open-memex 0.4.1 → 0.5.0-alpha.2

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,191 @@ 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";
+}
+
+/**
+ * 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`);
+      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;
 }
 
@@ -252,6 +403,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 +468,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 +649,31 @@ 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.`);
 }