claude-flow-novice 2.18.6 → 2.18.7

package/claude-assets/skills/cfn-loop-orchestration-v2/lib/orchestrator/dist/helpers/validator.d.ts

@@ -1,83 +0,0 @@
-/**
- * Unified Validation Abstraction Layer
- * Centralizes validation logic for gate checks, consensus, and deliverables
- * Type-safe validation with comprehensive result tracking
- */
-import { Mode } from './gate-check';
-/**
- * Unified validation result - common interface for all validation types
- */
-export interface ValidationResult {
-    passed: boolean;
-    score: number;
-    threshold: number;
-    reason: string;
-    metadata?: Record<string, any>;
-}
-/**
- * Validator interface - abstraction for different validation strategies
- */
-export interface Validator {
-    validate(data: any): Promise<ValidationResult>;
-    name: string;
-}
-/**
- * Gate validator - validates test pass rates against mode thresholds
- */
-export declare class GateValidator implements Validator {
-    name: string;
-    validate(data: {
-        passRate: number;
-        threshold?: number;
-        mode: Mode;
-    }): Promise<ValidationResult>;
-}
-/**
- * Consensus validator - validates Loop 2 validator scores
- */
-export declare class ConsensusValidator implements Validator {
-    name: string;
-    validate(data: {
-        scores: number[];
-        threshold?: number;
-        mode: Mode | string;
-    }): Promise<ValidationResult>;
-}
-/**
- * Deliverable validator - verifies expected deliverables exist
- */
-export declare class DeliverableValidator implements Validator {
-    name: string;
-    validate(data: {
-        files: string[];
-        expectedTypes?: string[];
-        requireGitChanges?: boolean;
-        taskType?: string;
-    }): Promise<ValidationResult>;
-}
-/**
- * Composite validator - combines multiple validators with AND logic
- */
-export declare class CompositeValidator implements Validator {
-    private validators;
-    name: string;
-    constructor(validators: Validator[]);
-    validate(data: Record<string, any>): Promise<ValidationResult>;
-}
-/**
- * Validator factory - creates validators based on type
- */
-export declare class ValidatorFactory {
-    static create(type: 'gate' | 'consensus' | 'deliverable'): Validator;
-    static createComposite(types: ('gate' | 'consensus' | 'deliverable')[]): CompositeValidator;
-}
-/**
- * Validation context - encapsulates validation state and operations
- */
-export declare class ValidationContext {
-    private validators;
-    registerValidator(name: string, validator: Validator): void;
-    validate(validatorName: string, data: any): Promise<ValidationResult>;
-    validateAll(validatorNames: string[], data: any): Promise<Map<string, ValidationResult>>;
-}
-//# sourceMappingURL=validator.d.ts.map

package/claude-assets/skills/cfn-loop-orchestration-v2/lib/orchestrator/dist/helpers/validator.js

