0xray 3.4.1 → 3.4.3

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,94 @@
+/**
+ * Dependency Graph Builder
+ *
+ * Builds comprehensive dependency graphs for codebase analysis.
+ * Tracks file relationships, import/export chains, and architectural dependencies.
+ *
+ * @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.
+ *
+ * @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, ComplexityLevel, ComplexityThresholds, } from "../nucleus/thin-dispatch.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 { scoreComplexity, routeToAgent, scoreAndRoute } from "../nucleus/thin-dispatch.js";
+export type { AgentInvocation, AgentType, AgentInvocationSummary, TimePeriodSummary, ComplexitySummary, AggregatedAgentMetrics, MetricsRetentionConfig, MetricsExport, AgentMetricsFilter, } from "../metrics/agent-metrics.js";

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

@@ -0,0 +1,91 @@
+/**
+ * Metrics Aggregator
+ *
+ * Provides aggregation, reporting, and export functionality for delegation
+ * and orchestration metrics stored in stateManager.
+ *
+ * @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;

package/dist/delegation/session-coordinator.d.ts

@@ -0,0 +1,132 @@
+/**
+ * Session Coordinator
+ *
+ * Manages cross-agent communication and coordination within sessions.
+ * Tracks delegation state, agent interactions, and conflict resolution.
+ *
+ * @since 2026-01-07
+ */
+import { XrayStateManager } from "../state/state-manager.js";
+import { DelegationResult } from "./agent-delegator.js";
+export interface SessionContext {
+    sessionId: string;
+    startTime: number;
+    activeDelegations: Map<string, DelegationResult>;
+    agentInteractions: Map<string, AgentInteraction[]>;
+    conflictHistory: ConflictRecord[];
+    coordinationState: CoordinationState;
+    isActive: boolean;
+}
+export interface AgentInteraction {
+    agentName: string;
+    timestamp: number;
+    action: string;
+    result: unknown;
+    duration: number;
+    success: boolean;
+}
+export interface ConflictRecord {
+    conflictId: string;
+    timestamp: number;
+    agents: string[];
+    resolution: "consensus" | "majority_vote" | "expert_priority" | "manual";
+    outcome: unknown;
+}
+export interface CoordinationState {
+    activeAgents: Set<string>;
+    pendingCommunications: Communication[];
+    sharedContext: Map<string, SharedContextEntry[]>;
+    sessionMetrics: SessionMetrics;
+}
+export interface SharedContextEntry {
+    value: unknown;
+    fromAgent: string;
+    timestamp: number;
+}
+export interface Communication {
+    id: string;
+    fromAgent: string;
+    toAgent: string;
+    message: unknown;
+    timestamp: number;
+    priority: "low" | "medium" | "high";
+}
+export interface SessionMetrics {
+    totalInteractions: number;
+    successfulInteractions: number;
+    failedInteractions: number;
+    averageResponseTime: number;
+    conflictResolutionRate: number;
+    coordinationEfficiency: number;
+}
+export declare class SessionCoordinator {
+    private stateManager;
+    private sessions;
+    constructor(stateManager: XrayStateManager);
+    /**
+     * Get read-only view of all sessions - avoids breaking encapsulation
+     */
+    getSessions(): ReadonlyMap<string, SessionContext>;
+    /**
+     * Get a specific session by ID
+     */
+    getSession(sessionId: string): SessionContext | undefined;
+    /**
+     * Initialize session coordination for a new session
+     */
+    initializeSession(sessionId: string): {
+        sessionId: string;
+        createdAt: Date;
+        active: boolean;
+        agentCount: number;
+    };
+    /**
+     * Register delegation execution in session
+     */
+    registerDelegation(sessionId: string, delegationId: string, delegation: DelegationResult): void;
+    /**
+     * Record agent interaction within session
+     */
+    recordInteraction(sessionId: string, agentName: string, interaction: Omit<AgentInteraction, "timestamp">): void;
+    /**
+     * Send message between agents within session
+     */
+    sendMessage(sessionId: string, fromAgent: string, toAgent: string, message: unknown, priority?: "low" | "medium" | "high"): Promise<void>;
+    /**
+     * Receive pending messages for an agent
+     */
+    receiveMessages(sessionId: string, agentName: string): Communication[];
+    /**
+     * Share context data between agents
+     */
+    shareContext(sessionId: string, key: string, value: unknown, fromAgent: string): void;
+    /**
+     * Get shared context data
+     */
+    getSharedContext(sessionId: string, key: string): unknown;
+    /**
+     * Record conflict and resolution
+     */
+    recordConflict(sessionId: string, agents: string[], resolution: ConflictRecord["resolution"], outcome: unknown): void;
+    /**
+     * Complete delegation and cleanup
+     */
+    completeDelegation(sessionId: string, delegationId: string, result: unknown): void;
+    /**
+     * Get session coordination status
+     */
+    getSessionStatus(sessionId: string): {
+        active: boolean;
+        agentCount: number;
+    } | null;
+    /**
+     * Resolve conflicts using specified strategy
+     */
+    resolveConflict(sessionId: string, conflictKey: string, strategy: "majority_vote" | "expert_priority" | "consensus"): unknown;
+    /**
+     * Cleanup session coordination data
+     */
+    cleanupSession(sessionId: string): void;
+    private updateSessionMetrics;
+}
+export declare const createSessionCoordinator: (stateManager: XrayStateManager) => SessionCoordinator;

