0xray 3.4.2 → 3.4.3

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

@@ -0,0 +1,173 @@
+/**
+ * AST Code Parser
+ *
+ * AST-based code parsing and structural analysis using ast-grep.
+ * Provides advanced code understanding, pattern detection, and refactoring insights.
+ *
+ * @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,110 @@
+/**
+ * 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-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[];