claude-flow-novice 2.15.11 → 2.16.1

package/claude-assets/skills/cfn-loop-validation/orchestrate-cfn-loop.sh.backup

@@ -0,0 +1,252 @@
+#!/usr/bin/env bash
+
+##############################################################################
+# CFN Loop Orchestration v1.0.0
+# Manages multi-loop CFN execution with dependency tracking and consensus
+#
+# Usage:
+#   ./orchestrate-cfn-loop.sh --task-id <id> \
+#                             --mode <mvp|standard|enterprise> \
+#                             --loop3-agents <agent1,agent2,...> \
+#                             --loop2-agents <agent1,agent2,...> \
+#                             --product-owner <agent-id> \
+#                             [--max-iterations <n>]
+#
+# CFN Loop Structure:
+#   Loop 3 (Primary Swarm) → Loop 2 (Consensus) → Product Owner Decision
+#
+# Dependency Enforcement:
+#   - Loop 2 agents BLOCK until all Loop 3 agents signal completion
+#   - Product Owner BLOCKS until all Loop 2 agents signal completion
+#   - Uses Redis BLPOP for zero-token waiting
+##############################################################################
+
+set -euo pipefail
+
+# Configuration
+TASK_ID=""
+MODE="standard"
+LOOP3_AGENTS=""
+LOOP2_AGENTS=""
+PRODUCT_OWNER=""
+MAX_ITERATIONS=10
+TIMEOUT=3600  # 1 hour timeout for agent completion
+
+# Thresholds by mode
+declare -A GATE_THRESHOLD=(
+  [mvp]=0.70
+  [standard]=0.75
+  [enterprise]=0.75
+)
+
+declare -A CONSENSUS_THRESHOLD=(
+  [mvp]=0.80
+  [standard]=0.90
+  [enterprise]=0.95
+)
+
+# Parse arguments
+while [[ $# -gt 0 ]]; do
+  case $1 in
+    --task-id)
+      TASK_ID="$2"
+      shift 2
+      ;;
+    --mode)
+      MODE="$2"
+      shift 2
+      ;;
+    --loop3-agents)
+      LOOP3_AGENTS="$2"
+      shift 2
+      ;;
+    --loop2-agents)
+      LOOP2_AGENTS="$2"
+      shift 2
+      ;;
+    --product-owner)
+      PRODUCT_OWNER="$2"
+      shift 2
+      ;;
+    --max-iterations)
+      MAX_ITERATIONS="$2"
+      shift 2
+      ;;
+    *)
+      echo "Unknown option: $1"
+      exit 1
+      ;;
+  esac
+done
+
+# Validation
+if [ -z "$TASK_ID" ] || [ -z "$LOOP3_AGENTS" ] || [ -z "$LOOP2_AGENTS" ] || [ -z "$PRODUCT_OWNER" ]; then
+  echo "Error: Required parameters missing"
+  echo "Usage: $0 --task-id <id> --mode <mode> --loop3-agents <agents> --loop2-agents <agents> --product-owner <agent>"
+  exit 1
+fi
+
+GATE=${GATE_THRESHOLD[$MODE]}
+CONSENSUS=${CONSENSUS_THRESHOLD[$MODE]}
+
+echo "=== CFN Loop Orchestration ==="
+echo "Task ID: $TASK_ID"
+echo "Mode: $MODE (Gate: $GATE, Consensus: $CONSENSUS)"
+echo "Max Iterations: $MAX_ITERATIONS"
+echo ""
+
+# Iteration loop
+for ITERATION in $(seq 1 $MAX_ITERATIONS); do
+  echo "=== Iteration $ITERATION/$MAX_ITERATIONS ==="
+
+  # Step 1: Wait for Loop 3 agents to complete
+  echo "[Loop 3] Waiting for implementers to complete..."
+  IFS=',' read -ra AGENTS <<< "$LOOP3_AGENTS"
+
+  for AGENT in "${AGENTS[@]}"; do
+    DONE_KEY="swarm:${TASK_ID}:${AGENT}:done"
+    echo "  Waiting for $AGENT..."
+
+    # BLPOP with timeout (blocks until agent signals done)
+    RESULT=$(timeout $TIMEOUT redis-cli blpop "$DONE_KEY" 0 2>/dev/null || echo "")
+
+    if [ -z "$RESULT" ]; then
+      echo "  ❌ ERROR: $AGENT timeout after ${TIMEOUT}s"
+      exit 1
+    fi
+
+    echo "  ✅ $AGENT complete"
+  done
+
+  echo "[Loop 3] All implementers complete!"
+  echo ""
+
+  # Step 2: Collect Loop 3 confidence scores
+  echo "[Loop 3] Collecting confidence scores..."
+  LOOP3_CONSENSUS=$(./.claude/skills/cfn-redis-coordination/invoke-waiting-mode.sh collect \
+    --task-id "$TASK_ID" \
+    --agent-ids "$LOOP3_AGENTS" | tail -1)
+
+  echo "[Loop 3] Average confidence: $LOOP3_CONSENSUS"
+
+  # Gate check
+  if (( $(echo "$LOOP3_CONSENSUS < $GATE" | bc -l) )); then
+    echo "❌ Gate FAILED ($LOOP3_CONSENSUS < $GATE)"
+    echo "Decision: RELAUNCH iteration $((ITERATION + 1))"
+
+    # Wake Loop 3 agents for next iteration
+    IFS=',' read -ra AGENTS <<< "$LOOP3_AGENTS"
+    for AGENT in "${AGENTS[@]}"; do
+      ./.claude/skills/cfn-redis-coordination/invoke-waiting-mode.sh wake \
+        --task-id "$TASK_ID" \
+        --agent-id "$AGENT" \
+        --reason "gate_failed" \
+        --iteration $((ITERATION + 1)) \
+        --feedback "Improve confidence from $LOOP3_CONSENSUS to >$GATE"
+    done
+
+    continue  # Next iteration
+  fi
+
+  echo "✅ Gate PASSED ($LOOP3_CONSENSUS >= $GATE)"
+  echo ""
+
+  # Step 3: Wait for Loop 2 validators to complete
+  echo "[Loop 2] Waiting for validators to complete..."
+  IFS=',' read -ra VALIDATORS <<< "$LOOP2_AGENTS"
+
+  for VALIDATOR in "${VALIDATORS[@]}"; do
+    DONE_KEY="swarm:${TASK_ID}:${VALIDATOR}:done"
+    echo "  Waiting for $VALIDATOR..."
+
+    RESULT=$(timeout $TIMEOUT redis-cli blpop "$DONE_KEY" 0 2>/dev/null || echo "")
+
+    if [ -z "$RESULT" ]; then
+      echo "  ❌ ERROR: $VALIDATOR timeout after ${TIMEOUT}s"
+      exit 1
+    fi
+
+    echo "  ✅ $VALIDATOR complete"
+  done
+
+  echo "[Loop 2] All validators complete!"
+  echo ""
+
+  # Step 4: Collect Loop 2 consensus scores
+  echo "[Loop 2] Collecting consensus scores..."
+  LOOP2_CONSENSUS=$(./.claude/skills/cfn-redis-coordination/invoke-waiting-mode.sh collect \
+    --task-id "$TASK_ID" \
+    --agent-ids "$LOOP2_AGENTS" | tail -1)
+
+  echo "[Loop 2] Average consensus: $LOOP2_CONSENSUS"
+
+  # Consensus check
+  if (( $(echo "$LOOP2_CONSENSUS >= $CONSENSUS" | bc -l) )); then
+    echo "✅ CONSENSUS REACHED ($LOOP2_CONSENSUS >= $CONSENSUS)"
+    echo ""
+
+    # Signal Product Owner that consensus is ready
+    DECISION_KEY="swarm:${TASK_ID}:${PRODUCT_OWNER}:consensus-ready"
+    redis-cli lpush "$DECISION_KEY" "{\"iteration\": $ITERATION, \"consensus\": $LOOP2_CONSENSUS}" > /dev/null
+
+    # Wait for Product Owner decision
+    echo "[Product Owner] Waiting for GOAP decision..."
+    DECISION_KEY="swarm:${TASK_ID}:${PRODUCT_OWNER}:decision"
+    DECISION=$(timeout $TIMEOUT redis-cli blpop "$DECISION_KEY" 0 2>/dev/null | tail -1)
+
+    if [ -z "$DECISION" ]; then
+      echo "❌ ERROR: Product Owner timeout"
+      exit 1
+    fi
+
+    DECISION_TYPE=$(echo "$DECISION" | jq -r '.decision')
+
+    echo "[Product Owner] Decision: $DECISION_TYPE"
+
+    if [ "$DECISION_TYPE" = "PROCEED" ]; then
+      echo ""
+      echo "🎉 CFN Loop Complete!"
+      echo "Final Consensus: $LOOP2_CONSENSUS (Iteration $ITERATION)"
+
+      # Wake all agents with completion signal
+      IFS=',' read -ra ALL_AGENTS <<< "$LOOP3_AGENTS,$LOOP2_AGENTS"
+      for AGENT in "${ALL_AGENTS[@]}"; do
+        ./.claude/skills/cfn-redis-coordination/invoke-waiting-mode.sh wake \
+          --task-id "$TASK_ID" \
+          --agent-id "$AGENT" \
+          --reason "cfn_complete" \
+          --iteration "$ITERATION"
+      done
+
+      exit 0
+    fi
+
+  else
+    echo "⚠️ CONSENSUS NOT REACHED ($LOOP2_CONSENSUS < $CONSENSUS)"
+    echo "Decision: RELAUNCH iteration $((ITERATION + 1))"
+    echo ""
+  fi
+
+  # Relaunch next iteration
+  if [ $ITERATION -eq $MAX_ITERATIONS ]; then
+    echo "❌ Maximum iterations ($MAX_ITERATIONS) reached without consensus"
+    exit 1
+  fi
+
+  # Wake all agents for next iteration
+  echo "[Coordinator] Waking agents for iteration $((ITERATION + 1))..."
+  IFS=',' read -ra ALL_AGENTS <<< "$LOOP3_AGENTS,$LOOP2_AGENTS"
+  for AGENT in "${ALL_AGENTS[@]}"; do
+    ./.claude/skills/cfn-redis-coordination/invoke-waiting-mode.sh wake \
+      --task-id "$TASK_ID" \
+      --agent-id "$AGENT" \
+      --reason "cfn_loop_iteration" \
+      --iteration $((ITERATION + 1)) \
+      --feedback "Improve consensus from $LOOP2_CONSENSUS to >=$CONSENSUS"
+  done
+
+  echo ""
+done
+
+echo "❌ CFN Loop failed after $MAX_ITERATIONS iterations"
+exit 1

