0xray 4.0.33 → 4.0.35

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;
-        };
-    };
-};

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

@@ -1,258 +0,0 @@
-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

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

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

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

@@ -1,59 +0,0 @@
-/**
- * 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/utils/batch-operations.d.ts

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