@@ -1,222 +0,0 @@
-"use strict";
-/**
- * Unified Validation Abstraction Layer
- * Centralizes validation logic for gate checks, consensus, and deliverables
- * Type-safe validation with comprehensive result tracking
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValidationContext = exports.ValidatorFactory = exports.CompositeValidator = exports.DeliverableValidator = exports.ConsensusValidator = exports.GateValidator = void 0;
-const gate_check_1 = require("./gate-check");
-const consensus_1 = require("./consensus");
-const deliverable_verifier_1 = require("./deliverable-verifier");
-/**
- * Gate validator - validates test pass rates against mode thresholds
- */
-class GateValidator {
-    name = 'GateValidator';
-    async validate(data) {
-        const result = (0, gate_check_1.gateCheck)({
-            passRate: data.passRate,
-            threshold: data.threshold ?? undefined,
-            mode: data.mode,
-        });
-        return {
-            passed: result.passed,
-            score: result.passRate,
-            threshold: result.threshold,
-            reason: result.reason,
-            metadata: {
-                gap: result.gap,
-                mode: result.mode,
-                type: 'gate',
-            },
-        };
-    }
-}
-exports.GateValidator = GateValidator;
-/**
- * Consensus validator - validates Loop 2 validator scores
- */
-class ConsensusValidator {
-    name = 'ConsensusValidator';
-    async validate(data) {
-        // Collect consensus statistics
-        const consensus = (0, consensus_1.collectConsensus)(data.scores);
-        // Validate against threshold
-        const validation = (0, consensus_1.validateConsensus)({
-            average: consensus.average,
-            threshold: data.threshold ?? undefined,
-            mode: data.mode,
-        });
-        return {
-            passed: validation.passed,
-            score: validation.average,
-            threshold: validation.threshold,
-            reason: `Consensus ${validation.passed ? 'PASSED' : 'FAILED'}: Average score ${validation.average.toFixed(4)} ${validation.passed ? '>=' : '<'} threshold ${validation.threshold.toFixed(4)} (mode: ${validation.mode})`,
-            metadata: {
-                gap: validation.gap,
-                scoreCount: consensus.count,
-                scores: consensus.scores,
-                min: consensus.min,
-                max: consensus.max,
-                type: 'consensus',
-            },
-        };
-    }
-}
-exports.ConsensusValidator = ConsensusValidator;
-/**
- * Deliverable validator - verifies expected deliverables exist
- */
-class DeliverableValidator {
-    name = 'DeliverableValidator';
-    async validate(data) {
-        const result = (0, deliverable_verifier_1.verifyDeliverables)(data);
-        const reason = result.reason
-            ? result.reason
-            : result.verified
-                ? `Deliverables VERIFIED: ${result.found.length} files found`
-                : `Deliverables MISSING: ${result.missing.length} files not found`;
-        return {
-            passed: result.verified,
-            score: result.found.length / (result.files.length || 1),
-            threshold: 1.0,
-            reason,
-            metadata: {
-                found: result.found,
-                missing: result.missing,
-                gitChanges: result.gitChanges,
-                typeErrors: result.typeErrors,
-                requiresChanges: result.requiresChanges,
-                type: 'deliverable',
-            },
-        };
-    }
-}
-exports.DeliverableValidator = DeliverableValidator;
-/**
- * Composite validator - combines multiple validators with AND logic
- */
-class CompositeValidator {
-    validators;
-    name = 'CompositeValidator';
-    constructor(validators) {
-        this.validators = validators;
-    }
-    async validate(data) {
-        const results = [];
-        for (const validator of this.validators) {
-            const result = await validator.validate(data);
-            results.push(result);
-        }
-        // All must pass (AND logic)
-        const allPassed = results.every(r => r.passed);
-        // Average score across all validators
-        const avgScore = results.reduce((sum, r) => sum + r.score, 0) / results.length;
-        // Combine reasons
-        const reasons = results.map(r => `[${r.metadata?.type || 'unknown'}] ${r.reason}`).join('\n');
-        return {
-            passed: allPassed,
-            score: avgScore,
-            threshold: 0.5, // Composite uses AND logic
-            reason: `Composite validation ${allPassed ? 'PASSED' : 'FAILED'}:\n${reasons}`,
-            metadata: {
-                validatorResults: results.map(r => ({
-                    passed: r.passed,
-                    score: r.score,
-                    type: r.metadata?.type,
-                })),
-                totalValidators: results.length,
-                passedValidators: results.filter(r => r.passed).length,
-                type: 'composite',
-            },
-        };
-    }
-}
-exports.CompositeValidator = CompositeValidator;
-/**
- * Validator factory - creates validators based on type
- */
-class ValidatorFactory {
-    static create(type) {
-        switch (type) {
-            case 'gate':
-                return new GateValidator();
-            case 'consensus':
-                return new ConsensusValidator();
-            case 'deliverable':
-                return new DeliverableValidator();
-            default:
-                throw new Error(`Unknown validator type: ${type}`);
-        }
-    }
-    static createComposite(types) {
-        const validators = types.map(type => this.create(type));
-        return new CompositeValidator(validators);
-    }
-}
-exports.ValidatorFactory = ValidatorFactory;
-/**
- * Validation context - encapsulates validation state and operations
- */
-class ValidationContext {
-    validators = new Map();
-    registerValidator(name, validator) {
-        this.validators.set(name, validator);
-    }
-    async validate(validatorName, data) {
-        const validator = this.validators.get(validatorName);
-        if (!validator) {
-            throw new Error(`Validator not found: ${validatorName}`);
-        }
-        return validator.validate(data);
-    }
-    async validateAll(validatorNames, data) {
-        const results = new Map();
-        for (const name of validatorNames) {
-            const result = await this.validate(name, data);
-            results.set(name, result);
-        }
-        return results;
-    }
-}
-exports.ValidationContext = ValidationContext;
-/**
- * CLI entry point for validation
- */
-if (require.main === module) {
-    const args = process.argv.slice(2);
-    const validationType = args[0];
-    (async () => {
-        try {
-            const data = JSON.parse(args[1] || '{}');
-            let result;
-            switch (validationType) {
-                case 'gate': {
-                    const validator = new GateValidator();
-                    result = await validator.validate(data);
-                    break;
-                }
-                case 'consensus': {
-                    const validator = new ConsensusValidator();
-                    result = await validator.validate(data);
-                    break;
-                }
-                case 'deliverable': {
-                    const validator = new DeliverableValidator();
-                    result = await validator.validate(data);
-                    break;
-                }
-                default:
-                    throw new Error(`Unknown validation type: ${validationType}`);
-            }
-            console.log(JSON.stringify(result, null, 2));
-            process.exit(result.passed ? 0 : 1);
-        }
-        catch (error) {
-            console.error('Validation error:', error);
-            process.exit(1);
-        }
-    })();
-}
-//# sourceMappingURL=validator.js.map

