630 lines
23 KiB
Bash
Executable file
630 lines
23 KiB
Bash
Executable file
#!/bin/bash
|
|
|
|
# rad-info.sh: Retrieve repository information for Radicle or centralized Git hosting.
|
|
# Complies with RIGOR principles: Reproducible, Interoperable, Generalizable, Open, Robust.
|
|
# Dependencies: git, rad (Radicle CLI). Optional: curl, jq (for centralized Git or JSON output).
|
|
# Version: 2.1.0
|
|
# License: GPLv3
|
|
|
|
# Default settings
|
|
REMOTE_NAME=""
|
|
OUTPUT_FORMAT="text"
|
|
DETAILED_MODE=false
|
|
ALL_REM=false
|
|
INTERACTIVE=false
|
|
FORCE_INIT=false
|
|
LOG_LEVEL="error" # error, warning, debug
|
|
LOG_DEST="stderr" # stderr, stdout, file:/path
|
|
CONFIG_FILE="${HOME}/.rad-info.rc"
|
|
PLUGIN_DIR="${HOME}/.rad-info/plugins"
|
|
TEMP_DIR=$(mktemp -d "/tmp/rad-info.XXXXXX")
|
|
RAD_TIMEOUT_SECONDS=10
|
|
RAD_RETRY_COUNT=3
|
|
GIT_CACHE=""
|
|
OUTPUT_GENERATED=false
|
|
|
|
# Centralized logging function
|
|
log_message() {
|
|
local level=$1 message=$2
|
|
local timestamp=$(date -u +"%Y-%m-%dT%H:%M:%S%z")
|
|
case $LOG_LEVEL in
|
|
error) [[ "$level" == "error" ]] || return 0 ;;
|
|
warning) [[ "$level" == "error" || "$level" == "warning" ]] || return 0 ;;
|
|
debug) ;;
|
|
*) return 1 ;;
|
|
esac
|
|
case $LOG_DEST in
|
|
file:*) echo "[$timestamp] $level: $message" >> "${LOG_DEST#file:}" ;;
|
|
stdout) echo "[$timestamp] $level: $message" ;;
|
|
*) echo "[$level] $message" >&2 >&3 ;;
|
|
esac
|
|
}
|
|
|
|
# Function to check for tools
|
|
check_tools() {
|
|
local tools=("$@")
|
|
for cmd in "${tools[@]}"; do
|
|
if ! command -v "$cmd" >/dev/null 2>&1; then
|
|
log_message "error" "$cmd is required but not installed"
|
|
return 1
|
|
fi
|
|
done
|
|
return 0
|
|
}
|
|
|
|
# Function to execute commands with timeout and retries
|
|
exec_command() {
|
|
local cmd=$1 retries=$2 stdout_file=$3 stderr_file=$4
|
|
local attempt=1 exit_code
|
|
while ((attempt <= retries)); do
|
|
if timeout $RAD_TIMEOUT_SECONDS $cmd 2>"$stderr_file" >"$stdout_file"; then
|
|
log_message "debug" "Command '$cmd' succeeded on attempt $attempt"
|
|
return 0
|
|
fi
|
|
exit_code=$?
|
|
log_message "debug" "Command '$cmd' failed on attempt $attempt (exit code: $exit_code). Retrying..."
|
|
((attempt++))
|
|
sleep 1
|
|
done
|
|
log_message "error" "Command '$cmd' failed after $retries attempts"
|
|
return 1
|
|
}
|
|
|
|
# Function to find Radicle remote
|
|
find_radicle_remote() {
|
|
if [ -z "$GIT_CACHE" ]; then
|
|
GIT_CACHE=$(git remote -v 2>/dev/null || echo "")
|
|
fi
|
|
local remote
|
|
remote=$(echo "$GIT_CACHE" | grep 'rad://' | awk '{print $1}' | sort -u | head -n1 || echo "")
|
|
log_message "debug" "Found Radicle remote: $remote"
|
|
echo "$remote"
|
|
}
|
|
|
|
# Function to check Radicle version
|
|
check_version() {
|
|
if ! check_tools rad; then
|
|
return 1
|
|
fi
|
|
local version
|
|
version=$(rad --version 2>/dev/null | awk '{print $2}' || echo "unknown")
|
|
log_message "debug" "Radicle CLI version: $version"
|
|
if [[ "$version" == "unknown" || ! "$version" =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
|
|
log_message "warning" "Could not determine Radicle CLI version. Some features may not work."
|
|
fi
|
|
echo "$version"
|
|
}
|
|
|
|
# Function to prompt for initialization
|
|
prompt_init() {
|
|
if [ "$INTERACTIVE" != "true" ] && [ "$FORCE_INIT" != "true" ]; then
|
|
log_message "warning" "Run with -i for interactive initialization or -f to force"
|
|
return 1
|
|
fi
|
|
local repo_name default_branch="main" visibility="public"
|
|
repo_name=$(basename "$PWD")
|
|
if [ "$INTERACTIVE" = "true" ]; then
|
|
read -p "Initialize Radicle repository? (y/n) [n]: " confirm
|
|
if [[ ! "$confirm" =~ ^[Yy]$ ]]; then return 1; fi
|
|
read -p "Repository name [$repo_name]: " name
|
|
repo_name=${name:-$repo_name}
|
|
read -p "Default branch [$default_branch]: " branch
|
|
default_branch=${branch:-$default_branch}
|
|
read -p "Visibility (public/private) [public]: " vis
|
|
visibility=${vis:-public}
|
|
fi
|
|
log_message "info" "Initializing Radicle repository: $repo_name"
|
|
if rad init --name "$repo_name" --default-branch "$default_branch" 2>"$TEMP_DIR/init_stderr"; then
|
|
if rad id update --payload xyz.radicle.project name "\"$repo_name\"" --visibility "$visibility" 2>"$TEMP_DIR/id_update_stderr"; then
|
|
log_message "info" "Updated repository metadata: $repo_name ($visibility)"
|
|
return 0
|
|
else
|
|
log_message "warning" "Failed to update repository metadata: $(cat "$TEMP_DIR/id_update_stderr")"
|
|
return 1
|
|
fi
|
|
else
|
|
log_message "error" "Failed to initialize Radicle repository: $(cat "$TEMP_DIR/init_stderr")"
|
|
return 1
|
|
fi
|
|
}
|
|
|
|
# Function to start Radicle node
|
|
start_node() {
|
|
if [ "$INTERACTIVE" != "true" ] && [ "$FORCE_INIT" != "true" ]; then
|
|
log_message "warning" "Radicle node not running. Run with -i or -f to start"
|
|
return 1
|
|
fi
|
|
if [ "$INTERACTIVE" = "true" ]; then
|
|
read -p "Start Radicle node? (y/n) [n]: " confirm
|
|
if [[ ! "$confirm" =~ ^[Yy]$ ]]; then return 1; fi
|
|
fi
|
|
log_message "info" "Starting Radicle node"
|
|
if rad node start 2>"$TEMP_DIR/node_start_stderr"; then
|
|
log_message "info" "Radicle node started"
|
|
return 0
|
|
else
|
|
log_message "error" "Failed to start Radicle node: $(cat "$TEMP_DIR/node_start_stderr")"
|
|
return 1
|
|
fi
|
|
}
|
|
|
|
# Function to display help
|
|
show_help() {
|
|
cat << EOF
|
|
rad-info.sh: Retrieve repository information for Radicle or centralized Git hosting.
|
|
Version: 2.1.0
|
|
License: GPLv3
|
|
|
|
Usage: $0 [options]
|
|
|
|
Options:
|
|
-h, --help Show this help message and exit
|
|
-r <remote> Specify remote name (default: auto-detect)
|
|
-j Output in JSON format
|
|
-d Detailed Radicle info (peers, issues, patches, etc.)
|
|
-i Interactive mode for initialization
|
|
-f Force initialization and node start
|
|
-a Summarize all remotes
|
|
-l <level> Log level or file (error, warning, debug, file:/path)
|
|
-v Verbose logging (debug level)
|
|
|
|
Configuration:
|
|
Config file: $CONFIG_FILE
|
|
Plugin directory: $PLUGIN_DIR
|
|
Log file (if -l file:/path): Specified path
|
|
|
|
Examples:
|
|
$0 Display repository info (text format)
|
|
$0 -j Output repository info in JSON
|
|
$0 -d Include detailed Radicle metadata
|
|
$0 -i Interactively initialize uninitialized Radicle repo
|
|
$0 -f Force Radicle initialization and node start
|
|
$0 -a List all remotes
|
|
$0 -l debug Enable debug logging
|
|
$0 -l file:/var/log/rad-info.log Log to file
|
|
|
|
Notes:
|
|
- Requires git and rad (Radicle CLI). Optional: curl, jq.
|
|
- Run 'rad node start' before using Radicle features.
|
|
- See https://radicle.xyz for Radicle documentation.
|
|
EOF
|
|
OUTPUT_GENERATED=true
|
|
}
|
|
|
|
# Parse command-line options
|
|
while getopts "r:jdihafl:v-:" opt; do
|
|
case "$opt" in
|
|
r) REMOTE_NAME="$OPTARG" ;;
|
|
j) OUTPUT_FORMAT="json" ;;
|
|
d) DETAILED_MODE="true" ;;
|
|
i) INTERACTIVE="true" ;;
|
|
f) FORCE_INIT="true" ;;
|
|
a) ALL_REM="true" ;;
|
|
l) LOG_LEVEL="$OPTARG" ;;
|
|
v) LOG_LEVEL="debug" ;;
|
|
h) show_help; exit 0 ;;
|
|
-) case "$OPTARG" in
|
|
help) show_help; exit 0 ;;
|
|
*) log_message "error" "Unknown option --$OPTARG"; show_help; exit 1 ;;
|
|
esac ;;
|
|
*) show_help; exit 1 ;;
|
|
esac
|
|
done
|
|
|
|
# Validate log level
|
|
if [[ "$LOG_LEVEL" != "error" && "$LOG_LEVEL" != "warning" && "$LOG_LEVEL" != "debug" && ! "$LOG_LEVEL" =~ ^file: ]]; then
|
|
log_message "error" "Invalid log level: $LOG_LEVEL. Use error, warning, debug, or file:/path"
|
|
show_help
|
|
exit 1
|
|
fi
|
|
|
|
# Redirect stderr to /dev/null for clean output, keep fd 3 for logging
|
|
exec 3>&2 2>/dev/null
|
|
|
|
# Load config file
|
|
if [ -f "$CONFIG_FILE" ]; then
|
|
log_message "debug" "Loading config from $CONFIG_FILE"
|
|
source "$CONFIG_FILE" || log_message "error" "Failed to load config file: $CONFIG_FILE"
|
|
fi
|
|
|
|
# Load plugins
|
|
if [ -d "$PLUGIN_DIR" ]; then
|
|
for plugin in "$PLUGIN_DIR"/*.sh; do
|
|
if [ -f "$plugin" ]; then
|
|
log_message "debug" "Loading plugin: $plugin"
|
|
if ! (source "$plugin" 2>"$TEMP_DIR/plugin_stderr"); then
|
|
log_message "warning" "Failed to load plugin $plugin: $(cat "$TEMP_DIR/plugin_stderr")"
|
|
fi
|
|
fi
|
|
done
|
|
fi
|
|
|
|
# Initialize variables
|
|
RID=""
|
|
NODE_ID=""
|
|
FULL_NAME=""
|
|
DEFAULT_BRANCH=""
|
|
CURRENT_BRANCH=""
|
|
CURRENT_COMMIT=""
|
|
REPO_STATUS=""
|
|
HOST=""
|
|
SEED_NODES=""
|
|
VISIBILITY=""
|
|
PEERS=""
|
|
ISSUES=""
|
|
PATCHES=""
|
|
OPEN_PATCHES=""
|
|
IDENTITY_REVISIONS=""
|
|
DELEGATES=""
|
|
SEED_STATUS=""
|
|
CONFIG_CACHE=""
|
|
|
|
# Function to get local Git details
|
|
get_local_git_details() {
|
|
if [ -z "$GIT_CACHE" ]; then
|
|
GIT_CACHE=$(git remote -v 2>/dev/null || echo "")
|
|
fi
|
|
CURRENT_BRANCH=$(git rev-parse --abbrev-ref HEAD 2>/dev/null || echo "N/A")
|
|
CURRENT_COMMIT=$(git rev-parse HEAD 2>/dev/null || echo "N/A")
|
|
local status_count
|
|
status_count=$(git status --porcelain 2>/dev/null | wc -l | xargs)
|
|
REPO_STATUS=$([ "$status_count" -eq 0 ] && echo "Clean" || echo "Dirty ($status_count uncommitted changes)")
|
|
DEFAULT_BRANCH=$(git symbolic-ref refs/remotes/origin/HEAD 2>/dev/null | sed 's@^refs/remotes/origin/@@' || echo "main")
|
|
log_message "debug" "Local Git details: branch=$CURRENT_BRANCH, commit=$CURRENT_COMMIT, status=$REPO_STATUS, default=$DEFAULT_BRANCH"
|
|
}
|
|
|
|
# Function to handle Radicle repositories
|
|
handle_radicle() {
|
|
if ! check_version >/dev/null; then
|
|
log_message "error" "Radicle CLI not available"
|
|
return 1
|
|
fi
|
|
|
|
# Check Radicle node status
|
|
local stdout_file="$TEMP_DIR/node_stdout" stderr_file="$TEMP_DIR/node_stderr"
|
|
if ! exec_command "rad node status" $RAD_RETRY_COUNT "$stdout_file" "$stderr_file"; then
|
|
log_message "error" "Radicle node is not running"
|
|
start_node && exec_command "rad node status" $RAD_RETRY_COUNT "$stdout_file" "$stderr_file"
|
|
if [ $? -ne 0 ]; then return 1; fi
|
|
fi
|
|
local node_status
|
|
node_status=$(cat "$stdout_file" 2>/dev/null || echo "")
|
|
log_message "debug" "Node status: $node_status"
|
|
local peer_count
|
|
peer_count=$(echo "$node_status" | grep -c 'connected' | xargs || echo "0")
|
|
if [ "$peer_count" -eq 0 ]; then
|
|
log_message "warning" "Radicle node is running but not connected to peers. Check seed node configuration."
|
|
fi
|
|
log_message "debug" "Connected peers: $peer_count"
|
|
|
|
# Get RID
|
|
stdout_file="$TEMP_DIR/inspect_stdout" stderr_file="$TEMP_DIR/inspect_stderr"
|
|
if ! exec_command "rad inspect" $RAD_RETRY_COUNT "$stdout_file" "$stderr_file"; then
|
|
log_message "warning" "Not a Radicle repository"
|
|
prompt_init && return handle_radicle
|
|
return 1
|
|
fi
|
|
RID=$(cat "$stdout_file" 2>/dev/null | grep -o 'rad:[^ ]*' || echo "")
|
|
if [ -z "$RID" ]; then
|
|
log_message "error" "Could not retrieve Radicle Repository ID (RID)"
|
|
prompt_init && return handle_radicle
|
|
return 1
|
|
fi
|
|
log_message "debug" "RID: $RID"
|
|
|
|
# Get Node ID
|
|
stdout_file="$TEMP_DIR/self_stdout" stderr_file="$TEMP_DIR/self_stderr"
|
|
exec_command "rad self" $RAD_RETRY_COUNT "$stdout_file" "$stderr_file" || true
|
|
NODE_ID=$(cat "$stdout_file" 2>/dev/null | grep 'Node ID (NID)' | awk '{print $NF}' || echo "N/A")
|
|
log_message "debug" "Node ID: $NODE_ID"
|
|
|
|
# Get repository metadata
|
|
stdout_file="$TEMP_DIR/payload_stdout" stderr_file="$TEMP_DIR/payload_stderr"
|
|
local payload_output
|
|
if exec_command "rad inspect --payload" $RAD_RETRY_COUNT "$stdout_file" "$stderr_file"; then
|
|
payload_output=$(cat "$stdout_file" 2>/dev/null || echo "")
|
|
log_message "debug" "rad inspect --payload output: $payload_output"
|
|
if check_tools jq; then
|
|
FULL_NAME=$(echo "$payload_output" | jq -r '.["xyz.radicle.project"].name // "N/A"' 2>/dev/null || echo "N/A")
|
|
VISIBILITY=$(echo "$payload_output" | jq -r '.visibility // "public"' 2>/dev/null || echo "public")
|
|
DEFAULT_BRANCH=$(echo "$payload_output" | jq -r '.["xyz.radicle.project"].defaultBranch // "'"$CURRENT_BRANCH"'"' 2>/dev/null || echo "$CURRENT_BRANCH")
|
|
DELEGATES=$(echo "$payload_output" | jq -r '.delegates | length' 2>/dev/null || echo "N/A")
|
|
else
|
|
log_message "warning" "jq not installed; falling back to directory name for metadata"
|
|
FULL_NAME=$(basename "$(git rev-parse --show-toplevel)" 2>/dev/null || echo "N/A")
|
|
VISIBILITY="public"
|
|
DEFAULT_BRANCH="$CURRENT_BRANCH"
|
|
DELEGATES="N/A"
|
|
fi
|
|
else
|
|
log_message "warning" "Repository not fully initialized"
|
|
prompt_init && return handle_radicle
|
|
FULL_NAME=$(basename "$(git rev-parse --show-toplevel)" 2>/dev/null || echo "N/A")
|
|
VISIBILITY="public"
|
|
DEFAULT_BRANCH="$CURRENT_BRANCH"
|
|
DELEGATES="N/A"
|
|
fi
|
|
[ "$FULL_NAME" = "N/A" ] && FULL_NAME=$(basename "$(git rev-parse --show-toplevel)" 2>/dev/null || echo "N/A")
|
|
log_message "debug" "Full Name: $FULL_NAME, Visibility: $VISIBILITY, Default Branch: $DEFAULT_BRANCH, Delegates: $DELEGATES"
|
|
|
|
# Get seed nodes
|
|
stdout_file="$TEMP_DIR/config_stdout" stderr_file="$TEMP_DIR/config_stderr"
|
|
if [ -z "$CONFIG_CACHE" ]; then
|
|
if exec_command "rad config" $RAD_RETRY_COUNT "$stdout_file" "$stderr_file"; then
|
|
CONFIG_CACHE=$(cat "$stdout_file" 2>/dev/null || echo "")
|
|
log_message "debug" "rad config output: $CONFIG_CACHE"
|
|
else
|
|
CONFIG_CACHE=""
|
|
log_message "warning" "Failed to parse rad config for seed nodes"
|
|
fi
|
|
fi
|
|
if [ -n "$CONFIG_CACHE" ] && echo "$CONFIG_CACHE" | grep -q '{'; then
|
|
if check_tools jq; then
|
|
SEED_NODES=$(echo "$CONFIG_CACHE" | jq -r '.preferredSeeds[]' 2>/dev/null | paste -sd, - || echo "N/A")
|
|
SEED_STATUS=$(echo "$node_status" | grep -oE '[^ ]+@[^ ]+:8776.*connected' | sed 's/.*\(@.*connected\)/\1/' | paste -sd, - || echo "N/A")
|
|
else
|
|
SEED_NODES=$(echo "$CONFIG_CACHE" | grep -oE '[^ ]+@[^ ]+:8776' | paste -sd, - || echo "N/A")
|
|
SEED_STATUS="N/A"
|
|
log_message "warning" "jq not installed; using fallback for seed nodes"
|
|
fi
|
|
else
|
|
SEED_NODES=""
|
|
SEED_STATUS=""
|
|
fi
|
|
log_message "info" "Seed Nodes: $SEED_NODES, Status: $SEED_STATUS"
|
|
|
|
# Detailed mode
|
|
if [ "$DETAILED_MODE" = "true" ]; then
|
|
PEERS=$(rad peer ls 2>/dev/null | wc -l | xargs || echo "N/A")
|
|
ISSUES=$(rad issue ls 2>/dev/null | wc -l | xargs || echo "N/A")
|
|
PATCHES=$(rad patch ls --all 2>/dev/null | wc -l | xargs || echo "N/A")
|
|
OPEN_PATCHES=$(rad patch ls --open 2>/dev/null | wc -l | xargs || echo "N/A")
|
|
IDENTITY_REVISIONS=$(rad id list 2>/dev/null | grep -c 'accepted' || echo "N/A")
|
|
log_message "debug" "Peers: $PEERS, Issues: $ISSUES, Patches: $PATCHES, Open Patches: $OPEN_PATCHES, Identity Revisions: $IDENTITY_REVISIONS"
|
|
fi
|
|
|
|
HOST="radicle"
|
|
get_local_git_details
|
|
return 0
|
|
}
|
|
|
|
# Function to handle centralized Git
|
|
handle_centralized() {
|
|
local remote_url=$1
|
|
if [[ "$remote_url" =~ ^rad:// ]]; then
|
|
log_message "error" "Radicle URL ($remote_url) cannot be processed as centralized Git"
|
|
return 1
|
|
fi
|
|
local parsed_url="$remote_url"
|
|
if [[ "$remote_url" =~ ^git@ ]]; then
|
|
parsed_url=$(echo "$remote_url" | sed -E 's/git@([^:]+):(.+)\.git/https:\/\/\1\/\2/')
|
|
fi
|
|
|
|
if [[ "$parsed_url" =~ https?://([^/]+)/(.*) ]]; then
|
|
HOST="${BASH_REMATCH[1]}"
|
|
FULL_NAME=$(echo "${BASH_REMATCH[2]}" | sed 's/\.git$//')
|
|
else
|
|
log_message "error" "Invalid remote URL: $remote_url. Expected format: https://host/path"
|
|
return 1
|
|
fi
|
|
log_message "Centralized Git: Host=$HOST, Age=$FULL_NAME"
|
|
|
|
# API-based metadata
|
|
if check_tools curl jq; then
|
|
local api_url=""
|
|
local curl_opts=(--silent --fail)
|
|
[ -n "$GITHUB_TOKEN" ] && [ "$HOST" = "github.com" ] && curl_opts+=(--header "Authorization: token $GITHUB_TOKEN")
|
|
case "$HOST in
|
|
github.com) api_url="https://api.github.com/repos/$FULL_NAME" ;;
|
|
gitlab.com) api_url="https://gitlab.com/api/v4/projects/$(echo -n "$FULL_NAME" | xxd -p | tr -d '\n')" ;;
|
|
bitbucket.org) api_url="https://api.bitbucket.org/2.0/repositories/$FULL_NAME" ;;
|
|
*) log_message "debug" "No API support for host: $HOST" ;;
|
|
esac
|
|
if [ -n "$api_url" ]; then
|
|
local stdout_file="$TEMP_DIR/api_stdout" stderr_file="$TEMP_DIR/api_stderr"
|
|
if exec_command "curl ${curl_opts[*]}" '$api_url'" $RAD_TIMEOUT_COUNT "$stdout_file" "$stderr_file"; then
|
|
local repo_details
|
|
repo_details=$(cat "$stdout_file" 2>/dev/null || echo "")
|
|
log_message "debug" "API response: $repo_details"
|
|
FULL_NAME=$(echo "$repo_details" | jq -r '.full_name // .path_with_namespace // "$FULL_NAME"' 2>/dev/null || echo "$FULL_NAME")
|
|
DEFAULT_BRANCH=$(echo "$repo_details" | jq -r '.default_branch // .mainbranch.name // "main"' 2>/dev/null || echo "main")
|
|
else
|
|
log_message "warning" "Failed to fetch API metadata for $HOST"
|
|
fi
|
|
fi
|
|
else
|
|
log_message "warning" "curl or jq not installed; skipping API metadata"
|
|
fi
|
|
fi
|
|
|
|
get_local_git_details()
|
|
return 0
|
|
}
|
|
|
|
# Function to summarize all remotes
|
|
summarize_all() {
|
|
if [ -z "$GIT_CACHE" ]; then
|
|
GIT_CACHE=$(git remote -v 2>/dev/null || echo "")
|
|
fi
|
|
local remotes
|
|
mapfile -t remotes < <(echo "$GIT_CACHE" | awk '{print $1}' | sort -u || echo "")
|
|
REMOTES=()
|
|
for remote in "${remotes[@]}"; do
|
|
local url=$(echo "$GIT_CACHE" | grep "^$remote\s" | awk '{print $2}' | head -n1 || echo "")
|
|
local type="centralized"
|
|
[[ "$url" =~ ^rad:// ]] && type="radicle"
|
|
REMOTES+=("$remote: $type ($url)")
|
|
log_message "debug" "Remote: $remote, Type: $type, URL: $url"
|
|
done
|
|
}
|
|
|
|
# Function to output repository information
|
|
output_info() {
|
|
if [ "$OUTPUT_FORMAT" = "json" ]; then
|
|
if ! check_tools jq; then
|
|
log_message "error" "jq is required for JSON output. Falling back to text."
|
|
OUTPUT_FORMAT="text"
|
|
else
|
|
jq -n --arg host "$HOST" \
|
|
--arg full_name "$FULL_NAME" \
|
|
--arg rid "$RID" \
|
|
--arg node_id node_id "$NODE_ID" \
|
|
--arg default_branch "$DEFAULT_BRANCH" \
|
|
--arg current_branch "$CURRENT_BRANCH" \
|
|
--arg current_commit "$CURRENT_COMMIT" \
|
|
--arg repo_status "$REPO_STATUS" \
|
|
--arg seed_nodes "$SEED_NODES" \
|
|
--arg seed_status "$SEED_STATUS" \
|
|
--arg visibility "$VISIBILITY" \
|
|
--arg peers "$PEERS" \
|
|
--arg issues "$ISSUES" \
|
|
--arg patches "$PATCHES" \
|
|
--arg open_patches "$OPEN_PATCHES" \
|
|
--arg identity_revisions "$IDENTITY_REVISIONS" \
|
|
--arg delegates "$DELEGATES" \
|
|
--argjson remotes "$(printf '%s\n' "${REMOTES[@]}" | jq -R . | jq -s .)" \
|
|
'{
|
|
hosting_service: $host,
|
|
full_name: $full_name,
|
|
repo_id: $rid,
|
|
node_id: $node_id,
|
|
default_branch: $default_branch,
|
|
current_branch: $current_branch,
|
|
current_commit: $current_commit,
|
|
repo_status: $repo_status,
|
|
seed_nodes: $seed_nodes,
|
|
seed_status: $seed_status,
|
|
visibility: $visibility,
|
|
peers: $peers,
|
|
issues: $issues,
|
|
patches: $patches,
|
|
open_patches: $open_patches,
|
|
identity_revisions: $identity_revisions,
|
|
delegates: $delegates,
|
|
remotes: $remotes
|
|
}'
|
|
OUTPUT_GENERATED=true
|
|
return 0
|
|
fi
|
|
fi
|
|
|
|
if [ "$OUTPUT_FORMAT" = "text" ]; then
|
|
echo
|
|
echo "Repository Information:"
|
|
echo "----------------------"
|
|
echo "Hosting Service: ${HOST:-N/A}"
|
|
echo "Full Name: ${FULL_NAME:-N/A}"
|
|
echo "Repository ID: ${RID:-N/A}"
|
|
echo "Node ID: ${NODE_ID:-N/A}"
|
|
echo "Default Branch: ${DEFAULT_BRANCH:-N/A}"
|
|
echo "Current Branch: ${CURRENT_BRANCH:-N/A}"
|
|
echo "Current Commit: ${CURRENT_COMMIT:-N/A}"
|
|
echo "Repository Status: ${REPO_STATUS:-N/A}"
|
|
[ -n "$SEED_NODES" ] && [ "$SEED_NODES" != "N/A" ] && echo "Seed Nodes: $SEED_NODES"
|
|
[ -n "$SEED_STATUS" ] && [ "$SEED_STATUS" != "N/A" ] && echo "Seed Status: $SEED_STATUS"
|
|
[ -n "$VISIBILITY" ] && [ "$VISIBILITY" != "N/A" ] && echo "Visibility: $VISIBILITY"
|
|
if [ "$DETAILED_MODE" = "true" ]; then
|
|
[ -n "$PEERS" ] && [ "$PEERS" != "N/A" ] && echo "Peers: $PEERS"
|
|
[ -n "$ISSUES" ] && [ "$ISSUES" != "N/A" ] && echo "Issues: $ISSUES"
|
|
[ -n "$PATCHES" ] && [ "$PATCHES" != "N/A" ] && echo "Total Patches: $PATCHES"
|
|
[ -n "$OPEN_PATCHES" ] && [ "$OPEN_PATCHES" != "N/A" ] && echo "Open Patches: $OPEN_PATCHES"
|
|
[ -n "$IDENTITY_REVISIONS" ] && [ "$IDENTITY_REVISIONS" != "N/A" ] && echo "Accepted Identity Revisions: $IDENTITY_REVISIONS"
|
|
[ -n "$DELEGATES" ] && [ "$DELEGATES" != "N/A" ] && echo "Delegates: $DELEGATES"
|
|
fi
|
|
if [ "$ALL_REM" = "true" ]; then
|
|
echo "Remotes:"
|
|
for remote in "${REMOTES[@]}"; do
|
|
echo " $remote"
|
|
done
|
|
fi
|
|
echo "----------------------"
|
|
if [ "$HOST" = "radicle" ]; then
|
|
echo "Clone Command: rad clone ${RID:-<repository-id>}"
|
|
echo "Sync Command: rad sync"
|
|
echo "Note: Ensure Radicle node is running ('rad node start') and configured with seed nodes."
|
|
echo "See 'rad help' for more commands and https://radicle.xyz for documentation."
|
|
else
|
|
echo "Clone Command: git clone ${REMOTE_URL:-<remote-url>}"
|
|
echo "Sync Command: git fetch ${REMOTE_NAME:-origin} && git pull ${REMOTE_NAME:-origin} ${DEFAULT_BRANCH:-main}"
|
|
fi
|
|
OUTPUT_GENERATED=true
|
|
return 0
|
|
fi
|
|
}
|
|
|
|
# Main logic
|
|
if ! git rev-parse --is-inside-work-tree >/dev/null; then
|
|
log_message "error" "Not inside a Git repository"
|
|
show_help
|
|
rm -rf "$TEMP_DIR"
|
|
exit 1
|
|
fi
|
|
|
|
if ! check_tools git; then
|
|
show_help
|
|
rm -rf "$TEMP_DIR"
|
|
exit 1
|
|
fi
|
|
|
|
if [ "$ALL_REM" = "true" ]; then
|
|
summarize_all
|
|
elif [ -z "$REMOTE_NAME" ]; then
|
|
REMOTE_NAME=$(find_radicle_remote)
|
|
if [ -z "$REMOTE_NAME" ] && rad inspect >/dev/null 2>&1; then
|
|
REMOTE_NAME="rad"
|
|
fi
|
|
fi
|
|
|
|
if [ -n "$REMOTE_NAME" ]; then
|
|
REMOTE_URL=$(git remote get-url "$REMOTE_NAME" 2>/dev/null || echo "")
|
|
log_message "debug" "Processing remote: $REMOTE_NAME ($REMOTE_URL)"
|
|
if [[ "$REMOTE_URL" =~ ^rad:// ]] || rad inspect >/dev/null 2>&1; then
|
|
handle_radicle || {
|
|
log_message "warning" "Failed to process Radicle repository. Falling back to Git details."
|
|
get_local_git_details
|
|
FULL_NAME=$(basename "$(git rev-parse --show-toplevel)" 2>/dev/null || echo "N/A")
|
|
VISIBILITY="public"
|
|
HOST="radicle"
|
|
DEFAULT_BRANCH="$CURRENT_BRANCH"
|
|
}
|
|
else
|
|
handle_centralized "$REMOTE_URL" || {
|
|
log_message "warning" "Failed to process centralized Git repository."
|
|
get_local_git_details
|
|
FULL_NAME=$(basename "$(git rev-parse --show-toplevel)" 2>/dev/null || echo "N/A")
|
|
HOST="unknown"
|
|
}
|
|
fi
|
|
else
|
|
log_message "warning" "No Radicle remote found. Processing as centralized Git."
|
|
REMOTE_NAME="origin"
|
|
REMOTE_URL=$(git remote get-url "$REMOTE_NAME" 2>/dev/null || echo "")
|
|
if [ -z "$REMOTE_URL" ]; then
|
|
log_message "error" "No remote URL found"
|
|
get_local_git_details
|
|
FULL_NAME=$(basename "$(git rev-parse --show-toplevel)" 2>/dev/null || echo "N/A")
|
|
HOST="unknown"
|
|
else
|
|
handle_centralized "$REMOTE_URL" || {
|
|
log_message "warning" "Failed to process centralized Git repository."
|
|
get_local_git_details
|
|
FULL_NAME=$(basename "$(git rev-parse --show-toplevel)" 2>/dev/null || echo "N/A")
|
|
HOST="unknown"
|
|
}
|
|
fi
|
|
fi
|
|
|
|
# Ensure output
|
|
output_info || {
|
|
log_message "error" "Failed to generate output"
|
|
show_help
|
|
}
|
|
|
|
if [ "$OUTPUT_GENERATED" = "false" ]; then
|
|
log_message "error" "No output generated"
|
|
show_help
|
|
fi
|
|
|
|
# Clean up
|
|
rm -rf "$TEMP_DIR"
|
|
exit 0
|