0xray 3.1.1 → 3.2.0

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

@@ -7,7 +7,6 @@
  * 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";

package/dist/enforcement/types.js

@@ -5,7 +5,6 @@
  * Extracted from rule-enforcer.ts as part of Phase 1 refactoring.
  *
  * @module types
- * @version 1.0.0
  */
 /**
  * Type guard to check if an object is a valid RuleValidationResult.

package/dist/enforcement/validators/architecture-validators.js

@@ -5,7 +5,6 @@
  * Each validator encapsulates the validation logic for a specific architectural rule.
  *
  * @module validators/architecture-validators
- * @version 1.0.0
  */
 import { BaseValidator } from "./base-validator.js";
 /**

package/dist/enforcement/validators/base-validator.js

@@ -5,7 +5,6 @@
  * and enforces the IValidator interface contract.
  *
  * @module validators/base-validator
- * @version 1.0.0
  */
 /**
  * Abstract base class for all validators.

package/dist/enforcement/validators/code-quality-validators.js

@@ -5,7 +5,6 @@
  * Each validator encapsulates the validation logic for a specific rule.
  *
  * @module validators/code-quality-validators
- * @version 1.0.0
  */
 import { BaseValidator } from "./base-validator.js";
 /**

package/dist/enforcement/validators/index.js

@@ -5,7 +5,6 @@
  * Part of Phase 3 refactoring to extract validators from rule-enforcer.ts.
  *
  * @module validators
- * @version 1.0.0
  */
 // Base validator class
 export { BaseValidator } from "./base-validator.js";

package/dist/enforcement/validators/security-validators.js

@@ -5,7 +5,6 @@
  * These validators enforce security best practices and input validation requirements.
  *
  * @module validators/security-validators
- * @version 1.0.0
  */
 import { BaseValidator } from "./base-validator.js";
 /**

package/dist/enforcement/validators/testing-validators.js

@@ -5,7 +5,6 @@
  * Each validator encapsulates the validation logic for a specific testing rule.
  *
  * @module validators/testing-validators
- * @version 1.0.0
  */
 import { BaseValidator } from "./base-validator.js";
 /**

package/dist/enforcement/validators/validator-registry.js

@@ -5,7 +5,6 @@
  * and category filtering capabilities.
  *
  * @module validators/validator-registry
- * @version 1.0.0
  */
 import { NoDuplicateCodeValidator, ContextAnalysisIntegrationValidator, MemoryOptimizationValidator, DocumentationRequiredValidator, NoOverEngineeringValidator, CleanDebugLogsValidator, ConsoleLogUsageValidator, } from "./code-quality-validators.js";
 import { InputValidationValidator, SecurityByDesignValidator, } from "./security-validators.js";

package/dist/governance/codex-policy.service.js

@@ -26,7 +26,6 @@
  *   - Make CodexLoader delegate its raw data load here, then re-export from governance.
  *
  * @module governance/codex-policy.service
- * @version 2.0.0-s02-real
  */
 import { frameworkLogger } from '../core/framework-logger.js';
 import { resolveCodexPath } from '../core/config-paths.js';

package/dist/inference/inference-agent-invoker.js

