0xray 4.0.13 → 4.0.14

package/dist/enforcement/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Rule Enforcement Module
+ *
+ * This module provides rule enforcement capabilities for the 0xRay framework.
+ * It validates code against development rules and codex compliance requirements.
+ *
+ * @module enforcement
+ *
+ * @example
+ * ```typescript
+ * import { RuleEnforcer, RuleDefinition, ValidationReport } from './enforcement/index.js';
+ *
+ * const enforcer = new RuleEnforcer();
+ * const report = await enforcer.validateOperation('write', context);
+ * ```
+ */
+export { RuleEnforcer } from "./rule-enforcer.js";
+export { RuleRegistry, RuleHierarchy, RuleExecutor, ViolationFixer, } from "./core/index.js";
+export { RuleDefinition, RuleValidationContext, RuleValidationResult, ValidationReport, Violation, ViolationFix, RuleFix, RuleCategory, RuleSeverity, RuleFixType, IRuleRegistry, IValidator, IValidatorRegistry, IRuleHierarchy, IRuleExecutor, IViolationFixer, ExecutionOptions, BatchExecutionOptions, FixStrategy, isRuleValidationResult, } from "./types.js";
+export { BaseValidator, ValidatorRegistry, globalValidatorRegistry, NoDuplicateCodeValidator, ContextAnalysisIntegrationValidator, MemoryOptimizationValidator, DocumentationRequiredValidator, NoOverEngineeringValidator, CleanDebugLogsValidator, ConsoleLogUsageValidator, } from "./validators/index.js";
+export { BaseLoader, CodexLoader, AgentTriageLoader, ProcessorLoader, AgentsMdValidationLoader, LoaderOrchestrator, type LoaderOrchestratorOptions, type LoaderOrchestratorResult, } from "./loaders/index.js";
+export * as enforcerTools from "./enforcer-tools.js";

package/dist/enforcement/index.js

@@ -0,0 +1,40 @@
+/**
+ * Rule Enforcement Module
+ *
+ * This module provides rule enforcement capabilities for the 0xRay framework.
+ * It validates code against development rules and codex compliance requirements.
+ *
+ * @module enforcement
+ *
+ * @example
+ * ```typescript
+ * import { RuleEnforcer, RuleDefinition, ValidationReport } from './enforcement/index.js';
+ *
+ * const enforcer = new RuleEnforcer();
+ * const report = await enforcer.validateOperation('write', context);
+ * ```
+ */
+// Core enforcer
+export { RuleEnforcer } from "./rule-enforcer.js";
+// Core components (Phase 5 refactoring)
+export { RuleRegistry, RuleHierarchy, RuleExecutor, ViolationFixer, } from "./core/index.js";
+// All types
+export { isRuleValidationResult, } from "./types.js";
+// Validators (Phase 3 refactoring)
+export { 
+// Base class
+BaseValidator, 
+// Registry
+ValidatorRegistry, globalValidatorRegistry, 
+// Code quality validators
+NoDuplicateCodeValidator, ContextAnalysisIntegrationValidator, MemoryOptimizationValidator, DocumentationRequiredValidator, NoOverEngineeringValidator, CleanDebugLogsValidator, ConsoleLogUsageValidator, } from "./validators/index.js";
+// Loaders (Phase 4 refactoring)
+export { 
+// Base loader
+BaseLoader, 
+// Concrete loaders
+CodexLoader, AgentTriageLoader, ProcessorLoader, AgentsMdValidationLoader, 
+// Orchestrator
+LoaderOrchestrator, } from "./loaders/index.js";
+// Enforcer tools (if any exports exist)
+export * as enforcerTools from "./enforcer-tools.js";

