0xray 2.0.0 → 2.0.1

package/dist/utils/codex-parser.d.ts

@@ -0,0 +1,61 @@
+/**
+ * 0xRay Codex Parser Utility
+ *
+ * Unified parsing utility for codex content in both JSON and Markdown formats.
+ * Provides consistent parsing across all components with format detection and validation.
+ *
+ * @version 1.0.1
+ * @since 2026-01-07
+ */
+import { CodexContext } from "../core/context-loader.js";
+/**
+ * Content format detection result
+ */
+export interface FormatDetectionResult {
+    format: "json" | "markdown" | "unknown";
+    confidence: number;
+}
+/**
+ * Parsing result
+ */
+export interface ParsingResult {
+    success: boolean;
+    context?: CodexContext;
+    error?: string;
+    warnings: string[];
+}
+/**
+ * Detect content format
+ */
+export declare function detectContentFormat(content: string): FormatDetectionResult;
+/**
+ * Unified codex content parser
+ */
+export declare function parseCodexContent(content: string, sourcePath?: string): ParsingResult;
+/**
+ * Extract codex metadata from content (for compatibility with existing code)
+ */
+export declare function extractCodexMetadata(content: string): {
+    version: string;
+    termCount: number;
+};
+/**
+ * Pre-modification validation result
+ */
+export interface ValidationResult {
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+}
+/**
+ * Validate TypeScript code syntax
+ */
+export declare function validateTypeScriptSyntax(code: string, filePath?: string): Promise<ValidationResult>;
+/**
+ * Validate JSON syntax
+ */
+export declare function validateJsonSyntax(jsonString: string): ValidationResult;
+/**
+ * Comprehensive pre-modification validation
+ */
+export declare function validateBeforeModification(content: string, filePath: string): Promise<ValidationResult>;

package/dist/utils/command-runner.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Simple command runner utility for executing shell commands
+ */
+export interface CommandResult {
+    success: boolean;
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+}
+export interface CommandOptions {
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    timeout?: number;
+    silent?: boolean;
+}
+/**
+ * Run a shell command and return the result
+ */
+export declare function runCommand(command: string, options?: CommandOptions): Promise<CommandResult>;
+/**
+ * Run a command and throw on failure
+ */
+export declare function runCommandStrict(command: string, options?: CommandOptions): Promise<string>;
+/**
+ * Run a command safely using spawn with an args array (no shell interpretation).
+ * This prevents command injection when args may contain user-controlled input.
+ */
+export declare function runCommandSafe(command: string, args: string[], options?: CommandOptions): Promise<CommandResult>;
+/**
+ * Run a safe command and throw on failure
+ */
+export declare function runCommandSafeStrict(command: string, args: string[], options?: CommandOptions): Promise<string>;

package/dist/utils/import-resolver.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Import Resolver Utility
+ * Dynamically resolves module imports across different environments
+ *
+ * This solves the systemic path resolution issue where hardcoded paths
+ * break between development, built, and deployed environments.
+ */
+export declare class ImportResolver {
+    private static instance;
+    private currentDir;
+    private projectRoot;
+    private isDevelopment;
+    private isBuilt;
+    private isInstalled;
+    private isTesting;
+    private constructor();
+    static getInstance(): ImportResolver;
+    private getCurrentDirectory;
+    private findProjectRoot;
+    private fileExists;
+    private detectDevelopment;
+    private detectBuilt;
+    private detectInstalled;
+    private detectTesting;
+    /**
+     * Resolve module import path for any module
+     */
+    resolveModulePath(moduleName: string, subPath?: string): string;
+    /**
+     * Resolve agent import path (special case for agents)
+     */
+    resolveAgentPath(agentName: string): string;
+    /**
+     * Dynamic import with comprehensive environment resolution
+     */
+    importModule(moduleName: string, subPath?: string): Promise<any>;
+    /**
+     * Generate alternative import paths for fallback
+     */
+    private generateAlternativePaths;
+    /**
+     * Get comprehensive environment information
+     */
+    getEnvironmentInfo(): {
+        currentDir: string;
+        projectRoot: string;
+        isDevelopment: boolean;
+        isBuilt: boolean;
+        isInstalled: boolean;
+        isTesting: boolean;
+        nodeEnv: string | undefined;
+    };
+}
+export declare const importResolver: ImportResolver;

