claude-flow-novice 2.15.6 → 2.15.7

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/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, ConsensusResult, ConsensusValidation } 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);
+    });
+  });
+});

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

@@ -0,0 +1,199 @@
+/**
+ * Deliverable Verifier Tests
+ * Tests for verifying expected deliverables exist (prevents "consensus on vapor")
+ */
+
+import { verifyDeliverables, VerificationResult } from '../src/helpers/deliverable-verifier';
+import * as fs from 'fs';
+import * as path from 'path';
+
+describe('deliverable-verifier', () => {
+  describe('file existence verification', () => {
+    it('should verify existing files', () => {
+      const result = verifyDeliverables({
+        files: ['package.json', 'tsconfig.json']
+      });
+
+      expect(result.verified).toBe(true);
+      expect(result.missing).toEqual([]);
+      expect(result.found).toContain('package.json');
+      expect(result.found).toContain('tsconfig.json');
+    });
+
+    it('should detect missing files', () => {
+      const result = verifyDeliverables({
+        files: ['nonexistent-file-12345.txt']
+      });
+
+      expect(result.verified).toBe(false);
+      expect(result.missing).toContain('nonexistent-file-12345.txt');
+      expect(result.found).toEqual([]);
+    });
+
+    it('should detect partial missing files', () => {
+      const result = verifyDeliverables({
+        files: ['package.json', 'nonexistent.txt', 'tsconfig.json']
+      });
+
+      expect(result.verified).toBe(false);
+      expect(result.missing).toEqual(['nonexistent.txt']);
+      expect(result.found).toContain('package.json');
+      expect(result.found).toContain('tsconfig.json');
+    });
+
+    it('should handle empty file list', () => {
+      const result = verifyDeliverables({
+        files: []
+      });
+
+      expect(result.verified).toBe(true);
+      expect(result.missing).toEqual([]);
+      expect(result.found).toEqual([]);
+    });
+  });
+
+  describe('file type validation', () => {
+    it('should verify TypeScript files', () => {
+      const result = verifyDeliverables({
+        files: ['src/helpers/gate-check.ts'],
+        expectedTypes: ['.ts']
+      });
+
+      expect(result.verified).toBe(true);
+    });
+
+    it('should verify shell script files', () => {
+      const result = verifyDeliverables({
+        files: ['helpers/consensus.sh'],
+        expectedTypes: ['.sh']
+      });
+
+      expect(result.verified).toBe(true);
+    });
+
+    it('should reject wrong file types', () => {
+      const result = verifyDeliverables({
+        files: ['package.json'],
+        expectedTypes: ['.ts']
+      });
+
+      expect(result.verified).toBe(false);
+      expect(result.typeErrors).toContain('package.json');
+    });
+
+    it('should allow multiple file types', () => {
+      const result = verifyDeliverables({
+        files: ['package.json', 'tsconfig.json'],
+        expectedTypes: ['.json', '.ts']
+      });
+
+      expect(result.verified).toBe(true);
+    });
+  });
+
+  describe('git change detection', () => {
+    it('should detect when files are created', () => {
+      const result = verifyDeliverables({
+        files: [],
+        requireGitChanges: true
+      });
+
+      // This test depends on actual git state, so we check structure
+      expect(result).toHaveProperty('gitChanges');
+      expect(typeof result.gitChanges).toBe('number');
+    });
+
+    it('should fail when no changes and changes required', () => {
+      // Mock scenario: implementation task with no files
+      const result = verifyDeliverables({
+        files: [],
+        requireGitChanges: true,
+        taskType: 'implementation'
+      });
+
+      // If no files specified and git has no changes, should fail for implementation
+      if (result.gitChanges === 0) {
+        expect(result.verified).toBe(false);
+      }
+    });
+  });
+
+  describe('task type keyword detection', () => {
+    it('should detect implementation keywords', () => {
+      const keywords = ['create', 'build', 'implement', 'add', 'generate'];
+
+      keywords.forEach(keyword => {
+        const result = verifyDeliverables({
+          files: [],
+          taskType: keyword,
+          requireGitChanges: true
+        });
+
+        // Should require git changes for implementation keywords
+        expect(result).toHaveProperty('requiresChanges');
+        if (result.requiresChanges) {
+          expect(result.gitChanges).toBeGreaterThan(-1); // Check git changes were counted
+        }
+      });
+    });
+
+    it('should not require changes for read-only tasks', () => {
+      const result = verifyDeliverables({
+        files: [],
+        taskType: 'analyze',
+        requireGitChanges: false
+      });
+
+      expect(result.verified).toBe(true);
+    });
+  });
+
+  describe('consensus on vapor prevention', () => {
+    it('should fail if implementation task has no deliverables', () => {
+      const result = verifyDeliverables({
+        files: [],
+        taskType: 'implement authentication',
+        requireGitChanges: true
+      });
+
+      // If git has changes, this should pass; otherwise fail
+      if (result.gitChanges === 0) {
+        expect(result.verified).toBe(false);
+        expect(result.reason).toContain('vapor');
+      }
+    });
+
+    it('should pass if implementation task has deliverables', () => {
+      const result = verifyDeliverables({
+        files: ['package.json'], // Existing file as proxy
+        taskType: 'implement feature'
+      });
+
+      expect(result.verified).toBe(true);
+    });
+  });
+
+  describe('verification reporting', () => {
+    it('should provide detailed results', () => {
+      const result = verifyDeliverables({
+        files: ['package.json', 'missing.txt']
+      });
+
+      expect(result).toHaveProperty('verified');
+      expect(result).toHaveProperty('files');
+      expect(result).toHaveProperty('missing');
+      expect(result).toHaveProperty('found');
+      expect(result.files).toEqual(['package.json', 'missing.txt']);
+    });
+
+    it('should track all requested files', () => {
+      const requestedFiles = ['file1.ts', 'file2.ts', 'file3.ts'];
+      const result = verifyDeliverables({
+        files: requestedFiles
+      });
+
+      expect(result.files).toEqual(requestedFiles);
+      expect(result.found.length + result.missing.length).toBe(requestedFiles.length);
+    });
+  });
+});