claude-flow-novice 2.15.6 → 2.15.8

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

@@ -0,0 +1,197 @@
+/**
+ * Deliverable Verifier Tests
+ * Tests for verifying expected deliverables exist (prevents "consensus on vapor")
+ */
+
+import { verifyDeliverables } from '../src/helpers/deliverable-verifier';
+
+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);
+    });
+  });
+});

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

@@ -0,0 +1,325 @@
+import { gateCheck, GateCheckResult, Mode } from '../src/helpers/gate-check';
+
+describe('gateCheck', () => {
+  describe('Basic gate logic', () => {
+    it('should pass gate when pass rate >= threshold', () => {
+      const result = gateCheck({
+        passRate: 0.96,
+        threshold: 0.95,
+        mode: 'standard',
+      });
+
+      expect(result.passed).toBe(true);
+      expect(result.passRate).toBe(0.96);
+      expect(result.threshold).toBe(0.95);
+      expect(result.mode).toBe('standard');
+      expect(result.reason).toContain('0.96');
+      expect(result.reason).toContain('0.95');
+    });
+
+    it('should fail gate when pass rate < threshold', () => {
+      const result = gateCheck({
+        passRate: 0.85,
+        threshold: 0.95,
+        mode: 'standard',
+      });
+
+      expect(result.passed).toBe(false);
+      expect(result.passRate).toBe(0.85);
+      expect(result.threshold).toBe(0.95);
+      expect(result.gap).toBeCloseTo(0.10, 2);
+    });
+
+    it('should pass gate when pass rate equals threshold', () => {
+      const result = gateCheck({
+        passRate: 0.95,
+        threshold: 0.95,
+        mode: 'standard',
+      });
+
+      expect(result.passed).toBe(true);
+    });
+
+    it('should handle perfect pass rate', () => {
+      const result = gateCheck({
+        passRate: 1.0,
+        threshold: 0.95,
+        mode: 'standard',
+      });
+
+      expect(result.passed).toBe(true);
+      expect(result.gap).toBeCloseTo(-0.05, 2);
+    });
+
+    it('should handle zero pass rate', () => {
+      const result = gateCheck({
+        passRate: 0.0,
+        threshold: 0.95,
+        mode: 'standard',
+      });
+
+      expect(result.passed).toBe(false);
+      expect(result.gap).toBeCloseTo(0.95, 2);
+    });
+  });
+
+  describe('Mode-specific thresholds', () => {
+    it('should use MVP threshold (0.70)', () => {
+      const result = gateCheck({
+        passRate: 0.75,
+        mode: 'mvp',
+      });
+
+      expect(result.threshold).toBe(0.70);
+      expect(result.passed).toBe(true);
+    });
+
+    it('should use Standard threshold (0.95)', () => {
+      const result = gateCheck({
+        passRate: 0.96,
+        mode: 'standard',
+      });
+
+      expect(result.threshold).toBe(0.95);
+      expect(result.passed).toBe(true);
+    });
+
+    it('should use Enterprise threshold (0.98)', () => {
+      const result = gateCheck({
+        passRate: 0.99,
+        mode: 'enterprise',
+      });
+
+      expect(result.threshold).toBe(0.98);
+      expect(result.passed).toBe(true);
+    });
+
+    it('should fail MVP mode when below 0.70', () => {
+      const result = gateCheck({
+        passRate: 0.65,
+        mode: 'mvp',
+      });
+
+      expect(result.passed).toBe(false);
+      expect(result.threshold).toBe(0.70);
+    });
+
+    it('should fail Standard mode when below 0.95', () => {
+      const result = gateCheck({
+        passRate: 0.90,
+        mode: 'standard',
+      });
+
+      expect(result.passed).toBe(false);
+      expect(result.threshold).toBe(0.95);
+    });
+
+    it('should fail Enterprise mode when below 0.98', () => {
+      const result = gateCheck({
+        passRate: 0.97,
+        mode: 'enterprise',
+      });
+
+      expect(result.passed).toBe(false);
+      expect(result.threshold).toBe(0.98);
+    });
+  });
+
+  describe('Custom threshold override', () => {
+    it('should use custom threshold when provided', () => {
+      const result = gateCheck({
+        passRate: 0.88,
+        threshold: 0.85,
+        mode: 'standard',
+      });
+
+      expect(result.threshold).toBe(0.85);
+      expect(result.passed).toBe(true);
+    });
+
+    it('should override mode threshold with custom value', () => {
+      const result = gateCheck({
+        passRate: 0.92,
+        threshold: 0.90,
+        mode: 'enterprise', // Would be 0.98 without override
+      });
+
+      expect(result.threshold).toBe(0.90);
+      expect(result.passed).toBe(true);
+    });
+  });
+
+  describe('Gap calculation', () => {
+    it('should calculate gap correctly when failing', () => {
+      const result = gateCheck({
+        passRate: 0.80,
+        threshold: 0.95,
+        mode: 'standard',
+      });
+
+      expect(result.gap).toBeCloseTo(0.15, 2);
+    });
+
+    it('should have zero gap when passing exactly at threshold', () => {
+      const result = gateCheck({
+        passRate: 0.95,
+        threshold: 0.95,
+        mode: 'standard',
+      });
+
+      expect(result.gap).toBeCloseTo(0.0, 2);
+    });
+
+    it('should have negative gap when exceeding threshold', () => {
+      const result = gateCheck({
+        passRate: 1.0,
+        threshold: 0.95,
+        mode: 'standard',
+      });
+
+      expect(result.gap).toBeCloseTo(-0.05, 2);
+    });
+  });
+
+  describe('Reason generation', () => {
+    it('should provide clear reason for passing', () => {
+      const result = gateCheck({
+        passRate: 0.98,
+        threshold: 0.95,
+        mode: 'standard',
+      });
+
+      expect(result.reason).toMatch(/pass/i);
+      expect(result.reason).toContain('0.98');
+      expect(result.reason).toContain('0.95');
+    });
+
+    it('should provide clear reason for failing', () => {
+      const result = gateCheck({
+        passRate: 0.85,
+        threshold: 0.95,
+        mode: 'standard',
+      });
+
+      expect(result.reason).toMatch(/fail/i);
+      expect(result.reason).toContain('0.85');
+      expect(result.reason).toContain('0.95');
+    });
+
+    it('should include mode in reason', () => {
+      const result = gateCheck({
+        passRate: 0.96,
+        mode: 'standard',
+      });
+
+      expect(result.reason).toMatch(/standard/i);
+    });
+  });
+
+  describe('Edge cases', () => {
+    it('should handle very small differences', () => {
+      const result = gateCheck({
+        passRate: 0.9501,
+        threshold: 0.95,
+        mode: 'standard',
+      });
+
+      expect(result.passed).toBe(true);
+    });
+
+    it('should handle floating point precision', () => {
+      const result = gateCheck({
+        passRate: 0.9499999,
+        threshold: 0.95,
+        mode: 'standard',
+      });
+
+      expect(result.passed).toBe(false);
+    });
+
+    it('should handle threshold at boundaries', () => {
+      const result1 = gateCheck({
+        passRate: 1.0,
+        threshold: 1.0,
+        mode: 'standard',
+      });
+
+      const result2 = gateCheck({
+        passRate: 0.0,
+        threshold: 0.0,
+        mode: 'standard',
+      });
+
+      expect(result1.passed).toBe(true);
+      expect(result2.passed).toBe(true);
+    });
+  });
+
+  describe('Type safety', () => {
+    it('should enforce Mode type', () => {
+      const modes: Mode[] = ['mvp', 'standard', 'enterprise'];
+
+      modes.forEach((mode) => {
+        const result = gateCheck({
+          passRate: 1.0,
+          mode,
+        });
+
+        expect(result.mode).toBe(mode);
+      });
+    });
+
+    it('should return properly typed GateCheckResult', () => {
+      const result: GateCheckResult = gateCheck({
+        passRate: 0.96,
+        mode: 'standard',
+      });
+
+      // Type assertions
+      expect(typeof result.passed).toBe('boolean');
+      expect(typeof result.passRate).toBe('number');
+      expect(typeof result.threshold).toBe('number');
+      expect(typeof result.mode).toBe('string');
+      expect(typeof result.reason).toBe('string');
+      expect(typeof result.gap).toBe('number');
+    });
+  });
+
+  describe('Default mode', () => {
+    it('should default to standard mode when mode not specified', () => {
+      const result = gateCheck({
+        passRate: 0.96,
+        mode: 'standard',
+      });
+
+      expect(result.mode).toBe('standard');
+      expect(result.threshold).toBe(0.95);
+    });
+  });
+
+  describe('Boundary testing', () => {
+    it('should handle MVP boundary (0.70)', () => {
+      const pass = gateCheck({ passRate: 0.70, mode: 'mvp' });
+      const fail = gateCheck({ passRate: 0.6999, mode: 'mvp' });
+
+      expect(pass.passed).toBe(true);
+      expect(fail.passed).toBe(false);
+    });
+
+    it('should handle Standard boundary (0.95)', () => {
+      const pass = gateCheck({ passRate: 0.95, mode: 'standard' });
+      const fail = gateCheck({ passRate: 0.9499, mode: 'standard' });
+
+      expect(pass.passed).toBe(true);
+      expect(fail.passed).toBe(false);
+    });
+
+    it('should handle Enterprise boundary (0.98)', () => {
+      const pass = gateCheck({ passRate: 0.98, mode: 'enterprise' });
+      const fail = gateCheck({ passRate: 0.9799, mode: 'enterprise' });
+
+      expect(pass.passed).toBe(true);
+      expect(fail.passed).toBe(false);
+    });
+  });
+});

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

