claude-flow-novice 2.15.5 → 2.15.7

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

@@ -0,0 +1,72 @@
+/**
+ * Redis coordination implementation
+ * Handles agent communication and synchronization
+ */
+
+/**
+ * Redis coordinator class - placeholder for migration
+ */
+export class RedisCoordinator {
+  /**
+   * Connect to Redis instance
+   */
+  async connect(): Promise<void> {
+    // Placeholder
+  }
+
+  /**
+   * Disconnect from Redis
+   */
+  async disconnect(): Promise<void> {
+    // Placeholder
+  }
+
+  /**
+   * Push message to queue
+   */
+  async lpush(_queue: string, _message: string): Promise<number> {
+    return 0;
+  }
+
+  /**
+   * Blocking pop from queue
+   */
+  async blpop(_queue: string, _timeout: number): Promise<[string, string] | null> {
+    return null;
+  }
+
+  /**
+   * Get all hash values
+   */
+  async hGetAll(_key: string): Promise<Record<string, string>> {
+    return {};
+  }
+
+  /**
+   * Set key-value pair
+   */
+  async set(_key: string, _value: string): Promise<string> {
+    return 'OK';
+  }
+
+  /**
+   * Get value by key
+   */
+  async get(_key: string): Promise<string | null> {
+    return null;
+  }
+
+  /**
+   * Get all members of a set
+   */
+  async sMembers(_key: string): Promise<string[]> {
+    return [];
+  }
+
+  /**
+   * Delete key
+   */
+  async del(_key: string): Promise<number> {
+    return 0;
+  }
+}

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

@@ -0,0 +1,188 @@
+/**
+ * Core type definitions for CFN Loop orchestration engine
+ * TypeScript v3.0 - Test-Driven validation
+ */
+
+/**
+ * Execution mode determines test gate thresholds and consensus requirements
+ */
+export type ExecutionMode = 'mvp' | 'standard' | 'enterprise';
+
+/**
+ * Core orchestration configuration passed from CLI
+ */
+export interface OrchestrationConfig {
+  taskId: string;
+  mode: ExecutionMode;
+  maxIterations: number;
+  aceReflect?: boolean;
+}
+
+/**
+ * Agent specification with resource allocation
+ */
+export interface AgentSpec {
+  id: string;
+  type: string;
+  memoryTier: 1 | 2 | 3 | 4;
+  memoryLimit: string; // '512m', '1g', '2g', '4g'
+}
+
+/**
+ * Test execution results - counts of pass/fail/skip
+ */
+export interface TestResult {
+  pass: number;
+  fail: number;
+  skip?: number;
+}
+
+/**
+ * Gate check result from test execution
+ * Contains test results and pass rate vs threshold
+ */
+export interface GateResult {
+  passed: boolean;
+  passRate: number;
+  threshold: number;
+  testResults: Map<string, TestResult>;
+}
+
+/**
+ * Loop 2 consensus result from a single validator
+ */
+export interface Loop2Result {
+  agentId: string;
+  consensusScore: number;
+  feedback: string;
+}
+
+/**
+ * Product Owner decision on whether to proceed, iterate, or abort
+ */
+export type ProductOwnerDecision = 'PROCEED' | 'ITERATE' | 'ABORT';
+
+/**
+ * Final orchestration result after all loops complete
+ */
+export interface OrchestrationResult {
+  taskId: string;
+  decision: ProductOwnerDecision;
+  iteration: number;
+  gateResults: GateResult[];
+  consensusScores: number[];
+  deliverables: string[];
+}
+
+/**
+ * Mode-specific threshold configuration
+ */
+export interface ModeConfig {
+  testPassRateGate: number; // Loop 3 gate threshold
+  consensusThreshold: number; // Loop 2 consensus threshold
+  maxIterations: number;
+  validatorCount: number;
+}
+
+/**
+ * Mode configuration map
+ */
+export const MODE_CONFIG: Record<ExecutionMode, ModeConfig> = {
+  mvp: {
+    testPassRateGate: 0.7,
+    consensusThreshold: 0.8,
+    maxIterations: 5,
+    validatorCount: 2,
+  },
+  standard: {
+    testPassRateGate: 0.95,
+    consensusThreshold: 0.9,
+    maxIterations: 10,
+    validatorCount: 3,
+  },
+  enterprise: {
+    testPassRateGate: 0.98,
+    consensusThreshold: 0.95,
+    maxIterations: 15,
+    validatorCount: 5,
+  },
+};
+
+/**
+ * Redis message envelope for coordination
+ */
+export interface RedisMessage {
+  taskId: string;
+  agentId: string;
+  type: 'completion' | 'test-result' | 'consensus' | 'decision';
+  payload: unknown;
+  timestamp: number;
+}
+
+/**
+ * Agent execution context for coordination
+ */
+export interface AgentContext {
+  taskId: string;
+  agentId: string;
+  agentType: string;
+  iteration: number;
+  memoryTier: 1 | 2 | 3 | 4;
+  broadcastMessages?: string[];
+}
+
+/**
+ * Wave specification for parallel agent execution
+ */
+export interface WaveSpec {
+  waveNumber: number;
+  agentCount: number;
+  memoryTier: 1 | 2 | 3 | 4;
+  timeout: number;
+}
+
+/**
+ * Orchestration state tracking
+ */
+export interface OrchestrationState {
+  taskId: string;
+  mode: ExecutionMode;
+  iteration: number;
+  currentWave: number;
+  gateStatus: 'pending' | 'passed' | 'failed';
+  consensusStatus: 'pending' | 'reached' | 'unreachable';
+  decision: ProductOwnerDecision | null;
+  completedAgents: Set<string>;
+  failedAgents: Set<string>;
+  startTime: number;
+  lastUpdateTime: number;
+}
+
+/**
+ * Type guard to check if value is valid ExecutionMode
+ */
+export function isValidExecutionMode(value: unknown): value is ExecutionMode {
+  return typeof value === 'string' && ['mvp', 'standard', 'enterprise'].includes(value);
+}
+
+/**
+ * Type guard to check if value is valid ProductOwnerDecision
+ */
+export function isValidProductOwnerDecision(value: unknown): value is ProductOwnerDecision {
+  return typeof value === 'string' && ['PROCEED', 'ITERATE', 'ABORT'].includes(value);
+}
+
+/**
+ * Get mode configuration for execution mode
+ */
+export function getModeConfig(mode: ExecutionMode): ModeConfig {
+  return MODE_CONFIG[mode];
+}
+
+/**
+ * Calculate pass rate from test results
+ */
+export function calculatePassRate(result: TestResult): number {
+  const total = result.pass + result.fail + (result.skip ?? 0);
+  return total === 0 ? 0 : result.pass / total;
+}

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

@@ -0,0 +1,32 @@
+/**
+ * Logging utility for orchestration engine
+ */
+
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+
+/**
+ * Simple logger utility
+ */
+export class Logger {
+  private context: string;
+
+  constructor(context: string) {
+    this.context = context;
+  }
+
+  debug(message: string, data?: unknown): void {
+    console.log(`[DEBUG] [${this.context}] ${message}`, data ?? '');
+  }
+
+  info(message: string, data?: unknown): void {
+    console.log(`[INFO] [${this.context}] ${message}`, data ?? '');
+  }
+
+  warn(message: string, data?: unknown): void {
+    console.warn(`[WARN] [${this.context}] ${message}`, data ?? '');
+  }
+
+  error(message: string, error?: unknown): void {
+    console.error(`[ERROR] [${this.context}] ${message}`, error ?? '');
+  }
+}

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);
+    });
+  });
+});