0xray 4.0.11 → 4.0.13

package/dist/utils/path-resolver.js

@@ -1,112 +0,0 @@
-/**
- * Path Resolution Utility for 0xRay Framework
- * Resolves import paths that work across development, build, and installed environments
- */
-import { fileURLToPath } from "url";
-import { dirname } from "path";
-import { frameworkLogger } from "../core/framework-logger.js";
-export class PathResolver {
-    static instance;
-    currentDir;
-    isDevelopment;
-    isBuilt;
-    isInstalled;
-    constructor() {
-        // Determine current execution context
-        this.currentDir = this.getCurrentDirectory();
-        this.isDevelopment = this.detectDevelopment();
-        this.isBuilt = this.detectBuilt();
-        this.isInstalled = this.detectInstalled();
-    }
-    static getInstance() {
-        if (!PathResolver.instance) {
-            PathResolver.instance = new PathResolver();
-        }
-        return PathResolver.instance;
-    }
-    /**
-     * Get current working directory
-     */
-    getCurrentDirectory() {
-        try {
-            // In ES modules, __dirname is not available, so we use import.meta.url
-            const currentFile = fileURLToPath(import.meta.url);
-            return dirname(currentFile);
-        }
-        catch (error) {
-            // Fallback for CommonJS or other environments
-            return process.cwd();
-        }
-    }
-    /**
-     * Detect if we're running in development environment (src/ directory)
-     */
-    detectDevelopment() {
-        return (this.currentDir.includes("/src/") ||
-            this.currentDir.includes("\\src\\") ||
-            process.env.NODE_ENV === "development");
-    }
-    /**
-     * Detect if we're running in built environment (dist/ directory)
-     */
-    detectBuilt() {
-        return (this.currentDir.includes("/dist/") ||
-            this.currentDir.includes("\\dist\\") ||
-            (this.currentDir.includes("xray") && !this.detectDevelopment()));
-    }
-    /**
-     * Detect if we're running in installed package environment
-     */
-    detectInstalled() {
-        return (this.currentDir.includes("/node_modules/") ||
-            this.currentDir.includes("\\node_modules\\") ||
-            (this.currentDir.includes("xray") && this.detectBuilt()));
-    }
-    /**
-     * Resolve agent import path for current environment
-     */
-    resolveAgentPath(agentName) {
-        if (this.isDevelopment) {
-            return `./agents/${agentName}.js`;
-        }
-        else if (this.isBuilt || this.isInstalled) {
-            return `../agents/${agentName}.js`;
-        }
-        else {
-            frameworkLogger.log("path-resolver", "unknown-environment-fallback", "warning", { agentName });
-            return `../agents/${agentName}.js`;
-        }
-    }
-    /**
-     * Resolve any module path for current environment
-     */
-    resolveModulePath(modulePath) {
-        const cleanPath = modulePath.startsWith("./")
-            ? modulePath.slice(2)
-            : modulePath;
-        if (this.isDevelopment) {
-            return `./${cleanPath}`;
-        }
-        else if (this.isBuilt || this.isInstalled) {
-            return `./${cleanPath}`;
-        }
-        else {
-            frameworkLogger.log("path-resolver", "unknown-module-environment", "warning", { modulePath });
-            return modulePath;
-        }
-    }
-    /**
-     * Get environment information for debugging
-     */
-    getEnvironmentInfo() {
-        return {
-            currentDir: this.currentDir,
-            isDevelopment: this.isDevelopment,
-            isBuilt: this.isBuilt,
-            isInstalled: this.isInstalled,
-            nodeEnv: process.env.NODE_ENV,
-        };
-    }
-}
-// Export singleton instance
-export const pathResolver = PathResolver.getInstance();

package/dist/utils/shutdown-handler.d.ts

@@ -1,26 +0,0 @@
-/**
- * Graceful Shutdown Handler
- *
- * Centralized shutdown handling for MCP servers.
- * Extracts common shutdown patterns to reduce code duplication.
- *
- * @since 2026-03-22
- */
-export interface ShutdownOptions {
-    serverName: string;
-    server: {
-        close: () => Promise<void>;
-    } | null;
-    shutdownTimeout?: number;
-}
-export interface ShutdownHandler {
-    cleanup: (signal: string) => Promise<void>;
-    stop: () => void;
-}
-/**
- * Creates a graceful shutdown handler for MCP servers
- *
- * @param options - Configuration for the shutdown handler
- * @returns ShutdownHandler with cleanup and stop methods
- */
-export declare function createGracefulShutdown(options: ShutdownOptions): ShutdownHandler;

