claude-flow-novice 2.18.5 → 2.18.7

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

@@ -1,411 +0,0 @@
-"use strict";
-/**
- * CFN Validator - Unified Validation Module
- *
- * Core validation functionality for CFN Loop system:
- * - Deliverable verification (prevents "consensus on vapor")
- * - Success criteria validation
- * - Gate threshold checking
- * - Consensus validation
- * - Vapor detection
- *
- * @module cfn-loop-validation/validator
- */
-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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CFNValidator = void 0;
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const child_process_1 = require("child_process");
-const types_1 = require("./types");
-/**
- * CFN Validator class
- */
-class CFNValidator {
-    constructor(config) {
-        this.modeThresholds = {
-            mvp: 0.70,
-            standard: 0.95,
-            enterprise: 0.98,
-        };
-        this.config = config;
-    }
-    /**
-     * Get mode-specific threshold
-     */
-    getModeThreshold(mode) {
-        const targetMode = mode || this.config.mode;
-        return this.modeThresholds[targetMode];
-    }
-    /**
-     * Validate deliverables exist and are accessible
-     */
-    async validateDeliverables(paths) {
-        const deliverables = [];
-        let totalSizeBytes = 0;
-        for (const filePath of paths) {
-            const validation = {
-                path: filePath,
-                exists: false,
-            };
-            try {
-                // Check if file exists
-                if (!fs.existsSync(filePath)) {
-                    deliverables.push(validation);
-                    continue;
-                }
-                const stats = fs.statSync(filePath);
-                validation.exists = true;
-                validation.sizeBytes = stats.size;
-                validation.lastModified = stats.mtime.toISOString();
-                validation.readable = true;
-                totalSizeBytes += stats.size;
-                // Get MIME type (basic detection)
-                validation.mimeType = this.detectMimeType(filePath);
-            }
-            catch (error) {
-                validation.exists = false;
-                validation.error = error instanceof Error ? error.message : String(error);
-                validation.readable = false;
-            }
-            deliverables.push(validation);
-        }
-        const existingFiles = deliverables.filter((d) => d.exists).length;
-        return {
-            deliverables,
-            totalFiles: paths.length,
-            existingFiles,
-            missingFiles: paths.length - existingFiles,
-            totalSizeBytes,
-            allExist: existingFiles === paths.length,
-            timestamp: Date.now(),
-        };
-    }
-    /**
-     * Check if success criteria are met
-     */
-    async checkSuccessCriteria(criteria) {
-        const results = [];
-        let passedCount = 0;
-        for (const criterion of criteria) {
-            const result = {
-                criterion,
-                passed: false,
-            };
-            try {
-                switch (criterion.type) {
-                    case 'file_exists':
-                        result.passed = await this.validateFileExists(criterion);
-                        break;
-                    case 'test_pass':
-                        result.passed = await this.validateTestPass(criterion);
-                        break;
-                    case 'command_output':
-                        result.passed = await this.validateCommandOutput(criterion);
-                        break;
-                    case 'custom':
-                        result.passed = await this.validateCustom(criterion);
-                        break;
-                }
-                if (result.passed) {
-                    passedCount++;
-                }
-            }
-            catch (error) {
-                result.error = error instanceof Error ? error.message : String(error);
-                result.passed = false;
-            }
-            results.push(result);
-        }
-        return {
-            passed: passedCount === criteria.length,
-            criteria,
-            passedCount,
-            failedCount: criteria.length - passedCount,
-            details: results,
-            timestamp: Date.now(),
-        };
-    }
-    /**
-     * Validate file exists
-     */
-    async validateFileExists(criterion) {
-        if (!criterion.paths || criterion.paths.length === 0) {
-            throw new types_1.ValidationError('No paths provided for file_exists criterion', 'INVALID_CRITERION');
-        }
-        for (const filePath of criterion.paths) {
-            if (!fs.existsSync(filePath)) {
-                return false;
-            }
-        }
-        return true;
-    }
-    /**
-     * Validate test passes
-     */
-    async validateTestPass(criterion) {
-        if (!criterion.command) {
-            throw new types_1.ValidationError('No command provided for test_pass criterion', 'INVALID_CRITERION');
-        }
-        try {
-            const timeout = criterion.timeout || 30000;
-            (0, child_process_1.execSync)(criterion.command, {
-                timeout,
-                stdio: 'pipe',
-            });
-            return true;
-        }
-        catch (error) {
-            return false;
-        }
-    }
-    /**
-     * Validate command output
-     */
-    async validateCommandOutput(criterion) {
-        if (!criterion.command) {
-            throw new types_1.ValidationError('No command provided for command_output criterion', 'INVALID_CRITERION');
-        }
-        try {
-            const timeout = criterion.timeout || 30000;
-            const output = (0, child_process_1.execSync)(criterion.command, {
-                timeout,
-                stdio: 'pipe',
-                encoding: 'utf-8',
-            });
-            if (!criterion.expected) {
-                return true;
-            }
-            return output.trim().includes(String(criterion.expected));
-        }
-        catch (error) {
-            return false;
-        }
-    }
-    /**
-     * Validate custom criterion
-     */
-    async validateCustom(criterion) {
-        // Custom validation - can be extended by subclasses
-        // For now, just return false unless explicitly implemented
-        return false;
-    }
-    /**
-     * Validate gate pass (simple threshold check)
-     */
-    async validateGatePass(passRate, mode) {
-        const targetMode = mode || this.config.mode;
-        const threshold = this.getModeThreshold(targetMode);
-        const passed = passRate >= threshold;
-        return {
-            passed,
-            passRate,
-            threshold,
-            mode: targetMode,
-            gap: passed ? 0 : threshold - passRate,
-            reason: passed
-                ? `Gate PASSED: pass rate ${(passRate * 100).toFixed(2)}% >= threshold ${(threshold * 100).toFixed(2)}%`
-                : `Gate FAILED: pass rate ${(passRate * 100).toFixed(2)}% < threshold ${(threshold * 100).toFixed(2)}%`,
-            timestamp: Date.now(),
-        };
-    }
-    /**
-     * Validate consensus pass
-     */
-    async validateConsensus(scores, mode) {
-        if (scores.length === 0) {
-            throw new types_1.ValidationError('No consensus scores provided', 'INVALID_CONSENSUS');
-        }
-        const targetMode = mode || this.config.mode;
-        const threshold = this.getModeThreshold(targetMode);
-        // Calculate average consensus score
-        const consensusScore = scores.reduce((a, b) => a + b, 0) / scores.length;
-        const passed = consensusScore >= threshold;
-        return {
-            passed,
-            consensusScore,
-            threshold,
-            mode: targetMode,
-            validatorCount: scores.length,
-            scores,
-            timestamp: Date.now(),
-        };
-    }
-    /**
-     * Detect consensus on vapor - prevents false completion claims
-     *
-     * Returns true if agent claims completion but deliverables don't exist
-     */
-    async detectConsensusOnVapor(agentOutput, expectedDeliverables) {
-        // Check if agent claims completion/success
-        const claimsCompletion = /complete|done|finished|success|delivered|implemented|created|generated/i.test(agentOutput);
-        // Validate deliverables exist
-        const validation = await this.validateDeliverables(expectedDeliverables);
-        const result = {
-            detected: claimsCompletion && !validation.allExist,
-            claimsCompletion,
-            deliverablesMissing: !validation.allExist,
-            missingDeliverables: validation.deliverables
-                .filter((d) => !d.exists)
-                .map((d) => d.path),
-            agentOutput: agentOutput.substring(0, 500), // Truncate for privacy
-            expectedDeliverables,
-            confidence: this.calculateVaporConfidence(claimsCompletion, validation.missingFiles, expectedDeliverables.length),
-            timestamp: Date.now(),
-        };
-        return result;
-    }
-    /**
-     * Calculate vapor detection confidence
-     *
-     * Higher confidence when more deliverables are missing despite completion claims
-     */
-    calculateVaporConfidence(claimsCompletion, missingFileCount, totalFileCount) {
-        if (!claimsCompletion || missingFileCount === 0) {
-            return 0.0;
-        }
-        // Confidence increases with percentage of missing files
-        const missingRatio = missingFileCount / totalFileCount;
-        return Math.min(1.0, missingRatio);
-    }
-    /**
-     * Detect MIME type from file extension
-     */
-    detectMimeType(filePath) {
-        const ext = path.extname(filePath).toLowerCase();
-        const mimeTypes = {
-            '.js': 'application/javascript',
-            '.ts': 'application/typescript',
-            '.json': 'application/json',
-            '.html': 'text/html',
-            '.css': 'text/css',
-            '.md': 'text/markdown',
-            '.txt': 'text/plain',
-            '.sh': 'application/x-sh',
-            '.py': 'text/x-python',
-            '.java': 'text/x-java-source',
-        };
-        return mimeTypes[ext] || 'application/octet-stream';
-    }
-    /**
-     * Perform comprehensive validation
-     */
-    async performValidation(options) {
-        const errors = [];
-        const warnings = [];
-        const result = {
-            taskId: this.config.taskId,
-            timestamp: Date.now(),
-            mode: this.config.mode,
-            passed: true,
-            errors,
-            warnings,
-        };
-        // Validate deliverables
-        if (options.deliverables) {
-            try {
-                result.deliverables = await this.validateDeliverables(options.deliverables);
-                if (!result.deliverables.allExist) {
-                    warnings.push(`${result.deliverables.missingFiles} deliverables missing`);
-                }
-            }
-            catch (error) {
-                errors.push(new types_1.ValidationError(`Deliverable validation failed: ${error}`, 'DELIVERABLE_VALIDATION_FAILED'));
-                result.passed = false;
-            }
-        }
-        // Validate success criteria
-        if (options.successCriteria && options.successCriteria.length > 0) {
-            try {
-                result.successCriteria = await this.checkSuccessCriteria(options.successCriteria);
-                if (!result.successCriteria.passed) {
-                    warnings.push(`${result.successCriteria.failedCount} success criteria not met`);
-                }
-            }
-            catch (error) {
-                errors.push(new types_1.ValidationError(`Success criteria validation failed: ${error}`, 'CRITERIA_VALIDATION_FAILED'));
-                result.passed = false;
-            }
-        }
-        // Validate gate
-        if (typeof options.passRate === 'number') {
-            try {
-                result.gate = await this.validateGatePass(options.passRate);
-                if (!result.gate.passed) {
-                    result.passed = false;
-                }
-            }
-            catch (error) {
-                errors.push(new types_1.ValidationError(`Gate validation failed: ${error}`, 'GATE_VALIDATION_FAILED'));
-                result.passed = false;
-            }
-        }
-        // Validate consensus
-        if (options.consensusScores && options.consensusScores.length > 0) {
-            try {
-                result.consensus = await this.validateConsensus(options.consensusScores);
-                if (!result.consensus.passed) {
-                    result.passed = false;
-                }
-            }
-            catch (error) {
-                errors.push(new types_1.ValidationError(`Consensus validation failed: ${error}`, 'CONSENSUS_VALIDATION_FAILED'));
-                result.passed = false;
-            }
-        }
-        // Detect vapor
-        if (options.agentOutput &&
-            options.deliverables &&
-            options.deliverables.length > 0) {
-            try {
-                result.vapor = await this.detectConsensusOnVapor(options.agentOutput, options.deliverables);
-                if (result.vapor.detected) {
-                    errors.push(new types_1.ConsensusOnVaporError('Consensus on vapor detected: agent claims completion but deliverables missing', {
-                        missingDeliverables: result.vapor.missingDeliverables,
-                        confidence: result.vapor.confidence,
-                    }));
-                    result.passed = false;
-                }
-            }
-            catch (error) {
-                errors.push(new types_1.ValidationError(`Vapor detection failed: ${error}`, 'VAPOR_DETECTION_FAILED'));
-            }
-        }
-        return result;
-    }
-}
-exports.CFNValidator = CFNValidator;
-exports.default = CFNValidator;
-//# sourceMappingURL=validator.js.map

