0xray 2.2.3 → 3.0.0

package/dist/benchmark/performance-benchmark.js

@@ -1,372 +0,0 @@
-// Consumer runtime compat shim from prior StringRay releases (1-line min per Scope Rule; primary xray paths + XRAY_||STRRAY_ env + .xray fallbacks)
-import { frameworkLogger } from "../core/framework-logger.js";
-import crypto from "crypto";
-export class XrayPerformanceBenchmark {
-    results = [];
-    activeBenchmarks = new Map();
-    /**
-     * Start a benchmark measurement
-     */
-    startBenchmark(operation, metadata = {}) {
-        const benchmarkId = `${operation}_${Date.now()}_${crypto.randomBytes(4).toString("hex")}`;
-        this.activeBenchmarks.set(benchmarkId, {
-            startTime: performance.now(),
-            metadata,
-        });
-        return benchmarkId;
-    }
-    /**
-     * End a benchmark measurement
-     */
-    endBenchmark(benchmarkId, success = true, error) {
-        const activeBenchmark = this.activeBenchmarks.get(benchmarkId);
-        if (!activeBenchmark) {
-            frameworkLogger.log("performance-benchmark", "benchmark-not-found", "warning", { benchmarkId });
-            return null;
-        }
-        const endTime = performance.now();
-        const duration = endTime - activeBenchmark.startTime;
-        const result = {
-            operation: benchmarkId.split("_")[0] || "unknown",
-            startTime: activeBenchmark.startTime,
-            endTime,
-            duration,
-            success,
-            metadata: activeBenchmark.metadata,
-            error,
-        };
-        this.results.push(result);
-        this.activeBenchmarks.delete(benchmarkId);
-        return result;
-    }
-    /**
-     * Benchmark boot sequence performance
-     */
-    async benchmarkBootSequence(_bootOrchestrator) {
-        const result = {
-            totalBootTime: 0,
-            phaseTimings: {},
-            componentLoadTimes: {},
-            memoryUsage: {
-                beforeBoot: 0,
-                afterBoot: 0,
-                peakDuringBoot: 0,
-            },
-            success: false,
-            errors: [],
-        };
-        const bootStartTime = performance.now();
-        const peakMemory = 0;
-        try {
-            // Measure initial memory
-            result.memoryUsage.beforeBoot = process.memoryUsage().heapUsed;
-            // Phase 1: Orchestrator loading
-            const orchestratorStart = performance.now();
-            const benchmarkId = this.startBenchmark("orchestrator_load");
-            // Boot sequence will be executed by the caller
-            const orchestratorResult = this.endBenchmark(benchmarkId, true);
-            if (orchestratorResult) {
-                result.phaseTimings.orchestrator_load = orchestratorResult.duration;
-                result.componentLoadTimes.orchestrator = orchestratorResult.duration;
-            }
-            // Phase 2: Delegation system initialization
-            const delegationStart = performance.now();
-            const delegationBenchmarkId = this.startBenchmark("delegation_init");
-            // This will be measured during actual boot
-            const delegationResult = this.endBenchmark(delegationBenchmarkId, true);
-            if (delegationResult) {
-                result.phaseTimings.delegation_init = delegationResult.duration;
-                result.componentLoadTimes.delegation_system = delegationResult.duration;
-            }
-            // Phase 3: Session management initialization
-            const sessionStart = performance.now();
-            const sessionBenchmarkId = this.startBenchmark("session_management_init");
-            const sessionResult = this.endBenchmark(sessionBenchmarkId, true);
-            if (sessionResult) {
-                result.phaseTimings.session_management_init = sessionResult.duration;
-                result.componentLoadTimes.session_management = sessionResult.duration;
-            }
-            // Phase 4: Processor activation
-            const processorStart = performance.now();
-            const processorBenchmarkId = this.startBenchmark("processor_activation");
-            const processorResult = this.endBenchmark(processorBenchmarkId, true);
-            if (processorResult) {
-                result.phaseTimings.processor_activation = processorResult.duration;
-                result.componentLoadTimes.processor_pipeline = processorResult.duration;
-            }
-            // Phase 5: Agent loading
-            const agentStart = performance.now();
-            const agentBenchmarkId = this.startBenchmark("agent_loading");
-            const agentResult = this.endBenchmark(agentBenchmarkId, true);
-            if (agentResult) {
-                result.phaseTimings.agent_loading = agentResult.duration;
-                result.componentLoadTimes.agent_loading = agentResult.duration;
-            }
-            // Phase 6: Enforcement activation
-            const enforcementStart = performance.now();
-            const enforcementBenchmarkId = this.startBenchmark("enforcement_activation");
-            const enforcementResult = this.endBenchmark(enforcementBenchmarkId, true);
-            if (enforcementResult) {
-                result.phaseTimings.enforcement_activation = enforcementResult.duration;
-                result.componentLoadTimes.enforcement_system =
-                    enforcementResult.duration;
-            }
-            // Phase 7: Codex compliance activation
-            const codexStart = performance.now();
-            const codexBenchmarkId = this.startBenchmark("codex_compliance_activation");
-            const codexResult = this.endBenchmark(codexBenchmarkId, true);
-            if (codexResult) {
-                result.phaseTimings.codex_compliance_activation = codexResult.duration;
-                result.componentLoadTimes.codex_compliance = codexResult.duration;
-            }
-            // Calculate total boot time
-            result.totalBootTime = performance.now() - bootStartTime;
-            result.memoryUsage.afterBoot = process.memoryUsage().heapUsed;
-            result.memoryUsage.peakDuringBoot = peakMemory;
-            result.success = true;
-        }
-        catch (error) {
-            result.errors.push(error instanceof Error ? error.message : String(error));
-            result.success = false;
-        }
-        return result;
-    }
-    /**
-     * Benchmark orchestrator task execution
-     */
-    async benchmarkOrchestratorTasks(_orchestrator, taskCount = 10, concurrentTasks = 3) {
-        const result = {
-            taskExecutionTimes: [],
-            delegationLatencies: [],
-            conflictResolutionTimes: [],
-            concurrentTaskThroughput: 0,
-            dependencyResolutionTime: 0,
-            overallSuccess: true,
-        };
-        try {
-            // Benchmark single task execution
-            for (let i = 0; i < taskCount; i++) {
-                const taskStart = performance.now();
-                const benchmarkId = this.startBenchmark(`single_task_${i}`, {
-                    taskId: `task_${i}`,
-                });
-                // Simulate task execution
-                await new Promise((resolve) => setTimeout(resolve, Math.random() * 100 + 50));
-                const taskResult = this.endBenchmark(benchmarkId, true);
-                if (taskResult) {
-                    result.taskExecutionTimes.push(taskResult.duration);
-                }
-            }
-            // Benchmark concurrent task execution
-            const concurrentStart = performance.now();
-            const concurrentPromises = [];
-            for (let i = 0; i < concurrentTasks; i++) {
-                const benchmarkId = this.startBenchmark(`concurrent_task_${i}`, {
-                    concurrent: true,
-                });
-                const promise = new Promise((resolve) => {
-                    setTimeout(() => {
-                        this.endBenchmark(benchmarkId, true);
-                        resolve();
-                    }, Math.random() * 200 + 100);
-                });
-                concurrentPromises.push(promise);
-            }
-            await Promise.all(concurrentPromises);
-            const concurrentEnd = performance.now();
-            result.concurrentTaskThroughput =
-                concurrentTasks / ((concurrentEnd - concurrentStart) / 1000);
-            // Benchmark complex task with dependencies
-            const dependencyStart = performance.now();
-            const dependencyBenchmarkId = this.startBenchmark("dependency_resolution");
-            const complexTasks = [
-                {
-                    id: "task_a",
-                    description: "Task A",
-                    subagentType: "architect",
-                    dependencies: [],
-                },
-                {
-                    id: "task_b",
-                    description: "Task B",
-                    subagentType: "code-reviewer",
-                    dependencies: ["task_a"],
-                },
-                {
-                    id: "task_c",
-                    description: "Task C",
-                    subagentType: "researcher",
-                    dependencies: ["task_b"],
-                },
-            ];
-            // Simulate dependency resolution
-            await new Promise((resolve) => setTimeout(resolve, 150));
-            const dependencyResult = this.endBenchmark(dependencyBenchmarkId, true);
-            if (dependencyResult) {
-                result.dependencyResolutionTime = dependencyResult.duration;
-            }
-        }
-        catch (error) {
-            result.overallSuccess = false;
-            await frameworkLogger.log("performance-benchmark", "orchestrator-benchmarking-failed", "error", { error: String(error) });
-        }
-        return result;
-    }
-    /**
-     * Benchmark session management operations
-     */
-    async benchmarkSessionOperations(_sessionStateManager, operationCount = 20) {
-        const result = {
-            stateShareLatencies: [],
-            dependencyUpdateTimes: [],
-            groupOperationTimes: [],
-            migrationTimes: [],
-            failoverTimes: [],
-            concurrentSessionOperations: 0,
-        };
-        try {
-            // Benchmark state sharing
-            for (let i = 0; i < operationCount; i++) {
-                const shareStart = performance.now();
-                const benchmarkId = this.startBenchmark(`state_share_${i}`, {
-                    operation: "share",
-                });
-                // Simulate state sharing
-                await new Promise((resolve) => setTimeout(resolve, Math.random() * 20 + 5));
-                const shareResult = this.endBenchmark(benchmarkId, true);
-                if (shareResult) {
-                    result.stateShareLatencies.push(shareResult.duration);
-                }
-            }
-            // Benchmark dependency operations
-            for (let i = 0; i < operationCount / 2; i++) {
-                const depStart = performance.now();
-                const benchmarkId = this.startBenchmark(`dependency_update_${i}`, {
-                    operation: "dependency",
-                });
-                // Simulate dependency update
-                await new Promise((resolve) => setTimeout(resolve, Math.random() * 30 + 10));
-                const depResult = this.endBenchmark(benchmarkId, true);
-                if (depResult) {
-                    result.dependencyUpdateTimes.push(depResult.duration);
-                }
-            }
-            // Benchmark group operations
-            const groupStart = performance.now();
-            const groupBenchmarkId = this.startBenchmark("group_operations", {
-                operation: "group",
-            });
-            // Simulate group operations
-            await new Promise((resolve) => setTimeout(resolve, 100));
-            const groupResult = this.endBenchmark(groupBenchmarkId, true);
-            if (groupResult) {
-                result.groupOperationTimes.push(groupResult.duration);
-            }
-            // Benchmark migration simulation
-            const migrationStart = performance.now();
-            const migrationBenchmarkId = this.startBenchmark("session_migration", {
-                operation: "migration",
-            });
-            // Simulate migration
-            await new Promise((resolve) => setTimeout(resolve, 200));
-            const migrationResult = this.endBenchmark(migrationBenchmarkId, true);
-            if (migrationResult) {
-                result.migrationTimes.push(migrationResult.duration);
-            }
-        }
-        catch (error) {
-            await frameworkLogger.log("performance-benchmark", "session-benchmarking-failed", "error", { error: String(error) });
-        }
-        return result;
-    }
-    /**
-     * Calculate performance metrics from benchmark results
-     */
-    calculateMetrics(operationFilter) {
-        const filteredResults = operationFilter
-            ? this.results.filter((r) => r.operation.includes(operationFilter))
-            : this.results;
-        if (filteredResults.length === 0) {
-            return {
-                totalOperations: 0,
-                successfulOperations: 0,
-                failedOperations: 0,
-                averageDuration: 0,
-                medianDuration: 0,
-                p95Duration: 0,
-                p99Duration: 0,
-                minDuration: 0,
-                maxDuration: 0,
-                throughput: 0,
-            };
-        }
-        const durations = filteredResults
-            .map((r) => r.duration)
-            .sort((a, b) => a - b);
-        const successful = filteredResults.filter((r) => r.success);
-        const totalTime = Math.max(...filteredResults.map((r) => r.endTime)) -
-            Math.min(...filteredResults.map((r) => r.startTime));
-        const avgDuration = durations.length > 0
-            ? durations.reduce((a, b) => a + b, 0) / durations.length
-            : 0;
-        const medianIndex = Math.floor(durations.length / 2);
-        const medianDuration = durations.length > 0 ? durations[medianIndex] : 0;
-        const p95Index = Math.floor(durations.length * 0.95);
-        const p95Duration = durations.length > 0 ? durations[p95Index] : 0;
-        const p99Index = Math.floor(durations.length * 0.99);
-        const p99Duration = durations.length > 0 ? durations[p99Index] : 0;
-        const minDuration = durations.length > 0 ? Math.min(...durations) : 0;
-        const maxDuration = durations.length > 0 ? Math.max(...durations) : 0;
-        return {
-            totalOperations: filteredResults.length,
-            successfulOperations: successful.length,
-            failedOperations: filteredResults.length - successful.length,
-            averageDuration: avgDuration,
-            medianDuration,
-            p95Duration,
-            p99Duration,
-            minDuration,
-            maxDuration,
-            throughput: filteredResults.length / (totalTime / 1000),
-        };
-    }
-    /**
-     * Generate comprehensive benchmark report
-     */
-    generateReport() {
-        const summary = this.calculateMetrics();
-        const report = {
-            summary,
-            recommendations: [],
-        };
-        // Analyze results and generate recommendations
-        if (summary.averageDuration > 100) {
-            report.recommendations.push("Consider optimizing slow operations (>100ms average)");
-        }
-        if (summary.failedOperations > 0) {
-            report.recommendations.push(`${summary.failedOperations} operations failed - investigate error patterns`);
-        }
-        if (summary.p95Duration > 500) {
-            report.recommendations.push("P95 latency >500ms - consider performance optimizations");
-        }
-        if (summary.throughput < 10) {
-            report.recommendations.push("Low throughput (<10 ops/sec) - evaluate bottlenecks");
-        }
-        return report;
-    }
-    /**
-     * Clear all benchmark results
-     */
-    clearResults() {
-        this.results = [];
-        this.activeBenchmarks.clear();
-    }
-    /**
-     * Export results for external analysis
-     */
-    exportResults() {
-        return [...this.results];
-    }
-}
-// Export singleton instance
-export const performanceBenchmark = new XrayPerformanceBenchmark();

