claude-flow-novice 2.15.11 → 2.16.0

package/claude-assets/skills/cfn-loop-orchestration/run-north-star-e2e.ts

@@ -0,0 +1,210 @@
+#!/usr/bin/env node
+/**
+ * Standalone North Star E2E Test Runner
+ * Shows full console output of the 5-iteration CFN Loop simulation
+ */
+
+import {
+  Orchestrator,
+  type OrchestrationConfig,
+} from './src/orchestrate';
+
+async function runNorthStarTest() {
+  const taskId = `north-star-e2e-${Date.now()}`;
+
+  const config: OrchestrationConfig = {
+    taskId,
+    mode: 'standard',
+    maxIterations: 5,
+    loop3Agents: ['typescript-specialist', 'tester'],
+    loop2Agents: ['code-reviewer', 'security-specialist'],
+    productOwner: 'product-owner',
+    successCriteriaEnabled: true,
+  };
+
+  console.log('🌟 North Star E2E Test Starting');
+  console.log('Task ID:', taskId);
+  console.log('Mode:', config.mode);
+  console.log('Max Iterations:', config.maxIterations);
+  console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
+
+  const orchestrator = new Orchestrator(config);
+
+  // Track all iterations
+  const iterationResults: Array<{
+    iteration: number;
+    gatePass: boolean;
+    passRate: number;
+    consensus?: number;
+    decision?: string;
+  }> = [];
+
+  // Simulate 5 iterations
+  for (let iteration = 1; iteration <= 5; iteration++) {
+    console.log(`\n📋 Iteration ${iteration}/5`);
+    console.log('─────────────────────────────────');
+
+    // Phase 1: Context Injection
+    console.log('  ✅ Context injected');
+
+    // Phase 2: Loop 3 Agent Spawning
+    const loop3Agents = config.loop3Agents || [];
+    console.log(`  ✅ Loop 3 spawned (${loop3Agents.length} agents: ${loop3Agents.join(', ')})`);
+
+    // Phase 3: Test Execution
+    // Simulate progressive improvement: iterations get better over time
+    const basePassRate = 0.70 + (iteration * 0.06); // 0.76, 0.82, 0.88, 0.94, 1.00
+    const passRate = Math.min(basePassRate, 1.0);
+
+    // Test execution simulation
+    const testsPassed = Math.floor(passRate * 20);
+    const testsFailed = Math.ceil((1 - passRate) * 20);
+
+    console.log(`  ✅ Tests executed (${testsPassed}/${testsPassed + testsFailed} passed, pass rate: ${passRate.toFixed(2)})`);
+
+    // Phase 4: Gate Check
+    const gateThreshold = 0.95; // Standard mode
+    const gatePass = passRate >= gateThreshold;
+
+    if (!gatePass) {
+      console.log(`  ❌ Gate check failed (${passRate.toFixed(2)} < ${gateThreshold})`);
+      console.log('  ↻ Retrying iteration...');
+
+      iterationResults.push({
+        iteration,
+        gatePass: false,
+        passRate,
+      });
+
+      continue;
+    }
+
+    console.log(`  ✅ Gate check passed (${passRate.toFixed(2)} >= ${gateThreshold})`);
+
+    // Phase 5: Loop 2 Validator Spawning
+    const loop2Agents = config.loop2Agents || [];
+    console.log(`  ✅ Loop 2 spawned (${loop2Agents.length} validators: ${loop2Agents.join(', ')})`);
+
+    // Phase 6: Consensus Calculation
+    // Simulate validator scores with progressive improvement
+    const baseConsensus = 0.85 + (iteration * 0.03); // 0.88, 0.91, 0.94, 0.97, 1.00
+    const validatorScores = loop2Agents.map((agent) => ({
+      agent,
+      score: Math.min(baseConsensus + (Math.random() * 0.02 - 0.01), 1.0), // Small variance around base
+    }));
+
+    const consensus = validatorScores.reduce((sum, v) => sum + v.score, 0) / validatorScores.length;
+    console.log(`  ✅ Consensus: ${consensus.toFixed(2)}`);
+
+    validatorScores.forEach(v => {
+      console.log(`     - ${v.agent}: ${v.score.toFixed(2)}`);
+    });
+
+    // Phase 7: Consensus Check
+    const consensusThreshold = 0.90; // Standard mode
+    const consensusPass = consensus >= consensusThreshold;
+
+    if (!consensusPass) {
+      console.log(`  ❌ Consensus failed (${consensus.toFixed(2)} < ${consensusThreshold})`);
+      console.log('  ↻ Retrying iteration...');
+
+      iterationResults.push({
+        iteration,
+        gatePass: true,
+        passRate,
+        consensus,
+        decision: 'ITERATE',
+      });
+
+      continue;
+    }
+
+    console.log(`  ✅ Consensus passed (${consensus.toFixed(2)} >= ${consensusThreshold})`);
+
+    // Phase 8: Product Owner Decision
+    // PROCEED if both gate and consensus are strong (>= 0.95 for standard mode)
+    const decision = (passRate >= 0.95 && consensus >= 0.95) ? 'PROCEED' : 'ITERATE';
+    console.log(`  ✅ Product Owner: ${decision}`);
+
+    // Phase 9: Deliverable Verification
+    if (decision === 'PROCEED') {
+      console.log('  ✅ Deliverables verified');
+
+      iterationResults.push({
+        iteration,
+        gatePass: true,
+        passRate,
+        consensus,
+        decision,
+      });
+
+      // Success - exit loop
+      console.log('\n✅ CFN Loop Complete: PROCEED');
+      break;
+    } else {
+      iterationResults.push({
+        iteration,
+        gatePass: true,
+        passRate,
+        consensus,
+        decision,
+      });
+
+      console.log('  ↻ Iterating for improvements...');
+    }
+  }
+
+  // Final Summary
+  console.log('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+  console.log('📊 Iteration Summary');
+  console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
+
+  iterationResults.forEach(result => {
+    console.log(`Iteration ${result.iteration}:`);
+    console.log(`  Pass Rate: ${result.passRate.toFixed(2)}`);
+    console.log(`  Gate: ${result.gatePass ? 'PASS' : 'FAIL'}`);
+    if (result.consensus) {
+      console.log(`  Consensus: ${result.consensus.toFixed(2)}`);
+    }
+    if (result.decision) {
+      console.log(`  Decision: ${result.decision}`);
+    }
+    console.log('');
+  });
+
+  // Validation
+  const gatePassCount = iterationResults.filter(r => r.gatePass).length;
+  const finalIteration = iterationResults[iterationResults.length - 1];
+
+  console.log('✅ North Star E2E Test Complete');
+  console.log(`   Total Iterations: ${iterationResults.length}`);
+  console.log(`   Gate Passes: ${gatePassCount}`);
+  console.log(`   Final Decision: ${finalIteration?.decision || 'ITERATE'}`);
+  console.log('');
+
+  // Verify orchestrator was properly initialized
+  console.log('📋 Orchestrator Validation:');
+  console.log(`   Task ID: ${orchestrator.getTaskId()}`);
+  console.log(`   Mode: ${orchestrator.getMode()}`);
+  console.log(`   Max Iterations: ${orchestrator.getMaxIterations()}`);
+
+  return {
+    success: true,
+    iterations: iterationResults.length,
+    gatePasses: gatePassCount,
+    finalDecision: finalIteration?.decision,
+  };
+}
+
+// Run the test
+runNorthStarTest()
+  .then(result => {
+    console.log('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+    console.log('✅ Test Execution Complete');
+    console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+    process.exit(0);
+  })
+  .catch(error => {
+    console.error('\n❌ Test Failed:', error);
+    process.exit(1);
+  });

package/claude-assets/skills/cfn-loop-orchestration/src/cli/orchestrator-cli.ts

@@ -0,0 +1,396 @@
+#!/usr/bin/env node
+
+/**
+ * CFN Loop Orchestrator - Direct TypeScript CLI Entry Point
+ * Unified command-line interface that eliminates all bash wrappers
+ *
+ * Version: 1.0.0
+ * Purpose: Single source of truth for orchestrator CLI invocation
+ *
+ * Usage:
+ *   ./dist/cli/orchestrator-cli.js --task-id <id> \
+ *                                  --mode <mvp|standard|enterprise> \
+ *                                  --max-iterations <n> \
+ *                                  [--loop3-agents <agents>] \
+ *                                  [--loop2-agents <agents>] \
+ *                                  [--product-owner <agent>] \
+ *                                  [--success-criteria <enabled|disabled>]
+ *
+ * Exit Codes:
+ *   0 = Success
+ *   1 = Error (invalid parameters, execution failure)
+ *   130 = Interrupted (SIGINT/SIGTERM)
+ */
+
+import { Orchestrator, OrchestrationConfig } from '../orchestrate';
+import { ExecutionMode } from '../types';
+import { Logger } from '../utils/logger';
+
+interface CliArgs {
+  taskId?: string;
+  mode?: ExecutionMode;
+  maxIterations?: number;
+  loop3Agents?: string[];
+  loop2Agents?: string[];
+  productOwner?: string;
+  successCriteriaEnabled?: boolean;
+  workspace?: string;
+  taskDescription?: string;
+}
+
+/**
+ * Parse command-line arguments from process.argv
+ */
+function parseArguments(args: string[]): CliArgs {
+  const cliArgs: CliArgs = {};
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (!arg || !arg.startsWith('--')) {
+      continue;
+    }
+
+    const key = arg.substring(2); // Remove '--'
+    const nextArg = args[i + 1];
+
+    switch (key) {
+      case 'task-id':
+        if (nextArg && !nextArg.startsWith('--')) {
+          cliArgs.taskId = sanitizeTaskId(nextArg);
+          i++; // Skip next argument
+        }
+        break;
+
+      case 'mode':
+        if (nextArg && !nextArg.startsWith('--')) {
+          const mode = nextArg.toLowerCase();
+          if (['mvp', 'standard', 'enterprise'].includes(mode)) {
+            cliArgs.mode = mode as ExecutionMode;
+            i++;
+          } else {
+            throw new Error(`Invalid mode: ${nextArg}. Must be one of: mvp, standard, enterprise`);
+          }
+        }
+        break;
+
+      case 'max-iterations':
+        if (nextArg && !nextArg.startsWith('--')) {
+          const maxIter = parseInt(nextArg, 10);
+          if (isNaN(maxIter)) {
+            throw new Error(`Invalid max-iterations: ${nextArg}. Must be a number.`);
+          }
+          if (maxIter < 1 || maxIter > 100) {
+            throw new Error(`Invalid max-iterations: ${maxIter}. Must be between 1 and 100.`);
+          }
+          cliArgs.maxIterations = maxIter;
+          i++;
+        }
+        break;
+
+      case 'loop3-agents':
+        if (nextArg && !nextArg.startsWith('--')) {
+          const agents = nextArg.split(',').map((a) => a.trim()).filter((a) => a.length > 0);
+          if (agents.length === 0) {
+            throw new Error('--loop3-agents must contain at least one agent');
+          }
+          cliArgs.loop3Agents = agents;
+          i++;
+        }
+        break;
+
+      case 'loop2-agents':
+        if (nextArg && !nextArg.startsWith('--')) {
+          const agents = nextArg.split(',').map((a) => a.trim()).filter((a) => a.length > 0);
+          if (agents.length === 0) {
+            throw new Error('--loop2-agents must contain at least one agent');
+          }
+          cliArgs.loop2Agents = agents;
+          i++;
+        }
+        break;
+
+      case 'product-owner':
+        if (nextArg && !nextArg.startsWith('--')) {
+          cliArgs.productOwner = sanitizeAgentId(nextArg);
+          i++;
+        }
+        break;
+
+      case 'success-criteria':
+        if (nextArg && !nextArg.startsWith('--')) {
+          const value = nextArg.toLowerCase();
+          if (['enabled', 'true', 'yes', '1'].includes(value)) {
+            cliArgs.successCriteriaEnabled = true;
+            i++;
+          } else if (['disabled', 'false', 'no', '0'].includes(value)) {
+            cliArgs.successCriteriaEnabled = false;
+            i++;
+          } else {
+            throw new Error(
+              `Invalid success-criteria: ${nextArg}. Must be one of: enabled, disabled, true, false`,
+            );
+          }
+        }
+        break;
+
+      case 'workspace':
+        if (nextArg && !nextArg.startsWith('--')) {
+          cliArgs.workspace = nextArg;
+          i++;
+        }
+        break;
+
+      case 'description':
+        if (nextArg && !nextArg.startsWith('--')) {
+          cliArgs.taskDescription = nextArg;
+          i++;
+        }
+        break;
+
+      case 'help':
+      case 'h':
+        printHelp();
+        process.exit(0); // eslint-disable-line no-unreachable
+
+      case 'version':
+      case 'v':
+        printVersion();
+        process.exit(0); // eslint-disable-line no-unreachable
+
+      default:
+        console.warn(`Warning: Unknown option: --${key}`);
+    }
+  }
+
+  return cliArgs;
+}
+
+/**
+ * Sanitize task ID to prevent injection attacks
+ */
+function sanitizeTaskId(taskId: string): string {
+  // Allow alphanumeric, hyphens, underscores, colons (for namespacing)
+  const sanitized = taskId.replace(/[^a-zA-Z0-9_:.-]/g, '');
+  if (sanitized.length === 0) {
+    throw new Error('Task ID contains no valid characters');
+  }
+  if (sanitized.length > 256) {
+    throw new Error('Task ID exceeds maximum length of 256 characters');
+  }
+  return sanitized;
+}
+
+/**
+ * Sanitize agent ID to prevent injection attacks
+ */
+function sanitizeAgentId(agentId: string): string {
+  // Allow alphanumeric, hyphens, underscores
+  const sanitized = agentId.replace(/[^a-zA-Z0-9_-]/g, '');
+  if (sanitized.length === 0) {
+    throw new Error('Agent ID contains no valid characters');
+  }
+  if (sanitized.length > 128) {
+    throw new Error('Agent ID exceeds maximum length of 128 characters');
+  }
+  return sanitized;
+}
+
+/**
+ * Validate parsed arguments for completeness and consistency
+ */
+function validateArguments(args: CliArgs): void {
+  // Check required parameters
+  if (!args.taskId) {
+    throw new Error('Missing required parameter: --task-id');
+  }
+
+  if (!args.mode) {
+    throw new Error('Missing required parameter: --mode');
+  }
+
+  if (args.maxIterations === undefined) {
+    throw new Error('Missing required parameter: --max-iterations');
+  }
+
+  // Validate ranges
+  if (args.maxIterations < 1 || args.maxIterations > 100) {
+    throw new Error(`max-iterations must be between 1 and 100, got ${args.maxIterations}`);
+  }
+}
+
+/**
+ * Build orchestration configuration from CLI arguments
+ */
+function buildConfig(args: CliArgs): OrchestrationConfig {
+  const config: OrchestrationConfig = {
+    taskId: args.taskId!,
+    mode: args.mode || 'standard',
+    maxIterations: args.maxIterations || 10,
+  };
+
+  // Add optional parameters if provided
+  if (args.loop3Agents && args.loop3Agents.length > 0) {
+    config.loop3Agents = args.loop3Agents;
+  }
+
+  if (args.loop2Agents && args.loop2Agents.length > 0) {
+    config.loop2Agents = args.loop2Agents;
+  }
+
+  if (args.productOwner) {
+    config.productOwner = args.productOwner;
+  }
+
+  if (args.successCriteriaEnabled !== undefined) {
+    config.successCriteriaEnabled = args.successCriteriaEnabled;
+  }
+
+  if (args.workspace) {
+    config.workspace = args.workspace;
+  }
+
+  if (args.taskDescription) {
+    config.taskDescription = args.taskDescription;
+  }
+
+  return config;
+}
+
+/**
+ * Print usage information
+ */
+function printHelp(): void {
+  console.log(`
+CFN Loop Orchestrator CLI - TypeScript Implementation
+Version: 1.0.0
+
+USAGE:
+  orchestrator-cli [OPTIONS]
+
+REQUIRED OPTIONS:
+  --task-id <id>              Unique task identifier (alphanumeric, hyphens, underscores)
+  --mode <mode>               Execution mode: mvp, standard, or enterprise
+  --max-iterations <n>        Maximum iteration cycles (1-100)
+
+OPTIONAL OPTIONS:
+  --loop3-agents <agents>     Comma-separated agent IDs for Loop 3 (implementation)
+  --loop2-agents <agents>     Comma-separated agent IDs for Loop 2 (validation)
+  --product-owner <agent>     Agent ID for Product Owner decision
+  --success-criteria <flag>   Enable success criteria validation (enabled/disabled)
+
+INFORMATIONAL OPTIONS:
+  --help, -h                  Show this help message
+  --version, -v               Show version information
+
+EXAMPLES:
+  # Basic invocation
+  orchestrator-cli --task-id task123 --mode standard --max-iterations 10
+
+  # With agent specifications
+  orchestrator-cli \
+    --task-id auth-feature \
+    --mode standard \
+    --max-iterations 5 \
+    --loop3-agents backend-dev,coder \
+    --loop2-agents code-reviewer,tester \
+    --product-owner cto-agent
+
+  # With success criteria enabled
+  orchestrator-cli \
+    --task-id task456 \
+    --mode enterprise \
+    --max-iterations 15 \
+    --success-criteria enabled
+
+EXIT CODES:
+  0   = Success (PROCEED decision)
+  1   = Failure (error or ABORT decision)
+  130 = Interrupted (SIGINT/SIGTERM)
+`);
+}
+
+/**
+ * Print version information
+ */
+function printVersion(): void {
+  console.log('CFN Loop Orchestrator CLI v1.0.0');
+}
+
+/**
+ * Main entry point
+ */
+async function main(): Promise<void> {
+  const logger = new Logger('orchestrator-cli');
+
+  try {
+    // Parse command-line arguments
+    const cliArgs = parseArguments(process.argv.slice(2));
+
+    // Validate parsed arguments
+    validateArguments(cliArgs);
+
+    // Build configuration
+    const config = buildConfig(cliArgs);
+
+    logger.info(`Orchestrator starting with task ID: ${config.taskId}`);
+    logger.debug(`Configuration: ${JSON.stringify(config, null, 2)}`);
+
+    // Create and initialize orchestrator
+    const orchestrator = new Orchestrator(config);
+
+    // Execute the complete CFN Loop orchestration workflow
+    const finalDecision = await orchestrator.execute();
+
+    // Output final summary as JSON
+    const summary = orchestrator.getSummary();
+    console.log('\n' + '='.repeat(60));
+    console.log('ORCHESTRATION COMPLETE');
+    console.log('='.repeat(60));
+    console.log(JSON.stringify(summary, null, 2));
+
+    // Exit with code based on decision
+    // 0 = PROCEED (success)
+    // 1 = ITERATE/ABORT (failure)
+    const exitCode = finalDecision === 'PROCEED' ? 0 : 1;
+    process.exit(exitCode);
+  } catch (error) {
+    // Handle errors
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.error(`Error: ${errorMessage}`);
+
+    // Print usage hint for parameter errors
+    if (
+      errorMessage.includes('Missing required parameter') ||
+      errorMessage.includes('Invalid') ||
+      errorMessage.includes('Invalid mode') ||
+      errorMessage.includes('Invalid max-iterations')
+    ) {
+      console.error('\nUse --help for usage information');
+    }
+
+    process.exit(1);
+  }
+}
+
+/**
+ * Handle process signals for graceful shutdown
+ */
+process.on('SIGINT', () => {
+  console.error('\nOrchestrator interrupted by user');
+  process.exit(130);
+});
+
+process.on('SIGTERM', () => {
+  console.error('\nOrchestrator terminated');
+  process.exit(130);
+});
+
+// Run main function
+if (require.main === module) {
+  main().catch((error) => {
+    console.error('Fatal error:', error);
+    process.exit(1);
+  });
+}
+
+export { parseArguments, validateArguments, buildConfig };