package/dist/enforcement/loaders/agent-triage-loader.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Agent Triage Rule Loader
+ *
+ * Loads agent triage rules from AGENTS.md file.
+ * Extracts triage guidelines and converts them to RuleDefinition objects.
+ *
+ * Phase 4 refactoring: Extracted from RuleEnforcer.loadAgentTriageRules()
+ *
+ * @module loaders/agent-triage-loader
+ */
+import { BaseLoader } from "./base-loader.js";
+import { RuleDefinition } from "../types.js";
+/**
+ * Loader for agent triage rules from AGENTS.md.
+ * Parses the markdown file to extract triage guidelines.
+ *
+ * @example
+ * ```typescript
+ * const loader = new AgentTriageLoader();
+ * if (await loader.isAvailable()) {
+ *   const rules = await loader.load();
+ *   console.log(`Loaded ${rules.length} triage rules`);
+ * }
+ * ```
+ */
+export declare class AgentTriageLoader extends BaseLoader {
+    readonly name = "agent-triage";
+    /**
+     * Path to the AGENTS.md file.
+     */
+    private get agentsPath();
+    /**
+     * Check if AGENTS.md exists.
+     * @returns Promise resolving to true if AGENTS.md is available
+     */
+    isAvailable(): Promise<boolean>;
+    /**
+     * Load agent triage rules from AGENTS.md.
+     * @returns Promise resolving to array of rule definitions
+     */
+    load(): Promise<RuleDefinition[]>;
+    /**
+     * Extract the triage section from AGENTS.md content.
+     * @param content - Full content of AGENTS.md
+     * @returns Triage section content or null if not found
+     */
+    private extractTriageSection;
+    /**
+     * Extract additional rules from AGENTS.md content.
+     * @param content - Full content of AGENTS.md
+     * @returns Array of additional rule definitions
+     */
+    private extractAdditionalRules;
+    /**
+     * Create the triage commit status reporting rule.
+     * @returns RuleDefinition for triage commit status
+     */
+    private createTriageCommitStatusRule;
+    /**
+     * Create a reflection guideline rule.
+     * @returns RuleDefinition for reflection guidelines
+     */
+    private createReflectionGuidelineRule;
+    /**
+     * Create a complexity routing rule.
+     * @returns RuleDefinition for complexity routing
+     */
+    private createComplexityRoutingRule;
+    /**
+     * Create an agent invocation rule.
+     * @returns RuleDefinition for agent invocation
+     */
+    private createAgentInvocationRule;
+    /**
+     * Validate triage reporting requirements.
+     * @param context - Validation context
+     * @returns Validation result
+     */
+    private validateTriageReporting;
+    /**
+     * Validate reflection guidelines.
+     * @param context - Validation context
+     * @returns Validation result
+     */
+    private validateReflectionGuidelines;
+    /**
+     * Validate complexity routing.
+     * @param context - Validation context
+     * @returns Validation result
+     */
+    private validateComplexityRouting;
+    /**
+     * Validate agent invocation syntax.
+     * @param context - Validation context
+     * @returns Validation result
+     */
+    private validateAgentInvocation;
+}

package/dist/enforcement/loaders/agent-triage-loader.js

