0xray 2.0.0

package/dist/enforcement/core/index.js

@@ -0,0 +1,19 @@
+/**
+ * Rule Enforcement Core Components
+ *
+ * This module exports the core components of the rule enforcement system.
+ * These components handle rule storage, hierarchy, execution, and fixing.
+ *
+ * Phase 5 refactoring: Extracted from RuleEnforcer.
+ *
+ * @module enforcement/core
+ * @version 1.0.0
+ */
+// Rule storage and management
+export { RuleRegistry } from './rule-registry.js';
+// Rule dependency management
+export { RuleHierarchy } from './rule-hierarchy.js';
+// Validation execution orchestration
+export { RuleExecutor } from './rule-executor.js';
+// Violation fix delegation
+export { ViolationFixer } from './violation-fixer.js';

package/dist/enforcement/core/rule-executor.js

@@ -0,0 +1,365 @@
+/**
+ * Rule Executor - Orchestrate validation execution
+ *
+ * This class orchestrates the execution of validation rules, handling
+ * single rule execution, batch execution, parallel vs serial execution,
+ * dependency ordering, timeouts, and error handling.
+ *
+ * Phase 5 refactoring: Extracted from RuleEnforcer.
+ *
+ * @module enforcement/core
+ * @version 1.0.0
+ *
+ * @example
+ * ```typescript
+ * const executor = new RuleExecutor(registry, hierarchy, validatorRegistry);
+ *
+ * // Execute all applicable rules for an operation
+ * const report = await executor.execute('write', context);
+ *
+ * // Execute a specific rule
+ * const result = await executor.executeSingle('no-duplicate-code', context);
+ *
+ * // Execute multiple rules in batch
+ * const results = await executor.executeBatch(['rule1', 'rule2'], context);
+ * ```
+ */
+import { frameworkLogger } from '../../core/framework-logger.js';
+import { isRuleValidationResult, } from '../types.js';
+/**
+ * RuleExecutor orchestrates the execution of validation rules.
+ *
+ * Key responsibilities:
+ * - Execute single rules
+ * - Execute rules in batch (parallel or serial)
+ * - Sort rules by dependency order
+ * - Handle timeouts and errors
+ * - Generate validation reports
+ */
+export class RuleExecutor {
+    registry;
+    hierarchy;
+    validatorRegistry;
+    /** Default timeout for rule validation in milliseconds */
+    DEFAULT_TIMEOUT_MS = 30000;
+    constructor(registry, hierarchy, validatorRegistry) {
+        this.registry = registry;
+        this.hierarchy = hierarchy;
+        this.validatorRegistry = validatorRegistry;
+    }
+    /**
+     * Execute validation for an operation against all applicable rules.
+     *
+     * This method:
+     * 1. Gets all applicable rules for the operation
+     * 2. Sorts them by dependency order
+     * 3. Executes each rule
+     * 4. Collects results and generates a validation report
+     *
+     * @param operation - The operation being performed (e.g., 'write', 'create')
+     * @param context - Validation context with code and operation info
+     * @param options - Optional execution options
+     * @returns Promise resolving to validation report
+     *
+     * @example
+     * ```typescript
+     * const report = await executor.execute('write', {
+     *   operation: 'write',
+     *   files: ['src/index.ts'],
+     *   newCode: 'console.log("hello");'
+     * });
+     *
+     * console.log(report.passed); // false if any rule failed
+     * console.log(report.errors); // Array of error messages
+     * ```
+     */
+    async execute(operation, context, options) {
+        const applicableRules = this.getApplicableRules(operation, context);
+        await frameworkLogger.log('rule-executor', 'execute-start', 'info', {
+            operation,
+            ruleCount: applicableRules.length,
+            rules: applicableRules.map(r => r.id),
+        });
+        const results = [];
+        const errors = [];
+        const warnings = [];
+        // Always sort rules by dependency order for execute()
+        const sortedRules = this.sortByDependencyOrder(applicableRules);
+        // Execute rules
+        if (options?.parallel) {
+            // Execute in parallel
+            const batchResults = await this.executeParallel(sortedRules, context, options);
+            this.processResults(batchResults, sortedRules, results, errors, warnings);
+        }
+        else {
+            // Execute serially
+            const executedRules = new Set();
+            for (const rule of sortedRules) {
+                // Check if dependencies are satisfied
+                if (!this.hierarchy.isDependencySatisfied(rule.id, executedRules)) {
+                    const deps = this.hierarchy.getDependencies(rule.id);
+                    warnings.push(`${rule.id}: dependencies not satisfied (requires: ${deps.join(', ')})`);
+                    executedRules.add(rule.id);
+                    continue;
+                }
+                try {
+                    const result = await this.executeRuleWithTimeout(rule, context, options?.timeoutMs || this.DEFAULT_TIMEOUT_MS);
+                    this.processResult(result, rule, results, errors, warnings);
+                    executedRules.add(rule.id);
+                    // Stop on first error if requested
+                    if (options?.stopOnError && errors.length > 0) {
+                        break;
+                    }
+                }
+                catch (error) {
+                    const errorMessage = `Rule ${rule.name} failed: ${error instanceof Error ? error.message : String(error)}`;
+                    errors.push(errorMessage);
+                    executedRules.add(rule.id);
+                    await frameworkLogger.log('rule-executor', 'rule-execution-error', 'error', {
+                        ruleId: rule.id,
+                        operation,
+                        error: errorMessage,
+                    });
+                    // Stop on first error if requested
+                    if (options?.stopOnError) {
+                        break;
+                    }
+                }
+            }
+        }
+        const report = {
+            operation,
+            passed: errors.length === 0,
+            errors,
+            warnings,
+            results,
+            timestamp: new Date(),
+        };
+        await frameworkLogger.log('rule-executor', 'execute-complete', report.passed ? 'success' : 'error', {
+            operation,
+            passed: report.passed,
+            errorCount: errors.length,
+            warningCount: warnings.length,
+        });
+        return report;
+    }
+    /**
+     * Execute a single rule by ID.
+     *
+     * @param ruleId - The ID of the rule to execute
+     * @param context - Validation context
+     * @returns Promise resolving to validation result
+     * @throws Error if rule not found or not enabled
+     *
+     * @example
+     * ```typescript
+     * const result = await executor.executeSingle('no-duplicate-code', context);
+     * console.log(result.passed); // true or false
+     * ```
+     */
+    async executeSingle(ruleId, context) {
+        const rule = this.registry.getRule(ruleId);
+        if (!rule) {
+            throw new Error(`Rule with ID "${ruleId}" not found`);
+        }
+        if (!rule.enabled) {
+            throw new Error(`Rule "${ruleId}" is disabled`);
+        }
+        return this.executeRuleWithTimeout(rule, context, this.DEFAULT_TIMEOUT_MS);
+    }
+    /**
+     * Execute multiple rules in batch.
+     *
+     * Supports parallel or serial execution based on options.
+     * Optionally sorts rules by dependency order before execution.
+     *
+     * @param ruleIds - Array of rule IDs to execute
+     * @param context - Validation context
+     * @param options - Optional batch execution options
+     * @returns Promise resolving to array of validation results
+     *
+     * @example
+     * ```typescript
+     * const results = await executor.executeBatch(
+     *   ['no-duplicate-code', 'tests-required'],
+     *   context,
+     *   { parallel: true, sortByDependencies: true }
+     * );
+     * ```
+     */
+    async executeBatch(ruleIds, context, options) {
+        // Get rule definitions
+        const rules = [];
+        for (const id of ruleIds) {
+            const rule = this.registry.getRule(id);
+            if (rule && rule.enabled) {
+                rules.push(rule);
+            }
+        }
+        // Sort by dependencies if requested
+        const sortedRules = options?.sortByDependencies !== false
+            ? this.sortByDependencyOrder(rules)
+            : rules;
+        if (options?.parallel) {
+            return this.executeParallel(sortedRules, context, options);
+        }
+        else {
+            const results = [];
+            for (const rule of sortedRules) {
+                const result = await this.executeRuleWithTimeout(rule, context, options?.timeoutMs || this.DEFAULT_TIMEOUT_MS);
+                results.push(result);
+                if (options?.stopOnError && !result.passed) {
+                    break;
+                }
+            }
+            return results;
+        }
+    }
+    /**
+     * Execute a rule with timeout protection.
+     *
+     * @param rule - The rule definition to execute
+     * @param context - Validation context
+     * @param timeoutMs - Timeout in milliseconds
+     * @returns Promise resolving to validation result
+     */
+    async executeRuleWithTimeout(rule, context, timeoutMs) {
+        return new Promise((resolve, reject) => {
+            const timeoutId = setTimeout(() => {
+                reject(new Error(`Rule ${rule.id} timed out after ${timeoutMs}ms`));
+            }, timeoutMs);
+            rule.validator(context)
+                .then(result => {
+                clearTimeout(timeoutId);
+                resolve(result);
+            })
+                .catch(error => {
+                clearTimeout(timeoutId);
+                reject(error);
+            });
+        });
+    }
+    /**
+     * Execute rules in parallel.
+     *
+     * @param rules - Array of rules to execute
+     * @param context - Validation context
+     * @param options - Execution options
+     * @returns Promise resolving to array of results
+     */
+    async executeParallel(rules, context, options) {
+        const concurrency = options?.concurrency || rules.length;
+        const results = [];
+        // Process in chunks based on concurrency limit
+        for (let i = 0; i < rules.length; i += concurrency) {
+            const chunk = rules.slice(i, i + concurrency);
+            const chunkPromises = chunk.map(rule => this.executeRuleWithTimeout(rule, context, options?.timeoutMs || this.DEFAULT_TIMEOUT_MS).catch(error => ({
+                passed: false,
+                message: `Rule ${rule.id} failed: ${error instanceof Error ? error.message : String(error)}`,
+            })));
+            const chunkResults = await Promise.all(chunkPromises);
+            results.push(...chunkResults);
+            // Stop on first error if requested
+            if (options?.stopOnError && chunkResults.some(r => !r.passed)) {
+                break;
+            }
+        }
+        return results;
+    }
+    /**
+     * Sort rules by dependency order using the hierarchy.
+     *
+     * @param rules - Array of rules to sort
+     * @returns Sorted array of rules
+     */
+    sortByDependencyOrder(rules) {
+        const ruleIds = rules.map(r => r.id);
+        const orderedIds = this.hierarchy.getExecutionOrder(ruleIds);
+        // Map ordered IDs back to rule definitions
+        const ruleMap = new Map(rules.map(r => [r.id, r]));
+        return orderedIds
+            .map(id => ruleMap.get(id))
+            .filter((r) => r !== undefined);
+    }
+    /**
+     * Process a single result and categorize errors/warnings.
+     */
+    processResult(result, rule, results, errors, warnings) {
+        if (isRuleValidationResult(result) && result.passed === false) {
+            results.push(result);
+            if (rule.severity === 'error' || rule.severity === 'blocking' || rule.severity === 'high') {
+                errors.push(`${rule.name}: ${result.message}`);
+            }
+            else if (rule.severity === 'warning') {
+                warnings.push(`${rule.name}: ${result.message}`);
+            }
+        }
+    }
+    /**
+     * Process multiple results and categorize errors/warnings.
+     */
+    processResults(batchResults, rules, results, errors, warnings) {
+        batchResults.forEach((result, index) => {
+            const rule = rules[index];
+            if (rule && isRuleValidationResult(result) && result.passed === false) {
+                results.push(result);
+                if (rule.severity === 'error' || rule.severity === 'blocking' || rule.severity === 'high') {
+                    errors.push(`${rule.name}: ${result.message}`);
+                }
+                else if (rule.severity === 'warning') {
+                    warnings.push(`${rule.name}: ${result.message}`);
+                }
+            }
+        });
+    }
+    /**
+     * Get applicable rules for an operation and context.
+     *
+     * @param operation - The operation being performed
+     * @param context - Validation context
+     * @returns Array of applicable rule definitions
+     */
+    getApplicableRules(operation, context) {
+        return this.registry.getRules().filter(rule => this.isRuleApplicable(rule, operation, context));
+    }
+    /**
+     * Check if a rule is applicable to the current operation.
+     *
+     * @param rule - The rule definition
+     * @param operation - The operation being performed
+     * @param context - Validation context
+     * @returns true if the rule is applicable
+     */
+    isRuleApplicable(rule, operation, context) {
+        if (!rule.enabled)
+            return false;
+        // Check operation type for specific rules
+        switch (rule.id) {
+            case 'tests-required':
+                return operation === 'write' || operation === 'create';
+            case 'no-duplicate-code':
+                return operation === 'write' && !!context.newCode;
+            case 'no-over-engineering':
+                return operation === 'write' && !!context.newCode;
+            case 'resolve-all-errors':
+                return operation === 'write' && !!context.newCode;
+            case 'prevent-infinite-loops':
+                return operation === 'write' && !!context.newCode;
+            case 'state-management-patterns':
+                return operation === 'write' && !!context.newCode;
+            case 'import-consistency':
+                return operation === 'write' && !!context.newCode;
+            case 'documentation-required':
+                return operation === 'write' || operation === 'modify';
+            case 'clean-debug-logs':
+                return operation === 'write' && !!context.newCode;
+            case 'console-log-usage':
+                return operation === 'write' && !!context.newCode;
+            case 'src-dist-integrity':
+                return ((operation === 'write' || operation === 'copy' || operation === 'modify') &&
+                    !!context.files);
+            default:
+                return true;
+        }
+    }
+}

