claude-flow-novice 2.15.5 → 2.15.6

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

@@ -0,0 +1,49 @@
+{
+  "name": "@cfn/loop-orchestration",
+  "version": "3.0.0",
+  "description": "TypeScript implementation of CFN Loop orchestration engine",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "build:watch": "tsc --watch",
+    "dev": "ts-node src/index.ts",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "lint": "eslint src tests --ext .ts",
+    "lint:fix": "eslint src tests --ext .ts --fix",
+    "format": "prettier --write \"src/**/*.ts\" \"tests/**/*.ts\"",
+    "format:check": "prettier --check \"src/**/*.ts\" \"tests/**/*.ts\"",
+    "type-check": "tsc --noEmit",
+    "clean": "rm -rf dist .eslintcache"
+  },
+  "keywords": [
+    "cfn",
+    "orchestration",
+    "loop",
+    "typescript"
+  ],
+  "author": "CFN Team",
+  "license": "MIT",
+  "dependencies": {
+    "ioredis": "^5.3.2",
+    "dotenv": "^16.3.1"
+  },
+  "devDependencies": {
+    "typescript": "^5.3.3",
+    "@types/node": "^20.10.6",
+    "ts-node": "^10.9.2",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.1",
+    "@types/jest": "^29.5.11",
+    "eslint": "^8.56.0",
+    "@typescript-eslint/parser": "^6.16.0",
+    "@typescript-eslint/eslint-plugin": "^6.16.0",
+    "prettier": "^3.1.1",
+    "jest-mock-extended": "^3.0.5"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

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

@@ -0,0 +1,34 @@
+/**
+ * Agent spawner implementation
+ * Spawns specialized agents for loop execution
+ */
+
+import { AgentSpec, ExecutionMode } from '../types';
+
+/**
+ * Agent spawner class - placeholder for migration
+ */
+export class AgentSpawner {
+  /**
+   * Spawn agents for a specific loop and wave
+   */
+  static async spawnAgents(
+    taskId: string,
+    loopNumber: number,
+    agentCount: number,
+    _mode: ExecutionMode
+  ): Promise<AgentSpec[]> {
+    const agents: AgentSpec[] = [];
+
+    for (let i = 0; i < agentCount; i++) {
+      agents.push({
+        id: `${taskId}-loop${loopNumber}-agent${i}`,
+        type: `loop${loopNumber}-agent`,
+        memoryTier: 2,
+        memoryLimit: '1g',
+      });
+    }
+
+    return agents;
+  }
+}

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

@@ -0,0 +1,36 @@
+/**
+ * Gate checker implementation
+ * Validates test results against mode-specific thresholds
+ */
+
+import { GateResult, TestResult, getModeConfig, ExecutionMode, calculatePassRate } from '../types';
+
+/**
+ * Gate checker class - placeholder for migration
+ */
+export class GateChecker {
+  /**
+   * Check if test results pass the gate threshold
+   */
+  static checkGate(
+    testResults: Map<string, TestResult>,
+    mode: ExecutionMode
+  ): GateResult {
+    const config = getModeConfig(mode);
+    const passRates: number[] = [];
+
+    testResults.forEach((result: TestResult): void => {
+      passRates.push(calculatePassRate(result));
+    });
+
+    const averagePassRate =
+      passRates.length === 0 ? 0 : passRates.reduce((a, b) => a + b, 0) / passRates.length;
+
+    return {
+      passed: averagePassRate >= config.testPassRateGate,
+      passRate: averagePassRate,
+      threshold: config.testPassRateGate,
+      testResults,
+    };
+  }
+}

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

@@ -0,0 +1,14 @@
+/**
+ * CFN Loop Orchestration Engine - TypeScript Implementation
+ * Main entry point
+ */
+
+export * from './types';
+export * from './orchestrator/orchestrator';
+export * from './gate-checker/gate-checker';
+export * from './agent-spawner/agent-spawner';
+export * from './redis/redis-coordinator';
+export * from './utils/logger';
+
+// Version
+export const VERSION = '3.0.0';

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

@@ -0,0 +1,31 @@
+/**
+ * Main orchestrator implementation
+ * Coordinates CFN Loop execution with test-driven validation
+ */
+
+import { OrchestrationConfig, OrchestrationResult, ProductOwnerDecision } from '../types';
+
+/**
+ * Main orchestrator class - placeholder for migration
+ */
+export class Orchestrator {
+  private taskId: string;
+
+  constructor(config: OrchestrationConfig) {
+    this.taskId = config.taskId;
+  }
+
+  /**
+   * Execute the orchestration loop
+   */
+  async execute(): Promise<OrchestrationResult> {
+    return {
+      taskId: this.taskId,
+      decision: 'PROCEED' as ProductOwnerDecision,
+      iteration: 0,
+      gateResults: [],
+      consensusScores: [],
+      deliverables: [],
+    };
+  }
+}

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/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/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"
+  ]
+}

package/claude-assets/skills/cfn-redis-coordination/bash-wrappers/store-context.sh

@@ -0,0 +1,23 @@
+#!/bin/bash
+# Backward compatibility wrapper for store-context
+# Delegates to TypeScript implementation
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(dirname "$SCRIPT_DIR")"
+
+# Check if compiled TypeScript is available
+if [ ! -f "$PROJECT_ROOT/dist/context-manager.js" ]; then
+  echo "Error: TypeScript modules not built. Run 'npm run build' in $PROJECT_ROOT" >&2
+  exit 1
+fi
+
+# For now, delegate to original shell script if it exists
+if [ -f "$PROJECT_ROOT/store-context.sh" ]; then
+  "$PROJECT_ROOT/store-context.sh" "$@"
+else
+  # Fallback message
+  echo "Error: Original store-context.sh not found" >&2
+  exit 1
+fi