0xray 2.0.0 → 2.0.1

package/dist/enforcement/loaders/codex-loader.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Codex Rule Loader
+ *
+ * Loads codex terms from the resolved codex path and converts them
+ * to RuleDefinition objects for the rule enforcement system.
+ *
+ * Phase 4 refactoring: Extracted from RuleEnforcer.loadCodexRules()
+ *
+ * @module loaders/codex-loader
+ * @version 1.0.0
+ */
+import { BaseLoader } from "./base-loader.js";
+import { RuleDefinition } from "../types.js";
+/**
+ * Loader for codex terms from codex.json.
+ * Converts codex terms to RuleDefinition objects.
+ *
+ * @example
+ * ```typescript
+ * const loader = new CodexLoader();
+ * if (await loader.isAvailable()) {
+ *   const rules = await loader.load();
+ *   console.log(`Loaded ${rules.length} codex rules`);
+ * }
+ * ```
+ */
+export declare class CodexLoader extends BaseLoader {
+    readonly name = "codex";
+    /**
+     * Path to the codex.json file.
+     * Uses the standard config-paths resolver which checks .strray/, .opencode/strray/, etc.
+     */
+    private get codexPath();
+    /**
+     * Check if codex.json exists.
+     * @returns Promise resolving to true if codex.json is available
+     */
+    isAvailable(): Promise<boolean>;
+    /**
+     * Load codex terms and convert to RuleDefinition objects.
+     * @returns Promise resolving to array of rule definitions
+     */
+    load(): Promise<RuleDefinition[]>;
+    /**
+     * Type guard to check if an object is a valid CodexTerm.
+     * @param term - Object to validate
+     * @returns True if the object is a valid CodexTerm
+     */
+    private isValidCodexTerm;
+    /**
+     * Convert a codex term to a RuleDefinition.
+     * @param key - Term key (number as string)
+     * @param term - Codex term data
+     * @returns RuleDefinition object
+     */
+    private convertTermToRule;
+    /**
+     * Map codex category to RuleCategory.
+     * @param category - Codex category string
+     * @returns Mapped RuleCategory
+     */
+    private mapCodexCategory;
+    /**
+     * Map codex severity to RuleSeverity.
+     * @param enforcementLevel - Codex enforcement level
+     * @param zeroTolerance - Whether term has zero tolerance
+     * @returns Mapped RuleSeverity
+     */
+    private mapCodexSeverity;
+    /**
+     * Create a validator function for a codex term.
+     * Now actually validates code against the term requirements.
+     * @param term - Codex term data
+     * @returns Validator function that performs real validation
+     */
+    private createCodexValidator;
+}

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

@@ -0,0 +1,37 @@
+/**
+ * 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
+ * @version 1.0.0
+ *
+ * @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/loader-orchestrator.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Loader Orchestrator
+ *
+ * Coordinates multiple rule loaders to load rules from various sources.
+ * Manages loader execution, error handling, and rule aggregation.
+ *
+ * Phase 4 refactoring: Extracted loader orchestration from RuleEnforcer
+ *
+ * @module loaders/loader-orchestrator
+ * @version 1.0.0
+ */
+import { IRuleLoader, RuleDefinition } from "../types.js";
+/**
+ * Options for LoaderOrchestrator configuration.
+ */
+export interface LoaderOrchestratorOptions {
+    /** Whether to continue loading if one loader fails */
+    continueOnError?: boolean;
+    /** Whether to log loader activity */
+    enableLogging?: boolean;
+}
+/**
+ * Result from the orchestrator's load operation.
+ */
+export interface LoaderOrchestratorResult {
+    /** All loaded rules */
+    rules: RuleDefinition[];
+    /** Number of successful loaders */
+    successfulLoaders: number;
+    /** Number of failed loaders */
+    failedLoaders: number;
+    /** Loader-specific results */
+    loaderResults: Map<string, {
+        success: boolean;
+        ruleCount: number;
+        error?: string;
+    }>;
+}
+/**
+ * Orchestrates multiple rule loaders to load rules from various sources.
+ *
+ * @example
+ * ```typescript
+ * const orchestrator = new LoaderOrchestrator();
+ * const result = await orchestrator.loadAllRules();
+ * console.log(`Loaded ${result.rules.length} rules from ${result.successfulLoaders} loaders`);
+ * ```
+ */
+export declare class LoaderOrchestrator {
+    private loaders;
+    private options;
+    /**
+     * Create a new LoaderOrchestrator.
+     * @param options - Configuration options
+     */
+    constructor(options?: LoaderOrchestratorOptions);
+    /**
+     * Register the default set of loaders.
+     */
+    private registerDefaultLoaders;
+    /**
+     * Load all rules from all available loaders.
+     * @returns Promise resolving to orchestrator result
+     */
+    loadAllRules(): Promise<LoaderOrchestratorResult>;
+    /**
+     * Register a custom loader.
+     * @param loader - Loader to register
+     */
+    registerLoader(loader: IRuleLoader): void;
+    /**
+     * Get all registered loaders.
+     * @returns Array of registered loaders
+     */
+    getLoaders(): IRuleLoader[];
+    /**
+     * Get loader by name.
+     * @param name - Loader name
+     * @returns Loader instance or undefined
+     */
+    getLoader(name: string): IRuleLoader | undefined;
+    /**
+     * Remove a loader by name.
+     * @param name - Loader name
+     * @returns True if loader was removed
+     */
+    removeLoader(name: string): boolean;
+    /**
+     * Clear all registered loaders.
+     */
+    clearLoaders(): void;
+    /**
+     * Get count of registered loaders.
+     * @returns Number of loaders
+     */
+    getLoaderCount(): number;
+}

