0xray 4.0.12 → 4.0.13

package/dist/architect/architect-tools.js

@@ -1,437 +0,0 @@
-/**
- * Architect Tools - Integration layer between architect agent and contextual analysis system
- * Provides tools for codebase intelligence, architectural assessment, and design planning
- */
-import { createCodebaseContextAnalyzer, } from "../delegation/codebase-context-analyzer.js";
-import { ASTCodeParser } from "../delegation/ast-code-parser.js";
-import { DependencyGraphBuilder, } from "../delegation/dependency-graph-builder.js";
-import { frameworkLogger } from "../core/framework-logger.js";
-/**
- * Context Analysis Tool - Comprehensive codebase intelligence gathering
- */
-export async function contextAnalysis(projectRoot, files, depth = "detailed") {
-    await frameworkLogger.log("architect-tools", "context-analysis-start", "info", {
-        projectRoot,
-        fileCount: files?.length || 0,
-        depth,
-    });
-    try {
-        // Initialize contextual analysis components
-        const contextAnalyzer = createCodebaseContextAnalyzer(projectRoot, {
-            maxFilesInMemory: depth === "comprehensive" ? 500 : 100,
-            maxFileSizeBytes: 1024 * 1024, // 1MB
-            enableStreaming: true,
-            batchSize: 20,
-            enableCaching: true,
-        });
-        const astParser = new ASTCodeParser();
-        const dependencyBuilder = new DependencyGraphBuilder(contextAnalyzer, astParser);
-        // Perform comprehensive analysis
-        const analysis = await contextAnalyzer.analyzeCodebase();
-        // Enhanced analysis based on depth
-        let architecturalPatterns = [];
-        let dependencyIssues = [];
-        let scalabilityAssessment;
-        let maintainabilityIndex;
-        let complexityAnalysis;
-        if (depth !== "overview") {
-            // Build dependency graph for deeper analysis
-            const dependencyAnalysis = await dependencyBuilder.buildDependencyGraph();
-            architecturalPatterns = identifyArchitecturalPatterns(analysis, dependencyAnalysis);
-            dependencyIssues = analyzeDependencyHealth(dependencyAnalysis);
-            scalabilityAssessment = assessScalability(analysis, dependencyAnalysis);
-            maintainabilityIndex = calculateMaintainabilityIndex(analysis, dependencyAnalysis);
-            complexityAnalysis = analyzeComplexityPatterns(analysis);
-        }
-        else {
-            // Basic analysis for overview
-            architecturalPatterns = identifyBasicPatterns(analysis);
-            dependencyIssues = [];
-            scalabilityAssessment = {
-                score: 75,
-                recommendations: ["Detailed analysis recommended"],
-            };
-            maintainabilityIndex = 75;
-            complexityAnalysis = {
-                averageComplexity: 0,
-                highComplexityFiles: [],
-                complexityDistribution: "low",
-                recommendations: ["Detailed analysis recommended"],
-            };
-        }
-        const result = {
-            codebaseStructure: analysis.structure,
-            architecturalPatterns,
-            dependencyIssues,
-            scalabilityAssessment,
-            maintainabilityIndex,
-            complexityAnalysis,
-        };
-        await frameworkLogger.log("architect-tools", "context-analysis-complete", "success", {
-            projectRoot,
-            filesAnalyzed: analysis.structure.totalFiles,
-            patternsFound: architecturalPatterns.length,
-            issuesFound: dependencyIssues.length,
-            maintainabilityIndex,
-        });
-        return result;
-    }
-    catch (error) {
-        await frameworkLogger.log("architect-tools", "context-analysis-failed", "error", {
-            projectRoot,
-            error: error instanceof Error ? error.message : String(error),
-        });
-        throw error;
-    }
-}
-/**
- * Codebase Structure Tool - File organization and module analysis
- */
-export async function codebaseStructure(projectRoot, includeMetrics = true) {
-    await frameworkLogger.log("architect-tools", "structure-analysis-start", "info", {
-        projectRoot,
-        includeMetrics,
-    });
-    const contextAnalyzer = createCodebaseContextAnalyzer(projectRoot);
-    const analysis = await contextAnalyzer.analyzeCodebase();
-    const structure = {
-        overview: {
-            totalFiles: analysis.structure.totalFiles,
-            totalLinesOfCode: analysis.structure.totalLinesOfCode,
-            languages: Array.from(analysis.structure.languages.entries()),
-            modules: analysis.structure.modules.size,
-        },
-        fileTypes: analysis.structure.fileGraph
-            ? groupByFileType(analysis.structure.fileGraph)
-            : {},
-        moduleStructure: analysis.structure.modules
-            ? Array.from(analysis.structure.modules.values())
-            : [],
-        ...(includeMetrics && {
-            metrics: {
-                qualityScore: analysis.metrics.qualityScore,
-                complexity: analysis.metrics.complexity,
-                coupling: analysis.metrics.coupling,
-                cohesion: analysis.metrics.cohesion,
-            },
-        }),
-    };
-    await frameworkLogger.log("architect-tools", "structure-analysis-complete", "success", {
-        projectRoot,
-        filesAnalyzed: analysis.structure.totalFiles,
-    });
-    return structure;
-}
-/**
- * Dependency Analysis Tool - Component relationship and coupling analysis
- */
-export async function dependencyAnalysis(projectRoot, focusAreas) {
-    await frameworkLogger.log("architect-tools", "dependency-analysis-start", "info", {
-        projectRoot,
-        focusAreas: focusAreas?.length || 0,
-    });
-    const contextAnalyzer = createCodebaseContextAnalyzer(projectRoot);
-    const astParser = new ASTCodeParser();
-    const dependencyBuilder = new DependencyGraphBuilder(contextAnalyzer, astParser);
-    const analysis = await dependencyBuilder.buildDependencyGraph();
-    // Analyze dependency health
-    const circularDependencies = analysis.issues
-        .filter((issue) => issue.type === "circular-dependency")
-        .map((issue) => issue.description);
-    const tightlyCoupledModules = identifyTightlyCoupledModules(analysis.graph);
-    const orphanModules = identifyOrphanModules(analysis.graph);
-    const healthScore = calculateDependencyHealthScore(analysis);
-    const recommendations = generateDependencyRecommendations(circularDependencies, tightlyCoupledModules, orphanModules, healthScore);
-    const result = {
-        graph: analysis.graph,
-        circularDependencies,
-        tightlyCoupledModules,
-        orphanModules,
-        healthScore,
-        recommendations,
-    };
-    await frameworkLogger.log("architect-tools", "dependency-analysis-complete", "success", {
-        projectRoot,
-        circularDeps: circularDependencies.length,
-        tightlyCoupled: tightlyCoupledModules.length,
-        orphans: orphanModules.length,
-        healthScore,
-    });
-    return result;
-}
-/**
- * Architecture Assessment Tool - Overall architectural health evaluation
- */
-export async function architectureAssessment(projectRoot, assessmentType = "comprehensive") {
-    await frameworkLogger.log("architect-tools", "architecture-assessment-start", "info", {
-        projectRoot,
-        assessmentType,
-    });
-    // Gather all necessary data
-    const contextResult = await contextAnalysis(projectRoot, undefined, assessmentType === "comprehensive" ? "detailed" : "overview");
-    const dependencyResult = await dependencyAnalysis(projectRoot);
-    // Calculate architectural health scores
-    const scores = calculateArchitecturalScores(contextResult, dependencyResult);
-    const overallHealth = determineOverallHealth(scores);
-    const issues = identifyArchitecturalIssues(contextResult, dependencyResult, scores);
-    const recommendations = generateArchitecturalRecommendations(issues, scores);
-    const result = {
-        overallHealth,
-        scores,
-        issues,
-        recommendations,
-    };
-    await frameworkLogger.log("architect-tools", "architecture-assessment-complete", "success", {
-        projectRoot,
-        overallHealth,
-        issueCount: issues.length,
-        recommendationCount: recommendations.length,
-    });
-    return result;
-}
-// Helper functions
-function identifyArchitecturalPatterns(codebaseAnalysis, dependencyAnalysis) {
-    const patterns = [];
-    // MVC Pattern detection
-    if (hasMVCPattern(codebaseAnalysis)) {
-        patterns.push("Model-View-Controller (MVC)");
-    }
-    // Repository Pattern
-    if (hasRepositoryPattern(codebaseAnalysis)) {
-        patterns.push("Repository Pattern");
-    }
-    // Observer Pattern
-    if (hasObserverPattern(codebaseAnalysis)) {
-        patterns.push("Observer Pattern");
-    }
-    // Factory Pattern
-    if (hasFactoryPattern(codebaseAnalysis)) {
-        patterns.push("Factory Pattern");
-    }
-    // Microservices indicators
-    if (hasMicroservicesIndicators(codebaseAnalysis)) {
-        patterns.push("Microservices Architecture");
-    }
-    // Layered Architecture
-    if (hasLayeredArchitecture(dependencyAnalysis)) {
-        patterns.push("Layered Architecture");
-    }
-    return patterns;
-}
-function identifyBasicPatterns(codebaseAnalysis) {
-    const patterns = [];
-    // Basic pattern detection based on file structure
-    const fileNames = Array.from(codebaseAnalysis.structure.fileGraph?.keys() || []);
-    if (fileNames.some((f) => typeof f === "string" && f.includes("controller")))
-        patterns.push("Controller Layer Detected");
-    if (fileNames.some((f) => typeof f === "string" && f.includes("service")))
-        patterns.push("Service Layer Detected");
-    if (fileNames.some((f) => typeof f === "string" && (f.includes("model") || f.includes("entity"))))
-        patterns.push("Data Models Detected");
-    return patterns;
-}
-function analyzeDependencyHealth(dependencyAnalysis) {
-    const issues = [];
-    if (dependencyAnalysis.metrics.circularDependencies > 0) {
-        issues.push(`${dependencyAnalysis.metrics.circularDependencies} circular dependencies detected`);
-    }
-    if (dependencyAnalysis.metrics.couplingIndex > 80) {
-        issues.push(`High coupling index: ${dependencyAnalysis.metrics.couplingIndex}`);
-    }
-    if (dependencyAnalysis.metrics.orphanFiles > 0) {
-        issues.push(`${dependencyAnalysis.metrics.orphanFiles} orphan files detected`);
-    }
-    return issues;
-}
-function assessScalability(codebaseAnalysis, dependencyAnalysis) {
-    let score = 100;
-    const recommendations = [];
-    // Coupling impact on scalability
-    if (dependencyAnalysis.metrics.couplingIndex > 70) {
-        score -= 20;
-        recommendations.push("Reduce coupling to improve scalability");
-    }
-    // Modularity impact
-    if (codebaseAnalysis.structure.modules.size < 5 &&
-        codebaseAnalysis.structure.totalFiles > 50) {
-        score -= 15;
-        recommendations.push("Increase modularity for better scalability");
-    }
-    // File size impact
-    const avgFileSize = codebaseAnalysis.structure.totalLinesOfCode /
-        codebaseAnalysis.structure.totalFiles;
-    if (avgFileSize > 500) {
-        score -= 10;
-        recommendations.push("Break down large files for better maintainability");
-    }
-    return { score: Math.max(0, score), recommendations };
-}
-function calculateMaintainabilityIndex(codebaseAnalysis, dependencyAnalysis) {
-    let index = 100;
-    // Complexity impact
-    if (codebaseAnalysis.metrics.complexity > 80)
-        index -= 25;
-    // Coupling impact
-    if (dependencyAnalysis.metrics.couplingIndex > 70)
-        index -= 20;
-    // Test coverage impact (estimated)
-    const estimatedTestCoverage = codebaseAnalysis.metrics.testCoverage || 50;
-    if (estimatedTestCoverage < 70)
-        index -= Math.floor((70 - estimatedTestCoverage) / 2);
-    return Math.max(0, index);
-}
-function analyzeComplexityPatterns(codebaseAnalysis) {
-    return {
-        averageComplexity: codebaseAnalysis.metrics.complexity || 0,
-        highComplexityFiles: [], // Would be populated with actual analysis
-        complexityDistribution: "low",
-        recommendations: generateComplexityRecommendations(codebaseAnalysis),
-    };
-}
-function hasMVCPattern(analysis) {
-    const files = Array.from(analysis.structure.fileGraph?.keys() || []);
-    const hasControllers = files.some((f) => typeof f === "string" && f.includes("controller"));
-    const hasModels = files.some((f) => typeof f === "string" && f.includes("model"));
-    const hasViews = files.some((f) => typeof f === "string" && (f.includes("view") || f.includes("component")));
-    return hasControllers && hasModels && hasViews;
-}
-function hasRepositoryPattern(analysis) {
-    const files = Array.from(analysis.structure.fileGraph?.keys() || []);
-    return files.some((f) => typeof f === "string" && f.includes("repository"));
-}
-function hasObserverPattern(analysis) {
-    return false;
-}
-function hasFactoryPattern(analysis) {
-    const files = Array.from(analysis.structure.fileGraph?.keys() || []);
-    return files.some((f) => typeof f === "string" && f.includes("factory"));
-}
-function hasMicroservicesIndicators(analysis) {
-    const files = Array.from(analysis.structure.fileGraph?.keys() || []);
-    return files.some((f) => typeof f === "string" &&
-        (f.includes("docker") || f.includes("kubernetes")));
-}
-function hasLayeredArchitecture(dependencyAnalysis) {
-    return false;
-}
-function groupByFileType(fileGraph) {
-    const types = {};
-    for (const fileInfo of fileGraph.values()) {
-        const type = fileInfo.language || "other";
-        types[type] = (types[type] || 0) + 1;
-    }
-    return types;
-}
-function identifyTightlyCoupledModules(graph) {
-    return [];
-}
-function identifyOrphanModules(graph) {
-    return [];
-}
-function calculateDependencyHealthScore(analysis) {
-    let score = 100;
-    if (analysis.metrics.circularDependencies > 0)
-        score -= analysis.metrics.circularDependencies * 10;
-    if (analysis.metrics.couplingIndex > 70)
-        score -= analysis.metrics.couplingIndex - 70;
-    if (analysis.metrics.orphanFiles > 0)
-        score -= analysis.metrics.orphanFiles * 5;
-    return Math.max(0, score);
-}
-function generateDependencyRecommendations(circularDeps, tightlyCoupled, orphans, healthScore) {
-    const recommendations = [];
-    if (circularDeps.length > 0) {
-        recommendations.push("Resolve circular dependencies by introducing interfaces or mediator patterns");
-    }
-    if (tightlyCoupled.length > 0) {
-        recommendations.push("Reduce coupling by applying dependency inversion principle");
-    }
-    if (orphans.length > 0) {
-        recommendations.push("Review orphan modules - they may indicate dead code or missing integration");
-    }
-    if (healthScore < 70) {
-        recommendations.push("Consider architectural refactoring to improve dependency health");
-    }
-    return recommendations;
-}
-function calculateArchitecturalScores(context, deps) {
-    return {
-        modularity: context.codebaseStructure.modules?.size > 5 ? 85 : 60,
-        coupling: Math.max(0, 100 - deps.healthScore),
-        cohesion: context.maintainabilityIndex,
-        testability: 75, // Placeholder
-        scalability: context.scalabilityAssessment.score,
-    };
-}
-function determineOverallHealth(scores) {
-    const avgScore = Object.values(scores).reduce((a, b) => a + b, 0) /
-        Object.values(scores).length;
-    if (avgScore >= 85)
-        return "excellent";
-    if (avgScore >= 70)
-        return "good";
-    if (avgScore >= 55)
-        return "fair";
-    if (avgScore >= 40)
-        return "poor";
-    return "critical";
-}
-function identifyArchitecturalIssues(context, deps, scores) {
-    const issues = [];
-    if (scores.coupling > 80) {
-        issues.push({
-            type: "critical",
-            description: "High coupling between components",
-            impact: "Makes changes difficult and increases bug risk",
-            recommendation: "Apply dependency inversion and interface segregation principles",
-        });
-    }
-    if (scores.modularity < 60) {
-        issues.push({
-            type: "major",
-            description: "Low modularity",
-            impact: "Code is monolithic and hard to maintain",
-            recommendation: "Break down into smaller, focused modules",
-        });
-    }
-    if (deps.circularDependencies.length > 0) {
-        issues.push({
-            type: "major",
-            description: `${deps.circularDependencies.length} circular dependencies detected`,
-            impact: "Creates tight coupling and makes testing difficult",
-            recommendation: "Refactor to break circular dependencies",
-        });
-    }
-    return issues;
-}
-function generateArchitecturalRecommendations(issues, scores) {
-    const recommendations = [];
-    if (issues.some((i) => i.type === "critical")) {
-        recommendations.push("Address critical architectural issues immediately");
-    }
-    if (scores.scalability < 70) {
-        recommendations.push("Improve scalability by reducing coupling and increasing modularity");
-    }
-    if (scores.testability < 70) {
-        recommendations.push("Enhance testability by improving separation of concerns");
-    }
-    recommendations.push("Regular architectural reviews to maintain code quality");
-    return recommendations;
-}
-function generateComplexityRecommendations(codebaseAnalysis) {
-    const recommendations = [];
-    if (codebaseAnalysis.metrics.complexity > 80) {
-        recommendations.push("Break down complex functions into smaller, focused units");
-    }
-    if (codebaseAnalysis.structure.totalLinesOfCode > 10000) {
-        recommendations.push("Consider splitting large codebases into separate modules");
-    }
-    return recommendations;
-}
-// Export tools for MCP integration
-export const architectTools = {
-    contextAnalysis,
-    codebaseStructure,
-    dependencyAnalysis,
-    architectureAssessment,
-};

