0xray 2.0.0 → 2.1.0

package/dist/delegation/analytics/learning-engine.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Learning Engine
+ *
+ * P9 learning system - analyzes patterns, detects drift, and improves routing.
+ * Extracted from task-skill-router.ts as part of Phase 2 refactoring.
+ *
+ * @version 1.0.0
+ * @since 2026-03-12
+ */
+import { P9LearningStats, PatternDriftAnalysis, LearningResult, AdaptiveThresholds } from '../config/types.js';
+/**
+ * LearningEngine class
+ *
+ * Active implementation for P9 learning capabilities:
+ * - Pattern drift detection
+ * - Automatic routing refinement
+ * - Success rate learning
+ * - Adaptive confidence thresholds
+ */
+export declare class LearningEngine {
+    private enabled;
+    private learningHistory;
+    constructor(enabled?: boolean);
+    /**
+     * Get P9 learning statistics
+     */
+    getP9LearningStats(): P9LearningStats;
+    /**
+     * Calculate overall success rate from outcome tracker
+     */
+    private calculateOverallSuccessRate;
+    /**
+     * Get pattern drift analysis from performance tracker
+     */
+    getPatternDriftAnalysis(): PatternDriftAnalysis;
+    /**
+     * Get adaptive thresholds based on learned data
+     */
+    getAdaptiveThresholds(): AdaptiveThresholds;
+    /**
+     * Trigger P9 learning process
+     */
+    triggerLearning(): Promise<LearningResult>;
+    /**
+     * Enable or disable learning
+     */
+    setEnabled(enabled: boolean): void;
+    /**
+     * Check if learning is enabled
+     */
+    isEnabled(): boolean;
+    /**
+     * Get learning history
+     */
+    getLearningHistory(): Array<{
+        timestamp: Date;
+        patternsAnalyzed: number;
+        adaptations: number;
+        successRate: number;
+    }>;
+    /**
+     * Clear learning history
+     */
+    clearHistory(): void;
+    /**
+     * Analyze a specific pattern for optimization opportunities
+     */
+    analyzePattern(patternId: string): {
+        optimized: boolean;
+        recommendations: string[];
+        confidence: number;
+    };
+    /**
+     * Suggest routing improvements based on learning
+     */
+    suggestImprovements(): Array<{
+        type: 'mapping' | 'threshold' | 'confidence';
+        description: string;
+        impact: 'low' | 'medium' | 'high';
+    }>;
+}
+/**
+ * Global learning engine instance (enabled by default)
+ */
+export declare const learningEngine: LearningEngine;

package/dist/delegation/analytics/outcome-tracker.d.ts

@@ -0,0 +1,118 @@
+/**
+ * Routing Outcome Tracker
+ *
+ * Tracks routing outcomes and provides statistics for performance analysis.
+ * Extracted from task-skill-router.ts as part of Phase 2 refactoring.
+ *
+ * @version 1.0.0
+ * @since 2026-03-12
+ */
+import { RoutingOutcome, AgentStats, PromptDataPoint, RoutingDecision } from '../config/types.js';
+/**
+ * RoutingOutcomeTracker class
+ *
+ * Tracks routing outcomes with circular buffer pattern for memory efficiency.
+ * Provides methods for recording outcomes, calculating statistics, and
+ * retrieving data for analytics.
+ *
+ * Persists outcomes to logs/framework/routing-outcomes.json for analytics to read.
+ */
+export declare class RoutingOutcomeTracker {
+    private outcomes;
+    private readonly maxOutcomes;
+    private readonly persistencePath;
+    private saveTimeout;
+    private readonly SAVE_DEBOUNCE_MS;
+    /**
+     * Create a new outcome tracker
+     * @param maxOutcomes Maximum number of outcomes to retain (default: 1000)
+     */
+    constructor(maxOutcomes?: number);
+    /**
+     * Ensure the log directory and file exist on initialization
+     */
+    private initializeFile;
+    /**
+     * Load outcomes from disk on initialization
+     */
+    private loadFromDisk;
+    /**
+     * Save outcomes to disk (debounced)
+     */
+    private scheduleSave;
+    /**
+     * Immediately save to disk (synchronous for reliability)
+     */
+    private saveToDisk;
+    /**
+     * Record a new routing outcome
+     * @param outcome The outcome to record (timestamp will be added)
+     */
+    recordOutcome(outcome: Omit<RoutingOutcome, 'timestamp'>): void;
+    /**
+     * Update an existing outcome by taskId
+     * @param taskId The task ID to update
+     * @param updates The fields to update
+     * @returns true if updated, false if not found
+     */
+    updateOutcome(taskId: string, updates: Partial<RoutingOutcome>): boolean;
+    /**
+     * Force reload from disk - call this before analytics to get latest data
+     */
+    reloadFromDisk(): Promise<void>;
+    /**
+     * Get all outcomes, optionally filtered by agent
+     * @param agent Optional agent name to filter by
+     * @returns Array of routing outcomes
+     */
+    getOutcomes(agent?: string): RoutingOutcome[];
+    /**
+     * Calculate success rate for a specific agent
+     * @param agent The agent name
+     * @returns Success rate between 0 and 1
+     */
+    getSuccessRate(agent: string): number;
+    /**
+     * Get statistics for all agents
+     * @returns Array of agent statistics
+     */
+    getStats(): AgentStats[];
+    /**
+     * Clear all recorded outcomes
+     */
+    clear(): void;
+    /**
+     * Get the count of recorded outcomes
+     * @returns Number of outcomes
+     */
+    getCount(): number;
+    /**
+     * Export outcomes to JSON string
+     * @returns JSON string of all outcomes
+     */
+    toJSON(): string;
+    /**
+     * Convert outcomes to prompt data points for pattern analysis
+     * @returns Array of prompt data points
+     */
+    getPromptData(): PromptDataPoint[];
+    /**
+     * Convert outcomes to routing decisions
+     * @returns Array of routing decisions
+     */
+    getRoutingDecisions(): RoutingDecision[];
+    /**
+     * Apply routing refinements to existing outcomes
+     * @param changes Array of changes to apply
+     */
+    applyRoutingRefinements(changes: Array<{
+        taskId: string;
+        agent?: string;
+        skill?: string;
+        confidence?: number;
+    }>): void;
+}
+/**
+ * Global routing outcome tracker instance
+ */
+export declare const routingOutcomeTracker: RoutingOutcomeTracker;

