claude-flow-novice 2.15.5 → 2.15.7

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

@@ -0,0 +1,382 @@
+import { parseTestResults } from '../src/helpers/parse-test-results';
+
+describe('parseTestResults', () => {
+  describe('Jest parser', () => {
+    it('should parse passing Jest output', () => {
+      const jestOutput = `
+        PASS tests/example.test.ts
+        ✓ test case 1 (5 ms)
+        ✓ test case 2 (3 ms)
+
+        Test Suites: 1 passed, 1 total
+        Tests:       2 passed, 2 total
+        Time:        1.234 s
+      `;
+
+      const result = parseTestResults('jest', jestOutput);
+
+      expect(result.framework).toBe('jest');
+      expect(result.total).toBe(2);
+      expect(result.passed).toBe(2);
+      expect(result.failed).toBe(0);
+      expect(result.skipped).toBe(0);
+      expect(result.passRate).toBeCloseTo(1.0, 4);
+      expect(result.durationMs).toBeGreaterThan(0);
+    });
+
+    it('should parse failing Jest output', () => {
+      const jestOutput = `
+        FAIL tests/example.test.ts
+        ✓ test case 1 (5 ms)
+        ✕ test case 2 (3 ms)
+        ✕ test case 3 (2 ms)
+
+        ● test case 2
+        ● test case 3
+
+        Test Suites: 1 failed, 1 total
+        Tests:       1 passed, 2 failed, 3 total
+        Time:        0.567 s
+      `;
+
+      const result = parseTestResults('jest', jestOutput);
+
+      expect(result.framework).toBe('jest');
+      expect(result.total).toBe(3);
+      expect(result.passed).toBe(1);
+      expect(result.failed).toBe(2);
+      expect(result.passRate).toBeCloseTo(0.3333, 4);
+      expect(result.failedTestNames).toEqual(['test case 2', 'test case 3']);
+    });
+
+    it('should handle Jest output with skipped tests', () => {
+      const jestOutput = `
+        Tests:       2 passed, 1 skipped, 3 total
+      `;
+
+      const result = parseTestResults('jest', jestOutput);
+
+      expect(result.total).toBe(3);
+      expect(result.passed).toBe(2);
+      expect(result.skipped).toBe(1);
+      expect(result.passRate).toBeCloseTo(0.6667, 4);
+    });
+
+    it('should handle invalid Jest output', () => {
+      const result = parseTestResults('jest', 'invalid output');
+
+      expect(result.total).toBe(0);
+      expect(result.passed).toBe(0);
+      expect(result.failed).toBe(0);
+      expect(result.passRate).toBe(0.0);
+    });
+  });
+
+  describe('Mocha parser', () => {
+    it('should parse passing Mocha output', () => {
+      const mochaOutput = `
+        ✓ test case 1
+        ✓ test case 2
+
+        2 passing (150ms)
+      `;
+
+      const result = parseTestResults('mocha', mochaOutput);
+
+      expect(result.framework).toBe('mocha');
+      expect(result.total).toBe(2);
+      expect(result.passed).toBe(2);
+      expect(result.failed).toBe(0);
+      expect(result.passRate).toBe(1.0);
+      expect(result.durationMs).toBe(150);
+    });
+
+    it('should parse failing Mocha output', () => {
+      const mochaOutput = `
+        ✓ test case 1
+        1) test case 2: AssertionError
+        2) test case 3: Error
+
+        1 passing (100ms)
+        2 failing
+      `;
+
+      const result = parseTestResults('mocha', mochaOutput);
+
+      expect(result.total).toBe(3);
+      expect(result.passed).toBe(1);
+      expect(result.failed).toBe(2);
+      expect(result.passRate).toBeCloseTo(0.3333, 4);
+      expect(result.failedTestNames).toHaveLength(2);
+    });
+
+    it('should parse Mocha output with pending tests', () => {
+      const mochaOutput = `
+        2 passing (50ms)
+        1 pending
+      `;
+
+      const result = parseTestResults('mocha', mochaOutput);
+
+      expect(result.total).toBe(3);
+      expect(result.passed).toBe(2);
+      expect(result.skipped).toBe(1);
+    });
+
+    it('should handle time in seconds', () => {
+      const mochaOutput = `
+        5 passing (2.5s)
+      `;
+
+      const result = parseTestResults('mocha', mochaOutput);
+
+      expect(result.durationMs).toBe(2500);
+    });
+  });
+
+  describe('Pytest parser', () => {
+    it('should parse passing pytest output', () => {
+      const pytestOutput = `
+        test_example.py::test_case_1 PASSED
+        test_example.py::test_case_2 PASSED
+
+        ====== 2 passed in 0.45s ======
+      `;
+
+      const result = parseTestResults('pytest', pytestOutput);
+
+      expect(result.framework).toBe('pytest');
+      expect(result.total).toBe(2);
+      expect(result.passed).toBe(2);
+      expect(result.failed).toBe(0);
+      expect(result.passRate).toBe(1.0);
+      expect(result.durationMs).toBe(450);
+    });
+
+    it('should parse failing pytest output', () => {
+      const pytestOutput = `
+        test_example.py::test_case_1 PASSED
+        test_example.py::test_case_2 FAILED
+
+        FAILED test_example.py::test_case_2
+
+        1 passed, 1 failed in 1.23s
+      `;
+
+      const result = parseTestResults('pytest', pytestOutput);
+
+      expect(result.total).toBe(2);
+      expect(result.passed).toBe(1);
+      expect(result.failed).toBe(1);
+      expect(result.passRate).toBe(0.5);
+      expect(result.failedTestNames).toContain('test_example.py::test_case_2');
+    });
+
+    it('should parse pytest output with skipped tests', () => {
+      const pytestOutput = `
+        2 passed, 1 skipped in 0.5s
+      `;
+
+      const result = parseTestResults('pytest', pytestOutput);
+
+      expect(result.total).toBe(3);
+      expect(result.skipped).toBe(1);
+    });
+  });
+
+  describe('TAP parser', () => {
+    it('should parse passing TAP output', () => {
+      const tapOutput = `
+        1..3
+        ok 1 - test case 1
+        ok 2 - test case 2
+        ok 3 - test case 3
+      `;
+
+      const result = parseTestResults('tap', tapOutput);
+
+      expect(result.framework).toBe('tap');
+      expect(result.total).toBe(3);
+      expect(result.passed).toBe(3);
+      expect(result.failed).toBe(0);
+      expect(result.passRate).toBe(1.0);
+    });
+
+    it('should parse failing TAP output', () => {
+      const tapOutput = `
+        1..4
+        ok 1 - test case 1
+        not ok 2 - test case 2
+        ok 3 - test case 3
+        not ok 4 - test case 4
+      `;
+
+      const result = parseTestResults('tap', tapOutput);
+
+      expect(result.total).toBe(4);
+      expect(result.passed).toBe(2);
+      expect(result.failed).toBe(2);
+      expect(result.passRate).toBe(0.5);
+      expect(result.failedTestNames).toHaveLength(2);
+    });
+
+    it('should parse TAP output with skipped tests', () => {
+      const tapOutput = `
+        1..3
+        ok 1 - test case 1
+        ok 2 - test case 2 # SKIP not implemented
+        ok 3 - test case 3
+      `;
+
+      const result = parseTestResults('tap', tapOutput);
+
+      expect(result.total).toBe(3);
+      expect(result.passed).toBe(2);
+      expect(result.skipped).toBe(1);
+    });
+  });
+
+  describe('Go test parser', () => {
+    it('should parse passing Go test output', () => {
+      const goOutput = `
+        --- PASS: TestExample1 (0.00s)
+        --- PASS: TestExample2 (0.01s)
+        PASS
+        ok  	example/package	0.123s
+      `;
+
+      const result = parseTestResults('go', goOutput);
+
+      expect(result.framework).toBe('go');
+      expect(result.total).toBe(2);
+      expect(result.passed).toBe(2);
+      expect(result.failed).toBe(0);
+      expect(result.passRate).toBe(1.0);
+      expect(result.durationMs).toBe(123);
+    });
+
+    it('should parse failing Go test output', () => {
+      const goOutput = `
+        --- PASS: TestExample1 (0.00s)
+        --- FAIL: TestExample2 (0.01s)
+        --- FAIL: TestExample3 (0.00s)
+        FAIL
+        ok  	example/package	0.234s
+      `;
+
+      const result = parseTestResults('go', goOutput);
+
+      expect(result.total).toBe(3);
+      expect(result.passed).toBe(1);
+      expect(result.failed).toBe(2);
+      expect(result.passRate).toBeCloseTo(0.3333, 4);
+      expect(result.failedTestNames).toHaveLength(2);
+    });
+
+    it('should parse Go output with skipped tests', () => {
+      const goOutput = `
+        --- PASS: TestExample1 (0.00s)
+        --- SKIP: TestExample2 (0.00s)
+        ok  	example/package	0.1s
+      `;
+
+      const result = parseTestResults('go', goOutput);
+
+      expect(result.total).toBe(2);
+      expect(result.passed).toBe(1);
+      expect(result.skipped).toBe(1);
+    });
+  });
+
+  describe('Auto-detect framework', () => {
+    it('should auto-detect Jest output', () => {
+      const jestOutput = `
+        Test Suites: 1 passed, 1 total
+        Tests:       5 passed, 5 total
+      `;
+
+      const result = parseTestResults('auto', jestOutput);
+
+      expect(result.framework).toBe('jest');
+      expect(result.total).toBe(5);
+    });
+
+    it('should auto-detect Mocha output', () => {
+      const mochaOutput = `
+        3 passing (100ms)
+        1 failing
+      `;
+
+      const result = parseTestResults('auto', mochaOutput);
+
+      expect(result.framework).toBe('mocha');
+      expect(result.total).toBe(4);
+    });
+
+    it('should auto-detect pytest output', () => {
+      const pytestOutput = `
+        ====== 5 passed in 1.2s ======
+      `;
+
+      const result = parseTestResults('auto', pytestOutput);
+
+      expect(result.framework).toBe('pytest');
+    });
+
+    it('should auto-detect TAP output', () => {
+      const tapOutput = `
+        1..10
+        ok 1 - test
+      `;
+
+      const result = parseTestResults('auto', tapOutput);
+
+      expect(result.framework).toBe('tap');
+    });
+
+    it('should auto-detect Go test output', () => {
+      const goOutput = `
+        --- PASS: TestExample (0.00s)
+        PASS
+      `;
+
+      const result = parseTestResults('auto', goOutput);
+
+      expect(result.framework).toBe('go');
+    });
+
+    it('should return unknown for unrecognized output', () => {
+      const result = parseTestResults('auto', 'completely random output');
+
+      expect(result.framework).toBe('unknown');
+      expect(result.total).toBe(0);
+    });
+  });
+
+  describe('Edge cases', () => {
+    it('should handle empty output', () => {
+      const result = parseTestResults('jest', '');
+
+      expect(result.total).toBe(0);
+      expect(result.passRate).toBe(0.0);
+    });
+
+    it('should handle zero tests', () => {
+      const jestOutput = `
+        Tests:       0 total
+      `;
+
+      const result = parseTestResults('jest', jestOutput);
+
+      expect(result.total).toBe(0);
+      expect(result.passRate).toBe(0.0);
+    });
+
+    it('should preserve raw output', () => {
+      const rawOutput = 'test output here';
+      const result = parseTestResults('jest', rawOutput);
+
+      expect(result.raw).toBe(rawOutput);
+    });
+  });
+});

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

