open-memex 0.4.1 → 0.5.0-alpha.2

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,72 @@ 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";
+}
+/**
+ * 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 {
@@ -110,29 +177,93 @@ function writeMcpJson(root, client, force) {
             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). */
@@ -293,17 +424,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 +579,39 @@ 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);
-    }
-    else {
-        console.log("  - editor setup skipped");
+        writeInstructions(root, scope, clients.find((c) => c !== "opencode"));
     }
     console.log(`\nDone. Reload your editor window to start the open-memex MCP server.`);
 }

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 真实场景）

package/docs/V2-DESIGN.md

@@ -882,6 +882,24 @@ requirement: personal data never touches third-party services). Benchmarks to tr
   cannot confirm what the real run will do; and a destructive-path failure must
   speak in user terms. Shipped as 0.4.1 hotfix on the stable line. Approved
   2026-09-29.*
+- **D45** — `init --global` (0.5.0-alpha.1): one-time user-level MCP wiring for
+  VS Code / Cursor. Writes the open-memex server entry to the editor's
+  user-level `mcp.json` (`%APPDATA%\Code\User\mcp.json` on Windows,
+  `~/Library/Application Support/Code/User/mcp.json` on macOS,
+  `~/.config/Code/User/mcp.json` on Linux; `~/.cursor/mcp.json` for Cursor)
+  instead of the project's `.vscode/mcp.json` — init once, the server starts
+  in every project. The entry keeps `cwd: "${workspaceFolder}"` so VS Code
+  substitutes it per window and project-scope resolution keeps working;
+  a per-project config still wins when present. Merge semantics are shared
+  with project-level init (merge, never clobber; `--force` overwrites).
+  Interactive `init` now asks per-project vs user-level for vscode/cursor
+  (default: per-project, preserving old behavior); `--global` skips the
+  question. For opencode, `--global` is a no-op that prints the native-plugin
+  one-liner (already global, and strictly more capable than plain-MCP mode);
+  Visual Studio stays solution-level by design. *Rationale: per-project init
+  is a paper cut that compounds — the data layer already needs zero per-project
+  setup (scope is derived from cwd), so the editor wiring should be able to
+  match. Approved 2026-09-29.*
 - **D41** — The type taxonomy is reconciled to 11 types with one-line definitions
   (§3.1): `fact` `preference` `decision` `constraint` `todo` `knowledge` `howto`
   `gotcha` `lesson` `observation` `reference`. Merged away: `warning`→`gotcha`,
@@ -893,6 +911,25 @@ requirement: personal data never touches third-party services). Benchmarks to tr
   is deliberately broader than `incident`: a postmortem's shape (timeline, root
   cause, actions) is a template concern, not a type. Code
   `MEMORY_TYPE_TAXONOMY` updated to match. Approved 2026-09-28.*
+- **D46** — `init` with no `--client` auto-detects installed editors and wires
+  them all (0.5.0-alpha.2). Detection: VS Code via `code` on `PATH`, well-known
+  install locations, or an existing user-level `mcp.json`; Cursor via `cursor`
+  on `PATH` or `~/.cursor`; opencode via `opencode` on `PATH` or its global
+  config dir; Visual Studio only when the project has a `.sln` (solution-scoped
+  by design). Auto mode always wires user-level where the editor supports it —
+  VS Code / Cursor MCP entry (D45), and for opencode the native plugin entry is
+  now *actually merged* into `~/.config/opencode/opencode.json` (replacing D45's
+  hint-only `--global`), so one init covers every editor and every project.
+  A config file with comments (JSONC) is never rewritten — init prints the
+  manual one-liner instead. Interactive `init` shows the detected editors and
+  confirms wiring all of them (declining falls back to the single-editor
+  prompt); non-interactive (`--yes`) wires all detected with no prompts.
+  An explicit `--client` keeps the old single-editor behavior, including the
+  per-project default for vscode/cursor. *Rationale: Stone's two hats — he
+  writes code in several editors himself, and new users / pilot colleagues
+  should not have to learn `--client` to get started. The help text already
+  promised "default: auto-detect"; D46 makes the code keep that promise.
+  Approved 2026-09-29.*
 
 ## Open Questions
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-memex",
-  "version": "0.4.1",
+  "version": "0.5.0-alpha.2",
   "description": "Local-first memory layer and protocol for AI coding agents. Markdown source of truth, SQLite FTS5 index, zero cloud.",
   "type": "module",
   "license": "Apache-2.0",

package/scripts/smoke-pure.ts

@@ -8,6 +8,7 @@ import { DEFAULT_CONFIG } from "../src/config.ts";
 import { resolveProjectScope, resolveCwdScope, PERSONAL_SCOPE } from "../src/scope.ts";
 import { cjkIndexText, cjkQueryExpr, hasCjk } from "../src/retrieve/cjk.ts";
 import { contentHash, similarity, NEAR_DUP_THRESHOLD } from "../src/store/lifecycle.ts";
