open-memex 0.4.0 → 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.`);
 }

package/src/store/v2migrate.ts

@@ -118,23 +118,48 @@ export interface MigrateV2Result {
 }
 
 /**
- * Merge a legacy `my-o-memory` data root into the current `open-memex` root.
- * The old dir is renamed to a dated backup — never deleted. Returns the
- * backup path, or null when no legacy dir exists.
+ * Locate a legacy `my-o-memory` data root next to the current root.
+ * Pure lookup — no disk writes.
  */
-function migrateLegacyDataRoot(dryRun: boolean): string | null {
+export function findLegacyDataRoot(): string | null {
   const { root } = paths();
   const legacy = path.join(path.dirname(root), "my-o-memory");
   if (!fs.existsSync(legacy) || !fs.statSync(legacy).isDirectory()) return null;
+  return legacy;
+}
 
+/** Dated backup path for a legacy data root. Pure — no disk writes. */
+export function legacyBackupPath(legacy: string): string {
   const stamp = new Date().toISOString().slice(0, 10);
-  const backup = `${legacy}.backup-${stamp}`;
-  if (!dryRun) {
-    const legacyMem = path.join(legacy, "memories");
-    if (fs.existsSync(legacyMem)) {
-      for (const entry of fs.readdirSync(legacyMem)) {
-        const src = path.join(legacyMem, entry);
-        const dst = path.join(root, "memories", entry);
+  return `${legacy}.backup-${stamp}`;
+}
+
+/**
+ * Merge a legacy `my-o-memory` data root into the current `open-memex` root.
+ * The old dir is renamed to a dated backup — never deleted.
+ * Failures throw an actionable Error (no raw syscall dump): on Windows the
+ * backup rename typically fails with EPERM when another program holds the
+ * folder open.
+ */
+function mergeLegacyDataRoot(legacy: string, backup: string): void {
+  const { memories } = paths();
+  const fail = (where: string, err: unknown): never => {
+    const code = (err as NodeJS.ErrnoException)?.code;
+    throw new Error(
+      `could not ${where} (${legacy})` +
+        (code ? ` [${code}]` : "") +
+        `. Another program may be holding the folder open (e.g. a running MCP server, editor, or antivirus). ` +
+        `Your memories are safe — nothing was deleted. Close the program and re-run ` +
+        `\`open-memex migrate --to-v2\`, or rename the folder to ${backup} yourself and re-run.`,
+    );
+  };
+  const legacyMem = path.join(legacy, "memories");
+  if (fs.existsSync(legacyMem)) {
+    fs.mkdirSync(memories, { recursive: true });
+    for (const entry of fs.readdirSync(legacyMem)) {
+      const src = path.join(legacyMem, entry);
+      const dst = path.join(memories, entry);
+      try {
         if (!fs.existsSync(dst)) {
           fs.renameSync(src, dst);
         } else {
@@ -145,46 +170,75 @@ function migrateLegacyDataRoot(dryRun: boolean): string | null {
             if (!fs.existsSync(d)) fs.renameSync(s, d);
           }
         }
+      } catch (err) {
+        fail(`move memories from the legacy data dir`, err);
       }
     }
+  }
+  try {
     fs.renameSync(legacy, backup);
+  } catch (err) {
+    fail(`back up the legacy data dir`, err);
   }
-  return backup;
 }
 
-export function migrateV2(opts: { dryRun: boolean }): MigrateV2Result {
-  const { memories: memoriesRoot } = paths();
-  const result: MigrateV2Result = {
-    scanned: 0,
-    converted: 0,
-    skippedV2: 0,
-    plans: [],
-    legacyBackup: null,
-  };
-
-  result.legacyBackup = migrateLegacyDataRoot(opts.dryRun);
-
-  if (!fs.existsSync(memoriesRoot)) return result;
-  for (const entry of fs.readdirSync(memoriesRoot, { withFileTypes: true })) {
+/** Plan v1 → v2 conversion for every `.md` file under `dir`. Read-only. */
+function planDir(
+  dir: string,
+  memoriesRoot: string,
+  result: MigrateV2Result,
+): void {
+  if (!fs.existsSync(dir)) return;
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
     if (!entry.isDirectory()) continue;
-    const dir = path.join(memoriesRoot, entry.name);
-    for (const name of fs.readdirSync(dir)) {
+    const sub = path.join(dir, entry.name);
+    for (const name of fs.readdirSync(sub)) {
       if (!name.endsWith(".md")) continue;
-      const filePath = path.join(dir, name);
+      const filePath = path.join(sub, name);
       result.scanned++;
       const plan = planConversion(filePath, memoriesRoot);
       if (!plan) {
         result.skippedV2++;
         continue;
       }
-      if (!opts.dryRun) {
-        fs.mkdirSync(path.dirname(plan.toPath), { recursive: true });
-        fs.writeFileSync(plan.toPath, serialize(plan.fm, plan.body), "utf8");
-        if (plan.toPath !== plan.fromPath) fs.unlinkSync(plan.fromPath);
-      }
       result.converted++;
       result.plans.push(plan);
     }
   }
+}
+
+/** Apply conversion plans to disk (real run only — never in dry-run). */
+function applyPlans(result: MigrateV2Result): void {
+  for (const plan of result.plans) {
+    fs.mkdirSync(path.dirname(plan.toPath), { recursive: true });
+    fs.writeFileSync(plan.toPath, serialize(plan.fm, plan.body), "utf8");
+    if (plan.toPath !== plan.fromPath) fs.unlinkSync(plan.fromPath);
+  }
+}
+
+export function migrateV2(opts: { dryRun: boolean }): MigrateV2Result {
+  const { memories: memoriesRoot } = paths();
+  const result: MigrateV2Result = {
+    scanned: 0,
+    converted: 0,
+    skippedV2: 0,
+    plans: [],
+    legacyBackup: null,
+  };
+
+  const legacy = findLegacyDataRoot();
+  if (legacy) {
+    result.legacyBackup = legacyBackupPath(legacy);
+    if (opts.dryRun) {
+      // D44: dry-run previews the legacy files in place — nothing is moved,
+      // so the preview actually shows what would convert (issue #7).
+      planDir(path.join(legacy, "memories"), memoriesRoot, result);
+    } else {
+      mergeLegacyDataRoot(legacy, result.legacyBackup);
+    }
+  }
+
+  planDir(memoriesRoot, memoriesRoot, result);
+  if (!opts.dryRun) applyPlans(result);
   return result;
 }