0xray 4.0.13 → 4.0.15

package/dist/inference/inference-accumulator.js

@@ -0,0 +1,126 @@
+import * as fs from "fs";
+import * as path from "path";
+export function shouldTriggerCycle(inferenceDir, lastCycleFile) {
+    const sessions = loadSessionInferences(inferenceDir);
+    if (sessions.length < 1) {
+        return { trigger: false, reason: `no session files collected` };
+    }
+    const lastCycle = loadLastCycleDate(lastCycleFile);
+    const daysSince = lastCycle ? daysBetween(new Date(lastCycle), new Date()) : Infinity;
+    if (daysSince < 1) {
+        return { trigger: false, reason: `${daysSince.toFixed(1)} days since last cycle (minimum 1)` };
+    }
+    const totalCommits = sessions.reduce((sum, s) => sum + s.metrics.commits, 0);
+    if (totalCommits < 5 && daysSince < 3) {
+        return { trigger: false, reason: `${totalCommits}/5 total commits, ${daysSince.toFixed(1)}/3 days` };
+    }
+    return {
+        trigger: true,
+        reason: `${sessions.length} sessions, ${totalCommits} commits, ${daysSince.toFixed(1)} days since last cycle`,
+    };
+}
+export function accumulateCorpus(inferenceDir) {
+    const sessions = loadSessionInferences(inferenceDir);
+    const totalCommits = sessions.reduce((sum, s) => sum + s.metrics.commits, 0);
+    const patternMap = new Map();
+    for (const session of sessions) {
+        for (const p of session.patterns) {
+            const existing = patternMap.get(p.name);
+            if (existing) {
+                existing.count++;
+                existing.confidence.push(p.confidence);
+                existing.sessions.push(session.sessionId);
+                for (const e of p.evidence) {
+                    if (!existing.evidence.includes(e))
+                        existing.evidence.push(e);
+                }
+            }
+            else {
+                patternMap.set(p.name, {
+                    count: 1,
+                    confidence: [p.confidence],
+                    sessions: [session.sessionId],
+                    evidence: [...p.evidence],
+                    description: p.description,
+                });
+            }
+        }
+    }
+    const recurringPatterns = [...patternMap.entries()]
+        .filter(([, data]) => data.count >= 2)
+        .map(([name, data]) => ({
+        name,
+        occurrences: data.count,
+        avgConfidence: data.confidence.reduce((a, b) => a + b, 0) / data.confidence.length,
+        sessions: data.sessions,
+        evidence: data.evidence.slice(0, 5),
+        description: data.description,
+    }))
+        .sort((a, b) => b.occurrences - a.occurrences || b.avgConfidence - a.avgConfidence);
+    const problemMap = new Map();
+    for (const session of sessions) {
+        for (const problem of session.problems) {
+            const key = normalizeProblem(problem);
+            const existing = problemMap.get(key);
+            if (existing) {
+                existing.count++;
+                if (!existing.sessions.includes(session.sessionId))
+                    existing.sessions.push(session.sessionId);
+            }
+            else {
+                problemMap.set(key, { count: 1, sessions: [session.sessionId] });
+            }
+        }
+    }
+    const recurringProblems = [...problemMap.entries()]
+        .filter(([, data]) => data.count >= 2)
+        .map(([pattern, data]) => ({ pattern, occurrences: data.count, sessions: data.sessions }))
+        .sort((a, b) => b.occurrences - a.occurrences);
+    const uniqueApproaches = [...new Set(sessions.flatMap((s) => s.approaches))];
+    const allWrongTurns = [...new Set(sessions.flatMap((s) => s.wrongTurns))];
+    return {
+        sessions,
+        totalCommits,
+        recurringPatterns,
+        recurringProblems,
+        uniqueApproaches,
+        allWrongTurns,
+        collectedAt: new Date().toISOString(),
+    };
+}
+export function loadSessionInferences(dir) {
+    if (!fs.existsSync(dir))
+        return [];
+    return fs.readdirSync(dir)
+        .filter((f) => f.startsWith("session-") && f.endsWith(".json"))
+        .map((f) => {
+        try {
+            return JSON.parse(fs.readFileSync(path.join(dir, f), "utf-8"));
+        }
+        catch {
+            return null;
+        }
+    })
+        .filter((s) => s !== null);
+}
+function loadLastCycleDate(filePath) {
+    if (!fs.existsSync(filePath))
+        return null;
+    try {
+        const data = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+        return data.completedAt || data.timestamp || null;
+    }
+    catch {
+        return null;
+    }
+}
+function normalizeProblem(problem) {
+    return problem
+        .replace(/\([a-f0-9]{7}\)/g, "")
+        .replace(/\d+ commits affected/g, "N commits affected")
+        .replace(/\d+ files?/g, "N files")
+        .trim();
+}
+function daysBetween(a, b) {
+    return (b.getTime() - a.getTime()) / (1000 * 60 * 60 * 24);
+}

