claude-flow-novice 2.18.6 → 2.18.8

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

@@ -1,359 +0,0 @@
-"use strict";
-/**
- * Confidence Score Aggregation
- *
- * Aggregates and analyzes confidence scores from Loop 3 implementers.
- * Provides statistical analysis, outlier detection, and validation.
- *
- * Phase 4 · P1 Priority · Loop 3 Score Aggregation
- * Target: 224 LOC (actual: ~230 LOC)
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateScoreRange = validateScoreRange;
-exports.detectOutliers = detectOutliers;
-exports.aggregateScores = aggregateScores;
-exports.calculateWeightedAverage = calculateWeightedAverage;
-exports.groupByAgentType = groupByAgentType;
-exports.analyzeByAgentType = analyzeByAgentType;
-exports.identifyLowPerformers = identifyLowPerformers;
-exports.generateSummary = generateSummary;
-/**
- * Validates that a confidence score is in valid range [0.0, 1.0]
- * @param score The score to validate
- * @returns true if valid, false otherwise
- */
-function validateScoreRange(score) {
-    return typeof score === 'number' && score >= 0.0 && score <= 1.0;
-}
-/**
- * Detects outliers using Interquartile Range (IQR) method
- * @param scores Array of confidence scores
- * @param threshold IQR multiplier (default 1.5)
- * @returns Outlier detection result
- */
-function detectOutliers(scores, threshold = 1.5) {
-    if (scores.length < 4) {
-        // Not enough data for meaningful outlier detection
-        return {
-            outliers: [],
-            isOutlier: () => false,
-            outlierCount: 0,
-            outlierPercentage: 0
-        };
-    }
-    // Sort scores numerically
-    const sortedScores = [...scores].sort((a, b) => a.score - b.score);
-    const n = sortedScores.length;
-    // Calculate quartiles
-    const q1Index = Math.floor(n * 0.25);
-    const q3Index = Math.floor(n * 0.75);
-    const q1Element = sortedScores[q1Index];
-    const q3Element = sortedScores[q3Index];
-    if (!q1Element || !q3Element) {
-        // Safeguard against undefined elements
-        return {
-            outliers: [],
-            isOutlier: () => false,
-            outlierCount: 0,
-            outlierPercentage: 0
-        };
-    }
-    const q1 = q1Element.score;
-    const q3 = q3Element.score;
-    const iqr = q3 - q1;
-    // Calculate outlier bounds
-    const lowerBound = q1 - threshold * iqr;
-    const upperBound = q3 + threshold * iqr;
-    // Identify outliers
-    const outliers = scores.filter(s => s.score < lowerBound || s.score > upperBound);
-    const isOutlier = (score) => score.score < lowerBound || score.score > upperBound;
-    return {
-        outliers,
-        isOutlier,
-        outlierCount: outliers.length,
-        outlierPercentage: (outliers.length / scores.length) * 100
-    };
-}
-/**
- * Calculates median of scores
- * @param sortedScores Pre-sorted array of score numbers
- * @returns Median value
- */
-function calculateMedian(sortedScores) {
-    const n = sortedScores.length;
-    if (n === 0)
-        return 0;
-    if (n % 2 === 1) {
-        const midIndex = Math.floor(n / 2);
-        return sortedScores[midIndex] ?? 0;
-    }
-    const mid1 = sortedScores[n / 2 - 1] ?? 0;
-    const mid2 = sortedScores[n / 2] ?? 0;
-    return (mid1 + mid2) / 2;
-}
-/**
- * Calculates standard deviation
- * @param scores Array of score numbers
- * @param average Pre-calculated average
- * @returns Standard deviation
- */
-function calculateStdDev(scores, average) {
-    if (scores.length < 2)
-        return 0;
-    const variance = scores.reduce((sum, score) => {
-        return sum + Math.pow(score - average, 2);
-    }, 0) / scores.length;
-    return Math.sqrt(variance);
-}
-/**
- * Calculates statistical measures for scores
- * @param scores Array of confidence scores
- * @returns ScoreStatistics object
- */
-function calculateStatistics(scores) {
-    if (scores.length === 0) {
-        return {
-            min: 0,
-            max: 0,
-            average: 0,
-            median: 0,
-            stddev: 0,
-            count: 0,
-            range: 0,
-            variance: 0
-        };
-    }
-    const numericScores = scores.map(s => s.score);
-    const sum = numericScores.reduce((a, b) => a + b, 0);
-    const average = sum / numericScores.length;
-    const min = Math.min(...numericScores);
-    const max = Math.max(...numericScores);
-    const sortedScores = [...numericScores].sort((a, b) => a - b);
-    const median = calculateMedian(sortedScores);
-    const stddev = calculateStdDev(numericScores, average);
-    const variance = Math.pow(stddev, 2);
-    return {
-        min,
-        max,
-        average,
-        median,
-        stddev,
-        count: scores.length,
-        range: max - min,
-        variance
-    };
-}
-/**
- * Aggregates confidence scores with full statistical analysis
- * @param scores Array of confidence scores to aggregate
- * @returns AggregatedConfidence with statistics and validation
- */
-function aggregateScores(scores) {
-    const validationErrors = [];
-    const timestamp = Date.now();
-    // Validate input
-    if (!scores || !Array.isArray(scores)) {
-        validationErrors.push('Scores must be a non-empty array');
-        return {
-            scores: [],
-            statistics: {
-                min: 0,
-                max: 0,
-                average: 0,
-                median: 0,
-                stddev: 0,
-                count: 0,
-                range: 0,
-                variance: 0
-            },
-            outliers: [],
-            aggregateScore: 0,
-            confidence: 0,
-            isValid: false,
-            validationErrors,
-            timestamp
-        };
-    }
-    if (scores.length === 0) {
-        validationErrors.push('No scores provided');
-        return {
-            scores: [],
-            statistics: {
-                min: 0,
-                max: 0,
-                average: 0,
-                median: 0,
-                stddev: 0,
-                count: 0,
-                range: 0,
-                variance: 0
-            },
-            outliers: [],
-            aggregateScore: 0,
-            confidence: 0,
-            isValid: false,
-            validationErrors,
-            timestamp
-        };
-    }
-    // Validate all scores
-    const validScores = [];
-    for (const score of scores) {
-        if (!validateScoreRange(score.score)) {
-            validationErrors.push(`Invalid score from ${score.agentId}: ${score.score} (must be 0.0-1.0)`);
-        }
-        else {
-            validScores.push(score);
-        }
-    }
-    // Calculate statistics
-    const statistics = calculateStatistics(validScores);
-    // Detect outliers
-    const outlierResult = detectOutliers(validScores);
-    // Aggregate score = average of valid scores
-    const aggregateScore = statistics.average;
-    // Confidence score based on consistency (inverse of stddev)
-    // High stddev = low consistency = low confidence
-    const maxStdDev = 0.5; // Normalize by reasonable max stddev
-    const confidenceFromConsistency = Math.max(0, 1 - (statistics.stddev / maxStdDev));
-    // Confidence also considers number of agents (more agents = higher confidence)
-    const agentScaling = Math.min(1, validScores.length / 5);
-    const confidence = (aggregateScore + confidenceFromConsistency + agentScaling) / 3;
-    // Determine validity
-    const isValid = validationErrors.length === 0 && validScores.length > 0;
-    return {
-        scores: validScores,
-        statistics,
-        outliers: outlierResult.outliers,
-        aggregateScore,
-        confidence: Math.min(1.0, Math.max(0.0, confidence)),
-        isValid,
-        validationErrors,
-        timestamp
-    };
-}
-/**
- * Calculates weighted average of confidence scores
- * @param scores Array of confidence scores
- * @param weightMap Map of agentId to weight (will be normalized)
- * @returns WeightedAggregation result
- */
-function calculateWeightedAverage(scores, weightMap) {
-    if (scores.length === 0) {
-        return {
-            weights: new Map(),
-            weightedScore: 0,
-            normalizedWeights: new Map(),
-            contributionMap: new Map()
-        };
-    }
-    // Default weights: equal distribution
-    let weights = weightMap || new Map();
-    if (weights.size === 0) {
-        const equalWeight = 1 / scores.length;
-        weights = new Map(scores.map(s => [s.agentId, equalWeight]));
-    }
-    // Normalize weights to sum to 1.0
-    const totalWeight = Array.from(weights.values()).reduce((a, b) => a + b, 0);
-    const normalizedWeights = new Map(Array.from(weights.entries()).map(([agentId, weight]) => [
-        agentId,
-        weight / totalWeight
-    ]));
-    // Calculate weighted score
-    let weightedScore = 0;
-    const contributionMap = new Map();
-    for (const score of scores) {
-        const weight = normalizedWeights.get(score.agentId) || 0;
-        const contribution = score.score * weight;
-        weightedScore += contribution;
-        contributionMap.set(score.agentId, contribution);
-    }
-    return {
-        weights,
-        weightedScore: Math.min(1.0, Math.max(0.0, weightedScore)),
-        normalizedWeights,
-        contributionMap
-    };
-}
-/**
- * Groups scores by agent type for analysis
- * @param scores Array of confidence scores
- * @returns Map of agentType to their scores
- */
-function groupByAgentType(scores) {
-    const grouped = new Map();
-    for (const score of scores) {
-        if (!grouped.has(score.agentType)) {
-            grouped.set(score.agentType, []);
-        }
-        grouped.get(score.agentType).push(score);
-    }
-    return grouped;
-}
-/**
- * Analyzes confidence scores by agent type
- * @param scores Array of confidence scores
- * @returns Map of agentType to their statistics
- */
-function analyzeByAgentType(scores) {
-    const grouped = groupByAgentType(scores);
-    const analysis = new Map();
-    for (const [agentType, typeScores] of grouped.entries()) {
-        analysis.set(agentType, calculateStatistics(typeScores));
-    }
-    return analysis;
-}
-/**
- * Identifies potentially problematic agents (consistently low scores)
- * @param scores Array of confidence scores
- * @param threshold Minimum acceptable average (default 0.75)
- * @returns Array of agents with low average scores
- */
-function identifyLowPerformers(scores, threshold = 0.75) {
-    const grouped = groupByAgentType(scores);
-    const lowPerformers = [];
-    for (const typeScores of grouped.values()) {
-        const stats = calculateStatistics(typeScores);
-        if (stats.average < threshold) {
-            lowPerformers.push(...typeScores);
-        }
-    }
-    return lowPerformers;
-}
-/**
- * Generates a human-readable summary of aggregated scores
- * @param aggregated The aggregated confidence result
- * @returns Summary string
- */
-function generateSummary(aggregated) {
-    const lines = [];
-    lines.push('=== Confidence Score Aggregation Summary ===');
-    lines.push(`Total Agents: ${aggregated.statistics.count}`);
-    lines.push(`Aggregate Score: ${aggregated.aggregateScore.toFixed(3)}`);
-    lines.push(`Confidence: ${aggregated.confidence.toFixed(3)}`);
-    lines.push('');
-    lines.push('Statistics:');
-    lines.push(`  Min: ${aggregated.statistics.min.toFixed(3)}`);
-    lines.push(`  Max: ${aggregated.statistics.max.toFixed(3)}`);
-    lines.push(`  Average: ${aggregated.statistics.average.toFixed(3)}`);
-    lines.push(`  Median: ${aggregated.statistics.median.toFixed(3)}`);
-    lines.push(`  StdDev: ${aggregated.statistics.stddev.toFixed(3)}`);
-    lines.push(`  Range: ${aggregated.statistics.range.toFixed(3)}`);
-    if (aggregated.outliers.length > 0) {
-        lines.push('');
-        lines.push(`Outliers (${aggregated.outliers.length}):`);
-        for (const outlier of aggregated.outliers) {
-            lines.push(`  - ${outlier.agentId}: ${outlier.score.toFixed(3)}`);
-        }
-    }
-    if (aggregated.validationErrors.length > 0) {
-        lines.push('');
-        lines.push('Validation Errors:');
-        for (const error of aggregated.validationErrors) {
-            lines.push(`  - ${error}`);
-        }
-    }
-    lines.push(`Validity: ${aggregated.isValid ? 'Valid' : 'Invalid'}`);
-    return lines.join('\n');
-}
-//# sourceMappingURL=confidence-aggregator.js.map

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

