claude-flow-novice 2.10.8 → 2.11.0

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

@@ -0,0 +1,128 @@
+#!/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

@@ -0,0 +1,168 @@
+#!/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

package/dist/agents/agent-loader.js

@@ -191,4 +191,319 @@ export const isValidAgentType = (name)=>agentLoader.isValidAgentType(name);
 export const getAgentsByCategory = (category)=>agentLoader.getAgentsByCategory(category);
 export const refreshAgents = ()=>agentLoader.refresh();
 
+//# sourceMappingURL=agent-loader.js.map.isArray(input)) return input.map(String);
+            if (typeof input === 'string') {
+                return input.split(/[,\s]+/).map(function(t) {
+                    return t.trim();
+                }).filter(function(t) {
+                    return t.length > 0;
+                });
+            }
+            return [];
+        };
+        // Safely handle tools and capabilities.tools
+        var toolsFromFrontmatter = frontmatter.tools ? extractTools(frontmatter.tools) : [];
+        var toolsFromCapabilities = frontmatter.capabilities && typeof frontmatter.capabilities === 'object' ? extractTools(Object(frontmatter.capabilities).tools) : [];
+        return __spreadArray(__spreadArray([], toolsFromFrontmatter, true), toolsFromCapabilities, true);
+    };
+    AgentLoader.prototype.loadAgents = function() {
+        return __awaiter(this, void 0, void 0, function() {
+            var agentsDir, agentFiles, categoryMap, _i, agentFiles_1, filePath, agent, relativePath, pathParts, category;
+            return __generator(this, function(_a) {
+                switch(_a.label){
+                    case 0:
+                        agentsDir = this.getAgentsDirectory();
+                        if (!(0, node_fs_1.existsSync)(agentsDir)) {
+                            console.warn("Agents directory not found: ".concat(agentsDir));
+                            return [
+                                2 /*return*/ 
+                            ];
+                        }
+                        return [
+                            4 /*yield*/ ,
+                            new Promise(function(resolve, reject) {
+                                (0, glob_1.glob)('**/*.md', {
+                                    cwd: agentsDir,
+                                    ignore: [
+                                        '**/README.md',
+                                        '**/MIGRATION_SUMMARY.md'
+                                    ],
+                                    absolute: true
+                                }, function(err, matches) {
+                                    if (err) reject(err);
+                                    else resolve(matches);
+                                });
+                            })
+                        ];
+                    case 1:
+                        agentFiles = _a.sent();
+                        this.agentCache.clear();
+                        this.categoriesCache = [];
+                        categoryMap = new Map();
+                        for(_i = 0, agentFiles_1 = agentFiles; _i < agentFiles_1.length; _i++){
+                            filePath = agentFiles_1[_i];
+                            agent = this.parseAgentFile(filePath);
+                            if (agent) {
+                                this.agentCache.set(agent.name, agent);
+                                relativePath = filePath.replace(agentsDir, '');
+                                pathParts = relativePath.split('/');
+                                category = pathParts[1] || 'uncategorized';
+                                if (!categoryMap.has(category)) {
+                                    categoryMap.set(category, []);
+                                }
+                                categoryMap.get(category).push(agent);
+                            }
+                        }
+                        this.categoriesCache = Array.from(categoryMap.entries()).map(function(_a) {
+                            var name = _a[0], agents = _a[1];
+                            return {
+                                name: name,
+                                agents: agents.sort(function(a, b) {
+                                    return a.name.localeCompare(b.name);
+                                })
+                            };
+                        });
+                        this.lastLoadTime = Date.now();
+                        return [
+                            2 /*return*/ 
+                        ];
+                }
+            });
+        });
+    };
+    // Rest of the methods remain similar to the original implementation
+    AgentLoader.prototype.needsRefresh = function() {
+        return Date.now() - this.lastLoadTime > this.CACHE_EXPIRY;
+    };
+    AgentLoader.prototype.ensureLoaded = function() {
+        return __awaiter(this, void 0, void 0, function() {
+            return __generator(this, function(_a) {
+                switch(_a.label){
+                    case 0:
+                        if (!(this.agentCache.size === 0 || this.needsRefresh())) return [
+                            3 /*break*/ ,
+                            2
+                        ];
+                        return [
+                            4 /*yield*/ ,
+                            this.loadAgents()
+                        ];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2:
+                        return [
+                            2 /*return*/ 
+                        ];
+                }
+            });
+        });
+    };
+    AgentLoader.prototype.getAvailableAgentTypes = function() {
+        return __awaiter(this, void 0, void 0, function() {
+            var currentTypes, legacyTypes;
+            return __generator(this, function(_a) {
+                switch(_a.label){
+                    case 0:
+                        return [
+                            4 /*yield*/ ,
+                            this.ensureLoaded()
+                        ];
+                    case 1:
+                        _a.sent();
+                        currentTypes = Array.from(this.agentCache.keys());
+                        legacyTypes = Object.keys(LEGACY_AGENT_MAPPING);
+                        return [
+                            2 /*return*/ ,
+                            Array.from(new Set(__spreadArray(__spreadArray([], currentTypes, true), legacyTypes, true))).sort()
+                        ];
+                }
+            });
+        });
+    };
+    AgentLoader.prototype.getAgent = function(name) {
+        return __awaiter(this, void 0, void 0, function() {
+            return __generator(this, function(_a) {
+                switch(_a.label){
+                    case 0:
+                        return [
+                            4 /*yield*/ ,
+                            this.ensureLoaded()
+                        ];
+                    case 1:
+                        _a.sent();
+                        return [
+                            2 /*return*/ ,
+                            this.agentCache.get(name) || this.agentCache.get(resolveLegacyAgentType(name)) || null
+                        ];
+                }
+            });
+        });
+    };
+    AgentLoader.prototype.getAllAgents = function() {
+        return __awaiter(this, void 0, void 0, function() {
+            return __generator(this, function(_a) {
+                switch(_a.label){
+                    case 0:
+                        return [
+                            4 /*yield*/ ,
+                            this.ensureLoaded()
+                        ];
+                    case 1:
+                        _a.sent();
+                        return [
+                            2 /*return*/ ,
+                            Array.from(this.agentCache.values()).sort(function(a, b) {
+                                return a.name.localeCompare(b.name);
+                            })
+                        ];
+                }
+            });
+        });
+    };
+    AgentLoader.prototype.getAgentCategories = function() {
+        return __awaiter(this, void 0, void 0, function() {
+            return __generator(this, function(_a) {
+                switch(_a.label){
+                    case 0:
+                        return [
+                            4 /*yield*/ ,
+                            this.ensureLoaded()
+                        ];
+                    case 1:
+                        _a.sent();
+                        return [
+                            2 /*return*/ ,
+                            this.categoriesCache
+                        ];
+                }
+            });
+        });
+    };
+    AgentLoader.prototype.searchAgents = function(query) {
+        return __awaiter(this, void 0, void 0, function() {
+            var lowerQuery;
+            return __generator(this, function(_a) {
+                switch(_a.label){
+                    case 0:
+                        return [
+                            4 /*yield*/ ,
+                            this.ensureLoaded()
+                        ];
+                    case 1:
+                        _a.sent();
+                        lowerQuery = query.toLowerCase();
+                        return [
+                            2 /*return*/ ,
+                            Array.from(this.agentCache.values()).filter(function(agent) {
+                                var _a;
+                                return agent.name.toLowerCase().includes(lowerQuery) || agent.description.toLowerCase().includes(lowerQuery) || ((_a = agent.capabilities) === null || _a === void 0 ? void 0 : _a.some(function(cap) {
+                                    return cap.toLowerCase().includes(lowerQuery);
+                                }));
+                            })
+                        ];
+                }
+            });
+        });
+    };
+    AgentLoader.prototype.isValidAgentType = function(name) {
+        return __awaiter(this, void 0, void 0, function() {
+            return __generator(this, function(_a) {
+                switch(_a.label){
+                    case 0:
+                        return [
+                            4 /*yield*/ ,
+                            this.ensureLoaded()
+                        ];
+                    case 1:
+                        _a.sent();
+                        return [
+                            2 /*return*/ ,
+                            this.agentCache.has(name) || this.agentCache.has(resolveLegacyAgentType(name))
+                        ];
+                }
+            });
+        });
+    };
+    AgentLoader.prototype.getAgentsByCategory = function(category) {
+        return __awaiter(this, void 0, void 0, function() {
+            var categories, found;
+            return __generator(this, function(_a) {
+                switch(_a.label){
+                    case 0:
+                        return [
+                            4 /*yield*/ ,
+                            this.getAgentCategories()
+                        ];
+                    case 1:
+                        categories = _a.sent();
+                        found = categories.find(function(cat) {
+                            return cat.name === category;
+                        });
+                        return [
+                            2 /*return*/ ,
+                            (found === null || found === void 0 ? void 0 : found.agents) || []
+                        ];
+                }
+            });
+        });
+    };
+    AgentLoader.prototype.refresh = function() {
+        return __awaiter(this, void 0, void 0, function() {
+            return __generator(this, function(_a) {
+                switch(_a.label){
+                    case 0:
+                        this.lastLoadTime = 0;
+                        return [
+                            4 /*yield*/ ,
+                            this.loadAgents()
+                        ];
+                    case 1:
+                        _a.sent();
+                        return [
+                            2 /*return*/ 
+                        ];
+                }
+            });
+        });
+    };
+    return AgentLoader;
+}();
+exports.AgentLoader = AgentLoader;
+// Singleton instance
+exports.agentLoader = new AgentLoader();
+// Convenience exports for use in other modules
+var getAvailableAgentTypes = function() {
+    return exports.agentLoader.getAvailableAgentTypes();
+};
+exports.getAvailableAgentTypes = getAvailableAgentTypes;
+var getAgent = function(name) {
+    return exports.agentLoader.getAgent(name);
+};
+exports.getAgent = getAgent;
+var getAllAgents = function() {
+    return exports.agentLoader.getAllAgents();
+};
+exports.getAllAgents = getAllAgents;
+var getAgentCategories = function() {
+    return exports.agentLoader.getAgentCategories();
+};
+exports.getAgentCategories = getAgentCategories;
+var searchAgents = function(query) {
+    return exports.agentLoader.searchAgents(query);
+};
+exports.searchAgents = searchAgents;
+var isValidAgentType = function(name) {
+    return exports.agentLoader.isValidAgentType(name);
+};
+exports.isValidAgentType = isValidAgentType;
+var getAgentsByCategory = function(category) {
+    return exports.agentLoader.getAgentsByCategory(category);
+};
+exports.getAgentsByCategory = getAgentsByCategory;
+var refreshAgents = function() {
+    return exports.agentLoader.refresh();
+};
+exports.refreshAgents = refreshAgents;
+
 //# sourceMappingURL=agent-loader.js.map