@@ -0,0 +1,22 @@
+/**
+ * Jest test setup and global configuration
+ */
+
+// Mock environment variables
+process.env.CFN_REDIS_HOST = process.env.CFN_REDIS_HOST || 'localhost';
+process.env.CFN_REDIS_PORT = process.env.CFN_REDIS_PORT || '6379';
+process.env.NODE_ENV = 'test';
+
+// Suppress console logs in tests unless explicitly needed
+const originalLog = console.log;
+const originalWarn = console.warn;
+
+beforeAll((): void => {
+  console.log = jest.fn();
+  console.warn = jest.fn();
+});
+
+afterAll((): void => {
+  console.log = originalLog;
+  console.warn = originalWarn;
+});

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

@@ -0,0 +1,118 @@
+/**
+ * Timeout Calculator Tests
+ * Tests for calculating mode and phase-specific timeouts
+ */
+
+import { calculateTimeout, Mode } from '../src/helpers/timeout-calculator';
+
+describe('timeout-calculator', () => {
+  describe('mode-based timeouts', () => {
+    it('should calculate timeout for mvp mode', () => {
+      const timeout = calculateTimeout({ mode: 'mvp' });
+      expect(timeout).toBe(1800); // 30 min
+    });
+
+    it('should calculate timeout for standard mode', () => {
+      const timeout = calculateTimeout({ mode: 'standard' });
+      expect(timeout).toBe(3600); // 60 min
+    });
+
+    it('should calculate timeout for enterprise mode', () => {
+      const timeout = calculateTimeout({ mode: 'enterprise' });
+      expect(timeout).toBe(7200); // 120 min
+    });
+  });
+
+  describe('phase multipliers', () => {
+    it('should apply phase-1 multiplier (1x)', () => {
+      const timeout = calculateTimeout({ mode: 'standard', phase: 'phase-1' });
+      expect(timeout).toBe(3600); // 60 min * 1.0
+    });
+
+    it('should apply phase-2 multiplier (1.5x)', () => {
+      const timeout = calculateTimeout({ mode: 'standard', phase: 'phase-2' });
+      expect(timeout).toBe(5400); // 60 min * 1.5
+    });
+
+    it('should apply phase-3 multiplier (2x)', () => {
+      const timeout = calculateTimeout({ mode: 'standard', phase: 'phase-3' });
+      expect(timeout).toBe(7200); // 60 min * 2.0
+    });
+
+    it('should apply phase-4 multiplier (1.0x)', () => {
+      const timeout = calculateTimeout({ mode: 'standard', phase: 'phase-4' });
+      expect(timeout).toBe(3600); // 60 min * 1.0
+    });
+  });
+
+  describe('combined mode and phase calculations', () => {
+    it('should calculate mvp mode with phase-2', () => {
+      const timeout = calculateTimeout({ mode: 'mvp', phase: 'phase-2' });
+      expect(timeout).toBe(2700); // 30 min * 1.5
+    });
+
+    it('should calculate mvp mode with phase-3', () => {
+      const timeout = calculateTimeout({ mode: 'mvp', phase: 'phase-3' });
+      expect(timeout).toBe(3600); // 30 min * 2.0
+    });
+
+    it('should calculate enterprise mode with phase-2', () => {
+      const timeout = calculateTimeout({ mode: 'enterprise', phase: 'phase-2' });
+      expect(timeout).toBe(10800); // 120 min * 1.5
+    });
+
+    it('should calculate enterprise mode with phase-3', () => {
+      const timeout = calculateTimeout({ mode: 'enterprise', phase: 'phase-3' });
+      expect(timeout).toBe(14400); // 120 min * 2.0
+    });
+  });
+
+  describe('edge cases', () => {
+    it('should use base timeout when no phase specified', () => {
+      const timeout = calculateTimeout({ mode: 'standard' });
+      expect(timeout).toBe(3600); // No multiplier
+    });
+
+    it('should use base timeout for unknown phase', () => {
+      const timeout = calculateTimeout({ mode: 'standard', phase: 'unknown-phase' });
+      expect(timeout).toBe(3600); // Default multiplier = 1.0
+    });
+
+    it('should handle phase with different casing', () => {
+      const timeout = calculateTimeout({ mode: 'standard', phase: 'PHASE-2' });
+      expect(timeout).toBe(5400); // Case-insensitive
+    });
+  });
+
+  describe('timeout consistency', () => {
+    it('should return same timeout for same inputs', () => {
+      const timeout1 = calculateTimeout({ mode: 'standard', phase: 'phase-2' });
+      const timeout2 = calculateTimeout({ mode: 'standard', phase: 'phase-2' });
+      expect(timeout1).toBe(timeout2);
+    });
+
+    it('should return integer values', () => {
+      const modes: Mode[] = ['mvp', 'standard', 'enterprise'];
+      const phases = ['phase-1', 'phase-2', 'phase-3', 'phase-4'];
+
+      modes.forEach(mode => {
+        phases.forEach(phase => {
+          const timeout = calculateTimeout({ mode, phase });
+          expect(Number.isInteger(timeout)).toBe(true);
+        });
+      });
+    });
+  });
+
+  describe('timeout ranges', () => {
+    it('should have minimum timeout of 1800 seconds (30 min)', () => {
+      const timeout = calculateTimeout({ mode: 'mvp' });
+      expect(timeout).toBeGreaterThanOrEqual(1800);
+    });
+
+    it('should have maximum timeout of 14400 seconds (240 min)', () => {
+      const timeout = calculateTimeout({ mode: 'enterprise', phase: 'phase-3' });
+      expect(timeout).toBeLessThanOrEqual(14400);
+    });
+  });
+});

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