package/dist/mcps/connection/connection-manager.d.ts

@@ -1,39 +0,0 @@
-import { IMcpConnection, IServerConfig } from '../types/index.js';
-/**
- * Connection Manager
- * Manages MCP connection lifecycle and provides centralized access to connections
- */
-export declare class ConnectionManager {
-    private connections;
-    /**
-     * Get or create a connection for a server
-     * @param config - Server configuration
-     * @returns Promise resolving to an MCP connection
-     */
-    getConnection(config: IServerConfig): Promise<IMcpConnection>;
-    /**
-     * Disconnect a specific server
-     * @param serverName - Name of the server to disconnect
-     */
-    disconnect(serverName: string): Promise<void>;
-    /**
-     * Disconnect all managed connections
-     */
-    disconnectAll(): Promise<void>;
-    /**
-     * Check if a connection exists for a server
-     * @param serverName - Name of the server
-     * @returns True if connection exists and is connected
-     */
-    hasConnection(serverName: string): boolean;
-    /**
-     * Get all connected server names
-     * @returns Array of server names
-     */
-    getConnectedServers(): string[];
-    /**
-     * Get the number of active connections
-     * @returns Number of connections
-     */
-    getConnectionCount(): number;
-}

package/dist/mcps/connection/connection-manager.js

