0xray 4.0.12 → 4.0.13

package/dist/inference/inference-cycle.js

@@ -1,392 +0,0 @@
-import * as fs from "fs";
-import * as path from "path";
-import { shouldTriggerCycle, accumulateCorpus } from "./inference-accumulator.js";
-import { DeployVerifier } from "./deploy-verifier.js";
-import { frameworkLogger } from "../core/framework-logger.js";
-import { featuresConfigLoader } from "../core/features-config.js";
-import { mcpClientManager } from "../mcps/mcp-client.js";
-import { getConfigDir } from "../core/config-paths.js";
-import { generateProposals } from "./inference-proposal-generator.js";
-import { applyProposals as applyProposalsEx } from "./inference-applier.js";
-const CYCLE_STATE_FILE = "inference-cycle-state.json";
-const CYCLE_HISTORY_FILE = "inference-cycle-history.json";
-export class InferenceCycle {
-    static instances = new Map();
-    static reEntryLock = false;
-    static governedProposalIds = new Set();
-    static getInstance(projectRoot, options) {
-        const root = path.resolve(projectRoot || process.cwd());
-        if (!InferenceCycle.instances.has(root)) {
-            InferenceCycle.instances.set(root, new InferenceCycle(root, undefined, options));
-        }
-        return InferenceCycle.instances.get(root);
-    }
-    static resetInstance() {
-        InferenceCycle.instances.clear();
-        InferenceCycle.reEntryLock = false;
-        InferenceCycle.governedProposalIds.clear();
-    }
-    inferenceDir;
-    stateDir;
-    projectRoot;
-    phase = "idle";
-    opencodeAvailable = null;
-    agentInvoker;
-    options;
-    constructor(projectRoot, agentInvoker, options) {
-        this.projectRoot = projectRoot || process.cwd();
-        this.inferenceDir = path.join(this.projectRoot, "docs", "inference");
-        this.stateDir = path.join(this.projectRoot, ".xray", "inference");
-        this.agentInvoker = agentInvoker ?? null;
-        this.options = options ?? {};
-    }
-    async governExternalProposals(proposals) {
-        if (InferenceCycle.reEntryLock) {
-            const blockedId = `blocked-${Date.now()}`;
-            frameworkLogger.log("inference-cycle", "external-re-entry-blocked", "warning", {});
-            return this.buildBlockedResult(blockedId, "Cycle in progress — external governance blocked");
-        }
-        InferenceCycle.reEntryLock = true;
-        const startTime = Date.now();
-        const cycleId = `external-${Date.now()}`;
-        try {
-            frameworkLogger.log("inference-cycle", "external-governance-start", "info", {
-                cycleId,
-                proposalCount: proposals.length,
-            });
-            this.setPhase("governing");
-            let votes = [];
-            try {
-                votes = await this.governProposals(proposals);
-            }
-            catch (e) {
-                frameworkLogger.log("inference-cycle", "govern-proposals-error", "error", {
-                    error: e.message,
-                    stack: e.stack?.substring(0, 500),
-                });
-                for (const proposal of proposals) {
-                    votes.push({
-                        proposalId: proposal.id,
-                        decision: "reject",
-                        confidence: 0,
-                        details: [`rejected: external governance error: ${e.message}`],
-                    });
-                }
-            }
-            const approved = proposals.filter((p) => votes.find((v) => v.proposalId === p.id && v.decision === "approve"));
-            for (const p of approved)
-                p.status = "approved";
-            for (const p of proposals.filter((p) => p.status !== "approved"))
-                p.status = "rejected";
-            for (const p of proposals)
-                InferenceCycle.governedProposalIds.add(p.id);
-            this.setPhase("complete");
-            this.saveCycleState(cycleId);
-            const result = this.buildResult(cycleId, true, "external proposals", startTime, undefined, proposals, votes);
-            this.appendHistory(result);
-            frameworkLogger.log("inference-cycle", "external-governance-complete", "info", {
-                cycleId,
-                approved: approved.length,
-                rejected: proposals.length - approved.length,
-            });
-            return result;
-        }
-        finally {
-            InferenceCycle.reEntryLock = false;
-        }
-    }
-    async maybeRunCycle() {
-        if (InferenceCycle.reEntryLock) {
-            const blockedId = `blocked-${Date.now()}`;
-            frameworkLogger.log("inference-cycle", "re-entry-blocked", "warning", {});
-            return this.buildBlockedResult(blockedId, "Cycle already in progress — re-entry blocked");
-        }
-        InferenceCycle.reEntryLock = true;
-        const startTime = Date.now();
-        const cycleId = `cycle-${Date.now()}`;
-        try {
-            this.setPhase("collecting");
-            const lastCycleFile = path.join(this.stateDir, CYCLE_STATE_FILE);
-            const threshold = this.options.force ? { trigger: true, reason: "force flag set" } : shouldTriggerCycle(this.inferenceDir, lastCycleFile);
-            if (!threshold.trigger) {
-                this.setPhase("idle");
-                return this.buildResult(cycleId, false, threshold.reason, startTime);
-            }
-            frameworkLogger.log("inference-cycle", "cycle-triggered", "info", {
-                cycleId,
-                reason: threshold.reason,
-            });
-            const corpus = accumulateCorpus(this.inferenceDir);
-            this.setPhase("proposing");
-            const proposals = generateProposals(corpus, this.loadHistory());
-            if (proposals.length === 0) {
-                this.setPhase("complete");
-                return this.buildResult(cycleId, true, threshold.reason, startTime, corpus, proposals);
-            }
-            this.setPhase("governing");
-            let votes = [];
-            try {
-                votes = await this.governProposals(proposals);
-            }
-            catch (e) {
-                frameworkLogger.log("inference-cycle", "govern-proposals-error", "error", {
-                    error: e.message,
-                    stack: e.stack?.substring(0, 500),
-                });
-                for (const proposal of proposals) {
-                    votes.push({
-                        proposalId: proposal.id,
-                        decision: "reject",
-                        confidence: 0,
-                        details: [`rejected: governance error: ${e.message}`],
-                    });
-                }
-            }
-            // Track governed proposals for dedup across cycles
-            for (const p of proposals)
-                InferenceCycle.governedProposalIds.add(p.id);
-            const approved = proposals.filter((p) => votes.find((v) => v.proposalId === p.id && v.decision === "approve"));
-            for (const p of approved) {
-                p.status = "approved";
-            }
-            for (const p of proposals.filter((p) => p.status !== "approved")) {
-                p.status = "rejected";
-            }
-            if (approved.length > 0) {
-                if (!this.options.skipApply) {
-                    this.setPhase("applying");
-                    await applyProposalsEx(approved, this.projectRoot, this.agentInvoker, this.options);
-                }
-                let deployResult;
-                if (!this.options.skipDeployVerify) {
-                    this.setPhase("deploying");
-                    const verifier = new DeployVerifier(this.projectRoot);
-                    deployResult = verifier.quickVerify();
-                    this.setPhase("verifying");
-                    if (deployResult.success) {
-                        for (const p of approved) {
-                            p.status = "applied";
-                        }
-                    }
-                    else {
-                        const failureReasons = deployResult.checks
-                            .filter((c) => !c.passed)
-                            .map((c) => c.output)
-                            .join("; ");
-                        frameworkLogger.log("inference-cycle", "deploy-failed", "warning", {
-                            checks: deployResult.checks.map((c) => ({ name: c.name, passed: c.passed })),
-                            failureReasons,
-                        });
-                    }
-                }
-                else {
-                    for (const p of approved) {
-                        p.status = "approved";
-                    }
-                }
-                this.setPhase("complete");
-                this.saveCycleState(cycleId);
-                this.appendHistory(this.buildResult(cycleId, true, threshold.reason, startTime, corpus, proposals, votes, deployResult));
-                return this.buildResult(cycleId, true, threshold.reason, startTime, corpus, proposals, votes, deployResult);
-            }
-            this.setPhase("complete");
-            this.saveCycleState(cycleId);
-            this.appendHistory(this.buildResult(cycleId, true, threshold.reason, startTime, corpus, proposals, votes));
-            return this.buildResult(cycleId, true, threshold.reason, startTime, corpus, proposals, votes);
-        }
-        finally {
-            InferenceCycle.reEntryLock = false;
-        }
-    }
-    async governProposals(proposals) {
-        // Governance MCP is the sole governance path (governance.server.ts + GovernanceService).
-        // It calls individual skill MCPs (code-review, security-audit, researcher) internally
-        // and integrates with external Dynamo Solar SSOT.
-        const useGovernanceMcp = process.env.XRAY_FORCE_MCP_GOVERNANCE === 'true' ||
-            this.isGovernanceMcpPreferred();
-        if (!useGovernanceMcp) {
-            throw new Error("Governance MCP is required but not available");
-        }
-        const result = await Promise.race([
-            mcpClientManager.callServerTool("governance", "govern_proposals", {
-                proposals: proposals.map(p => ({
-                    id: p.id,
-                    type: p.type,
-                    title: p.title,
-                    description: p.description,
-                    evidence: p.evidence || [],
-                    source: p.source || "inference",
-                    confidence: p.confidence || 0.8,
-                })),
-                context: { source: "inference-cycle" },
-                options: { require_external: true },
-            }),
-            new Promise((_, reject) => setTimeout(() => reject(new Error("Governance MCP timed out after 8s")), 8000)),
-        ]);
-        const text = result?.content?.[0]?.text || "";
-        const parsed = this.parseGovernanceMcpResponse(text, proposals);
-        frameworkLogger.log("inference-cycle", "governance-mcp-primary-path", "info", {
-            proposalCount: proposals.length,
-            overall: parsed.overallDecision,
-        });
-        return parsed.votes;
-    }
-    isGovernanceMcpPreferred() {
-        try {
-            const config = featuresConfigLoader.loadConfig();
-            const inferenceGov = config.inference_governance;
-            return inferenceGov?.enabled ?? true;
-        }
-        catch {
-            return true;
-        }
-    }
-    parseGovernanceMcpResponse(text, proposals) {
-        // The governance MCP returns a GovernanceResponse JSON
-        try {
-            const data = JSON.parse(text);
-            const results = data.results || [];
-            const votes = proposals.map((p, i) => {
-                const r = results[i] || {};
-                return {
-                    proposalId: p.id,
-                    decision: (r.finalDecision === 'approve' ? 'approve' : r.finalDecision === 'reject' ? 'reject' : 'needs_revision'),
-                    confidence: r.averageConfidence || 0.75,
-                    details: (r.votes || []).map((v) => `${v.server}: ${v.decision} (${v.confidence})`),
-                };
-            });
-            return { votes, overallDecision: data.overallDecision || "needs_revision" };
-        }
-        catch {
-            frameworkLogger.log('inference-cycle', 'governance-mcp-parse-failed', 'warning', {
-                textPreview: text.substring(0, 200),
-                proposalCount: proposals.length,
-            });
-            const votes = proposals.map(p => ({
-                proposalId: p.id,
-                decision: "abstain",
-                confidence: 0.5,
-                details: ["governance-mcp: parse-failed"],
-            }));
-            return { votes, overallDecision: "needs_revision" };
-        }
-    }
-    extractTextFromNdjson(output) {
-        const texts = [];
-        for (const line of output.split("\n")) {
-            const trimmed = line.trim();
-            if (!trimmed)
-                continue;
-            try {
-                const obj = JSON.parse(trimmed);
-                if (obj.type === "text" && obj.part?.text) {
-                    texts.push(obj.part.text);
-                }
-            }
-            catch {
-                // skip non-JSON lines
-            }
-        }
-        return texts.join("\n").trim();
-    }
-    resolveOpencodeRoot() {
-        const configDir = getConfigDir(this.projectRoot);
-        if (configDir.includes(".xray") || configDir.includes("xray")) {
-            return path.dirname(configDir);
-        }
-        let dir = this.projectRoot;
-        for (let i = 0; i < 10; i++) {
-            if (fs.existsSync(path.join(dir, ".opencode")))
-                return dir;
-            const parent = path.dirname(dir);
-            if (parent === dir)
-                break;
-            dir = parent;
-        }
-        const cwd = process.cwd();
-        if (fs.existsSync(path.join(cwd, ".opencode")))
-            return cwd;
-        return this.projectRoot;
-    }
-    setPhase(phase) {
-        this.phase = phase;
-        frameworkLogger.log("inference-cycle", "phase-change", "info", { phase });
-    }
-    getPhase() {
-        return this.phase;
-    }
-    saveCycleState(cycleId) {
-        if (!fs.existsSync(this.stateDir)) {
-            fs.mkdirSync(this.stateDir, { recursive: true });
-        }
-        fs.writeFileSync(path.join(this.stateDir, CYCLE_STATE_FILE), JSON.stringify({
-            cycleId,
-            completedAt: new Date().toISOString(),
-            phase: this.phase,
-        }));
-    }
-    appendHistory(result) {
-        if (!fs.existsSync(this.stateDir)) {
-            fs.mkdirSync(this.stateDir, { recursive: true });
-        }
-        const historyPath = path.join(this.stateDir, CYCLE_HISTORY_FILE);
-        let history = [];
-        if (fs.existsSync(historyPath)) {
-            try {
-                history = JSON.parse(fs.readFileSync(historyPath, "utf-8"));
-            }
-            catch {
-                history = [];
-            }
-        }
-        history.push(result);
-        if (history.length > 50)
-            history = history.slice(-50);
-        fs.writeFileSync(historyPath, JSON.stringify(history, null, 2));
-    }
-    loadHistory() {
-        const historyPath = path.join(this.stateDir, CYCLE_HISTORY_FILE);
-        if (!fs.existsSync(historyPath))
-            return [];
-        try {
-            return JSON.parse(fs.readFileSync(historyPath, "utf-8"));
-        }
-        catch {
-            return [];
-        }
-    }
-    buildBlockedResult(cycleId, reason) {
-        return {
-            cycleId,
-            triggered: false,
-            triggerReason: reason,
-            corpusSummary: { sessions: 0, totalCommits: 0, recurringPatterns: 0, recurringProblems: 0 },
-            proposals: [],
-            votes: [],
-            phase: "idle",
-            completedAt: new Date().toISOString(),
-            duration: 0,
-        };
-    }
-    buildResult(cycleId, triggered, reason, startTime, corpus, proposals, votes, deployVerification) {
-        return {
-            cycleId,
-            triggered,
-            triggerReason: reason,
-            corpusSummary: corpus
-                ? {
-                    sessions: corpus.sessions.length,
-                    totalCommits: corpus.totalCommits,
-                    recurringPatterns: corpus.recurringPatterns.length,
-                    recurringProblems: corpus.recurringProblems.length,
-                }
-                : { sessions: 0, totalCommits: 0, recurringPatterns: 0, recurringProblems: 0 },
-            proposals: proposals || [],
-            votes: votes || [],
-            deployVerification,
-            phase: this.phase,
-            completedAt: new Date().toISOString(),
-            duration: Date.now() - startTime,
-        };
-    }
-}

