0xray 4.0.13 → 4.0.14

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

@@ -0,0 +1,105 @@
+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;
+        };
+    };
+};

package/dist/testing/memory-regression-suite.js

@@ -0,0 +1,258 @@
+import { EventEmitter } from "events";
+export class MemoryRegressionTester extends EventEmitter {
+    config;
+    tests = [];
+    constructor(config = {}) {
+        super();
+        this.config = {
+            testTimeout: 30000, // 30 seconds
+            memorySamplingInterval: 1000, // 1 second
+            acceptableMemoryGrowth: 10, // 10MB
+            leakDetectionThreshold: 1, // 1MB per minute
+            ...config,
+        };
+    }
+    /**
+     * Add a regression test
+     */
+    addTest(test) {
+        this.tests.push(test);
+    }
+    /**
+     * Run all regression tests
+     */
+    async runAllTests() {
+        const results = [];
+        for (const test of this.tests) {
+            try {
+                const result = await this.runTest(test);
+                results.push(result);
+            }
+            catch (error) {
+                results.push({
+                    testName: test.name,
+                    passed: false,
+                    memoryDelta: 0,
+                    leakRate: 0,
+                    duration: 0,
+                    error: error instanceof Error ? error.message : String(error),
+                    recommendations: [
+                        "Check test implementation",
+                        "Verify memory cleanup",
+                    ],
+                });
+            }
+        }
+        return results;
+    }
+    /**
+     * Run a single regression test
+     */
+    async runTest(test) {
+        const startTime = Date.now();
+        try {
+            // Setup
+            if (test.setup) {
+                await Promise.resolve(test.setup());
+            }
+            // Memory sampling during test
+            const samples = [];
+            const samplingInterval = setInterval(() => {
+                const memUsage = process.memoryUsage();
+                samples.push(memUsage.heapUsed);
+            }, this.config.memorySamplingInterval);
+            // Execute test with timeout
+            const testPromise = test.execute();
+            const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error("Test timeout")), this.config.testTimeout));
+            await Promise.race([testPromise, timeoutPromise]);
+            clearInterval(samplingInterval);
+            // Calculate results
+            const endTime = Date.now();
+            const duration = endTime - startTime;
+            if (samples.length === 0) {
+                throw new Error("No memory samples collected");
+            }
+            const startMemory = samples[0];
+            const endMemory = samples[samples.length - 1];
+            const memoryDelta = (endMemory - startMemory) / 1024 / 1024; // MB
+            // Calculate leak rate (MB per minute)
+            const leakRate = duration > 0 ? memoryDelta / (duration / 1000 / 60) : 0;
+            // Determine pass/fail
+            const passed = Math.abs(memoryDelta) <= test.expectedMemoryDelta.maxIncrease &&
+                Math.abs(leakRate) <= test.expectedMemoryDelta.acceptableLeak;
+            // Generate recommendations
+            const recommendations = [];
+            if (memoryDelta > test.expectedMemoryDelta.maxIncrease) {
+                recommendations.push(`Memory increased by ${memoryDelta.toFixed(2)}MB (expected ≤${test.expectedMemoryDelta.maxIncrease}MB)`);
+            }
+            if (leakRate > test.expectedMemoryDelta.acceptableLeak) {
+                recommendations.push(`Memory leak rate: ${leakRate.toFixed(2)}MB/min (expected ≤${test.expectedMemoryDelta.acceptableLeak}MB/min)`);
+            }
+            if (samples.length > 10) {
+                const variance = this.calculateVariance(samples);
+                if (variance > 5 * 1024 * 1024) {
+                    // 5MB variance
+                    recommendations.push("High memory variance detected - consider stabilizing allocations");
+                }
+            }
+            // Cleanup
+            if (test.cleanup) {
+                await Promise.resolve(test.cleanup());
+            }
+            return {
+                testName: test.name,
+                passed,
+                memoryDelta,
+                leakRate,
+                duration,
+                recommendations,
+            };
+        }
+        catch (error) {
+            // Cleanup on error
+            if (test.cleanup) {
+                try {
+                    await test.cleanup();
+                }
+                catch (cleanupError) {
+                    // Ignore cleanup errors
+                }
+            }
+            throw error;
+        }
+    }
+    /**
+     * Create a standard memory regression test
+     */
+    createStandardTest(name, description, testFunction, options = {}) {
+        return {
+            name,
+            description,
+            setup: options.setup,
+            execute: testFunction,
+            cleanup: options.cleanup,
+            expectedMemoryDelta: {
+                maxIncrease: options.maxMemoryIncrease || this.config.acceptableMemoryGrowth,
+                acceptableLeak: options.acceptableLeakRate || this.config.leakDetectionThreshold,
+            },
+        };
+    }
+    /**
+     * Generate test report
+     */
+    generateReport(results) {
+        const passed = results.filter((r) => r.passed).length;
+        const failed = results.length - passed;
+        let report = `# Memory Regression Test Report\n\n`;
+        report += `**Summary:** ${passed}/${results.length} tests passed (${failed} failed)\n\n`;
+        if (failed > 0) {
+            report += `## Failed Tests\n\n`;
+            results
+                .filter((r) => !r.passed)
+                .forEach((result) => {
+                report += `### ${result.testName}\n`;
+                report += `- Memory Delta: ${result.memoryDelta.toFixed(2)}MB\n`;
+                report += `- Leak Rate: ${result.leakRate.toFixed(2)}MB/min\n`;
+                report += `- Duration: ${result.duration}ms\n`;
+                if (result.error) {
+                    report += `- Error: ${result.error}\n`;
+                }
+                if (result.recommendations.length > 0) {
+                    report += `- Recommendations:\n`;
+                    result.recommendations.forEach((rec) => {
+                        report += `  - ${rec}\n`;
+                    });
+                }
+                report += `\n`;
+            });
+        }
+        report += `## Performance Metrics\n\n`;
+        const avgDelta = results.reduce((sum, r) => sum + r.memoryDelta, 0) / results.length;
+        const avgLeakRate = results.reduce((sum, r) => sum + r.leakRate, 0) / results.length;
+        const totalDuration = results.reduce((sum, r) => sum + r.duration, 0);
+        report += `- Average Memory Delta: ${avgDelta.toFixed(2)}MB\n`;
+        report += `- Average Leak Rate: ${avgLeakRate.toFixed(2)}MB/min\n`;
+        report += `- Total Test Duration: ${totalDuration}ms\n`;
+        return report;
+    }
+    /**
+     * Calculate variance of memory samples
+     */
+    calculateVariance(samples) {
+        const mean = samples.reduce((sum, s) => sum + s, 0) / samples.length;
+        const variance = samples.reduce((sum, s) => sum + Math.pow(s - mean, 2), 0) /
+            samples.length;
+        return variance;
+    }
+}
+// Pre-configured test templates
+export const memoryTestTemplates = {
+    sessionOperations: (sessionCount = 100) => ({
+        name: "Session Operations Memory Test",
+        description: `Test memory usage during ${sessionCount} session operations`,
+        setup: async () => {
+            // Setup would initialize session manager
+        },
+        execute: async () => {
+            // Simulate session operations
+            const operations = [];
+            for (let i = 0; i < sessionCount; i++) {
+                operations.push({
+                    id: `session-${i}`,
+                    data: { userId: i, metadata: { created: Date.now(), active: true } },
+                });
+            }
+            return operations;
+        },
+        cleanup: async () => {
+            // Cleanup sessions
+        },
+        expectedMemoryDelta: {
+            maxIncrease: sessionCount * 0.01, // ~10KB per session
+            acceptableLeak: 0.1, // 0.1MB per minute
+        },
+    }),
+    cacheOperations: (cacheSize = 1000) => ({
+        name: "Cache Operations Memory Test",
+        description: `Test memory usage during ${cacheSize} cache operations`,
+        execute: async () => {
+            const cache = new Map();
+            for (let i = 0; i < cacheSize; i++) {
+                cache.set(`key-${i}`, {
+                    data: `value-${i}`.repeat(10), // ~100 bytes per entry
+                    timestamp: Date.now(),
+                });
+            }
+            // Simulate cache operations
+            for (let i = 0; i < cacheSize / 2; i++) {
+                cache.get(`key-${i}`);
+            }
+            return cache.size;
+        },
+        expectedMemoryDelta: {
+            maxIncrease: (cacheSize * 0.1) / 1024 / 1024, // ~100KB total
+            acceptableLeak: 0.05, // 0.05MB per minute
+        },
+    }),
+    streamingOperations: (messageCount = 1000) => ({
+        name: "Streaming Operations Memory Test",
+        description: `Test memory usage during ${messageCount} streaming operations`,
+        execute: async () => {
+            const messages = [];
+            for (let i = 0; i < messageCount; i++) {
+                messages.push({
+                    id: i,
+                    payload: Buffer.from(`message-${i}-`.repeat(50)), // ~500 bytes per message
+                    timestamp: Date.now(),
+                });
+                // Simulate processing delay
+                await new Promise((resolve) => setTimeout(resolve, 1));
+            }
+            return messages.length;
+        },
+        expectedMemoryDelta: {
+            maxIncrease: (messageCount * 0.5) / 1024 / 1024, // ~500KB total
+            acceptableLeak: 0.2, // 0.2MB per minute
+        },
+    }),
+};