@@ -1,36 +0,0 @@
-/**
- * Consensus Collection and Validation
- * Collects Loop 2 validator scores and validates against thresholds
- */
-export interface ConsensusResult {
-    scores: number[];
-    average: number;
-    count: number;
-    min: number;
-    max: number;
-}
-export interface ConsensusValidation {
-    passed: boolean;
-    average: number;
-    threshold: number;
-    mode: string;
-    gap: number;
-}
-export type Mode = 'mvp' | 'standard' | 'enterprise';
-/**
- * Collects consensus scores from multiple validators
- * @param scores Array of validator confidence scores (0.0-1.0)
- * @returns ConsensusResult with statistics
- */
-export declare function collectConsensus(scores: number[]): ConsensusResult;
-/**
- * Validates consensus against mode-specific threshold
- * @param params Validation parameters
- * @returns ConsensusValidation result
- */
-export declare function validateConsensus(params: {
-    average: number;
-    threshold?: number | undefined;
-    mode: Mode | string;
-}): ConsensusValidation;
-//# sourceMappingURL=consensus.d.ts.map

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

@@ -1,62 +0,0 @@
-"use strict";
-/**
- * Consensus Collection and Validation
- * Collects Loop 2 validator scores and validates against thresholds
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.collectConsensus = collectConsensus;
-exports.validateConsensus = validateConsensus;
-const MODE_THRESHOLDS = {
-    mvp: 0.80,
-    standard: 0.90,
-    enterprise: 0.95
-};
-/**
- * Collects consensus scores from multiple validators
- * @param scores Array of validator confidence scores (0.0-1.0)
- * @returns ConsensusResult with statistics
- */
-function collectConsensus(scores) {
-    if (!scores || scores.length === 0) {
-        throw new Error('No consensus scores provided');
-    }
-    // Validate all scores are in valid range
-    for (const score of scores) {
-        if (score < 0 || score > 1.0) {
-            throw new Error(`Invalid consensus score: ${score} (must be 0.0-1.0)`);
-        }
-    }
-    // Calculate statistics
-    const sum = scores.reduce((acc, score) => acc + score, 0);
-    const average = sum / scores.length;
-    const min = Math.min(...scores);
-    const max = Math.max(...scores);
-    return {
-        scores,
-        average,
-        count: scores.length,
-        min,
-        max
-    };
-}
-/**
- * Validates consensus against mode-specific threshold
- * @param params Validation parameters
- * @returns ConsensusValidation result
- */
-function validateConsensus(params) {
-    // Use explicit threshold if provided, otherwise use mode default
-    const threshold = params.threshold !== undefined
-        ? params.threshold
-        : MODE_THRESHOLDS[params.mode] || 0.90;
-    const passed = params.average >= threshold;
-    const gap = params.average - threshold;
-    return {
-        passed,
-        average: params.average,
-        threshold,
-        mode: params.mode,
-        gap
-    };
-}
-//# sourceMappingURL=consensus.js.map

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

