0xray 4.0.12 → 4.0.13

package/dist/enforcement/loaders/loader-orchestrator.js

@@ -1,167 +0,0 @@
-/**
- * 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
- */
-import { frameworkLogger } from "../../core/framework-logger.js";
-import { CodexLoader } from "./codex-loader.js";
-import { AgentTriageLoader } from "./agent-triage-loader.js";
-import { ProcessorLoader } from "./processor-loader.js";
-import { AgentsMdValidationLoader } from "./agents-md-validation-loader.js";
-/**
- * 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 class LoaderOrchestrator {
-    loaders = [];
-    options;
-    /**
-     * Create a new LoaderOrchestrator.
-     * @param options - Configuration options
-     */
-    constructor(options = {}) {
-        this.options = {
-            continueOnError: true,
-            enableLogging: true,
-            ...options,
-        };
-        // Register default loaders
-        this.registerDefaultLoaders();
-    }
-    /**
-     * Register the default set of loaders.
-     */
-    registerDefaultLoaders() {
-        this.loaders = [
-            new CodexLoader(),
-            new AgentTriageLoader(),
-            new ProcessorLoader(),
-            new AgentsMdValidationLoader(),
-        ];
-    }
-    /**
-     * Load all rules from all available loaders.
-     * @returns Promise resolving to orchestrator result
-     */
-    async loadAllRules() {
-        const allRules = [];
-        const loaderResults = new Map();
-        let successfulLoaders = 0;
-        let failedLoaders = 0;
-        for (const loader of this.loaders) {
-            try {
-                const isAvailable = await loader.isAvailable();
-                if (!isAvailable) {
-                    if (this.options.enableLogging) {
-                        await frameworkLogger.log("loader-orchestrator", "loader-not-available", "info", {
-                            message: `Loader ${loader.name} not available, skipping`,
-                            loader: loader.name,
-                        });
-                    }
-                    loaderResults.set(loader.name, { success: true, ruleCount: 0 });
-                    continue;
-                }
-                const rules = await loader.load();
-                allRules.push(...rules);
-                successfulLoaders++;
-                loaderResults.set(loader.name, { success: true, ruleCount: rules.length });
-                if (this.options.enableLogging) {
-                    await frameworkLogger.log("loader-orchestrator", "loader-success", "success", {
-                        message: `Loader ${loader.name} loaded ${rules.length} rules`,
-                        loader: loader.name,
-                        ruleCount: rules.length,
-                    });
-                }
-            }
-            catch (error) {
-                failedLoaders++;
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                loaderResults.set(loader.name, { success: false, ruleCount: 0, error: errorMessage });
-                if (this.options.enableLogging) {
-                    await frameworkLogger.log("loader-orchestrator", "loader-failed", "error", {
-                        message: `Loader ${loader.name} failed: ${errorMessage}`,
-                        loader: loader.name,
-                        error: errorMessage,
-                    });
-                }
-                if (!this.options.continueOnError) {
-                    throw error;
-                }
-            }
-        }
-        const result = {
-            rules: allRules,
-            successfulLoaders,
-            failedLoaders,
-            loaderResults,
-        };
-        if (this.options.enableLogging) {
-            await frameworkLogger.log("loader-orchestrator", "load-complete", "success", {
-                message: `Loaded ${allRules.length} rules from ${successfulLoaders} loaders (${failedLoaders} failed)`,
-                totalRules: allRules.length,
-                successfulLoaders,
-                failedLoaders,
-            });
-        }
-        return result;
-    }
-    /**
-     * Register a custom loader.
-     * @param loader - Loader to register
-     */
-    registerLoader(loader) {
-        this.loaders.push(loader);
-    }
-    /**
-     * Get all registered loaders.
-     * @returns Array of registered loaders
-     */
-    getLoaders() {
-        return [...this.loaders];
-    }
-    /**
-     * Get loader by name.
-     * @param name - Loader name
-     * @returns Loader instance or undefined
-     */
-    getLoader(name) {
-        return this.loaders.find((loader) => loader.name === name);
-    }
-    /**
-     * Remove a loader by name.
-     * @param name - Loader name
-     * @returns True if loader was removed
-     */
-    removeLoader(name) {
-        const index = this.loaders.findIndex((loader) => loader.name === name);
-        if (index >= 0) {
-            this.loaders.splice(index, 1);
-            return true;
-        }
-        return false;
-    }
-    /**
-     * Clear all registered loaders.
-     */
-    clearLoaders() {
-        this.loaders = [];
-    }
-    /**
-     * Get count of registered loaders.
-     * @returns Number of loaders
-     */
-    getLoaderCount() {
-        return this.loaders.length;
-    }
-}

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

@@ -1,59 +0,0 @@
-/**
- * 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/loaders/processor-loader.js

@@ -1,112 +0,0 @@
-/**
- * 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 { frameworkLogger } from "../../core/framework-logger.js";
-import { BaseLoader } from "./base-loader.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 class ProcessorLoader extends BaseLoader {
-    name = "processor";
-    /**
-     * Processor rules are always available.
-     * @returns Always returns true
-     */
-    async isAvailable() {
-        return true;
-    }
-    /**
-     * Load processor-specific rules.
-     * Currently returns placeholder rules for future expansion.
-     * @returns Promise resolving to array of rule definitions
-     */
-    async load() {
-        const rules = [];
-        try {
-            // Add processor validation rule
-            rules.push(this.createProcessorValidationRule());
-            // Add processor health check rule
-            rules.push(this.createProcessorHealthRule());
-            await frameworkLogger.log("processor-loader", "loaded-processor-rules", "success", {
-                message: `Loaded ${rules.length} processor rules`,
-                ruleCount: rules.length,
-            });
-        }
-        catch (error) {
-            await frameworkLogger.log("processor-loader", "failed-to-load-processor", "error", {
-                message: `Failed to load processor rules: ${error instanceof Error ? error.message : String(error)}`,
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
-        return rules;
-    }
-    /**
-     * Create processor validation rule.
-     * @returns RuleDefinition for processor validation
-     */
-    createProcessorValidationRule() {
-        return {
-            id: "processor-validation",
-            name: "Processor Validation",
-            description: "Validates that processor operations follow established patterns",
-            category: "architecture",
-            severity: "info",
-            enabled: true,
-            validator: this.validateProcessorOperations.bind(this),
-        };
-    }
-    /**
-     * Create processor health check rule.
-     * @returns RuleDefinition for processor health
-     */
-    createProcessorHealthRule() {
-        return {
-            id: "processor-health",
-            name: "Processor Health Check",
-            description: "Monitors processor health and performance metrics",
-            category: "performance",
-            severity: "info",
-            enabled: true,
-            validator: this.validateProcessorHealth.bind(this),
-        };
-    }
-    /**
-     * Validate processor operations.
-     * @param context - Validation context
-     * @returns Validation result
-     */
-    async validateProcessorOperations(context) {
-        // Placeholder for processor operation validation
-        return {
-            passed: true,
-            message: "Processor operations validated",
-        };
-    }
-    /**
-     * Validate processor health.
-     * @param context - Validation context
-     * @returns Validation result
-     */
-    async validateProcessorHealth(context) {
-        // Placeholder for processor health validation
-        return {
-            passed: true,
-            message: "Processor health check passed",
-        };
-    }
-}

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

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