@@ -0,0 +1,67 @@
+import { frameworkLogger } from "../core/framework-logger.js";
+import { invokeViaOpencode as invokeOpencodeFromEngine } from "../execution/opencode-cli-invoker.js";
+const MCP_TIMEOUT_MS = 8000;
+export async function invokeAgent(agentName, prompt, projectRoot, agentInvoker) {
+    frameworkLogger.log("inference-cycle", "invoke-agent-internal", "info", {
+        agentName,
+        promptLength: prompt.length,
+    });
+    try {
+        const { mcpClientManager } = await import("../mcps/mcp-client.js");
+        const result = await Promise.race([
+            mcpClientManager.callServerTool("orchestrator", "orchestrate-task", {
+                description: prompt,
+                tasks: [{
+                        id: `task-${Date.now()}`,
+                        description: prompt,
+                        type: agentName,
+                        priority: "high",
+                    }],
+                executionMode: "sequential",
+            }),
+            new Promise((_, reject) => setTimeout(() => reject(new Error(`Orchestrator MCP timed out after ${MCP_TIMEOUT_MS}ms`)), MCP_TIMEOUT_MS)),
+        ]);
+        const content = result.content;
+        let responseText = "";
+        if (content && Array.isArray(content)) {
+            responseText = content.map((c) => c.text ?? "").join("");
+        }
+        else {
+            responseText = JSON.stringify(result);
+        }
+        const isPureMcp = process.env.XRAY_FORCE_MCP_GOVERNANCE === 'true';
+        const hasRealContent = /PROPOSAL:\s*\d+/i.test(responseText) ||
+            /DECISION:\s*(approve|reject|abstain)/i.test(responseText) ||
+            /Agent Outputs \(real MCP responses\):/i.test(responseText);
+        if (hasRealContent || isPureMcp) {
+            if (isPureMcp && !hasRealContent) {
+                frameworkLogger.log("inference-cycle", "pure-mcp-orchestrator-response", "info", {
+                    agentName,
+                    responsePreview: responseText.substring(0, 300),
+                });
+            }
+            return responseText;
+        }
+        frameworkLogger.log("inference-cycle", "mcp-no-useful-content", "info", {
+            agentName,
+            responsePreview: responseText.substring(0, 200),
+        });
+    }
+    catch (mcpError) {
+        frameworkLogger.log("inference-cycle", "mcp-invocation-failed", "info", {
+            agentName,
+            error: String(mcpError),
+        });
+    }
+    if (agentInvoker) {
+        frameworkLogger.log("inference-cycle", "invoke-via-callback", "info", { agentName });
+        return agentInvoker(agentName, prompt);
+    }
+    if (process.env.XRAY_FORCE_MCP_GOVERNANCE === 'true') {
+        throw new Error(`[PURE MCP] Orchestrator returned no usable response for agent "${agentName}" and OpenCode fallback is disabled`);
+    }
+    return invokeViaOpencode(agentName, prompt, projectRoot);
+}
+export async function invokeViaOpencode(agentName, prompt, projectRoot) {
+    return invokeOpencodeFromEngine(agentName, prompt, projectRoot);
+}

package/dist/inference/inference-applier.js

