open-memex 0.4.1 → 0.5.0-alpha.4

package/dist/init.js

@@ -4,6 +4,7 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { createInterface } from "node:readline/promises";
+import { pathToFileURL, fileURLToPath } from "node:url";
 import { DEFAULT_CONFIG, saveConfig } from "./config.js";
 import { projectRoot } from "./paths.js";
 const MARKER = "<!-- open-memex -->";
@@ -100,6 +101,82 @@ function writeMcpJson(root, client, force) {
     const dir = client === "cursor" ? path.join(root, ".cursor") : path.join(root, ".vscode");
     const file = path.join(dir, "mcp.json");
     const sectionKey = client === "cursor" ? "mcpServers" : "servers";
+    const { entry, durable } = stdioServerEntry(client);
+    const written = writeServerEntryFile(file, sectionKey, entry, force, true);
+    if (written)
+        warnNonDurable(durable);
+    return written;
+}
+/**
+ * D45: user-level MCP config path — `init --global` writes here so one init
+ * covers all projects. `platform` and `home` are parameters (default: current)
+ * so tests can cover all OS layouts without mocking.
+ */
+export function userMcpConfigPath(client, platform = process.platform, home = os.homedir()) {
+    if (client === "cursor")
+        return path.join(home, ".cursor", "mcp.json");
+    if (platform === "win32") {
+        const appData = process.env.APPDATA || path.join(home, "AppData", "Roaming");
+        return path.join(appData, "Code", "User", "mcp.json");
+    }
+    if (platform === "darwin") {
+        return path.join(home, "Library", "Application Support", "Code", "User", "mcp.json");
+    }
+    const xdg = process.env.XDG_CONFIG_HOME || path.join(home, ".config");
+    return path.join(xdg, "Code", "User", "mcp.json");
+}
+/** The open-memex server entry, same shape init writes at project level. */
+function stdioServerEntry(client) {
+    // D17: resolve the server command at init time — a one-shot npx leaves no bin behind.
+    const mc = resolveMcpCommand();
+    const entry = client === "cursor"
+        ? { command: mc.command, args: mc.args }
+        : {
+            type: "stdio",
+            command: mc.command,
+            args: mc.args,
+            // VS Code substitutes ${workspaceFolder} per window, so the server
+            // starts with the open project as cwd and scope resolution just works.
+            cwd: "${workspaceFolder}",
+        };
+    return { entry, durable: mc.durable };
+}
+/** Warn when init had to fall back to an npx-based server command. */
+function warnNonDurable(durable) {
+    if (durable)
+        return;
+    console.log(`  ! no durable \`open-memex\` on PATH (one-shot npx?) — wrote an npx-based command.`);
+    console.log(`    For faster startup: \`npm i -g ${ALPHA_TAG}\`, then re-run \`open-memex init --force\`.`);
+}
+/**
+ * Pure merge of one server entry into a parsed config doc.
+ * Returns "added" when the entry was written, "kept" when an entry already
+ * existed and force was not set. Mutates `doc`.
+ */
+export function mergeServerEntry(doc, sectionKey, entry, force) {
+    const section = (doc[sectionKey] ??= {});
+    if (section["open-memex"] && !force)
+        return "kept";
+    section["open-memex"] = entry;
+    return "added";
+}
+/**
+ * D46-followup: when a config file isn't valid JSON we leave it untouched —
+ * but "fix it manually" alone isn't helpful. Print the exact snippet the
+ * user needs to add by hand (same idea as the opencode --global hint).
+ */
+export function printManualEntryHint(sectionKey, entry) {
+    console.error(`    Add this under "${sectionKey}":`);
+    const pretty = JSON.stringify({ "open-memex": entry }, null, 2).replace(/\n/g, "\n    ");
+    console.error(`    ${pretty}`);
+}
+/**
+ * Read (or create) a JSON config file, merge the open-memex server entry, write
+ * it back. Existing files are merged, never clobbered; invalid JSON is left
+ * untouched. `mkdir` controls whether parent dirs are created (user-level
+ * configs) or expected to exist via the project root.
+ */
+function writeServerEntryFile(file, sectionKey, entry, force, mkdir) {
     let doc = {};
     if (fs.existsSync(file)) {
         try {
@@ -107,32 +184,97 @@ function writeMcpJson(root, client, force) {
         }
         catch {
             console.error(`  ! ${file} is not valid JSON — left untouched, fix it manually`);
+            printManualEntryHint(sectionKey, entry);
             return null;
         }
     }
-    const section = (doc[sectionKey] ??= {});
-    if (section["open-memex"] && !force) {
+    const merged = mergeServerEntry(doc, sectionKey, entry, force);
+    if (merged === "kept") {
         console.log(`  = ${file} already configures open-memex — left as is (use --force to overwrite)`);
         return file;
     }
-    // D17: resolve the server command at init time — a one-shot npx leaves no bin behind.
-    const mc = resolveMcpCommand();
-    section["open-memex"] =
-        client === "cursor"
-            ? { command: mc.command, args: mc.args }
-            : {
-                type: "stdio",
-                command: mc.command,
-                args: mc.args,
-                cwd: "${workspaceFolder}",
-            };
-    fs.mkdirSync(dir, { recursive: true });
+    if (mkdir)
+        fs.mkdirSync(path.dirname(file), { recursive: true });
     fs.writeFileSync(file, JSON.stringify(doc, null, 2) + "\n");
     console.log(`  + ${file}`);
-    if (!mc.durable) {
-        console.log(`  ! no durable \`open-memex\` on PATH (one-shot npx?) — wrote an npx-based command.`);
-        console.log(`    For faster startup: \`npm i -g ${ALPHA_TAG}\`, then re-run \`open-memex init --force\`.`);
+    return file;
+}
+/** D45: `init --global` — one-time user-level wiring for VS Code / Cursor. */
+function writeGlobalMcpJson(client, force) {
+    const file = userMcpConfigPath(client);
+    const sectionKey = client === "cursor" ? "mcpServers" : "servers";
+    const { entry, durable } = stdioServerEntry(client);
+    const written = writeServerEntryFile(file, sectionKey, entry, force, true);
+    if (written) {
+        warnNonDurable(durable);
+        const projFile = client === "cursor" ? ".cursor/mcp.json" : ".vscode/mcp.json";
+        console.log(`  i user-level config — the open-memex MCP server now starts in every project.`);
+        console.log(`    (a per-project ${projFile} still wins if a project defines its own)`);
+    }
+    return written;
+}
+/** Where this installed copy's opencode native plugin entry point lives. */
+function opencodePluginUrl() {
+    // init.ts sits in <pkg>/src — the plugin entry is <pkg>/src/index.ts.
+    const pkgRoot = path.dirname(path.dirname(fileURLToPath(import.meta.url)));
+    return pathToFileURL(path.join(pkgRoot, "src", "index.ts")).href;
+}
+/**
+ * D46: opencode's user-level config. opencode reads `~/.config/opencode/`
+ * (`$XDG_CONFIG_HOME` when set) on every platform; a `plugin` entry there
+ * loads open-memex in every project with no per-project init.
+ */
+export function opencodeGlobalConfigPath(home = os.homedir()) {
+    return path.join(opencodeConfigDir(home, process.env.XDG_CONFIG_HOME), "opencode.json");
+}
+/**
+ * Pure merge of the open-memex plugin URL into a parsed opencode config doc.
+ * Creates the `plugin` array when missing; never duplicates the URL.
+ * Returns "added" when the doc changed, "kept" when already present.
+ */
+export function mergePluginEntry(doc, url, force) {
+    let plugins = doc["plugin"];
+    if (!Array.isArray(plugins)) {
+        plugins = [];
+        doc["plugin"] = plugins;
+    }
+    const list = plugins;
+    if (list.includes(url) && !force)
+        return "kept";
+    if (!list.includes(url))
+        list.push(url);
+    return "added";
+}
+/**
+ * D46: wire the native plugin at the opencode user level — the one-time
+ * global setup. Merges into the existing config when it parses as JSON;
+ * a file with comments (JSONC) is left untouched with a manual hint instead
+ * of being clobbered.
+ */
+function writeOpencodeGlobalPlugin(force) {
+    const dir = path.dirname(opencodeGlobalConfigPath());
+    const file = ["opencode.jsonc", "opencode.json"]
+        .map((f) => path.join(dir, f))
+        .find((f) => fs.existsSync(f)) ?? path.join(dir, "opencode.json");
+    const url = opencodePluginUrl();
+    let doc = {};
+    if (fs.existsSync(file)) {
+        try {
+            doc = JSON.parse(fs.readFileSync(file, "utf8"));
+        }
+        catch {
+            console.log(`  ! ${file} has comments or invalid JSON — left untouched, fix it manually.`);
+            console.log(`    To enable open-memex everywhere, add "plugin": ["${url}"] to it.`);
+            return null;
+        }
+    }
+    if (mergePluginEntry(doc, url, force) === "kept") {
+        console.log(`  = ${file} already loads the open-memex plugin — left as is (use --force to overwrite)`);
+        return file;
     }
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, JSON.stringify(doc, null, 2) + "\n");
+    console.log(`  + ${file} (native plugin — works in every project, no per-project init needed)`);
     return file;
 }
 /** opencode MCP config: project-level opencode.jsonc, `type: "local"` + command array (v1 format). */
@@ -145,6 +287,12 @@ function writeOpencodeMcpJson(root, force) {
         }
         catch {
             console.error(`  ! ${file} is not valid JSON — left untouched, fix it manually`);
+            const mc = resolveMcpCommand();
+            printManualEntryHint("mcp", {
+                type: "local",
+                command: [mc.command, ...mc.args],
+                enabled: true,
+            });
             return null;
         }
     }
@@ -180,6 +328,12 @@ function writeVisualStudioMcpJson(root, force) {
         }
         catch {
             console.error(`  ! ${file} is not valid JSON — left untouched, fix it manually`);
+            const mc = resolveMcpCommand();
+            printManualEntryHint("servers", {
+                type: "stdio",
+                command: mc.command,
+                args: mc.args,
+            });
             return null;
         }
     }