package/dist/enforcement/core/rule-hierarchy.js

@@ -0,0 +1,259 @@
+/**
+ * Rule Hierarchy - Manage rule dependencies and execution order
+ *
+ * This class manages rule dependencies and calculates execution order.
+ * It uses topological sorting to ensure dependencies are validated before dependents.
+ *
+ * Phase 5 refactoring: Extracted from RuleEnforcer.
+ *
+ * @module enforcement/core
+ * @version 1.0.0
+ *
+ * @example
+ * ```typescript
+ * const hierarchy = new RuleHierarchy();
+ * hierarchy.addDependency('tests-required', ['no-duplicate-code']);
+ * hierarchy.addDependency('memory-optimization', ['context-analysis-integration']);
+ *
+ * const order = hierarchy.getExecutionOrder(['tests-required', 'memory-optimization']);
+ * // Result: ['no-duplicate-code', 'tests-required', 'context-analysis-integration', 'memory-optimization']
+ * ```
+ */
+/**
+ * RuleHierarchy manages rule dependency relationships and execution ordering.
+ *
+ * Key responsibilities:
+ * - Track rule dependencies (A depends on B)
+ * - Calculate execution order via topological sort
+ * - Detect circular dependencies
+ * - Check dependency satisfaction
+ */
+export class RuleHierarchy {
+    /** Map of rule IDs to their dependencies */
+    dependencies = new Map();
+    /** Map of rule IDs to rules that depend on them */
+    dependents = new Map();
+    /**
+     * Add a dependency relationship.
+     * The rule will be executed after all its dependencies.
+     *
+     * @param ruleId - The rule that depends on others
+     * @param dependsOn - Array of rule IDs that must be executed first
+     *
+     * @example
+     * ```typescript
+     * hierarchy.addDependency('tests-required', ['no-duplicate-code']);
+     * // tests-required will be validated after no-duplicate-code
+     * ```
+     */
+    addDependency(ruleId, dependsOn) {
+        // Add forward dependency relationship
+        if (!this.dependencies.has(ruleId)) {
+            this.dependencies.set(ruleId, new Set());
+        }
+        dependsOn.forEach(dep => this.dependencies.get(ruleId).add(dep));
+        // Track reverse relationship (dependents)
+        dependsOn.forEach(dep => {
+            if (!this.dependents.has(dep)) {
+                this.dependents.set(dep, new Set());
+            }
+            this.dependents.get(dep).add(ruleId);
+        });
+    }
+    /**
+     * Get all dependencies for a rule.
+     *
+     * @param ruleId - The rule to get dependencies for
+     * @returns Array of rule IDs that the rule depends on
+     *
+     * @example
+     * ```typescript
+     * const deps = hierarchy.getDependencies('tests-required');
+     * console.log(deps); // ['no-duplicate-code']
+     * ```
+     */
+    getDependencies(ruleId) {
+        const deps = this.dependencies.get(ruleId);
+        return deps ? Array.from(deps) : [];
+    }
+    /**
+     * Get all rules that depend on the given rule.
+     *
+     * @param ruleId - The rule to get dependents for
+     * @returns Array of rule IDs that depend on this rule
+     *
+     * @example
+     * ```typescript
+     * const dependents = hierarchy.getDependents('no-duplicate-code');
+     * console.log(dependents); // ['tests-required']
+     * ```
+     */
+    getDependents(ruleId) {
+        const deps = this.dependents.get(ruleId);
+        return deps ? Array.from(deps) : [];
+    }
+    /**
+     * Get the execution order for a set of rules using topological sort.
+     * Rules are returned in order such that dependencies come before dependents.
+     *
+     * Uses Kahn's algorithm for topological sorting.
+     *
+     * @param ruleIds - Array of rule IDs to order
+     * @returns Sorted array of rule IDs in dependency order
+     *
+     * @example
+     * ```typescript
+     * const order = hierarchy.getExecutionOrder(['tests-required', 'no-duplicate-code']);
+     * // Result: ['no-duplicate-code', 'tests-required']
+     * ```
+     */
+    getExecutionOrder(ruleIds) {
+        if (ruleIds.length === 0)
+            return [];
+        // Build in-degree map for rules in the set
+        const inDegree = new Map();
+        const adjacencyList = new Map();
+        // Initialize
+        ruleIds.forEach(id => {
+            inDegree.set(id, 0);
+            adjacencyList.set(id, new Set());
+        });
+        // Calculate in-degrees and adjacency list
+        ruleIds.forEach(id => {
+            const deps = this.getDependencies(id);
+            deps.forEach(dep => {
+                // Only count dependencies that are in the rule set
+                if (ruleIds.includes(dep)) {
+                    inDegree.set(id, (inDegree.get(id) || 0) + 1);
+                    adjacencyList.get(dep).add(id);
+                }
+            });
+        });
+        // Kahn's algorithm
+        const result = [];
+        const queue = [];
+        // Start with nodes that have no dependencies
+        inDegree.forEach((degree, id) => {
+            if (degree === 0)
+                queue.push(id);
+        });
+        while (queue.length > 0) {
+            const current = queue.shift();
+            result.push(current);
+            const dependents = adjacencyList.get(current) || new Set();
+            dependents.forEach(dependent => {
+                const newDegree = (inDegree.get(dependent) || 0) - 1;
+                inDegree.set(dependent, newDegree);
+                if (newDegree === 0) {
+                    queue.push(dependent);
+                }
+            });
+        }
+        // If not all rules were processed, there's a circular dependency
+        if (result.length !== ruleIds.length) {
+            // Return rules in original order if topological sort fails
+            // This ensures we still execute rules even with cycles
+            return [...ruleIds];
+        }
+        return result;
+    }
+    /**
+     * Check if any circular dependencies exist in the hierarchy.
+     *
+     * @returns true if circular dependencies exist, false otherwise
+     *
+     * @example
+     * ```typescript
+     * if (hierarchy.hasCircularDependencies()) {
+     *   console.error('Circular dependencies detected!');
+     * }
+     * ```
+     */
+    hasCircularDependencies() {
+        return this.findCircularDependencies().length > 0;
+    }
+    /**
+     * Find all circular dependency cycles.
+     * Uses DFS to detect cycles in the dependency graph.
+     *
+     * @returns Array of cycles, where each cycle is an array of rule IDs
+     *
+     * @example
+     * ```typescript
+     * const cycles = hierarchy.findCircularDependencies();
+     * // cycles might be [['rule-a', 'rule-b', 'rule-c']]
+     * ```
+     */
+    findCircularDependencies() {
+        const cycles = [];
+        const visited = new Set();
+        const recursionStack = new Set();
+        const dfs = (node, path) => {
+            if (recursionStack.has(node)) {
+                // Found a cycle
+                const cycleStart = path.indexOf(node);
+                if (cycleStart !== -1) {
+                    const cycle = path.slice(cycleStart);
+                    cycles.push(cycle);
+                }
+                return;
+            }
+            if (visited.has(node)) {
+                return;
+            }
+            visited.add(node);
+            recursionStack.add(node);
+            path.push(node);
+            const deps = this.getDependencies(node);
+            deps.forEach(dep => {
+                dfs(dep, [...path]);
+            });
+            recursionStack.delete(node);
+        };
+        // Check all nodes
+        this.dependencies.forEach((_, ruleId) => {
+            if (!visited.has(ruleId)) {
+                dfs(ruleId, []);
+            }
+        });
+        return cycles;
+    }
+    /**
+     * Check if all dependencies for a rule have been executed.
+     *
+     * @param ruleId - The rule to check
+     * @param executedRules - Set of rule IDs that have already been executed
+     * @returns true if all dependencies are satisfied, false otherwise
+     *
+     * @example
+     * ```typescript
+     * const executed = new Set(['no-duplicate-code']);
+     * if (hierarchy.isDependencySatisfied('tests-required', executed)) {
+     *   // Safe to execute tests-required
+     * }
+     * ```
+     */
+    isDependencySatisfied(ruleId, executedRules) {
+        const deps = this.getDependencies(ruleId);
+        return deps.every(dep => executedRules.has(dep));
+    }
+    /**
+     * Clear all dependency relationships.
+     * Useful for testing or reinitializing.
+     */
+    clear() {
+        this.dependencies.clear();
+        this.dependents.clear();
+    }
+    /**
+     * Get all rules that have dependencies registered.
+     *
+     * @returns Array of rule IDs with dependencies
+     */
+    getAllRules() {
+        const rules = new Set();
+        this.dependencies.forEach((_, ruleId) => rules.add(ruleId));
+        this.dependents.forEach((_, ruleId) => rules.add(ruleId));
+        return Array.from(rules);
+    }
+}