0xray 2.0.0 → 2.1.0

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

@@ -0,0 +1,119 @@
+/**
+ * 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[];

package/dist/delegation/config/types.d.ts

@@ -0,0 +1,247 @@
+/**
+ * Routing Types
+ *
+ * Type definitions for task-skill routing system.
+ */
+/**
+ * Individual routing mapping that maps keywords to an agent/skill
+ */
+export interface RoutingMapping {
+    /** Keywords to match against task descriptions */
+    keywords: string[];
+    /** Skill to invoke */
+    skill: string;
+    /** Agent to route to */
+    agent: string;
+    /** Confidence level (0-1) */
+    confidence: number;
+    /** Category for organization */
+    category?: string;
+    /** Priority level */
+    priority?: 'critical' | 'high' | 'medium' | 'low';
+}
+/**
+ * Result of a routing operation
+ */
+export interface RoutingResult {
+    skill: string;
+    agent: string;
+    confidence: number;
+    matchedKeyword?: string;
+    fromHistory?: boolean;
+    reason?: string;
+    operation?: string;
+    context?: Record<string, unknown>;
+    escalateToLlm?: boolean;
+    isRelease?: boolean;
+    kernelInsights?: unknown;
+}
+/**
+ * Routing options
+ */
+export interface RoutingOptions {
+    complexity?: number;
+    taskId?: string;
+    useHistoricalData?: boolean;
+    sessionId?: string;
+    stateManager?: any;
+}
+/**
+ * Validation result for mappings
+ */
+export interface ValidationResult {
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+    duplicateCount: number;
+}
+/**
+ * Routing outcome tracking record
+ */
+export interface RoutingOutcome {
+    taskId: string;
+    taskDescription: string;
+    taskType?: string;
+    routedAgent: string;
+    routedSkill: string;
+    confidence: number;
+    timestamp: Date;
+    success?: boolean;
+    feedback?: string;
+    complexity?: number;
+    predictedComplexity?: number;
+    executionTimeMs?: number;
+    routingMethod?: 'keyword' | 'history' | 'complexity' | 'default';
+}
+/**
+ * Agent statistics for analytics
+ */
+export interface AgentStats {
+    agent: string;
+    total: number;
+    successRate: number;
+    attempts: number;
+    successes: number;
+}
+/**
+ * Prompt data point for pattern analysis
+ */
+export interface PromptDataPoint {
+    taskId: string;
+    prompt: string;
+    timestamp: Date;
+    complexity: number;
+    keywords: string[];
+    context: Record<string, unknown>;
+    routingDecision?: RoutingDecision;
+    outcome?: {
+        success: boolean;
+        agent: string;
+        skill: string;
+        feedback?: string;
+    };
+    templatePrompt?: string;
+    userRequest?: string;
+    generatedPrompt?: string;
+    confidence?: number;
+    usageMetadata?: {
+        timestamp: number;
+        executionTime: number;
+        success: boolean;
+        retryCount?: number;
+    };
+    routedAgent?: string;
+}
+/**
+ * Routing decision record
+ */
+export interface RoutingDecision {
+    taskId: string;
+    agent: string;
+    skill: string;
+    confidence: number;
+    matchedKeyword?: string;
+    reason: string;
+    kernelInsights?: unknown;
+    timestamp: Date;
+    selectedAgent?: string;
+    selectedSkill?: string;
+    executionTime?: number;
+    keywordMatched?: string;
+}
+/**
+ * Daily analytics summary
+ */
+export interface DailyAnalyticsSummary {
+    totalRoutings: number;
+    averageConfidence: number;
+    templateMatchRate: number;
+    successRate: number;
+    topAgents: Array<{
+        agent: string;
+        count: number;
+        successRate: number;
+    }>;
+    topKeywords: Array<{
+        keyword: string;
+        count: number;
+        successRate: number;
+    }>;
+    insights: string[];
+}
+/**
+ * Full routing analytics data
+ */
+export interface RoutingAnalyticsData {
+    promptPatterns: {
+        totalPrompts: number;
+        templateMatches: number;
+        templateMatchRate: number;
+        gaps: Array<{
+            pattern: string;
+            suggestions: string[];
+        }>;
+        emergingPatterns: Array<{
+            pattern: string;
+            frequency: number;
+        }>;
+    };
+    routingPerformance: {
+        totalRoutings: number;
+        overallSuccessRate: number;
+        avgConfidence: number;
+        timeRange: {
+            start: Date;
+            end: Date;
+        };
+        recommendations: string[];
+        agentMetrics: Array<{
+            agent: string;
+            successRate: number;
+            count: number;
+        }>;
+        keywordEffectiveness: Array<{
+            keyword: string;
+            successRate: number;
+        }>;
+        confidenceMetrics: Array<{
+            threshold: number;
+            successRate: number;
+        }>;
+    };
+}
+/**
+ * P9 learning statistics
+ */
+export interface P9LearningStats {
+    totalLearnings: number;
+    successRate: number;
+    lastLearning: Date | null;
+    averageLearningTime: number;
+    enabled: boolean;
+}
+/**
+ * Pattern drift analysis result
+ */
+export interface PatternDriftAnalysis {
+    driftDetected: boolean;
+    affectedPatterns: string[];
+    severity: 'low' | 'medium' | 'high';
+}
+/**
+ * Learning result from P9 learning trigger
+ */
+export interface LearningResult {
+    learningStarted: boolean;
+    patternsAnalyzed: number;
+    adaptations: number;
+}
+/**
+ * Routing refinement change record
+ */
+export interface RoutingRefinementChange {
+    type: 'added' | 'optimized' | 'removed';
+    reason: string;
+    data?: unknown;
+}
+/**
+ * Routing refinement result
+ */
+export interface RoutingRefinementResult {
+    appliedMappings: number;
+    optimizedMappings: number;
+    removedMappings: number;
+    changes: RoutingRefinementChange[];
+}
+/**
+ * Adaptive thresholds configuration
+ */
+export interface AdaptiveThresholds {
+    overall: {
+        confidenceMin: number;
+        confidenceMax: number;
+        frequencyMin: number;
+        frequencyMax: number;
+    };
+    perAgent?: Record<string, unknown>;
+}