package/claude-assets/skills/cfn-loop-orchestration-v2/lib/orchestrator/dist/index.d.ts

@@ -1,14 +0,0 @@
-/**
- * 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';
-export * from './helpers/validator';
-export * from './helpers/confidence-aggregator';
-export declare const VERSION = "3.0.0";
-//# sourceMappingURL=index.d.ts.map

package/claude-assets/skills/cfn-loop-orchestration-v2/lib/orchestrator/dist/index.js

@@ -1,32 +0,0 @@
-"use strict";
-/**
- * CFN Loop Orchestration Engine - TypeScript Implementation
- * Main entry point
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.VERSION = void 0;
-__exportStar(require("./types"), exports);
-__exportStar(require("./orchestrator/orchestrator"), exports);
-__exportStar(require("./gate-checker/gate-checker"), exports);
-__exportStar(require("./agent-spawner/agent-spawner"), exports);
-__exportStar(require("./redis/redis-coordinator"), exports);
-__exportStar(require("./utils/logger"), exports);
-__exportStar(require("./helpers/validator"), exports);
-__exportStar(require("./helpers/confidence-aggregator"), exports);
-// Version
-exports.VERSION = '3.0.0';
-//# sourceMappingURL=index.js.map

package/claude-assets/skills/cfn-loop-orchestration-v2/lib/orchestrator/dist/orchestrate.d.ts

@@ -1,325 +0,0 @@
-/**
- * CFN Loop Orchestrator - Complete TypeScript Implementation
- * Orchestrates the Fail Never (CFN) Loop workflow with test-driven validation
- * Supports MVP, Standard, and Enterprise execution modes
- *
- * Version: 3.0.0
- */
-import { TestResult, ExecutionMode } from './types';
-/**
- * Execution phases in the CFN Loop
- */
-export type LoopPhase = 'loop3' | 'loop2' | 'product-owner' | 'complete';
-/**
- * Product owner decision outcomes
- */
-export type ProductOwnerDecision = 'PROCEED' | 'ITERATE' | 'ABORT' | null;
-/**
- * Timeout configuration for agent execution
- */
-export interface TimeoutConfig {
-    loop3Agent?: number;
-    loop2Agent?: number;
-    productOwner?: number;
-}
-/**
- * Orchestration configuration
- */
-export interface OrchestrationConfig {
-    taskId: string;
-    mode: ExecutionMode;
-    maxIterations: number;
-    aceReflect?: boolean;
-    loop3Agents?: string[];
-    loop2Agents?: string[];
-    productOwner?: string;
-    successCriteriaEnabled?: boolean;
-    timeouts?: TimeoutConfig;
-    workspace?: string;
-    taskDescription?: string;
-}
-/**
- * Agent execution context
- */
-export interface AgentExecutionContext {
-    agentId: string;
-    agentType: string;
-    loopType: 'loop3' | 'loop2';
-    iteration: number;
-    taskId: string;
-    timestamp: number;
-}
-/**
- * Phase transition tracking
- */
-export interface PhaseTransition {
-    fromPhase: LoopPhase;
-    toPhase: LoopPhase;
-    timestamp: number;
-    iteration: number;
-}
-/**
- * Gate check result
- */
-export interface GateCheckResult {
-    passed: boolean;
-    passRate: number;
-    threshold: number;
-    gap: number;
-}
-/**
- * Consensus validation result
- */
-export interface ConsensusValidationResult {
-    passed: boolean;
-    average: number;
-    threshold: number;
-    gap: number;
-}
-/**
- * Test result aggregation
- */
-export interface AggregatedTestResults {
-    totalPass: number;
-    totalFail: number;
-    totalSkip: number;
-    passRate: number;
-    agentCount: number;
-}
-/**
- * Orchestration state tracking
- */
-export interface OrchestrationState {
-    taskId: string;
-    mode: ExecutionMode;
-    iteration: number;
-    currentPhase: LoopPhase;
-    completedAgents: Set<string>;
-    failedAgents: Set<string>;
-    startTime: number;
-    lastUpdateTime: number;
-}
-/**
- * Feedback for next iteration
- */
-export interface IterationFeedback {
-    gatePassRate?: number;
-    consensusAverage?: number;
-    previousFailures?: string[];
-    reasons?: string[];
-    timestamp?: number;
-}
-/**
- * Main orchestrator class
- */
-export declare class Orchestrator {
-    private config;
-    private state;
-    private testResults;
-    private consensusScores;
-    private decision;
-    private errors;
-    private phaseHistory;
-    constructor(config: OrchestrationConfig);
-    /**
-     * Validate configuration parameters
-     */
-    private validateConfig;
-    /**
-     * Initialize orchestration state
-     */
-    private initializeState;
-    /**
-     * Get current orchestration state
-     */
-    getState(): OrchestrationState;
-    /**
-     * Get task ID
-     */
-    getTaskId(): string;
-    /**
-     * Get execution mode
-     */
-    getMode(): ExecutionMode;
-    /**
-     * Get maximum iterations for mode
-     */
-    getMaxIterations(): number;
-    /**
-     * Get gate threshold for current mode
-     */
-    getGateThreshold(): number;
-    /**
-     * Get consensus threshold for current mode
-     */
-    getConsensusThreshold(): number;
-    /**
-     * Get timeout configuration with defaults
-     * Defaults: Loop 3 = 300s, Loop 2 = 300s, Product Owner = 60s
-     */
-    getTimeouts(): {
-        loop3Agent: number;
-        loop2Agent: number;
-        productOwner: number;
-    };
-    /**
-     * Transition to next phase
-     */
-    transitionPhase(newPhase: LoopPhase): void;
-    /**
-     * Increment iteration counter
-     */
-    incrementIteration(): void;
-    /**
-     * Check if can continue iterating
-     */
-    canContinueIterating(): boolean;
-    /**
-     * Check if orchestration should terminate
-     */
-    shouldTerminate(): boolean;
-    /**
-     * Mark agent as completed
-     */
-    markAgentComplete(agentId: string, _loopType: 'loop3' | 'loop2'): void;
-    /**
-     * Mark agent as failed
-     */
-    markAgentFailed(agentId: string, _loopType: 'loop3' | 'loop2'): void;
-    /**
-     * Record execution error for agent
-     */
-    recordExecutionError(agentId: string, error: Error): void;
-    /**
-     * Record timeout for agent
-     */
-    recordTimeout(agentId: string, timeoutSeconds: number): void;
-    /**
-     * Record test results for agent
-     */
-    recordTestResult(agentId: string, result: TestResult): void;
-    /**
-     * Get test result for agent
-     */
-    getTestResult(agentId: string): TestResult | undefined;
-    /**
-     * Aggregate test results across all agents
-     */
-    aggregateTestResults(): AggregatedTestResults;
-    /**
-     * Check gate (Loop 3 → Loop 2 transition)
-     */
-    checkGate(passRate: number): GateCheckResult;
-    /**
-     * Record consensus score from validator
-     */
-    recordConsensusScore(validatorId: string, score: number): void;
-    /**
-     * Get all consensus scores
-     */
-    getConsensusScores(): number[];
-    /**
-     * Get consensus average
-     */
-    getConsensusAverage(): number;
-    /**
-     * Validate consensus against threshold
-     */
-    validateConsensus(): ConsensusValidationResult;
-    /**
-     * Record product owner decision
-     */
-    recordDecision(decision: ProductOwnerDecision): void;
-    /**
-     * Get recorded decision
-     */
-    getDecision(): ProductOwnerDecision;
-    /**
-     * Parse decision from agent output
-     */
-    parseDecisionFromOutput(output: string): ProductOwnerDecision;
-    /**
-     * Spawn Loop 3 (implementer) agents
-     */
-    spawnLoop3Agents(agentTypes: string[]): Promise<AgentExecutionContext[]>;
-    /**
-     * Spawn Loop 2 (validator) agents
-     */
-    spawnLoop2Validators(validatorTypes: string[]): Promise<AgentExecutionContext[]>;
-    /**
-     * Build task context string for agent spawning
-     */
-    private buildTaskContext;
-    /**
-     * Wait for agents to complete via Redis coordination
-     * Blocks until all agents signal completion or timeout occurs
-     *
-     * @param spawnResults - Results from agent spawning
-     * @param timeoutSeconds - Maximum wait time (default: 300s)
-     * @returns Array of completed agent IDs
-     */
-    private waitForAgentsToComplete;
-    /**
-     * Collect agent outputs from Redis
-     * Retrieves test results, confidence scores, and deliverables
-     *
-     * @param agentIds - List of agent IDs to collect from
-     * @returns Map of agent outputs
-     */
-    private collectAgentOutputs;
-    /**
-     * Get value from Redis using redis-cli
-     *
-     * @param key - Redis key
-     * @returns Value or null if not found
-     */
-    private getRedisValue;
-    /**
-     * Execute tests against agent deliverables
-     * Runs test suite to validate actual agent work
-     *
-     * @param agentOutputs - Map of agent outputs with deliverables
-     * @returns Aggregated test results
-     */
-    private executeTestsOnDeliverables;
-    /**
-     * Build agent context for spawning
-     */
-    buildAgentContext(agentId: string, loopType: 'loop3' | 'loop2', iteration: number, _feedback?: IterationFeedback): AgentExecutionContext;
-    /**
-     * Prepare feedback for next iteration
-     */
-    prepareFeedback(feedback: IterationFeedback): IterationFeedback;
-    /**
-     * Get phase history
-     */
-    getPhaseHistory(): PhaseTransition[];
-    /**
-     * Get execution errors
-     */
-    getErrors(): Map<string, Error>;
-    /**
-     * Reset state for new iteration
-     */
-    resetForIteration(): void;
-    /**
-     * Get orchestration summary
-     */
-    getSummary(): {
-        taskId: string;
-        mode: ExecutionMode;
-        iteration: number;
-        totalAgentsCompleted: number;
-        totalAgentsFailed: number;
-        decision: ProductOwnerDecision;
-        duration: number;
-    };
-    /**
-     * Execute the complete CFN Loop orchestration workflow
-     * Runs iterations with Loop 3 → Loop 2 → Product Owner progression
-     * Returns final decision (PROCEED/ITERATE/ABORT)
-     */
-    execute(): Promise<ProductOwnerDecision>;
-}
-export default Orchestrator;
-//# sourceMappingURL=orchestrate.d.ts.map