package/dist/utils/shutdown-handler.js

@@ -1,74 +0,0 @@
-/**
- * Graceful Shutdown Handler
- *
- * Centralized shutdown handling for MCP servers.
- * Extracts common shutdown patterns to reduce code duplication.
- *
- * @since 2026-03-22
- */
-import { frameworkLogger } from "../core/framework-logger.js";
-/**
- * Creates a graceful shutdown handler for MCP servers
- *
- * @param options - Configuration for the shutdown handler
- * @returns ShutdownHandler with cleanup and stop methods
- */
-export function createGracefulShutdown(options) {
-    const { serverName, server, shutdownTimeout = 5000 } = options;
-    let isShuttingDown = false;
-    const cleanup = async (signal) => {
-        if (isShuttingDown)
-            return;
-        isShuttingDown = true;
-        await frameworkLogger.log(serverName, "shutdown-initiated", "info", { signal });
-        // Force exit after timeout
-        const timeout = setTimeout(() => {
-            frameworkLogger.log(serverName, "shutdown-timeout", "error", { message: "Graceful shutdown timeout, forcing exit..." });
-            process.exit(1);
-        }, shutdownTimeout);
-        try {
-            if (server && typeof server.close === "function") {
-                await server.close();
-            }
-            clearTimeout(timeout);
-            await frameworkLogger.log(serverName, "shutdown-complete", "info", { message: `${serverName} shut down gracefully` });
-            process.exit(0);
-        }
-        catch (error) {
-            clearTimeout(timeout);
-            frameworkLogger.log(serverName, "shutdown-error", "error", { message: `Error during ${serverName} shutdown: ${error instanceof Error ? error.message : String(error)}` });
-            process.exit(1);
-        }
-    };
-    const stop = () => {
-        cleanup("manual-stop");
-    };
-    // Register signal handlers
-    process.on("SIGINT", () => cleanup("SIGINT"));
-    process.on("SIGTERM", () => cleanup("SIGTERM"));
-    process.on("SIGHUP", () => cleanup("SIGHUP"));
-    // Handle uncaught exceptions
-    process.on("uncaughtException", (error) => {
-        frameworkLogger.log(serverName, "uncaught-exception", "error", { message: `Uncaught Exception: ${error instanceof Error ? error.message : String(error)}` });
-        cleanup("uncaughtException");
-    });
-    // Handle unhandled rejections
-    process.on("unhandledRejection", (reason, promise) => {
-        frameworkLogger.log(serverName, "unhandled-rejection", "error", { message: `Unhandled Rejection at: ${String(promise)} reason: ${String(reason)}` });
-        cleanup("unhandledRejection");
-    });
-    // Monitor parent process (opencode) and shutdown if it dies
-    const checkParent = async () => {
-        try {
-            process.kill(process.ppid, 0);
-            setTimeout(checkParent, 1000);
-        }
-        catch {
-            await frameworkLogger.log(serverName, "parent-process-died", "info", { message: "Parent process (opencode) died, shutting down..." });
-            cleanup("parent-process-death");
-        }
-    };
-    // Start parent monitoring after 2 seconds
-    setTimeout(checkParent, 2000);
-    return { cleanup, stop };
-}

package/dist/utils/task-graph.d.ts

@@ -1,29 +0,0 @@
-/**
- * Task graph utilities — pure functions for dependency resolution,
- * topological sorting, and conflict resolution.
- *
- * Extracted from KernelOrchestrator for neutral access.
- */
-import type { TaskDefinition } from "../agents/types.js";
-/**
- * DFS-based topological sort with circular dependency detection.
- */
-export declare function topologicalSort(tasks: TaskDefinition[]): TaskDefinition[];
-/**
- * Validates that all task dependencies are within the current task batch.
- * Throws a descriptive error listing cross-orchestrator dependencies.
- */
-export declare function validateTaskDependencies(tasks: TaskDefinition[]): void;
-export interface ConflictInput {
-    response?: unknown;
-    proposed?: unknown;
-    expertiseScore?: number;
-}
-export interface ConflictResult {
-    response: string;
-    expertiseScore: number;
-}
-/**
- * Resolve conflicts by majority vote or highest expertise score.
- */
-export declare function resolveConflicts(conflicts: ConflictInput[], strategy?: "majority_vote" | "expert_priority"): ConflictResult;

