0xray 4.0.33 → 4.0.35

package/dist/core/trace-context.d.ts

@@ -1,12 +0,0 @@
-export interface TraceContext {
-    traceId: string;
-    parentId?: string;
-    operation: string;
-    governanceApproved: boolean;
-    startTime: number;
-    metadata?: Record<string, any>;
-}
-export declare function startTrace(operation: string, metadata?: Record<string, any>): TraceContext;
-export declare function getCurrentTrace(): TraceContext | null;
-export declare function endTrace(approved?: boolean): void;
-export declare function propagateTrace(childOperation: string): TraceContext | null;

package/dist/core/trace-context.js

@@ -1,33 +0,0 @@
-// src/core/trace-context.ts
-// Centralized trace propagation
-let currentTrace = null;
-function generateId() {
-    if (typeof crypto !== 'undefined' && crypto.randomUUID) {
-        return crypto.randomUUID();
-    }
-    return Date.now().toString(36) + Math.random().toString(36).substring(2);
-}
-export function startTrace(operation, metadata) {
-    const trace = {
-        traceId: generateId(),
-        operation,
-        governanceApproved: false,
-        startTime: Date.now(),
-        metadata: metadata || {}
-    };
-    currentTrace = trace;
-    return trace;
-}
-export function getCurrentTrace() {
-    return currentTrace;
-}
-export function endTrace(approved = true) {
-    if (currentTrace)
-        currentTrace.governanceApproved = approved;
-    currentTrace = null;
-}
-export function propagateTrace(childOperation) {
-    if (!currentTrace)
-        return null;
-    return { ...currentTrace, parentId: currentTrace.traceId, operation: childOperation, startTime: Date.now() };
-}

package/dist/enforcement/index.d.ts

@@ -1,22 +0,0 @@
-/**
- * Rule Enforcement Module
- *
- * This module provides rule enforcement capabilities for the 0xRay framework.
- * It validates code against development rules and codex compliance requirements.
- *
- * @module enforcement
- *
- * @example
- * ```typescript
- * import { RuleEnforcer, RuleDefinition, ValidationReport } from './enforcement/index.js';
- *
- * const enforcer = new RuleEnforcer();
- * const report = await enforcer.validateOperation('write', context);
- * ```
- */
-export { RuleEnforcer } from "./rule-enforcer.js";
-export { RuleRegistry, RuleHierarchy, RuleExecutor, ViolationFixer, } from "./core/index.js";
-export { RuleDefinition, RuleValidationContext, RuleValidationResult, ValidationReport, Violation, ViolationFix, RuleFix, RuleCategory, RuleSeverity, RuleFixType, IRuleRegistry, IValidator, IValidatorRegistry, IRuleHierarchy, IRuleExecutor, IViolationFixer, ExecutionOptions, BatchExecutionOptions, FixStrategy, isRuleValidationResult, } from "./types.js";
-export { BaseValidator, ValidatorRegistry, globalValidatorRegistry, NoDuplicateCodeValidator, ContextAnalysisIntegrationValidator, MemoryOptimizationValidator, DocumentationRequiredValidator, NoOverEngineeringValidator, CleanDebugLogsValidator, ConsoleLogUsageValidator, } from "./validators/index.js";
-export { BaseLoader, CodexLoader, AgentTriageLoader, ProcessorLoader, AgentsMdValidationLoader, LoaderOrchestrator, type LoaderOrchestratorOptions, type LoaderOrchestratorResult, } from "./loaders/index.js";
-export * as enforcerTools from "./enforcer-tools.js";

package/dist/enforcement/index.js