@@ -293,17 +447,133 @@ async function promptInstructionsScope() {
         rl.close();
     }
 }
+/** D45: ask whether the MCP server config should be project-level or user-level. */
+async function promptConfigLevel() {
+    console.log("Where should the MCP server config live?");
+    console.log("  1) this project only — .vscode/mcp.json (or .cursor/mcp.json)");
+    console.log("  2) user-level — all projects, init once (VS Code / Cursor)");
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        const ans = (await rl.question("Choice [1]: ")).trim();
+        return ans === "2";
+    }
+    finally {
+        rl.close();
+    }
+}
+function exists(p) {
+    try {
+        return fs.existsSync(p);
+    }
+    catch {
+        return false;
+    }
+}
+/** True when `name` resolves on PATH (honors .cmd/.exe on Windows). */
+function binOnPath(name, pathEnv, platform) {
+    const names = platform === "win32" ? [`${name}.cmd`, `${name}.exe`, name] : [name];
+    return pathEnv
+        .split(path.delimiter)
+        .filter((d) => d && !d.includes("_npx"))
+        .some((d) => names.some((n) => exists(path.join(d, n))));
+}
+function opencodeConfigDir(home, xdg) {
+    return path.join(xdg || path.join(home, ".config"), "opencode");
+}
+/**
+ * D46: detect which supported editors are installed. Used when `init` runs
+ * without --client — one init wires every detected editor (user-level where
+ * the editor supports it). Visual Studio is included only when the project
+ * has a solution file, since VS config is solution-scoped by design.
+ */
+export function detectInstalledClients(env = {}) {
+    const platform = env.platform ?? process.platform;
+    const pathEnv = env.pathEnv ?? process.env.PATH ?? "";
+    const home = env.home ?? os.homedir();
+    const found = [];
+    // VS Code: bin on PATH, well-known install location, or an existing
+    // user-level MCP config (a previous init counts as installed).
+    const vscodeInstallPaths = platform === "win32"
+        ? [path.join(home, "AppData", "Local", "Programs", "Microsoft VS Code", "Code.exe")]
+        : platform === "darwin"
+            ? ["/Applications/Visual Studio Code.app"]
+            : ["/usr/bin/code", "/usr/share/code/bin/code", "/snap/bin/code"];
+    if (binOnPath("code", pathEnv, platform) ||
+        vscodeInstallPaths.some(exists) ||
+        exists(userMcpConfigPath("vscode", platform, home))) {
+        found.push("vscode");
+    }
+    // Cursor: bin on PATH or its user config dir exists.
+    if (binOnPath("cursor", pathEnv, platform) || exists(path.join(home, ".cursor"))) {
+        found.push("cursor");
+    }
+    // opencode: bin on PATH or its global config dir exists.
+    const xdg = env.xdgConfigHome ?? process.env.XDG_CONFIG_HOME;
+    if (binOnPath("opencode", pathEnv, platform) || exists(opencodeConfigDir(home, xdg))) {
+        found.push("opencode");
+    }
+    // Visual Studio: solution-scoped — only when the project has a .sln.
+    let hasSln = false;
+    try {
+        hasSln = fs.readdirSync(env.root ?? projectRoot()).some((f) => f.toLowerCase().endsWith(".sln"));
+    }
+    catch {
+        hasSln = false;
+    }
+    if (hasSln)
+        found.push("visualstudio");
+    return found;
+}
 export async function initProject(opts) {
     const interactive = !opts.yes && !!process.stdin.isTTY && !!process.stdout.isTTY;
-    let client = normalizeClient(opts.client ?? "");
-    if (client && !INIT_CLIENTS.includes(client)) {
+    const explicit = normalizeClient(opts.client ?? "");
+    if (explicit && !INIT_CLIENTS.includes(explicit)) {
         console.error(`unknown client "${opts.client}" (${INIT_CLIENTS.join("|")})`);
         process.exit(1);
     }
-    if (!client && interactive)
-        client = (await promptClient()) ?? "";
-    if (!client && !interactive)
-        client = "vscode"; // historical default for scripts / one-shot npx
+    // D46: no --client → auto-detect installed editors and wire them all
+    // (user-level where the editor supports it — init once). An explicit
+    // --client keeps the old single-editor behavior.
+    let clients;
+    let autoGlobal = false;
+    if (explicit) {
+        clients = [explicit];
+    }
+    else if (interactive) {
+        const detected = detectInstalledClients();
+        if (detected.length === 0) {
+            console.log("  - no supported editors detected — editor setup skipped");
+            clients = [];
+        }
+        else {
+            console.log(`Detected editors: ${detected.join(", ")}`);
+            const all = await askBool("Wire up open-memex in all of them (one-time, user-level where supported)?", true);
+            if (all) {
+                clients = detected;
+                autoGlobal = true;
+            }
+            else {
+                const one = await promptClient();
+                clients = one ? [one] : [];
+            }
+        }
+    }
+    else {
+        clients = detectInstalledClients();
+        autoGlobal = true;
+        if (clients.length === 0) {
+            console.log("  - no supported editors detected — editor setup skipped");
+        }
+        else {
+            console.log(`Detected editors: ${clients.join(", ")} — wiring all (use --client to pick one)`);
+        }
+    }
+    let global = !!opts.global || autoGlobal;
+    // The project-vs-user-level choice only applies to an explicit single
+    // client; auto mode is user-level by design (init once).
+    if (explicit && !global && interactive && (clients[0] === "vscode" || clients[0] === "cursor")) {
+        global = await promptConfigLevel();
+    }
     let scope = "personal";
     if (opts.instructions) {
         if (opts.instructions !== "personal" && opts.instructions !== "project") {
@@ -332,17 +602,233 @@ export async function initProject(opts) {
     }
     const root = projectRoot();
     console.log(`open-memex init — project root: ${root}`);
-    if (client) {
-        writeMcpJson(root, client, opts.force);
+    for (const client of clients) {
+        if (client === "vscode" || client === "cursor") {
+            if (global)
+                writeGlobalMcpJson(client, opts.force);
+            else
+                writeMcpJson(root, client, opts.force);
+        }
+        else if (client === "opencode") {
+            // D46: the native plugin is the one-time global setup; without --global
+            // (explicit single-client mode) keep the per-project plain-MCP config.
+            if (global)
+                writeOpencodeGlobalPlugin(opts.force);
+            else
+                writeMcpJson(root, client, opts.force);
+        }
+        else if (client === "visualstudio") {
+            if (explicit && global) {
+                console.log(`  - visualstudio: --global not supported — VS uses solution-level .mcp.json by design.`);
+            }
+            else {
+                writeMcpJson(root, client, opts.force);
+            }
+        }
+    }
+    if (clients.length === 0) {
+        console.log("  - editor setup skipped");
+    }
+    else if (clients.some((c) => c !== "opencode")) {
         // copilot-instructions.md is VS Code/Cursor-shaped; opencode as a plain MCP
         // consumer already gets the guidance from the tool descriptions (D16).
         // D22: personal scope (default) writes to the Copilot user-level location
         // so the repo stays clean for teammates without open-memex.
-        if (client !== "opencode")
-            writeInstructions(root, scope, client);
+        writeInstructions(root, scope, clients.find((c) => c !== "opencode"));
+    }
+    console.log(`\nDone. Reload your editor window to start the open-memex MCP server.`);
+}
+// ---------------------------------------------------------------------------
+// uninstall — the reverse of init (D48). Removes the editor wiring init wrote:
+// the MCP server entry, the opencode native plugin line, and the Copilot
+// instructions section. Memory data is never touched.
+// ---------------------------------------------------------------------------
+/**
+ * Pure removal of the open-memex server entry from a parsed config doc.
+ * Prunes the section when it becomes empty. Mutates `doc`.
+ */
+export function removeServerEntry(doc, sectionKey) {
+    const section = doc[sectionKey];
+    if (!section || typeof section !== "object" || !("open-memex" in section))
+        return "absent";
+    delete section["open-memex"];
+    if (Object.keys(section).length === 0)
+        delete doc[sectionKey];
+    return "removed";
+}
+/**
+ * Pure removal of open-memex plugin entries from a parsed opencode config doc.
+ * Matches any plugin URL containing `match` (robust against the package moving
+ * between installs). Prunes the `plugin` array when it becomes empty.
+ * Mutates `doc`.
+ */
+export function removePluginEntry(doc, match) {
+    const plugins = doc["plugin"];
+    if (!Array.isArray(plugins))
+        return "absent";
+    const kept = plugins.filter((p) => !(typeof p === "string" && p.includes(match)));
+    if (kept.length === plugins.length)
+        return "absent";
+    if (kept.length === 0)
+        delete doc["plugin"];
+    else
+        doc["plugin"] = kept;
+    return "removed";
+}
+/**
+ * Pure removal of the open-memex instructions section from a
+ * copilot-instructions.md body. init always appends it last (MARKER..end),
+ * so cutting from the marker to the end is exact; returns "" when nothing
+ * but the section remains so the caller can delete the file.
+ */
+export function removeInstructionsSection(text) {
+    const idx = text.lastIndexOf(MARKER);
+    if (idx < 0)
+        return text;
+    const rest = text.slice(0, idx).replace(/\s+$/, "");
+    return rest ? rest + "\n" : "";
+}
+/**
+ * Remove the server entry from one JSON config file. Existing files are
+ * merged, never clobbered; invalid JSON is left untouched with the manual
+ * step (same D47 treatment as the init write path).
+ */
+function removeServerEntryFile(file, sectionKey) {
+    if (!fs.existsSync(file))
+        return "absent";
+    let doc;
+    try {
+        doc = JSON.parse(fs.readFileSync(file, "utf8"));
+    }
+    catch {
+        console.error(`  ! ${file} is not valid JSON — left untouched, fix it manually`);
+        console.error(`    Delete the "open-memex" key under "${sectionKey}".`);
+        return null;
+    }
+    const res = removeServerEntry(doc, sectionKey);
+    if (res === "removed") {
+        fs.writeFileSync(file, JSON.stringify(doc, null, 2) + "\n");
+        console.log(`  - ${file} (open-memex entry removed)`);
+    }
+    return res;
+}
+/** Remove the open-memex plugin URL from one opencode user-level config file. */
+function removeOpencodePluginFile(file) {
+    if (!fs.existsSync(file))
+        return "absent";
+    let doc;
+    try {
+        doc = JSON.parse(fs.readFileSync(file, "utf8"));
+    }
+    catch {
+        console.error(`  ! ${file} is not valid JSON — left untouched, fix it manually`);
+        console.error(`    Delete the open-memex URL from the "plugin" array.`);
+        return null;
+    }
+    const res = removePluginEntry(doc, "open-memex");
+    if (res === "removed") {
+        fs.writeFileSync(file, JSON.stringify(doc, null, 2) + "\n");
+        console.log(`  - ${file} (open-memex plugin removed)`);
+    }
+    return res;
+}
+/** Remove the open-memex section from one copilot-instructions.md file. */
+function removeInstructionsFile(file) {
+    if (!fs.existsSync(file))
+        return "absent";
+    const cur = fs.readFileSync(file, "utf8");
+    if (!cur.includes(MARKER))
+        return "absent";
+    const next = removeInstructionsSection(cur);
+    if (next === "") {
+        fs.unlinkSync(file);
+        console.log(`  - ${file} (deleted — it only held open-memex instructions)`);
     }
     else {
-        console.log("  - editor setup skipped");
+        fs.writeFileSync(file, next);
+        console.log(`  - ${file} (open-memex instructions removed)`);
     }
-    console.log(`\nDone. Reload your editor window to start the open-memex MCP server.`);
+    return "removed";
+}
+export async function uninstallProject(opts) {
+    const interactive = !opts.yes && !!process.stdin.isTTY && !!process.stdout.isTTY;
+    const explicit = normalizeClient(opts.client ?? "");
+    if (explicit && !INIT_CLIENTS.includes(explicit)) {
+        console.error(`unknown client "${opts.client}" (${INIT_CLIENTS.join("|")})`);
+        process.exit(1);
+    }
+    // Mirror init's client resolution: explicit --client, else auto-detect.
+    let clients;
+    if (explicit) {
+        clients = [explicit];
+    }
+    else if (interactive) {
+        const detected = detectInstalledClients();
+        if (detected.length === 0) {
+            console.log("  - no supported editors detected — nothing to remove");
+            return;
+        }
+        console.log(`Detected editors: ${detected.join(", ")}`);
+        const all = await askBool("Remove open-memex wiring from all of them?", true);
+        if (all) {
+            clients = detected;
+        }
+        else {
+            const one = await promptClient();
+            clients = one ? [one] : [];
+        }
+    }
+    else {
+        clients = detectInstalledClients();
+        if (clients.length > 0) {
+            console.log(`Detected editors: ${clients.join(", ")} — removing from all (use --client to pick one)`);
+        }
+    }
+    if (clients.length === 0) {
+        console.log("  - nothing to remove");
+        return;
+    }
+    // Without --global, clean both levels: init may have written either one,
+    // and a leftover entry at the other level would be a surprise.
+    const levels = opts.global ? ["user"] : ["project", "user"];
+    const root = projectRoot();
+    console.log(`open-memex uninstall — project root: ${root}`);
+    let changed = 0;
+    const bump = (r) => {
+        if (r === "removed")
+            changed++;
+    };
+    for (const client of clients) {
+        if (client === "vscode" || client === "cursor") {
+            const sectionKey = client === "cursor" ? "mcpServers" : "servers";
+            for (const level of levels) {
+                const file = level === "user"
+                    ? userMcpConfigPath(client)
+                    : path.join(root, client === "cursor" ? ".cursor/mcp.json" : ".vscode/mcp.json");
+                bump(removeServerEntryFile(file, sectionKey));
+            }
+        }
+        else if (client === "opencode") {
+            for (const level of levels) {
+                if (level === "user")
+                    bump(removeOpencodePluginFile(opencodeGlobalConfigPath()));
+                else
+                    bump(removeServerEntryFile(path.join(root, "opencode.jsonc"), "mcp"));
+            }
+        }
+        else if (client === "visualstudio") {
+            // Solution-level only — --global is meaningless, same as init.
+            bump(removeServerEntryFile(path.join(root, ".mcp.json"), "servers"));
+        }
+    }
+    // Copilot instructions: init may have written personal (default) or project.
+    if (clients.some((c) => c !== "opencode")) {
+        bump(removeInstructionsFile(path.join(os.homedir(), ".copilot", "copilot-instructions.md")));
+        bump(removeInstructionsFile(path.join(os.homedir(), "copilot-instructions.md")));
+        bump(removeInstructionsFile(path.join(root, ".github", "copilot-instructions.md")));
+    }
+    console.log(changed > 0
+        ? `\nDone. Removed open-memex wiring from ${changed} file(s).`
+        : "\nDone. Nothing to remove — no open-memex wiring found.");
+    console.log("Your memories are untouched (uninstall never deletes data).");
 }

package/docs/TEST-PLAN.md

@@ -33,6 +33,8 @@
 
 - [ ] Cursor：`open-memex mcp --print-config cursor` → 贴到 Cursor MCP 配置 → 能连上
 - [ ] opencode：`open-memex init --client opencode` → `opencode.jsonc` 生效
+- [ ] `open-memex init --yes`（不带 --client）→ 自动检测已装编辑器并一次全接上
+- [ ] opencode：`open-memex init --client opencode --global` → `~/.config/opencode/opencode.json` 的 `plugin` 数组合并（带注释的 jsonc 不动、只给手动提示）
 - [ ] Claude Code：`open-memex mcp --print-config claude` 给出的 `claude mcp add` 命令能跑通
 
 ## D. 跨机迁移（export/import 真实场景）