package/dist/delegation/dependency-graph-builder.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Dependency Graph Builder
+ *
+ * Builds comprehensive dependency graphs for codebase analysis.
+ * Tracks file relationships, import/export chains, and architectural dependencies.
+ *
+ * @version 1.0.0
+ * @since 2026-01-11
+ */
+import { CodebaseContextAnalyzer } from "./codebase-context-analyzer.js";
+import { ASTCodeParser } from "./ast-code-parser.js";
+export interface DependencyNode {
+    file: string;
+    module: string;
+    imports: string[];
+    exports: string[];
+    dependents: string[];
+    depth: number;
+    circular: boolean;
+}
+export interface DependencyChain {
+    start: string;
+    end: string;
+    path: string[];
+    type: "direct" | "indirect" | "circular";
+}
+export interface DependencyMetrics {
+    totalDependencies: number;
+    uniqueModules: number;
+    maxDepth: number;
+    circularDependencies: number;
+    orphanFiles: number;
+    tightlyCoupledFiles: number;
+    averageDependenciesPerFile: number;
+    couplingIndex: number;
+}
+export interface DependencyAnalysis {
+    graph: Map<string, DependencyNode>;
+    chains: DependencyChain[];
+    metrics: DependencyMetrics;
+    issues: DependencyIssue[];
+    recommendations: string[];
+}
+export interface DependencyIssue {
+    type: "circular-dependency" | "orphan-file" | "tight-coupling" | "deep-dependency";
+    severity: "low" | "medium" | "high" | "critical";
+    files: string[];
+    description: string;
+    impact: string;
+    suggestion: string;
+}
+export declare class DependencyGraphBuilder {
+    private codebaseAnalyzer;
+    private astParser;
+    constructor(codebaseAnalyzer: CodebaseContextAnalyzer, astParser: ASTCodeParser);
+    /**
+     * Build comprehensive dependency graph for the codebase
+     */
+    buildDependencyGraph(): Promise<DependencyAnalysis>;
+    /**
+     * Enhance dependency graph with AST analysis
+     */
+    private enhanceWithASTAnalysis;
+    /**
+     * Calculate which files depend on each file (reverse dependencies)
+     */
+    private calculateDependents;
+    /**
+     * Calculate dependency depth for each file
+     */
+    private calculateDepths;
+    /**
+     * Detect circular dependencies in the graph
+     */
+    private detectCircularDependencies;
+    /**
+     * Mark files that are part of circular dependencies
+     */
+    private markCircularDependencies;
+    /**
+     * Calculate comprehensive dependency metrics
+     */
+    private calculateDependencyMetrics;
+    /**
+     * Identify dependency-related issues
+     */
+    private identifyDependencyIssues;
+    /**
+     * Generate recommendations based on issues and metrics
+     */
+    private generateRecommendations;
+    private getModuleName;
+    private isSourceFile;
+    private resolveImport;
+}

