0xray 4.0.11 → 4.0.13

package/dist/inference/inference-accumulator.js

@@ -1,126 +0,0 @@
-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

@@ -1,3 +0,0 @@
-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

@@ -1,67 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,178 +0,0 @@
-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

@@ -1,70 +0,0 @@
-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;
-}