0xray 4.0.13 → 4.0.15

package/dist/inference/inference-cycle.js

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

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

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

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