@@ -1,79 +0,0 @@
-import { McpConnection } from './mcp-connection.js';
-import { frameworkLogger } from '../../core/framework-logger.js';
-/**
- * Connection Manager
- * Manages MCP connection lifecycle and provides centralized access to connections
- */
-export class ConnectionManager {
-    connections = new Map();
-    /**
-     * Get or create a connection for a server
-     * @param config - Server configuration
-     * @returns Promise resolving to an MCP connection
-     */
-    async getConnection(config) {
-        const existingConnection = this.connections.get(config.serverName);
-        if (existingConnection && existingConnection.isConnected) {
-            return existingConnection;
-        }
-        // If existing connection is disconnected, remove it
-        if (existingConnection) {
-            await existingConnection.disconnect();
-            this.connections.delete(config.serverName);
-        }
-        // Create new connection
-        const connection = new McpConnection(config);
-        await connection.connect();
-        this.connections.set(config.serverName, connection);
-        return connection;
-    }
-    /**
-     * Disconnect a specific server
-     * @param serverName - Name of the server to disconnect
-     */
-    async disconnect(serverName) {
-        const connection = this.connections.get(serverName);
-        if (connection) {
-            await connection.disconnect();
-            this.connections.delete(serverName);
-        }
-    }
-    /**
-     * Disconnect all managed connections
-     */
-    async disconnectAll() {
-        const disconnectPromises = [];
-        for (const [serverName, connection] of this.connections) {
-            disconnectPromises.push(connection.disconnect().catch((error) => {
-                frameworkLogger.log("connection-manager", "disconnect-error", "error", { serverName, error });
-            }));
-        }
-        await Promise.all(disconnectPromises);
-        this.connections.clear();
-    }
-    /**
-     * Check if a connection exists for a server
-     * @param serverName - Name of the server
-     * @returns True if connection exists and is connected
-     */
-    hasConnection(serverName) {
-        const connection = this.connections.get(serverName);
-        return connection !== undefined && connection.isConnected;
-    }
-    /**
-     * Get all connected server names
-     * @returns Array of server names
-     */
-    getConnectedServers() {
-        return Array.from(this.connections.entries())
-            .filter(([, connection]) => connection.isConnected)
-            .map(([name]) => name);
-    }
-    /**
-     * Get the number of active connections
-     * @returns Number of connections
-     */
-    getConnectionCount() {
-        return this.getConnectedServers().length;
-    }
-}