package/dist/architect/architectural-integrity.d.ts

@@ -1,20 +0,0 @@
-/**
- * ARCHITECTURAL INTEGRITY ENFORCEMENT
- *
- * This module ensures that critical framework components are always active
- * and integrated, preventing the staged initialization issues that broke
- * the post-processor and rules engine enforcement.
- */
-/**
- * Verify all critical components are active and integrated
- */
-export declare function verifyArchitecturalIntegrity(): Promise<{
-    allActive: boolean;
-    issues: string[];
-    recommendations: string[];
-}>;
-/**
- * Force activation of critical components if missing
- * This prevents staged initialization from breaking the framework
- */
-export declare function ensureCriticalComponents(): Promise<void>;

package/dist/architect/architectural-integrity.js

@@ -1,78 +0,0 @@
-/**
- * ARCHITECTURAL INTEGRITY ENFORCEMENT
- *
- * This module ensures that critical framework components are always active
- * and integrated, preventing the staged initialization issues that broke
- * the post-processor and rules engine enforcement.
- */
-import { frameworkLogger } from "../core/framework-logger.js";
-// Critical components that must always be active
-const CRITICAL_COMPONENTS = [
-    "stateManager",
-    "postProcessor",
-    "rulesEngine",
-    "codexInjector",
-];
-/**
- * Verify all critical components are active and integrated
- */
-export async function verifyArchitecturalIntegrity() {
-    const issues = [];
-    const recommendations = [];
-    // Check state manager
-    const stateManager = globalThis.xrayStateManager;
-    if (!stateManager) {
-        issues.push("State manager not initialized");
-        recommendations.push("Ensure boot orchestrator runs before framework activation");
-    }
-    const postProcessor = globalThis.xrayPostProcessor;
-    if (!postProcessor) {
-        issues.push("Post-processor not activated");
-        recommendations.push("Add post-processor activation to xray-activation.ts");
-    }
-    const codexInjector = globalThis.xrayCodexInjector;
-    if (!codexInjector) {
-        issues.push("Codex injector not initialized");
-        recommendations.push("Ensure codex injection is active in plugin context");
-    }
-    // Check rules engine enforcement
-    if (stateManager && !stateManager.get("enforcement:active")) {
-        issues.push("Rules engine not actively enforcing codex");
-        recommendations.push("Ensure codex rules are enforced during tool execution");
-    }
-    const allActive = issues.length === 0;
-    if (!allActive) {
-        frameworkLogger.log("architectural-integrity", `Integrity check failed: ${issues.length} issues found`, "error", { issues, recommendations });
-    }
-    else {
-        frameworkLogger.log("architectural-integrity", "All critical components active and integrated", "success");
-    }
-    return { allActive, issues, recommendations };
-}
-/**
- * Force activation of critical components if missing
- * This prevents staged initialization from breaking the framework
- */
-export async function ensureCriticalComponents() {
-    const integrity = await verifyArchitecturalIntegrity();
-    if (!integrity.allActive) {
-        frameworkLogger.log("architectural-integrity", "Activating missing critical components", "info");
-        // Force activation of missing components
-        for (const recommendation of integrity.recommendations) {
-            if (recommendation.includes("post-processor")) {
-                await forcePostProcessorActivation();
-            }
-            if (recommendation.includes("codex")) {
-                await forceCodexActivation();
-            }
-        }
-    }
-}
-async function forcePostProcessorActivation() {
-    // Implementation to force post-processor activation
-    // This ensures the post-processor is always available
-}
-async function forceCodexActivation() {
-    // Implementation to force codex activation
-    // This ensures rules are always enforced
-}