@@ -1,40 +0,0 @@
-/**
- * Rule Enforcement Module
- *
- * This module provides rule enforcement capabilities for the 0xRay framework.
- * It validates code against development rules and codex compliance requirements.
- *
- * @module enforcement
- *
- * @example
- * ```typescript
- * import { RuleEnforcer, RuleDefinition, ValidationReport } from './enforcement/index.js';
- *
- * const enforcer = new RuleEnforcer();
- * const report = await enforcer.validateOperation('write', context);
- * ```
- */
-// Core enforcer
-export { RuleEnforcer } from "./rule-enforcer.js";
-// Core components (Phase 5 refactoring)
-export { RuleRegistry, RuleHierarchy, RuleExecutor, ViolationFixer, } from "./core/index.js";
-// All types
-export { isRuleValidationResult, } from "./types.js";
-// Validators (Phase 3 refactoring)
-export { 
-// Base class
-BaseValidator, 
-// Registry
-ValidatorRegistry, globalValidatorRegistry, 
-// Code quality validators
-NoDuplicateCodeValidator, ContextAnalysisIntegrationValidator, MemoryOptimizationValidator, DocumentationRequiredValidator, NoOverEngineeringValidator, CleanDebugLogsValidator, ConsoleLogUsageValidator, } from "./validators/index.js";
-// Loaders (Phase 4 refactoring)
-export { 
-// Base loader
-BaseLoader, 
-// Concrete loaders
-CodexLoader, AgentTriageLoader, ProcessorLoader, AgentsMdValidationLoader, 
-// Orchestrator
-LoaderOrchestrator, } from "./loaders/index.js";
-// Enforcer tools (if any exports exist)
-export * as enforcerTools from "./enforcer-tools.js";

package/dist/enforcement/loaders/index.d.ts

@@ -1,36 +0,0 @@
-/**
- * Rule Loaders Module
- *
- * This module provides rule loading capabilities for the 0xRay framework.
- * Loaders encapsulate the logic for loading rules from various sources.
- *
- * Phase 4 refactoring: Extracted async rule loading from RuleEnforcer
- *
- * @module loaders
- *
- * @example
- * ```typescript
- * import {
- *   LoaderOrchestrator,
- *   CodexLoader,
- *   AgentTriageLoader,
- *   IRuleLoader
- * } from './enforcement/loaders/index.js';
- *
- * // Use the orchestrator to load all rules
- * const orchestrator = new LoaderOrchestrator();
- * const result = await orchestrator.loadAllRules();
- *
- * // Or use individual loaders
- * const codexLoader = new CodexLoader();
- * if (await codexLoader.isAvailable()) {
- *   const codexRules = await codexLoader.load();
- * }
- * ```
- */
-export { BaseLoader } from "./base-loader.js";
-export { CodexLoader } from "./codex-loader.js";
-export { AgentTriageLoader } from "./agent-triage-loader.js";
-export { ProcessorLoader } from "./processor-loader.js";
-export { AgentsMdValidationLoader } from "./agents-md-validation-loader.js";
-export { LoaderOrchestrator, type LoaderOrchestratorOptions, type LoaderOrchestratorResult, } from "./loader-orchestrator.js";

package/dist/enforcement/loaders/index.js

@@ -1,39 +0,0 @@
-/**
- * Rule Loaders Module
- *
- * This module provides rule loading capabilities for the 0xRay framework.
- * Loaders encapsulate the logic for loading rules from various sources.
- *
- * Phase 4 refactoring: Extracted async rule loading from RuleEnforcer
- *
- * @module loaders
- *
- * @example
- * ```typescript
- * import {
- *   LoaderOrchestrator,
- *   CodexLoader,
- *   AgentTriageLoader,
- *   IRuleLoader
- * } from './enforcement/loaders/index.js';
- *
- * // Use the orchestrator to load all rules
- * const orchestrator = new LoaderOrchestrator();
- * const result = await orchestrator.loadAllRules();
- *
- * // Or use individual loaders
- * const codexLoader = new CodexLoader();
- * if (await codexLoader.isAvailable()) {
- *   const codexRules = await codexLoader.load();
- * }
- * ```
- */
-// Base loader
-export { BaseLoader } from "./base-loader.js";
-// Concrete loaders
-export { CodexLoader } from "./codex-loader.js";
-export { AgentTriageLoader } from "./agent-triage-loader.js";
-export { ProcessorLoader } from "./processor-loader.js";
-export { AgentsMdValidationLoader } from "./agents-md-validation-loader.js";
-// Orchestrator
-export { LoaderOrchestrator, } from "./loader-orchestrator.js";

