0xray 2.0.0

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

@@ -0,0 +1,113 @@
+/**
+ * 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 { 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.js

@@ -0,0 +1,298 @@
+/**
+ * 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 { frameworkLogger } from "../core/framework-logger.js";
+import { RuleRegistry, RuleHierarchy, RuleExecutor, ViolationFixer, } from "./core/index.js";
+import { ValidatorRegistry } from "./validators/index.js";
+import { LoaderOrchestrator } from "./loaders/loader-orchestrator.js";
+// Re-export types for backward compatibility
+export { isRuleValidationResult, } from "./types.js";
+// Re-export core components
+export { RuleRegistry, RuleHierarchy, RuleExecutor, ViolationFixer, } from "./core/index.js";
+/**
+ * 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 class RuleEnforcer {
+    registry;
+    hierarchy;
+    executor;
+    fixer;
+    validatorRegistry;
+    initialized = false;
+    constructor(options) {
+        // Initialize core components with dependency injection for testability
+        this.registry = options?.registry ?? new RuleRegistry();
+        this.hierarchy = options?.hierarchy ?? new RuleHierarchy();
+        this.fixer = options?.fixer ?? new ViolationFixer();
+        this.validatorRegistry = options?.validatorRegistry ?? new ValidatorRegistry();
+        // Initialize rule executor
+        this.executor = options?.executor ?? new RuleExecutor(this.registry, this.hierarchy, this.validatorRegistry);
+        // Initialize synchronously first
+        this.initializeRules();
+        this.initializeRuleHierarchy();
+        // Load async rules in background
+        this.loadAsyncRules();
+    }
+    /**
+     * Initialize default framework rules using compact metadata.
+     * All validators are delegated to the ValidatorRegistry via createValidatorDelegate.
+     */
+    initializeRules() {
+        // Rule metadata: [id, name, description, category, severity]
+        const ruleMetadata = [
+            // Code Quality Rules
+            ["no-duplicate-code", "No Duplicate Code Creation", "Prevents creation of code that already exists", "code-quality", "error"],
+            ["context-analysis-integration", "Context Analysis Integration", "Ensures new code integrates properly with context analysis", "architecture", "warning"],
+            ["memory-optimization", "Memory Optimization Compliance", "Ensures code follows memory optimization patterns", "performance", "warning"],
+            ["dependency-management", "Proper Dependency Management", "Validates dependency declarations and imports", "architecture", "error"],
+            // Build Process Rules
+            ["src-dist-integrity", "Source-Dist Integrity", "Prevents direct file copying between src/ and dist/. All changes must be made in src/ and compiled via npm run build", "architecture", "error"],
+            // Security Rules
+            ["input-validation", "Input Validation Required", "Requires input validation for user-facing functions", "security", "warning"],
+            // Testing Rules
+            ["tests-required", "Tests Required for New Code", "Requires tests when creating new components or modifying functionality", "testing", "error"],
+            // Documentation Rules - Codex Term #46 (changed to warning to reduce false positives)
+            ["documentation-required", "Documentation Required (Codex Term #46)", "Requires comprehensive documentation for all new code, APIs, and architectural changes", "code-quality", "warning"],
+            // Codex Term #3: No Over-Engineering
+            ["no-over-engineering", "No Over-Engineering (Codex Term #3)", "Prevents over-engineering by enforcing simple, direct solutions without unnecessary abstractions", "architecture", "error"],
+            // Codex Term #7: Resolve All Errors
+            ["error-resolution", "Resolve All Errors (Codex Term #7)", "Ensures all runtime errors are properly handled and prevented", "architecture", "blocking"],
+            // Codex Term #8: Prevent Infinite Loops
+            ["loop-safety", "Prevent Infinite Loops (Codex Term #8)", "Ensures all loops have clear termination conditions", "architecture", "blocking"],
+            // Codex Term #41: State Management Patterns
+            ["state-management-patterns", "State Management Patterns (Codex Term #41)", "Ensures proper state management patterns are used throughout the application", "architecture", "high"],
+            // Codex Term #46: Import Consistency
+            ["import-consistency", "Import Consistency (Codex Term #46)", "Ensures consistent import patterns that work in both development and production environments", "architecture", "error"],
+            // Codex Term #24: Single Responsibility Principle
+            ["single-responsibility", "Single Responsibility Principle (Codex Term #24)", "Ensures each class/module has one reason to change", "architecture", "warning"],
+            // Codex Term #26: Test Coverage >85%
+            ["test-coverage", "Test Coverage >85% (Codex Term #26)", "Maintains 85%+ behavioral test coverage", "testing", "error"],
+            // Codex Term #29: Security by Design
+            ["security-by-design", "Security by Design (Codex Term #29)", "Validates all inputs (client and server) and sanitizes data", "security", "error"],
+            // Codex Term #36: Continuous Integration
+            ["continuous-integration", "Continuous Integration (Codex Term #36)", "Ensures automated testing and linting on every commit", "testing", "error"],
+            // Codex Term #43: Deployment Safety
+            ["deployment-safety", "Deployment Safety (Codex Term #43)", "Ensures zero-downtime deployments and rollback capability", "architecture", "blocking"],
+            // Development Triage Rule: Clean Debug Logs
+            ["clean-debug-logs", "Clean Debug Logs (Development Triage)", "Ensures debug logs are removed before production deployment", "code-quality", "error"],
+            // Reporting Rules
+            ["test-failure-reporting", "Test Failure Report Generation", "Automatically generates reports when tests fail", "reporting", "warning"],
+            ["performance-regression-reporting", "Performance Regression Report Generation", "Generates reports when performance regressions are detected", "reporting", "warning"],
+            ["security-vulnerability-reporting", "Security Vulnerability Report Generation", "Automatically reports security vulnerabilities found", "reporting", "error"],
+            // Phase 3: Multi-Agent Ensemble Rule
+            ["multi-agent-ensemble", "Multi-Agent Ensemble (Phase 3)", "Validates that multiple AI perspectives are considered in complex decisions", "architecture", "warning"],
+            // Phase 3: Substrate Pattern Externalization
+            ["substrate-externalization", "Substrate Externalization", "Validates that framework patterns mirror observed AI orchestration behaviors", "architecture", "info"],
+            // Phase 4: Self-Bootstrapping & Emergence Rules
+            ["framework-self-validation", "Framework Self-Validation", "Validates that the framework can validate and improve its own code", "architecture", "info"],
+            ["emergent-improvement", "Emergent Framework Improvement", "Validates that the framework can identify and suggest its own improvements", "architecture", "info"],
+            // Phase 4.1: Module System Consistency
+            ["module-system-consistency", "Module System Consistency", "Enforces consistent use of ES modules, preventing CommonJS/ES module mixing", "architecture", "error"],
+            // Console Log Usage Rule
+            ["console-log-usage", "Console Log Usage Restrictions", "Console.log must be used only for debugging in dev mode - retained logs must use framework logger", "code-quality", "error"],
+        ];
+        // Register all rules with validator delegates
+        for (const [id, name, description, category, severity] of ruleMetadata) {
+            this.addRule({
+                id,
+                name,
+                description,
+                category,
+                severity,
+                enabled: true,
+                validator: this.createValidatorDelegate(id),
+            });
+        }
+    }
+    /**
+     * Initialize rule hierarchy (prerequisites)
+     * Delegates to RuleHierarchy for dependency management
+     */
+    initializeRuleHierarchy() {
+        this.hierarchy.addDependency("tests-required", ["no-duplicate-code"]);
+        this.hierarchy.addDependency("context-analysis-integration", [
+            "tests-required",
+            "no-duplicate-code",
+        ]);
+        this.hierarchy.addDependency("memory-optimization", [
+            "context-analysis-integration",
+        ]);
+        this.hierarchy.addDependency("dependency-management", ["no-duplicate-code"]);
+        this.hierarchy.addDependency("input-validation", ["tests-required"]);
+        this.hierarchy.addDependency("documentation-required", ["tests-required"]);
+        this.hierarchy.addDependency("no-over-engineering", ["tests-required"]);
+    }
+    /**
+     * Load async rules in background using LoaderOrchestrator.
+     * Delegates to LoaderOrchestrator for rule loading.
+     */
+    async loadAsyncRules() {
+        try {
+            const orchestrator = new LoaderOrchestrator({
+                continueOnError: true,
+                enableLogging: true,
+            });
+            const result = await orchestrator.loadAllRules();
+            // Get existing rule IDs to prevent duplicates
+            const existingRuleIds = new Set(this.registry.getRules().map(r => r.id));
+            let addedCount = 0;
+            let skippedCount = 0;
+            // Register loaded rules, skipping duplicates
+            for (const rule of result.rules) {
+                if (existingRuleIds.has(rule.id)) {
+                    await frameworkLogger.log("rule-enforcer", "async-rule-skipped-duplicate", "info", { message: `Skipping duplicate rule: ${rule.id}` });
+                    skippedCount++;
+                    continue;
+                }
+                this.addRule(rule);
+                existingRuleIds.add(rule.id); // Add to prevent future duplicates in same batch
+                addedCount++;
+            }
+            this.initialized = true;
+            await frameworkLogger.log("rule-enforcer", "async-rules-loaded", "success", {
+                message: `Loaded ${addedCount} async rules (${skippedCount} duplicates skipped) from ${result.successfulLoaders} loaders`,
+                ruleCount: addedCount,
+                skippedCount,
+                successfulLoaders: result.successfulLoaders,
+                failedLoaders: result.failedLoaders
+            });
+        }
+        catch (error) {
+            // Silent failure - async rules may not load in all environments
+            await frameworkLogger.log("rule-enforcer", "async-rules-load-failed", "error", {
+                message: `Failed to load async rules: ${error instanceof Error ? error.message : String(error)}`,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    // ==================== PUBLIC API ====================
+    /**
+     * Add a rule to the enforcer
+     * Delegates to RuleRegistry for storage
+     */
+    addRule(rule) {
+        this.registry.addRule(rule);
+    }
+    /**
+     * Get all loaded rules
+     * Delegates to RuleRegistry for retrieval
+     */
+    getRules() {
+        return this.registry.getRules();
+    }
+    /**
+     * Get rule count
+     * Delegates to RuleRegistry for count
+     */
+    getRuleCount() {
+        return this.registry.getRuleCount();
+    }
+    /**
+     * Get rule by ID
+     * Delegates to RuleRegistry for retrieval
+     */
+    getRule(id) {
+        return this.registry.getRule(id);
+    }
+    /**
+     * Enable a rule by ID
+     * Delegates to RuleRegistry for state management
+     */
+    enableRule(ruleId) {
+        return this.registry.enableRule(ruleId);
+    }
+    /**
+     * Disable a rule by ID
+     * Delegates to RuleRegistry for state management
+     */
+    disableRule(ruleId) {
+        return this.registry.disableRule(ruleId);
+    }
+    /**
+     * Check if a rule is enabled
+     * Delegates to RuleRegistry for state check
+     */
+    isRuleEnabled(ruleId) {
+        return this.registry.isRuleEnabled(ruleId);
+    }
+    /**
+     * Get rule statistics
+     * Delegates to RuleRegistry for statistics
+     */
+    getRuleStats() {
+        return this.registry.getRuleStats();
+    }
+    /**
+     * Check if rule enforcer is fully initialized
+     */
+    isInitialized() {
+        return this.initialized;
+    }
+    /**
+     * Validate operation against all applicable rules
+     * Delegates to RuleExecutor for validation orchestration
+     */
+    async validateOperation(operation, context) {
+        // Ensure async rules are loaded
+        if (!this.initialized) {
+            await this.loadAsyncRules();
+        }
+        // Delegate to executor
+        return this.executor.execute(operation, context);
+    }
+    /**
+     * Attempt to fix rule violations by delegating to appropriate agents/skills
+     * Delegates to ViolationFixer for fix orchestration
+     */
+    async attemptRuleViolationFixes(violations, context) {
+        // Delegate to fixer
+        return this.fixer.fixViolations(violations, context);
+    }
+    // ==================== PRIVATE HELPER METHODS ====================
+    /**
+     * Creates a validator delegate function that looks up and calls the appropriate validator.
+     * Eliminates the need for 30+ individual wrapper methods.
+     */
+    createValidatorDelegate(ruleId) {
+        return async (context) => {
+            const validator = this.validatorRegistry.getValidator(ruleId);
+            if (!validator) {
+                return {
+                    passed: false,
+                    message: `Validator not found for rule: ${ruleId}`,
+                };
+            }
+            return validator.validate(context);
+        };
+    }
+}
+// Export singleton instance
+export const ruleEnforcer = new RuleEnforcer();