package/dist/delegation/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * 0xRay AI v1.22.60 - Delegation System
+ *
+ * Complete automatic multi-agent delegation system with complexity assessment
+ * and session-based coordination.
+ *
+ * @version 1.1.0
+ * @since 2026-01-07
+ */
+export { ComplexityAnalyzer, complexityAnalyzer, } from "./complexity-analyzer.js";
+export { AgentDelegator, createAgentDelegator } from "./agent-delegator.js";
+export { SessionCoordinator, createSessionCoordinator, } from "./session-coordinator.js";
+export { RoutingOutcomeTracker, routingOutcomeTracker, } from "./analytics/index.js";
+export { RoutingAnalytics } from "./analytics/index.js";
+export { LearningEngine, learningEngine } from "./analytics/index.js";
+export { VotingCoordinator, createVotingCoordinator, } from "./voting-coordinator.js";
+export { WeightedVotingAggregator, createWeightedVotingAggregator, createDetailedVotingResult, DEFAULT_HISTORICAL_CONFIG, DEFAULT_CONFIDENCE_CONFIG, } from "./weighted-voting-aggregator.js";
+export { AdaptiveStrategySelector, adaptiveStrategySelector, selectVotingStrategy, } from "./strategy-selector.js";
+export { getAgentExpertise, getAgentExpertiseLevel, getVotingWeight, getAgentsWithExpertiseDomain, getTopExpertsForDomain, } from "./agent-expertise.js";
+export type { VotingSession, VotingStrategy, VoteChoice, VotingResult, VotingResultDetail, AgentExpertise, StrategySelectionContext, VotingHistoryEntry, AdaptiveStrategyConfig, VotingMetrics, ConflictResolutionRequest, ConflictResolutionResponse, } from "./voting-types.js";
+export type { ComplexityMetrics, ComplexityScore, ComplexityThresholds, } from "./complexity-analyzer.js";
+export type { DelegationRequest, DelegationResult, AgentCapability, DelegationMetrics, } from "./agent-delegator.js";
+export type { SessionContext, AgentInteraction, ConflictRecord, CoordinationState, Communication, SessionMetrics, } from "./session-coordinator.js";
+export { AgentMetricsSystem, getAgentMetricsSystem, initializeAgentMetrics, resetAgentMetricsSystem, } from "../metrics/agent-metrics.js";
+export type { AgentInvocation, AgentType, ComplexityLevel, AgentInvocationSummary, TimePeriodSummary, ComplexitySummary, AggregatedAgentMetrics, MetricsRetentionConfig, MetricsExport, AgentMetricsFilter, } from "../metrics/agent-metrics.js";

package/dist/delegation/metrics-aggregator.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Metrics Aggregator
+ *
+ * Provides aggregation, reporting, and export functionality for delegation
+ * and orchestration metrics stored in stateManager.
+ *
+ * @version 1.0.0
+ * @since 2026-04-16
+ */
+import type { XrayStateManager } from "../state/state-manager.js";
+export interface DelegationMetricEntry {
+    timestamp: number;
+    operation: string;
+    strategy: string;
+    complexity: {
+        level: string;
+        score: number;
+    };
+    estimatedDuration: number;
+    agents: string[];
+    results?: Array<{
+        agent: string;
+        success: boolean;
+    }>;
+    totalTime?: number;
+    success?: boolean;
+    errors?: string[];
+    analysisOnly: boolean;
+    sessionId?: string;
+}
+export interface OrchestrationMetricEntry {
+    timestamp: number;
+    parentTask: string;
+    operation: string;
+    orchestratorType: string;
+    subAgents: Array<{
+        name: string;
+        role: string;
+        confidence: number;
+    }>;
+    complexityLevel: string;
+    complexityScore: number;
+    sessionId?: string;
+}
+export interface AggregatedMetrics {
+    summary: {
+        totalEntries: number;
+        timeRange: {
+            start: number;
+            end: number;
+        };
+        oldestEntry: number;
+        newestEntry: number;
+    };
+    byAgent: Record<string, {
+        count: number;
+        operations: string[];
+        avgComplexity: number;
+        successRate: number;
+    }>;
+    byComplexityLevel: Record<string, {
+        count: number;
+        avgDuration: number;
+        operations: string[];
+    }>;
+    byTimePeriod: Record<string, {
+        count: number;
+        operations: string[];
+    }>;
+}
+export interface MetricsExport {
+    format: "json" | "csv" | "summary";
+    data: unknown;
+    exportedAt: number;
+    entryCount: number;
+}
+export declare function getDelegationMetrics(stateManager: XrayStateManager): DelegationMetricEntry[];
+export declare function getOrchestrationMetrics(stateManager: XrayStateManager): OrchestrationMetricEntry[];
+export declare function aggregateDelegationMetrics(stateManager: XrayStateManager): AggregatedMetrics;
+export declare function aggregateOrchestrationMetrics(stateManager: XrayStateManager): AggregatedMetrics;
+export declare function summarizeByAgent(stateManager: XrayStateManager, type?: "delegation" | "orchestration"): Record<string, unknown>;
+export declare function summarizeByComplexityLevel(stateManager: XrayStateManager, type?: "delegation" | "orchestration"): Record<string, unknown>;
+export declare function summarizeByTimePeriod(stateManager: XrayStateManager, type?: "delegation" | "orchestration"): Record<string, unknown>;
+export declare function rotateMetrics(stateManager: XrayStateManager, maxEntries?: number): {
+    delegation: number;
+    orchestration: number;
+};
+export declare function cleanupOldMetrics(stateManager: XrayStateManager, olderThan: number): {
+    delegation: number;
+    orchestration: number;
+};
+export declare function exportMetrics(stateManager: XrayStateManager, format?: "json" | "csv" | "summary"): MetricsExport;