package/claude-assets/skills/cfn-loop-validation/package.json

@@ -0,0 +1,93 @@
+{
+  "name": "@cfn/loop-validation",
+  "version": "1.0.0",
+  "description": "Unified TypeScript validation module for CFN Loop critical path",
+  "main": "dist/validator.js",
+  "types": "dist/validator.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "build:watch": "tsc --watch",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "lint": "eslint src tests --ext .ts",
+    "lint:fix": "eslint src tests --ext .ts --fix",
+    "format": "prettier --write \"src/**/*.ts\" \"tests/**/*.ts\"",
+    "format:check": "prettier --check \"src/**/*.ts\" \"tests/**/*.ts\"",
+    "type-check": "tsc --noEmit",
+    "clean": "rm -rf dist .eslintcache",
+    "validate-deliverables": "node dist/cli/validate-deliverables.js",
+    "validate-gate": "node dist/cli/validate-gate.js",
+    "detect-vapor": "node dist/cli/detect-vapor.js"
+  },
+  "keywords": [
+    "cfn",
+    "validation",
+    "loop",
+    "typescript",
+    "gate-checking",
+    "deliverables",
+    "consensus",
+    "vapor-detection"
+  ],
+  "author": "CFN Team",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/jest": "^29.5.0",
+    "@types/node": "^20.0.0",
+    "@typescript-eslint/eslint-plugin": "^6.0.0",
+    "@typescript-eslint/parser": "^6.0.0",
+    "eslint": "^8.0.0",
+    "jest": "^29.5.0",
+    "prettier": "^3.0.0",
+    "ts-jest": "^29.1.0",
+    "typescript": "^5.0.0"
+  },
+  "dependencies": {},
+  "jest": {
+    "preset": "ts-jest",
+    "testEnvironment": "node",
+    "roots": [
+      "<rootDir>/tests"
+    ],
+    "testMatch": [
+      "**/__tests__/**/*.ts",
+      "**/?(*.)+(spec|test).ts"
+    ],
+    "collectCoverageFrom": [
+      "src/**/*.ts",
+      "!src/**/*.d.ts",
+      "!src/cli/**"
+    ],
+    "coverageThreshold": {
+      "global": {
+        "branches": 85,
+        "functions": 90,
+        "lines": 90,
+        "statements": 90
+      }
+    }
+  },
+  "eslintConfig": {
+    "parser": "@typescript-eslint/parser",
+    "extends": [
+      "eslint:recommended",
+      "plugin:@typescript-eslint/recommended"
+    ],
+    "parserOptions": {
+      "ecmaVersion": 2020,
+      "sourceType": "module"
+    },
+    "rules": {
+      "@typescript-eslint/no-explicit-any": "warn",
+      "@typescript-eslint/explicit-function-return-types": "warn"
+    }
+  },
+  "prettier": {
+    "semi": true,
+    "trailingComma": "es5",
+    "singleQuote": true,
+    "printWidth": 100,
+    "tabWidth": 2
+  }
+}

