0xray 4.0.11 → 4.0.13

package/dist/delegation/dependency-graph-builder.js

@@ -1,408 +0,0 @@
-/**
- * Dependency Graph Builder
- *
- * Builds comprehensive dependency graphs for codebase analysis.
- * Tracks file relationships, import/export chains, and architectural dependencies.
- *
- * @since 2026-01-11
- */
-import * as path from "path";
-import { frameworkLogger } from "../core/framework-logger.js";
-export class DependencyGraphBuilder {
-    codebaseAnalyzer;
-    astParser;
-    constructor(codebaseAnalyzer, astParser) {
-        this.codebaseAnalyzer = codebaseAnalyzer;
-        this.astParser = astParser;
-    }
-    /**
-     * Build comprehensive dependency graph for the codebase
-     */
-    async buildDependencyGraph() {
-        const jobId = `dependency-graph-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
-        await frameworkLogger.log("dependency-graph-builder", "analysis-start", "info", {
-            jobId,
-            message: "Building comprehensive dependency graph",
-        });
-        const codebaseAnalysis = await this.codebaseAnalyzer.analyzeCodebase();
-        const graph = new Map();
-        const chains = [];
-        // Build initial graph from codebase analysis
-        for (const [filePath, fileInfo] of Array.from(codebaseAnalysis.structure.fileGraph)) {
-            graph.set(filePath, {
-                file: filePath,
-                module: this.getModuleName(filePath, codebaseAnalysis.structure.modules),
-                imports: fileInfo.imports,
-                exports: fileInfo.exports,
-                dependents: [],
-                depth: 0,
-                circular: false,
-            });
-        }
-        // Enhance with AST analysis for more accurate dependencies
-        await this.enhanceWithASTAnalysis(graph, codebaseAnalysis.structure.fileGraph, jobId);
-        // Calculate dependents (reverse dependencies)
-        this.calculateDependents(graph);
-        // Calculate dependency depths
-        this.calculateDepths(graph);
-        // Detect circular dependencies
-        const circularChains = this.detectCircularDependencies(graph);
-        chains.push(...circularChains);
-        // Mark circular files
-        this.markCircularDependencies(graph, circularChains);
-        // Calculate metrics
-        const metrics = this.calculateDependencyMetrics(graph, chains);
-        // Identify issues
-        const issues = this.identifyDependencyIssues(graph, chains, metrics);
-        // Generate recommendations
-        const recommendations = this.generateRecommendations(issues, metrics);
-        const analysis = {
-            graph,
-            chains,
-            metrics,
-            issues,
-            recommendations,
-        };
-        await frameworkLogger.log("dependency-graph-builder", "analysis-complete", "success", {
-            jobId,
-            files: graph.size,
-            dependencies: metrics.totalDependencies,
-            circularDeps: metrics.circularDependencies,
-            issues: issues.length,
-        });
-        return analysis;
-    }
-    /**
-     * Enhance dependency graph with AST analysis
-     */
-    async enhanceWithASTAnalysis(graph, fileGraph, jobId) {
-        for (const [filePath, fileInfo] of Array.from(fileGraph)) {
-            if (this.isSourceFile(filePath)) {
-                try {
-                    const astAnalysis = await this.astParser.analyzeFile(filePath);
-                    // Update imports and exports with AST data
-                    const node = graph.get(filePath);
-                    if (node) {
-                        node.imports = Array.from(new Set([
-                            ...node.imports,
-                            ...astAnalysis.structure.imports.map((imp) => imp.module),
-                        ]));
-                        node.exports = Array.from(new Set([
-                            ...node.exports,
-                            ...astAnalysis.structure.exports.map((exp) => exp.name),
-                        ]));
-                    }
-                }
-                catch (error) {
-                    await frameworkLogger.log("dependency-graph-builder", "ast-enhancement-failed", "info", {
-                        jobId,
-                        filePath,
-                        error: error instanceof Error ? error.message : String(error),
-                    });
-                }
-            }
-        }
-    }
-    /**
-     * Calculate which files depend on each file (reverse dependencies)
-     */
-    calculateDependents(graph) {
-        for (const [filePath, node] of Array.from(graph)) {
-            // Handle malformed data gracefully
-            if (!node.imports || !Array.isArray(node.imports)) {
-                continue;
-            }
-            for (const importPath of node.imports) {
-                // Skip invalid import paths
-                if (typeof importPath !== "string") {
-                    continue;
-                }
-                // Resolve import to actual file
-                const resolvedFile = this.resolveImport(importPath, filePath, graph);
-                if (resolvedFile && graph.has(resolvedFile)) {
-                    const dependentNode = graph.get(resolvedFile);
-                    if (!dependentNode.dependents.includes(filePath)) {
-                        dependentNode.dependents.push(filePath);
-                    }
-                }
-            }
-        }
-    }
-    /**
-     * Calculate dependency depth for each file
-     */
-    calculateDepths(graph) {
-        const visited = new Set();
-        const recursionStack = new Set();
-        const calculateDepth = (filePath) => {
-            if (visited.has(filePath)) {
-                return graph.get(filePath).depth;
-            }
-            visited.add(filePath);
-            recursionStack.add(filePath);
-            const node = graph.get(filePath);
-            let maxDepth = 0;
-            // Handle malformed data gracefully
-            if (!node.imports || !Array.isArray(node.imports)) {
-                node.depth = 0;
-                return 0;
-            }
-            for (const importPath of node.imports) {
-                // Skip invalid import paths
-                if (typeof importPath !== "string") {
-                    continue;
-                }
-                const resolvedFile = this.resolveImport(importPath, filePath, graph);
-                if (resolvedFile && graph.has(resolvedFile)) {
-                    if (recursionStack.has(resolvedFile)) {
-                        // Circular dependency detected
-                        continue;
-                    }
-                    const depth = calculateDepth(resolvedFile) + 1;
-                    maxDepth = Math.max(maxDepth, depth);
-                }
-            }
-            recursionStack.delete(filePath);
-            node.depth = maxDepth;
-            return maxDepth;
-        };
-        for (const filePath of Array.from(graph.keys())) {
-            calculateDepth(filePath);
-        }
-    }
-    /**
-     * Detect circular dependencies in the graph
-     */
-    detectCircularDependencies(graph) {
-        const circularChains = [];
-        const visited = new Set();
-        const recursionStack = new Set();
-        const dfs = (filePath, path = []) => {
-            visited.add(filePath);
-            recursionStack.add(filePath);
-            path.push(filePath);
-            const node = graph.get(filePath);
-            // Handle malformed data gracefully
-            if (!node.imports || !Array.isArray(node.imports)) {
-                recursionStack.delete(filePath);
-                path.pop();
-                return;
-            }
-            for (const importPath of node.imports) {
-                // Skip invalid import paths
-                if (typeof importPath !== "string") {
-                    continue;
-                }
-                const resolvedFile = this.resolveImport(importPath, filePath, graph);
-                if (!resolvedFile || !graph.has(resolvedFile))
-                    continue;
-                if (!visited.has(resolvedFile)) {
-                    dfs(resolvedFile, [...path]);
-                }
-                else if (recursionStack.has(resolvedFile)) {
-                    // Found circular dependency
-                    const cycleStart = path.indexOf(resolvedFile);
-                    const cycle = [...path.slice(cycleStart), resolvedFile];
-                    circularChains.push({
-                        start: resolvedFile,
-                        end: resolvedFile,
-                        path: cycle,
-                        type: "circular",
-                    });
-                }
-            }
-            recursionStack.delete(filePath);
-            path.pop();
-        };
-        for (const filePath of Array.from(graph.keys())) {
-            if (!visited.has(filePath)) {
-                dfs(filePath);
-            }
-        }
-        return circularChains;
-    }
-    /**
-     * Mark files that are part of circular dependencies
-     */
-    markCircularDependencies(graph, circularChains) {
-        for (const chain of circularChains) {
-            for (const filePath of chain.path) {
-                const node = graph.get(filePath);
-                if (node) {
-                    node.circular = true;
-                }
-            }
-        }
-    }
-    /**
-     * Calculate comprehensive dependency metrics
-     */
-    calculateDependencyMetrics(graph, chains) {
-        const allImports = Array.from(graph.values()).flatMap((node) => node.imports);
-        const uniqueModules = new Set(allImports).size;
-        const maxDepth = Math.max(...Array.from(graph.values()).map((node) => node.depth));
-        const circularDependencies = chains.filter((chain) => chain.type === "circular").length;
-        const orphanFiles = Array.from(graph.values()).filter((node) => node.dependents.length === 0 &&
-            (!node.imports || node.imports.length === 0)).length;
-        const tightlyCoupledFiles = Array.from(graph.values()).filter((node) => node.dependents.length > 10 ||
-            (node.imports && node.imports.length > 10)).length;
-        const averageDependenciesPerFile = allImports.length / graph.size;
-        // Calculate coupling index (0-100, higher = more coupled)
-        const couplingIndex = Math.min(100, averageDependenciesPerFile * 10 +
-            circularDependencies * 20 +
-            tightlyCoupledFiles * 5);
-        return {
-            totalDependencies: allImports.length,
-            uniqueModules,
-            maxDepth: maxDepth || 0,
-            circularDependencies,
-            orphanFiles,
-            tightlyCoupledFiles,
-            averageDependenciesPerFile,
-            couplingIndex,
-        };
-    }
-    /**
-     * Identify dependency-related issues
-     */
-    identifyDependencyIssues(graph, chains, metrics) {
-        const issues = [];
-        // Circular dependencies
-        for (const chain of chains.filter((c) => c.type === "circular")) {
-            issues.push({
-                type: "circular-dependency",
-                severity: chain.path.length > 4 ? "critical" : "high",
-                files: chain.path,
-                description: `Circular dependency detected: ${chain.path.join(" -> ")}`,
-                impact: "Makes code harder to test, maintain, and understand",
-                suggestion: "Refactor to break the circular dependency using dependency injection or event-driven patterns",
-            });
-        }
-        // Orphan files
-        if (metrics.orphanFiles > 0) {
-            const orphans = Array.from(graph.values())
-                .filter((node) => node.dependents.length === 0 &&
-                (!node.imports || node.imports.length === 0))
-                .map((node) => node.file);
-            issues.push({
-                type: "orphan-file",
-                severity: metrics.orphanFiles > 10 ? "medium" : "low",
-                files: orphans,
-                description: `${metrics.orphanFiles} files have no dependencies or dependents`,
-                impact: "May indicate dead code or unused functionality",
-                suggestion: "Review orphan files for removal or integration into the codebase",
-            });
-        }
-        // Tight coupling
-        if (metrics.tightlyCoupledFiles > 0) {
-            const tightlyCoupled = Array.from(graph.values())
-                .filter((node) => node.dependents.length > 10 || node.imports.length > 10)
-                .map((node) => node.file);
-            issues.push({
-                type: "tight-coupling",
-                severity: "high",
-                files: tightlyCoupled,
-                description: `${metrics.tightlyCoupledFiles} files have high coupling (many dependencies)`,
-                impact: "Changes to these files will affect many other files",
-                suggestion: "Consider breaking down tightly coupled files into smaller, focused modules",
-            });
-        }
-        // Deep dependency chains
-        if (metrics.maxDepth > 5) {
-            const deepFiles = Array.from(graph.values())
-                .filter((node) => node.depth > 5)
-                .map((node) => node.file);
-            issues.push({
-                type: "deep-dependency",
-                severity: "medium",
-                files: deepFiles,
-                description: `Some files have dependency depth > 5 (max: ${metrics.maxDepth})`,
-                impact: "Makes code harder to understand and test",
-                suggestion: "Consider flattening the dependency hierarchy",
-            });
-        }
-        return issues;
-    }
-    /**
-     * Generate recommendations based on issues and metrics
-     */
-    generateRecommendations(issues, metrics) {
-        const recommendations = [];
-        if (metrics.couplingIndex > 70) {
-            recommendations.push("High coupling detected - consider implementing dependency injection to reduce tight coupling");
-        }
-        if (metrics.circularDependencies > 0) {
-            recommendations.push("Break circular dependencies by introducing interfaces or event-driven communication");
-        }
-        if (metrics.maxDepth > 3) {
-            recommendations.push("Flatten deep dependency chains by creating facade classes or reducing abstraction layers");
-        }
-        if (metrics.orphanFiles > metrics.totalDependencies * 0.1) {
-            recommendations.push("High number of orphan files - conduct code cleanup to remove dead code");
-        }
-        if (issues.some((issue) => issue.type === "tight-coupling")) {
-            recommendations.push("Break down tightly coupled components by implementing facade pattern or adapter pattern");
-        }
-        return recommendations;
-    }
-    // Helper methods
-    getModuleName(filePath, modules) {
-        for (const [modulePath, module] of Array.from(modules)) {
-            if (filePath.startsWith(modulePath)) {
-                return module.name;
-            }
-        }
-        return path.dirname(filePath).split(path.sep).pop() || "root";
-    }
-    isSourceFile(filePath) {
-        const extensions = [
-            ".ts",
-            ".tsx",
-            ".js",
-            ".jsx",
-            ".py",
-            ".java",
-            ".cpp",
-            ".c",
-        ];
-        return extensions.some((ext) => filePath.endsWith(ext));
-    }
-    resolveImport(importPath, fromFile, graph) {
-        // Handle relative imports
-        if (importPath.startsWith("./") || importPath.startsWith("../")) {
-            const fromDir = path.dirname(fromFile);
-            const resolvedPath = path.resolve(fromDir, importPath);
-            // For test environments, also try relative path resolution
-            const relativeResolved = path
-                .relative("", resolvedPath)
-                .replace(/\\/g, "/");
-            // Try different extensions
-            const extensions = ["", ".ts", ".tsx", ".js", ".jsx", ".py", ".java"];
-            for (const ext of extensions) {
-                // Try absolute path first
-                let testPath = resolvedPath + ext;
-                if (graph.has(testPath)) {
-                    return testPath;
-                }
-                // Try relative path
-                testPath = relativeResolved + ext;
-                if (graph.has(testPath)) {
-                    return testPath;
-                }
-                // Try just the basename for test environments
-                const basename = path.basename(resolvedPath) + ext;
-                if (graph.has(basename)) {
-                    return basename;
-                }
-                // Try index files in directories
-                const indexPath = path.join(resolvedPath, "index" + ext);
-                if (graph.has(indexPath)) {
-                    return indexPath;
-                }
-            }
-        }
-        // Handle module imports (simplified - would need module resolution logic)
-        // For now, just return null for external modules
-        return null;
-    }
-}

package/dist/delegation/index.d.ts

@@ -1,25 +0,0 @@
-/**
- * 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/index.js

@@ -1,20 +0,0 @@
-/**
- * 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 { AgentMetricsSystem, getAgentMetricsSystem, initializeAgentMetrics, resetAgentMetricsSystem, } from "../metrics/agent-metrics.js";
-export { scoreComplexity, routeToAgent, scoreAndRoute } from "../nucleus/thin-dispatch.js";

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

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