@@ -1,135 +0,0 @@
-/**
- * Context Injector - Broadcast Message Builder
- * Constructs context messages for agent execution in CFN Loop
- * Implements iteration tracking, phase awareness, and success criteria injection
- *
- * Used by: cfn-loop-orchestration to broadcast agent context across Redis
- * Reference: helpers/context-injection.sh (142 LOC) - shell predecessor
- */
-import { ExecutionMode } from '../types';
-/**
- * Loop phase enumeration
- */
-export type LoopPhase = 'loop3' | 'loop2' | 'product-owner' | 'iteration-prep';
-/**
- * Success criteria for task execution
- */
-export interface SuccessCriteria {
-    criteria: string[];
-    testPassRate: number;
-    consensusThreshold: number;
-}
-/**
- * Broadcast context message for agent execution
- */
-export interface BroadcastContext {
-    taskId: string;
-    iteration: number;
-    phase: LoopPhase;
-    mode: ExecutionMode;
-    agentIds?: string[] | undefined;
-    successCriteria?: SuccessCriteria | undefined;
-    taskDescription?: string | undefined;
-    timestamp: string;
-    contextVersion: string;
-}
-/**
- * Result of successful broadcast context construction
- */
-export interface BroadcastResult {
-    context: BroadcastContext;
-    json: string;
-    messageCount: number;
-}
-/**
- * Build broadcast context for agent execution
- *
- * @param params Context parameters
- * @returns BroadcastResult with JSON-formatted message
- * @throws Error if required fields are missing
- *
- * @example
- * ```typescript
- * const result = buildBroadcastContext({
- *   taskId: 'task-123',
- *   iteration: 1,
- *   phase: 'loop3',
- *   mode: 'standard',
- *   agentIds: ['agent-1', 'agent-2']
- * });
- *
- * console.log(result.json); // JSON string for Redis broadcast
- * ```
- */
-export declare function buildBroadcastContext(params: {
-    taskId: string;
-    iteration: number;
-    phase: LoopPhase;
-    mode: ExecutionMode;
-    agentIds?: string[] | undefined;
-    successCriteria?: SuccessCriteria | undefined;
-    taskDescription?: string | undefined;
-}): BroadcastResult;
-/**
- * Build multiple broadcast messages for different agents
- *
- * @param baseContext Base context parameters
- * @param agentContexts Per-agent context overrides
- * @returns Array of broadcast contexts
- *
- * @example
- * ```typescript
- * const messages = buildBroadcastMessages(
- *   { taskId: 'task-1', iteration: 1, phase: 'loop3', mode: 'standard' },
- *   [
- *     { agentId: 'loop3-backend-1', agentType: 'backend-engineer' },
- *     { agentId: 'loop3-frontend-1', agentType: 'react-frontend-engineer' }
- *   ]
- * );
- * ```
- */
-export declare function buildBroadcastMessages(baseContext: {
-    taskId: string;
-    iteration: number;
-    phase: LoopPhase;
-    mode: ExecutionMode;
-    successCriteria?: SuccessCriteria;
-    taskDescription?: string;
-}, agentContexts: Array<{
-    agentId: string;
-    agentType: string;
-}>): BroadcastContext[];
-/**
- * Build iteration-specific broadcast context for agent wake operations
- *
- * @param taskId Unique task identifier
- * @param iteration Current iteration number
- * @param mode Execution mode
- * @param feedback Optional feedback for next iteration
- * @returns BroadcastContext for iteration prep
- */
-export declare function buildIterationContext(taskId: string, iteration: number, mode: ExecutionMode, feedback?: unknown): BroadcastContext;
-/**
- * Format context as JSON for Redis broadcast
- *
- * @param context Broadcast context
- * @param compact If true, removes whitespace
- * @returns JSON string
- */
-export declare function formatContextJson(context: BroadcastContext, compact?: boolean): string;
-/**
- * Parse broadcast context from JSON
- *
- * @param json JSON string containing broadcast context
- * @returns Parsed BroadcastContext
- * @throws Error if JSON is invalid or missing required fields
- */
-export declare function parseBroadcastContext(json: string): BroadcastContext;
-/**
- * Merge multiple broadcast contexts for multi-phase execution
- *
- * @param contexts Array of broadcast contexts
- * @returns Merged context with combined agentIds
- */
-export declare function mergeBroadcastContexts(contexts: BroadcastContext[]): BroadcastContext;
-//# sourceMappingURL=context-injector.d.ts.map