package/dist/enforcement/loaders/processor-loader.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Processor Rule Loader
+ *
+ * Loads processor-specific rules for the enforcement system.
+ * This is a placeholder for future expansion of processor-specific validation.
+ *
+ * Phase 4 refactoring: Extracted from RuleEnforcer.loadProcessorRules()
+ *
+ * @module loaders/processor-loader
+ * @version 1.0.0
+ */
+import { BaseLoader } from "./base-loader.js";
+import { RuleDefinition } from "../types.js";
+/**
+ * Loader for processor-specific rules.
+ * Currently provides a placeholder for future processor rule expansion.
+ *
+ * @example
+ * ```typescript
+ * const loader = new ProcessorLoader();
+ * const rules = await loader.load();
+ * console.log(`Loaded ${rules.length} processor rules`);
+ * ```
+ */
+export declare class ProcessorLoader extends BaseLoader {
+    readonly name = "processor";
+    /**
+     * Processor rules are always available.
+     * @returns Always returns true
+     */
+    isAvailable(): Promise<boolean>;
+    /**
+     * Load processor-specific rules.
+     * Currently returns placeholder rules for future expansion.
+     * @returns Promise resolving to array of rule definitions
+     */
+    load(): Promise<RuleDefinition[]>;
+    /**
+     * Create processor validation rule.
+     * @returns RuleDefinition for processor validation
+     */
+    private createProcessorValidationRule;
+    /**
+     * Create processor health check rule.
+     * @returns RuleDefinition for processor health
+     */
+    private createProcessorHealthRule;
+    /**
+     * Validate processor operations.
+     * @param context - Validation context
+     * @returns Validation result
+     */
+    private validateProcessorOperations;
+    /**
+     * Validate processor health.
+     * @param context - Validation context
+     * @returns Validation result
+     */
+    private validateProcessorHealth;
+}

package/dist/enforcement/rule-enforcer.d.ts