package/dist/utils/language-detector.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Language Detector Utility
+ *
+ * Detects project language and test framework from project files.
+ * Supports: TypeScript, JavaScript, Python, Go, Rust, Java, C++, Ruby, PHP
+ *
+ * @version 1.0.0
+ * @since 2026-02-25
+ */
+export interface ProjectLanguage {
+    language: string;
+    testFramework: string;
+    testCommand: string;
+    testFilePattern: string;
+    configFiles: string[];
+}
+export interface LanguageConfig {
+    language: string;
+    extensions: string[];
+    testFrameworks: {
+        name: string;
+        patterns: string[];
+        testCommands: string[];
+        configFiles: string[];
+    }[];
+}
+export declare const LANGUAGE_CONFIGS: LanguageConfig[];
+/**
+ * Detect the project language from directory contents
+ */
+export declare function detectProjectLanguage(cwd: string): ProjectLanguage | null;
+/**
+ * Get the test file path for a given source file
+ */
+export declare function getTestFilePath(sourceFilePath: string, projectLanguage: ProjectLanguage): string;
+/**
+ * Build the test command for running specific tests
+ */
+export declare function buildTestCommand(projectLanguage: ProjectLanguage, testFilePath?: string): string;
+export declare const languageDetector: {
+    detect: typeof detectProjectLanguage;
+    getTestFilePath: typeof getTestFilePath;
+    buildTestCommand: typeof buildTestCommand;
+};

package/dist/utils/path-resolver.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Path Resolution Utility for 0xRay Framework
+ * Resolves import paths that work across development, build, and installed environments
+ */
+export declare class PathResolver {
+    private static instance;
+    private currentDir;
+    private isDevelopment;
+    private isBuilt;
+    private isInstalled;
+    private constructor();
+    static getInstance(): PathResolver;
+    /**
+     * Get current working directory
+     */
+    private getCurrentDirectory;
+    /**
+     * Detect if we're running in development environment (src/ directory)
+     */
+    private detectDevelopment;
+    /**
+     * Detect if we're running in built environment (dist/ directory)
+     */
+    private detectBuilt;
+    /**
+     * Detect if we're running in installed package environment
+     */
+    private detectInstalled;
+    /**
+     * Resolve agent import path for current environment
+     */
+    resolveAgentPath(agentName: string): string;
+    /**
+     * Resolve any module path for current environment
+     */
+    resolveModulePath(modulePath: string): string;
+    /**
+     * Get environment information for debugging
+     */
+    getEnvironmentInfo(): {
+        currentDir: string;
+        isDevelopment: boolean;
+        isBuilt: boolean;
+        isInstalled: boolean;
+        nodeEnv: string | undefined;
+    };
+}
+export declare const pathResolver: PathResolver;

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

