claude-flow-novice 2.15.11 → 2.16.1

package/claude-assets/skills/cfn-agent-selection-with-fallback/src/agent-selector.ts

@@ -0,0 +1,350 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+/**
+ * Task classification result
+ */
+export interface TaskClassification {
+  category: string;
+  confidence: number;
+  keywords: string[];
+}
+
+/**
+ * Agent selection result with Loop 3, Loop 2, and Product Owner
+ */
+export interface AgentSelection {
+  loop3: string[];
+  loop2: string[];
+  product_owner: string;
+  category: string;
+  confidence: number;
+}
+
+/**
+ * Agent mapping configuration for a single category
+ */
+export interface CategoryMapping {
+  loop3: string[];
+  loop2: string[];
+  keywords: string[];
+  confidence: number;
+}
+
+/**
+ * Full agent mappings configuration
+ */
+export interface AgentMappings {
+  categories: {
+    [key: string]: Omit<CategoryMapping, 'keywords'>;
+  };
+  product_owner: string;
+  agent_aliases: {
+    [key: string]: string;
+  };
+}
+
+/**
+ * Task classification keywords for each category
+ */
+const CLASSIFICATION_KEYWORDS: Record<string, string[]> = {
+  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
+ */
+export class AgentSelector {
+  private agentMappings: AgentMappings | null = null;
+  private mappingsPath: string;
+  private agentsDir: string;
+
+  constructor(
+    mappingsPath: string = '.claude/skills/cfn-agent-selection-with-fallback/agent-mappings.json',
+    agentsDir: string = '.claude/agents/cfn-dev-team'
+  ) {
+    this.mappingsPath = mappingsPath;
+    this.agentsDir = agentsDir;
+  }
+
+  /**
+   * Load agent mappings from JSON file
+   */
+  async loadMappings(): Promise<AgentMappings> {
+    if (this.agentMappings !== null) {
+      return this.agentMappings;
+    }
+
+    try {
+      const mappingsContent = await fs.promises.readFile(this.mappingsPath, 'utf-8');
+      const parsed = JSON.parse(mappingsContent) as AgentMappings;
+      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: string): Promise<TaskClassification> {
+    if (!description || description.trim().length === 0) {
+      return {
+        category: 'default',
+        confidence: 0.0,
+        keywords: []
+      };
+    }
+
+    const lowerDesc = description.toLowerCase();
+    const scores: Record<string, { count: number; keywords: string[] }> = {};
+
+    // 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: string[] = [];
+
+    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
+   */
+  private hasKeywords(description: string, keywords: string[]): boolean {
+    return keywords.some(keyword => description.includes(keyword));
+  }
+
+  /**
+   * Select agents for the given task description
+   */
+  async selectAgents(
+    description: string,
+    minValidators: number = 3
+  ): Promise<AgentSelection> {
+    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
+   */
+  private async validateAndFixAgents(
+    agents: string[],
+    fallbackAgent: string
+  ): Promise<string[]> {
+    const mappings = await this.loadMappings();
+    const validated: string[] = [];
+
+    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
+   */
+  private async validateAgent(agentName: string, mappings: AgentMappings): Promise<boolean> {
+    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: string[]): Promise<string[]> {
+    const mappings = await this.loadMappings();
+    const validated: string[] = [];
+
+    for (const agent of agents) {
+      if (await this.validateAgent(agent, mappings)) {
+        validated.push(agent);
+      }
+    }
+
+    return validated;
+  }
+}
+
+/**
+ * Create a default agent selector with standard paths
+ */
+export async function createDefaultSelector(): Promise<AgentSelector> {
+  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/src/cli.ts

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+
+import { AgentSelector, AgentSelection } from './agent-selector';
+import * as path from 'path';
+
+/**
+ * CLI entry point for agent selection
+ * Usage: npx ts-node src/cli.ts "task description" [--min-validators N]
+ */
+async function main(): Promise<void> {
+  try {
+    // Parse command line arguments
+    const args = process.argv.slice(2);
+
+    if (args.length === 0) {
+      // No task description provided, return default
+      const defaultResult: AgentSelection = {
+        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 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: AgentSelection = {
+      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/task-classifier.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
 
 # Task Classifier - Categorize tasks into predefined types

package/claude-assets/skills/cfn-agent-selection-with-fallback/task-classifier.sh.backup

@@ -0,0 +1,71 @@
+#!/usr/bin/env bash
+set -eu
+
+# Task Classifier - Categorize tasks into predefined types
+# Usage: ./task-classifier.sh "task description"
+
+TASK_DESCRIPTION="${1:-}"
+
+if [ -z "$TASK_DESCRIPTION" ]; then
+  echo "default"
+  exit 0
+fi
+
+# Convert to lowercase for matching
+TASK_LOWER=$(echo "$TASK_DESCRIPTION" | tr '[:upper:]' '[:lower:]')
+
+# Classification logic (priority order matters)
+
+# Security (highest priority - security-critical)
+if echo "$TASK_LOWER" | grep -qE "(security|vulnerability|exploit|encryption|ssl|tls|certificate|oauth|saml|rbac|permission|auth|jwt|authentication|authorization)"; then
+  echo "security"
+  exit 0
+fi
+
+# Infrastructure (DevOps, Docker, K8s)
+if echo "$TASK_LOWER" | grep -qE "(docker|kubernetes|k8s|helm|deployment|ci/cd|pipeline|aws|gcp|azure|cloud|terraform|ansible|infrastructure)"; then
+  echo "infrastructure"
+  exit 0
+fi
+
+# Mobile (iOS, Android, React Native)
+if echo "$TASK_LOWER" | grep -qE "(mobile|ios|android|react-native|react native|swift|kotlin|flutter|app store|play store)"; then
+  echo "mobile"
+  exit 0
+fi
+
+# Fullstack (Frontend + Backend keywords)
+if echo "$TASK_LOWER" | grep -qE "(fullstack|full-stack|full stack)" || \
+   (echo "$TASK_LOWER" | grep -qE "(react|vue|angular|svelte|frontend|ui)" && \
+    echo "$TASK_LOWER" | grep -qE "(api|backend|server|database|endpoint)"); then
+  echo "fullstack"
+  exit 0
+fi
+
+# Performance (Optimization, benchmarking) - Check early due to broad keywords
+if echo "$TASK_LOWER" | grep -qE "(performance|benchmark|latency|throughput|profiling|memory leak|cpu usage|slow|optimize|optimiz)"; then
+  echo "performance"
+  exit 0
+fi
+
+# Database (Schema, migrations, design)
+if echo "$TASK_LOWER" | grep -qE "(schema|migration|index|database.*query|sql|nosql|postgres|mongodb|redis|mysql|database design|table design|user.*table|create.*table)"; then
+  echo "database"
+  exit 0
+fi
+
+# Frontend (React, TypeScript, UI/UX)
+if echo "$TASK_LOWER" | grep -qE "(react|vue|angular|svelte|typescript|javascript|css|scss|tailwind|ui|ux|design|component|frontend|next\.js|remix)"; then
+  echo "frontend"
+  exit 0
+fi
+
+# Backend API (REST, GraphQL, endpoints)
+if echo "$TASK_LOWER" | grep -qE "(api|rest|graphql|endpoint|middleware|express|fastify|nest\.js|backend|server|microservice)"; then
+  echo "backend-api"
+  exit 0
+fi
+
+# Default fallback
+echo "default"
+exit 0

package/claude-assets/skills/cfn-agent-selection-with-fallback/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "target": "es2020",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "moduleResolution": "node",
+    "allowSyntheticDefaultImports": true,
+    "lib": ["es2020"]
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules", "**/*.test.ts"]
+}

package/claude-assets/skills/cfn-agent-spawning/SKILL.md

@@ -132,4 +132,51 @@ npx claude-flow-spawn "Implement auth" --agents=coder,tester --provider zai
   --agents coder,tester \
   --provider zai \
   --redis-channel swarm:auth
-```
+```
+
+---
+
+## ⚠️ Bash Deprecation Notice
+
+**The bash implementation of this skill is deprecated as of 2025-11-20.**
+
+**Deprecation Date:** 2025-11-20  
+**Removal Date:** 2026-02-20 (90 days)  
+**TypeScript Implementation:** dist/cli/spawn-agent-cli.js  
+**Migration Guide:** .claude/skills/cfn-agent-spawning/TYPESCRIPT_MIGRATION.md  
+
+### Why Migrate to TypeScript?
+
+- **Type Safety:** Zero runtime type errors with compile-time validation
+- **Better Performance:** 5-10ms faster execution, optimized Redis operations
+- **Comprehensive Testing:** 90%+ test coverage with unit, integration, and E2E tests
+- **Modern Tooling:** Full IDE support, autocomplete, and inline documentation
+- **Maintainability:** Single source of truth, easier debugging
+
+### Automatic Migration
+
+Set environment variable to automatically use TypeScript:
+
+```bash
+export USE_TYPESCRIPT=true
+```
+
+All coordinators and orchestrators will automatically prefer TypeScript implementations.
+
+### Rollback
+
+If issues arise:
+
+```bash
+export USE_TYPESCRIPT=false
+```
+
+Bash scripts will continue working for the 90-day deprecation period.
+
+### See Also
+
+- **Complete Deprecation List:** [docs/BASH_DEPRECATION_NOTICE.md](../../../docs/BASH_DEPRECATION_NOTICE.md)
+- **TypeScript Benefits:** See individual migration guides
+- **Test Coverage:** Run `npm test` to verify TypeScript implementation
+
+---