claude-flow-novice 2.18.5 → 2.18.6

package/.claude/skills/cfn-loop-orchestration-v2/lib/orchestrator/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/skills/cfn-loop-orchestration-v2/lib/orchestrator/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/skills/cfn-loop-orchestration-v2/lib/orchestrator/src/types.ts

@@ -0,0 +1,244 @@
+/**
+ * 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;
+  timeouts?: TimeoutConfig; // Optional timeout configuration
+}
+
+/**
+ * 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;
+  timeouts?: TimeoutConfig; // Optional timeout overrides
+}
+
+/**
+ * Timeout configuration for agent execution
+ */
+export interface TimeoutConfig {
+  loop3Agent?: number; // Loop 3 agent timeout in seconds (default: 300)
+  loop2Agent?: number; // Loop 2 validator timeout in seconds (default: 300)
+  productOwner?: number; // Product Owner decision timeout in seconds (default: 60)
+}
+
+/**
+ * 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;
+}
+
+/**
+ * Get timeout configuration with defaults
+ * Default values: Loop 3 = 300s, Loop 2 = 300s, Product Owner = 60s
+ */
+export function getTimeoutConfig(config?: TimeoutConfig): Required<TimeoutConfig> {
+  return {
+    loop3Agent: config?.loop3Agent ?? 300,
+    loop2Agent: config?.loop2Agent ?? 300,
+    productOwner: config?.productOwner ?? 60,
+  };
+}
+
+/**
+ * Validate timeout configuration
+ * Ensures timeouts are within reasonable bounds (10-3600 seconds)
+ */
+export function validateTimeoutConfig(config: TimeoutConfig): { valid: boolean; errors: string[] } {
+  const errors: string[] = [];
+  const MIN_TIMEOUT = 10;
+  const MAX_TIMEOUT = 3600;
+
+  if (config.loop3Agent !== undefined) {
+    if (config.loop3Agent < MIN_TIMEOUT || config.loop3Agent > MAX_TIMEOUT) {
+      errors.push(`loop3Agent timeout must be between ${MIN_TIMEOUT}-${MAX_TIMEOUT}s, got ${config.loop3Agent}s`);
+    }
+  }
+
+  if (config.loop2Agent !== undefined) {
+    if (config.loop2Agent < MIN_TIMEOUT || config.loop2Agent > MAX_TIMEOUT) {
+      errors.push(`loop2Agent timeout must be between ${MIN_TIMEOUT}-${MAX_TIMEOUT}s, got ${config.loop2Agent}s`);
+    }
+  }
+
+  if (config.productOwner !== undefined) {
+    if (config.productOwner < MIN_TIMEOUT || config.productOwner > MAX_TIMEOUT) {
+      errors.push(`productOwner timeout must be between ${MIN_TIMEOUT}-${MAX_TIMEOUT}s, got ${config.productOwner}s`);
+    }
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors,
+  };
+}

package/.claude/skills/cfn-loop-orchestration-v2/lib/orchestrator/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/skills/cfn-loop-orchestration-v2/lib/orchestrator/test-cfn-orchestration.sh

