0xray 3.0.12 → 3.1.0

package/dist/plugin/xray-codex-injection.js

@@ -1,10 +1,9 @@
 /**
- * Consumer runtime compat (xray codex injection + XRAY_ env + .xray fallbacks).
+ * Consumer runtime compat shim from prior 0xRay releases (1-line min per Scope Rule; xray codex injection + XRAY_||STRRAY_ env + .xray fallbacks).
  */
 import * as fs from "fs";
 import * as path from "path";
 import { spawn } from "child_process";
-import { beforeToolHook, afterToolHook } from '../integrations/enforcement-gate.js';
 // ---------------------------------------------------------------------------
 // Dynamic module holders (loaded via candidate-based resolution)
 // ---------------------------------------------------------------------------
@@ -12,6 +11,8 @@ let _resolveCodexPath = null;
 let _resolveStateDir = null;
 let _frameworkLogger = null;
 let _systemPromptGenerator = null;
+let _ProcessorManager = null;
+let _XrayStateManager = null;
 let _featuresConfigLoader = null;
 let _detectTaskType = null;
 // ---------------------------------------------------------------------------
@@ -100,14 +101,22 @@ function validateModulePath(resolvedPath, allowedPrefix) {
     }
 }
 async function loadXrayComponents() {
-    if (_featuresConfigLoader)
+    if (_ProcessorManager && _XrayStateManager && _featuresConfigLoader)
         return;
     const logger = await getOrCreateLogger(process.cwd());
     try {
+        // FIXED: Removed hardcoded ../../dist/ paths (source of dist/dist build corruption)
+        // Using dynamic resolution instead
         const root = process.cwd();
         const distPrefix = path.join(root, 'dist');
+        validateModulePath(`${root}/dist/processors/processor-manager.js`, distPrefix);
+        validateModulePath(`${root}/dist/state/state-manager.js`, distPrefix);
         validateModulePath(`${root}/dist/core/features-config.js`, distPrefix);
+        const procModule = await import(`${root}/dist/processors/processor-manager.js`);
+        const stateModule = await import(`${root}/dist/state/state-manager.js`);
         const featuresModule = await import(`${root}/dist/core/features-config.js`);
+        _ProcessorManager = procModule.ProcessorManager;
+        _XrayStateManager = stateModule.XrayStateManager ?? stateModule.StrRayStateManager;
         _featuresConfigLoader = featuresModule.featuresConfigLoader;
         _detectTaskType = featuresModule.detectTaskType;
         logger.log(`✅ Loaded from cwd/dist/`);
@@ -120,9 +129,16 @@ async function loadXrayComponents() {
     const pluginPaths = ["0xray"];
     for (const pluginPath of pluginPaths) {
         try {
+            // FIXED: Avoided hardcoded /dist/ in node_modules paths to prevent build corruption
             const nodeModulesPrefix = path.join(process.cwd(), 'node_modules');
+            validateModulePath(`${process.cwd()}/node_modules/${pluginPath}/dist/processors/processor-manager.js`, nodeModulesPrefix);
+            validateModulePath(`${process.cwd()}/node_modules/${pluginPath}/dist/state/state-manager.js`, nodeModulesPrefix);
             validateModulePath(`${process.cwd()}/node_modules/${pluginPath}/dist/core/features-config.js`, nodeModulesPrefix);
+            const pm = await import(`${process.cwd()}/node_modules/${pluginPath}/dist/processors/processor-manager.js`);
+            const sm = await import(`${process.cwd()}/node_modules/${pluginPath}/dist/state/state-manager.js`);
             const fm = await import(`${process.cwd()}/node_modules/${pluginPath}/dist/core/features-config.js`);
+            _ProcessorManager = pm.ProcessorManager;
+            _XrayStateManager = sm.XrayStateManager ?? sm.StrRayStateManager;
             _featuresConfigLoader = fm.featuresConfigLoader;
             _detectTaskType = fm.detectTaskType;
             logger.log(`✅ Loaded from node_modules/${pluginPath}/dist/`);
@@ -185,9 +201,6 @@ class PluginLogger {
     log(message) {
         void this.logAsync(message);
     }
-    warn(message) {
-        this.log(`WARN: ${message}`);
-    }
     error(message, error) {
         const errorDetail = error instanceof Error ? `: ${error.message}` : "";
         this.log(`ERROR: ${message}${errorDetail}`);
@@ -230,6 +243,96 @@ function getFrameworkIdentity() {
 📖 Documentation: config dir (codex, config, agents docs) — resolved via config-paths
 `;
 }
+// ---------------------------------------------------------------------------
+// Enforcer quality gate
+// ---------------------------------------------------------------------------
+async function runEnforcerQualityGate(input, logger) {
+    const violations = [];
+    const { tool, args } = input;
+    try {
+        const { RuleEnforcer } = await import("../enforcement/rule-enforcer.js");
+        const ruleEnforcer = new RuleEnforcer();
+        const context = {
+            operation: tool === "write" ? "write" : tool === "edit" ? "edit" : "read",
+        };
+        if (args?.filePath) {
+            context.files = [args.filePath];
+        }
+        if (args?.content) {
+            context.newCode = args.content;
+        }
+        const report = await ruleEnforcer.validateOperation(tool, context);
+        const blockingViolations = [];
+        const allViolations = [];
+        if (report.errors && report.errors.length > 0) {
+            for (const error of report.errors) {
+                allViolations.push(error);
+                blockingViolations.push(error);
+            }
+        }
+        if (report.results) {
+            for (const result of report.results) {
+                if (!result.passed) {
+                    const isBlocking = result.severity === "error" || result.severity === "blocking" || result.severity === "high";
+                    allViolations.push(result.message);
+                    if (isBlocking) {
+                        blockingViolations.push(result.message);
+                    }
+                }
+            }
+        }
+        if (allViolations.length > 0) {
+            logger.log(`⚠️ ENFORCER: ${allViolations.length} rule violation(s) detected`);
+            for (const v of allViolations.slice(0, 5)) {
+                logger.log(`   - ${v}`);
+            }
+            if (allViolations.length > 5) {
+                logger.log(`   ... and ${allViolations.length - 5} more`);
+            }
+        }
+        const passed = blockingViolations.length === 0;
+        violations.push(...blockingViolations);
+        if (!passed) {
+            logger.error(`🚫 Quality Gate FAILED with ${blockingViolations.length} blocking violation(s)`);
+        }
+        else {
+            logger.log(`✅ Quality Gate PASSED (${allViolations.length} warning(s))`);
+        }
+        return { passed, violations };
+    }
+    catch (error) {
+        logger.log(`Warning: RuleEnforcer unavailable, using fallback checks: ${error instanceof Error ? error.message : String(error)}`);
+        if (tool === "write" && args?.filePath) {
+            const filePath = args.filePath;
+            if (filePath.endsWith(".ts") &&
+                !filePath.includes(".test.") &&
+                !filePath.includes(".spec.")) {
+                const testPath = filePath.replace(".ts", ".test.ts");
+                const specPath = filePath.replace(".ts", ".spec.ts");
+                if (!fs.existsSync(testPath) && !fs.existsSync(specPath)) {
+                    violations.push(`tests-required: No test file found for ${filePath}`);
+                }
+            }
+        }
+        if (args?.content) {
+            const errorPatterns = [/console\.log\s*\(/g, /TODO\s*:/gi, /FIXME\s*:/gi];
+            for (const pattern of errorPatterns) {
+                if (pattern.test(args.content)) {
+                    violations.push(`resolve-all-errors: Found error pattern in code`);
+                    break;
+                }
+            }
+        }
+        const passed = violations.length === 0;
+        if (!passed) {
+            logger.error(`🚫 Fallback Quality Gate FAILED with ${violations.length} violation(s)`);
+        }
+        else {
+            logger.log(`✅ Fallback Quality Gate PASSED`);
+        }
+        return { passed, violations };
+    }
+}
 let cachedCodexContexts = null;
 async function getCodexFileLocations(directory) {
     const root = directory || process.cwd();
@@ -363,6 +466,9 @@ function classifyTaskType(tool, args) {
 function isWriteEditOperation(tool) {
     return tool === "write" || tool === "edit" || tool === "multiedit";
 }
+function isPublishOperation(tool) {
+    return tool === "publish" || tool === "release" || tool === "npm-publish" || tool === "xray-release";
+}
 function resolveAgentName(input) {
     const globalAgent = globalThis.currentAgent;
     if (globalAgent?.agentType)
@@ -373,8 +479,58 @@ function resolveAgentName(input) {
         return input.agentType;
     return "architect";
 }
+function registerAllProcessors(pm) {
+    pm.registerProcessor({ name: "preValidate", type: "pre", priority: 10, enabled: true });
+    pm.registerProcessor({ name: "codexCompliance", type: "pre", priority: 20, enabled: true });
+    pm.registerProcessor({ name: "versionCompliance", type: "pre", priority: 25, enabled: true });
+    pm.registerProcessor({ name: "testAutoCreation", type: "post", priority: 5, enabled: true });
+    pm.registerProcessor({ name: "testExecution", type: "post", priority: 10, enabled: true });
+    pm.registerProcessor({ name: "coverageAnalysis", type: "post", priority: 20, enabled: true });
+}
+function registerAfterPostProcessors(pm) {
+    pm.registerProcessor({ name: "testAutoCreation", type: "post", priority: 50, enabled: true });
+    pm.registerProcessor({ name: "testExecution", type: "post", priority: 10, enabled: true });
+    pm.registerProcessor({ name: "coverageAnalysis", type: "post", priority: 20, enabled: true });
+}
+function logPreProcessorResults(results, logger) {
+    logger.log(`📊 Pre-processor result: ${results.success ? "SUCCESS" : "FAILED"} (${results.results.length} processors)`);
+    if (!results.success) {
+        const failures = results.results.filter((r) => !r.success);
+        for (const f of failures) {
+            logger.error(`❌ Pre-processor ${f.processorName} failed: ${f.error}`);
+        }
+    }
+    else {
+        for (const r of results.results) {
+            logger.log(`✅ Pre-processor ${r.processorName}: ${r.success ? "OK" : "FAILED"}`);
+        }
+    }
+}
+function logPostProcessorResults(results, logger) {
+    const allSuccess = results.every((r) => r.success);
+    logger.log(`📊 Post-processor result: ${allSuccess ? "SUCCESS" : "FAILED"} (${results.length} processors)`);
+    for (const r of results) {
+        if (r.success) {
+            logger.log(`✅ Post-processor ${r.processorName}: OK`);
+        }
+        else {
+            logger.error(`❌ Post-processor ${r.processorName} failed: ${r.error}`);
+        }
+    }
+}
+function logTestAutoCreationResult(results, logger) {
+    const testAutoResult = results.find((r) => r.processorName === "testAutoCreation");
+    if (testAutoResult) {
+        const data = testAutoResult.data;
+        if (testAutoResult.success && data?.testCreated && data?.testFile) {
+            logger.log(`✅ TEST AUTO-CREATION: Created ${data.testFile}`);
+        }
+        else if (!testAutoResult.success) {
+            logger.log(`ℹ️ TEST AUTO-CREATION: ${testAutoResult.error ?? "skipped - no new files"}`);
+        }
+    }
+}
 // ---------------------------------------------------------------------------
-// Feature detection helpers
 // Main plugin function
 // ---------------------------------------------------------------------------
 export default async function xrayCodexPlugin(input) {
@@ -432,18 +588,81 @@ export default async function xrayCodexPlugin(input) {
                 }
             }
             const { tool, args } = input;
-            const gateResult = await beforeToolHook(tool, args);
-            if (gateResult.blocked) {
-                const msgs = gateResult.violations.map(v => `[${v.severity}] ${v.message}`).join("; ");
-                logger.error(`🚫 Enforcement gate blocked: ${msgs}`);
-                throw new Error(`ENFORCER BLOCKED: ${msgs}`);
-            }
-            if (gateResult.violations.length > 0) {
-                logger.warn(`⚠️ Enforcement gate: ${gateResult.violations.length} warning(s), resonance=${gateResult.resonance.toFixed(2)}`);
+            const qualityGateResult = await runEnforcerQualityGate(input, logger);
+            if (!qualityGateResult.passed) {
+                logger.error(`🚫 Quality gate failed: ${qualityGateResult.violations.join(", ")}`);
+                throw new Error(`ENFORCER BLOCKED: ${qualityGateResult.violations.join("; ")}`);
             }
-            logger.log(`✅ Enforcement gate passed for ${tool}`);
+            logger.log(`✅ Quality gate passed for ${tool}`);
             if (isWriteEditOperation(tool)) {
-                logger.log(`🔧 Processors delegated to enforcement gate for ${tool}`);
+                if (!_ProcessorManager || !_XrayStateManager) {
+                    logger.error("ProcessorManager or XrayStateManager not loaded");
+                    return;
+                }
+                let stateManager;
+                let processorManager;
+                const globalState = globalThis.xrayStateManager;
+                if (globalState) {
+                    logger.log("🔗 Connecting to booted 0xRay framework");
+                    stateManager = globalState;
+                }
+                else {
+                    logger.log("🚀 0xRay framework not booted, initializing...");
+                    stateManager = new _XrayStateManager(await resolveStateDir(directory));
+                    globalThis.xrayStateManager = stateManager;
+                }
+                processorManager = stateManager.get("processor:manager") ?? null;
+                if (!processorManager) {
+                    logger.log("⚙️ Creating and registering processors...");
+                    processorManager = new _ProcessorManager(stateManager);
+                    registerAllProcessors(processorManager);
+                    stateManager.set("processor:manager", processorManager);
+                    logger.log("✅ Processors registered successfully");
+                }
+                else {
+                    logger.log("✅ Using existing processor manager");
+                }
+                try {
+                    logger.log(`▶️ Executing pre-processors for ${tool}...`);
+                    const preProcessorInput = {
+                        tool,
+                        args: args,
+                        context: {
+                            directory,
+                            operation: "tool_execution",
+                            filePath: args?.filePath,
+                        },
+                    };
+                    const result = await processorManager.executePreProcessors(preProcessorInput);
+                    logPreProcessorResults(result, logger);
+                }
+                catch (error) {
+                    logger.error(`💥 Pre-processor execution error`, error);
+                }
+                try {
+                    logger.log(`▶️ Executing post-processors for ${tool}...`);
+                    logger.log(`📝 Post-processor args: ${JSON.stringify(args)}`);
+                    const agentName = resolveAgentName(input);
+                    const postProcessorContext = {
+                        directory,
+                        operation: tool,
+                        filePath: args?.filePath,
+                        success: true,
+                        agentName,
+                        metadata: {
+                            isPublishing: isPublishOperation(tool),
+                            hook: "tool_execution",
+                            toolName: tool,
+                            timestamp: Date.now(),
+                            agentType: agentName,
+                        },
+                    };
+                    const postResults = await processorManager.executePostProcessors(tool, postProcessorContext, []);
+                    logPostProcessorResults(postResults, logger);
+                }
+                catch (error) {
+                    logger.error(`💥 Post-processor execution error`, error);
+                }
             }
         },
         "tool.execute.after": async (input, _output) => {
@@ -479,19 +698,34 @@ export default async function xrayCodexPlugin(input) {
                 // Outcome tracker not available — skip silently
             }
             logger.log(`📥 After hook input: ${JSON.stringify({ tool, hasArgs: !!args, args, hasResult: !!result }).slice(0, 200)}`);
-            // Run enforcement after-hook for code-producing tools
-            if (tool && (tool.includes('write') || tool.includes('edit') || tool.includes('create') || tool.includes('modify'))) {
+            if (isWriteEditOperation(tool)) {
+                if (!_ProcessorManager || !_XrayStateManager)
+                    return;
+                const stateManager = new _XrayStateManager(await resolveStateDir(directory));
+                const processorManager = new _ProcessorManager(stateManager);
+                registerAfterPostProcessors(processorManager);
                 try {
-                    const afterResult = await afterToolHook(tool, args, result, null);
-                    if (afterResult.processorResults.length > 0) {
-                        logger.log(`📊 Post-tool processors: ${afterResult.processorResults.filter(r => r.success).length}/${afterResult.processorResults.length} passed`);
-                    }
-                    if (afterResult.governanceTriggered) {
-                        logger.log(`🏛️ Governance cycle triggered from ${tool} output`);
-                    }
+                    logger.log(`📝 Post-processor tool: ${tool}`);
+                    logger.log(`📝 Post-processor args: ${JSON.stringify(args)}`);
+                    logger.log(`📝 Post-processor directory: ${directory}`);
+                    const postProcessorContext = {
+                        directory,
+                        operation: tool,
+                        filePath: args?.filePath,
+                        success: result?.success !== false,
+                        metadata: {
+                            isPublishing: isPublishOperation(tool),
+                            hook: "tool_execution",
+                            toolName: tool,
+                            timestamp: Date.now(),
+                        },
+                    };
+                    const postResults = await processorManager.executePostProcessors(tool, postProcessorContext, []);
+                    logPostProcessorResults(postResults, logger);
+                    logTestAutoCreationResult(postResults, logger);
                 }
-                catch (e) {
-                    logger.log(`⚠️ Post-tool enforcement hook skipped: ${e instanceof Error ? e.message : String(e)}`);
+                catch (error) {
+                    logger.error(`💥 Post-processor error`, error);
                 }
             }
             _openCodeToolCallCount++;
@@ -621,4 +855,3 @@ export default async function xrayCodexPlugin(input) {
         },
     };
 }
-//# sourceMappingURL=xray-codex-injection.js.map