package/claude-assets/skills/cfn-loop-orchestration-v2/lib/validation/orchestrate-cfn-loop.sh.backup

@@ -1,252 +0,0 @@
-#!/usr/bin/env bash
-
-##############################################################################
-# CFN Loop Orchestration v1.0.0
-# Manages multi-loop CFN execution with dependency tracking and consensus
-#
-# Usage:
-#   ./orchestrate-cfn-loop.sh --task-id <id> \
-#                             --mode <mvp|standard|enterprise> \
-#                             --loop3-agents <agent1,agent2,...> \
-#                             --loop2-agents <agent1,agent2,...> \
-#                             --product-owner <agent-id> \
-#                             [--max-iterations <n>]
-#
-# CFN Loop Structure:
-#   Loop 3 (Primary Swarm) → Loop 2 (Consensus) → Product Owner Decision
-#
-# Dependency Enforcement:
-#   - Loop 2 agents BLOCK until all Loop 3 agents signal completion
-#   - Product Owner BLOCKS until all Loop 2 agents signal completion
-#   - Uses Redis BLPOP for zero-token waiting
-##############################################################################
-
-set -euo pipefail
-
-# Configuration
-TASK_ID=""
-MODE="standard"
-LOOP3_AGENTS=""
-LOOP2_AGENTS=""
-PRODUCT_OWNER=""
-MAX_ITERATIONS=10
-TIMEOUT=3600  # 1 hour timeout for agent completion
-
-# Thresholds by mode
-declare -A GATE_THRESHOLD=(
-  [mvp]=0.70
-  [standard]=0.75
-  [enterprise]=0.75
-)
-
-declare -A CONSENSUS_THRESHOLD=(
-  [mvp]=0.80
-  [standard]=0.90
-  [enterprise]=0.95
-)
-
-# Parse arguments
-while [[ $# -gt 0 ]]; do
-  case $1 in
-    --task-id)
-      TASK_ID="$2"
-      shift 2
-      ;;
-    --mode)
-      MODE="$2"
-      shift 2
-      ;;
-    --loop3-agents)
-      LOOP3_AGENTS="$2"
-      shift 2
-      ;;
-    --loop2-agents)
-      LOOP2_AGENTS="$2"
-      shift 2
-      ;;
-    --product-owner)
-      PRODUCT_OWNER="$2"
-      shift 2
-      ;;
-    --max-iterations)
-      MAX_ITERATIONS="$2"
-      shift 2
-      ;;
-    *)
-      echo "Unknown option: $1"
-      exit 1
-      ;;
-  esac
-done
-
-# Validation
-if [ -z "$TASK_ID" ] || [ -z "$LOOP3_AGENTS" ] || [ -z "$LOOP2_AGENTS" ] || [ -z "$PRODUCT_OWNER" ]; then
-  echo "Error: Required parameters missing"
-  echo "Usage: $0 --task-id <id> --mode <mode> --loop3-agents <agents> --loop2-agents <agents> --product-owner <agent>"
-  exit 1
-fi
-
-GATE=${GATE_THRESHOLD[$MODE]}
-CONSENSUS=${CONSENSUS_THRESHOLD[$MODE]}
-
-echo "=== CFN Loop Orchestration ==="
-echo "Task ID: $TASK_ID"
-echo "Mode: $MODE (Gate: $GATE, Consensus: $CONSENSUS)"
-echo "Max Iterations: $MAX_ITERATIONS"
-echo ""
-
-# Iteration loop
-for ITERATION in $(seq 1 $MAX_ITERATIONS); do
-  echo "=== Iteration $ITERATION/$MAX_ITERATIONS ==="
-
-  # Step 1: Wait for Loop 3 agents to complete
-  echo "[Loop 3] Waiting for implementers to complete..."
-  IFS=',' read -ra AGENTS <<< "$LOOP3_AGENTS"
-
-  for AGENT in "${AGENTS[@]}"; do
-    DONE_KEY="swarm:${TASK_ID}:${AGENT}:done"
-    echo "  Waiting for $AGENT..."
-
-    # BLPOP with timeout (blocks until agent signals done)
-    RESULT=$(timeout $TIMEOUT redis-cli blpop "$DONE_KEY" 0 2>/dev/null || echo "")
-
-    if [ -z "$RESULT" ]; then
-      echo "  ❌ ERROR: $AGENT timeout after ${TIMEOUT}s"
-      exit 1
-    fi
-
-    echo "  ✅ $AGENT complete"
-  done
-
-  echo "[Loop 3] All implementers complete!"
-  echo ""
-
-  # Step 2: Collect Loop 3 confidence scores
-  echo "[Loop 3] Collecting confidence scores..."
-  LOOP3_CONSENSUS=$(./.claude/skills/cfn-redis-coordination/invoke-waiting-mode.sh collect \
-    --task-id "$TASK_ID" \
-    --agent-ids "$LOOP3_AGENTS" | tail -1)
-
-  echo "[Loop 3] Average confidence: $LOOP3_CONSENSUS"
-
-  # Gate check
-  if (( $(echo "$LOOP3_CONSENSUS < $GATE" | bc -l) )); then
-    echo "❌ Gate FAILED ($LOOP3_CONSENSUS < $GATE)"
-    echo "Decision: RELAUNCH iteration $((ITERATION + 1))"
-
-    # Wake Loop 3 agents for next iteration
-    IFS=',' read -ra AGENTS <<< "$LOOP3_AGENTS"
-    for AGENT in "${AGENTS[@]}"; do
-      ./.claude/skills/cfn-redis-coordination/invoke-waiting-mode.sh wake \
-        --task-id "$TASK_ID" \
-        --agent-id "$AGENT" \
-        --reason "gate_failed" \
-        --iteration $((ITERATION + 1)) \
-        --feedback "Improve confidence from $LOOP3_CONSENSUS to >$GATE"
-    done
-
-    continue  # Next iteration
-  fi
-
-  echo "✅ Gate PASSED ($LOOP3_CONSENSUS >= $GATE)"
-  echo ""
-
-  # Step 3: Wait for Loop 2 validators to complete
-  echo "[Loop 2] Waiting for validators to complete..."
-  IFS=',' read -ra VALIDATORS <<< "$LOOP2_AGENTS"
-
-  for VALIDATOR in "${VALIDATORS[@]}"; do
-    DONE_KEY="swarm:${TASK_ID}:${VALIDATOR}:done"
-    echo "  Waiting for $VALIDATOR..."
-
-    RESULT=$(timeout $TIMEOUT redis-cli blpop "$DONE_KEY" 0 2>/dev/null || echo "")
-
-    if [ -z "$RESULT" ]; then
-      echo "  ❌ ERROR: $VALIDATOR timeout after ${TIMEOUT}s"
-      exit 1
-    fi
-
-    echo "  ✅ $VALIDATOR complete"
-  done
-
-  echo "[Loop 2] All validators complete!"
-  echo ""
-
-  # Step 4: Collect Loop 2 consensus scores
-  echo "[Loop 2] Collecting consensus scores..."
-  LOOP2_CONSENSUS=$(./.claude/skills/cfn-redis-coordination/invoke-waiting-mode.sh collect \
-    --task-id "$TASK_ID" \
-    --agent-ids "$LOOP2_AGENTS" | tail -1)
-
-  echo "[Loop 2] Average consensus: $LOOP2_CONSENSUS"
-
-  # Consensus check
-  if (( $(echo "$LOOP2_CONSENSUS >= $CONSENSUS" | bc -l) )); then
-    echo "✅ CONSENSUS REACHED ($LOOP2_CONSENSUS >= $CONSENSUS)"
-    echo ""
-
-    # Signal Product Owner that consensus is ready
-    DECISION_KEY="swarm:${TASK_ID}:${PRODUCT_OWNER}:consensus-ready"
-    redis-cli lpush "$DECISION_KEY" "{\"iteration\": $ITERATION, \"consensus\": $LOOP2_CONSENSUS}" > /dev/null
-
-    # Wait for Product Owner decision
-    echo "[Product Owner] Waiting for GOAP decision..."
-    DECISION_KEY="swarm:${TASK_ID}:${PRODUCT_OWNER}:decision"
-    DECISION=$(timeout $TIMEOUT redis-cli blpop "$DECISION_KEY" 0 2>/dev/null | tail -1)
-
-    if [ -z "$DECISION" ]; then
-      echo "❌ ERROR: Product Owner timeout"
-      exit 1
-    fi
-
-    DECISION_TYPE=$(echo "$DECISION" | jq -r '.decision')
-
-    echo "[Product Owner] Decision: $DECISION_TYPE"
-
-    if [ "$DECISION_TYPE" = "PROCEED" ]; then
-      echo ""
-      echo "🎉 CFN Loop Complete!"
-      echo "Final Consensus: $LOOP2_CONSENSUS (Iteration $ITERATION)"
-
-      # Wake all agents with completion signal
-      IFS=',' read -ra ALL_AGENTS <<< "$LOOP3_AGENTS,$LOOP2_AGENTS"
-      for AGENT in "${ALL_AGENTS[@]}"; do
-        ./.claude/skills/cfn-redis-coordination/invoke-waiting-mode.sh wake \
-          --task-id "$TASK_ID" \
-          --agent-id "$AGENT" \
-          --reason "cfn_complete" \
-          --iteration "$ITERATION"
-      done
-
-      exit 0
-    fi
-
-  else
-    echo "⚠️ CONSENSUS NOT REACHED ($LOOP2_CONSENSUS < $CONSENSUS)"
-    echo "Decision: RELAUNCH iteration $((ITERATION + 1))"
-    echo ""
-  fi
-
-  # Relaunch next iteration
-  if [ $ITERATION -eq $MAX_ITERATIONS ]; then
-    echo "❌ Maximum iterations ($MAX_ITERATIONS) reached without consensus"
-    exit 1
-  fi
-
-  # Wake all agents for next iteration
-  echo "[Coordinator] Waking agents for iteration $((ITERATION + 1))..."
-  IFS=',' read -ra ALL_AGENTS <<< "$LOOP3_AGENTS,$LOOP2_AGENTS"
-  for AGENT in "${ALL_AGENTS[@]}"; do
-    ./.claude/skills/cfn-redis-coordination/invoke-waiting-mode.sh wake \
-      --task-id "$TASK_ID" \
-      --agent-id "$AGENT" \
-      --reason "cfn_loop_iteration" \
-      --iteration $((ITERATION + 1)) \
-      --feedback "Improve consensus from $LOOP2_CONSENSUS to >=$CONSENSUS"
-  done
-
-  echo ""
-done
-
-echo "❌ CFN Loop failed after $MAX_ITERATIONS iterations"
-exit 1