claude-flow-novice 2.15.11 → 2.16.0

package/claude-assets/skills/cfn-agent-selection-with-fallback/dist/agent-selector.js

@@ -0,0 +1,297 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentSelector = void 0;
+exports.createDefaultSelector = createDefaultSelector;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * Task classification keywords for each category
+ */
+const CLASSIFICATION_KEYWORDS = {
+    security: [
+        'security', 'vulnerability', 'exploit', 'encryption', 'ssl', 'tls',
+        'certificate', 'oauth', 'saml', 'rbac', 'permission', 'auth', 'jwt',
+        'authentication', 'authorization'
+    ],
+    infrastructure: [
+        'docker', 'kubernetes', 'k8s', 'helm', 'deployment', 'ci/cd', 'pipeline',
+        'aws', 'gcp', 'azure', 'cloud', 'terraform', 'ansible', 'infrastructure'
+    ],
+    mobile: [
+        'mobile', 'ios', 'android', 'react-native', 'react native', 'swift',
+        'kotlin', 'flutter', 'app store', 'play store'
+    ],
+    frontend: [
+        'react', 'vue', 'angular', 'svelte', 'typescript', 'javascript', 'css',
+        'scss', 'tailwind', 'ui', 'ux', 'design', 'component', 'frontend',
+        'next.js', 'remix'
+    ],
+    database: [
+        'schema', 'migration', 'index', 'database', 'sql', 'nosql', 'postgres',
+        'mongodb', 'redis', 'mysql', 'table design', 'create table'
+    ],
+    'backend-api': [
+        'api', 'rest', 'graphql', 'endpoint', 'middleware', 'express', 'fastify',
+        'nest.js', 'backend', 'server', 'microservice'
+    ],
+    performance: [
+        'performance', 'benchmark', 'latency', 'throughput', 'profiling',
+        'memory leak', 'cpu usage', 'slow', 'optimize'
+    ],
+    fullstack: [
+        'fullstack', 'full-stack', 'full stack'
+    ],
+    default: []
+};
+/**
+ * Keyword categories sorted by priority (highest first)
+ */
+const CATEGORY_PRIORITY = [
+    'security',
+    'infrastructure',
+    'mobile',
+    'fullstack',
+    'performance',
+    'database',
+    'frontend',
+    'backend-api',
+    'default'
+];
+/**
+ * Agent Selection class for task classification and agent selection
+ */
+class AgentSelector {
+    constructor(mappingsPath = '.claude/skills/cfn-agent-selection-with-fallback/agent-mappings.json', agentsDir = '.claude/agents/cfn-dev-team') {
+        this.agentMappings = null;
+        this.mappingsPath = mappingsPath;
+        this.agentsDir = agentsDir;
+    }
+    /**
+     * Load agent mappings from JSON file
+     */
+    async loadMappings() {
+        if (this.agentMappings !== null) {
+            return this.agentMappings;
+        }
+        try {
+            const mappingsContent = await fs.promises.readFile(this.mappingsPath, 'utf-8');
+            const parsed = JSON.parse(mappingsContent);
+            this.agentMappings = parsed;
+            return parsed;
+        }
+        catch (error) {
+            console.error(`Failed to load agent mappings from ${this.mappingsPath}:`, error);
+            throw new Error(`Cannot load agent mappings: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Classify a task description into a category
+     * Returns the category with highest confidence score
+     */
+    async classifyTask(description) {
+        if (!description || description.trim().length === 0) {
+            return {
+                category: 'default',
+                confidence: 0.0,
+                keywords: []
+            };
+        }
+        const lowerDesc = description.toLowerCase();
+        const scores = {};
+        // Initialize scores for all categories
+        for (const category of CATEGORY_PRIORITY) {
+            scores[category] = { count: 0, keywords: [] };
+        }
+        // Special handling for fullstack (requires both frontend AND backend keywords)
+        const hasFrontend = this.hasKeywords(lowerDesc, ['react', 'vue', 'angular', 'svelte', 'typescript', 'javascript', 'css', 'scss', 'tailwind', 'ui', 'component', 'frontend']);
+        const hasBackend = this.hasKeywords(lowerDesc, ['api', 'backend', 'server', 'database', 'endpoint']);
+        const hasFullstackKeyword = this.hasKeywords(lowerDesc, ['fullstack', 'full-stack', 'full stack']);
+        if (hasFullstackKeyword || (hasFrontend && hasBackend)) {
+            scores['fullstack'].count = 3; // High score for fullstack
+            scores['fullstack'].keywords = ['fullstack'];
+        }
+        // Score other categories
+        for (const category of CATEGORY_PRIORITY) {
+            if (category === 'fullstack' || category === 'default')
+                continue;
+            const keywords = CLASSIFICATION_KEYWORDS[category] || [];
+            for (const keyword of keywords) {
+                if (lowerDesc.includes(keyword)) {
+                    scores[category].count++;
+                    scores[category].keywords.push(keyword);
+                }
+            }
+        }
+        // Find category with highest score
+        let bestCategory = 'default';
+        let bestScore = 0;
+        let bestKeywords = [];
+        for (const category of CATEGORY_PRIORITY) {
+            if (scores[category].count > bestScore) {
+                bestScore = scores[category].count;
+                bestCategory = category;
+                bestKeywords = scores[category].keywords;
+            }
+        }
+        // Map bestScore to confidence (normalize to 0.0-1.0)
+        const confidence = bestCategory === 'default' ? 0.0 : Math.min(1.0, 0.5 + (bestScore * 0.1));
+        return {
+            category: bestCategory,
+            confidence: Math.round(confidence * 100) / 100,
+            keywords: bestKeywords
+        };
+    }
+    /**
+     * Check if description contains any of the given keywords
+     */
+    hasKeywords(description, keywords) {
+        return keywords.some(keyword => description.includes(keyword));
+    }
+    /**
+     * Select agents for the given task description
+     */
+    async selectAgents(description, minValidators = 3) {
+        const mappings = await this.loadMappings();
+        const classification = await this.classifyTask(description);
+        // Validate category exists in mappings
+        let category = classification.category;
+        if (!mappings.categories[category]) {
+            console.warn(`[WARN] Invalid category '${category}', falling back to 'default'`);
+            category = 'default';
+        }
+        const categoryMapping = mappings.categories[category];
+        if (!categoryMapping) {
+            throw new Error(`Category '${category}' not found in mappings`);
+        }
+        // Extract agents for category
+        let loop3Agents = Array.isArray(categoryMapping.loop3) ? [...categoryMapping.loop3] : [];
+        let loop2Agents = Array.isArray(categoryMapping.loop2) ? [...categoryMapping.loop2] : [];
+        // Fallback if empty Loop 3 agents
+        if (loop3Agents.length === 0) {
+            console.warn(`[WARN] Empty Loop 3 agents for category '${category}', using default`);
+            const defaultMapping = mappings.categories['default'];
+            loop3Agents = Array.isArray(defaultMapping.loop3) ? [...defaultMapping.loop3] : [];
+        }
+        // Fallback if empty Loop 2 agents
+        if (loop2Agents.length === 0) {
+            console.warn(`[WARN] Empty Loop 2 agents for category '${category}', using default`);
+            const defaultMapping = mappings.categories['default'];
+            loop2Agents = Array.isArray(defaultMapping.loop2) ? [...defaultMapping.loop2] : [];
+        }
+        // Validate agents exist in agent profiles
+        const validatedLoop3 = await this.validateAndFixAgents(loop3Agents, 'backend-developer');
+        const validatedLoop2 = await this.validateAndFixAgents(loop2Agents, 'tester');
+        // Ensure minimum 2 Loop 3 agents
+        if (validatedLoop3.length < 2) {
+            console.warn('[WARN] Less than 2 Loop 3 agents, adding devops-engineer');
+            validatedLoop3.push('devops-engineer');
+        }
+        // Ensure minimum validators for Loop 2
+        while (validatedLoop2.length < minValidators) {
+            console.warn(`[WARN] Less than ${minValidators} Loop 2 validators, adding code-quality-validator`);
+            validatedLoop2.push('code-quality-validator');
+        }
+        const productOwner = mappings.product_owner || 'product-owner';
+        return {
+            loop3: validatedLoop3,
+            loop2: validatedLoop2,
+            product_owner: productOwner,
+            category,
+            confidence: categoryMapping.confidence || 0.70
+        };
+    }
+    /**
+     * Validate agents and replace invalid ones with fallback
+     */
+    async validateAndFixAgents(agents, fallbackAgent) {
+        const mappings = await this.loadMappings();
+        const validated = [];
+        for (const agent of agents) {
+            if (await this.validateAgent(agent, mappings)) {
+                validated.push(agent);
+            }
+            else {
+                console.warn(`[WARN] Invalid agent '${agent}', replacing with ${fallbackAgent}`);
+                validated.push(fallbackAgent);
+            }
+        }
+        return validated.length > 0 ? validated : [fallbackAgent];
+    }
+    /**
+     * Validate that an agent exists in the agent profiles
+     */
+    async validateAgent(agentName, mappings) {
+        const agentAliases = mappings.agent_aliases || {};
+        const agentPath = agentAliases[agentName];
+        if (!agentPath) {
+            return false;
+        }
+        const fullPath = path.join(this.agentsDir, agentPath);
+        try {
+            await fs.promises.access(fullPath, fs.constants.F_OK);
+            // Verify path stays within agents directory (security check)
+            const realPath = await fs.promises.realpath(fullPath);
+            const realAgentsDir = await fs.promises.realpath(this.agentsDir);
+            return realPath.startsWith(realAgentsDir);
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Validate agents exist in agent profiles
+     */
+    async validateAgents(agents) {
+        const mappings = await this.loadMappings();
+        const validated = [];
+        for (const agent of agents) {
+            if (await this.validateAgent(agent, mappings)) {
+                validated.push(agent);
+            }
+        }
+        return validated;
+    }
+}
+exports.AgentSelector = AgentSelector;
+/**
+ * Create a default agent selector with standard paths
+ */
+async function createDefaultSelector() {
+    const projectRoot = process.env.PROJECT_ROOT || process.cwd();
+    const mappingsPath = path.join(projectRoot, '.claude/skills/cfn-agent-selection-with-fallback/agent-mappings.json');
+    const agentsDir = path.join(projectRoot, '.claude/agents/cfn-dev-team');
+    return new AgentSelector(mappingsPath, agentsDir);
+}

package/claude-assets/skills/cfn-agent-selection-with-fallback/dist/cli.cjs

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const agent_selector_1 = require("./agent-selector.cjs");
+const path = __importStar(require("path"));
+/**
+ * CLI entry point for agent selection
+ * Usage: npx ts-node src/cli.ts "task description" [--min-validators N]
+ */
+async function main() {
+    try {
+        // Parse command line arguments
+        const args = process.argv.slice(2);
+        if (args.length === 0) {
+            // No task description provided, return default
+            const defaultResult = {
+                loop3: ['backend-developer', 'devops-engineer'],
+                loop2: ['code-reviewer', 'tester', 'code-quality-validator'],
+                product_owner: 'product-owner',
+                category: 'default',
+                confidence: 0.70
+            };
+            console.log(JSON.stringify(defaultResult));
+            return;
+        }
+        const taskDescription = args[0];
+        let minValidators = 3;
+        // Parse optional parameters
+        for (let i = 1; i < args.length; i++) {
+            if (args[i] === '--min-validators' && i + 1 < args.length) {
+                const parsed = parseInt(args[i + 1], 10);
+                if (!isNaN(parsed) && parsed > 0) {
+                    minValidators = parsed;
+                }
+                i++;
+            }
+        }
+        // Create selector with proper paths
+        const projectRoot = process.env.PROJECT_ROOT || process.cwd();
+        const mappingsPath = path.join(projectRoot, '.claude/skills/cfn-agent-selection-with-fallback/agent-mappings.json');
+        const agentsDir = path.join(projectRoot, '.claude/agents/cfn-dev-team');
+        const selector = new agent_selector_1.AgentSelector(mappingsPath, agentsDir);
+        // Select agents
+        const result = await selector.selectAgents(taskDescription, minValidators);
+        // Output JSON
+        console.log(JSON.stringify(result));
+    }
+    catch (error) {
+        // Return error response with fallback agents
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        const errorResult = {
+            loop3: ['backend-developer', 'devops-engineer'],
+            loop2: ['code-reviewer', 'tester', 'code-quality-validator'],
+            product_owner: 'product-owner',
+            category: 'default',
+            confidence: 0.70
+        };
+        console.error(`[ERROR] ${errorMessage}`);
+        console.log(JSON.stringify(errorResult));
+        process.exit(1);
+    }
+}
+main();

package/claude-assets/skills/cfn-agent-selection-with-fallback/dist/cli.js

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const agent_selector_1 = require("./agent-selector");
+const path = __importStar(require("path"));
+/**
+ * CLI entry point for agent selection
+ * Usage: npx ts-node src/cli.ts "task description" [--min-validators N]
+ */
+async function main() {
+    try {
+        // Parse command line arguments
+        const args = process.argv.slice(2);
+        if (args.length === 0) {
+            // No task description provided, return default
+            const defaultResult = {
+                loop3: ['backend-developer', 'devops-engineer'],
+                loop2: ['code-reviewer', 'tester', 'code-quality-validator'],
+                product_owner: 'product-owner',
+                category: 'default',
+                confidence: 0.70
+            };
+            console.log(JSON.stringify(defaultResult));
+            return;
+        }
+        const taskDescription = args[0];
+        let minValidators = 3;
+        // Parse optional parameters
+        for (let i = 1; i < args.length; i++) {
+            if (args[i] === '--min-validators' && i + 1 < args.length) {
+                const parsed = parseInt(args[i + 1], 10);
+                if (!isNaN(parsed) && parsed > 0) {
+                    minValidators = parsed;
+                }
+                i++;
+            }
+        }
+        // Create selector with proper paths
+        const projectRoot = process.env.PROJECT_ROOT || process.cwd();
+        const mappingsPath = path.join(projectRoot, '.claude/skills/cfn-agent-selection-with-fallback/agent-mappings.json');
+        const agentsDir = path.join(projectRoot, '.claude/agents/cfn-dev-team');
+        const selector = new agent_selector_1.AgentSelector(mappingsPath, agentsDir);
+        // Select agents
+        const result = await selector.selectAgents(taskDescription, minValidators);
+        // Output JSON
+        console.log(JSON.stringify(result));
+    }
+    catch (error) {
+        // Return error response with fallback agents
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        const errorResult = {
+            loop3: ['backend-developer', 'devops-engineer'],
+            loop2: ['code-reviewer', 'tester', 'code-quality-validator'],
+            product_owner: 'product-owner',
+            category: 'default',
+            confidence: 0.70
+        };
+        console.error(`[ERROR] ${errorMessage}`);
+        console.log(JSON.stringify(errorResult));
+        process.exit(1);
+    }
+}
+main();

package/claude-assets/skills/cfn-agent-selection-with-fallback/select-agents-ts.sh

@@ -0,0 +1,45 @@
+#!/bin/bash
+
+##############################################################################
+# ⚠️  DEPRECATED - This bash script is deprecated
+#
+# Deprecation Date: 2025-11-20
+# Removal Date: 2026-02-20 (90 days)
+# Replacement: dist/cli.cjs
+#
+# This script will be removed in 90 days. Please migrate to TypeScript.
+#
+# Migration Guide: See docs/BASH_DEPRECATION_NOTICE.md
+# TypeScript Benefits:
+#   - Type safety (zero runtime type errors)
+#   - 90%+ test coverage
+#   - Better performance
+#   - Comprehensive documentation
+#
+# Automatic Migration:
+#   Set USE_TYPESCRIPT=true to use TypeScript implementation automatically
+#
+##############################################################################
+
+# TypeScript wrapper for agent selection
+# Replaces select-agents.sh with TypeScript implementation
+# Usage: ./select-agents-ts.sh "task description" [--min-validators N]
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="${PROJECT_ROOT:-.}"
+
+# Build TypeScript if dist doesn't exist or is stale
+if [ ! -f "$SCRIPT_DIR/dist/cli.cjs" ] || [ "$SCRIPT_DIR/src/cli.ts" -nt "$SCRIPT_DIR/dist/cli.cjs" ]; then
+  echo "[INFO] Building TypeScript agent selector..." >&2
+  npx tsc --skipLibCheck --project "$SCRIPT_DIR/tsconfig.json" 2>/dev/null || true
+fi
+
+# Run the compiled CLI
+if [ -f "$SCRIPT_DIR/dist/cli.cjs" ]; then
+  PROJECT_ROOT="$PROJECT_ROOT" node "$SCRIPT_DIR/dist/cli.cjs" "$@"
+else
+  echo '{"error": "TypeScript compilation failed", "loop3": ["backend-developer", "devops-engineer"], "loop2": ["code-reviewer", "tester", "code-quality-validator"], "product_owner": "product-owner", "category": "default", "confidence": 0.70}'
+  exit 1
+fi

package/claude-assets/skills/cfn-agent-selection-with-fallback/select-agents-ts.sh.backup

@@ -0,0 +1,23 @@
+#!/bin/bash
+# TypeScript wrapper for agent selection
+# Replaces select-agents.sh with TypeScript implementation
+# Usage: ./select-agents-ts.sh "task description" [--min-validators N]
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="${PROJECT_ROOT:-.}"
+
+# Build TypeScript if dist doesn't exist or is stale
+if [ ! -f "$SCRIPT_DIR/dist/cli.cjs" ] || [ "$SCRIPT_DIR/src/cli.ts" -nt "$SCRIPT_DIR/dist/cli.cjs" ]; then
+  echo "[INFO] Building TypeScript agent selector..." >&2
+  npx tsc --skipLibCheck --project "$SCRIPT_DIR/tsconfig.json" 2>/dev/null || true
+fi
+
+# Run the compiled CLI
+if [ -f "$SCRIPT_DIR/dist/cli.cjs" ]; then
+  PROJECT_ROOT="$PROJECT_ROOT" node "$SCRIPT_DIR/dist/cli.cjs" "$@"
+else
+  echo '{"error": "TypeScript compilation failed", "loop3": ["backend-developer", "devops-engineer"], "loop2": ["code-reviewer", "tester", "code-quality-validator"], "product_owner": "product-owner", "category": "default", "confidence": 0.70}'
+  exit 1
+fi

package/claude-assets/skills/cfn-agent-selection-with-fallback/select-agents.sh

@@ -1,4 +1,26 @@
 #!/usr/bin/env bash
+
+##############################################################################
+# ⚠️  DEPRECATED - This bash script is deprecated
+#
+# Deprecation Date: 2025-11-20
+# Removal Date: 2026-02-20 (90 days)
+# Replacement: dist/cli.cjs
+#
+# This script will be removed in 90 days. Please migrate to TypeScript.
+#
+# Migration Guide: See docs/BASH_DEPRECATION_NOTICE.md
+# TypeScript Benefits:
+#   - Type safety (zero runtime type errors)
+#   - 90%+ test coverage
+#   - Better performance
+#   - Comprehensive documentation
+#
+# Automatic Migration:
+#   Set USE_TYPESCRIPT=true to use TypeScript implementation automatically
+#
+##############################################################################
+
 set -eu
 
 # Agent Selection with Fallback