@@ -0,0 +1,178 @@
+import * as fs from "fs";
+import * as path from "path";
+import { ProposalApplier } from "../execution/proposal-applier.js";
+import { invokeAgent } from "./inference-agent-invoker.js";
+import { frameworkLogger } from "../core/framework-logger.js";
+function extractTargetFiles(evidence) {
+    const filePattern = /[a-zA-Z0-9/_-]+\.(ts|js|mjs|json|yml|yaml)/g;
+    const files = new Set();
+    for (const item of evidence) {
+        const matches = item.matchAll(filePattern);
+        for (const match of matches) {
+            const f = match[0];
+            if (f.startsWith("src/") || f.startsWith("dist/") || f.startsWith(".opencode/")) {
+                files.add(f);
+            }
+        }
+    }
+    return [...files];
+}
+async function researcherReview(p, prUrl, projectRoot, agentInvoker) {
+    const prompt = `You are a researcher agent reviewing a PR for proposal: "${p.title}".
+
+PR URL: ${prUrl}
+
+Proposal Type: ${p.type}
+Description: ${p.description}
+Evidence: ${p.evidence.slice(0, 5).join("; ")}
+
+Your job: Review the actual codebase to verify this proposal makes sense. Search the code to confirm:
+1. Does the problem described actually exist in the codebase?
+2. Is the proposed solution appropriate?
+3. Are there any missed edge cases?
+
+Respond with EXACTLY one of:
+- GO (proposal is valid, approve)
+- NO-GO (proposal is invalid, reject)
+- MODIFY: <specific changes needed>`;
+    try {
+        const result = await invokeAgent("researcher", prompt, projectRoot, agentInvoker);
+        const output = result.toLowerCase();
+        if (output.includes("no-go"))
+            return "no-go";
+        if (output.includes("modify"))
+            return "modify";
+        return "go";
+    }
+    catch (err) {
+        frameworkLogger.log("inference-cycle", "researcher-review-failed", "warning", { error: String(err) });
+        return "go";
+    }
+}
+async function applyCodeChange(p, projectRoot, agentInvoker) {
+    const targetFiles = extractTargetFiles(p.evidence);
+    const prompt = [
+        `Apply approved inference proposal`,
+        ``,
+        `Type: ${p.type}`,
+        `Title: ${p.title}`,
+        `Description: ${p.description}`,
+        targetFiles.length > 0 ? `Target files: ${targetFiles.join(", ")}` : "No specific target files identified",
+        `Evidence: ${p.evidence.slice(0, 5).join("; ")}`,
+        `Confidence: ${(p.confidence * 100).toFixed(0)}%`,
+        ``,
+        `1. Read the relevant source files`,
+        `2. Apply the ${p.type} described above`,
+        `3. Make minimal, surgical changes`,
+        `4. If the change is unsafe or unclear, skip and explain`,
+    ].join("\n");
+    frameworkLogger.log("inference-cycle", "apply-invoking-agent", "info", {
+        proposalId: p.id,
+        proposalType: p.type,
+        targetFiles,
+    });
+    try {
+        let agentName = p.type === "refactor" ? "refactorer" : "code-reviewer";
+        if (process.env.XRAY_FORCE_MCP_GOVERNANCE === 'true') {
+            agentName = p.type === "refactor" ? "refactoring-strategies" : "code-review";
+        }
+        await invokeAgent(agentName, prompt, projectRoot, agentInvoker);
+        return true;
+    }
+    catch (err) {
+        frameworkLogger.log("inference-cycle", "apply-agent-failed", "warning", {
+            proposalId: p.id,
+            error: String(err),
+        });
+        return false;
+    }
+}
+async function applyGuard(p, projectRoot, agentInvoker) {
+    const prompt = [
+        `Add guard/validation for the following issue:`,
+        ``,
+        `Title: ${p.title}`,
+        `Description: ${p.description}`,
+        `Evidence: ${p.evidence.join("; ")}`,
+        `Confidence: ${(p.confidence * 100).toFixed(0)}%`,
+        ``,
+        `1. Read the relevant source files`,
+        `2. Add the missing guard, validation, or edge case handling`,
+        `3. If this is a codex rule, add the term to .xray/codex.json`,
+        `4. Make minimal, surgical changes`,
+    ].join("\n");
+    try {
+        const agentName = process.env.XRAY_FORCE_MCP_GOVERNANCE === 'true'
+            ? "code-review"
+            : "code-reviewer";
+        await invokeAgent(agentName, prompt, projectRoot, agentInvoker);
+        return true;
+    }
+    catch (err) {
+        frameworkLogger.log("inference-cycle", "apply-guard-failed", "warning", {
+            proposalId: p.id,
+            error: String(err),
+        });
+        const guardPath = path.join(projectRoot, "docs", "guards", `${p.title.replace(/[^a-z0-9]/gi, "-")}.md`);
+        fs.mkdirSync(path.dirname(guardPath), { recursive: true });
+        fs.writeFileSync(guardPath, `# Guard: ${p.title}\n\n${p.description}\n\n## Evidence\n${p.evidence.join("\n")}`);
+        return true;
+    }
+}
+async function applyAutomation(p, projectRoot, agentInvoker) {
+    const prompt = [
+        `Design automation for the following manual process:`,
+        ``,
+        `Title: ${p.title}`,
+        `Description: ${p.description}`,
+        `Evidence: ${p.evidence.join("; ")}`,
+        `Confidence: ${(p.confidence * 100).toFixed(0)}%`,
+        ``,
+        `1. Read the relevant source files`,
+        `2. Design the automation (script, processor, or config change)`,
+        `3. Implement it if straightforward, otherwise describe the design`,
+    ].join("\n");
+    try {
+        const agentName = process.env.XRAY_FORCE_MCP_GOVERNANCE === 'true'
+            ? "architecture-patterns"
+            : "architect";
+        await invokeAgent(agentName, prompt, projectRoot, agentInvoker);
+        return true;
+    }
+    catch (err) {
+        frameworkLogger.log("inference-cycle", "apply-automation-failed", "warning", {
+            proposalId: p.id,
+            error: String(err),
+        });
+        const automationPath = path.join(projectRoot, "docs", "automation-proposals.md");
+        const entry = `\n## ${p.title}\n\n${p.description}\n\n**Evidence:** ${p.evidence.join(", ")}\n`;
+        fs.mkdirSync(path.dirname(automationPath), { recursive: true });
+        fs.appendFileSync(automationPath, entry);
+        return true;
+    }
+}
+async function applyProposalWork(p, projectRoot, agentInvoker) {
+    if (p.type === "fix" || p.type === "refactor") {
+        return applyCodeChange(p, projectRoot, agentInvoker);
+    }
+    if (p.type === "guard") {
+        return applyGuard(p, projectRoot, agentInvoker);
+    }
+    if (p.type === "automate") {
+        return applyAutomation(p, projectRoot, agentInvoker);
+    }
+    return false;
+}
+export async function applyProposals(proposals, projectRoot, agentInvoker, options) {
+    const applier = new ProposalApplier(projectRoot, async (p) => applyProposalWork(p, projectRoot, agentInvoker), async (p, prUrl) => {
+        if (options.skipResearcherReview)
+            return "go";
+        return researcherReview(p, prUrl, projectRoot, agentInvoker);
+    });
+    const results = await applier.applyProposals(proposals);
+    for (const r of results) {
+        const p = proposals.find(pr => pr.id === r.proposalId);
+        if (p)
+            p.status = r.success ? "applied" : "failed";
+    }
+}