claude-flow-novice 2.18.6 → 2.18.8

package/claude-assets/skills/cfn-loop-orchestration-v2/lib/orchestrator/ORCHESTRATOR_QUICK_START.md

@@ -1,499 +0,0 @@
-# CFN Orchestrator Quick Start Guide
-
-## What Was Delivered
-
-Complete TypeScript implementation of the CFN Loop orchestrator from scratch:
-
-- **src/orchestrate.ts** - 580 LOC production implementation
-- **tests/orchestrate.test.ts** - 600+ LOC with 72 comprehensive tests
-- **helpers/orchestrate-ts.sh** - Bash wrapper for CLI usage
-- **ORCHESTRATOR_IMPLEMENTATION.md** - Full technical documentation
-
-**Test Results:** 72/72 passing (100% pass rate)
-
-## Key Features
-
-### 1. Three Execution Modes
-```
-MVP Mode:        Gate 70% | Consensus 80% | Max 5 iterations
-Standard Mode:   Gate 95% | Consensus 90% | Max 10 iterations
-Enterprise Mode: Gate 98% | Consensus 95% | Max 15 iterations
-```
-
-### 2. Complete CFN Loop Support
-```
-Loop 3 (Implementers)
-  ├─ Spawn agents
-  ├─ Record test results
-  └─ Check gate (pass rate >= threshold)
-
-Loop 2 (Validators)
-  ├─ Spawn validators
-  ├─ Collect consensus scores
-  └─ Validate consensus (average >= threshold)
-
-Product Owner
-  ├─ Parse decision (PROCEED/ITERATE/ABORT)
-  └─ Handle termination or re-iteration
-```
-
-### 3. Comprehensive Type Safety
-- No `any` types
-- Strict TypeScript compilation
-- Full type definitions for all interfaces
-- Type-safe enums
-
-## Basic Usage Examples
-
-### Example 1: Simple Initialization
-```typescript
-import { Orchestrator } from './src/orchestrate';
-
-const orch = new Orchestrator({
-  taskId: 'feature-auth',
-  mode: 'standard',
-  maxIterations: 10,
-});
-
-console.log(orch.getTaskId());        // 'feature-auth'
-console.log(orch.getMode());          // 'standard'
-console.log(orch.getGateThreshold()); // 0.95
-```
-
-### Example 2: Complete Loop Workflow
-```typescript
-// Loop 3: Implementers
-orch.transitionPhase('loop3');
-const agents = await orch.spawnLoop3Agents(['backend-dev', 'frontend-dev']);
-
-// Record test results
-orch.recordTestResult('backend-dev-1-1', { pass: 95, fail: 5 });
-orch.recordTestResult('frontend-dev-1-1', { pass: 93, fail: 7 });
-
-// Aggregate and check gate
-const aggregated = orch.aggregateTestResults();
-const gateResult = orch.checkGate(aggregated.passRate); // 0.94
-
-if (gateResult.passed) {
-  console.log('Gate passed! Proceeding to Loop 2');
-
-  // Loop 2: Validators
-  orch.transitionPhase('loop2');
-  const validators = await orch.spawnLoop2Validators(['validator-1', 'validator-2', 'validator-3']);
-
-  orch.recordConsensusScore('validator-1-1', 0.92);
-  orch.recordConsensusScore('validator-2-1', 0.91);
-  orch.recordConsensusScore('validator-3-1', 0.93);
-
-  const consensus = orch.validateConsensus();
-  if (consensus.passed) {
-    console.log('Consensus reached! Proceeding to Product Owner');
-
-    // Product Owner
-    orch.transitionPhase('product-owner');
-    orch.recordDecision('PROCEED');
-  }
-} else {
-  console.log(`Gate failed: ${gateResult.passRate} < ${gateResult.threshold}`);
-  orch.recordDecision('ITERATE');
-  orch.incrementIteration();
-}
-```
-
-### Example 3: Decision Parsing
-```typescript
-const output = `After review of implementation:
-Decision: PROCEED with deployment`;
-
-const decision = orch.parseDecisionFromOutput(output);
-console.log(decision); // 'PROCEED'
-
-orch.recordDecision(decision);
-```
-
-### Example 4: Mode-Specific Behavior
-```typescript
-// MVP mode - loose requirements
-const mvpOrch = new Orchestrator({
-  taskId: 'mvp-feature',
-  mode: 'mvp',
-  maxIterations: 5,
-});
-
-console.log(mvpOrch.getGateThreshold());      // 0.70
-console.log(mvpOrch.getConsensusThreshold()); // 0.80
-console.log(mvpOrch.getMaxIterations());      // 5
-
-// Enterprise mode - strict requirements
-const entOrch = new Orchestrator({
-  taskId: 'enterprise-feature',
-  mode: 'enterprise',
-  maxIterations: 15,
-});
-
-console.log(entOrch.getGateThreshold());      // 0.98
-console.log(entOrch.getConsensusThreshold()); // 0.95
-console.log(entOrch.getMaxIterations());      // 15
-```
-
-### Example 5: Error Handling
-```typescript
-try {
-  const orch = new Orchestrator({
-    taskId: '',  // Invalid: empty
-    mode: 'standard',
-    maxIterations: 10,
-  });
-} catch (error) {
-  console.error(error.message); // 'Task ID cannot be empty'
-}
-
-try {
-  const orch = new Orchestrator({
-    taskId: 'test',
-    mode: 'invalid',  // Invalid mode
-    maxIterations: 10,
-  });
-} catch (error) {
-  console.error(error.message); // 'Invalid execution mode: invalid'
-}
-```
-
-### Example 6: Iteration Management
-```typescript
-while (true) {
-  // Do loop work...
-
-  if (orch.shouldTerminate()) {
-    console.log(`Terminated with decision: ${orch.getDecision()}`);
-    break;
-  }
-
-  if (orch.canContinueIterating()) {
-    console.log('Continuing to next iteration');
-    orch.incrementIteration();
-  } else {
-    console.log('Max iterations reached');
-    orch.recordDecision('ABORT');
-    break;
-  }
-}
-```
-
-## API Reference
-
-### Configuration
-```typescript
-interface OrchestrationConfig {
-  taskId: string;              // Unique task identifier
-  mode: 'mvp' | 'standard' | 'enterprise';
-  maxIterations: number;       // 1-100
-  aceReflect?: boolean;        // Optional
-}
-```
-
-### Main Methods
-
-#### Initialization & Queries
-```typescript
-getTaskId(): string
-getMode(): ExecutionMode
-getMaxIterations(): number
-getGateThreshold(): number
-getConsensusThreshold(): number
-getState(): OrchestrationState
-```
-
-#### Phase Management
-```typescript
-transitionPhase(phase: LoopPhase): void
-getPhaseHistory(): PhaseTransition[]
-```
-
-#### Iteration Control
-```typescript
-incrementIteration(): void
-canContinueIterating(): boolean
-shouldTerminate(): boolean
-```
-
-#### Agent Management
-```typescript
-markAgentComplete(agentId: string, loopType: 'loop3' | 'loop2'): void
-markAgentFailed(agentId: string, loopType: 'loop3' | 'loop2'): void
-recordExecutionError(agentId: string, error: Error): void
-recordTimeout(agentId: string, timeoutSeconds: number): void
-```
-
-#### Loop 3 (Implementers)
-```typescript
-spawnLoop3Agents(agentTypes: string[]): Promise<AgentExecutionContext[]>
-recordTestResult(agentId: string, result: TestResult): void
-getTestResult(agentId: string): TestResult | undefined
-aggregateTestResults(): AggregatedTestResults
-checkGate(passRate: number): GateCheckResult
-```
-
-#### Loop 2 (Validators)
-```typescript
-spawnLoop2Validators(validatorTypes: string[]): Promise<AgentExecutionContext[]>
-recordConsensusScore(validatorId: string, score: number): void
-getConsensusScores(): number[]
-getConsensusAverage(): number
-validateConsensus(): ConsensusValidationResult
-```
-
-#### Product Owner
-```typescript
-recordDecision(decision: ProductOwnerDecision): void
-getDecision(): ProductOwnerDecision
-parseDecisionFromOutput(output: string): ProductOwnerDecision
-```
-
-#### Utilities
-```typescript
-buildAgentContext(agentId: string, loopType: 'loop3'|'loop2', iteration: number): AgentExecutionContext
-prepareFeedback(feedback: IterationFeedback): IterationFeedback
-resetForIteration(): void
-getSummary(): {taskId, mode, iteration, totalAgentsCompleted, totalAgentsFailed, decision, duration}
-```
-
-## Testing
-
-### Run All Tests
-```bash
-cd .claude/skills/cfn-loop-orchestration
-npm test
-```
-
-### Run Orchestrator Tests Only
-```bash
-npm test -- tests/orchestrate.test.ts
-```
-
-### Run with Coverage
-```bash
-npm run test:coverage
-```
-
-### Watch Mode
-```bash
-npm run test:watch
-```
-
-## Compilation
-
-### Build TypeScript
-```bash
-npm run build
-```
-
-### Type Check
-```bash
-npm run type-check
-```
-
-### Clean Build
-```bash
-npm run clean && npm run build
-```
-
-## CLI Usage
-
-### Via Bash Wrapper
-```bash
-./helpers/orchestrate-ts.sh \
-  --task-id my-feature \
-  --mode standard \
-  --max-iterations 10
-```
-
-### Via Node
-```bash
-node dist/orchestrate.js \
-  --task-id my-feature \
-  --mode standard \
-  --max-iterations 10
-```
-
-### Via ts-node
-```bash
-npx ts-node src/orchestrate.ts \
-  --task-id my-feature \
-  --mode standard \
-  --max-iterations 10
-```
-
-## Mode Selection Guide
-
-### Use MVP Mode When
-- Building proof of concept
-- Tight timeline
-- Lower quality requirements acceptable
-- Early development stage
-
-### Use Standard Mode When
-- Production release candidate
-- Balanced quality/time tradeoff
-- Most feature work
-- Default recommendation
-
-### Use Enterprise Mode When
-- Critical infrastructure
-- High reliability required
-- Compliance requirements
-- Production systems
-
-## Common Patterns
-
-### Pattern 1: Run Full Loop
-```typescript
-const orch = new Orchestrator(config);
-let iteration = 0;
-
-while (iteration < orch.getMaxIterations()) {
-  // Loop 3
-  orch.transitionPhase('loop3');
-  // ... spawn and test ...
-
-  if (!orch.checkGate(passRate).passed) {
-    orch.recordDecision('ITERATE');
-    iteration++;
-    continue;
-  }
-
-  // Loop 2
-  orch.transitionPhase('loop2');
-  // ... validate ...
-
-  if (!orch.validateConsensus().passed) {
-    orch.recordDecision('ITERATE');
-    iteration++;
-    continue;
-  }
-
-  // Product Owner
-  orch.transitionPhase('product-owner');
-  orch.recordDecision('PROCEED');
-  break;
-}
-```
-
-### Pattern 2: Error Recovery
-```typescript
-try {
-  orch.recordTestResult(agentId, testResult);
-  orch.markAgentComplete(agentId, 'loop3');
-} catch (error) {
-  orch.recordExecutionError(agentId, error);
-  // Continue with other agents
-}
-```
-
-### Pattern 3: Summary Report
-```typescript
-const summary = orch.getSummary();
-console.log(`
-Task: ${summary.taskId}
-Mode: ${summary.mode}
-Iterations: ${summary.iteration}
-Agents Completed: ${summary.totalAgentsCompleted}
-Agents Failed: ${summary.totalAgentsFailed}
-Decision: ${summary.decision}
-Duration: ${summary.duration}ms
-`);
-```
-
-## Type Definitions Quick Reference
-
-```typescript
-type ExecutionMode = 'mvp' | 'standard' | 'enterprise'
-type LoopPhase = 'loop3' | 'loop2' | 'product-owner' | 'complete'
-type ProductOwnerDecision = 'PROCEED' | 'ITERATE' | 'ABORT' | null
-
-interface TestResult {
-  pass: number
-  fail: number
-  skip?: number
-}
-
-interface GateCheckResult {
-  passed: boolean
-  passRate: number
-  threshold: number
-  gap: number
-}
-
-interface ConsensusValidationResult {
-  passed: boolean
-  average: number
-  threshold: number
-  gap: number
-}
-```
-
-## Troubleshooting
-
-### Build Fails
-```bash
-# Clean and rebuild
-npm run clean
-npm run build
-```
-
-### Tests Failing
-```bash
-# Check if dependencies installed
-npm install
-
-# Run single test file
-npm test -- tests/orchestrate.test.ts
-
-# Check test output
-npm test -- --verbose
-```
-
-### Type Errors
-```bash
-# Type check only
-npm run type-check
-
-# Check for any types
-grep -r "any" src/
-```
-
-## Integration Checklist
-
-When integrating into your workflow:
-
-- [ ] Install dependencies: `npm install`
-- [ ] Build TypeScript: `npm run build`
-- [ ] Run tests: `npm test`
-- [ ] Type check: `npm run type-check`
-- [ ] Review ORCHESTRATOR_IMPLEMENTATION.md
-- [ ] Import Orchestrator class
-- [ ] Create config with valid parameters
-- [ ] Test basic workflow locally
-- [ ] Integrate with agent spawning system
-- [ ] Connect to Redis coordination (optional)
-
-## Support Resources
-
-- **Full Implementation Details:** See `ORCHESTRATOR_IMPLEMENTATION.md`
-- **Test Examples:** See `tests/orchestrate.test.ts` (72 examples)
-- **Type Definitions:** See `src/orchestrate.ts` (lines 1-150)
-- **API Reference:** See this file (above)
-
-## Summary
-
-The TypeScript orchestrator provides:
-
-✓ Complete CFN Loop implementation
-✓ Type-safe operations (zero `any` types)
-✓ 100% test coverage (72 tests)
-✓ Three execution modes (MVP/Standard/Enterprise)
-✓ Backward compatible bash wrapper
-✓ Production-ready code
-✓ Comprehensive documentation
-
-Ready for immediate integration and use.