package/dist/delegation/analytics/routing-analytics.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Routing Analytics
+ *
+ * Provides analytics aggregation and insights generation for routing data.
+ * Extracted from task-skill-router.ts as part of Phase 2 refactoring.
+ *
+ * @version 1.0.0
+ * @since 2026-03-12
+ */
+import { DailyAnalyticsSummary, RoutingAnalyticsData, RoutingRefinementResult } from '../config/types.js';
+import { RoutingOutcomeTracker } from './outcome-tracker.js';
+/**
+ * RoutingAnalytics class
+ *
+ * Aggregates routing data and provides analytics insights.
+ * Works with RoutingOutcomeTracker to generate reports and recommendations.
+ */
+export declare class RoutingAnalytics {
+    private tracker;
+    constructor(tracker: RoutingOutcomeTracker);
+    /**
+     * Get daily analytics summary for reporting
+     * @returns Daily summary with metrics and insights
+     */
+    getDailySummary(): DailyAnalyticsSummary;
+    /**
+     * Get full routing analytics data
+     * @returns Comprehensive analytics data
+     */
+    getFullAnalytics(): RoutingAnalyticsData;
+    /**
+     * Apply routing refinements based on analytics
+     * @param apply Whether to actually apply the changes
+     * @returns Refinement result with changes list
+     */
+    applyRoutingRefinements(apply: boolean): RoutingRefinementResult;
+    /**
+     * Generate insights from routing data
+     * @returns Array of insight strings
+     */
+    generateInsights(): string[];
+    /**
+     * Get raw statistics from the tracker
+     * @returns Record of agent statistics
+     */
+    getRawStats(): Record<string, {
+        attempts: number;
+        successes: number;
+        successRate: number;
+    }>;
+    /**
+     * Compare current performance to historical baseline
+     * @returns Comparison metrics
+     */
+    compareToBaseline(): {
+        improved: boolean;
+        changePercent: number;
+        currentRate: number;
+        baselineRate: number;
+    };
+}

package/dist/delegation/ast-code-parser.d.ts