package/claude-assets/skills/cfn-loop-validation/src/cli/detect-vapor.ts

@@ -0,0 +1,177 @@
+#!/usr/bin/env node
+
+/**
+ * CLI: Detect Consensus on Vapor
+ *
+ * Detects when agents claim completion but deliverables are missing.
+ *
+ * Usage:
+ *   detect-vapor --output "agent_output.txt" --deliverables file1.js,file2.js [--json]
+ *   detect-vapor --output "Completed the task" --deliverables file1.js,file2.js [--json]
+ *
+ * Returns JSON with vapor detection result
+ */
+
+import * as fs from 'fs';
+import { CFNValidator } from '../validator';
+
+interface CLIOptions {
+  output?: string;
+  outputFile?: string;
+  deliverables?: string;
+  json?: boolean;
+  taskId?: string;
+  mode?: 'mvp' | 'standard' | 'enterprise';
+}
+
+/**
+ * Parse CLI arguments
+ */
+function parseArgs(): CLIOptions {
+  const options: CLIOptions = {
+    json: false,
+    mode: 'standard',
+  };
+
+  for (let i = 2; i < process.argv.length; i++) {
+    const arg = process.argv[i];
+
+    if (arg === '--output' && process.argv[i + 1]) {
+      options.output = process.argv[++i];
+    } else if (arg === '--output-file' && process.argv[i + 1]) {
+      options.outputFile = process.argv[++i];
+    } else if (arg === '--deliverables' && process.argv[i + 1]) {
+      options.deliverables = process.argv[++i];
+    } else if (arg === '--json') {
+      options.json = true;
+    } else if (arg === '--task-id' && process.argv[i + 1]) {
+      options.taskId = process.argv[++i];
+    } else if (arg === '--mode' && process.argv[i + 1]) {
+      options.mode = process.argv[++i] as any;
+    }
+  }
+
+  return options;
+}
+
+/**
+ * Load output from file
+ */
+function loadOutputFromFile(filePath: string): string {
+  try {
+    return fs.readFileSync(filePath, 'utf-8');
+  } catch (error) {
+    console.error(`Error reading output file: ${error}`);
+    process.exit(1);
+  }
+}
+
+/**
+ * Print human-readable output
+ */
+function printHumanOutput(
+  result: Awaited<ReturnType<CFNValidator['detectConsensusOnVapor']>>
+): void {
+  console.log('\nConsensus on Vapor Detection Report:');
+  console.log(`  Vapor Detected: ${result.detected ? 'YES' : 'NO'}`);
+  console.log(`  Detection Confidence: ${(result.confidence * 100).toFixed(2)}%`);
+  console.log(`  Claims Completion: ${result.claimsCompletion ? 'YES' : 'NO'}`);
+  console.log(`  Deliverables Missing: ${result.deliverablesMissing ? 'YES' : 'NO'}`);
+
+  if (result.detected) {
+    console.log('\n  WARNING: Consensus on Vapor Detected!');
+    console.log('  Agent claims completion but deliverables are missing:');
+    for (const missing of result.missingDeliverables) {
+      console.log(`    - ${missing}`);
+    }
+  }
+
+  if (result.missingDeliverables.length > 0) {
+    console.log(`\n  Missing Deliverables (${result.missingDeliverables.length}):`);
+    for (const deliverable of result.missingDeliverables) {
+      console.log(`    - ${deliverable}`);
+    }
+  }
+
+  console.log(`\n  Expected Deliverables (${result.expectedDeliverables.length}):`);
+  for (const deliverable of result.expectedDeliverables) {
+    console.log(`    - ${deliverable}`);
+  }
+
+  console.log(`\n  Status: ${result.detected ? 'VAPOR DETECTED' : 'OK'}`);
+}
+
+/**
+ * Main execution
+ */
+async function main(): Promise<void> {
+  const options = parseArgs();
+
+  // Validate input
+  if (!options.output && !options.outputFile) {
+    console.error('Error: Must provide --output or --output-file');
+    console.error('Usage: detect-vapor --output "output text" --deliverables file1.js,file2.js [--json]');
+    process.exit(1);
+  }
+
+  if (!options.deliverables) {
+    console.error('Error: --deliverables is required');
+    console.error('Usage: detect-vapor --output "output text" --deliverables file1.js,file2.js [--json]');
+    process.exit(1);
+  }
+
+  // Load output
+  let agentOutput = options.output || '';
+  if (options.outputFile) {
+    agentOutput = loadOutputFromFile(options.outputFile);
+  }
+
+  // Parse deliverables
+  const deliverables = options.deliverables
+    .split(',')
+    .map((d) => d.trim())
+    .filter((d) => d);
+
+  if (deliverables.length === 0) {
+    console.error('Error: No deliverables provided');
+    process.exit(1);
+  }
+
+  // Create validator
+  const validator = new CFNValidator({
+    mode: options.mode || 'standard',
+    taskId: options.taskId || 'cli-detect-vapor',
+  });
+
+  try {
+    // Detect vapor
+    const result = await validator.detectConsensusOnVapor(
+      agentOutput,
+      deliverables
+    );
+
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      printHumanOutput(result);
+    }
+
+    // Exit with proper code
+    process.exit(result.detected ? 1 : 0);
+  } catch (error) {
+    if (options.json) {
+      console.error(JSON.stringify({
+        error: error instanceof Error ? error.message : String(error),
+        code: 'DETECTION_ERROR',
+      }));
+    } else {
+      console.error(`Error: ${error}`);
+    }
+    process.exit(1);
+  }
+}
+
+main().catch((error) => {
+  console.error('Fatal error:', error);
+  process.exit(1);
+});

