@orangepro/orangepro-mcp 0.1.0

package/dist/local/interactive.js

@@ -0,0 +1,53 @@
+/**
+ * Curated, current known-good models per provider. NOT exhaustive — a custom id
+ * is always selectable, and the provider adapters self-correct request params,
+ * so newer reasoning models (e.g. gpt-5*, o-series) work even when not listed.
+ */
+export const SUPPORTED_MODELS = {
+    openai: [
+        { model: "gpt-4.1", note: "strong general (recommended)" },
+        { model: "gpt-4o", note: "fast, multimodal" },
+        { model: "gpt-5", note: "reasoning — uses max_completion_tokens" },
+        { model: "gpt-4.1-mini", note: "cheap — smoke tests only" }
+    ],
+    anthropic: [
+        { model: "claude-sonnet-4-6", note: "recommended" },
+        { model: "claude-opus-4-8", note: "deepest reasoning" },
+        { model: "claude-haiku-4-5", note: "fast, cheap" }
+    ],
+    ollama: [
+        { model: "qwen2.5-coder:32b", note: "strong local coder" },
+        { model: "llama3.1", note: "general local" }
+    ]
+};
+/** Providers offered by the picker, each flagged with whether creds are present. */
+export function detectProviders(env) {
+    return [
+        { id: "openai", label: "OpenAI / OpenAI-compatible", ready: Boolean(env.OPENAI_API_KEY), hint: "set OPENAI_API_KEY" },
+        { id: "anthropic", label: "Anthropic (Claude)", ready: Boolean(env.ANTHROPIC_API_KEY), hint: "set ANTHROPIC_API_KEY" },
+        { id: "ollama", label: "Ollama (local)", ready: Boolean(env.OLLAMA_BASE_URL), hint: "needs local Ollama (default :11434)" },
+        { id: "deterministic", label: "Deterministic offline stand-in", ready: true, hint: "no key — scaffold tests only" }
+    ];
+}
+export async function selectProviderAndModel(env, choose, ask) {
+    const providers = detectProviders(env);
+    const provIdx = await choose("Select a model provider:", providers.map((p) => `${p.label}  ${p.ready ? "[ready]" : `[${p.hint}]`}`));
+    if (provIdx < 0 || provIdx >= providers.length)
+        return null;
+    const chosen = providers[provIdx];
+    if (chosen.id === "deterministic")
+        return { provider: "deterministic" };
+    const models = SUPPORTED_MODELS[chosen.id];
+    const labels = models.map((m) => `${m.model} — ${m.note}`);
+    labels.push("custom (enter a model id)");
+    const modelIdx = await choose(`Select a ${chosen.label} model:`, labels);
+    if (modelIdx < 0 || modelIdx > models.length)
+        return null;
+    if (modelIdx === models.length) {
+        const custom = (await ask("Model id: ")).trim();
+        if (!custom)
+            return null;
+        return { provider: chosen.id, model: custom };
+    }
+    return { provider: chosen.id, model: models[modelIdx].model };
+}

package/dist/local/jobs/jobStore.js