package/dist/inference/inference-proposal-generator.d.ts

@@ -1,3 +0,0 @@
-import type { InferenceProposal, InferenceCycleResult } from "./inference-cycle.js";
-import type { InferenceCorpus } from "./inference-accumulator.js";
-export declare function generateProposals(corpus: InferenceCorpus, history?: InferenceCycleResult[]): InferenceProposal[];

package/dist/inference/inference-proposal-generator.js

@@ -1,149 +0,0 @@
-function classifyProposalType(problemPattern) {
-    const lower = problemPattern.toLowerCase();
-    if (lower.includes("bug") || lower.includes("fix") || lower.includes("stability"))
-        return "fix";
-    if (lower.includes("dead code") || lower.includes("remove") || lower.includes("health"))
-        return "refactor";
-    if (lower.includes("manual") || lower.includes("automate"))
-        return "automate";
-    if (lower.includes("guard") || lower.includes("path") || lower.includes("timing") || lower.includes("edge case"))
-        return "guard";
-    return "codify";
-}
-function patternToProposalType(pattern) {
-    const name = pattern.name.toLowerCase();
-    if (name.includes("dead code"))
-        return "refactor";
-    if (name.includes("extract"))
-        return "refactor";
-    if (name.includes("registry") || name.includes("facade"))
-        return "codify";
-    if (name.includes("test"))
-        return "guard";
-    if (name.includes("stability"))
-        return "fix";
-    return "codify";
-}
-const ACTION_MAP = [
-    [/^Bug fix$/i, "Fix recurring bug pattern"],
-    [/^Code health cleanup$/i, "Clean up code health issues"],
-    [/^Accumulated dead code$/i, "Remove accumulated dead code"],
-    [/^Incomplete implementation$/i, "Complete partial implementation"],
-    [/^Technical debt/i, "Address technical debt"],
-    [/^Missing guard/i, "Add missing guard"],
-    [/^Manual step/i, "Automate manual step"],
-];
-function generateTitle(problem) {
-    const pattern = problem.pattern;
-    for (const [re, title] of ACTION_MAP) {
-        if (re.test(pattern)) {
-            return `${title} (${problem.occurrences}x across ${problem.sessions.length} sessions)`;
-        }
-    }
-    if (pattern.length > 80) {
-        return `Address: ${pattern.substring(0, 77)}... (${problem.occurrences}x)`;
-    }
-    return `Address: ${pattern} (${problem.occurrences}x)`;
-}
-function adjustConfidenceFromHistory(proposals, history) {
-    if (history.length === 0)
-        return;
-    const recentVotes = history.slice(-10).flatMap((h) => h.votes);
-    const approvedIds = new Set(recentVotes.filter((v) => v.decision === "approve").map((v) => v.proposalId));
-    const approvedTypes = new Map();
-    const rejectedTypes = new Map();
-    for (const h of history.slice(-10)) {
-        for (const p of h.proposals) {
-            if (p.status === "approved" || p.status === "applied") {
-                approvedTypes.set(p.type, (approvedTypes.get(p.type) ?? 0) + 1);
-            }
-            else if (p.status === "rejected" || p.status === "failed") {
-                rejectedTypes.set(p.type, (rejectedTypes.get(p.type) ?? 0) + 1);
-            }
-        }
-    }
-    for (const proposal of proposals) {
-        const approved = approvedTypes.get(proposal.type) ?? 0;
-        const rejected = rejectedTypes.get(proposal.type) ?? 0;
-        const total = approved + rejected;
-        if (total >= 3) {
-            const successRate = approved / total;
-            if (successRate < 0.3) {
-                proposal.confidence *= 0.8;
-            }
-            else if (successRate > 0.7) {
-                proposal.confidence = Math.min(0.95, proposal.confidence * 1.05);
-            }
-        }
-    }
-}
-export function generateProposals(corpus, history) {
-    const proposals = [];
-    for (const problem of corpus.recurringProblems) {
-        proposals.push({
-            id: `prop-${Date.now()}-${proposals.length}`,
-            type: classifyProposalType(problem.pattern),
-            title: generateTitle(problem),
-            description: `Recurring across ${problem.occurrences} sessions: ${problem.pattern}`,
-            evidence: problem.sessions.map((s) => `Seen in session ${s}`),
-            confidence: Math.min(0.95, 0.5 + problem.occurrences * 0.15),
-            source: "recurring_problem",
-            status: "pending",
-        });
-    }
-    const seenPatterns = new Set(corpus.recurringProblems.map((p) => p.pattern));
-    const allProblems = corpus.sessions.flatMap((s) => s.problems.map((p) => ({ problem: p, session: s.sessionId })));
-    for (const { problem, session } of allProblems) {
-        const normalized = problem.replace(/\([a-f0-9]{7}\)/g, "").trim();
-        if (seenPatterns.has(normalized))
-            continue;
-        if (proposals.length >= 5)
-            break;
-        proposals.push({
-            id: `prop-${Date.now()}-${proposals.length}`,
-            type: classifyProposalType(problem),
-            title: `Investigate: ${problem.substring(0, 80)}`,
-            description: `Observed in session ${session}: ${problem}`,
-            evidence: [problem],
-            confidence: 0.4,
-            source: "recurring_problem",
-            status: "pending",
-        });
-        seenPatterns.add(normalized);
-    }
-    for (const pattern of corpus.recurringPatterns) {
-        if (pattern.occurrences < 2)
-            continue;
-        const type = patternToProposalType(pattern);
-        proposals.push({
-            id: `prop-${Date.now()}-${proposals.length}`,
-            type,
-            title: `Codify ${pattern.name} pattern`,
-            description: `${pattern.name} detected across ${pattern.occurrences} sessions (avg confidence: ${Math.round(pattern.avgConfidence * 100)}%). ${pattern.description}`,
-            evidence: pattern.evidence,
-            confidence: pattern.avgConfidence,
-            source: "recurring_pattern",
-            status: "pending",
-        });
-    }
-    const wrongTurns = corpus.allWrongTurns.slice(0, 2);
-    for (const wt of wrongTurns) {
-        const summary = wt.length > 50 ? `${wt.substring(0, 47)}...` : wt;
-        proposals.push({
-            id: `prop-${Date.now()}-${proposals.length}`,
-            type: "guard",
-            title: `Guard against: ${summary}`,
-            description: `Recurring wrong turn detected: ${wt}. Add a guard or validation to prevent this pattern.`,
-            evidence: [wt],
-            confidence: 0.7,
-            source: "wrong_turn",
-            status: "pending",
-        });
-    }
-    const sorted = proposals.sort((a, b) => b.confidence - a.confidence).slice(0, 3);
-    if (history && history.length > 0) {
-        adjustConfidenceFromHistory(sorted, history);
-        sorted.sort((a, b) => b.confidence - a.confidence);
-    }
-    return sorted;
-}

package/dist/inference/semantic-patterns.d.ts

@@ -1,7 +0,0 @@
-export interface StructuralPattern {
-    name: string;
-    confidence: number;
-    evidence: string[];
-    description: string;
-}
-export declare function analyzeStructuralPatterns(fromRef: string, toRef: string): StructuralPattern[];