0xray 4.0.12 → 4.0.13

package/dist/delegation/complexity-analyzer.d.ts

@@ -1,110 +0,0 @@
-/**
- * Complexity Analyzer
- *
- * Assesses operation complexity to determine optimal agent delegation strategy.
- * Implements metrics-based complexity scoring for intelligent task distribution.
- *
- * CALIBRATED: Thresholds lowered to enable multi-agent orchestration with voting
- * - simple: 15 - single agent tasks
- * - moderate: 25 - multi-agent preparation
- * - complex: 50+ - multi-agent orchestration with voting
- * - enterprise: 75+ - maximum orchestration
- *
- * @since 2026-01-07
- */
-import { ComplexityMetrics, ComplexityScore, ComplexityThresholds, ComplexityLevel, DelegationStrategy } from "./complexity-core.js";
-export type { ComplexityMetrics, ComplexityScore, ComplexityThresholds, ComplexityLevel, DelegationStrategy, };
-/**
- * Complexity Analyzer
- * Analyzes operations and calculates complexity scores
- */
-export declare class ComplexityAnalyzer {
-    private static readonly MAX_CALIBRATION_HISTORY;
-    /**
-     * CALIBRATED: Adjusted thresholds for balanced orchestration utilization
-     * - simple: 15 - single agent tasks
-     * - moderate: 25 - multi-agent preparation
-     * - complex: 50 - complex tasks get multi-agent coordination with voting
-     * - enterprise: 75 - maximum orchestration (only extreme cases)
-     */
-    private thresholds;
-    private operationWeights;
-    private riskMultipliers;
-    /**
-     * Analyze operation complexity and return detailed metrics
-     */
-    analyzeComplexity(operation: string, context: unknown): ComplexityMetrics;
-    /**
-     * Calculate complexity score and delegation strategy
-     *
-     * CALIBRATED: Weights increased to properly utilize orchestration
-     * - File count: 4 pts/file (was 2) - better reflects multi-file complexity
-     * - Change volume: 0.2/line (was 0.1) - better reflects code volume
-     * - Dependencies: 5 each (was 3) - better reflects coordination needs
-     */
-    calculateComplexityScore(metrics: ComplexityMetrics): ComplexityScore;
-    /**
-     * Performance data structure for calibration
-     */
-    private calibrationHistory;
-    /**
-     * Update thresholds based on historical performance data
-     * Analyzes: task score vs completion time vs success rate
-     * to automatically adjust thresholds for better accuracy
-     */
-    updateThresholds(performanceData: unknown): void;
-    /**
-     * Analyze calibration data to find patterns
-     */
-    private analyzeCalibrationData;
-    /**
-     * Apply calibration analysis to adjust thresholds
-     */
-    private applyCalibrationAnalysis;
-    /**
-     * Get calibration history for diagnostics
-     */
-    getCalibrationHistory(): ReadonlyArray<{
-        complexityScore: number;
-        actualDuration: number;
-        estimatedDuration: number;
-        success: boolean;
-        timestamp: number;
-    }>;
-    /**
-     * Reset calibration history
-     */
-    resetCalibration(): void;
-    /**
-     * Get current complexity thresholds
-     */
-    getThresholds(): ComplexityThresholds;
-    /**
-     * Set custom complexity thresholds
-     */
-    setThresholds(thresholds: Partial<ComplexityThresholds>): void;
-    /**
-     * Set operation type weights (from calibrator)
-     */
-    setOperationWeights(weights: Partial<Record<string, number>>): void;
-    /**
-     * Set risk level multipliers (from calibrator)
-     */
-    setRiskMultipliers(multipliers: Partial<Record<string, number>>): void;
-    /**
-     * Calibrate analyzer based on calibrator recommendations
-     */
-    calibrate(settings: {
-        thresholds?: Partial<ComplexityThresholds>;
-        operationWeights?: Partial<Record<string, number>>;
-        riskMultipliers?: Partial<Record<string, number>>;
-    }): void;
-    private calculateFileCount;
-    private calculateChangeVolume;
-    private determineOperationType;
-    private calculateDependencies;
-    private assessRiskLevel;
-    private estimateDuration;
-}
-export declare function getComplexityAnalyzer(): ComplexityAnalyzer;
-export declare const complexityAnalyzer: ComplexityAnalyzer;

package/dist/delegation/complexity-analyzer.js