@@ -0,0 +1,281 @@
+#!/usr/bin/env bash
+
+##############################################################################
+# CFN Loop Orchestration Test Suite
+# Version: 1.0.0
+#
+# Comprehensive tests for modular CFN Loop Orchestration skill
+##############################################################################
+
+set -euo pipefail
+
+# Test configuration
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+HELPERS_DIR="$SCRIPT_DIR/helpers"
+TEST_TASK_ID="test-cfn-$(date +%s)"
+PASSED=0
+FAILED=0
+
+# Colors
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+##############################################################################
+# Test Helper Functions
+##############################################################################
+
+function test_passed() {
+  local test_name="$1"
+  echo -e "${GREEN}✓${NC} $test_name"
+  PASSED=$((PASSED + 1))
+}
+
+function test_failed() {
+  local test_name="$1"
+  local reason="$2"
+  echo -e "${RED}✗${NC} $test_name: $reason"
+  FAILED=$((FAILED + 1))
+}
+
+function cleanup_test() {
+  local task_id="$1"
+  # Clean up Redis keys for test
+  redis-cli --scan --pattern "swarm:${task_id}:*" | xargs -r redis-cli del > /dev/null 2>&1 || true
+}
+
+##############################################################################
+# Test Cases
+##############################################################################
+
+echo "=============================================="
+echo "CFN Loop Orchestration Test Suite"
+echo "=============================================="
+echo ""
+
+# Test 1: Gate Check Helper - Pass
+echo "Test 1: Gate Check - Pass Scenario"
+cleanup_test "$TEST_TASK_ID"
+
+# Simulate Loop 3 agents with high confidence
+redis-cli lpush "swarm:${TEST_TASK_ID}:agent1:result" "0.85" > /dev/null
+redis-cli lpush "swarm:${TEST_TASK_ID}:agent2:result" "0.90" > /dev/null
+redis-cli lpush "swarm:${TEST_TASK_ID}:agent3:result" "0.88" > /dev/null
+
+if "$HELPERS_DIR/gate-check.sh" \
+     --task-id "$TEST_TASK_ID" \
+     --agents "agent1,agent2,agent3" \
+     --threshold "0.75" \
+     --min-quorum "0.66" > /dev/null 2>&1; then
+  # Check that gate-passed signal was sent
+  if redis-cli --raw lrange "swarm:${TEST_TASK_ID}:gate-passed" 0 -1 | grep -q "1"; then
+    test_passed "Gate check PASS with signal broadcast"
+  else
+    test_failed "Gate check PASS" "Signal not broadcast to Loop 2"
+  fi
+else
+  test_failed "Gate check PASS" "Should have passed with 0.87 avg confidence"
+fi
+
+cleanup_test "$TEST_TASK_ID"
+echo ""
+
+# Test 2: Gate Check Helper - Fail
+echo "Test 2: Gate Check - Fail Scenario"
+cleanup_test "$TEST_TASK_ID"
+
+# Simulate Loop 3 agents with low confidence
+redis-cli lpush "swarm:${TEST_TASK_ID}:agent1:result" "0.65" > /dev/null
+redis-cli lpush "swarm:${TEST_TASK_ID}:agent2:result" "0.70" > /dev/null
+redis-cli lpush "swarm:${TEST_TASK_ID}:agent3:result" "0.68" > /dev/null
+
+if ! "$HELPERS_DIR/gate-check.sh" \
+       --task-id "$TEST_TASK_ID" \
+       --agents "agent1,agent2,agent3" \
+       --threshold "0.75" \
+       --min-quorum "0.66" > /dev/null 2>&1; then
+  test_passed "Gate check FAIL detection"
+else
+  test_failed "Gate check FAIL" "Should have failed with 0.67 avg confidence"
+fi
+
+cleanup_test "$TEST_TASK_ID"
+echo ""
+
+# Test 3: Consensus Check Helper - Pass
+echo "Test 3: Consensus Check - Pass Scenario"
+cleanup_test "$TEST_TASK_ID"
+
+# Simulate Loop 2 validators with high consensus
+redis-cli lpush "swarm:${TEST_TASK_ID}:reviewer1:result" "0.92" > /dev/null
+redis-cli lpush "swarm:${TEST_TASK_ID}:tester1:result" "0.95" > /dev/null
+redis-cli lpush "swarm:${TEST_TASK_ID}:security1:result" "0.91" > /dev/null
+
+if "$HELPERS_DIR/consensus.sh" \
+     --task-id "$TEST_TASK_ID" \
+     --agents "reviewer1,tester1,security1" \
+     --threshold "0.90" \
+     --min-quorum "0.66" > /dev/null 2>&1; then
+  test_passed "Consensus check PASS"
+else
+  test_failed "Consensus check PASS" "Should have passed with 0.93 avg consensus"
+fi
+
+cleanup_test "$TEST_TASK_ID"
+echo ""
+
+# Test 4: Consensus Check Helper - Fail
+echo "Test 4: Consensus Check - Fail Scenario"
+cleanup_test "$TEST_TASK_ID"
+
+# Simulate Loop 2 validators with low consensus
+redis-cli lpush "swarm:${TEST_TASK_ID}:reviewer1:result" "0.82" > /dev/null
+redis-cli lpush "swarm:${TEST_TASK_ID}:tester1:result" "0.85" > /dev/null
+redis-cli lpush "swarm:${TEST_TASK_ID}:security1:result" "0.88" > /dev/null
+
+if ! "$HELPERS_DIR/consensus.sh" \
+       --task-id "$TEST_TASK_ID" \
+       --agents "reviewer1,tester1,security1" \
+       --threshold "0.90" \
+       --min-quorum "0.66" > /dev/null 2>&1; then
+  test_passed "Consensus check FAIL detection"
+else
+  test_failed "Consensus check FAIL" "Should have failed with 0.85 avg consensus"
+fi
+
+cleanup_test "$TEST_TASK_ID"
+echo ""
+
+# Test 5: Deliverable Verifier - File Exists
+echo "Test 5: Deliverable Verifier - File Exists"
+
+# Create test file
+TEST_FILE="/tmp/test-deliverable-$$.txt"
+echo "test content" > "$TEST_FILE"
+
+if "$HELPERS_DIR/deliverable-verifier.sh" \
+     --expected-files "$TEST_FILE" \
+     --task-type "implement feature" > /dev/null 2>&1; then
+  test_passed "Deliverable verification - file exists"
+else
+  test_failed "Deliverable verification" "Should have passed with existing file"
+fi
+
+# Cleanup
+rm -f "$TEST_FILE"
+echo ""
+
+# Test 6: Deliverable Verifier - Missing File
+echo "Test 6: Deliverable Verifier - Missing File"
+
+# Reference non-existent file
+TEST_FILE="/tmp/nonexistent-file-$$.txt"
+
+if ! "$HELPERS_DIR/deliverable-verifier.sh" \
+       --expected-files "$TEST_FILE" \
+       --task-type "create component" > /dev/null 2>&1; then
+  test_passed "Deliverable verification - missing file detection"
+else
+  test_failed "Deliverable verification" "Should have failed with missing file"
+fi
+
+echo ""
+
+# Test 7: Timeout Calculator - Phase-Specific
+echo "Test 7: Timeout Calculator - Phase-Specific"
+
+PHASE1_TIMEOUT=$("$HELPERS_DIR/timeout-calculator.sh" --phase-id "phase-1")
+PHASE2_TIMEOUT=$("$HELPERS_DIR/timeout-calculator.sh" --phase-id "phase-2")
+UNKNOWN_TIMEOUT=$("$HELPERS_DIR/timeout-calculator.sh" --phase-id "unknown-phase")
+
+if [ "$PHASE1_TIMEOUT" = "900" ] && [ "$PHASE2_TIMEOUT" = "3600" ] && [ "$UNKNOWN_TIMEOUT" = "3600" ]; then
+  test_passed "Timeout calculator - phase-specific values"
+else
+  test_failed "Timeout calculator" "Expected 900, 3600, 3600 but got $PHASE1_TIMEOUT, $PHASE2_TIMEOUT, $UNKNOWN_TIMEOUT"
+fi
+
+echo ""
+
+# Test 8: Iteration Manager - Wake Agents
+echo "Test 8: Iteration Manager - Agent Wake"
+cleanup_test "$TEST_TASK_ID"
+
+# Simulate agents in waiting mode
+redis-cli lpush "swarm:${TEST_TASK_ID}:agent1:wake" "" > /dev/null
+redis-cli lpush "swarm:${TEST_TASK_ID}:agent2:wake" "" > /dev/null
+
+# Store feedback
+redis-cli set "swarm:${TEST_TASK_ID}:feedback:agent1" "Improve test coverage" > /dev/null
+redis-cli set "swarm:${TEST_TASK_ID}:feedback:agent2" "Add error handling" > /dev/null
+
+if "$HELPERS_DIR/iteration-manager.sh" \
+     --task-id "$TEST_TASK_ID" \
+     --iteration "2" \
+     --agents "agent1,agent2" \
+     --feedback-source "swarm:${TEST_TASK_ID}:feedback" > /dev/null 2>&1; then
+  test_passed "Iteration manager - agent wake"
+else
+  test_failed "Iteration manager" "Failed to wake agents"
+fi
+
+cleanup_test "$TEST_TASK_ID"
+echo ""
+
+# Test 9: Helper Script Parameter Validation
+echo "Test 9: Parameter Validation"
+
+# Test gate-check.sh without required params
+if ! "$HELPERS_DIR/gate-check.sh" > /dev/null 2>&1; then
+  test_passed "Parameter validation - gate-check.sh"
+else
+  test_failed "Parameter validation" "gate-check.sh should fail without params"
+fi
+
+# Test consensus.sh without required params
+if ! "$HELPERS_DIR/consensus.sh" > /dev/null 2>&1; then
+  test_passed "Parameter validation - consensus.sh"
+else
+  test_failed "Parameter validation" "consensus.sh should fail without params"
+fi
+
+echo ""
+
+# Test 10: SKILL.md Metadata Validation
+echo "Test 10: SKILL.md Metadata Validation"
+
+if [ -f "$SCRIPT_DIR/SKILL.md" ]; then
+  # Check for required metadata fields
+  if grep -q "Skill ID:" "$SCRIPT_DIR/SKILL.md" && \
+     grep -q "Version:" "$SCRIPT_DIR/SKILL.md" && \
+     grep -q "Dependencies:" "$SCRIPT_DIR/SKILL.md" && \
+     grep -q "Purpose" "$SCRIPT_DIR/SKILL.md"; then
+    test_passed "SKILL.md metadata completeness"
+  else
+    test_failed "SKILL.md metadata" "Missing required fields"
+  fi
+else
+  test_failed "SKILL.md" "File not found"
+fi
+
+echo ""
+
+##############################################################################
+# Test Summary
+##############################################################################
+
+echo "=============================================="
+echo "Test Summary"
+echo "=============================================="
+echo -e "${GREEN}Passed:${NC} $PASSED"
+echo -e "${RED}Failed:${NC} $FAILED"
+echo "Total: $((PASSED + FAILED))"
+echo "=============================================="
+
+if [ $FAILED -eq 0 ]; then
+  echo -e "${GREEN}All tests passed!${NC}"
+  exit 0
+else
+  echo -e "${RED}Some tests failed${NC}"
+  exit 1
+fi