@@ -0,0 +1,132 @@
+/**
+ * Iteration Manager Tests
+ * Tests for managing CFN Loop iteration transitions and feedback
+ */
+
+import { prepareIteration, wakeAgents } from '../src/helpers/iteration-manager';
+
+describe('iteration-manager', () => {
+  describe('prepareIteration', () => {
+    it('should increment iteration number', () => {
+      const result = prepareIteration({
+        currentIteration: 1,
+        feedback: { issues: ['Fix tests'] }
+      });
+
+      expect(result.nextIteration).toBe(2);
+      expect(result.feedback).toBeDefined();
+      expect(result.feedback.issues).toEqual(['Fix tests']);
+      expect(result.timestamp).toMatch(/^\d{4}-\d{2}-\d{2}T/); // ISO format
+    });
+
+    it('should handle iteration 0 to 1 transition', () => {
+      const result = prepareIteration({
+        currentIteration: 0,
+        feedback: { message: 'Initial iteration' }
+      });
+
+      expect(result.nextIteration).toBe(1);
+    });
+
+    it('should handle high iteration numbers', () => {
+      const result = prepareIteration({
+        currentIteration: 15,
+        feedback: {}
+      });
+
+      expect(result.nextIteration).toBe(16);
+    });
+
+    it('should preserve feedback structure', () => {
+      const complexFeedback = {
+        issues: ['Issue 1', 'Issue 2'],
+        suggestions: ['Suggestion 1'],
+        metadata: { validator: 'code-reviewer', confidence: 0.85 }
+      };
+
+      const result = prepareIteration({
+        currentIteration: 3,
+        feedback: complexFeedback
+      });
+
+      expect(result.feedback).toEqual(complexFeedback);
+    });
+
+    it('should allow empty feedback', () => {
+      const result = prepareIteration({
+        currentIteration: 2,
+        feedback: {}
+      });
+
+      expect(result.nextIteration).toBe(3);
+      expect(result.feedback).toEqual({});
+    });
+
+    it('should generate valid timestamp', () => {
+      const result = prepareIteration({
+        currentIteration: 1,
+        feedback: {}
+      });
+
+      const timestamp = new Date(result.timestamp);
+      expect(timestamp.toString()).not.toBe('Invalid Date');
+    });
+  });
+
+  describe('wakeAgents', () => {
+    it('should prepare wake signals for single agent', () => {
+      const result = wakeAgents(['backend-dev-001']);
+
+      expect(result.signals).toHaveLength(1);
+      expect(result.signals[0]).toContain('backend-dev-001');
+    });
+
+    it('should prepare wake signals for multiple agents', () => {
+      const agentIds = ['backend-dev-001', 'code-reviewer-002', 'tester-003'];
+      const result = wakeAgents(agentIds);
+
+      expect(result.signals).toHaveLength(3);
+      expect(result.signals[0]).toContain('backend-dev-001');
+      expect(result.signals[1]).toContain('code-reviewer-002');
+      expect(result.signals[2]).toContain('tester-003');
+    });
+
+    it('should handle empty agent list', () => {
+      const result = wakeAgents([]);
+
+      expect(result.signals).toEqual([]);
+    });
+
+    it('should generate unique signals for each agent', () => {
+      const agentIds = ['agent-1', 'agent-2', 'agent-3'];
+      const result = wakeAgents(agentIds);
+
+      const uniqueSignals = new Set(result.signals);
+      expect(uniqueSignals.size).toBe(3);
+    });
+
+    it('should include agent ID in each signal', () => {
+      const agentIds = ['test-agent-123'];
+      const result = wakeAgents(agentIds);
+
+      expect(result.signals[0]).toContain('test-agent-123');
+    });
+  });
+
+  describe('integration: prepareIteration + wakeAgents', () => {
+    it('should support iteration workflow', () => {
+      // Prepare next iteration
+      const iteration = prepareIteration({
+        currentIteration: 2,
+        feedback: { issues: ['Fix validation'] }
+      });
+
+      expect(iteration.nextIteration).toBe(3);
+
+      // Wake agents for next iteration
+      const wake = wakeAgents(['dev-1', 'validator-1']);
+
+      expect(wake.signals).toHaveLength(2);
+    });
+  });
+});