package/dist/benchmark/performance-benchmark.d.ts

@@ -1,103 +0,0 @@
-export interface BenchmarkResult {
-    operation: string;
-    startTime: number;
-    endTime: number;
-    duration: number;
-    success: boolean;
-    metadata: Record<string, any>;
-    error?: string | undefined;
-}
-export interface PerformanceMetrics {
-    totalOperations: number;
-    successfulOperations: number;
-    failedOperations: number;
-    averageDuration: number;
-    medianDuration: number;
-    p95Duration: number;
-    p99Duration: number;
-    minDuration: number;
-    maxDuration: number;
-    throughput: number;
-}
-export interface BootBenchmarkResult {
-    totalBootTime: number;
-    phaseTimings: Record<string, number>;
-    componentLoadTimes: Record<string, number>;
-    memoryUsage: {
-        beforeBoot: number;
-        afterBoot: number;
-        peakDuringBoot: number;
-    };
-    success: boolean;
-    errors: string[];
-    orchestratorLoadTime?: number;
-    delegationInitTime?: number;
-    sessionManagementInitTime?: number;
-    processorActivationTime?: number;
-    agentLoadingTime?: number;
-    enforcementActivationTime?: number;
-    codexComplianceActivationTime?: number;
-}
-export interface OrchestratorBenchmarkResult {
-    taskExecutionTimes: number[];
-    delegationLatencies: number[];
-    conflictResolutionTimes: number[];
-    concurrentTaskThroughput: number;
-    dependencyResolutionTime: number;
-    overallSuccess: boolean;
-}
-export interface SessionBenchmarkResult {
-    stateShareLatencies: number[];
-    dependencyUpdateTimes: number[];
-    groupOperationTimes: number[];
-    migrationTimes: number[];
-    failoverTimes: number[];
-    concurrentSessionOperations: number;
-}
-export declare class XrayPerformanceBenchmark {
-    private results;
-    private activeBenchmarks;
-    /**
-     * Start a benchmark measurement
-     */
-    startBenchmark(operation: string, metadata?: Record<string, any>): string;
-    /**
-     * End a benchmark measurement
-     */
-    endBenchmark(benchmarkId: string, success?: boolean, error?: string): BenchmarkResult | null;
-    /**
-     * Benchmark boot sequence performance
-     */
-    benchmarkBootSequence(_bootOrchestrator: unknown): Promise<BootBenchmarkResult>;
-    /**
-     * Benchmark orchestrator task execution
-     */
-    benchmarkOrchestratorTasks(_orchestrator: unknown, taskCount?: number, concurrentTasks?: number): Promise<OrchestratorBenchmarkResult>;
-    /**
-     * Benchmark session management operations
-     */
-    benchmarkSessionOperations(_sessionStateManager: unknown, operationCount?: number): Promise<SessionBenchmarkResult>;
-    /**
-     * Calculate performance metrics from benchmark results
-     */
-    calculateMetrics(operationFilter?: string): PerformanceMetrics;
-    /**
-     * Generate comprehensive benchmark report
-     */
-    generateReport(): {
-        summary: PerformanceMetrics;
-        bootBenchmark?: BootBenchmarkResult;
-        orchestratorBenchmark?: OrchestratorBenchmarkResult;
-        sessionBenchmark?: SessionBenchmarkResult;
-        recommendations: string[];
-    };
-    /**
-     * Clear all benchmark results
-     */
-    clearResults(): void;
-    /**
-     * Export results for external analysis
-     */
-    exportResults(): BenchmarkResult[];
-}
-export declare const performanceBenchmark: XrayPerformanceBenchmark;