package/dist/tools/assess-complexity-tool.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Assess Complexity Tool
+ *
+ * Wraps ComplexityAnalyzer so the main AI can query task complexity
+ * and decide whether to delegate to subagents.
+ *
+ * Exposes:
+ *  - assessComplexity() — full analysis returning score, level, strategy, agents
+ *  - simple assess() helper for quick threshold checks
+ */
+export interface AssessmentInput {
+    taskDescription: string;
+    files?: string[];
+    dependencies?: string[];
+    changeVolume?: number;
+    riskLevel?: "low" | "medium" | "high" | "critical";
+    estimatedDuration?: number;
+}
+export interface AssessmentResult {
+    score: number;
+    level: "simple" | "moderate" | "complex" | "enterprise";
+    strategy: "single-agent" | "multi-agent" | "orchestrator-led";
+    estimatedAgents: number;
+    reasoning: string[];
+}
+export declare function assessComplexity(input: AssessmentInput): AssessmentResult;
+export declare function shouldDelegate(input: AssessmentInput): boolean;
+export declare function getDelegationStrategy(input: AssessmentInput): AssessmentResult;

package/dist/tools/assess-complexity-tool.js

@@ -0,0 +1,44 @@
+/**
+ * Assess Complexity Tool
+ *
+ * Wraps ComplexityAnalyzer so the main AI can query task complexity
+ * and decide whether to delegate to subagents.
+ *
+ * Exposes:
+ *  - assessComplexity() — full analysis returning score, level, strategy, agents
+ *  - simple assess() helper for quick threshold checks
+ */
+import { getComplexityAnalyzer, } from "../delegation/complexity-analyzer.js";
+import { frameworkLogger } from "../core/framework-logger.js";
+const analyzer = getComplexityAnalyzer();
+export function assessComplexity(input) {
+    const metrics = analyzer.analyzeComplexity(input.taskDescription, {
+        files: input.files ?? [],
+        dependencies: input.dependencies ?? [],
+        changeVolume: input.changeVolume ?? 0,
+        riskLevel: input.riskLevel ?? "low",
+        estimatedDuration: input.estimatedDuration ?? 30,
+    });
+    const score = analyzer.calculateComplexityScore(metrics);
+    frameworkLogger.log("assess-complexity-tool", "assessment-complete", "info", {
+        taskDescription: input.taskDescription.substring(0, 80),
+        score: score.score,
+        level: score.level,
+        strategy: score.recommendedStrategy,
+        estimatedAgents: score.estimatedAgents,
+    });
+    return {
+        score: score.score,
+        level: score.level,
+        strategy: score.recommendedStrategy,
+        estimatedAgents: score.estimatedAgents,
+        reasoning: score.reasoning,
+    };
+}
+export function shouldDelegate(input) {
+    const result = assessComplexity(input);
+    return result.score > 15;
+}
+export function getDelegationStrategy(input) {
+    return assessComplexity(input);
+}