@@ -0,0 +1,27 @@
+/**
+ * Graceful Shutdown Handler
+ *
+ * Centralized shutdown handling for MCP servers.
+ * Extracts common shutdown patterns to reduce code duplication.
+ *
+ * @version 1.0.0
+ * @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/test-template-generator.d.ts

@@ -0,0 +1,25 @@
+/**
+ * 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/token-manager.d.ts

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

package/dist/validation/estimation-validator.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Estimation Validator
+ *
+ * Tracks estimates vs. actuals and provides calibrated estimates
+ * Prevents the "always estimate high" syndrome by learning from history
+ */
+/**
+ * Estimation Validator
+ * Tracks estimates and learns from actuals to improve future predictions
+ */
+export declare class EstimationValidator {
+    private estimations;
+    private calibrations;
+    private readonly STORAGE_KEY;
+    constructor();
+    /**
+     * Start tracking an estimate
+     */
+    startEstimate(taskId: string, description: string, category: string, estimatedMinutes: number, confidence?: 'high' | 'medium' | 'low'): void;
+    /**
+     * Complete tracking and record actual time
+     */
+    completeEstimate(taskId: string): void;
+    /**
+     * Get calibrated estimate based on historical data
+     */
+    getCalibratedEstimate(category: string, baseEstimate: number, confidence?: 'high' | 'medium' | 'low'): {
+        calibratedEstimate: number;
+        calibrationFactor: number;
+        confidence: number;
+    };
+    /**
+     * Check if an estimate needs adjustment
+     */
+    validateEstimate(category: string, estimate: number): {
+        isReasonable: boolean;
+        suggestedEstimate: number;
+        warning?: string;
+    };
+    /**
+     * Get estimation accuracy report
+     */
+    getAccuracyReport(): {
+        overallAccuracy: number;
+        categoryBreakdown: Array<{
+            category: string;
+            sampleSize: number;
+            avgRatio: number;
+            trend: 'over' | 'under' | 'accurate';
+        }>;
+        recommendations: string[];
+    };
+    private updateCalibration;
+    private loadFromStorage;
+    private saveToStorage;
+}
+export declare function getEstimationValidator(): EstimationValidator;
+/**
+ * Decorator for async functions to track estimates
+ */
+export declare function trackEstimate(taskId: string, description: string, category: string, estimatedMinutes: number): (_target: unknown, _propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;

package/dist/validation/report-content-validator.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Report Content Validator
+ * Reads and analyzes full report content to detect hidden errors and inconsistencies
+ */
+export declare class ReportContentValidator {
+    private reportPatterns;
+    /**
+     * Validate full report content for hidden errors
+     */
+    validateReportContent(reportPath: string, reportType: "session" | "framework" | "validation" | "simulation"): Promise<{
+        valid: boolean;
+        issues: string[];
+        summary: {
+            errorCount: number;
+            warningCount: number;
+            falsePositiveCount: number;
+            inconsistencyCount: number;
+            riskLevel: "low" | "medium" | "high" | "critical";
+        };
+        details: {
+            criticalErrors: string[];
+            warnings: string[];
+            falsePositives: string[];
+            inconsistencies: string[];
+        };
+    }>;
+    private validateReportTypeSpecific;
+    private createValidationResult;
+    /**
+     * Get validation patterns for debugging
+     */
+    getValidationPatterns(): {
+        criticalErrors: RegExp[];
+        warnings: RegExp[];
+        falsePositives: RegExp[];
+        inconsistencies: RegExp[];
+    };
+    /**
+     * Add custom validation pattern
+     */
+    addValidationPattern(category: keyof typeof this.reportPatterns, pattern: RegExp): void;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "0xray",
-  "version": "2.0.0",
+  "version": "2.0.1",
   "description": "Multi-agent orchestration and Codex governance for OpenCode, Hermes, Grok Build, and OpenClaw",
   "readme": "README.md",
   "license": "MIT",
@@ -49,6 +49,8 @@
     "prepublishOnly": "npm run prepare-consumer && npm run build:all && find dist -name '*.d.ts' -o -name '*.d.ts.map' -o -name '*.js.map' | xargs rm -f",
     "version:bump": "node scripts/node/version-manager.mjs",
     "version": "node scripts/node/version-manager.mjs",
+    "postinstall": "node scripts/node/postinstall.cjs",
+    "prepare": "npm run build",
     "prebuild": "rm -rf dist tsconfig.tsbuildinfo tsconfig.*.tsbuildinfo",
     "build": "tsc && mkdir -p dist/public dist/scripts && cp -r public/* dist/public/ && cp scripts/hooks/pre-command dist/scripts/ && cp scripts/hooks/pre-command.mjs dist/scripts/ && cp README.md AGENTS.md CHANGELOG.md LICENSE dist/ && find src -name '*.mjs' ! -path '*/__tests__/*' | while read f; do tgt=\"dist/${f#src/}\"; mkdir -p \"$(dirname $tgt)\"; cp \"$f\" \"$tgt\"; done && for dir in skills integrations mcps; do find src/$dir -type f ! -name '*.ts' ! -path '*/.pytest_cache/*' | while read f; do tgt=\"dist/${f#src/}\"; mkdir -p \"$(dirname $tgt)\"; cp \"$f\" \"$tgt\"; done; done && mkdir -p dist/plugin && (find dist/plugin -name '*codex-injection*.js' -exec cp {} dist/plugin/xray-codex-injection.js \\; 2>/dev/null || true) && cp -r src/opencode/ .opencode/ && rm -rf .opencode/xray 2>/dev/null; mkdir -p .opencode/xray && cp xray/codex.json .opencode/xray/codex.json 2>/dev/null || true",
     "build:all": "npm run build",
@@ -73,7 +75,6 @@
     "test:root": "npm test -- src/__tests__/integration/server.test.ts src/__tests__/framework-enforcement-integration.test.ts",
     "test:pipelines": "node src/__tests__/pipeline/run-all-pipelines.mjs",
     "test:full-suite": "npm run typecheck && npm run test:integration-all && npm run test:performance-all && npm run test:infrastructure && npm run test:root",
-    "postinstall": "node scripts/node/postinstall.cjs",
     "setup-dev": "node scripts/node/setup-dev.cjs",
     "prepare-consumer": "node scripts/node/prepare-consumer.cjs",
     "typecheck": "tsc --noEmit",