claude-flow-novice 2.15.5 → 2.15.7

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

@@ -0,0 +1,49 @@
+{
+  "name": "@cfn/loop-orchestration",
+  "version": "3.0.0",
+  "description": "TypeScript implementation of CFN Loop orchestration engine",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "build:watch": "tsc --watch",
+    "dev": "ts-node src/index.ts",
+    "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"
+  },
+  "keywords": [
+    "cfn",
+    "orchestration",
+    "loop",
+    "typescript"
+  ],
+  "author": "CFN Team",
+  "license": "MIT",
+  "dependencies": {
+    "ioredis": "^5.3.2",
+    "dotenv": "^16.3.1"
+  },
+  "devDependencies": {
+    "typescript": "^5.3.3",
+    "@types/node": "^20.10.6",
+    "ts-node": "^10.9.2",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.1",
+    "@types/jest": "^29.5.11",
+    "eslint": "^8.56.0",
+    "@typescript-eslint/parser": "^6.16.0",
+    "@typescript-eslint/eslint-plugin": "^6.16.0",
+    "prettier": "^3.1.1",
+    "jest-mock-extended": "^3.0.5"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/claude-assets/skills/cfn-loop-orchestration/src/agent-spawner/agent-spawner.ts

@@ -0,0 +1,34 @@
+/**
+ * Agent spawner implementation
+ * Spawns specialized agents for loop execution
+ */
+
+import { AgentSpec, ExecutionMode } from '../types';
+
+/**
+ * Agent spawner class - placeholder for migration
+ */
+export class AgentSpawner {
+  /**
+   * Spawn agents for a specific loop and wave
+   */
+  static async spawnAgents(
+    taskId: string,
+    loopNumber: number,
+    agentCount: number,
+    _mode: ExecutionMode
+  ): Promise<AgentSpec[]> {
+    const agents: AgentSpec[] = [];
+
+    for (let i = 0; i < agentCount; i++) {
+      agents.push({
+        id: `${taskId}-loop${loopNumber}-agent${i}`,
+        type: `loop${loopNumber}-agent`,
+        memoryTier: 2,
+        memoryLimit: '1g',
+      });
+    }
+
+    return agents;
+  }
+}

package/claude-assets/skills/cfn-loop-orchestration/src/gate-checker/gate-checker.ts

@@ -0,0 +1,36 @@
+/**
+ * Gate checker implementation
+ * Validates test results against mode-specific thresholds
+ */
+
+import { GateResult, TestResult, getModeConfig, ExecutionMode, calculatePassRate } from '../types';
+
+/**
+ * Gate checker class - placeholder for migration
+ */
+export class GateChecker {
+  /**
+   * Check if test results pass the gate threshold
+   */
+  static checkGate(
+    testResults: Map<string, TestResult>,
+    mode: ExecutionMode
+  ): GateResult {
+    const config = getModeConfig(mode);
+    const passRates: number[] = [];
+
+    testResults.forEach((result: TestResult): void => {
+      passRates.push(calculatePassRate(result));
+    });
+
+    const averagePassRate =
+      passRates.length === 0 ? 0 : passRates.reduce((a, b) => a + b, 0) / passRates.length;
+
+    return {
+      passed: averagePassRate >= config.testPassRateGate,
+      passRate: averagePassRate,
+      threshold: config.testPassRateGate,
+      testResults,
+    };
+  }
+}

package/claude-assets/skills/cfn-loop-orchestration/src/helpers/gate-check.ts

@@ -0,0 +1,115 @@
+/**
+ * Gate Check Helper - Test-Driven Validation
+ * Validates Loop 3 self-assessment against test pass rate thresholds
+ */
+
+export type Mode = 'mvp' | 'standard' | 'enterprise';
+
+export interface GateCheckParams {
+  passRate: number;
+  threshold?: number;
+  mode: Mode;
+}
+
+export interface GateCheckResult {
+  passed: boolean;
+  passRate: number;
+  threshold: number;
+  mode: Mode;
+  gap: number;
+  reason: string;
+}
+
+/**
+ * Mode-specific thresholds
+ */
+const MODE_THRESHOLDS: Record<Mode, number> = {
+  mvp: 0.70,
+  standard: 0.95,
+  enterprise: 0.98,
+};
+
+/**
+ * Get threshold for a specific mode
+ */
+export function getModeThreshold(mode: Mode): number {
+  return MODE_THRESHOLDS[mode];
+}
+
+/**
+ * Perform gate check
+ */
+export function gateCheck(params: GateCheckParams): GateCheckResult {
+  const { passRate, mode } = params;
+
+  // Use custom threshold if provided, otherwise use mode-specific
+  const threshold = params.threshold !== undefined ? params.threshold : getModeThreshold(mode);
+
+  // Determine if gate passed
+  const passed = passRate >= threshold;
+
+  // Calculate gap (threshold - passRate)
+  // Positive gap = need improvement (failing)
+  // Zero gap = exactly at threshold
+  // Negative gap = exceeded threshold (passing)
+  const gap = parseFloat((threshold - passRate).toFixed(4));
+
+  // Generate reason
+  const reason = passed
+    ? `Gate PASSED: Pass rate ${passRate.toFixed(4)} >= threshold ${threshold.toFixed(4)} (${mode} mode)`
+    : `Gate FAILED: Pass rate ${passRate.toFixed(4)} < threshold ${threshold.toFixed(4)} (${mode} mode)`;
+
+  return {
+    passed,
+    passRate,
+    threshold,
+    mode,
+    gap,
+    reason,
+  };
+}
+
+/**
+ * CLI entry point for bash wrapper
+ */
+if (require.main === module) {
+  const args = process.argv.slice(2);
+
+  // Parse command line arguments
+  let passRate = 0;
+  let threshold: number | undefined = undefined;
+  let mode: Mode = 'standard';
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (!arg) continue;
+
+    switch (arg) {
+      case '--pass-rate': {
+        const nextArg = args[++i];
+        if (nextArg) passRate = parseFloat(nextArg);
+        break;
+      }
+      case '--threshold': {
+        const nextArg = args[++i];
+        if (nextArg) threshold = parseFloat(nextArg);
+        break;
+      }
+      case '--mode': {
+        const nextArg = args[++i];
+        if (nextArg) mode = nextArg as Mode;
+        break;
+      }
+    }
+  }
+
+  const params: GateCheckParams = { passRate, mode };
+  if (threshold !== undefined) {
+    params.threshold = threshold;
+  }
+
+  const result = gateCheck(params);
+
+  console.log(JSON.stringify(result, null, 2));
+  process.exit(result.passed ? 0 : 1);
+}