@@ -0,0 +1,174 @@
+/**
+ * AST Code Parser
+ *
+ * AST-based code parsing and structural analysis using ast-grep.
+ * Provides advanced code understanding, pattern detection, and refactoring insights.
+ *
+ * @version 1.0.0
+ * @since 2026-01-11
+ */
+export interface ASTPattern {
+    name: string;
+    pattern: string;
+    language: string;
+    description: string;
+}
+export interface ASTMatch {
+    pattern: string;
+    file: string;
+    line: number;
+    column: number;
+    content: string;
+    captures?: Record<string, string>;
+}
+export interface CodeStructure {
+    functions: FunctionInfo[];
+    classes: ClassInfo[];
+    imports: ImportInfo[];
+    exports: ExportInfo[];
+    patterns: PatternInfo[];
+    complexity: {
+        cyclomatic: number;
+        cognitive: number;
+        nesting: number;
+    };
+}
+export interface FunctionInfo {
+    name: string;
+    line: number;
+    parameters: string[];
+    returnType?: string;
+    complexity: number;
+    lines: number;
+}
+export interface ClassInfo {
+    name: string;
+    line: number;
+    methods: string[];
+    properties: string[];
+    extends?: string;
+    implements?: string[];
+}
+export interface ImportInfo {
+    module: string;
+    names: string[];
+    line: number;
+    type: "default" | "named" | "namespace" | "side-effect";
+    file: string;
+}
+export interface ExportInfo {
+    name: string;
+    type: "function" | "class" | "variable" | "default";
+    line: number;
+}
+export interface PatternInfo {
+    pattern: string;
+    occurrences: number;
+    files: string[];
+    type: "anti-pattern" | "best-practice" | "refactoring-opportunity";
+    severity: "low" | "medium" | "high" | "critical";
+}
+export interface ASTAnalysis {
+    structure: CodeStructure;
+    patterns: PatternInfo[];
+    issues: CodeIssue[];
+    suggestions: RefactoringSuggestion[];
+    metrics: CodeMetrics;
+}
+export interface CodeIssue {
+    type: "bug" | "security" | "performance" | "maintainability";
+    severity: "low" | "medium" | "high" | "critical";
+    message: string;
+    file: string;
+    line: number;
+    suggestion: string;
+}
+export interface RefactoringSuggestion {
+    type: "extract-method" | "rename" | "move" | "simplify" | "consolidate";
+    description: string;
+    file: string;
+    line: number;
+    impact: "low" | "medium" | "high";
+    effort: "low" | "medium" | "high";
+}
+export interface CodeMetrics {
+    linesOfCode: number;
+    functions: number;
+    classes: number;
+    complexity: number;
+    duplication: number;
+    testCoverage: number;
+    maintainabilityIndex: number;
+}
+export declare class ASTCodeParser {
+    private astGrepPath;
+    private astGrepAvailable;
+    private patterns;
+    constructor(astGrepPath?: string);
+    /**
+     * Analyze code file using AST parsing
+     */
+    analyzeFile(filePath: string): Promise<ASTAnalysis>;
+    /**
+     * Parse code structure using ast-grep (advanced)
+     */
+    private parseCodeStructureWithAstGrep;
+    /**
+     * Get ast-grep language flag for a language
+     */
+    private getAstGrepLanguageFlag;
+    /**
+     * Parse code structure using regex (fallback)
+     */
+    private parseCodeStructureWithRegex;
+    /**
+     * Find AST matches using ast-grep
+     */
+    private findMatches;
+    /**
+     * Regex-based pattern matching (fallback when ast-grep not available)
+     */
+    private regexBasedMatching;
+    /**
+     * Extract named captures from regex match
+     */
+    private extractCaptures;
+    /**
+     * Detect code patterns using ast-grep (advanced)
+     */
+    private detectPatternsWithAstGrep;
+    /**
+     * Detect code smells using ast-grep rules
+     */
+    private detectCodeSmellsWithAstGrep;
+    /**
+     * Detect code patterns using regex (fallback)
+     */
+    private detectPatternsWithRegex;
+    /**
+     * Identify code issues
+     */
+    private identifyIssues;
+    /**
+     * Generate refactoring suggestions
+     */
+    private generateRefactoringSuggestions;
+    /**
+     * Calculate code metrics
+     */
+    private calculateMetrics;
+    private detectLanguage;
+    private findAstGrep;
+    private parseParameters;
+    private calculateFunctionComplexity;
+    private parseImportNames;
+    private determineImportType;
+    private extractExportName;
+    private determineExportType;
+    private calculateCyclomaticComplexity;
+    private calculateCognitiveComplexity;
+    private calculateMaxNesting;
+    private getLineNumber;
+    private calculateMaintainabilityIndex;
+    private findDuplicateImports;
+}

package/dist/delegation/codebase-context-analyzer.d.ts

