claude-flow-novice 2.14.18 → 2.14.19

package/claude-assets/skills/cfn-expert-update/update-expert.sh

@@ -0,0 +1,346 @@
+#!/bin/bash
+
+# CFN Expert Update Skill
+# Updates CFN system expert agent with relevant git commits
+
+set -euo pipefail
+
+# Configuration
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(cd "$SCRIPT_DIR/../../.." && pwd)"
+AGENT_FILE="$PROJECT_ROOT/.claude/agents/custom/cfn-system-expert.md"
+STATE_FILE="$PROJECT_ROOT/.claude/state/cfn-expert-last-commit"
+BACKUP_DIR="$PROJECT_ROOT/.claude/backups/cfn-expert"
+
+# Ensure directories exist
+mkdir -p "$(dirname "$STATE_FILE")"
+mkdir -p "$BACKUP_DIR"
+
+# Parse arguments
+DRY_RUN=false
+FORCE=false
+SINCE_COMMIT=""
+
+while [[ $# -gt 0 ]]; do
+    case $1 in
+        --dry-run)
+            DRY_RUN=true
+            shift
+            ;;
+        --force)
+            FORCE=true
+            shift
+            ;;
+        --since=*)
+            SINCE_COMMIT="${1#*=}"
+            shift
+            ;;
+        *)
+            echo "❌ Unknown parameter: $1"
+            echo "Usage: $0 [--dry-run] [--force] [--since=commit_hash]"
+            exit 1
+            ;;
+    esac
+done
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+# Logging functions
+log_info() { echo -e "${BLUE}ℹ️  $1${NC}"; }
+log_success() { echo -e "${GREEN}✅ $1${NC}"; }
+log_warning() { echo -e "${YELLOW}⚠️  $1${NC}"; }
+log_error() { echo -e "${RED}❌ $1${NC}"; }
+
+# Get last scanned commit
+get_last_commit() {
+    if [[ -n "$SINCE_COMMIT" ]]; then
+        echo "$SINCE_COMMIT"
+    elif [[ -f "$STATE_FILE" ]] && ! $FORCE; then
+        head -n1 "$STATE_FILE"
+    else
+        # Default to 10 commits back if no tracking
+        git log --format="%H" -n 10 | tail -n1
+    fi
+}
+
+# Update last commit tracking
+update_last_commit() {
+    local commit_hash="$1"
+    local timestamp="$(date -u +%Y-%m-%dT%H:%M:%SZ)"
+    echo "$commit_hash" > "$STATE_FILE"
+    echo "$timestamp" >> "$STATE_FILE"
+    log_success "📝 Last commit updated: $commit_hash"
+}
+
+# Create backup of agent file
+create_backup() {
+    if [[ -f "$AGENT_FILE" ]]; then
+        local timestamp=$(date +%Y%m%d_%H%M%S)
+        local backup_file="$BACKUP_DIR/${timestamp}_cfn-system-expert.md"
+        cp "$AGENT_FILE" "$backup_file"
+        log_success "📁 Backup created: $backup_file"
+        echo "$backup_file"
+    fi
+}
+
+# Check if commit is relevant to CFN system
+is_relevant_commit() {
+    local commit_hash="$1"
+    local commit_files
+    local commit_msg
+
+    # Get commit message and files
+    commit_msg=$(git log --format="%s" -n 1 "$commit_hash")
+    commit_files=$(git show --name-only --format="" "$commit_hash" | tr '\n' ' ')
+
+    # High relevance patterns
+    local high_patterns=(
+        "CLAUDE\.md"
+        "\.claude/commands/cfn/"
+        "cfn-loop"
+        "CFN Loop"
+        "claude-flow-novice"
+    )
+
+    # Medium relevance patterns
+    local medium_patterns=(
+        "\.claude/skills/cfn-"
+        "agent.*coordination"
+        "redis.*coordination"
+        "cost.*optimization"
+        "adaptive.*context"
+        "consensus"
+        "swarm"
+    )
+
+    # Low relevance patterns
+    local low_patterns=(
+        "\.claude/agents/cfn-"
+        "performance"
+        "optimization"
+        "debugging"
+        "troubleshooting"
+    )
+
+    # Check relevance
+    local relevance=0
+    local combined_check="$commit_msg $commit_files"
+
+    # High priority (always relevant)
+    for pattern in "${high_patterns[@]}"; do
+        if echo "$combined_check" | grep -qE "$pattern"; then
+            echo "high"
+            return
+        fi
+    done
+
+    # Medium priority
+    for pattern in "${medium_patterns[@]}"; do
+        if echo "$combined_check" | grep -qE "$pattern"; then
+            echo "medium"
+            return
+        fi
+    done
+
+    # Low priority
+    for pattern in "${low_patterns[@]}"; do
+        if echo "$combined_check" | grep -qE "$pattern"; then
+            echo "low"
+            return
+        fi
+    done
+
+    echo "none"
+}
+
+# Extract knowledge from commit
+extract_commit_knowledge() {
+    local commit_hash="$1"
+    local relevance="$2"
+    local commit_msg
+    local commit_diff
+    local knowledge=""
+
+    commit_msg=$(git log --format="%s%n%b" -n 1 "$commit_hash")
+    commit_diff=$(git show "$commit_hash" -- . | head -200)
+
+    case "$relevance" in
+        "high")
+            knowledge="# HIGH PRIORITY UPDATE
+Commit: $commit_hash
+Message: $commit_msg
+
+## System Changes
+$commit_diff
+
+## Impact
+This commit contains critical system updates that affect CFN Loop methodology, commands, or core rules.
+"
+            ;;
+        "medium")
+            knowledge="# MEDIUM PRIORITY UPDATE
+Commit: $commit_hash
+Message: $commit_msg
+
+## Process Changes
+$commit_diff
+
+## Impact
+This commit updates coordination patterns, skills, or cost optimization strategies.
+"
+            ;;
+        "low")
+            knowledge="# LOW PRIORITY UPDATE
+Commit: $commit_hash
+Message: $commit_msg
+
+## Informational Changes
+$commit_diff
+
+## Impact
+This commit contains improvements or additions that may be useful for reference.
+"
+            ;;
+    esac
+
+    echo "$knowledge"
+}
+
+# Update agent with new knowledge
+update_agent() {
+    local new_knowledge="$1"
+    local backup_file="$2"
+
+    if [[ "$DRY_RUN" == "true" ]]; then
+        log_info "🔍 DRY RUN: Would update agent with new knowledge"
+        echo "$new_knowledge" | head -20
+        log_info "🔍 ... (truncated in dry run)"
+        return
+    fi
+
+    # Create backup if not already created
+    if [[ -z "$backup_file" ]]; then
+        backup_file=$(create_backup)
+    fi
+
+    # Find insertion point (before "---" at end of file)
+    local temp_file=$(mktemp)
+    local inserted=false
+
+    while IFS= read -r line; do
+        echo "$line" >> "$temp_file"
+
+        # Insert new knowledge before the closing ---
+        if [[ "$line" == "---" ]] && [[ "$inserted" == "false" ]]; then
+            echo "" >> "$temp_file"
+            echo "$new_knowledge" >> "$temp_file"
+            echo "" >> "$temp_file"
+            inserted=true
+        fi
+    done < "$AGENT_FILE"
+
+    # Move temp file to agent location
+    mv "$temp_file" "$AGENT_FILE"
+    log_success "🔄 Expert agent updated successfully"
+}
+
+# Main execution
+main() {
+    log_info "🚀 Starting CFN expert update..."
+
+    # Validate we're in a git repo
+    if ! git rev-parse --git-dir >/dev/null 2>&1; then
+        log_error "Not in a git repository"
+        exit 1
+    fi
+
+    # Check if agent file exists
+    if [[ ! -f "$AGENT_FILE" ]]; then
+        log_error "CFN system expert agent not found: $AGENT_FILE"
+        exit 1
+    fi
+
+    # Get commit range
+    local last_commit=$(get_last_commit)
+    local current_head=$(git rev-parse HEAD)
+
+    if [[ "$last_commit" == "$current_head" ]] && [[ "$FORCE" != "true" ]]; then
+        log_info "ℹ️  No new commits to scan"
+        return
+    fi
+
+    log_info "🔍 Scanning commits since ${last_commit:0:8}..."
+
+    # Get commits since last scan
+    local commits
+    if [[ "$FORCE" == "true" ]]; then
+        commits=$(git log --format="%H" --since="2 weeks ago" | tac)
+    else
+        commits=$(git log --format="%H" "$last_commit..HEAD" | tac)
+    fi
+
+    if [[ -z "$commits" ]]; then
+        log_info "ℹ️  No new commits found"
+        return
+    fi
+
+    local commit_count=$(echo "$commits" | wc -l)
+    log_info "📋 Found $commit_count commits to analyze"
+
+    # Process commits
+    local relevant_commits=0
+    local total_knowledge=""
+    local backup_file=""
+
+    while read -r commit_hash; do
+        [[ -z "$commit_hash" ]] && continue
+
+        local relevance=$(is_relevant_commit "$commit_hash")
+
+        if [[ "$relevance" != "none" ]]; then
+            ((relevant_commits++))
+            log_info "🎯 Relevant commit found (${relevance}): ${commit_hash:0:8}"
+
+            local knowledge=$(extract_commit_knowledge "$commit_hash" "$relevance")
+            total_knowledge="${total_knowledge}${knowledge}"$'\n'
+        fi
+    done <<< "$commits"
+
+    # Report results
+    if [[ "$relevant_commits" == "0" ]]; then
+        log_info "ℹ️  No CFN-relevant changes found"
+        return
+    fi
+
+    log_info "📊 Found $relevant_commits/$commit_count relevant commits"
+
+    if [[ "$DRY_RUN" == "true" ]]; then
+        log_info "🔍 DRY RUN MODE - No changes will be applied"
+        log_info "💡 Run without --dry-run to apply updates"
+        echo ""
+        echo "Sample of updates that would be applied:"
+        echo "$total_knowledge" | head -50
+        return
+    fi
+
+    # Create backup before updating
+    backup_file=$(create_backup)
+
+    # Update agent with new knowledge
+    update_agent "$total_knowledge" "$backup_file"
+
+    # Update tracking
+    update_last_commit "$current_head"
+
+    log_success "🎉 Update complete!"
+    log_info "📊 Processed $relevant_commits relevant commits"
+    log_info "📁 Backup available: $backup_file"
+}
+
+# Execute main function
+main "$@"

