open-memex 0.3.0 → 0.4.0-alpha.10

package/dist/config.js

@@ -33,6 +33,8 @@ export const DEFAULT_CONFIG = {
     // Add only your own extra patterns here.
     redactPatterns: [],
     logLevel: "info",
+    memoryDir: ".ai/open-memex",
+    sync: { autoPull: false },
 };
 function stripJsonComments(raw) {
     // Line comments
@@ -63,12 +65,22 @@ function toNonNegInt(v) {
         throw new Error("must be a non-negative integer");
     return n;
 }
+function toRelativeDir(v) {
+    if (typeof v !== "string" || !v.trim())
+        throw new Error("must be a non-empty relative directory");
+    const t = v.trim().replace(/\\/g, "/").replace(/\/+$/, "");
+    if (!t || path.isAbsolute(t) || t.split("/").includes(".."))
+        throw new Error('must be a relative path without ".." (e.g. ".ai/open-memex")');
+    return t;
+}
 /** Keys users may change via `open-memex config set <key> <value>`, with validators. */
 export const SETTABLE_KEYS = {
     maxProjectMemories: toNonNegInt,
     maxProfileItems: toNonNegInt,
     injectOnFirstTurn: toBool,
     keywordCaptureEnabled: toBool,
+    memoryDir: toRelativeDir,
+    "sync.autoPull": toBool,
     logLevel: (v) => {
         if (v !== "info" && v !== "debug")
             throw new Error('must be "info" or "debug"');

package/dist/distill-agents.js

@@ -0,0 +1,55 @@
+/**
+ * distill-to-AGENTS.md assist (Phase 3).
+ *
+ * Turns distilled project memories (decisions, lessons, gotchas, howtos,
+ * constraints) into a proposed AGENTS.md snippet. ASSIST only: it prints
+ * (or writes with -o) a markdown section for the human to review and merge
+ * by hand — open-memex never rewrites your AGENTS.md on its own.
+ */
+import { db } from "./store/db.js";
+const DEFAULT_TYPES = ["decision", "constraint", "lesson", "gotcha", "howto"];
+export function distillAgentsMarkdown(opts) {
+    const types = opts.types?.length ? opts.types : DEFAULT_TYPES;
+    const limit = Math.max(1, Math.min(opts.limit ?? 30, 200));
+    const sql = `
+    SELECT id, type, tags, content, updated_at FROM memories
+    WHERE scope_key IN (${opts.scopeKeys.map(() => "?").join(",")})
+      AND type IN (${types.map(() => "?").join(",")})
+      AND status = 'active'
+    ORDER BY updated_at DESC
+    LIMIT ?`;
+    const rows = db()
+        .prepare(sql)
+        .all(...opts.scopeKeys, ...types, limit);
+    if (rows.length === 0)
+        return "";
+    const date = new Date().toISOString().slice(0, 10);
+    const lines = [
+        `## Learned (distilled from open-memex, ${date})`,
+        ``,
+        `<!-- Proposed by \`open-memex distill-agents\`. Review each line, keep`,
+        `what's true, delete the rest, then merge into this file by hand. -->`,
+        ``,
+    ];
+    // Group by type, preserving recency within each group.
+    const byType = new Map();
+    for (const r of rows) {
+        const g = byType.get(r.type) ?? [];
+        g.push(r);
+        byType.set(r.type, g);
+    }
+    for (const t of types) {
+        const g = byType.get(t);
+        if (!g?.length)
+            continue;
+        lines.push(`### ${t}`);
+        lines.push(``);
+        for (const r of g) {
+            const first = r.content.split("\n").map((l) => l.trim()).find((l) => l) ?? "";
+            const snippet = first.length > 160 ? first.slice(0, 160) + "…" : first;
+            lines.push(`- ${snippet} \`[${r.id.slice(0, 8)}]\``);
+        }
+        lines.push(``);
+    }
+    return lines.join("\n");
+}

package/dist/doctor.js

@@ -116,7 +116,7 @@ function mcpCheck() {
                         name,
                         ok: missing.length === 0,
                         detail: missing.length === 0
-                            ? `handshake OK, 5 tools listed (${names.join(", ")})`
+                            ? `handshake OK, ${names.length} tools listed (${names.join(", ")})`
                             : `missing tools: ${missing.join(", ")}`,
                     });
                 }

package/dist/export.js

@@ -0,0 +1,157 @@
+/**
+ * Export / import: portable memory archives (§9, D40).
+ *
+ * `export` bundles selected memories (markdown source of truth + manifest)
+ * into a single .tar.gz for moving to another machine or another app.
+ * `import` restores a bundle: personal memories go to the personal dir,
+ * project memories are re-keyed to the current project and land in the
+ * outbox as drafts (submit moves them into the repo).
+ *
+ * D40: export excludes `visibility: private` by default; `--all` / `-a`
+ * includes everything — the full-migration escape hatch.
+ */
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { execFileSync } from "node:child_process";
+import { db } from "./store/db.js";
+import { readMemoryFile, writeMemoryFile, normalizeFrontmatter, } from "./store/markdown.js";
+import { upsertFromFile } from "./store/sync.js";
+import { contentHash } from "./store/lifecycle.js";
+const EXPORT_FORMAT = "open-memex-export/1";
+function fail(msg) {
+    throw new Error(`[open-memex] ${msg}`);
+}
+function checkTar() {
+    try {
+        execFileSync("tar", ["--version"], { stdio: ["ignore", "pipe", "ignore"] });
+    }
+    catch {
+        fail("the `tar` command is required for export/import but was not found on PATH");
+    }
+}
+export function exportMemories(opts) {
+    checkTar();
+    const includePrivate = opts.includePrivate ?? false;
+    let sql = `SELECT id, scope_key, scope, visibility, type, file_path FROM memories WHERE scope_key IN (${opts.scopeKeys.map(() => "?").join(",")})`;
+    const params = [...opts.scopeKeys];
+    if (!includePrivate)
+        sql += ` AND visibility != 'private'`;
+    if (opts.type) {
+        sql += ` AND type = ?`;
+        params.push(opts.type);
+    }
+    if (opts.tag) {
+        sql += ` AND (',' || tags || ',' LIKE ?)`;
+        params.push(`%,${opts.tag},%`);
+    }
+    sql += ` ORDER BY updated_at DESC`;
+    const rows = db().prepare(sql).all(...params);
+    const skippedPrivate = includePrivate
+        ? 0
+        : db().prepare(`SELECT COUNT(*) AS n FROM memories WHERE scope_key IN (${opts.scopeKeys.map(() => "?").join(",")}) AND visibility = 'private'`).get(...opts.scopeKeys).n;
+    const stage = fs.mkdtempSync(path.join(os.tmpdir(), "open-memex-export-"));
+    try {
+        const memDir = path.join(stage, "memories");
+        fs.mkdirSync(memDir, { recursive: true });
+        const manifestEntries = [];
+        let exported = 0;
+        for (const r of rows) {
+            const mf = readMemoryFile(r.file_path);
+            if (!mf)
+                continue; // stale index row — skip, don't fail the export
+            const rel = path.join(r.scope, `${r.id}.md`);
+            const dest = path.join(memDir, rel);
+            fs.mkdirSync(path.dirname(dest), { recursive: true });
+            fs.copyFileSync(r.file_path, dest);
+            manifestEntries.push({ id: r.id, scope: r.scope, file: path.join("memories", rel) });
+            exported++;
+        }
+        const manifest = {
+            format: EXPORT_FORMAT,
+            exported_at: new Date().toISOString(),
+            open_memex_version: readPackageVersion(),
+            include_private: includePrivate,
+            filters: {
+                scope_keys: opts.scopeKeys,
+                type: opts.type ?? null,
+                tag: opts.tag ?? null,
+            },
+            memories: manifestEntries,
+        };
+        fs.writeFileSync(path.join(stage, "manifest.json"), JSON.stringify(manifest, null, 2), "utf8");
+        const stamp = new Date().toISOString().replace(/[:.]/g, "").slice(0, 15);
+        const outFile = opts.outFile ?? path.resolve(`open-memex-export-${stamp}.tar.gz`);
+        execFileSync("tar", ["-czf", outFile, "-C", stage, "manifest.json", "memories"], {
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        return { file: outFile, exported, skippedPrivate, includePrivate };
+    }
+    finally {
+        fs.rmSync(stage, { recursive: true, force: true });
+    }
+}
+function readPackageVersion() {
+    try {
+        const here = new URL(import.meta.url);
+        const pkg = path.join(path.dirname(here.pathname), "..", "package.json");
+        return JSON.parse(fs.readFileSync(pkg, "utf8")).version;
+    }
+    catch {
+        return "unknown";
+    }
+}
+export function importBundle(bundlePath, opts) {
+    checkTar();
+    if (!fs.existsSync(bundlePath))
+        fail(`bundle not found: ${bundlePath}`);
+    const stage = fs.mkdtempSync(path.join(os.tmpdir(), "open-memex-import-"));
+    try {
+        execFileSync("tar", ["-xzf", path.resolve(bundlePath), "-C", stage], {
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        const manifestPath = path.join(stage, "manifest.json");
+        if (!fs.existsSync(manifestPath))
+            fail("not an open-memex export bundle (manifest.json missing)");
+        const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+        if (manifest.format !== EXPORT_FORMAT) {
+            fail(`unsupported bundle format: ${manifest.format} (expected ${EXPORT_FORMAT})`);
+        }
+        const result = { imported: 0, skippedIdentical: 0, skippedConflict: [] };
+        const existingStmt = db().prepare(`SELECT content_hash FROM memories WHERE id = ?`);
+        for (const entry of manifest.memories ?? []) {
+            const src = path.join(stage, entry.file);
+            const mf = readMemoryFile(src);
+            if (!mf)
+                continue;
+            const fm = normalizeFrontmatter({ ...mf.fm });
+            // Re-key to this machine: personal stays personal; project memories
+            // adopt the current project's scope key (keys embed a path hash).
+            if (fm.scope === "project")
+                fm.scope_key = opts.projectScopeKey;
+            else if (fm.scope === "personal")
+                fm.scope_key = "personal";
+            const existing = existingStmt.get(fm.id);
+            if (existing) {
+                if (existing.content_hash === contentHash(mf.body))
+                    result.skippedIdentical++;
+                else
+                    result.skippedConflict.push({ id: fm.id, file: entry.file });
+                continue;
+            }
+            if (opts.dryRun) {
+                result.imported++;
+                continue;
+            }
+            const { filePath } = writeMemoryFile(fm, mf.body);
+            const written = readMemoryFile(filePath);
+            if (written)
+                upsertFromFile(written);
+            result.imported++;
+        }
+        return result;
+    }
+    finally {
+        fs.rmSync(stage, { recursive: true, force: true });
+    }
+}

package/dist/github.js

@@ -0,0 +1,215 @@
+/**
+ * 2B/D32: GitHub PR ↔ review_state mapping.
+ *
+ * Memories ride into review inside a branch + PR (dedicated memory PR or
+ * together with code). The PR's lifecycle on GitHub is the team's review
+ * signal; this module reads it back and maps it onto each memory's own
+ * review_state:
+ *
+ *   PR merged                        → proposed/approved → published
+ *   PR reviewDecision == APPROVED     → proposed → approved (approved_by = reviewer login)
+ *   PR reviewDecision == CHANGES_REQUESTED → suggestion only, printed for the human
+ *
+ * Per-memory independence: every memory on the branch keeps its own state.
+ * A locally `rejected` memory is never flipped by a PR approval, and a
+ * changes-requested review never auto-rejects — the human runs `promote`.
+ *
+ * Report by default; `--apply` performs the mapped transitions locally
+ * (file rewrite + index, never a push — inside the D27 local-git line).
+ * Needs the GitHub CLI (`gh`) authenticated on the user's machine.
+ */
+import { execFileSync } from "node:child_process";
+import * as fs from "node:fs";
+import { loadConfig } from "./config.js";
+import { projectRoot } from "./paths.js";
+import { parse as parseMemory } from "./store/markdown.js";
+import { iterInRepoMemoryFiles } from "./store/markdown.js";
+import { promoteMemory, currentAuthor } from "./review.js";
+function fail(msg) {
+    throw new Error(`[open-memex] ${msg}`);
+}
+function sh(cmd, args, cwd) {
+    try {
+        return execFileSync(cmd, args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim();
+    }
+    catch (e) {
+        const err = e;
+        const detail = (err.stderr ?? err.message ?? "").trim().split("\n")[0];
+        fail(`${cmd} ${args.join(" ")} failed${detail ? `: ${detail}` : ""}`);
+    }
+}
+/** Read the PR for a branch (default: current branch) via the GitHub CLI. */
+export function getPrInfo(branch) {
+    const root = projectRoot();
+    // `gh` must exist and be authenticated on the user's machine.
+    try {
+        execFileSync("gh", ["--version"], { stdio: ["ignore", "pipe", "ignore"] });
+    }
+    catch {
+        fail("the GitHub CLI (`gh`) is not installed — install it and run `gh auth login` first.");
+    }
+    const ref = branch ?? sh("git", ["branch", "--show-current"], root);
+    if (!ref)
+        fail("not on a branch — check out the memory branch first.");
+    let raw;
+    try {
+        raw = sh("gh", ["pr", "view", ref, "--json",
+            "number,url,state,mergedAt,reviewDecision,baseRefName,headRefName,title,reviews"], root);
+    }
+    catch {
+        return null; // no PR for this branch yet
+    }
+    let j;
+    try {
+        j = JSON.parse(raw);
+    }
+    catch {
+        fail(`could not parse \`gh pr view\` output for branch ${ref}.`);
+    }
+    const approvedBy = [];
+    const changesRequestedBy = [];
+    // Latest review per author wins.
+    const latest = new Map();
+    for (const r of j.reviews ?? []) {
+        const login = r.author?.login;
+        if (!login)
+            continue;
+        const prev = latest.get(login);
+        if (!prev || r.submittedAt >= prev.at)
+            latest.set(login, { state: r.state, at: r.submittedAt });
+    }
+    for (const [login, r] of latest) {
+        if (r.state === "APPROVED")
+            approvedBy.push(login);
+        else if (r.state === "CHANGES_REQUESTED")
+            changesRequestedBy.push(login);
+    }
+    return {
+        number: j.number,
+        url: j.url,
+        state: j.state === "OPEN" ? "open" : "closed",
+        merged: !!j.mergedAt,
+        mergedAt: j.mergedAt,
+        reviewDecision: j.reviewDecision ?? null,
+        approvedBy,
+        changesRequestedBy,
+        base: j.baseRefName,
+        head: j.headRefName,
+        title: j.title,
+    };
+}
+/** Map the branch PR's state onto each in-repo memory's review_state. */
+export function getPrStatus(branch) {
+    const root = projectRoot();
+    const cfg = loadConfig();
+    const current = branch ?? sh("git", ["branch", "--show-current"], root);
+    const pr = getPrInfo(current);
+    const mappings = [];
+    for (const fp of iterInRepoMemoryFiles(root, cfg.memoryDir)) {
+        const raw = fs.readFileSync(fp, "utf8");
+        const parsed = parseMemory(raw);
+        if (!parsed)
+            continue;
+        const from = parsed.fm.review_state ?? "draft";
+        const id = parsed.fm.id;
+        if (!pr) {
+            mappings.push({ memoryId: id, from, suggestedTo: null, reason: `no PR for branch ${current} yet`, approvedBy: null });
+            continue;
+        }
+        if (from === "published") {
+            mappings.push({ memoryId: id, from, suggestedTo: null, reason: "already published", approvedBy: null });
+            continue;
+        }
+        if (from === "rejected") {
+            mappings.push({ memoryId: id, from, suggestedTo: null, reason: `stays rejected — a PR ${pr.merged ? "merge" : "approval"} never overrides a human rejection`, approvedBy: null });
+            continue;
+        }
+        if (pr.merged) {
+            if (from === "proposed" || from === "approved") {
+                mappings.push({ memoryId: id, from, suggestedTo: "published", reason: `PR #${pr.number} merged`, approvedBy: null });
+            }
+            else {
+                mappings.push({ memoryId: id, from, suggestedTo: null, reason: `PR #${pr.number} merged, but memory is "${from}"`, approvedBy: null });
+            }
+            continue;
+        }
+        if (pr.reviewDecision === "APPROVED" && from === "proposed") {
+            const by = pr.approvedBy[0] ?? null;
+            mappings.push({
+                memoryId: id, from, suggestedTo: "approved",
+                reason: `PR #${pr.number} approved${by ? ` by @${by}` : ""}`, approvedBy: by,
+            });
+            continue;
+        }
+        if (pr.reviewDecision === "CHANGES_REQUESTED") {
+            const by = pr.changesRequestedBy[0] ?? null;
+            mappings.push({
+                memoryId: id, from, suggestedTo: null,
+                reason: `PR #${pr.number} has changes requested${by ? ` by @${by}` : ""} — run \`open-memex promote ${id} --reject --note "..."\` yourself if you agree`,
+                approvedBy: null,
+            });
+            continue;
+        }
+        mappings.push({
+            memoryId: id, from, suggestedTo: null,
+            reason: pr.state === "open" ? `PR #${pr.number} still awaiting review` : `PR #${pr.number} is closed without merge`,
+            approvedBy: null,
+        });
+    }
+    return { branch: current, pr, mappings };
+}
+/** Apply the mapped transitions locally (no push — D27). Advances step by
+ *  step through the ladder, so a merged PR moves proposed → approved →
+ *  published with each step in the audit trail. */
+export function applyPrStatus(st) {
+    const out = [];
+    const actor = currentAuthor();
+    const order = ["draft", "proposed", "approved", "published"];
+    for (const m of st.mappings) {
+        if (!m.suggestedTo || order.indexOf(m.from) >= order.indexOf(m.suggestedTo))
+            continue;
+        const by = m.approvedBy ?? actor;
+        const note = m.suggestedTo === "published" && st.pr
+            ? `PR #${st.pr.number} merged`
+            : m.reason;
+        let cur = m.from;
+        while (order.indexOf(cur) < order.indexOf(m.suggestedTo)) {
+            const r = promoteMemory(m.memoryId, { by, note });
+            cur = r.to;
+            out.push({ memoryId: m.memoryId, from: r.from, to: r.to, by });
+        }
+    }
+    return out;
+}
+export function formatPrStatus(st) {
+    const lines = [];
+    lines.push(`branch: ${st.branch}`);
+    if (!st.pr) {
+        lines.push(`PR: none yet — push the branch and open one, then re-run.`);
+    }
+    else {
+        const p = st.pr;
+        lines.push(`PR #${p.number}: ${p.title}`);
+        lines.push(`  ${p.url}`);
+        lines.push(`  state: ${p.merged ? `merged${p.mergedAt ? ` at ${p.mergedAt}` : ""}` : p.state}` +
+            (p.reviewDecision ? `, reviews: ${p.reviewDecision}` : ""));
+        if (p.approvedBy.length > 0)
+            lines.push(`  approved by: ${p.approvedBy.map((l) => "@" + l).join(", ")}`);
+        if (p.changesRequestedBy.length > 0)
+            lines.push(`  changes requested by: ${p.changesRequestedBy.map((l) => "@" + l).join(", ")}`);
+    }
+    if (st.mappings.length === 0) {
+        lines.push(`no in-repo memories on this branch.`);
+    }
+    else {
+        lines.push(`memories (${st.mappings.length}):`);
+        for (const m of st.mappings) {
+            const arrow = m.suggestedTo ? ` → [${m.suggestedTo}]` : "";
+            lines.push(`  ${m.memoryId.slice(0, 8)}  [${m.from}]${arrow}  ${m.reason}`);
+        }
+        if (st.mappings.some((m) => m.suggestedTo)) {
+            lines.push(`run with --apply to perform the mapped transitions locally (no push).`);
+        }
+    }
+    return lines.join("\n");
+}

package/dist/index.js

@@ -83,6 +83,12 @@ const plugin = async ({ worktree, directory }) => {
                     updated_at: rfc,
                     supersedes: null,
                     superseded_by: null,
+                    review_state: "draft",
+                    proposed_by: null,
+                    approved_by: null,
+                    derived_from: null,
+                    review_note: null,
+                    review_history: [],
                 };
                 try {
                     const { filePath } = writeMemoryFile(fm, content);

package/dist/init.js

@@ -3,9 +3,9 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { execFileSync } from "node:child_process";
 import { createInterface } from "node:readline/promises";
 import { DEFAULT_CONFIG, saveConfig } from "./config.js";
+import { projectRoot } from "./paths.js";
 const MARKER = "<!-- open-memex -->";
 /** npm dist-tag carrying the 0.3.x preview line. */
 const ALPHA_TAG = "open-memex@alpha";
@@ -39,34 +39,59 @@ const INSTRUCTIONS = `${MARKER}
 > Applies only when the \`open-memex\` MCP server is available in this session
 > (the \`memory_*\` tools exist). Otherwise ignore this section.
 
-You have a local memory MCP server (\`open-memex\`) with five tools:
-\`memory_add\`, \`memory_search\`, \`memory_list\`, \`memory_supersede\`, \`memory_forget\`.
+You have a local memory MCP server (\`open-memex\`) with eleven tools:
+\`memory_add\`, \`memory_search\`, \`memory_list\`, \`memory_supersede\`, \`memory_forget\`,
+\`memory_status\`, \`memory_submit\`, \`memory_propose\`, \`memory_promote\`, \`memory_resolve\`,
+\`memory_pr_status\`.
 
 - BE PROACTIVE. When the user shares something worth remembering across sessions
   (a decision, a preference, a project convention, a fix and its cause), call
   \`memory_add\` without being asked. Keep each memory to one self-contained statement.
+- At checkpoints (session start, end of a work chunk, after the user commits, after
+  any memory_* action), DISTILL the session: propose 1–3 short memories capturing the
+  useful conclusion — what was learned or decided, how an issue was resolved, what to
+  avoid, where the authoritative doc lives — not the raw transcript. Save NOTHING the
+  user did not approve; on approval call \`memory_add\` with source "inference" at the
+  confirmed scope. If the knowledge already lives in project docs, save a \`reference\`
+  memory pointing at the doc instead of copying it. Long-form notes are fine ONLY when
+  the user explicitly asks to save one.
 - Before asking the user about past decisions, conventions, or preferences they may
   have told you before, call \`memory_search\` first — try a few keyword variants
   (including the user's own language) when the first search comes up empty.
 - Memories default to this project's scope; use the \`personal\` scope for facts about
   the user that hold across all projects. When a saved fact becomes outdated, call
   \`memory_supersede\` instead of adding a duplicate.
+
+## Syncing project memories for review (D26)
+
+Project memories you save land in a local outbox first — they are NOT in git yet.
+Syncing them into the repo for review is an explicit, user-approved step:
+
+- At session start, when you finish a meaningful chunk of work, after the user
+  commits (git commit), and after any memory_* action completes, call
+  \`memory_status\`. If the outbox has drafts, summarize them (one line each) and ask
+  the user which ones to sync. Sync NOTHING the user did not name.
+- When the user says "sync memory" (or "同步记忆"), treat it as a request to run
+  the sync flow above: call \`memory_status\`, summarize the outbox drafts, and ask
+  which ones to sync.
+- When the user approves, call \`memory_submit\` with the approved ids. It copies
+  the drafts into the repo as \`proposed\`, commits locally on the CURRENT branch,
+  and prints the push + PR commands. It NEVER creates a branch on its own.
+- After the submit, ask ONE follow-up: "want me to create a branch + push +
+  open the PR, or will you handle it yourself?" A "yes, you do it" answer covers
+  the whole chain — branch creation, push, PR creation — do NOT re-ask at each
+  step. If the user says they will do it themselves, hand them the printed
+  push/PR commands and do nothing. NEVER create branches, push, or open PRs
+  without their explicit approval.
+- Base branch for the memory PR defaults to the branch you are on; the user may
+  redirect it to the integration branch (main) for branch-independent knowledge.
+- If anything conflicts (same id with different content, push rejected), STOP and
+  let the user judge — never overwrite.
+- After the PR merges, call \`memory_pr_status\` (with \`apply\` when the user
+  approves) to map the PR's review state back onto each memory — merged means
+  \`published\`, an approval means \`approved\` (credited to the reviewer).
+- \`personal\` scope memories NEVER leave the machine.
 `;
-/** Project root: git top-level, falling back to cwd. */
-function projectRoot() {
-    try {
-        const top = execFileSync("git", ["rev-parse", "--show-toplevel"], {
-            encoding: "utf8",
-            stdio: ["ignore", "pipe", "ignore"],
-        }).trim();
-        if (top)
-            return top;
-    }
-    catch {
-        /* not a git repo — use cwd */
-    }
-    return process.cwd();
-}
 function writeMcpJson(root, client, force) {
     if (client === "opencode")
         return writeOpencodeMcpJson(root, force);