+import { userMcpConfigPath, mergeServerEntry, detectInstalledClients, mergePluginEntry, opencodeGlobalConfigPath } from "../src/init.ts";
 
 let fails = 0;
 function ok(name: string, cond: boolean, info?: unknown) {
@@ -376,5 +377,74 @@ const near = similarity(
 ok(`similarity near-dup ${near.toFixed(2)} >= ${NEAR_DUP_THRESHOLD}`, near >= NEAR_DUP_THRESHOLD);
 ok("similarity empty → 0", similarity("", "anything") === 0);
 
+console.log("== init --global: userMcpConfigPath / mergeServerEntry ==");
+// D45: user-level MCP config locations, per platform (platform param is injectable).
+ok("vscode win32", userMcpConfigPath("vscode", "win32").endsWith(path.join("Code", "User", "mcp.json")));
+ok("vscode darwin", userMcpConfigPath("vscode", "darwin").includes(path.join("Library", "Application Support", "Code", "User", "mcp.json")));
+ok("vscode linux", userMcpConfigPath("vscode", "linux").endsWith(path.join(".config", "Code", "User", "mcp.json")));
+ok("cursor is ~/.cursor/mcp.json on every platform",
+  (["win32", "darwin", "linux"] as const).every((p) =>
+    userMcpConfigPath("cursor", p).endsWith(path.join(".cursor", "mcp.json"))));
+// mergeServerEntry: pure merge semantics.
+const doc1: Record<string, unknown> = {};
+ok("merge into empty doc adds", mergeServerEntry(doc1, "servers", { command: "x" }, false) === "added");
+ok("entry landed under section", (doc1["servers"] as Record<string, unknown>)["open-memex"] !== undefined);
+ok("existing entry kept without force", mergeServerEntry(doc1, "servers", { command: "y" }, false) === "kept");
+ok("kept entry untouched", ((doc1["servers"] as Record<string, unknown>)["open-memex"] as Record<string, unknown>)["command"] === "x");
+ok("force overwrites", mergeServerEntry(doc1, "servers", { command: "y" }, true) === "added");
+ok("forced entry applied", ((doc1["servers"] as Record<string, unknown>)["open-memex"] as Record<string, unknown>)["command"] === "y");
+const doc2: Record<string, unknown> = { servers: { other: { command: "z" } } };
+ok("merge preserves sibling entries", mergeServerEntry(doc2, "servers", { command: "x" }, false) === "added"
+  && (doc2["servers"] as Record<string, unknown>)["other"] !== undefined);
+
+console.log("== init D46: auto-detect + opencode global plugin ==");
+// opencodeGlobalConfigPath: user-level location, XDG-aware.
+const fakeHome = fs.mkdtempSync(path.join(os.tmpdir(), "memex-smoke-"));
+ok("opencode global config under ~/.config/opencode",
+  opencodeGlobalConfigPath(fakeHome).endsWith(path.join(".config", "opencode", "opencode.json")));
+ok("opencode global config honors XDG_CONFIG_HOME", (() => {
+  const prev = process.env.XDG_CONFIG_HOME;
+  process.env.XDG_CONFIG_HOME = path.join(fakeHome, "xdg");
+  try {
+    return opencodeGlobalConfigPath(fakeHome).startsWith(path.join(fakeHome, "xdg"));
+  } finally {
+    if (prev === undefined) delete process.env.XDG_CONFIG_HOME;
+    else process.env.XDG_CONFIG_HOME = prev;
+  }
+})());
+// mergePluginEntry: pure merge semantics.
+const pdoc: Record<string, unknown> = {};
+ok("plugin merge creates array", mergePluginEntry(pdoc, "file:///x", false) === "added"
+  && JSON.stringify(pdoc["plugin"]) === JSON.stringify(["file:///x"]));
+ok("plugin merge dup kept", mergePluginEntry(pdoc, "file:///x", false) === "kept");
+ok("plugin merge force on dup adds nothing twice", mergePluginEntry(pdoc, "file:///x", true) === "added"
+  && (pdoc["plugin"] as unknown[]).length === 1);
+const pdoc2: Record<string, unknown> = { plugin: ["file:///other"], theme: "dark" };
+ok("plugin merge preserves siblings", mergePluginEntry(pdoc2, "file:///x", false) === "added"
+  && (pdoc2["plugin"] as unknown[]).length === 2 && pdoc2["theme"] === "dark");
+// detectInstalledClients with a fully fake env.
+const binDir = fs.mkdtempSync(path.join(os.tmpdir(), "memex-bin-"));
+fs.writeFileSync(path.join(binDir, "code"), "#!/bin/sh\n");
+const detHome = fs.mkdtempSync(path.join(os.tmpdir(), "memex-home-"));
+fs.mkdirSync(path.join(detHome, ".cursor"), { recursive: true });
+fs.mkdirSync(path.join(detHome, ".config", "opencode"), { recursive: true });
+const detRoot = fs.mkdtempSync(path.join(os.tmpdir(), "memex-root-"));
+const detEnv = { pathEnv: binDir, home: detHome, platform: "linux" as const, root: detRoot, xdgConfigHome: path.join(detHome, ".config") };
+const det = detectInstalledClients(detEnv);
+ok("detects vscode via PATH", det.includes("vscode"));
+ok("detects cursor via ~/.cursor", det.includes("cursor"));
+ok("detects opencode via config dir", det.includes("opencode"));
+ok("no visualstudio without .sln", !det.includes("visualstudio"));
+fs.writeFileSync(path.join(detRoot, "app.sln"), "");
+ok("visualstudio detected with .sln", detectInstalledClients(detEnv).includes("visualstudio"));
+const emptyHome = fs.mkdtempSync(path.join(os.tmpdir(), "memex-empty-"));
+const detEmpty = detectInstalledClients({ pathEnv: "", home: emptyHome, platform: "linux", root: emptyHome, xdgConfigHome: path.join(emptyHome, ".config") });
+ok("empty env detects nothing", detEmpty.length === 0);
+const winBin = fs.mkdtempSync(path.join(os.tmpdir(), "memex-winbin-"));
+fs.writeFileSync(path.join(winBin, "code.cmd"), "@echo off\n");
+ok("win32 detects vscode via code.cmd",
+  detectInstalledClients({ pathEnv: winBin, home: emptyHome, platform: "win32", root: emptyHome, xdgConfigHome: path.join(emptyHome, ".config") }).includes("vscode"));
+for (const d of [fakeHome, binDir, detHome, detRoot, emptyHome, winBin]) fs.rmSync(d, { recursive: true, force: true });
+
 console.log(fails === 0 ? "\nALL PASS" : `\n${fails} FAILURES`);
 process.exit(fails === 0 ? 0 : 1);

package/src/cli.ts

@@ -279,16 +279,21 @@ Examples:
 agent memory instructions. Existing files are merged, never clobbered.
 
 Usage: open-memex init [--client vscode|cursor|opencode|visualstudio]
-              [--instructions personal|project] [--force] [--yes]
+              [--instructions personal|project] [--global] [--force] [--yes]
 
 Flags:
-  --client        editor to configure (default: auto-detect)
+  --client        editor to configure (default: auto-detect all installed editors)
   --instructions  personal (default, ~/.copilot/copilot-instructions.md) or project
+  --global        write the MCP server entry to the editor's user-level config
+                  (VS Code / Cursor) — init once, works in every project.
+                  For opencode, --global wires the native plugin at user level
+                  (~/.config/opencode/opencode.json) — no per-project init needed.
   --force         overwrite existing config
   --yes           accept all defaults, never prompt
 
 Examples:
   open-memex init
+  open-memex init --client vscode --global --yes
   open-memex init --client cursor --yes`,
 
   config: `Show config, or set a key.
@@ -353,16 +358,19 @@ Usage:
 Every command has its own help with description and examples:
   open-memex <command> --help   (or -h)
 
-One-command project setup: \`open-memex init\` (or \`npx open-memex@alpha init\`) writes
-the MCP config for your editor (\`.vscode/mcp.json\`, \`.cursor/mcp.json\`,
-\`opencode.jsonc\`, or Visual Studio's solution-level \`.mcp.json\`) — no copy-paste
-needed. The Copilot memory instructions default to your user-level
+One-command project setup: \`open-memex init\` (or \`npx open-memex@alpha init\`) detects
+your installed editors and wires them all — user-level where the editor supports it
+(VS Code / Cursor MCP config, opencode native plugin), so one init covers every project;
+Visual Studio is included when the project has a solution file (its \`.mcp.json\`
+stays solution-level by design). \`--client\` picks a single editor instead, and a
+single-editor opencode init writes the per-project plain-MCP \`opencode.jsonc\`.
+The Copilot memory instructions default to your user-level
 \`~/.copilot/copilot-instructions.md\` (all projects, never checked into a repo);
 \`--instructions project\` writes \`.github/copilot-instructions.md\` instead for
 teams where everyone uses open-memex.
 Existing files are merged, never clobbered; re-running is safe. On a terminal it
-asks which editor to set up and a couple of settings (keyword capture, first-turn
-injection); \`--yes\` accepts all defaults, and non-terminal runs never prompt.
+confirms the detected editors and asks a couple of settings (keyword capture,
+first-turn injection); \`--yes\` accepts all defaults, and non-terminal runs never prompt.
 \`open-memex config set <key> <value>\` changes those settings after install.
 
 Once installed globally (\`npm i -g open-memex@alpha\`) the \`open-memex\` command is
@@ -595,7 +603,7 @@ async function main() {
   }
 
   // `init` is a pure file operation (§17 adoption path) — no DB needed.
-  // Interactive when on a TTY (asks editor + settings); --yes skips prompts.
+  // Interactive when on a TTY (confirms detected editors + settings); --yes skips prompts.
   if (cmd === "init") {
     const flags = parseFlags(rest);
     const { initProject } = await import("./init.ts");
@@ -604,6 +612,7 @@ async function main() {
       force: flags["force"] === "true",
       yes: flags["yes"] === "true",
       instructions: flags["instructions"],
+      global: flags["global"] === "true",
     });
     return;
   }