package/dist/agents/agent-loader.js

@@ -1,12 +1,145 @@
+"use strict";
 /**
  * Dynamic Agent Loader - Reads agent definitions from .claude/agents/ directory
  * Single source of truth for agent types in the system
- */ import { readFileSync, existsSync } from 'node:fs';
-import { glob } from 'glob';
-import { resolve, dirname } from 'node:path';
-import { parse as parseYaml } from 'yaml';
+ */ var __awaiter = this && this.__awaiter || function(thisArg, _arguments, P, generator) {
+    function adopt(value) {
+        return value instanceof P ? value : new P(function(resolve) {
+            resolve(value);
+        });
+    }
+    return new (P || (P = Promise))(function(resolve, reject) {
+        function fulfilled(value) {
+            try {
+                step(generator.next(value));
+            } catch (e) {
+                reject(e);
+            }
+        }
+        function rejected(value) {
+            try {
+                step(generator["throw"](value));
+            } catch (e) {
+                reject(e);
+            }
+        }
+        function step(result) {
+            result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+        }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = this && this.__generator || function(thisArg, body) {
+    var _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+};
+var __spreadArray = this && this.__spreadArray || function(to, from, pack) {
+    if (pack || arguments.length === 2) for(var i = 0, l = from.length, ar; i < l; i++){
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+exports.refreshAgents = exports.getAgentsByCategory = exports.isValidAgentType = exports.searchAgents = exports.getAgentCategories = exports.getAllAgents = exports.getAgent = exports.getAvailableAgentTypes = exports.agentLoader = exports.AgentLoader = void 0;
+exports.resolveLegacyAgentType = resolveLegacyAgentType;
+var node_fs_1 = require("node:fs");
+var glob_1 = require("glob");
+var node_path_1 = require("node:path");
+var yaml_1 = require("yaml");
 // Legacy agent type mapping for backward compatibility
-const LEGACY_AGENT_MAPPING = {
+var LEGACY_AGENT_MAPPING = {
     analyst: 'code-analyzer',
     coordinator: 'hierarchical-coordinator',
     optimizer: 'perf-analyzer',
@@ -17,38 +150,40 @@ const LEGACY_AGENT_MAPPING = {
 };
 /**
  * Resolve legacy agent types to current equivalents
- */ export function resolveLegacyAgentType(legacyType) {
+ */ function resolveLegacyAgentType(legacyType) {
     return LEGACY_AGENT_MAPPING[legacyType] || legacyType;
 }
-export class AgentLoader {
-    agentCache = new Map();
-    categoriesCache = [];
-    lastLoadTime = 0;
-    CACHE_EXPIRY = 60_000;
-    getAgentsDirectory() {
-        let currentDir = process.cwd();
+var AgentLoader = /** @class */ function() {
+    function AgentLoader() {
+        this.agentCache = new Map();
+        this.categoriesCache = [];
+        this.lastLoadTime = 0;
+        this.CACHE_EXPIRY = 60000; // 1 minute cache
+    }
+    AgentLoader.prototype.getAgentsDirectory = function() {
+        var currentDir = process.cwd();
         while(currentDir !== '/'){
-            const claudeAgentsPath = resolve(currentDir, '.claude', 'agents');
-            if (existsSync(claudeAgentsPath)) {
+            var claudeAgentsPath = (0, node_path_1.resolve)(currentDir, '.claude', 'agents');
+            if ((0, node_fs_1.existsSync)(claudeAgentsPath)) {
                 return claudeAgentsPath;
             }
-            currentDir = dirname(currentDir);
+            currentDir = (0, node_path_1.dirname)(currentDir);
         }
-        return resolve(process.cwd(), '.claude', 'agents');
-    }
-    parseAgentFile(filePath) {
+        return (0, node_path_1.resolve)(process.cwd(), '.claude', 'agents');
+    };
+    AgentLoader.prototype.parseAgentFile = function(filePath) {
         try {
-            const content = readFileSync(filePath, 'utf-8');
-            const frontmatterMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/);
+            var content = (0, node_fs_1.readFileSync)(filePath, 'utf-8');
+            var frontmatterMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/);
             if (!frontmatterMatch) {
-                console.warn(`No frontmatter found in ${filePath}`);
+                console.warn("No frontmatter found in ".concat(filePath));
                 return null;
             }
-            const [, yamlContent, markdownContent] = frontmatterMatch;
-            const frontmatter = parseYaml(yamlContent);
-            const description = frontmatter.description;
+            var yamlContent = frontmatterMatch[1], markdownContent = frontmatterMatch[2];
+            var frontmatter = (0, yaml_1.parse)(yamlContent);
+            var description = frontmatter.description;
             if (!frontmatter.name || !description) {
-                console.warn(`Missing required fields (name, description) in ${filePath}`);
+                console.warn("Missing required fields (name, description) in ".concat(filePath));
                 return null;
             }
             return {
@@ -69,129 +204,13 @@ export class AgentLoader {
                 content: markdownContent.trim()
             };
         } catch (error) {
-            console.error(`Error parsing agent file ${filePath}:`, error);
+            console.error("Error parsing agent file ".concat(filePath, ":"), error);
             return null;
         }
-    }
-    parseTools(frontmatter) {
-        const extractTools = (input)=>{
+    };
+    AgentLoader.prototype.parseTools = function(frontmatter) {
+        var extractTools = function(input) {
             if (Array.isArray(input)) return input.map(String);
-            if (typeof input === 'string') {
-                return input.split(/[,\s]+/).map((t)=>t.trim()).filter((t)=>t.length > 0);
-            }
-            return [];
-        };
-        // Safely handle tools and capabilities.tools
-        const toolsFromFrontmatter = frontmatter.tools ? extractTools(frontmatter.tools) : [];
-        const toolsFromCapabilities = frontmatter.capabilities && typeof frontmatter.capabilities === 'object' ? extractTools(Object(frontmatter.capabilities).tools) : [];
-        return [
-            ...toolsFromFrontmatter,
-            ...toolsFromCapabilities
-        ];
-    }
-    async loadAgents() {
-        const agentsDir = this.getAgentsDirectory();
-        if (!existsSync(agentsDir)) {
-            console.warn(`Agents directory not found: ${agentsDir}`);
-            return;
-        }
-        const agentFiles = await new Promise((resolve, reject)=>{
-            glob('**/*.md', {
-                cwd: agentsDir,
-                ignore: [
-                    '**/README.md',
-                    '**/MIGRATION_SUMMARY.md'
-                ],
-                absolute: true
-            }, (err, matches)=>{
-                if (err) reject(err);
-                else resolve(matches);
-            });
-        });
-        this.agentCache.clear();
-        this.categoriesCache = [];
-        const categoryMap = new Map();
-        for (const filePath of agentFiles){
-            const agent = this.parseAgentFile(filePath);
-            if (agent) {
-                this.agentCache.set(agent.name, agent);
-                const relativePath = filePath.replace(agentsDir, '');
-                const pathParts = relativePath.split('/');
-                const category = pathParts[1] || 'uncategorized';
-                if (!categoryMap.has(category)) {
-                    categoryMap.set(category, []);
-                }
-                categoryMap.get(category).push(agent);
-            }
-        }
-        this.categoriesCache = Array.from(categoryMap.entries()).map(([name, agents])=>({
-                name,
-                agents: agents.sort((a, b)=>a.name.localeCompare(b.name))
-            }));
-        this.lastLoadTime = Date.now();
-    }
-    // Rest of the methods remain similar to the original implementation
-    needsRefresh() {
-        return Date.now() - this.lastLoadTime > this.CACHE_EXPIRY;
-    }
-    async ensureLoaded() {
-        if (this.agentCache.size === 0 || this.needsRefresh()) {
-            await this.loadAgents();
-        }
-    }
-    async getAvailableAgentTypes() {
-        await this.ensureLoaded();
-        const currentTypes = Array.from(this.agentCache.keys());
-        const legacyTypes = Object.keys(LEGACY_AGENT_MAPPING);
-        return Array.from(new Set([
-            ...currentTypes,
-            ...legacyTypes
-        ])).sort();
-    }
-    async getAgent(name) {
-        await this.ensureLoaded();
-        return this.agentCache.get(name) || this.agentCache.get(resolveLegacyAgentType(name)) || null;
-    }
-    async getAllAgents() {
-        await this.ensureLoaded();
-        return Array.from(this.agentCache.values()).sort((a, b)=>a.name.localeCompare(b.name));
-    }
-    async getAgentCategories() {
-        await this.ensureLoaded();
-        return this.categoriesCache;
-    }
-    async searchAgents(query) {
-        await this.ensureLoaded();
-        const lowerQuery = query.toLowerCase();
-        return Array.from(this.agentCache.values()).filter((agent)=>agent.name.toLowerCase().includes(lowerQuery) || agent.description.toLowerCase().includes(lowerQuery) || agent.capabilities?.some((cap)=>cap.toLowerCase().includes(lowerQuery)));
-    }
-    async isValidAgentType(name) {
-        await this.ensureLoaded();
-        return this.agentCache.has(name) || this.agentCache.has(resolveLegacyAgentType(name));
-    }
-    async getAgentsByCategory(category) {
-        const categories = await this.getAgentCategories();
-        const found = categories.find((cat)=>cat.name === category);
-        return found?.agents || [];
-    }
-    async refresh() {
-        this.lastLoadTime = 0;
-        await this.loadAgents();
-    }
-}
-// Singleton instance
-export const agentLoader = new AgentLoader();
-// Convenience exports for use in other modules
-export const getAvailableAgentTypes = ()=>agentLoader.getAvailableAgentTypes();
-export const getAgent = (name)=>agentLoader.getAgent(name);
-export const getAllAgents = ()=>agentLoader.getAllAgents();
-export const getAgentCategories = ()=>agentLoader.getAgentCategories();
-export const searchAgents = (query)=>agentLoader.searchAgents(query);
-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();