@@ -0,0 +1,221 @@
+/**
+ * Agent Triage Rule Loader
+ *
+ * Loads agent triage rules from AGENTS.md file.
+ * Extracts triage guidelines and converts them to RuleDefinition objects.
+ *
+ * Phase 4 refactoring: Extracted from RuleEnforcer.loadAgentTriageRules()
+ *
+ * @module loaders/agent-triage-loader
+ */
+import { frameworkLogger } from "../../core/framework-logger.js";
+import { BaseLoader } from "./base-loader.js";
+/**
+ * Loader for agent triage rules from AGENTS.md.
+ * Parses the markdown file to extract triage guidelines.
+ *
+ * @example
+ * ```typescript
+ * const loader = new AgentTriageLoader();
+ * if (await loader.isAvailable()) {
+ *   const rules = await loader.load();
+ *   console.log(`Loaded ${rules.length} triage rules`);
+ * }
+ * ```
+ */
+export class AgentTriageLoader extends BaseLoader {
+    name = "agent-triage";
+    /**
+     * Path to the AGENTS.md file.
+     */
+    get agentsPath() {
+        return this.resolvePath("AGENTS.md");
+    }
+    /**
+     * Check if AGENTS.md exists.
+     * @returns Promise resolving to true if AGENTS.md is available
+     */
+    async isAvailable() {
+        return this.fileExists(this.agentsPath);
+    }
+    /**
+     * Load agent triage rules from AGENTS.md.
+     * @returns Promise resolving to array of rule definitions
+     */
+    async load() {
+        const rules = [];
+        try {
+            const content = await this.readFile(this.agentsPath);
+            // Extract triage guidelines from AGENTS.md
+            const triageSection = this.extractTriageSection(content);
+            if (triageSection) {
+                // Create triage commit status reporting rule
+                rules.push(this.createTriageCommitStatusRule());
+                // Create additional triage rules based on AGENTS.md content
+                const additionalRules = this.extractAdditionalRules(content);
+                rules.push(...additionalRules);
+                await frameworkLogger.log("agent-triage-loader", "loaded-triage-rules", "success", {
+                    message: `Loaded ${rules.length} agent triage rules`,
+                    ruleCount: rules.length,
+                });
+            }
+        }
+        catch (error) {
+            await frameworkLogger.log("agent-triage-loader", "failed-to-load-triage", "error", {
+                message: `Failed to load agent triage rules: ${error instanceof Error ? error.message : String(error)}`,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+        return rules;
+    }
+    /**
+     * Extract the triage section from AGENTS.md content.
+     * @param content - Full content of AGENTS.md
+     * @returns Triage section content or null if not found
+     */
+    extractTriageSection(content) {
+        // Look for triage-related sections
+        const triagePatterns = [
+            /### Triage Summary Guidelines([\s\S]*?)(?=###|$)/,
+            /### Agent Triage([\s\S]*?)(?=###|$)/,
+            /### Triage([\s\S]*?)(?=###|$)/,
+            /## Triage([\s\S]*?)(?=##|$)/,
+        ];
+        for (const pattern of triagePatterns) {
+            const match = content.match(pattern);
+            if (match && match[1]) {
+                return match[1].trim();
+            }
+        }
+        return null;
+    }
+    /**
+     * Extract additional rules from AGENTS.md content.
+     * @param content - Full content of AGENTS.md
+     * @returns Array of additional rule definitions
+     */
+    extractAdditionalRules(content) {
+        const rules = [];
+        // Check for reflection guidelines
+        if (content.includes("reflection") || content.includes("Reflection")) {
+            rules.push(this.createReflectionGuidelineRule());
+        }
+        // Check for complexity routing
+        if (content.includes("complexity") ||
+            content.includes("routing") ||
+            content.includes("Complexity")) {
+            rules.push(this.createComplexityRoutingRule());
+        }
+        // Check for agent invocation patterns
+        if (content.includes("@") || content.includes("invoke")) {
+            rules.push(this.createAgentInvocationRule());
+        }
+        return rules;
+    }
+    /**
+     * Create the triage commit status reporting rule.
+     * @returns RuleDefinition for triage commit status
+     */
+    createTriageCommitStatusRule() {
+        return {
+            id: "agent-triage-commit-status",
+            name: "Triage Commit Status Reporting",
+            description: "When providing triage summaries after build error resolution or major changes, ALWAYS explicitly state the commit status (successful/failed) to avoid confusion",
+            category: "reporting",
+            severity: "info",
+            enabled: true,
+            validator: this.validateTriageReporting.bind(this),
+        };
+    }
+    /**
+     * Create a reflection guideline rule.
+     * @returns RuleDefinition for reflection guidelines
+     */
+    createReflectionGuidelineRule() {
+        return {
+            id: "agent-triage-reflection-guidelines",
+            name: "Triage Reflection Guidelines",
+            description: "Complex investigations and multi-session work should be documented in deep reflections",
+            category: "reporting",
+            severity: "info",
+            enabled: true,
+            validator: this.validateReflectionGuidelines.bind(this),
+        };
+    }
+    /**
+     * Create a complexity routing rule.
+     * @returns RuleDefinition for complexity routing
+     */
+    createComplexityRoutingRule() {
+        return {
+            id: "agent-triage-complexity-routing",
+            name: "Complexity-Based Agent Routing",
+            description: "Tasks should be routed to appropriate agents based on complexity level",
+            category: "architecture",
+            severity: "info",
+            enabled: true,
+            validator: this.validateComplexityRouting.bind(this),
+        };
+    }
+    /**
+     * Create an agent invocation rule.
+     * @returns RuleDefinition for agent invocation
+     */
+    createAgentInvocationRule() {
+        return {
+            id: "agent-triage-invocation-syntax",
+            name: "Agent Invocation Syntax",
+            description: "Use @agent-name syntax in prompts or code comments to invoke agents",
+            category: "code-quality",
+            severity: "info",
+            enabled: true,
+            validator: this.validateAgentInvocation.bind(this),
+        };
+    }
+    /**
+     * Validate triage reporting requirements.
+     * @param context - Validation context
+     * @returns Validation result
+     */
+    async validateTriageReporting(context) {
+        // This rule validates that triage summaries include commit status
+        // Would be checked during reporting operations
+        return {
+            passed: true,
+            message: "Triage reporting guidelines enforced",
+        };
+    }
+    /**
+     * Validate reflection guidelines.
+     * @param context - Validation context
+     * @returns Validation result
+     */
+    async validateReflectionGuidelines(context) {
+        return {
+            passed: true,
+            message: "Reflection guidelines available",
+        };
+    }
+    /**
+     * Validate complexity routing.
+     * @param context - Validation context
+     * @returns Validation result
+     */
+    async validateComplexityRouting(context) {
+        return {
+            passed: true,
+            message: "Complexity routing guidelines available",
+        };
+    }
+    /**
+     * Validate agent invocation syntax.
+     * @param context - Validation context
+     * @returns Validation result
+     */
+    async validateAgentInvocation(context) {
+        return {
+            passed: true,
+            message: "Agent invocation syntax guidelines available",
+        };
+    }
+}

package/dist/enforcement/loaders/agents-md-validation-loader.d.ts

@@ -0,0 +1,75 @@
+/**
+ * AGENTS.md Validation Rule Loader
+ *
+ * Loads validation rules for AGENTS.md file existence and currency.
+ * Ensures that AGENTS.md exists and is properly maintained.
+ *
+ * Phase 4 refactoring: Extracted from RuleEnforcer.loadAgentsMdValidationRule()
+ *
+ * @module loaders/agents-md-validation-loader
+ */
+import { BaseLoader } from "./base-loader.js";
+import { RuleDefinition } from "../types.js";
+/**
+ * Loader for AGENTS.md validation rules.
+ * Creates rules that validate AGENTS.md existence and currency.
+ *
+ * @example
+ * ```typescript
+ * const loader = new AgentsMdValidationLoader();
+ * if (await loader.isAvailable()) {
+ *   const rules = await loader.load();
+ *   console.log(`Loaded ${rules.length} AGENTS.md validation rules`);
+ * }
+ * ```
+ */
+export declare class AgentsMdValidationLoader extends BaseLoader {
+    readonly name = "agents-md-validation";
+    /**
+     * Path to the AGENTS.md file.
+     */
+    private get agentsPath();
+    /**
+     * Check if AGENTS.md exists.
+     * @returns Promise resolving to true if AGENTS.md is available
+     */
+    isAvailable(): Promise<boolean>;
+    /**
+     * Load AGENTS.md validation rules.
+     * @returns Promise resolving to array of rule definitions
+     */
+    load(): Promise<RuleDefinition[]>;
+    /**
+     * Create AGENTS.md existence rule.
+     * @returns RuleDefinition for AGENTS.md existence
+     */
+    private createAgentsMdExistsRule;
+    /**
+     * Create AGENTS.md currency rule.
+     * @returns RuleDefinition for AGENTS.md currency
+     */
+    private createAgentsMdCurrentRule;
+    /**
+     * Create AGENTS.md structure rule.
+     * @returns RuleDefinition for AGENTS.md structure
+     */
+    private createAgentsMdStructureRule;
+    /**
+     * Validate that AGENTS.md exists.
+     * @param context - Validation context
+     * @returns Validation result
+     */
+    private validateAgentsMdExists;
+    /**
+     * Validate that AGENTS.md is current (updated within 30 days).
+     * @param context - Validation context
+     * @returns Validation result
+     */
+    private validateAgentsMdCurrent;
+    /**
+     * Validate AGENTS.md structure.
+     * @param context - Validation context
+     * @returns Validation result
+     */
+    private validateAgentsMdStructure;
+}