@@ -0,0 +1,132 @@
+/**
+ * Tests for core type definitions and utilities
+ */
+
+import {
+  isValidExecutionMode,
+  isValidProductOwnerDecision,
+  getModeConfig,
+  calculatePassRate,
+  MODE_CONFIG,
+} from '../src/types';
+
+describe('Type Guards and Validators', (): void => {
+  describe('isValidExecutionMode', (): void => {
+    it('should validate standard execution mode', (): void => {
+      expect(isValidExecutionMode('standard')).toBe(true);
+    });
+
+    it('should validate mvp execution mode', (): void => {
+      expect(isValidExecutionMode('mvp')).toBe(true);
+    });
+
+    it('should validate enterprise execution mode', (): void => {
+      expect(isValidExecutionMode('enterprise')).toBe(true);
+    });
+
+    it('should reject invalid execution mode', (): void => {
+      expect(isValidExecutionMode('invalid')).toBe(false);
+    });
+
+    it('should reject non-string values', (): void => {
+      expect(isValidExecutionMode(123)).toBe(false);
+      expect(isValidExecutionMode(null)).toBe(false);
+      expect(isValidExecutionMode(undefined)).toBe(false);
+    });
+  });
+
+  describe('isValidProductOwnerDecision', (): void => {
+    it('should validate PROCEED decision', (): void => {
+      expect(isValidProductOwnerDecision('PROCEED')).toBe(true);
+    });
+
+    it('should validate ITERATE decision', (): void => {
+      expect(isValidProductOwnerDecision('ITERATE')).toBe(true);
+    });
+
+    it('should validate ABORT decision', (): void => {
+      expect(isValidProductOwnerDecision('ABORT')).toBe(true);
+    });
+
+    it('should reject invalid decision', (): void => {
+      expect(isValidProductOwnerDecision('SKIP')).toBe(false);
+    });
+
+    it('should be case-sensitive', (): void => {
+      expect(isValidProductOwnerDecision('proceed')).toBe(false);
+    });
+  });
+});
+
+describe('Mode Configuration', (): void => {
+  describe('getModeConfig', (): void => {
+    it('should return MVP config', (): void => {
+      const config = getModeConfig('mvp');
+      expect(config.testPassRateGate).toBe(0.7);
+      expect(config.consensusThreshold).toBe(0.8);
+      expect(config.maxIterations).toBe(5);
+      expect(config.validatorCount).toBe(2);
+    });
+
+    it('should return Standard config', (): void => {
+      const config = getModeConfig('standard');
+      expect(config.testPassRateGate).toBe(0.95);
+      expect(config.consensusThreshold).toBe(0.9);
+      expect(config.maxIterations).toBe(10);
+      expect(config.validatorCount).toBe(3);
+    });
+
+    it('should return Enterprise config', (): void => {
+      const config = getModeConfig('enterprise');
+      expect(config.testPassRateGate).toBe(0.98);
+      expect(config.consensusThreshold).toBe(0.95);
+      expect(config.maxIterations).toBe(15);
+      expect(config.validatorCount).toBe(5);
+    });
+  });
+
+  describe('MODE_CONFIG constant', (): void => {
+    it('should contain all execution modes', (): void => {
+      expect(MODE_CONFIG).toHaveProperty('mvp');
+      expect(MODE_CONFIG).toHaveProperty('standard');
+      expect(MODE_CONFIG).toHaveProperty('enterprise');
+    });
+
+    it('should have valid thresholds', (): void => {
+      Object.values(MODE_CONFIG).forEach((config): void => {
+        expect(config.testPassRateGate).toBeGreaterThanOrEqual(0);
+        expect(config.testPassRateGate).toBeLessThanOrEqual(1);
+        expect(config.consensusThreshold).toBeGreaterThanOrEqual(0);
+        expect(config.consensusThreshold).toBeLessThanOrEqual(1);
+      });
+    });
+  });
+});
+
+describe('Pass Rate Calculation', (): void => {
+  it('should calculate pass rate correctly', (): void => {
+    const result = { pass: 80, fail: 20 };
+    expect(calculatePassRate(result)).toBe(0.8);
+  });
+
+  it('should handle zero total with skip', (): void => {
+    const result = { pass: 95, fail: 5, skip: 10 };
+    // 95 / (95 + 5 + 10) = 95 / 110 = 0.8636...
+    expect(calculatePassRate(result)).toBeCloseTo(0.8636, 2);
+  });
+
+  it('should return 0 for zero total', (): void => {
+    const result = { pass: 0, fail: 0 };
+    expect(calculatePassRate(result)).toBe(0);
+  });
+
+  it('should handle all passing', (): void => {
+    const result = { pass: 100, fail: 0 };
+    expect(calculatePassRate(result)).toBe(1);
+  });
+
+  it('should handle all failing', (): void => {
+    const result = { pass: 0, fail: 100 };
+    expect(calculatePassRate(result)).toBe(0);
+  });
+});

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

@@ -0,0 +1,54 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "lib": ["ES2022"],
+    "declaration": true,
+    "declarationMap": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "baseUrl": "./src",
+    "paths": {
+      "@orchestrator/*": ["orchestrator/*"],
+      "@gate-checker/*": ["gate-checker/*"],
+      "@agent-spawner/*": ["agent-spawner/*"],
+      "@redis/*": ["redis/*"],
+      "@utils/*": ["utils/*"],
+      "@types/*": ["types/*"]
+    },
+    "strict": true,
+    "strictNullChecks": true,
+    "strictFunctionTypes": true,
+    "strictPropertyInitialization": true,
+    "strictBindCallApply": true,
+    "alwaysStrict": true,
+    "noImplicitAny": true,
+    "noImplicitThis": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "allowUnusedLabels": false,
+    "allowUnreachableCode": false,
+    "exactOptionalPropertyTypes": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "moduleResolution": "node",
+    "sourceMap": true,
+    "inlineSourceMap": false,
+    "removeComments": false,
+    "pretty": true
+  },
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist",
+    "**/*.test.ts",
+    "**/*.spec.ts"
+  ]
+}