package/claude-assets/skills/cfn-loop-validation/src/cli/validate-deliverables.ts

@@ -0,0 +1,161 @@
+#!/usr/bin/env node
+
+/**
+ * CLI: Validate Deliverables
+ *
+ * Checks if deliverable files exist and are accessible.
+ *
+ * Usage:
+ *   validate-deliverables --paths file1.js,file2.js [--json]
+ *   validate-deliverables --file-list paths.txt [--json]
+ *
+ * Returns JSON with validation results
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import { CFNValidator } from '../validator';
+
+interface CLIOptions {
+  paths?: string;
+  fileList?: string;
+  json?: boolean;
+  taskId?: string;
+  mode?: 'mvp' | 'standard' | 'enterprise';
+}
+
+/**
+ * Parse CLI arguments
+ */
+function parseArgs(): CLIOptions {
+  const options: CLIOptions = {
+    json: false,
+    mode: 'standard',
+  };
+
+  for (let i = 2; i < process.argv.length; i++) {
+    const arg = process.argv[i];
+
+    if (arg === '--paths' && process.argv[i + 1]) {
+      options.paths = process.argv[++i];
+    } else if (arg === '--file-list' && process.argv[i + 1]) {
+      options.fileList = process.argv[++i];
+    } else if (arg === '--json') {
+      options.json = true;
+    } else if (arg === '--task-id' && process.argv[i + 1]) {
+      options.taskId = process.argv[++i];
+    } else if (arg === '--mode' && process.argv[i + 1]) {
+      options.mode = process.argv[++i] as any;
+    }
+  }
+
+  return options;
+}
+
+/**
+ * Load paths from file
+ */
+function loadPathsFromFile(filePath: string): string[] {
+  try {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    return content
+      .split('\n')
+      .map((line) => line.trim())
+      .filter((line) => line && !line.startsWith('#'));
+  } catch (error) {
+    console.error(`Error reading file list: ${error}`);
+    process.exit(1);
+  }
+}
+
+/**
+ * Print human-readable output
+ */
+function printHumanOutput(
+  result: Awaited<ReturnType<CFNValidator['validateDeliverables']>>
+): void {
+  console.log('\nDeliverable Validation Report:');
+  console.log(`  Total files: ${result.totalFiles}`);
+  console.log(`  Existing: ${result.existingFiles}`);
+  console.log(`  Missing: ${result.missingFiles}`);
+  console.log(`  Total size: ${(result.totalSizeBytes / 1024).toFixed(2)} KB`);
+  console.log(`  Status: ${result.allExist ? 'PASS' : 'FAIL'}`);
+  console.log('\nDeliverables:');
+
+  for (const deliverable of result.deliverables) {
+    const status = deliverable.exists ? '✓' : '✗';
+    const size = deliverable.sizeBytes
+      ? ` (${(deliverable.sizeBytes / 1024).toFixed(2)} KB)`
+      : '';
+    const timestamp = deliverable.lastModified
+      ? ` - Modified: ${deliverable.lastModified}`
+      : '';
+    console.log(`  ${status} ${deliverable.path}${size}${timestamp}`);
+
+    if (deliverable.error) {
+      console.log(`    Error: ${deliverable.error}`);
+    }
+  }
+}
+
+/**
+ * Main execution
+ */
+async function main(): Promise<void> {
+  const options = parseArgs();
+
+  // Validate input
+  if (!options.paths && !options.fileList) {
+    console.error('Error: Must provide --paths or --file-list');
+    console.error('Usage: validate-deliverables --paths file1.js,file2.js [--json]');
+    process.exit(1);
+  }
+
+  // Parse paths
+  let paths: string[];
+  if (options.paths) {
+    paths = options.paths.split(',').map((p) => p.trim());
+  } else {
+    paths = loadPathsFromFile(options.fileList!);
+  }
+
+  if (paths.length === 0) {
+    console.error('Error: No paths provided');
+    process.exit(1);
+  }
+
+  // Create validator
+  const validator = new CFNValidator({
+    mode: options.mode || 'standard',
+    taskId: options.taskId || 'cli-validate-deliverables',
+  });
+
+  try {
+    // Validate deliverables
+    const result = await validator.validateDeliverables(paths);
+
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      printHumanOutput(result);
+    }
+
+    // Exit with proper code
+    process.exit(result.allExist ? 0 : 1);
+  } catch (error) {
+    if (options.json) {
+      console.error(JSON.stringify({
+        error: error instanceof Error ? error.message : String(error),
+        code: 'VALIDATION_ERROR',
+      }));
+    } else {
+      console.error(`Error: ${error}`);
+    }
+    process.exit(1);
+  }
+}
+
+main().catch((error) => {
+  console.error('Fatal error:', error);
+  process.exit(1);
+});