package/dist/postprocessor/metamorphosis/MetamorphosisEngine.js

@@ -1,10 +0,0 @@
-/**
- * MetamorphosisEngine — Phase 0.5 skeleton
- *
- * Plug into PostProcessor lifecycle hooks to observe phases and proposals.
- * No-op when none configured. Concrete engines will be built in Phase 2.
- *
- * Integration: PostProcessor accepts optional MetamorphosisEngine[] in constructor.
- * Each engine receives onPhase/onProposal lifecycle notifications.
- */
-export {};

package/dist/testing/memory-regression-suite.d.ts

@@ -1,105 +0,0 @@
-import { EventEmitter } from "events";
-/**
- * Memory Regression Testing Suite
- * Automated testing for memory usage patterns and leak detection
- */
-export interface MemoryRegressionTest {
-    name: string;
-    description: string;
-    setup?: (() => Promise<void> | void) | undefined;
-    execute: () => Promise<any> | any;
-    cleanup?: (() => Promise<void> | void) | undefined;
-    expectedMemoryDelta: {
-        maxIncrease: number;
-        acceptableLeak: number;
-    };
-}
-export interface MemoryRegressionResult {
-    testName: string;
-    passed: boolean;
-    memoryDelta: number;
-    leakRate: number;
-    duration: number;
-    error?: string;
-    recommendations: string[];
-}
-export interface RegressionSuiteConfig {
-    testTimeout: number;
-    memorySamplingInterval: number;
-    acceptableMemoryGrowth: number;
-    leakDetectionThreshold: number;
-}
-export declare class MemoryRegressionTester extends EventEmitter {
-    private config;
-    private tests;
-    constructor(config?: Partial<RegressionSuiteConfig>);
-    /**
-     * Add a regression test
-     */
-    addTest(test: MemoryRegressionTest): void;
-    /**
-     * Run all regression tests
-     */
-    runAllTests(): Promise<MemoryRegressionResult[]>;
-    /**
-     * Run a single regression test
-     */
-    private runTest;
-    /**
-     * Create a standard memory regression test
-     */
-    createStandardTest(name: string, description: string, testFunction: () => Promise<any> | any, options?: {
-        maxMemoryIncrease?: number;
-        acceptableLeakRate?: number;
-        setup?: () => Promise<void> | void;
-        cleanup?: () => Promise<void> | void;
-    }): MemoryRegressionTest;
-    /**
-     * Generate test report
-     */
-    generateReport(results: MemoryRegressionResult[]): string;
-    /**
-     * Calculate variance of memory samples
-     */
-    private calculateVariance;
-}
-export declare const memoryTestTemplates: {
-    sessionOperations: (sessionCount?: number) => {
-        name: string;
-        description: string;
-        setup: () => Promise<void>;
-        execute: () => Promise<{
-            id: string;
-            data: {
-                userId: number;
-                metadata: {
-                    created: number;
-                    active: boolean;
-                };
-            };
-        }[]>;
-        cleanup: () => Promise<void>;
-        expectedMemoryDelta: {
-            maxIncrease: number;
-            acceptableLeak: number;
-        };
-    };
-    cacheOperations: (cacheSize?: number) => {
-        name: string;
-        description: string;
-        execute: () => Promise<number>;
-        expectedMemoryDelta: {
-            maxIncrease: number;
-            acceptableLeak: number;
-        };
-    };
-    streamingOperations: (messageCount?: number) => {
-        name: string;
-        description: string;
-        execute: () => Promise<number>;
-        expectedMemoryDelta: {
-            maxIncrease: number;
-            acceptableLeak: number;
-        };
-    };
-};