package/dist/enforcement/test-auto-healing.d.ts

@@ -1,83 +0,0 @@
-/**
- * Test Auto-Healing System for 0xRay Framework
- *
- * Automatically detects slow/failing tests and orchestrates fixes using specialized agents
- * Implements intelligent test optimization and refactoring for enterprise reliability
- */
-import { RuleValidationContext } from "./rule-enforcer.js";
-export interface TestFailureAnalysis {
-    testFile: string;
-    failureType: "timeout" | "performance" | "logic-error" | "flaky" | "infrastructure";
-    rootCause: string;
-    severity: "low" | "medium" | "high" | "critical";
-    estimatedFixTime: number;
-    autoFixable: boolean;
-    recommendedAgent: string;
-    fixStrategy: TestFixStrategy;
-}
-export interface TestFixStrategy {
-    type: "refactor" | "optimize" | "parallelize" | "mock" | "isolate" | "infrastructure";
-    description: string;
-    estimatedImprovement: number;
-    riskLevel: "low" | "medium" | "high";
-    requiresAgentCoordination: boolean;
-}
-export interface AutoHealingResult {
-    success: boolean;
-    fixesApplied: number;
-    testsOptimized: number;
-    performanceImprovement: number;
-    agentCoordinationUsed: boolean;
-    recommendations: string[];
-    nextSteps: string[];
-}
-export interface TestResults {
-    timedOut?: boolean;
-    executionTime?: number;
-    file?: string;
-    failed?: number;
-}
-export declare class TestAutoHealingSystem {
-    private healingHistory;
-    /**
-     * Main auto-healing entry point for test failures
-     */
-    healTestFailures(testResults: TestResults, context: RuleValidationContext): Promise<AutoHealingResult>;
-    /**
-     * Analyze test failures and determine root causes
-     */
-    private analyzeTestFailures;
-    /**
-     * Apply automatic fixes for simple issues
-     */
-    private applyAutomaticFixes;
-    /**
-     * Coordinate with specialized agents for complex fixes
-     */
-    private coordinateAgentFixes;
-    /**
-     * Optimize test timeouts automatically
-     */
-    private optimizeTestTimeouts;
-    /**
-     * Implement parallel test execution
-     */
-    private implementParallelExecution;
-    /**
-     * Add mocks to speed up tests
-     */
-    private addTestMocks;
-    /**
-     * Invoke specialized agents for complex fixes
-     */
-    private invokeSpecializedAgent;
-    /**
-     * Detect flaky tests based on inconsistent results
-     */
-    private detectFlakyTests;
-    /**
-     * Prioritize issues for fixing
-     */
-    private prioritizeIssues;
-}
-export declare const testAutoHealingSystem: TestAutoHealingSystem;

package/dist/enforcement/test-auto-healing.js