package/dist/inference/inference-agent-invoker.d.ts

@@ -0,0 +1,3 @@
+import type { AgentInvoker } from "./inference-cycle.js";
+export declare function invokeAgent(agentName: string, prompt: string, projectRoot: string, agentInvoker?: AgentInvoker | null): Promise<string>;
+export declare function invokeViaOpencode(agentName: string, prompt: string, projectRoot: string): Promise<string>;

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.d.ts

@@ -0,0 +1,4 @@
+import type { InferenceProposal, AgentInvoker } from "./inference-cycle.js";
+export declare function applyProposals(proposals: InferenceProposal[], projectRoot: string, agentInvoker: AgentInvoker | null, options: {
+    skipResearcherReview?: boolean;
+}): Promise<void>;

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";
+    }
+}

package/dist/inference/inference-cycle.d.ts

@@ -0,0 +1,70 @@
+import { DeployVerificationResult } from "./deploy-verifier.js";
+export interface InferenceProposal {
+    id: string;
+    type: "fix" | "refactor" | "automate" | "guard" | "codify";
+    title: string;
+    description: string;
+    evidence: string[];
+    confidence: number;
+    source: "recurring_problem" | "recurring_pattern" | "wrong_turn";
+    status: "pending" | "approved" | "rejected" | "applied" | "failed";
+}
+export interface InferenceCycleResult {
+    cycleId: string;
+    triggered: boolean;
+    triggerReason: string;
+    corpusSummary: {
+        sessions: number;
+        totalCommits: number;
+        recurringPatterns: number;
+        recurringProblems: number;
+    };
+    proposals: InferenceProposal[];
+    votes: {
+        proposalId: string;
+        decision: string;
+        confidence: number;
+        details: string[];
+    }[];
+    deployVerification?: DeployVerificationResult | undefined;
+    phase: CyclePhase;
+    completedAt: string;
+    duration: number;
+}
+export type CyclePhase = "idle" | "collecting" | "proposing" | "governing" | "applying" | "deploying" | "verifying" | "complete" | "failed";
+export type AgentInvoker = (agentName: string, prompt: string) => Promise<string>;
+export interface InferenceCycleOptions {
+    skipDeployVerify?: boolean;
+    skipApply?: boolean;
+    skipResearcherReview?: boolean;
+    force?: boolean;
+}
+export declare class InferenceCycle {
+    private static instances;
+    private static reEntryLock;
+    private static governedProposalIds;
+    static getInstance(projectRoot?: string, options?: InferenceCycleOptions): InferenceCycle;
+    static resetInstance(): void;
+    private inferenceDir;
+    private stateDir;
+    private projectRoot;
+    private phase;
+    private opencodeAvailable;
+    private agentInvoker;
+    private options;
+    constructor(projectRoot?: string, agentInvoker?: AgentInvoker, options?: InferenceCycleOptions);
+    governExternalProposals(proposals: InferenceProposal[]): Promise<InferenceCycleResult>;
+    maybeRunCycle(): Promise<InferenceCycleResult>;
+    private governProposals;
+    private isGovernanceMcpPreferred;
+    private parseGovernanceMcpResponse;
+    private extractTextFromNdjson;
+    private resolveOpencodeRoot;
+    private setPhase;
+    getPhase(): CyclePhase;
+    private saveCycleState;
+    private appendHistory;
+    private loadHistory;
+    private buildBlockedResult;
+    private buildResult;
+}