package/claude-assets/skills/cfn-loop-orchestration-v2/lib/orchestrator/README.md

@@ -1,149 +0,0 @@
-# CFN Loop Orchestration Engine - TypeScript v3.0
-
-Type-safe implementation of the CFN Loop orchestration system with test-driven validation.
-
-## Overview
-
-This is the TypeScript migration of the CFN Loop orchestration system, replacing the bash-based implementation with a fully type-safe, well-tested TypeScript codebase.
-
-**Key Features:**
-- Full type safety with TypeScript strict mode
-- Test-driven validation (≥95% pass rate gates)
-- Mode-specific execution (MVP, Standard, Enterprise)
-- Redis-based agent coordination
-- Comprehensive test coverage (80-100% per module)
-
-## Project Structure
-
-```
-src/
-├── orchestrator/       # Main orchestration engine
-├── gate-checker/       # Test result validation
-├── agent-spawner/      # Agent spawning and coordination
-├── redis/             # Redis coordination layer
-├── utils/             # Utilities and helpers
-└── types.ts           # Core type definitions
-
-tests/
-├── orchestrator/       # Orchestrator tests
-├── gate-checker/       # Gate checker tests
-└── agent-spawner/      # Agent spawner tests
-
-bash-wrappers/         # Shell wrappers for CLI compatibility
-```
-
-## Quick Start
-
-```bash
-# Install dependencies
-npm install
-
-# Build the project
-npm run build
-
-# Run tests
-npm test
-
-# Run tests with coverage
-npm run test:coverage
-
-# Type check
-npm run type-check
-
-# Lint
-npm run lint
-```
-
-## Development
-
-```bash
-# Watch mode for development
-npm run build:watch
-
-# Watch mode for tests
-npm run test:watch
-
-# Format code
-npm run format
-
-# Fix linting issues
-npm run lint:fix
-```
-
-## Configuration
-
-### tsconfig.json
-Strict TypeScript configuration with:
-- ES2022 target
-- CommonJS module format
-- Path mapping for clean imports
-- All strict compiler options enabled
-
-### jest.config.js
-Test configuration with:
-- ts-jest preset for TypeScript support
-- Coverage thresholds (80-100% per module)
-- Path mapping for imports
-- 30-second test timeout
-
-### .eslintrc.js
-Linting configuration with:
-- TypeScript-specific rules
-- Strict null checking
-- No implicit any
-- Prefer const and proper variable declarations
-
-## Test Coverage
-
-Target coverage per module:
-- `src/orchestrator/`: 100%
-- `src/gate-checker/`: 100%
-- `src/agent-spawner/`: 90%
-- `src/utils/`: 80%
-- Global minimum: 80%
-
-## Type Definitions
-
-Core types are defined in `src/types.ts`:
-
-- `ExecutionMode` - 'mvp' | 'standard' | 'enterprise'
-- `OrchestrationConfig` - Task configuration
-- `AgentSpec` - Agent specification with resources
-- `TestResult` - Test execution results
-- `GateResult` - Gate check results
-- `ProductOwnerDecision` - 'PROCEED' | 'ITERATE' | 'ABORT'
-- `OrchestrationResult` - Final result
-
-## Mode Configuration
-
-| Mode | Test Gate | Consensus | Max Iterations | Validators |
-|------|-----------|-----------|----------------|------------|
-| mvp | 70% | 80% | 5 | 2 |
-| standard | 95% | 90% | 10 | 3 |
-| enterprise | 98% | 95% | 15 | 5 |
-
-## Migration Plan
-
-See `docs/migration/BASH_TO_TYPESCRIPT_MIGRATION_PLAN.md` for the complete migration strategy from bash to TypeScript.
-
-## Building and Deployment
-
-```bash
-# Production build
-npm run build
-
-# Distribution files are in dist/
-# Include in packages: dist/, package.json, README.md
-```
-
-## Environment Variables
-
-```
-CFN_REDIS_HOST=localhost (default)
-CFN_REDIS_PORT=6379 (default)
-NODE_ENV=test|development|production
-```
-
-## License
-
-MIT