@@ -0,0 +1,142 @@
+/**
+ * RuleEnforcer - Facade for the enforcement system
+ *
+ * Orchestrates rule validation and fixing through specialized components:
+ * - RuleRegistry: Rule storage and lifecycle
+ * - RuleHierarchy: Dependency management
+ * - RuleExecutor: Validation orchestration
+ * - ViolationFixer: Fix delegation to agents
+ * - LoaderOrchestrator: Async rule loading
+ * - ValidatorRegistry: Individual rule validators
+ *
+ * Phase 6 refactoring: Final facade cleanup - RuleEnforcer is now a pure facade
+ * with all business logic delegated to specialized components.
+ *
+ * @example
+ * const enforcer = new RuleEnforcer();
+ * const report = await enforcer.validateOperation('write', context);
+ * const fixes = await enforcer.attemptRuleViolationFixes(report.violations, context);
+ */
+import { RuleDefinition, RuleValidationContext, ValidationReport, Violation, ViolationFix, IRuleRegistry, IValidatorRegistry, IRuleHierarchy, IRuleExecutor, IViolationFixer } from "./types.js";
+export { RuleDefinition, RuleValidationContext, RuleValidationResult, ValidationReport, Violation, ViolationFix, RuleFix, RuleFixType, isRuleValidationResult, } from "./types.js";
+export { RuleRegistry, RuleHierarchy, RuleExecutor, ViolationFixer, } from "./core/index.js";
+/**
+ * Options for RuleEnforcer constructor.
+ * Supports dependency injection for testability.
+ */
+export interface RuleEnforcerOptions {
+    /** Custom rule registry (optional) */
+    registry?: IRuleRegistry;
+    /** Custom rule hierarchy (optional) */
+    hierarchy?: IRuleHierarchy;
+    /** Custom rule executor (optional) */
+    executor?: IRuleExecutor;
+    /** Custom violation fixer (optional) */
+    fixer?: IViolationFixer;
+    /** Custom validator registry (optional) */
+    validatorRegistry?: IValidatorRegistry;
+}
+/**
+ * RuleEnforcer - Facade for the rule enforcement system
+ *
+ * This class acts as a unified interface to the enforcement system,
+ * delegating all operations to specialized components:
+ *
+ * - RuleRegistry: Stores and manages rule definitions
+ * - RuleHierarchy: Manages rule dependencies and execution order
+ * - RuleExecutor: Orchestrates validation execution
+ * - ViolationFixer: Delegates fixes to appropriate agents/skills
+ * - ValidatorRegistry: Registers and retrieves individual rule validators
+ *
+ * All validation logic has been extracted to individual validator classes
+ * in the validators/ directory. This facade only coordinates between components.
+ */
+export declare class RuleEnforcer {
+    private registry;
+    private hierarchy;
+    private executor;
+    private fixer;
+    private validatorRegistry;
+    private initialized;
+    constructor(options?: RuleEnforcerOptions);
+    /**
+     * Initialize default framework rules using compact metadata.
+     * All validators are delegated to the ValidatorRegistry via createValidatorDelegate.
+     */
+    private initializeRules;
+    /**
+     * Initialize rule hierarchy (prerequisites)
+     * Delegates to RuleHierarchy for dependency management
+     */
+    private initializeRuleHierarchy;
+    /**
+     * Load async rules in background using LoaderOrchestrator.
+     * Delegates to LoaderOrchestrator for rule loading.
+     */
+    private loadAsyncRules;
+    /**
+     * Add a rule to the enforcer
+     * Delegates to RuleRegistry for storage
+     */
+    addRule(rule: RuleDefinition): void;
+    /**
+     * Get all loaded rules
+     * Delegates to RuleRegistry for retrieval
+     */
+    getRules(): RuleDefinition[];
+    /**
+     * Get rule count
+     * Delegates to RuleRegistry for count
+     */
+    getRuleCount(): number;
+    /**
+     * Get rule by ID
+     * Delegates to RuleRegistry for retrieval
+     */
+    getRule(id: string): RuleDefinition | undefined;
+    /**
+     * Enable a rule by ID
+     * Delegates to RuleRegistry for state management
+     */
+    enableRule(ruleId: string): boolean;
+    /**
+     * Disable a rule by ID
+     * Delegates to RuleRegistry for state management
+     */
+    disableRule(ruleId: string): boolean;
+    /**
+     * Check if a rule is enabled
+     * Delegates to RuleRegistry for state check
+     */
+    isRuleEnabled(ruleId: string): boolean;
+    /**
+     * Get rule statistics
+     * Delegates to RuleRegistry for statistics
+     */
+    getRuleStats(): {
+        totalRules: number;
+        enabledRules: number;
+        disabledRules: number;
+        ruleCategories: Record<string, number>;
+    };
+    /**
+     * Check if rule enforcer is fully initialized
+     */
+    isInitialized(): boolean;
+    /**
+     * Validate operation against all applicable rules
+     * Delegates to RuleExecutor for validation orchestration
+     */
+    validateOperation(operation: string, context: RuleValidationContext): Promise<ValidationReport>;
+    /**
+     * Attempt to fix rule violations by delegating to appropriate agents/skills
+     * Delegates to ViolationFixer for fix orchestration
+     */
+    attemptRuleViolationFixes(violations: Violation[], context: RuleValidationContext): Promise<ViolationFix[]>;
+    /**
+     * Creates a validator delegate function that looks up and calls the appropriate validator.
+     * Eliminates the need for 30+ individual wrapper methods.
+     */
+    private createValidatorDelegate;
+}
+export declare const ruleEnforcer: RuleEnforcer;

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

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