@@ -1,281 +0,0 @@
-/**
- * Complexity Analyzer
- *
- * Assesses operation complexity to determine optimal agent delegation strategy.
- * Implements metrics-based complexity scoring for intelligent task distribution.
- *
- * CALIBRATED: Thresholds lowered to enable multi-agent orchestration with voting
- * - simple: 15 - single agent tasks
- * - moderate: 25 - multi-agent preparation
- * - complex: 50+ - multi-agent orchestration with voting
- * - enterprise: 75+ - maximum orchestration
- *
- * @since 2026-01-07
- */
-import { DEFAULT_THRESHOLDS, OPERATION_WEIGHTS, RISK_MULTIPLIERS, getLevelFromScore, getStrategyForLevel, getAgentCountForLevel, generateReasoning, } from "./complexity-core.js";
-/**
- * Complexity Analyzer
- * Analyzes operations and calculates complexity scores
- */
-export class ComplexityAnalyzer {
-    static MAX_CALIBRATION_HISTORY = 1000;
-    /**
-     * CALIBRATED: Adjusted thresholds for balanced orchestration utilization
-     * - simple: 15 - single agent tasks
-     * - moderate: 25 - multi-agent preparation
-     * - complex: 50 - complex tasks get multi-agent coordination with voting
-     * - enterprise: 75 - maximum orchestration (only extreme cases)
-     */
-    thresholds = { ...DEFAULT_THRESHOLDS };
-    operationWeights = { ...OPERATION_WEIGHTS };
-    riskMultipliers = { ...RISK_MULTIPLIERS };
-    /**
-     * Analyze operation complexity and return detailed metrics
-     */
-    analyzeComplexity(operation, context) {
-        const metrics = {
-            fileCount: this.calculateFileCount(context),
-            changeVolume: this.calculateChangeVolume(context),
-            operationType: this.determineOperationType(operation),
-            dependencies: this.calculateDependencies(context),
-            riskLevel: this.assessRiskLevel(context),
-            estimatedDuration: this.estimateDuration(context),
-        };
-        return metrics;
-    }
-    /**
-     * Calculate complexity score and delegation strategy
-     *
-     * CALIBRATED: Weights increased to properly utilize orchestration
-     * - File count: 4 pts/file (was 2) - better reflects multi-file complexity
-     * - Change volume: 0.2/line (was 0.1) - better reflects code volume
-     * - Dependencies: 5 each (was 3) - better reflects coordination needs
-     */
-    calculateComplexityScore(metrics) {
-        // Base score calculation
-        let score = 0;
-        // File count contribution (0-40 points)
-        score += Math.min(metrics.fileCount * 4, 40);
-        // Change volume contribution (0-50 points)
-        score += Math.min(metrics.changeVolume / 5, 50);
-        // Dependencies contribution (0-25 points)
-        score += Math.min(metrics.dependencies * 5, 25);
-        // Duration contribution (0-15 points)
-        score += Math.min(metrics.estimatedDuration / 10, 15);
-        // Operation type weight (multiplier)
-        score *= this.operationWeights[metrics.operationType];
-        // Risk level multiplier
-        score *= this.riskMultipliers[metrics.riskLevel];
-        // Normalize to 0-100
-        score = Math.min(Math.max(score, 0), 100);
-        // Determine level and strategy using core functions
-        const level = getLevelFromScore(score, this.thresholds);
-        const recommendedStrategy = getStrategyForLevel(level);
-        const estimatedAgents = getAgentCountForLevel(level);
-        // Generate reasoning using core function
-        const reasoning = generateReasoning(metrics, score, level);
-        return {
-            score: Math.round(score),
-            level,
-            recommendedStrategy,
-            estimatedAgents,
-            reasoning,
-        };
-    }
-    /**
-     * Performance data structure for calibration
-     */
-    calibrationHistory = [];
-    /**
-     * Update thresholds based on historical performance data
-     * Analyzes: task score vs completion time vs success rate
-     * to automatically adjust thresholds for better accuracy
-     */
-    updateThresholds(performanceData) {
-        if (!performanceData || typeof performanceData !== "object") {
-            return;
-        }
-        const data = performanceData;
-        if (data.complexityScore === undefined) {
-            return;
-        }
-        this.calibrationHistory.push({
-            complexityScore: data.complexityScore,
-            actualDuration: data.actualDuration || 0,
-            estimatedDuration: data.estimatedDuration || 30,
-            success: data.success !== false,
-            timestamp: data.timestamp || Date.now(),
-        });
-        if (this.calibrationHistory.length > ComplexityAnalyzer.MAX_CALIBRATION_HISTORY) {
-            const removeCount = this.calibrationHistory.length - ComplexityAnalyzer.MAX_CALIBRATION_HISTORY + 100;
-            this.calibrationHistory = this.calibrationHistory.slice(removeCount);
-        }
-        if (this.calibrationHistory.length < 10) {
-            return;
-        }
-        const analysis = this.analyzeCalibrationData();
-        this.applyCalibrationAnalysis(analysis);
-    }
-    /**
-     * Analyze calibration data to find patterns
-     */
-    analyzeCalibrationData() {
-        let underestimated = 0;
-        let overestimated = 0;
-        let totalAdjustmentFactor = 0;
-        for (const entry of this.calibrationHistory) {
-            if (entry.actualDuration > entry.estimatedDuration * 1.5) {
-                underestimated++;
-                totalAdjustmentFactor += 0.05;
-            }
-            else if (entry.actualDuration < entry.estimatedDuration * 0.5) {
-                overestimated++;
-                totalAdjustmentFactor -= 0.05;
-            }
-        }
-        return {
-            underestimated: underestimated > this.calibrationHistory.length * 0.3,
-            overestimated: overestimated > this.calibrationHistory.length * 0.3,
-            adjustmentFactor: totalAdjustmentFactor / this.calibrationHistory.length,
-        };
-    }
-    /**
-     * Apply calibration analysis to adjust thresholds
-     */
-    applyCalibrationAnalysis(analysis) {
-        const maxAdjustment = 10;
-        if (analysis.underestimated) {
-            const adjustment = Math.min(maxAdjustment, Math.abs(analysis.adjustmentFactor) * 100);
-            this.thresholds.simple = Math.max(10, this.thresholds.simple - adjustment);
-            this.thresholds.moderate = Math.max(20, this.thresholds.moderate - adjustment);
-            this.thresholds.complex = Math.max(40, this.thresholds.complex - adjustment);
-        }
-        else if (analysis.overestimated) {
-            const adjustment = Math.min(maxAdjustment, Math.abs(analysis.adjustmentFactor) * 100);
-            this.thresholds.simple = Math.min(40, this.thresholds.simple + adjustment);
-            this.thresholds.moderate = Math.min(60, this.thresholds.moderate + adjustment);
-            this.thresholds.complex = Math.min(90, this.thresholds.complex + adjustment);
-        }
-    }
-    /**
-     * Get calibration history for diagnostics
-     */
-    getCalibrationHistory() {
-        return [...this.calibrationHistory];
-    }
-    /**
-     * Reset calibration history
-     */
-    resetCalibration() {
-        this.calibrationHistory = [];
-    }
-    /**
-     * Get current complexity thresholds
-     */
-    getThresholds() {
-        return { ...this.thresholds };
-    }
-    /**
-     * Set custom complexity thresholds
-     */
-    setThresholds(thresholds) {
-        this.thresholds = { ...this.thresholds, ...thresholds };
-    }
-    /**
-     * Set operation type weights (from calibrator)
-     */
-    setOperationWeights(weights) {
-        for (const [key, value] of Object.entries(weights)) {
-            if (typeof value === "number") {
-                this.operationWeights[key] = value;
-            }
-        }
-    }
-    /**
-     * Set risk level multipliers (from calibrator)
-     */
-    setRiskMultipliers(multipliers) {
-        for (const [key, value] of Object.entries(multipliers)) {
-            if (typeof value === "number") {
-                this.riskMultipliers[key] = value;
-            }
-        }
-    }
-    /**
-     * Calibrate analyzer based on calibrator recommendations
-     */
-    calibrate(settings) {
-        if (settings.thresholds) {
-            this.setThresholds(settings.thresholds);
-        }
-        if (settings.operationWeights) {
-            this.setOperationWeights(settings.operationWeights);
-        }
-        if (settings.riskMultipliers) {
-            this.setRiskMultipliers(settings.riskMultipliers);
-        }
-    }
-    // Private helper methods
-    calculateFileCount(context) {
-        const ctx = context;
-        return ctx?.files?.length || 1;
-    }
-    calculateChangeVolume(context) {
-        const ctx = context;
-        // Support both formats: context.changes or context.linesChanged
-        if (ctx?.linesChanged !== undefined) {
-            return ctx.linesChanged;
-        }
-        if (ctx?.changeVolume !== undefined) {
-            return ctx.changeVolume;
-        }
-        const changes = ctx?.changes || {};
-        return (changes.added || 0) + (changes.deleted || 0) + (changes.modified || 0);
-    }
-    determineOperationType(operation) {
-        const op = operation.toLowerCase();
-        if (op.includes("refactor"))
-            return "refactor";
-        if (op.includes("debug"))
-            return "debug";
-        if (op.includes("test"))
-            return "test";
-        if (op.includes("analyze"))
-            return "analyze";
-        if (op.includes("create"))
-            return "create";
-        return "modify";
-    }
-    calculateDependencies(context) {
-        const ctx = context;
-        // Support both formats: context.dependencies array or context.dependencyCount
-        if (ctx?.dependencyCount !== undefined) {
-            return ctx.dependencyCount;
-        }
-        return ctx?.dependencies?.length || 0;
-    }
-    assessRiskLevel(context) {
-        const ctx = context;
-        if (ctx?.critical || ctx?.riskLevel === "critical")
-            return "critical";
-        if (ctx?.highRisk || ctx?.riskLevel === "high")
-            return "high";
-        if (ctx?.riskLevel === "medium")
-            return "medium";
-        return "low";
-    }
-    estimateDuration(context) {
-        const ctx = context;
-        return ctx?.estimatedDuration || ctx?.estimatedTime || 30;
-    }
-}
-// Singleton instance for convenience
-let analyzerInstance = null;
-export function getComplexityAnalyzer() {
-    if (!analyzerInstance) {
-        analyzerInstance = new ComplexityAnalyzer();
-    }
-    return analyzerInstance;
-}
-// Backward compatibility: export singleton instance
-export const complexityAnalyzer = getComplexityAnalyzer();