@@ -0,0 +1,164 @@
+export interface FileInfo {
+    path: string;
+    relativePath: string;
+    size: number;
+    extension: string;
+    language: string;
+    isSourceCode: boolean;
+    linesOfCode: number;
+    imports: string[];
+    exports: string[];
+    dependencies: string[];
+    lastModified: Date;
+    content?: string | undefined;
+}
+export interface ModuleInfo {
+    name: string;
+    path: string;
+    files: FileInfo[];
+    entryPoint?: string | undefined;
+    dependencies: string[];
+    dependents: string[];
+    type: "source" | "config" | "docs" | "test" | "infrastructure";
+}
+export interface CodebaseStructure {
+    rootPath: string;
+    totalFiles: number;
+    totalLinesOfCode: number;
+    languages: Map<string, number>;
+    modules: Map<string, ModuleInfo>;
+    fileGraph: Map<string, FileInfo>;
+    dependencyGraph: Map<string, Set<string>>;
+    architecture: {
+        framework: string[];
+        patterns: string[];
+        structure: "monolithic" | "modular" | "microservices";
+        entryPoints: string[];
+    };
+}
+export interface ContextMetrics {
+    fileCount: number;
+    linesOfCode: number;
+    languages: string[];
+    complexity: number;
+    coupling: number;
+    cohesion: number;
+    testCoverage: number;
+    architecturalPatterns: string[];
+    qualityScore: number;
+}
+export interface CodebaseAnalysis {
+    structure: CodebaseStructure;
+    metrics: ContextMetrics;
+    insights: string[];
+    recommendations: string[];
+    risks: string[];
+    scannedAt: Date;
+}
+export interface MemoryConfig {
+    maxFilesInMemory: number;
+    maxFileSizeBytes: number;
+    enableStreaming: boolean;
+    batchSize: number;
+    enableCaching: boolean;
+    cacheTtlMs: number;
+    enableConcurrentProcessing?: boolean;
+    concurrencyLimit?: number;
+}
+export interface CodebaseAnalysisCacheData {
+    linesOfCode: number;
+    imports: string[];
+    exports: string[];
+    content?: string;
+    lastModified?: Date;
+    timestamp: number;
+}
+export declare class CodebaseContextAnalyzer {
+    private projectRoot;
+    private memoryConfig;
+    private analysisCache;
+    private ignorePatterns;
+    private supportedLanguages;
+    constructor(projectRoot?: string, memoryConfig?: Partial<MemoryConfig>);
+    /**
+     * Perform comprehensive codebase analysis with memory optimization
+     */
+    analyzeCodebase(): Promise<CodebaseAnalysis>;
+    /**
+     * Get cached analysis result with intelligent invalidation
+     */
+    private getCachedAnalysis;
+    /**
+     * Set cached analysis result with size limits
+     */
+    private setCachedAnalysis;
+    /**
+     * Extract file path from cache key for validation
+     */
+    private extractFilePathFromCacheKey;
+    /**
+     * Stream file content for large files to reduce memory usage
+     */
+    private streamFileContent;
+    /**
+     * Build complete codebase structure map with batching for memory efficiency
+     */
+    private buildCodebaseStructure;
+    /**
+     * Analyze individual file for structure and dependencies with memory optimization
+     */
+    private analyzeFile;
+    /**
+     * Analyze module directory structure
+     */
+    private analyzeModule;
+    /**
+     * Extract imports and exports from source code
+     */
+    private extractImportsExports;
+    private extractJsTsImportsExports;
+    private extractPythonImportsExports;
+    private extractJavaImportsExports;
+    /**
+     * Build dependency graph between files
+     */
+    private buildDependencyGraph;
+    /**
+     * Detect architectural patterns and framework usage
+     */
+    private detectArchitecture;
+    /**
+     * Calculate comprehensive context metrics
+     */
+    private calculateContextMetrics;
+    private calculateComplexityScore;
+    private calculateCouplingScore;
+    private calculateCohesionScore;
+    private estimateTestCoverage;
+    private calculateQualityScore;
+    /**
+     * Generate insights based on analysis
+     */
+    private generateInsights;
+    /**
+     * Generate recommendations for improvement
+     */
+    private generateRecommendations;
+    /**
+     * Identify potential risks and issues
+     */
+    private identifyRisks;
+    private isModuleDirectory;
+    private isConfigFile;
+    private classifyModule;
+    private findEntryPoint;
+    private hasFramework;
+    private detectMVCPattern;
+    private detectRepositoryPattern;
+    private detectObserverPattern;
+    private detectFactoryPattern;
+    private hasMicroservicesIndicators;
+    private isEntryPoint;
+    private detectCircularDependencies;
+}
+export declare const createCodebaseContextAnalyzer: (projectRoot?: string, memoryConfig?: Partial<MemoryConfig>) => CodebaseContextAnalyzer;

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

@@ -0,0 +1,111 @@
+/**
+ * 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
+ *
+ * @version 1.2.0
+ * @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;