package/claude-assets/skills/cfn-loop-orchestration/src/helpers/parse-test-results.ts

@@ -0,0 +1,372 @@
+/**
+ * Test Results Parser - TypeScript Implementation
+ * Parses test output from multiple testing frameworks
+ */
+
+export type TestFramework = 'jest' | 'mocha' | 'pytest' | 'tap' | 'go' | 'junit' | 'unknown';
+
+export interface TestResults {
+  framework: TestFramework;
+  total: number;
+  passed: number;
+  failed: number;
+  skipped: number;
+  passRate: number;
+  durationMs: number;
+  failedTestNames: string[];
+  raw: string;
+}
+
+/**
+ * Parse Jest test output
+ */
+function parseJestOutput(output: string): TestResults {
+  let total = 0;
+  let passed = 0;
+  let failed = 0;
+  let skipped = 0;
+  let duration = 0;
+  const failedNames: string[] = [];
+
+  // Extract test counts from "Tests:" line
+  const testsLine = output.match(/^\s*Tests:.*$/m)?.[0] || '';
+
+  if (testsLine) {
+    const passedMatch = testsLine.match(/(\d+)\s+passed/);
+    const failedMatch = testsLine.match(/(\d+)\s+failed/);
+    const skippedMatch = testsLine.match(/(\d+)\s+skipped/);
+    const totalMatch = testsLine.match(/(\d+)\s+total/);
+
+    if (passedMatch?.[1]) passed = parseInt(passedMatch[1], 10);
+    if (failedMatch?.[1]) failed = parseInt(failedMatch[1], 10);
+    if (skippedMatch?.[1]) skipped = parseInt(skippedMatch[1], 10);
+    if (totalMatch?.[1]) total = parseInt(totalMatch[1], 10);
+  }
+
+  // Extract duration from "Time:" line
+  const timeMatch = output.match(/Time:\s+([0-9.]+)\s*s/);
+  if (timeMatch?.[1]) {
+    duration = Math.round(parseFloat(timeMatch[1]) * 1000);
+  }
+
+  // Extract failed test names
+  const failedNameMatches = output.matchAll(/●\s+(.+)/g);
+  for (const match of failedNameMatches) {
+    if (match[1]) failedNames.push(match[1].trim());
+  }
+
+  const passRate = total > 0 ? passed / total : 0.0;
+
+  return {
+    framework: 'jest',
+    total,
+    passed,
+    failed,
+    skipped,
+    passRate: parseFloat(passRate.toFixed(4)),
+    durationMs: duration,
+    failedTestNames: failedNames,
+    raw: output,
+  };
+}
+
+/**
+ * Parse Mocha test output
+ */
+function parseMochaOutput(output: string): TestResults {
+  let total = 0;
+  let passed = 0;
+  let failed = 0;
+  let skipped = 0;
+  let duration = 0;
+  const failedNames: string[] = [];
+
+  // Extract test counts
+  const passedMatch = output.match(/(\d+)\s+passing/);
+  const failedMatch = output.match(/(\d+)\s+failing/);
+  const pendingMatch = output.match(/(\d+)\s+pending/);
+
+  if (passedMatch?.[1]) passed = parseInt(passedMatch[1], 10);
+  if (failedMatch?.[1]) failed = parseInt(failedMatch[1], 10);
+  if (pendingMatch?.[1]) skipped = parseInt(pendingMatch[1], 10);
+
+  total = passed + failed + skipped;
+
+  // Extract duration - can be in ms or s
+  const durationMsMatch = output.match(/passing\s*\((\d+)ms\)/);
+  const durationSMatch = output.match(/passing\s*\(([0-9.]+)s\)/);
+
+  if (durationMsMatch?.[1]) {
+    duration = parseInt(durationMsMatch[1], 10);
+  } else if (durationSMatch?.[1]) {
+    duration = Math.round(parseFloat(durationSMatch[1]) * 1000);
+  }
+
+  // Extract failed test names
+  const failedNameMatches = output.matchAll(/^\s*\d+\)\s*(.+):/gm);
+  for (const match of failedNameMatches) {
+    if (match[1]) failedNames.push(match[1].trim());
+  }
+
+  const passRate = total > 0 ? passed / total : 0.0;
+
+  return {
+    framework: 'mocha',
+    total,
+    passed,
+    failed,
+    skipped,
+    passRate: parseFloat(passRate.toFixed(4)),
+    durationMs: duration,
+    failedTestNames: failedNames,
+    raw: output,
+  };
+}
+
+/**
+ * Parse Pytest test output
+ */
+function parsePytestOutput(output: string): TestResults {
+  let total = 0;
+  let passed = 0;
+  let failed = 0;
+  let skipped = 0;
+  let duration = 0;
+  const failedNames: string[] = [];
+
+  // Extract test counts
+  const passedMatch = output.match(/(\d+)\s+passed/);
+  const failedMatch = output.match(/(\d+)\s+failed/);
+  const skippedMatch = output.match(/(\d+)\s+skipped/);
+
+  if (passedMatch?.[1]) passed = parseInt(passedMatch[1], 10);
+  if (failedMatch?.[1]) failed = parseInt(failedMatch[1], 10);
+  if (skippedMatch?.[1]) skipped = parseInt(skippedMatch[1], 10);
+
+  total = passed + failed + skipped;
+
+  // Extract duration
+  const durationMatch = output.match(/in\s+([0-9.]+)s/);
+  if (durationMatch?.[1]) {
+    duration = Math.round(parseFloat(durationMatch[1]) * 1000);
+  }
+
+  // Extract failed test names
+  const failedNameMatches = output.matchAll(/^\s*FAILED\s+([^\s]+)/gm);
+  for (const match of failedNameMatches) {
+    if (match[1]) failedNames.push(match[1].trim());
+  }
+
+  const passRate = total > 0 ? passed / total : 0.0;
+
+  return {
+    framework: 'pytest',
+    total,
+    passed,
+    failed,
+    skipped,
+    passRate: parseFloat(passRate.toFixed(4)),
+    durationMs: duration,
+    failedTestNames: failedNames,
+    raw: output,
+  };
+}
+
+/**
+ * Parse TAP test output
+ */
+function parseTapOutput(output: string): TestResults {
+  let total = 0;
+  let passed = 0;
+  let failed = 0;
+  let skipped = 0;
+  const failedNames: string[] = [];
+
+  // Extract total from plan line (e.g., "1..10")
+  const planMatch = output.match(/^\s*1\.\.(\d+)/m);
+  if (planMatch?.[1]) {
+    total = parseInt(planMatch[1], 10);
+  }
+
+  // Count ok lines (excluding SKIP)
+  const okMatches = output.matchAll(/^\s*ok\s+\d+/gm);
+  let okCount = 0;
+  for (const _ of okMatches) {
+    okCount++;
+  }
+
+  // Count skipped tests
+  const skipMatches = output.matchAll(/^\s*ok\s+\d+.*#\s*SKIP/gm);
+  for (const _ of skipMatches) {
+    skipped++;
+  }
+
+  passed = okCount - skipped;
+
+  // Count not ok lines
+  const notOkMatches = output.matchAll(/^\s*not ok\s+\d+\s+(.+)/gm);
+  for (const match of notOkMatches) {
+    failed++;
+    if (match[1]) failedNames.push(match[1].trim());
+  }
+
+  const passRate = total > 0 ? passed / total : 0.0;
+
+  return {
+    framework: 'tap',
+    total,
+    passed,
+    failed,
+    skipped,
+    passRate: parseFloat(passRate.toFixed(4)),
+    durationMs: 0,
+    failedTestNames: failedNames,
+    raw: output,
+  };
+}
+
+/**
+ * Parse Go test output
+ */
+function parseGoTestOutput(output: string): TestResults {
+  let total = 0;
+  let passed = 0;
+  let failed = 0;
+  let skipped = 0;
+  let duration = 0;
+  const failedNames: string[] = [];
+
+  // Count PASS lines
+  const passMatches = output.matchAll(/^\s*---\s+PASS:\s+(.+)/gm);
+  for (const _ of passMatches) {
+    passed++;
+  }
+
+  // Count FAIL lines
+  const failMatches = output.matchAll(/^\s*---\s+FAIL:\s+(.+)/gm);
+  for (const match of failMatches) {
+    failed++;
+    if (match[1]) failedNames.push(match[1].trim());
+  }
+
+  // Count SKIP lines
+  const skipMatches = output.matchAll(/^\s*---\s+SKIP:/gm);
+  for (const _ of skipMatches) {
+    skipped++;
+  }
+
+  total = passed + failed + skipped;
+
+  // Extract duration
+  const durationMatch = output.match(/ok\s+[^\s]+\s+([0-9.]+)s/);
+  if (durationMatch?.[1]) {
+    duration = Math.round(parseFloat(durationMatch[1]) * 1000);
+  }
+
+  const passRate = total > 0 ? passed / total : 0.0;
+
+  return {
+    framework: 'go',
+    total,
+    passed,
+    failed,
+    skipped,
+    passRate: parseFloat(passRate.toFixed(4)),
+    durationMs: duration,
+    failedTestNames: failedNames,
+    raw: output,
+  };
+}
+
+/**
+ * Auto-detect testing framework from output
+ */
+function autoDetectFramework(output: string): TestFramework {
+  // Jest
+  if (output.match(/Test Suites:/i) || output.match(/PASS\s+.*\.test\.(js|ts)/)) {
+    return 'jest';
+  }
+
+  // Mocha
+  if (output.match(/\d+\s+passing/) && output.match(/\d+\s+failing/)) {
+    return 'mocha';
+  }
+
+  // Pytest
+  if (output.match(/====.*passed.*====/) || output.match(/FAILED.*\.py::/)) {
+    return 'pytest';
+  }
+
+  // TAP
+  if (output.match(/1\.\.\d+/) || output.match(/^ok\s+\d+/m) || output.match(/^not ok\s+\d+/m)) {
+    return 'tap';
+  }
+
+  // Go
+  if (output.match(/---\s+PASS:/) || output.match(/---\s+FAIL:/)) {
+    return 'go';
+  }
+
+  return 'unknown';
+}
+
+/**
+ * Main entry point - parse test results from any framework
+ */
+export function parseTestResults(framework: string, output: string): TestResults {
+  let detectedFramework: TestFramework = framework as TestFramework;
+
+  // Auto-detect if requested
+  if (framework === 'auto') {
+    detectedFramework = autoDetectFramework(output);
+  }
+
+  // Parse based on framework
+  switch (detectedFramework) {
+    case 'jest':
+      return parseJestOutput(output);
+    case 'mocha':
+      return parseMochaOutput(output);
+    case 'pytest':
+      return parsePytestOutput(output);
+    case 'tap':
+      return parseTapOutput(output);
+    case 'go':
+      return parseGoTestOutput(output);
+    default:
+      return {
+        framework: 'unknown',
+        total: 0,
+        passed: 0,
+        failed: 0,
+        skipped: 0,
+        passRate: 0.0,
+        durationMs: 0,
+        failedTestNames: [],
+        raw: output,
+      };
+  }
+}
+
+/**
+ * CLI entry point for bash wrapper
+ */
+if (require.main === module) {
+  const args = process.argv.slice(2);
+
+  if (args.length < 2) {
+    console.error('Usage: parse-test-results.js <framework|auto> <output_file_or_string>');
+    process.exit(1);
+  }
+
+  const framework = args[0];
+  const input = args[1];
+
+  if (!framework || !input) {
+    console.error('Error: framework and input are required');
+    process.exit(1);
+  }
+
+  const result = parseTestResults(framework, input);
+  console.log(JSON.stringify(result, null, 2));
+}

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

@@ -0,0 +1,14 @@
+/**
+ * CFN Loop Orchestration Engine - TypeScript Implementation
+ * Main entry point
+ */
+
+export * from './types';
+export * from './orchestrator/orchestrator';
+export * from './gate-checker/gate-checker';
+export * from './agent-spawner/agent-spawner';
+export * from './redis/redis-coordinator';
+export * from './utils/logger';
+
+// Version
+export const VERSION = '3.0.0';

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

@@ -0,0 +1,31 @@
+/**
+ * Main orchestrator implementation
+ * Coordinates CFN Loop execution with test-driven validation
+ */
+
+import { OrchestrationConfig, OrchestrationResult, ProductOwnerDecision } from '../types';
+
+/**
+ * Main orchestrator class - placeholder for migration
+ */
+export class Orchestrator {
+  private taskId: string;
+
+  constructor(config: OrchestrationConfig) {
+    this.taskId = config.taskId;
+  }
+
+  /**
+   * Execute the orchestration loop
+   */
+  async execute(): Promise<OrchestrationResult> {
+    return {
+      taskId: this.taskId,
+      decision: 'PROCEED' as ProductOwnerDecision,
+      iteration: 0,
+      gateResults: [],
+      consensusScores: [],
+      deliverables: [],
+    };
+  }
+}