package/dist/delegation/complexity-core.d.ts

@@ -1,119 +0,0 @@
-/**
- * Complexity Core
- *
- * Shared complexity types, thresholds, and utilities.
- * Single source of truth for complexity analysis across the framework.
- *
- * This module consolidates duplicate complexity logic from:
- * - complexity-analyzer.ts
- * - complexity-router.ts
- * - complexity-calibrator.ts
- */
-/**
- * Complexity metrics for analysis
- */
-export interface ComplexityMetrics {
-    fileCount: number;
-    changeVolume: number;
-    operationType: "create" | "modify" | "refactor" | "analyze" | "debug" | "test";
-    dependencies: number;
-    riskLevel: "low" | "medium" | "high" | "critical";
-    estimatedDuration: number;
-}
-/**
- * Complexity score with recommendations
- */
-export interface ComplexityScore {
-    score: number;
-    level: ComplexityLevel;
-    recommendedStrategy: DelegationStrategy;
-    estimatedAgents: number;
-    reasoning: string[];
-}
-/**
- * Complexity tiers/levels
- */
-export type ComplexityLevel = "simple" | "moderate" | "complex" | "enterprise";
-/**
- * Complexity tiers for routing (lowercase variants)
- */
-export type ComplexityTier = "low" | "medium" | "high" | "enterprise";
-/**
- * Delegation strategies based on complexity
- */
-export type DelegationStrategy = "single-agent" | "multi-agent" | "orchestrator-led";
-/**
- * Complexity thresholds configuration
- *
- * CALIBRATED: Based on empirical testing and routing requirements
- * - simple (0-25): Simple tasks, direct agent assignment
- * - moderate (26-50): Moderate complexity, architect review
- * - complex (51-75): Complex tasks, orchestrator coordination
- * - enterprise (76-100): Maximum complexity, full orchestration
- */
-export interface ComplexityThresholds {
-    simple: number;
-    moderate: number;
-    complex: number;
-    enterprise: number;
-}
-/**
- * Default complexity thresholds
- * Used across all complexity analyzers for consistency
- *
- * Based on empirical testing:
- * - Low (0-25): Simple tasks, direct agent assignment
- * - Medium (26-50): Moderate complexity, architect review
- * - High (51-75): Complex tasks, orchestrator coordination
- * - Enterprise (76-100): Maximum complexity, full orchestration
- */
-export declare const DEFAULT_THRESHOLDS: ComplexityThresholds;
-/**
- * Operation type weights for complexity calculation
- */
-export declare const OPERATION_WEIGHTS: Record<ComplexityMetrics['operationType'], number>;
-export declare const RISK_MULTIPLIERS: Record<ComplexityMetrics['riskLevel'], number>;
-/**
- * Map complexity level to routing tier
- */
-export declare function levelToTier(level: ComplexityLevel): ComplexityTier;
-/**
- * Map routing tier to complexity level
- */
-export declare function tierToLevel(tier: ComplexityTier): ComplexityLevel;
-/**
- * Get complexity level from score using thresholds
- */
-export declare function getLevelFromScore(score: number, thresholds?: ComplexityThresholds): ComplexityLevel;
-/**
- * Get routing tier from score using thresholds
- */
-export declare function getTierFromScore(score: number, thresholds?: ComplexityThresholds): ComplexityTier;
-/**
- * Get recommended delegation strategy for a complexity level
- */
-export declare function getStrategyForLevel(level: ComplexityLevel): DelegationStrategy;
-/**
- * Get recommended agent count for a complexity level
- */
-export declare function getAgentCountForLevel(level: ComplexityLevel): number;
-/**
- * Get default confidence score for a complexity tier
- */
-export declare function getConfidenceForTier(tier: ComplexityTier): number;
-/**
- * Get recommended agent for a complexity tier
- */
-export declare function getAgentForTier(tier: ComplexityTier): string;
-/**
- * Get recommended skill for a complexity tier
- */
-export declare function getSkillForTier(tier: ComplexityTier): string;
-/**
- * Calculate base complexity score from metrics
- */
-export declare function calculateBaseScore(metrics: ComplexityMetrics): number;
-/**
- * Generate reasoning for a complexity score
- */
-export declare function generateReasoning(metrics: ComplexityMetrics, score: number, level: ComplexityLevel): string[];