package/dist/utils/task-graph.js

@@ -1,106 +0,0 @@
-/**
- * Task graph utilities — pure functions for dependency resolution,
- * topological sorting, and conflict resolution.
- *
- * Extracted from KernelOrchestrator for neutral access.
- */
-/**
- * DFS-based topological sort with circular dependency detection.
- */
-export function topologicalSort(tasks) {
-    const visited = new Set();
-    const visiting = new Set();
-    const result = [];
-    const visit = (taskId) => {
-        if (visiting.has(taskId)) {
-            throw new Error(`Circular dependency detected: ${taskId}`);
-        }
-        if (visited.has(taskId)) {
-            return;
-        }
-        visiting.add(taskId);
-        const task = tasks.find((t) => t.id === taskId);
-        if (task && task.dependencies) {
-            for (const dep of task.dependencies) {
-                visit(dep);
-            }
-        }
-        visiting.delete(taskId);
-        visited.add(taskId);
-        if (task) {
-            result.push(task);
-        }
-    };
-    for (const task of tasks) {
-        if (!visited.has(task.id)) {
-            visit(task.id);
-        }
-    }
-    return result;
-}
-/**
- * Validates that all task dependencies are within the current task batch.
- * Throws a descriptive error listing cross-orchestrator dependencies.
- */
-export function validateTaskDependencies(tasks) {
-    const taskIds = new Set(tasks.map((t) => t.id));
-    const errors = [];
-    for (const task of tasks) {
-        if (task.dependencies && task.dependencies.length > 0) {
-            for (const dep of task.dependencies) {
-                if (!taskIds.has(dep)) {
-                    errors.push(`Task "${task.id}" depends on "${dep}" which is NOT in this orchestrator's task batch.\n` +
-                        `Available tasks in this batch: ${Array.from(taskIds).join(", ")}`);
-                }
-            }
-        }
-    }
-    if (errors.length > 0) {
-        const errorMessage = `[TEST ARCHITECTURE ERROR] Cross-orchestrator dependencies detected.\n\n` +
-            `${errors.join("\n\n")}\n\n` +
-            `This usually means:\n` +
-            `1. You're creating multiple orchestrator instances in one test\n` +
-            `2. Task dependencies are crossing orchestrator boundaries\n\n` +
-            `FIX: Either:\n` +
-            `A) Include the missing dependency task in this executeComplexTask() call\n` +
-            `B) Use a single orchestrator for all dependent tasks\n` +
-            `C) Remove the dependency if it's not needed\n\n` +
-            `Example of correct usage:\n` +
-            `  const orch = new XrayOrchestrator();\n` +
-            `  await orch.executeComplexTask("test", [\n` +
-            `    { id: "task-1" },\n` +
-            `    { id: "task-2", dependencies: ["task-1"] }  // Same orchestrator\n` +
-            `  ]);`;
-        throw new Error(errorMessage);
-    }
-}
-/**
- * Resolve conflicts by majority vote or highest expertise score.
- */
-export function resolveConflicts(conflicts, strategy) {
-    if (conflicts.length === 0) {
-        return { response: "", expertiseScore: 0 };
-    }
-    if (strategy === "majority_vote") {
-        const votes = {};
-        conflicts.forEach((conflict) => {
-            const response = String(conflict.response ?? conflict.proposed ?? "");
-            votes[response] = (votes[response] || 0) + 1;
-        });
-        const maxVotes = Math.max(...Object.values(votes));
-        const winner = Object.entries(votes).find(([_, voteCount]) => voteCount === maxVotes);
-        if (winner) {
-            const winningConflicts = conflicts.filter((c) => String(c.response ?? c.proposed ?? "") === winner[0]);
-            const avgExpertise = winningConflicts.reduce((sum, c) => sum + (c.expertiseScore || 0), 0) / winningConflicts.length;
-            return { response: winner[0], expertiseScore: avgExpertise };
-        }
-    }
-    // Fallback to highest expertise score
-    const bestConflict = conflicts.reduce((best, current) => (current.expertiseScore || 0) > (best.expertiseScore || 0)
-        ? current
-        : best);
-    return {
-        response: String(bestConflict.response ?? bestConflict.proposed ?? ""),
-        expertiseScore: bestConflict.expertiseScore || 0,
-    };
-}

