claude-flow-novice 2.15.6 → 2.15.8

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/helpers/timeout-calculator.ts

@@ -0,0 +1,41 @@
+/**
+ * Timeout Calculator
+ * Calculates mode and phase-specific timeouts for agent execution
+ */
+
+export type Mode = 'mvp' | 'standard' | 'enterprise';
+
+const BASE_TIMEOUTS: Record<Mode, number> = {
+  mvp: 1800,       // 30 minutes
+  standard: 3600,  // 60 minutes
+  enterprise: 7200 // 120 minutes
+};
+
+const PHASE_MULTIPLIERS: Record<string, number> = {
+  'phase-1': 1.0,   // Backend work
+  'phase-2': 1.5,   // React components
+  'phase-3': 2.0,   // Advanced components
+  'phase-4': 1.0    // Testing/integration
+};
+
+/**
+ * Calculates timeout based on mode and optional phase
+ * @param params Mode and optional phase identifier
+ * @returns Timeout in seconds
+ */
+export function calculateTimeout(params: {
+  mode: Mode;
+  phase?: string;
+}): number {
+  const baseTimeout = BASE_TIMEOUTS[params.mode] || BASE_TIMEOUTS.standard;
+
+  if (!params.phase) {
+    return baseTimeout;
+  }
+
+  // Normalize phase to lowercase for case-insensitive matching
+  const normalizedPhase = params.phase.toLowerCase();
+  const multiplier = PHASE_MULTIPLIERS[normalizedPhase] || 1.0;
+
+  return Math.floor(baseTimeout * multiplier);
+}

package/claude-assets/skills/cfn-loop-orchestration/tests/consensus.test.ts

@@ -0,0 +1,142 @@
+/**
+ * Consensus Collection and Validation Tests
+ * Tests for collecting Loop 2 validator scores and checking thresholds
+ */
+
+import { collectConsensus, validateConsensus } from '../src/helpers/consensus';
+
+describe('consensus', () => {
+  describe('collectConsensus', () => {
+    it('should collect scores from multiple validators', () => {
+      const scores = [0.92, 0.95, 0.88];
+      const result = collectConsensus(scores);
+
+      expect(result.scores).toEqual(scores);
+      expect(result.average).toBeCloseTo(0.917, 2);
+      expect(result.count).toBe(3);
+      expect(result.min).toBe(0.88);
+      expect(result.max).toBe(0.95);
+    });
+
+    it('should handle single validator', () => {
+      const scores = [0.85];
+      const result = collectConsensus(scores);
+
+      expect(result.scores).toEqual([0.85]);
+      expect(result.average).toBe(0.85);
+      expect(result.count).toBe(1);
+      expect(result.min).toBe(0.85);
+      expect(result.max).toBe(0.85);
+    });
+
+    it('should reject empty scores array', () => {
+      expect(() => collectConsensus([])).toThrow('No consensus scores provided');
+    });
+
+    it('should reject invalid scores (negative)', () => {
+      expect(() => collectConsensus([-0.5, 0.9])).toThrow('Invalid consensus score');
+    });
+
+    it('should reject invalid scores (>1.0)', () => {
+      expect(() => collectConsensus([0.9, 1.5])).toThrow('Invalid consensus score');
+    });
+
+    it('should handle edge case scores (0.0 and 1.0)', () => {
+      const scores = [0.0, 1.0, 0.5];
+      const result = collectConsensus(scores);
+
+      expect(result.average).toBeCloseTo(0.5, 2);
+      expect(result.min).toBe(0.0);
+      expect(result.max).toBe(1.0);
+    });
+
+    it('should calculate correct average for many validators', () => {
+      const scores = [0.90, 0.92, 0.88, 0.95, 0.91];
+      const result = collectConsensus(scores);
+
+      expect(result.average).toBeCloseTo(0.912, 2);
+      expect(result.count).toBe(5);
+    });
+  });
+
+  describe('validateConsensus', () => {
+    it('should pass when average >= threshold', () => {
+      const result = validateConsensus({
+        average: 0.92,
+        threshold: 0.90,
+        mode: 'standard'
+      });
+
+      expect(result.passed).toBe(true);
+      expect(result.average).toBe(0.92);
+      expect(result.threshold).toBe(0.90);
+      expect(result.gap).toBeCloseTo(0.02, 2);
+    });
+
+    it('should fail when average < threshold', () => {
+      const result = validateConsensus({
+        average: 0.85,
+        threshold: 0.90,
+        mode: 'standard'
+      });
+
+      expect(result.passed).toBe(false);
+      expect(result.gap).toBeCloseTo(-0.05, 2);
+    });
+
+    it('should use mvp mode threshold (0.80)', () => {
+      const result = validateConsensus({
+        average: 0.82,
+        mode: 'mvp'
+      });
+
+      expect(result.passed).toBe(true);
+      expect(result.threshold).toBe(0.80);
+      expect(result.mode).toBe('mvp');
+    });
+
+    it('should use standard mode threshold (0.90)', () => {
+      const result = validateConsensus({
+        average: 0.89,
+        mode: 'standard'
+      });
+
+      expect(result.passed).toBe(false);
+      expect(result.threshold).toBe(0.90);
+      expect(result.mode).toBe('standard');
+    });
+
+    it('should use enterprise mode threshold (0.95)', () => {
+      const result = validateConsensus({
+        average: 0.94,
+        mode: 'enterprise'
+      });
+
+      expect(result.passed).toBe(false);
+      expect(result.threshold).toBe(0.95);
+      expect(result.mode).toBe('enterprise');
+    });
+
+    it('should allow explicit threshold override', () => {
+      const result = validateConsensus({
+        average: 0.88,
+        threshold: 0.85,
+        mode: 'standard'
+      });
+
+      expect(result.passed).toBe(true);
+      expect(result.threshold).toBe(0.85); // Uses explicit, not mode default
+    });
+
+    it('should handle exact threshold match', () => {
+      const result = validateConsensus({
+        average: 0.90,
+        threshold: 0.90,
+        mode: 'standard'
+      });
+
+      expect(result.passed).toBe(true);
+      expect(result.gap).toBe(0);
+    });
+  });
+});