package/dist/tools/query-routing-tool.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Query Routing Tool
+ *
+ * Lets the main AI discover which agent/skill best matches a task.
+ * Combines ROUTING_MAPPINGS keyword lookup with AGENT_REGISTRY metadata.
+ */
+export interface AgentRoutingDetail {
+    agent: string;
+    skill: string;
+    confidence: number;
+    matchedKeywords: string[];
+    description: string | undefined;
+    capabilities: string[];
+    expertise: string | undefined;
+}
+export declare function queryRouting(keywords: string[]): AgentRoutingDetail[];
+export declare function listAllRoutes(): AgentRoutingDetail[];

package/dist/tools/query-routing-tool.js

@@ -0,0 +1,59 @@
+/**
+ * Query Routing Tool
+ *
+ * Lets the main AI discover which agent/skill best matches a task.
+ * Combines ROUTING_MAPPINGS keyword lookup with AGENT_REGISTRY metadata.
+ */
+import { queryRoutingMappings, getAllRoutingMappings, } from "../config/routing-mappings.js";
+import { getAgentEntry, getAgentCapabilities, } from "../agents/registry.js";
+import { frameworkLogger } from "../core/framework-logger.js";
+export function queryRouting(keywords) {
+    const matches = queryRoutingMappings(keywords);
+    const enriched = matches.map((m) => {
+        const entry = getAgentEntry(m.agent);
+        return {
+            agent: m.agent,
+            skill: m.skill,
+            confidence: m.confidence,
+            matchedKeywords: m.matchedKeywords,
+            description: entry?.description,
+            capabilities: entry
+                ? entry.capabilities
+                : getAgentCapabilities(m.agent),
+            expertise: entry?.expertise,
+        };
+    });
+    frameworkLogger.log("query-routing-tool", "query-complete", "info", {
+        keywords,
+        matchCount: enriched.length,
+        topMatch: enriched[0]
+            ? { agent: enriched[0].agent, confidence: enriched[0].confidence }
+            : null,
+    });
+    return enriched;
+}
+export function listAllRoutes() {
+    const all = getAllRoutingMappings();
+    const seen = new Set();
+    const unique = [];
+    for (const mapping of all) {
+        const key = `${mapping.agent}:${mapping.skill}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        const entry = getAgentEntry(mapping.agent);
+        unique.push({
+            agent: mapping.agent,
+            skill: mapping.skill,
+            confidence: mapping.confidence,
+            matchedKeywords: mapping.keywords,
+            description: entry?.description,
+            capabilities: entry
+                ? entry.capabilities
+                : getAgentCapabilities(mapping.agent),
+            expertise: entry?.expertise,
+        });
+    }
+    unique.sort((a, b) => b.confidence - a.confidence);
+    return unique;
+}

package/dist/types/metamorphosis.d.ts

@@ -0,0 +1,21 @@
+/**
+ * MetamorphosisEngine interface — lifecycle hooks for self-evolution proposals.
+ *
+ * Extracted from postprocessor/metamorphosis/ for neutral access by kernel.
+ */
+export interface MetamorphosisProposal {
+    id: string;
+    type: 'add' | 'modify' | 'remove';
+    target: string;
+    description: string;
+    rationale: string;
+    impact: 'low' | 'medium' | 'high';
+}
+export interface MetamorphosisEngine {
+    /** Human-readable engine name (for logging) */
+    name: string;
+    /** Called when PostProcessor enters a phase */
+    onPhase?(phase: string, context: unknown): Promise<void>;
+    /** Called when a metamorphosis proposal is generated */
+    onProposal?(proposal: MetamorphosisProposal): Promise<void>;
+}

package/dist/types/metamorphosis.js

@@ -0,0 +1,6 @@
+/**
+ * MetamorphosisEngine interface — lifecycle hooks for self-evolution proposals.
+ *
+ * Extracted from postprocessor/metamorphosis/ for neutral access by kernel.
+ */
+export {};

package/dist/utils/batch-operations.d.ts

@@ -0,0 +1,25 @@
+export interface ReplacementOperation {
+    pattern: string;
+    replacement: string;
+    isRegex?: boolean;
+    caseSensitive?: boolean;
+}
+export interface BatchResult {
+    success: boolean;
+    filesModified: number;
+    errors: Array<{
+        file: string;
+        error: string;
+    }>;
+    duration: number;
+}
+export interface FileOperation {
+    filePath: string;
+    operation: "replace" | "append" | "prepend" | "delete";
+    content?: string;
+    pattern?: string;
+}
+export declare function batchReplace(files: string[], operations: ReplacementOperation[]): Promise<BatchResult>;
+export declare function batchFileOperations(operations: FileOperation[]): Promise<BatchResult>;
+export declare function findFilesWithPattern(directory: string, pattern: string, extensions?: string[]): string[];
+export declare function bulkRename(directory: string, oldName: string, newName: string, extensions?: string[]): Promise<BatchResult>;