package/dist/utils/test-template-generator.d.ts

@@ -1,25 +0,0 @@
-/**
- * Test Template Generator for 0xRay Framework
- *
- * Automatically generates test templates for different file types
- * to ensure consistent test coverage and structure.
- */
-export interface TestTemplateOptions {
-    filePath: string;
-    componentName?: string;
-    exports?: string[];
-    isReact?: boolean;
-    isTypeScript?: boolean;
-}
-/**
- * Generate a test template based on file type and structure
- */
-export declare function generateTestTemplate(options: TestTemplateOptions): string;
-/**
- * Analyze a source file to extract exports for test generation
- */
-export declare function analyzeSourceFile(filePath: string): {
-    exports: string[];
-    isReact: boolean;
-    isTypeScript: boolean;
-};

package/dist/utils/test-template-generator.js

@@ -1,178 +0,0 @@
-/**
- * Test Template Generator for 0xRay Framework
- *
- * Automatically generates test templates for different file types
- * to ensure consistent test coverage and structure.
- */
-import { frameworkLogger } from "../core/framework-logger.js";
-import fs from "fs";
-/**
- * Generate a test template based on file type and structure
- */
-export function generateTestTemplate(options) {
-    const { filePath, componentName, exports = [], isReact = false, isTypeScript = false, } = options;
-    const fileName = filePath
-        .split("/")
-        .pop()
-        ?.replace(/\.(ts|tsx|js|jsx)$/, "") || "Unknown";
-    const testFileName = `${fileName}.test.${isTypeScript ? "ts" : "js"}${isReact ? "x" : ""}`;
-    if (isReact) {
-        return generateReactTestTemplate(fileName, componentName || fileName, isTypeScript);
-    }
-    return generateUnitTestTemplate(fileName, exports, isTypeScript);
-}
-/**
- * Generate React component test template
- */
-function generateReactTestTemplate(fileName, componentName, isTypeScript) {
-    const typeAnnotation = isTypeScript ? ": RenderResult" : "";
-    const typeImport = isTypeScript ? ", RenderResult" : "";
-    return `import { render, screen } from '@testing-library/react';
-import { expect, describe, it${typeImport} } from '${isTypeScript ? "vitest" : "jest"}';
-import { ${componentName} } from './${fileName}';
-
-describe('${componentName}', () => {
-  it('should render successfully', () => {
-    const { container }${typeAnnotation} = render(<${componentName} />);
-    expect(container).toBeInTheDocument();
-  });
-
-  it('should render with default props', () => {
-    render(<${componentName} />);
-    // Add specific assertions based on component behavior
-    expect(screen.getByRole('generic')).toBeInTheDocument();
-  });
-
-  // Add more test cases based on component props and behavior
-  // it('should handle prop changes', () => {
-  //   const { rerender } = render(<${componentName} prop="value" />);
-  //   expect(screen.getByText('value')).toBeInTheDocument();
-  //
-  //   rerender(<${componentName} prop="newValue" />);
-  //   expect(screen.getByText('newValue')).toBeInTheDocument();
-  // });
-
-  // Add accessibility tests
-  it('should be accessible', () => {
-    const { container } = render(<${componentName} />);
-    expect(container).toBeAccessible();
-  });
-});
-`;
-}
-/**
- * Generate unit test template for utility functions/classes
- */
-function generateUnitTestTemplate(fileName, exports, isTypeScript) {
-    const describeBlocks = exports
-        .map((exportName) => {
-        if (exportName.match(/^[A-Z]/)) {
-            // Class export
-            return generateClassTestTemplate(exportName);
-        }
-        else {
-            // Function export
-            return generateFunctionTestTemplate(exportName);
-        }
-    })
-        .join("\n\n");
-    return `import { expect, describe, it } from '${isTypeScript ? "vitest" : "jest"}';
-${exports.length > 0 ? `import { ${exports.join(", ")} } from './${fileName}';` : `// import functions from './${fileName}'`}
-
-${describeBlocks}
-
-describe('${fileName}', () => {
-  // Add general module tests here
-  it('should export expected functions', () => {
-    ${exports.length > 0 ? exports.map((exp) => `expect(typeof ${exp}).toBe('function');`).join("\n    ") : "// Add export tests"}
-  });
-});
-`;
-}
-/**
- * Generate test template for a class
- */
-function generateClassTestTemplate(className) {
-    return `describe('${className}', () => {
-  let instance: ${className};
-
-  beforeEach(() => {
-    // instance = new ${className}();
-  });
-
-  it('should create instance successfully', () => {
-    // expect(instance).toBeInstanceOf(${className});
-    expect(true).toBe(true); // Placeholder test
-  });
-
-  // Add method tests
-  // it('should have expected methods', () => {
-  //   expect(typeof instance.methodName).toBe('function');
-  // });
-
-  // Add property tests
-  // it('should have expected properties', () => {
-  //   expect(instance.propertyName).toBeDefined();
-  // });
-});`;
-}
-/**
- * Generate test template for a function
- */
-function generateFunctionTestTemplate(functionName) {
-    return `describe('${functionName}', () => {
-  it('should be a function', () => {
-    expect(typeof ${functionName}).toBe('function');
-  });
-
-  it('should handle basic input', () => {
-    // const result = ${functionName}(/* test input */);
-    // expect(result).toBe(/* expected output */);
-    expect(true).toBe(true); // Placeholder test
-  });
-
-  it('should handle edge cases', () => {
-    // Test null, undefined, empty inputs
-    // expect(() => ${functionName}(null)).toThrow();
-    expect(true).toBe(true); // Placeholder test
-  });
-
-  // Add more specific test cases based on function behavior
-});`;
-}
-/**
- * Analyze a source file to extract exports for test generation
- */
-export function analyzeSourceFile(filePath) {
-    try {
-        const content = fs.readFileSync(filePath, "utf-8");
-        const exports = [];
-        const isReact = /\b(React|jsx?|tsx?)\b/.test(content) ||
-            filePath.endsWith(".tsx") ||
-            filePath.endsWith(".jsx");
-        const isTypeScript = filePath.endsWith(".ts") || filePath.endsWith(".tsx");
-        // Extract named exports
-        const exportMatches = content.match(/export\s+(?:const|function|class|let|var)\s+(\w+)/g);
-        if (exportMatches) {
-            exportMatches.forEach((match) => {
-                const nameMatch = match.match(/(?:const|function|class|let|var)\s+(\w+)/);
-                if (nameMatch && nameMatch[1] && !exports.includes(nameMatch[1])) {
-                    exports.push(nameMatch[1]);
-                }
-            });
-        }
-        // Extract default export if no named exports found
-        if (exports.length === 0 && /export\s+default/.test(content)) {
-            const fileName = filePath
-                .split("/")
-                .pop()
-                ?.replace(/\.(ts|tsx|js|jsx)$/, "") || "Component";
-            exports.push(fileName.charAt(0).toUpperCase() + fileName.slice(1));
-        }
-        return { exports, isReact, isTypeScript };
-    }
-    catch (error) {
-        frameworkLogger.log("test-template-generator", "analyze-file", "error", { error, message: `Error analyzing ${filePath}:` });
-        return { exports: [], isReact: false, isTypeScript: false };
-    }
-}

package/dist/utils/token-manager.d.ts

@@ -1,48 +0,0 @@
-export interface TokenLimits {
-    maxPromptTokens: number;
-    warningThreshold: number;
-    modelLimits: Record<string, number>;
-}
-export interface ContextPruningConfig {
-    enabled: boolean;
-    aggressivePruning: boolean;
-    preserveCriticalContext: boolean;
-}
-export declare class TokenManager {
-    private config;
-    constructor(configPath?: string);
-    private loadConfig;
-    /**
-     * Estimate token count for text (rough approximation)
-     * Uses 4 characters per token as a conservative estimate
-     */
-    estimateTokens(text: string): number;
-    /**
-     * Check if prompt exceeds limits
-     */
-    checkLimits(prompt: string, modelName?: string): {
-        withinLimit: boolean;
-        currentTokens: number;
-        maxTokens: number;
-        needsPruning: boolean;
-        warning: boolean;
-    };
-    /**
-     * Prune context to fit within token limits
-     */
-    pruneContext(context: string, targetTokens?: number): string;
-    private extractCriticalSections;
-    private extractSection;
-    private extractNonCriticalContent;
-    private pruneNonCriticalContent;
-    /**
-     * Generate warning message for token limits
-     */
-    generateWarning(limitCheck: ReturnType<TokenManager["checkLimits"]>): string;
-    /**
-     * Get current configuration
-     */
-    getConfig(): TokenLimits & {
-        contextPruning: ContextPruningConfig;
-    };
-}