@@ -0,0 +1,80 @@
+/**
+ * Background-job state, persisted under `.orangepro/jobs/` (gitignored via the
+ * `.orangepro` ignore). Pure file helpers — NO process spawning here — so they are
+ * unit-testable with a tmp root. The detached child writes its status JSON so an
+ * agent can poll completion; the bell/notification is best-effort on top.
+ */
+import { appendFileSync, existsSync, mkdirSync, readdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { randomBytes } from "node:crypto";
+import { workspacePaths } from "../workspace.js";
+export function jobsDir(root) {
+    return join(workspacePaths(root).dir, "jobs");
+}
+export function jobJsonPath(root, id) {
+    return join(jobsDir(root), `${id}.json`);
+}
+export function jobLogPath(root, id) {
+    return join(jobsDir(root), `${id}.log`);
+}
+/** Result payload for a --single (agent-mode) job: generated tests + run hints. */
+export function jobResultPath(root, id) {
+    return join(jobsDir(root), `${id}.result.json`);
+}
+/** Fresh, time-sortable job id. Injectable clock/rng for deterministic tests. */
+export function newJobId(now = Date.now, rnd = () => randomBytes(3).toString("hex")) {
+    return `job_${now().toString(36)}_${rnd()}`;
+}
+function ensureDir(root) {
+    mkdirSync(jobsDir(root), { recursive: true });
+}
+/** Write the record atomically (temp + rename) so a poller never reads a half file. */
+export function writeJobRecord(root, rec) {
+    ensureDir(root);
+    const path = jobJsonPath(root, rec.id);
+    const tmp = `${path}.tmp`;
+    writeFileSync(tmp, JSON.stringify(rec, null, 2) + "\n", "utf8");
+    renameSync(tmp, path);
+}
+export function readJobRecord(root, id) {
+    const path = jobJsonPath(root, id);
+    if (!existsSync(path))
+        return null;
+    try {
+        return JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+/** Immutable read-modify-write of a job record. Returns the new record (or null if absent). */
+export function updateJobRecord(root, id, patch) {
+    const cur = readJobRecord(root, id);
+    if (!cur)
+        return null;
+    const next = { ...cur, ...patch };
+    writeJobRecord(root, next);
+    return next;
+}
+/** All job records, newest first. */
+export function listJobs(root) {
+    const dir = jobsDir(root);
+    if (!existsSync(dir))
+        return [];
+    const recs = [];
+    for (const f of readdirSync(dir)) {
+        if (!f.endsWith(".json"))
+            continue;
+        try {
+            recs.push(JSON.parse(readFileSync(join(dir, f), "utf8")));
+        }
+        catch {
+            // skip a corrupt/partial record
+        }
+    }
+    return recs.sort((a, b) => (a.created_at < b.created_at ? 1 : a.created_at > b.created_at ? -1 : 0));
+}
+export function appendJobLog(root, id, line) {
+    ensureDir(root);
+    appendFileSync(jobLogPath(root, id), line.endsWith("\n") ? line : `${line}\n`, "utf8");
+}

package/dist/local/jobs/notify.js

@@ -0,0 +1,29 @@
+/**
+ * Best-effort completion notification for a background job. The status JSON is the
+ * canonical signal an agent polls; this just nudges a human: a terminal bell
+ * (cross-platform, zero deps) and, on macOS, an optional `osascript` notification.
+ * All side effects are injectable so tests never fire a real OS notification.
+ */
+import { execFile } from "node:child_process";
+const BELL = String.fromCharCode(7); // ASCII BEL — terminal beep, zero deps
+export function notifyJobDone(rec, hooks = {}) {
+    const write = hooks.write ?? ((s) => void process.stderr.write(s));
+    const platform = hooks.platform ?? process.platform;
+    // Terminal bell — the canonical completion signal stays the status file.
+    write(BELL);
+    const title = "OrangePro";
+    const body = `Job ${rec.id} ${rec.status}`;
+    const notifier = hooks.notifier ??
+        ((t, b) => {
+            if (platform !== "darwin")
+                return;
+            try {
+                // Array args (injection-safe); fire-and-forget, swallow any error.
+                execFile("osascript", ["-e", `display notification ${JSON.stringify(b)} with title ${JSON.stringify(t)}`], () => { });
+            }
+            catch {
+                // best-effort only
+            }
+        });
+    notifier(title, body);
+}

package/dist/local/jobs/runner.js

@@ -0,0 +1,75 @@
+/**
+ * Executes a background `generate` job IN the detached child. Reuses the same
+ * op* functions unchanged; the only extra is streaming progress to the job log
+ * and recording status transitions. Directly callable (no spawning) so tests can
+ * run it with a tmp root + deterministic provider.
+ *
+ * Two modes:
+ *  - "compare" (default A/B): runs opCompare + writeCompareReport.
+ *  - "single" (agent mode): runs opGenerate and writes a result file with the
+ *    generated tests + run hints so a polling agent can write & run them.
+ */
+import { writeFileSync } from "node:fs";
+import { opCompare, opGenerate, writeCompareReport } from "../operations.js";
+import { runnableRunHintsFor, AGENT_RUN_WORKFLOW } from "../generate/runHints.js";
+import { setProgressReporter } from "../util/progress.js";
+import { appendJobLog, jobLogPath, jobResultPath, readJobRecord, updateJobRecord, writeJobRecord } from "./jobStore.js";
+import { notifyJobDone } from "./notify.js";
+export async function runGenerateJob(root, id, opts, deps, mode = "compare") {
+    const stamp = () => (deps ? deps.clock() : new Date().toISOString());
+    // The launcher normally pre-creates the queued record; create it if missing so
+    // runGenerateJob is self-sufficient (and directly unit-testable).
+    if (!readJobRecord(root, id)) {
+        writeJobRecord(root, { id, status: "queued", command: "generate", created_at: stamp(), cwd: root, args: {}, log_path: jobLogPath(root, id) });
+    }
+    updateJobRecord(root, id, { status: "running", started_at: stamp(), pid: process.pid });
+    setProgressReporter((m) => appendJobLog(root, id, m));
+    try {
+        if (mode === "single") {
+            appendJobLog(root, id, "Generating tests (single arm — agent mode)…");
+            const result = await opGenerate(root, opts, deps);
+            const resultPath = jobResultPath(root, id);
+            // The durable handoff for an agent: each test's code + suggested path + run command.
+            writeFileSync(resultPath, JSON.stringify({
+                model_provider: result.model_provider,
+                model_name: result.model_name,
+                generated_tests: result.generated_tests,
+                run_hints: runnableRunHintsFor(result.generated_tests, root),
+                agent_workflow: AGENT_RUN_WORKFLOW,
+                missing_evidence: result.missing_evidence,
+                warnings: result.warnings
+            }, null, 2) + "\n", "utf8");
+            updateJobRecord(root, id, { status: "done", finished_at: stamp(), outputs: { result_path: resultPath } });
+            appendJobLog(root, id, `Done — ${result.generated_tests.length} test(s) + run hints: ${resultPath}`);
+        }
+        else {
+            appendJobLog(root, id, "Generating A/B comparison (prompt-only vs Local KG)…");
+            const cmp = await opCompare(root, opts, deps);
+            const noTests = cmp.baseline.generated_tests.length === 0 && cmp.grounded.generated_tests.length === 0;
+            const outputs = cmp.model_provider !== "none" && !noTests ? writeCompareReport(root, cmp, deps) : undefined;
+            updateJobRecord(root, id, {
+                status: "done",
+                finished_at: stamp(),
+                outputs: outputs
+                    ? {
+                        tests_path: outputs.local_kg_tests_path,
+                        report_path: outputs.report_path,
+                        report_json_path: outputs.report_json_path
+                    }
+                    : undefined
+            });
+            appendJobLog(root, id, outputs ? `Done — Local KG tests: ${outputs.local_kg_tests_path}` : "Done — no tests generated (see report).");
+        }
+    }
+    catch (e) {
+        const error = e instanceof Error ? e.message : String(e);
+        updateJobRecord(root, id, { status: "failed", finished_at: stamp(), error });
+        appendJobLog(root, id, `Failed: ${error}`);
+    }
+    finally {
+        setProgressReporter(null);
+        const rec = readJobRecord(root, id);
+        if (rec)
+            notifyJobDone(rec);
+    }
+}

package/dist/local/ledger.js

@@ -0,0 +1,117 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { workspacePaths } from "./workspace.js";
+import { hashString } from "./util/hash.js";
+export const LEDGER_SCHEMA_VERSION = "orangepro.local_ledger.v1";
+export const LEDGER_FILE = "ledger.json";
+export function ledgerPath(root) {
+    return join(workspacePaths(root).dir, LEDGER_FILE);
+}
+export function proofEdgesFor(graph, symExtId) {
+    return graph.edges
+        .filter((e) => e.relationship_type === "COVERS" && e.evidence_strength === "hard" && e.to_external_id === symExtId)
+        .map(edgeKey)
+        .sort();
+}
+export function reproveTarget(preEdges, postGraph, symExtId) {
+    const pre = new Set(preEdges);
+    const newEdges = proofEdgesFor(postGraph, symExtId).filter((e) => !pre.has(e));
+    return { closed: newEdges.length > 0, newEdges };
+}
+export function resolveTargetSymbol(graph, target) {
+    const node = graph.nodes.find((n) => n.external_id === target);
+    if (node?.kind === "CodeSymbol")
+        return node.external_id;
+    const directSymbols = new Set();
+    for (const edge of graph.edges) {
+        if (edge.from_external_id !== target && edge.to_external_id !== target)
+            continue;
+        if (edge.evidence_strength !== "hard")
+            continue;
+        const other = edge.from_external_id === target ? edge.to_external_id : edge.from_external_id;
+        if (graph.nodes.find((n) => n.external_id === other && n.kind === "CodeSymbol"))
+            directSymbols.add(other);
+    }
+    return directSymbols.size === 1 ? [...directSymbols][0] : null;
+}
+export function targetLanguage(symExtId) {
+    const file = symExtId.match(/^sym:(.+)#/)?.[1] ?? "";
+    const ext = file.split(".").pop()?.toLowerCase();
+    if (ext === "ts" || ext === "tsx" || ext === "js" || ext === "jsx" || ext === "mts" || ext === "cts" || ext === "mjs" || ext === "cjs")
+        return "typescript";
+    if (ext === "go")
+        return "go";
+    if (ext === "java")
+        return "java";
+    if (ext === "py")
+        return "python";
+    return ext || "unknown";
+}
+export function canReproveLanguage(language) {
+    return language === "typescript" || language === "go";
+}
+export function loadLedger(root) {
+    const path = ledgerPath(root);
+    if (!existsSync(path))
+        return { schema_version: LEDGER_SCHEMA_VERSION, records: [] };
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    if (parsed.schema_version !== LEDGER_SCHEMA_VERSION) {
+        throw new Error(`Ledger schema mismatch: found ${parsed.schema_version ?? "unknown"}, expected ${LEDGER_SCHEMA_VERSION}.`);
+    }
+    return parsed;
+}
+export function appendLedgerRecord(root, input) {
+    const path = ledgerPath(root);
+    const ledger = loadLedger(root);
+    const record = {
+        ...input,
+        run_id: input.run_id || `run:${String(ledger.records.length + 1).padStart(6, "0")}`,
+        evidence_ids: [...new Set(input.evidence_ids ?? [])].sort(),
+        pre_edge_count: input.pre_edges.length
+    };
+    ledger.records.push(record);
+    mkdirSync(workspacePaths(root).dir, { recursive: true });
+    writeFileSync(path, JSON.stringify(ledger, null, 2) + "\n", "utf8");
+    return { ledger_path: path, record };
+}
+export function ledgerStats(root) {
+    const path = ledgerPath(root);
+    const ledger = loadLedger(root);
+    const attempted = ledger.records.filter((r) => r.status === "reproven" || r.status === "unproven").length;
+    const reproven = ledger.records.filter((r) => r.status === "reproven").length;
+    const unproven = ledger.records.filter((r) => r.status === "unproven").length;
+    return {
+        ledger_path: path,
+        records: ledger.records.length,
+        attempted,
+        reproven,
+        unproven,
+        already_proven: ledger.records.filter((r) => r.status === "already_proven").length,
+        generated_unverifiable: ledger.records.filter((r) => r.status === "generated_unverifiable").length,
+        quality_adjusted_kept_rate: attempted > 0 ? Number(((reproven / attempted) * 100).toFixed(2)) : 0
+    };
+}
+function edgeKey(edge) {
+    return `${edge.from_external_id}->${edge.to_external_id}`;
+}
+/**
+ * Composite code-identity fingerprint for a proven target: the target file's
+ * manifest content hash + the symbol external id + the credited member/method.
+ * Both the ledger writer (`opDynamicProof`) and RTM call THIS one function, so a
+ * proof only re-surfaces as Proven while the code it proved is byte-identical
+ * (any change to the file's content — hence its hash — lapses the proof).
+ * Returns `undefined` when the file has no manifest hash (synthesized symbol /
+ * not analyzed) or the id is not a parseable `sym:<file>#<name>` → no fingerprint
+ * → the record is never counted as Proven.
+ */
+export function targetFingerprint(graph, symExtId) {
+    const match = /^sym:(.+)#([^#]+)$/.exec(symExtId);
+    if (!match)
+        return undefined;
+    const [, file, symbolName] = match;
+    const member = symbolName.split(".").filter(Boolean).pop();
+    const fileHash = graph.manifest.files[file]?.hash;
+    if (!fileHash || !member)
+        return undefined;
+    return hashString([fileHash, symExtId, member].join("|"));
+}

package/dist/local/localConfig.js

@@ -0,0 +1,112 @@
+/**
+ * Local proof-kit configuration: privacy defaults + BYOK provider resolution.
+ *
+ * Security invariant: model provider API keys are read from the environment at
+ * call time and are NEVER written into the workspace config, the graph, or the
+ * evidence pack.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+export function defaultPrivacySettings() {
+    return { upload_enabled: false, source_snippets_in_pack: false };
+}
+export const PROVIDER_ENV_FILES = [".env.provider.local", ".env.local", ".env"];
+const PROVIDER_ENV_KEYS = new Set([
+    "OPENAI_API_KEY",
+    "OPENAI_BASE_URL",
+    "OPENAI_MODEL",
+    "ANTHROPIC_API_KEY",
+    "ANTHROPIC_BASE_URL",
+    "ANTHROPIC_MODEL",
+    "OLLAMA_BASE_URL",
+    "OLLAMA_MODEL",
+    "ORANGEPRO_PROVIDER"
+]);
+function parseEnvFile(contents) {
+    const out = {};
+    for (const rawLine of contents.split(/\r?\n/)) {
+        const line = rawLine.trim();
+        if (!line || line.startsWith("#"))
+            continue;
+        const match = /^(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)$/.exec(line);
+        if (!match || !PROVIDER_ENV_KEYS.has(match[1]))
+            continue;
+        let value = match[2].trim();
+        if ((value.startsWith("\"") && value.endsWith("\"")) ||
+            (value.startsWith("'") && value.endsWith("'"))) {
+            value = value.slice(1, -1);
+        }
+        out[match[1]] = value;
+    }
+    return out;
+}
+export function loadProviderEnv(roots, env = process.env) {
+    const merged = {};
+    const seen = new Set();
+    for (const root of roots) {
+        if (!root)
+            continue;
+        const abs = resolve(root);
+        if (seen.has(abs))
+            continue;
+        seen.add(abs);
+        for (const name of PROVIDER_ENV_FILES) {
+            const file = join(abs, name);
+            if (!existsSync(file))
+                continue;
+            try {
+                Object.assign(merged, parseEnvFile(readFileSync(file, "utf8")));
+            }
+            catch {
+                /* Ignore unreadable local env files; callers will surface no-provider guidance. */
+            }
+        }
+    }
+    return { ...merged, ...env };
+}
+/**
+ * Resolve a BYOK provider from env + optional per-call override.
+ * Returns null when no usable provider credentials are present, so callers can
+ * fall back to a deterministic provider (offline/demo) or surface guidance.
+ */
+export function resolveProviderConfig(env = process.env, override = {}) {
+    const requested = (override.provider || env.ORANGEPRO_PROVIDER || "").toLowerCase();
+    const tryOpenAI = () => {
+        if (!env.OPENAI_API_KEY)
+            return null;
+        return {
+            provider: "openai",
+            model: override.model || env.OPENAI_MODEL || "gpt-4.1",
+            baseUrl: (env.OPENAI_BASE_URL || "https://api.openai.com/v1").replace(/\/+$/, ""),
+            apiKey: env.OPENAI_API_KEY
+        };
+    };
+    const tryAnthropic = () => {
+        if (!env.ANTHROPIC_API_KEY)
+            return null;
+        return {
+            provider: "anthropic",
+            model: override.model || env.ANTHROPIC_MODEL || "claude-sonnet-4-6",
+            baseUrl: (env.ANTHROPIC_BASE_URL || "https://api.anthropic.com/v1").replace(/\/+$/, ""),
+            apiKey: env.ANTHROPIC_API_KEY
+        };
+    };
+    const tryOllama = () => {
+        const base = env.OLLAMA_BASE_URL;
+        if (!base && requested !== "ollama")
+            return null;
+        return {
+            provider: "ollama",
+            model: override.model || env.OLLAMA_MODEL || "llama3.1",
+            baseUrl: (base || "http://localhost:11434").replace(/\/+$/, "")
+        };
+    };
+    if (requested === "openai")
+        return tryOpenAI();
+    if (requested === "anthropic")
+        return tryAnthropic();
+    if (requested === "ollama")
+        return tryOllama();
+    // Auto-detect order: OpenAI-compatible, then Ollama, then Anthropic.
+    return tryOpenAI() || tryOllama() || tryAnthropic();
+}