package/dist/delegation/strategy-selector.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Adaptive Strategy Selector
+ *
+ * Selects the optimal voting strategy based on:
+ * - Complexity level of the task
+ * - Risk level involved
+ * - Security concerns
+ * - Architectural impact
+ * - Participant count
+ *
+ * @since 2026-04-16
+ */
+import type { VotingStrategy, StrategySelectionContext, AdaptiveStrategyConfig } from "./voting-types.js";
+export declare class AdaptiveStrategySelector {
+    private config;
+    constructor(config?: Partial<AdaptiveStrategyConfig>);
+    selectStrategy(context: StrategySelectionContext): VotingStrategy;
+    selectStrategyWithDefaults(complexity: number, riskLevel: string, hasSecurityConcerns?: boolean, hasArchitecturalImpact?: boolean, participantCount?: number): VotingStrategy;
+    getStrategyReasoning(context: StrategySelectionContext): string;
+    private isSecurityRelated;
+    private isArchitecturalRelated;
+    private getComplexityTier;
+    getConfig(): AdaptiveStrategyConfig;
+    updateConfig(config: Partial<AdaptiveStrategyConfig>): void;
+}
+export declare const adaptiveStrategySelector: AdaptiveStrategySelector;
+export declare function selectVotingStrategy(complexity: number, riskLevel: string, hasSecurityConcerns?: boolean, hasArchitecturalImpact?: boolean, participantCount?: number): VotingStrategy;

package/dist/delegation/voting-coordinator.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Voting Coordinator
+ *
+ * Multi-agent voting system with:
+ * - Weighted confidence scoring based on agent expertise
+ * - Adaptive strategy selection
+ * - Historical learning and pattern detection
+ * - Integration with session coordinator
+ *
+ * @since 2026-04-16
+ */
+import type { VotingSession, VotingResult, StrategySelectionContext, VotingHistoryEntry, VotingMetrics, ConflictResolutionRequest, ConflictResolutionResponse } from "./voting-types.js";
+import { SessionCoordinator } from "./session-coordinator.js";
+import { WeightedVotingAggregator } from "./weighted-voting-aggregator.js";
+import { XrayStateManager } from "../state/state-manager.js";
+export interface VotingCoordinatorConfig {
+    enableHistoryTracking: boolean;
+    enableLearning: boolean;
+    minVotersForConsensus: number;
+    consensusThreshold: number;
+}
+export declare class VotingCoordinator {
+    private stateManager;
+    private sessionCoordinator;
+    private activeVotingSessions;
+    private votingHistory;
+    private metrics;
+    private config;
+    private aggregator;
+    constructor(stateManager: XrayStateManager, sessionCoordinator?: SessionCoordinator, config?: Partial<VotingCoordinatorConfig>);
+    initiateVoting(sessionId: string, topic: string, description: string, participants: string[], context?: StrategySelectionContext): Promise<string>;
+    submitVote(voteId: string, agentName: string, vote: string, confidence: number, reasoning?: string): boolean;
+    resolveVoting(voteId: string): VotingResult | null;
+    resolveConflict(request: ConflictResolutionRequest): ConflictResolutionResponse;
+    getAggregator(): WeightedVotingAggregator;
+    getVotingSession(voteId: string): VotingSession | undefined;
+    getActiveVotingSessions(): VotingSession[];
+    getVotingHistory(sessionId?: string, limit?: number): VotingHistoryEntry[];
+    getMetrics(): VotingMetrics;
+    private resolveMajorityVote;
+    private resolveConsensus;
+    private resolveExpertPriority;
+    private recordVotingHistory;
+    private loadHistory;
+    private initializeMetrics;
+    private updateMetricsAfterVote;
+}
+export declare const createVotingCoordinator: (stateManager: XrayStateManager, sessionCoordinator?: SessionCoordinator) => VotingCoordinator;