0xray 3.4.1 → 3.4.3

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

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