open-memex 0.4.1 → 0.5.0-alpha.4

package/src/init.ts

@@ -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.ts";
 import { projectRoot } from "./paths.ts";
 
@@ -110,41 +111,203 @@ function writeMcpJson(root: string, client: string, force: boolean): string | nu
   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;
+}
 
-  let doc: Record<string, unknown> = {};
-  if (fs.existsSync(file)) {
-    try {
-      doc = JSON.parse(fs.readFileSync(file, "utf8")) as Record<string, unknown>;
-    } catch {
-      console.error(`  ! ${file} is not valid JSON — left untouched, fix it manually`);
-      return null;
-    }
+/**
+ * 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: "vscode" | "cursor",
+  platform: NodeJS.Platform = process.platform,
+  home: string = os.homedir(),
+): string {
+  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");
   }
-
-  const section = ((doc[sectionKey] ??= {}) as Record<string, unknown>);
-  if (section["open-memex"] && !force) {
-    console.log(`  = ${file} already configures open-memex — left as is (use --force to overwrite)`);
-    return file;
+  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: string): { entry: Record<string, unknown>; durable: boolean } {
   // D17: resolve the server command at init time — a one-shot npx leaves no bin behind.
   const mc = resolveMcpCommand();
-  section["open-memex"] =
+  const entry: Record<string, unknown> =
     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: boolean): void {
+  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\`.`);
+}
 
-  fs.mkdirSync(dir, { recursive: true });
+/**
+ * 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: Record<string, unknown>,
+  sectionKey: string,
+  entry: Record<string, unknown>,
+  force: boolean,
+): "added" | "kept" {
+  const section = ((doc[sectionKey] ??= {}) as Record<string, unknown>);
+  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: string, entry: Record<string, unknown>): void {
+  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: string,
+  sectionKey: string,
+  entry: Record<string, unknown>,
+  force: boolean,
+  mkdir: boolean,
+): string | null {
+  let doc: Record<string, unknown> = {};
+  if (fs.existsSync(file)) {
+    try {
+      doc = JSON.parse(fs.readFileSync(file, "utf8")) as Record<string, unknown>;
+    } catch {
+      console.error(`  ! ${file} is not valid JSON — left untouched, fix it manually`);
+      printManualEntryHint(sectionKey, entry);
+      return null;
+    }
+  }
+  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;
+  }
+  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: "vscode" | "cursor", force: boolean): string | null {
+  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(): string {
+  // 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: string = os.homedir()): string {
+  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: Record<string, unknown>,
+  url: string,
+  force: boolean,
+): "added" | "kept" {
+  let plugins = doc["plugin"];
+  if (!Array.isArray(plugins)) {
+    plugins = [] as unknown[];
+    doc["plugin"] = plugins;
   }
+  const list = plugins as unknown[];
+  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: boolean): string | null {
+  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: Record<string, unknown> = {};
+  if (fs.existsSync(file)) {
+    try {
+      doc = JSON.parse(fs.readFileSync(file, "utf8")) as Record<string, unknown>;
+    } 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;
 }
 
@@ -157,6 +320,12 @@ function writeOpencodeMcpJson(root: string, force: boolean): string | null {
       doc = JSON.parse(fs.readFileSync(file, "utf8")) as Record<string, unknown>;
     } 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;
     }
   }
@@ -192,6 +361,12 @@ function writeVisualStudioMcpJson(root: string, force: boolean): string | null {
       doc = JSON.parse(fs.readFileSync(file, "utf8")) as Record<string, unknown>;
     } 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;
     }
   }
@@ -252,6 +427,7 @@ function writeInstructions(
 }
 
 export const INIT_CLIENTS = ["vscode", "cursor", "opencode", "visualstudio"] as const;
+export type InitClient = (typeof INIT_CLIENTS)[number];
 
 /** Normalize --client values; accepts "visual-studio" as an alias. */
 export function normalizeClient(c: string): string {
@@ -316,20 +492,152 @@ async function promptInstructionsScope(): Promise<"personal" | "project"> {
   }
 }
 
+/** D45: ask whether the MCP server config should be project-level or user-level. */
+async function promptConfigLevel(): Promise<boolean> {
+  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();
+  }
+}
+
+/** D46: injectable environment for editor detection (tests pass fakes). */
+export interface DetectEnv {
+  pathEnv?: string;
+  home?: string;
+  platform?: NodeJS.Platform;
+  root?: string;
+  /** Overrides $XDG_CONFIG_HOME for the opencode global config dir. */
+  xdgConfigHome?: string;
+}
+
+function exists(p: string): boolean {
+  try {
+    return fs.existsSync(p);
+  } catch {
+    return false;
+  }
+}
+
+/** True when `name` resolves on PATH (honors .cmd/.exe on Windows). */
+function binOnPath(name: string, pathEnv: string, platform: NodeJS.Platform): boolean {
+  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: string, xdg: string | undefined): string {
+  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: DetectEnv = {}): InitClient[] {
+  const platform = env.platform ?? process.platform;
+  const pathEnv = env.pathEnv ?? process.env.PATH ?? "";
+  const home = env.home ?? os.homedir();
+  const found: InitClient[] = [];
+  // 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: {
   client?: string;
   force: boolean;
   yes: boolean;
   instructions?: string;
+  /** D45: write the MCP server entry to the editor's user-level config. */
+  global?: boolean;
 }): Promise<void> {
   const interactive = !opts.yes && !!process.stdin.isTTY && !!process.stdout.isTTY;
-  let client = normalizeClient(opts.client ?? "");
-  if (client && !(INIT_CLIENTS as readonly string[]).includes(client)) {
+  const explicit = normalizeClient(opts.client ?? "");
+  if (explicit && !(INIT_CLIENTS as readonly string[]).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: InitClient[];
+  let autoGlobal = false;
+  if (explicit) {
+    clients = [explicit as InitClient];
+  } 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 as InitClient] : [];
+      }
+    }
+  } 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" | "project" = "personal";
   if (opts.instructions) {
     if (opts.instructions !== "personal" && opts.instructions !== "project") {
@@ -365,15 +673,224 @@ 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.`);
 }
+
+// ---------------------------------------------------------------------------
+// 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: Record<string, unknown>,
+  sectionKey: string,
+): "removed" | "absent" {
+  const section = doc[sectionKey];
+  if (!section || typeof section !== "object" || !("open-memex" in section)) return "absent";
+  delete (section as Record<string, unknown>)["open-memex"];
+  if (Object.keys(section as Record<string, unknown>).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: Record<string, unknown>, match: string): "removed" | "absent" {
+  const plugins = doc["plugin"];
+  if (!Array.isArray(plugins)) return "absent";
+  const kept = (plugins as unknown[]).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: string): string {
+  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: string, sectionKey: string): "removed" | "absent" | null {
+  if (!fs.existsSync(file)) return "absent";
+  let doc: Record<string, unknown>;
+  try {
+    doc = JSON.parse(fs.readFileSync(file, "utf8")) as Record<string, unknown>;
+  } 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: string): "removed" | "absent" | null {
+  if (!fs.existsSync(file)) return "absent";
+  let doc: Record<string, unknown>;
+  try {
+    doc = JSON.parse(fs.readFileSync(file, "utf8")) as Record<string, unknown>;
+  } 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: string): "removed" | "absent" {
+  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 {
+    fs.writeFileSync(file, next);
+    console.log(`  - ${file} (open-memex instructions removed)`);
+  }
+  return "removed";
+}
+
+export async function uninstallProject(opts: {
+  client?: string;
+  /** D48: only the user-level config; without it, both levels are cleaned. */
+  global?: boolean;
+  yes: boolean;
+}): Promise<void> {
+  const interactive = !opts.yes && !!process.stdin.isTTY && !!process.stdout.isTTY;
+  const explicit = normalizeClient(opts.client ?? "");
+  if (explicit && !(INIT_CLIENTS as readonly string[]).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: InitClient[];
+  if (explicit) {
+    clients = [explicit as InitClient];
+  } 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 as InitClient] : [];
+    }
+  } 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: "removed" | "absent" | null) => {
+    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).");
+}