claude-flow-novice 2.14.13 → 2.14.15

package/claude-assets/skills/hook-pipeline/rust-dependency-checker.sh

@@ -1,50 +0,0 @@
-#!/bin/bash
-# Rust Dependency Checker
-set -o pipefail
-
-# Exit codes:
-# 0 - No issues found
-# 1 - Cargo.toml not found or cannot be read
-# 2 - Dependency warnings found
-
-if [ $# -eq 0 ]; then
-    echo "Usage: $0 <rust_file>"
-    exit 1
-fi
-
-file_path="$1"
-project_dir=$(dirname "$file_path")
-cargo_toml="${project_dir}/Cargo.toml"
-
-if [ ! -f "$cargo_toml" ]; then
-    echo "Cargo.toml not found in project directory"
-    exit 1
-fi
-
-# Skip list for built-in/standard libraries
-skip_modules="std|core|alloc|proc_macro"
-
-# Find local crate dependencies in the file
-local_deps=$(grep -o "use crate::[a-zA-Z_][a-zA-Z0-9_:]*" "$file_path" |
-    sed 's/use crate:://g' |
-    cut -d':' -f1 |
-    sort -u |
-    grep -vE "^(${skip_modules})$")
-
-# Check dependencies in Cargo.toml
-if [ -n "$local_deps" ]; then
-    warnings=$(echo "$local_deps" | while read -r dep; do
-        if ! grep -q "path = \".*${dep}\"" "$cargo_toml"; then
-            echo "Undeclared local crate dependency: ${dep}"
-        fi
-    done)
-
-    if [ -n "$warnings" ]; then
-        echo "Dependency warnings:"
-        echo "$warnings"
-        echo "Recommendation: Declare local crate dependencies in Cargo.toml"
-        exit 2
-    fi
-fi
-
-exit 0

package/claude-assets/skills/hook-pipeline/rust-future-safety.sh

@@ -1,50 +0,0 @@
-#!/bin/bash
-# Rust Future Safety Validator
-set -o pipefail
-
-# Exit codes:
-# 0 - No issues found
-# 1 - File not found or cannot be read
-# 2 - Future safety warnings found
-
-if [ $# -eq 0 ]; then
-    echo "Usage: $0 <rust_file>"
-    exit 1
-fi
-
-file_path="$1"
-
-if [ ! -f "$file_path" ]; then
-    echo "File not found: $file_path"
-    exit 1
-fi
-
-# Find async function definitions
-async_functions=$(grep -n "async fn" "$file_path")
-
-if [ -n "$async_functions" ]; then
-    warnings=$(echo "$async_functions" | while read -r async_line; do
-        line_num=$(echo "$async_line" | cut -d':' -f1)
-        func_name=$(echo "$async_line" | sed -n 's/.*async fn \([a-zA-Z_][a-zA-Z0-9_]*\).*/\1/p')
-
-        # Search for function calls without .await
-        calls_without_await=$(grep -n "\\b${func_name}(" "$file_path" |
-            grep -v ".await" |
-            grep -v "async fn" |
-            grep -v "fn ${func_name}")
-
-        if [ -n "$calls_without_await" ]; then
-            echo "Lines related to async function '${func_name}':"
-            echo "$calls_without_await"
-            echo "Recommendation: Use .await for async function calls. Run cargo clippy for more details."
-        fi
-    done)
-
-    if [ -n "$warnings" ]; then
-        echo "Future safety warnings:"
-        echo "$warnings"
-        exit 2
-    fi
-fi
-
-exit 0

package/claude-assets/skills/pre-edit-backup/backup.sh

@@ -1,130 +0,0 @@
-#!/bin/bash
-
-# Pre-Edit Backup Script
-# Creates timestamped backup with SHA-256 hash and JSON metadata
-#
-# Usage: backup.sh FILE_PATH AGENT_ID
-#
-# Arguments:
-#   FILE_PATH  - Absolute path to file to backup
-#   AGENT_ID   - Unique identifier for the agent creating the backup
-#
-# Returns:
-#   Backup directory path on success
-#   Exit code 1 on failure
-#
-# Example:
-#   ./.claude/skills/pre-edit-backup/backup.sh "/path/to/file.txt" "backend-dev-1"
-
-set -euo pipefail
-
-# === Input Validation ===
-
-FILE_PATH="$1"
-AGENT_ID="$2"
-
-if [[ -z "$FILE_PATH" ]]; then
-    echo "Error: No file path provided" >&2
-    echo "Usage: backup.sh FILE_PATH AGENT_ID" >&2
-    exit 1
-fi
-
-if [[ -z "$AGENT_ID" ]]; then
-    echo "Error: No agent ID provided" >&2
-    echo "Usage: backup.sh FILE_PATH AGENT_ID" >&2
-    exit 1
-fi
-
-if [[ ! -f "$FILE_PATH" ]]; then
-    echo "Error: File does not exist: $FILE_PATH" >&2
-    exit 1
-fi
-
-# === Configuration ===
-
-BACKUP_BASE_DIR=".backups"
-DEFAULT_TTL=86400  # 24 hours in seconds
-
-# === Tool Availability Checks ===
-
-# Check for sha256sum (with fallback to shasum on macOS)
-if command -v sha256sum &>/dev/null; then
-    HASH_TOOL="sha256sum"
-elif command -v shasum &>/dev/null; then
-    HASH_TOOL="shasum -a 256"
-else
-    echo "Error: Neither sha256sum nor shasum found. Cannot generate file hash." >&2
-    exit 1
-fi
-
-# Check for jq (graceful degradation)
-if ! command -v jq &>/dev/null; then
-    echo "Warning: jq not found. Metadata will be created using basic shell." >&2
-    USE_JQ=false
-else
-    USE_JQ=true
-fi
-
-# === Generate Backup Metadata ===
-
-TIMESTAMP=$(date +%s%3N 2>/dev/null || date +%s)  # Milliseconds if supported, else seconds
-FILE_HASH=$($HASH_TOOL "$FILE_PATH" | cut -d' ' -f1)
-
-# === Create Backup Directory ===
-
-BACKUP_DIR="${BACKUP_BASE_DIR}/${AGENT_ID}/${TIMESTAMP}_${FILE_HASH}"
-
-if ! mkdir -p "$BACKUP_DIR" 2>/dev/null; then
-    echo "Error: Failed to create backup directory: $BACKUP_DIR" >&2
-    exit 1
-fi
-
-# Set secure permissions (owner read/write/execute only)
-chmod 700 "$BACKUP_DIR" 2>/dev/null || true
-
-# === Copy Original File ===
-
-if ! cp "$FILE_PATH" "${BACKUP_DIR}/original_file" 2>/dev/null; then
-    echo "Error: Failed to copy file to backup directory" >&2
-    rm -rf "$BACKUP_DIR"
-    exit 1
-fi
-
-# === Generate Metadata ===
-
-METADATA_FILE="${BACKUP_DIR}/backup_metadata.json"
-
-if [[ "$USE_JQ" == true ]]; then
-    # Use jq for structured JSON generation
-    jq -n \
-        --arg agent_id "$AGENT_ID" \
-        --arg original_path "$FILE_PATH" \
-        --arg timestamp "$TIMESTAMP" \
-        --arg file_hash "$FILE_HASH" \
-        --arg ttl "$DEFAULT_TTL" \
-        '{
-            agent_id: $agent_id,
-            original_path: $original_path,
-            backup_timestamp: ($timestamp | tonumber),
-            file_hash: $file_hash,
-            backup_ttl: ($ttl | tonumber),
-            backup_status: "active"
-        }' > "$METADATA_FILE"
-else
-    # Fallback: Manual JSON generation
-    cat > "$METADATA_FILE" <<EOF
-{
-    "agent_id": "$AGENT_ID",
-    "original_path": "$FILE_PATH",
-    "backup_timestamp": $TIMESTAMP,
-    "file_hash": "$FILE_HASH",
-    "backup_ttl": $DEFAULT_TTL,
-    "backup_status": "active"
-}
-EOF
-fi
-
-# === Return Backup Path ===
-
-echo "$BACKUP_DIR"
-exit 0

package/claude-assets/skills/pre-edit-backup/cleanup.sh

@@ -1,155 +0,0 @@
-#!/bin/bash
-
-# Pre-Edit Backup Cleanup Script
-# Removes expired backups based on TTL configuration
-# Runs as background process or cron-style with flock for concurrency control
-#
-# Usage: cleanup.sh [--dry-run] [--log-file FILE]
-#
-# Options:
-#   --dry-run    - Show what would be deleted without actually deleting
-#   --log-file   - Path to log file (default: none, outputs to stdout)
-#
-# Returns:
-#   Exit code 0 on success
-#   Exit code 1 if cleanup already in progress
-#
-# Example:
-#   ./.claude/skills/pre-edit-backup/cleanup.sh
-#   ./.claude/skills/pre-edit-backup/cleanup.sh --dry-run
-#   ./.claude/skills/pre-edit-backup/cleanup.sh --log-file /tmp/backup-cleanup.log
-
-set -euo pipefail
-
-# === Configuration ===
-
-BACKUP_BASE_DIR=".backups"
-CURRENT_TIME=$(date +%s)
-DRY_RUN=false
-LOG_FILE=""
-
-# === Parse Options ===
-
-while [[ "$#" -gt 0 ]]; do
-    case $1 in
-        --dry-run)
-            DRY_RUN=true
-            shift
-            ;;
-        --log-file)
-            LOG_FILE="$2"
-            shift 2
-            ;;
-        *)
-            echo "Error: Unknown option: $1" >&2
-            echo "Usage: cleanup.sh [--dry-run] [--log-file FILE]" >&2
-            exit 1
-            ;;
-    esac
-done
-
-# === Logging Function ===
-
-log() {
-    local message="$1"
-    local timestamp=$(date '+%Y-%m-%d %H:%M:%S')
-    local log_line="[$timestamp] $message"
-
-    if [[ -n "$LOG_FILE" ]]; then
-        echo "$log_line" >> "$LOG_FILE"
-    else
-        echo "$log_line"
-    fi
-}
-
-# === Prevent Concurrent Cleanup ===
-
-if [[ ! -d "$BACKUP_BASE_DIR" ]]; then
-    log "Backup directory does not exist: $BACKUP_BASE_DIR"
-    exit 0
-fi
-
-LOCKFILE="${BACKUP_BASE_DIR}/cleanup.lock"
-
-# Ensure lock file directory exists
-mkdir -p "$(dirname "$LOCKFILE")" 2>/dev/null || true
-
-# Acquire lock (non-blocking)
-exec 9>"$LOCKFILE"
-if ! flock -n 9; then
-    log "Cleanup already in progress (lock held)"
-    exit 1
-fi
-
-log "Cleanup started (dry-run: $DRY_RUN)"
-
-# === Cleanup Logic ===
-
-REMOVED_COUNT=0
-SKIPPED_COUNT=0
-ERROR_COUNT=0
-
-# Check for jq availability
-if ! command -v jq &>/dev/null; then
-    log "Error: jq is required for cleanup operations"
-    exit 1
-fi
-
-# Iterate through agent directories
-for agent_dir in "$BACKUP_BASE_DIR"/*; do
-    # Skip if not a directory or if it's the lockfile
-    [[ -d "$agent_dir" ]] || continue
-    [[ "$(basename "$agent_dir")" == "cleanup.lock" ]] && continue
-
-    # Iterate through backup directories for this agent
-    for backup_dir in "$agent_dir"/*; do
-        [[ -d "$backup_dir" ]] || continue
-
-        metadata_file="${backup_dir}/backup_metadata.json"
-
-        if [[ ! -f "$metadata_file" ]]; then
-            log "Warning: Metadata missing for backup: ${backup_dir}"
-            SKIPPED_COUNT=$((SKIPPED_COUNT + 1))
-            continue
-        fi
-
-        # Extract backup timestamp and TTL
-        backup_timestamp=$(jq -r '.backup_timestamp' "$metadata_file" 2>/dev/null || echo "")
-        backup_ttl=$(jq -r '.backup_ttl' "$metadata_file" 2>/dev/null || echo "")
-
-        if [[ -z "$backup_timestamp" ]] || [[ "$backup_timestamp" == "null" ]] || \
-           [[ -z "$backup_ttl" ]] || [[ "$backup_ttl" == "null" ]]; then
-            log "Warning: Invalid metadata in: ${metadata_file}"
-            SKIPPED_COUNT=$((SKIPPED_COUNT + 1))
-            continue
-        fi
-
-        # Convert milliseconds to seconds if needed (timestamp > 10 digits = milliseconds)
-        if [[ ${#backup_timestamp} -gt 10 ]]; then
-            backup_timestamp=$((backup_timestamp / 1000))
-        fi
-
-        # Check if backup has expired
-        age=$((CURRENT_TIME - backup_timestamp))
-        if (( age > backup_ttl )); then
-            if [[ "$DRY_RUN" == true ]]; then
-                log "Would remove expired backup (age: ${age}s, ttl: ${backup_ttl}s): ${backup_dir}"
-                REMOVED_COUNT=$((REMOVED_COUNT + 1))
-            else
-                if rm -rf "$backup_dir" 2>/dev/null; then
-                    log "Removed expired backup (age: ${age}s, ttl: ${backup_ttl}s): ${backup_dir}"
-                    REMOVED_COUNT=$((REMOVED_COUNT + 1))
-                else
-                    log "Error: Failed to remove backup: ${backup_dir}"
-                    ERROR_COUNT=$((ERROR_COUNT + 1))
-                fi
-            fi
-        fi
-    done
-done
-
-# === Summary ===
-
-log "Cleanup completed: removed=$REMOVED_COUNT, skipped=$SKIPPED_COUNT, errors=$ERROR_COUNT"
-
-exit 0

package/claude-assets/skills/pre-edit-backup/restore.sh

@@ -1,128 +0,0 @@
-#!/bin/bash
-
-# Pre-Edit Restore Script
-# Restores file from backup and updates metadata
-#
-# Usage: restore.sh BACKUP_DIR [--list FILE_PATH AGENT_ID]
-#
-# Arguments:
-#   BACKUP_DIR  - Path to backup directory containing backup_metadata.json
-#   --list      - List available backups for a file (requires FILE_PATH and AGENT_ID)
-#
-# Returns:
-#   Exit code 0 on success
-#   Exit code 1 on failure
-#
-# Example:
-#   ./.claude/skills/pre-edit-backup/restore.sh ".backups/backend-dev-1/1698764800000_abc123"
-#   ./.claude/skills/pre-edit-backup/restore.sh --list "/path/to/file.txt" "backend-dev-1"
-
-set -euo pipefail
-
-# === Handle --list Mode ===
-
-if [[ "${1:-}" == "--list" ]]; then
-    FILE_PATH="$2"
-    AGENT_ID="$3"
-
-    if [[ -z "$FILE_PATH" ]] || [[ -z "$AGENT_ID" ]]; then
-        echo "Error: --list requires FILE_PATH and AGENT_ID" >&2
-        exit 1
-    fi
-
-    BACKUP_BASE_DIR=".backups"
-    AGENT_BACKUP_DIR="${BACKUP_BASE_DIR}/${AGENT_ID}"
-
-    if [[ ! -d "$AGENT_BACKUP_DIR" ]]; then
-        echo "No backups found for agent: $AGENT_ID" >&2
-        exit 1
-    fi
-
-    echo "Available backups for $FILE_PATH (agent: $AGENT_ID):"
-    echo "---"
-
-    FOUND_BACKUPS=0
-    for backup_dir in "$AGENT_BACKUP_DIR"/*; do
-        if [[ -f "${backup_dir}/backup_metadata.json" ]]; then
-            ORIGINAL=$(jq -r '.original_path' "${backup_dir}/backup_metadata.json" 2>/dev/null || echo "")
-            if [[ "$ORIGINAL" == "$FILE_PATH" ]]; then
-                TIMESTAMP=$(jq -r '.backup_timestamp' "${backup_dir}/backup_metadata.json" 2>/dev/null || echo "unknown")
-                STATUS=$(jq -r '.backup_status' "${backup_dir}/backup_metadata.json" 2>/dev/null || echo "unknown")
-                echo "Backup: $(basename "$backup_dir")"
-                echo "  Timestamp: $TIMESTAMP"
-                echo "  Status: $STATUS"
-                echo "  Path: $backup_dir"
-                echo "---"
-                FOUND_BACKUPS=$((FOUND_BACKUPS + 1))
-            fi
-        fi
-    done
-
-    if [[ $FOUND_BACKUPS -eq 0 ]]; then
-        echo "No backups found for this file."
-        exit 1
-    fi
-
-    exit 0
-fi
-
-# === Restore Mode ===
-
-BACKUP_DIR="$1"
-
-if [[ -z "$BACKUP_DIR" ]]; then
-    echo "Error: No backup directory provided" >&2
-    echo "Usage: restore.sh BACKUP_DIR" >&2
-    exit 1
-fi
-
-if [[ ! -d "$BACKUP_DIR" ]]; then
-    echo "Error: Backup directory does not exist: $BACKUP_DIR" >&2
-    exit 1
-fi
-
-METADATA_FILE="${BACKUP_DIR}/backup_metadata.json"
-BACKUP_FILE="${BACKUP_DIR}/original_file"
-
-if [[ ! -f "$METADATA_FILE" ]]; then
-    echo "Error: Backup metadata not found: $METADATA_FILE" >&2
-    exit 1
-fi
-
-if [[ ! -f "$BACKUP_FILE" ]]; then
-    echo "Error: Backup file not found: $BACKUP_FILE" >&2
-    exit 1
-fi
-
-# Check for jq availability
-if ! command -v jq &>/dev/null; then
-    echo "Error: jq is required for restore operations" >&2
-    exit 1
-fi
-
-# Extract original path
-ORIGINAL_PATH=$(jq -r '.original_path' "$METADATA_FILE" 2>/dev/null)
-
-if [[ -z "$ORIGINAL_PATH" ]] || [[ "$ORIGINAL_PATH" == "null" ]]; then
-    echo "Error: Failed to read original path from metadata" >&2
-    exit 1
-fi
-
-# Restore file
-if ! cp "$BACKUP_FILE" "$ORIGINAL_PATH" 2>/dev/null; then
-    echo "Error: Failed to restore file to: $ORIGINAL_PATH" >&2
-    exit 1
-fi
-
-# Update backup status
-TEMP_FILE=$(mktemp)
-if jq '.backup_status = "restored"' "$METADATA_FILE" > "$TEMP_FILE" 2>/dev/null; then
-    mv "$TEMP_FILE" "$METADATA_FILE"
-else
-    echo "Warning: Failed to update backup status in metadata" >&2
-    rm -f "$TEMP_FILE"
-fi
-
-echo "File restored from backup: ${BACKUP_DIR}"
-echo "Restored to: ${ORIGINAL_PATH}"
-exit 0

package/claude-assets/skills/pre-edit-backup/revert-file.sh

@@ -1,168 +0,0 @@
-#!/bin/bash
-#
-# Revert File Utility
-# High-level revert interface for agents to use instead of git operations
-#
-# Usage:
-#   ./.claude/skills/pre-edit-backup/revert-file.sh <file_path> [--agent-id <id>] [--interactive]
-#
-# Examples:
-#   # Revert to most recent backup (auto-select)
-#   ./.claude/skills/pre-edit-backup/revert-file.sh src/file.ts --agent-id "coder-1"
-#
-#   # Interactive mode (shows list of backups)
-#   ./.claude/skills/pre-edit-backup/revert-file.sh src/file.ts --agent-id "coder-1" --interactive
-#
-#   # List available backups without reverting
-#   ./.claude/skills/pre-edit-backup/revert-file.sh src/file.ts --agent-id "coder-1" --list-only
-
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-BACKUP_BASE_DIR=".backups"
-
-# Parse arguments
-FILE_PATH=""
-AGENT_ID="${AGENT_ID:-unknown}"
-INTERACTIVE=false
-LIST_ONLY=false
-
-while [[ $# -gt 0 ]]; do
-    case $1 in
-        --agent-id)
-            AGENT_ID="$2"
-            shift 2
-            ;;
-        --interactive)
-            INTERACTIVE=true
-            shift
-            ;;
-        --list-only)
-            LIST_ONLY=true
-            shift
-            ;;
-        *)
-            FILE_PATH="$1"
-            shift
-            ;;
-    esac
-done
-
-# Validate inputs
-if [ -z "$FILE_PATH" ]; then
-    echo "Error: File path required"
-    echo "Usage: $0 <file_path> [--agent-id <id>] [--interactive] [--list-only]"
-    exit 1
-fi
-
-# Normalize file path
-FILE_PATH=$(realpath "$FILE_PATH" 2>/dev/null || echo "$FILE_PATH")
-
-# Find backups for this file
-AGENT_BACKUP_DIR="$BACKUP_BASE_DIR/$AGENT_ID"
-
-if [ ! -d "$AGENT_BACKUP_DIR" ]; then
-    echo "❌ No backups found for agent: $AGENT_ID"
-    exit 1
-fi
-
-# Search for backups matching this file
-MATCHING_BACKUPS=()
-while IFS= read -r backup_dir; do
-    metadata_file="$backup_dir/backup_metadata.json"
-
-    if [ -f "$metadata_file" ]; then
-        original_path=$(jq -r '.original_path' "$metadata_file" 2>/dev/null || echo "")
-
-        # Normalize original path for comparison
-        original_path=$(realpath "$original_path" 2>/dev/null || echo "$original_path")
-
-        if [ "$original_path" = "$FILE_PATH" ]; then
-            MATCHING_BACKUPS+=("$backup_dir")
-        fi
-    fi
-done < <(find "$AGENT_BACKUP_DIR" -mindepth 1 -maxdepth 1 -type d | sort -r)
-
-# Check if any backups found
-if [ ${#MATCHING_BACKUPS[@]} -eq 0 ]; then
-    echo "❌ No backups found for file: $FILE_PATH"
-    exit 1
-fi
-
-# List backups function
-list_backups() {
-    echo "Available backups for: $FILE_PATH"
-    echo "----------------------------------------"
-
-    local index=1
-    for backup_dir in "${MATCHING_BACKUPS[@]}"; do
-        metadata_file="$backup_dir/backup_metadata.json"
-
-        timestamp=$(jq -r '.backup_timestamp' "$metadata_file")
-        status=$(jq -r '.backup_status' "$metadata_file")
-
-        # Convert timestamp to readable date
-        if command -v date >/dev/null 2>&1; then
-            # Handle millisecond timestamps
-            timestamp_seconds=$((timestamp / 1000))
-            date_str=$(date -d "@$timestamp_seconds" '+%Y-%m-%d %H:%M:%S' 2>/dev/null || date -r "$timestamp_seconds" '+%Y-%m-%d %H:%M:%S' 2>/dev/null || echo "Unknown")
-        else
-            date_str="$timestamp"
-        fi
-
-        echo "[$index] $date_str (Status: $status)"
-        echo "    Path: $backup_dir"
-
-        ((index++))
-    done
-    echo "----------------------------------------"
-}
-
-# List-only mode
-if [ "$LIST_ONLY" = true ]; then
-    list_backups
-    exit 0
-fi
-
-# Interactive mode
-if [ "$INTERACTIVE" = true ]; then
-    list_backups
-    echo ""
-    echo -n "Select backup to restore [1-${#MATCHING_BACKUPS[@]}] (or 0 to cancel): "
-    read -r selection
-
-    if [ "$selection" = "0" ]; then
-        echo "❌ Revert cancelled"
-        exit 0
-    fi
-
-    if ! [[ "$selection" =~ ^[0-9]+$ ]] || [ "$selection" -lt 1 ] || [ "$selection" -gt ${#MATCHING_BACKUPS[@]} ]; then
-        echo "❌ Invalid selection: $selection"
-        exit 1
-    fi
-
-    SELECTED_BACKUP="${MATCHING_BACKUPS[$((selection - 1))]}"
-else
-    # Auto-select most recent backup (first in sorted list)
-    SELECTED_BACKUP="${MATCHING_BACKUPS[0]}"
-
-    metadata_file="$SELECTED_BACKUP/backup_metadata.json"
-    timestamp=$(jq -r '.backup_timestamp' "$metadata_file")
-    timestamp_seconds=$((timestamp / 1000))
-    date_str=$(date -d "@$timestamp_seconds" '+%Y-%m-%d %H:%M:%S' 2>/dev/null || date -r "$timestamp_seconds" '+%Y-%m-%d %H:%M:%S' 2>/dev/null || echo "timestamp: $timestamp")
-
-    echo "🔄 Auto-selecting most recent backup: $date_str"
-fi
-
-# Restore using restore.sh
-echo "🔄 Restoring file from backup..."
-"$SCRIPT_DIR/restore.sh" "$SELECTED_BACKUP"
-
-if [ $? -eq 0 ]; then
-    echo "✅ File successfully reverted to backup"
-    echo "   Backup: $SELECTED_BACKUP"
-    exit 0
-else
-    echo "❌ Failed to revert file"
-    exit 1
-fi