@@ -1,325 +0,0 @@
-/**
- * Test Auto-Healing System for 0xRay Framework
- *
- * Automatically detects slow/failing tests and orchestrates fixes using specialized agents
- * Implements intelligent test optimization and refactoring for enterprise reliability
- */
-import { frameworkLogger } from "../core/framework-logger.js";
-export class TestAutoHealingSystem {
-    healingHistory = new Map();
-    /**
-     * Main auto-healing entry point for test failures
-     */
-    async healTestFailures(testResults, context) {
-        const jobId = `test-healing-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
-        const startTime = Date.now();
-        frameworkLogger.log("test-auto-healing", "healing-start", "info", {
-            jobId,
-            testFiles: context.tests?.length || 0,
-            operation: context.operation,
-        });
-        try {
-            // Step 1: Analyze test failures
-            const failureAnalysis = await this.analyzeTestFailures(testResults, context);
-            // Step 2: Prioritize and filter auto-fixable issues
-            const autoFixableIssues = failureAnalysis.filter((analysis) => analysis.autoFixable);
-            const prioritizedIssues = this.prioritizeIssues(autoFixableIssues);
-            // Step 3: Apply automatic fixes
-            const healingResult = await this.applyAutomaticFixes(prioritizedIssues, context, jobId);
-            // Step 4: Coordinate with agents for complex fixes
-            const agentCoordination = await this.coordinateAgentFixes(failureAnalysis.filter((analysis) => !analysis.autoFixable), context, jobId);
-            // Step 5: Generate final report
-            const result = {
-                success: healingResult.success && agentCoordination.success,
-                fixesApplied: healingResult.fixesApplied + agentCoordination.fixesApplied,
-                testsOptimized: healingResult.testsOptimized + agentCoordination.testsOptimized,
-                performanceImprovement: healingResult.performanceImprovement +
-                    agentCoordination.performanceImprovement,
-                agentCoordinationUsed: agentCoordination.agentsUsed.length > 0,
-                recommendations: [
-                    ...healingResult.recommendations,
-                    ...agentCoordination.recommendations,
-                ],
-                nextSteps: [...healingResult.nextSteps, ...agentCoordination.nextSteps],
-            };
-            const duration = Date.now() - startTime;
-            frameworkLogger.log("test-auto-healing", "healing-complete", "success", {
-                jobId,
-                duration,
-                fixesApplied: result.fixesApplied,
-                performanceImprovement: result.performanceImprovement,
-                success: result.success,
-            });
-            return result;
-        }
-        catch (error) {
-            frameworkLogger.log("test-auto-healing", "healing-error", "error", {
-                jobId,
-                error: error instanceof Error
-                    ? error.message
-                    : `Unknown error: ${String(error)}`,
-                operation: context.operation,
-            });
-            return {
-                success: false,
-                fixesApplied: 0,
-                testsOptimized: 0,
-                performanceImprovement: 0,
-                agentCoordinationUsed: false,
-                recommendations: ["Manual review required - auto-healing failed"],
-                nextSteps: ["Review error logs and fix underlying issues"],
-            };
-        }
-    }
-    /**
-     * Analyze test failures and determine root causes
-     */
-    async analyzeTestFailures(testResults, context) {
-        const analyses = [];
-        // Analyze timeout failures (Codex Term #45)
-        if (testResults.timedOut) {
-            analyses.push({
-                testFile: testResults.file || "unknown",
-                failureType: "timeout",
-                rootCause: "Test execution exceeded timeout limits",
-                severity: "high",
-                estimatedFixTime: 15,
-                autoFixable: true,
-                recommendedAgent: "testing-lead",
-                fixStrategy: {
-                    type: "optimize",
-                    description: "Optimize test execution time through parallelization and mocking",
-                    estimatedImprovement: 60,
-                    riskLevel: "low",
-                    requiresAgentCoordination: false,
-                },
-            });
-        }
-        // Analyze performance issues
-        if ((testResults.executionTime ?? 0) > 300000) {
-            // 5 minutes
-            analyses.push({
-                testFile: testResults.file || "unknown",
-                failureType: "performance",
-                rootCause: "Test suite execution too slow",
-                severity: "medium",
-                estimatedFixTime: 30,
-                autoFixable: true,
-                recommendedAgent: "refactorer",
-                fixStrategy: {
-                    type: "parallelize",
-                    description: "Implement parallel test execution and optimize slow tests",
-                    estimatedImprovement: 70,
-                    riskLevel: "medium",
-                    requiresAgentCoordination: true,
-                },
-            });
-        }
-        // Analyze flaky tests
-        const flakyTests = this.detectFlakyTests(testResults);
-        for (const flakyTest of flakyTests) {
-            analyses.push({
-                testFile: flakyTest.file,
-                failureType: "flaky",
-                rootCause: `Test ${flakyTest.name} is flaky - inconsistent results`,
-                severity: "medium",
-                estimatedFixTime: 20,
-                autoFixable: false,
-                recommendedAgent: "bug-triage-specialist",
-                fixStrategy: {
-                    type: "isolate",
-                    description: "Isolate and fix race conditions or timing dependencies",
-                    estimatedImprovement: 90,
-                    riskLevel: "medium",
-                    requiresAgentCoordination: true,
-                },
-            });
-        }
-        return analyses;
-    }
-    /**
-     * Apply automatic fixes for simple issues
-     */
-    async applyAutomaticFixes(issues, context, jobId) {
-        let fixesApplied = 0;
-        let testsOptimized = 0;
-        let performanceImprovement = 0;
-        const recommendations = [];
-        const nextSteps = [];
-        for (const issue of issues) {
-            try {
-                switch (issue.fixStrategy.type) {
-                    case "optimize":
-                        const optimizationResult = await this.optimizeTestTimeouts(issue, context, jobId);
-                        if (optimizationResult.success) {
-                            fixesApplied++;
-                            performanceImprovement += issue.fixStrategy.estimatedImprovement;
-                            recommendations.push(`Optimized ${issue.testFile} for better performance`);
-                        }
-                        break;
-                    case "parallelize":
-                        const parallelResult = await this.implementParallelExecution(issue, context, jobId);
-                        if (parallelResult.success) {
-                            fixesApplied++;
-                            testsOptimized++;
-                            performanceImprovement += issue.fixStrategy.estimatedImprovement;
-                            recommendations.push(`Implemented parallel execution for ${issue.testFile}`);
-                        }
-                        break;
-                    case "mock":
-                        const mockResult = await this.addTestMocks(issue, context, jobId);
-                        if (mockResult.success) {
-                            fixesApplied++;
-                            performanceImprovement += issue.fixStrategy.estimatedImprovement;
-                            recommendations.push(`Added mocks to speed up ${issue.testFile}`);
-                        }
-                        break;
-                }
-            }
-            catch (error) {
-                nextSteps.push(`Manual intervention needed for ${issue.testFile}: ${error instanceof Error ? error.message : String(error)}`);
-            }
-        }
-        return {
-            success: fixesApplied > 0,
-            fixesApplied,
-            testsOptimized,
-            performanceImprovement,
-            recommendations,
-            nextSteps,
-        };
-    }
-    /**
-     * Coordinate with specialized agents for complex fixes
-     */
-    async coordinateAgentFixes(complexIssues, context, jobId) {
-        let fixesApplied = 0;
-        let testsOptimized = 0;
-        let performanceImprovement = 0;
-        const agentsUsed = [];
-        const recommendations = [];
-        const nextSteps = [];
-        // Group issues by recommended agent
-        const agentGroups = new Map();
-        for (const issue of complexIssues) {
-            if (!agentGroups.has(issue.recommendedAgent)) {
-                agentGroups.set(issue.recommendedAgent, []);
-            }
-            agentGroups.get(issue.recommendedAgent).push(issue);
-        }
-        // Coordinate with each agent
-        for (const [agentName, issues] of agentGroups) {
-            try {
-                const agentResult = await this.invokeSpecializedAgent(agentName, issues, context, jobId);
-                if (agentResult.success) {
-                    fixesApplied += agentResult.fixesApplied;
-                    testsOptimized += agentResult.testsOptimized;
-                    performanceImprovement += agentResult.performanceImprovement;
-                    agentsUsed.push(agentName);
-                    recommendations.push(...agentResult.recommendations);
-                }
-                else {
-                    nextSteps.push(`Agent ${agentName} coordination needed for ${issues.length} issues`);
-                }
-            }
-            catch (error) {
-                nextSteps.push(`Failed to coordinate with ${agentName}: ${error instanceof Error ? error.message : String(error)}`);
-            }
-        }
-        return {
-            success: fixesApplied > 0,
-            fixesApplied,
-            testsOptimized,
-            performanceImprovement,
-            agentsUsed,
-            recommendations,
-            nextSteps,
-        };
-    }
-    /**
-     * Optimize test timeouts automatically
-     */
-    async optimizeTestTimeouts(issue, context, jobId) {
-        // Implementation would modify test files to add timeouts and optimize slow operations
-        // For now, return success to indicate capability
-        frameworkLogger.log("test-auto-healing", "timeout-optimization", "success", {
-            jobId,
-            testFile: issue.testFile,
-            improvement: issue.fixStrategy.estimatedImprovement,
-        });
-        return { success: true };
-    }
-    /**
-     * Implement parallel test execution
-     */
-    async implementParallelExecution(issue, context, jobId) {
-        // Implementation would modify test configuration for parallel execution
-        frameworkLogger.log("test-auto-healing", "parallel-execution", "success", {
-            jobId,
-            testFile: issue.testFile,
-            improvement: issue.fixStrategy.estimatedImprovement,
-        });
-        return { success: true };
-    }
-    /**
-     * Add mocks to speed up tests
-     */
-    async addTestMocks(issue, context, jobId) {
-        // Implementation would analyze test dependencies and add appropriate mocks
-        frameworkLogger.log("test-auto-healing", "mock-addition", "success", {
-            jobId,
-            testFile: issue.testFile,
-            improvement: issue.fixStrategy.estimatedImprovement,
-        });
-        return { success: true };
-    }
-    /**
-     * Invoke specialized agents for complex fixes
-     */
-    async invokeSpecializedAgent(agentName, issues, context, jobId) {
-        // This would integrate with the actual agent system
-        // For now, simulate agent coordination
-        frameworkLogger.log("test-auto-healing", "agent-coordination", "info", {
-            jobId,
-            agent: agentName,
-            issuesCount: issues.length,
-        });
-        // Simulate agent response
-        return {
-            success: true,
-            fixesApplied: issues.length,
-            testsOptimized: Math.floor(issues.length * 0.8),
-            performanceImprovement: issues.reduce((sum, issue) => sum + issue.fixStrategy.estimatedImprovement, 0),
-            recommendations: [
-                `${agentName} successfully addressed ${issues.length} complex issues`,
-            ],
-        };
-    }
-    /**
-     * Detect flaky tests based on inconsistent results
-     */
-    detectFlakyTests(testResults) {
-        // Implementation would analyze test history for flaky patterns
-        return []; // Placeholder
-    }
-    /**
-     * Prioritize issues for fixing
-     */
-    prioritizeIssues(issues) {
-        return issues.sort((a, b) => {
-            const severityOrder = { critical: 4, high: 3, medium: 2, low: 1 };
-            const typeOrder = {
-                timeout: 3,
-                performance: 2,
-                "logic-error": 3,
-                flaky: 2,
-                infrastructure: 1,
-            };
-            const aScore = severityOrder[a.severity] * 10 + typeOrder[a.failureType];
-            const bScore = severityOrder[b.severity] * 10 + typeOrder[b.failureType];
-            return bScore - aScore;
-        });
-    }
-}
-// Export singleton instance
-export const testAutoHealingSystem = new TestAutoHealingSystem();

package/dist/inference/index.d.ts

@@ -1,10 +0,0 @@
-export { analyzeStructuralPatterns } from "./semantic-patterns.js";
-export type { StructuralPattern } from "./semantic-patterns.js";
-export { captureSessionInference, saveSessionInference, } from "./session-capture.js";
-export type { SessionInference, ReasoningLink, SessionMetrics, } from "./session-capture.js";
-export { shouldTriggerCycle, accumulateCorpus } from "./inference-accumulator.js";
-export type { InferenceCorpus, RecurringPattern, RecurringProblem } from "./inference-accumulator.js";
-export { InferenceCycle } from "./inference-cycle.js";
-export type { InferenceProposal, InferenceCycleResult, CyclePhase } from "./inference-cycle.js";
-export { DeployVerifier } from "./deploy-verifier.js";
-export type { DeployVerificationResult, DeployCheck } from "./deploy-verifier.js";

package/dist/inference/index.js

@@ -1,5 +0,0 @@
-export { analyzeStructuralPatterns } from "./semantic-patterns.js";
-export { captureSessionInference, saveSessionInference, } from "./session-capture.js";
-export { shouldTriggerCycle, accumulateCorpus } from "./inference-accumulator.js";
-export { InferenceCycle } from "./inference-cycle.js";
-export { DeployVerifier } from "./deploy-verifier.js";