open-memex 0.4.0 → 0.5.0-alpha.2

package/scripts/smoke-pure.ts

@@ -1,13 +1,14 @@
 // Quick smoke test — runs the pure-logic modules (no bun:sqlite dependency).
 // Usage:  node --experimental-strip-types scripts\smoke-pure.ts
 import { parse, serialize, ulid, normalizeFrontmatter, msToRfc3339, timeToMs, parseRawFrontmatter, type Frontmatter } from "../src/store/markdown.ts";
-import { planConversion, isV2File } from "../src/store/v2migrate.ts";
+import { planConversion, isV2File, migrateV2 } from "../src/store/v2migrate.ts";
 import { redact, findSecret } from "../src/redact.ts";
 import { detectKeywords } from "../src/capture/keywords.ts";
 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) {
@@ -314,6 +315,54 @@ const plan2 = planConversion(v1path, memRoot);
 ok("v2 on disk → null plan", plan2 === null);
 fs.rmSync(tmpRoot, { recursive: true, force: true });
 
+console.log("== migrateV2 dry-run previews legacy files (issue #7) ==");
+// legacy dir sits next to the new root (sibling), as on a real v1 upgrade
+const tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), "v2hotfix-"));
+const newRoot = path.join(tmpHome, "open-memex");
+const legacyRoot = path.join(tmpHome, "my-o-memory");
+const legacyMem = path.join(legacyRoot, "memories", "user");
+fs.mkdirSync(legacyMem, { recursive: true });
+const v1legacy = `---\nid: 01HOTFIX1\nscope_key: user\nscope_kind: user\nproject_name: user\ntype: fact\npriority: 1\ncreated_at: 1758854400000\nupdated_at: 1758854400000\n---\n\nlegacy content\n`;
+fs.writeFileSync(path.join(legacyMem, "01HOTFIX1.md"), v1legacy, "utf8");
+process.env.MY_O_MEMORY_HOME = newRoot;
+
+const dry = migrateV2({ dryRun: true });
+ok("dry-run scans the legacy file", dry.scanned === 1 && dry.plans.length === 1, `scanned=${dry.scanned}`);
+ok("dry-run yields a conversion plan", dry.plans.length === 1 && dry.plans[0].toPath.startsWith(newRoot), dry.plans[0]?.toPath);
+ok("dry-run reports legacy backup target", typeof dry.legacyBackup === "string" && dry.legacyBackup.includes("backup-"), dry.legacyBackup);
+ok("dry-run moves nothing", fs.existsSync(path.join(legacyMem, "01HOTFIX1.md")) && !fs.existsSync(path.join(newRoot, "memories", "personal", "01HOTFIX1.md")));
+ok("dry-run does not rename legacy dir", fs.existsSync(legacyRoot) && !fs.existsSync(dry.legacyBackup!));
+
+const real = migrateV2({ dryRun: false });
+ok("real run converts", real.converted === 1, `converted=${real.converted}`);
+ok("real run writes v2 file to new root", fs.existsSync(path.join(newRoot, "memories", "personal", "01HOTFIX1.md")));
+ok("real run backs up legacy dir", !fs.existsSync(legacyRoot) && fs.existsSync(real.legacyBackup!));
+const backContent = fs.readFileSync(path.join(newRoot, "memories", "personal", "01HOTFIX1.md"), "utf8");
+ok("converted file has schema_version 2", backContent.includes("schema_version: 2"));
+
+// backup rename failure → actionable Error, exit-1-worthy, no raw stack
+// (same process/root: paths() is cached per process)
+const legacyRoot2 = path.join(tmpHome, "my-o-memory");
+const legacyMem2 = path.join(legacyRoot2, "memories", "user");
+fs.mkdirSync(legacyMem2, { recursive: true });
+fs.writeFileSync(path.join(legacyMem2, "01HOTFIX2.md"), v1legacy, "utf8");
+// block the rename: pre-create today's dated backup as a non-empty dir
+const blocked = path.join(tmpHome, "my-o-memory.backup-" + new Date().toISOString().slice(0, 10));
+fs.mkdirSync(blocked, { recursive: true });
+fs.writeFileSync(path.join(blocked, "sentinel"), "x", "utf8");
+let boom: unknown = null;
+try {
+  migrateV2({ dryRun: false });
+} catch (e) {
+  boom = e;
+}
+ok("backup failure throws", boom instanceof Error, String(boom));
+ok("backup failure message is actionable", boom instanceof Error && boom.message.includes("could not back up") && boom.message.includes("Your memories are safe"), boom instanceof Error ? boom.message.slice(0, 60) : "");
+ok("failed backup keeps moved files safe in new root", fs.existsSync(path.join(newRoot, "memories", "user", "01HOTFIX2.md")));
+ok("failed backup leaves legacy dir for retry", fs.existsSync(legacyRoot2));
+delete process.env.MY_O_MEMORY_HOME;
+fs.rmSync(tmpHome, { recursive: true, force: true });
+
 console.log("== lifecycle pure: contentHash / similarity ==");
 ok("hash deterministic + whitespace-insensitive", contentHash("hello   world\n") === contentHash("hello world"));
 ok("hash differs on content", contentHash("hello world") !== contentHash("hello mars"));
@@ -328,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

@@ -250,11 +250,15 @@ Usage: open-memex migrate [--from <key>] [--to <key>] [--dry-run] [--on-conflict
 
 Flags:
   --from / --to   scope keys (default: current project → personal)
-  --dry-run       preview without moving anything
+  --dry-run       preview without moving anything (--to-v2 previews the legacy
+                  files in place, including per-file conversion plans)
   --on-conflict   newer (default), overwrite, or skip
   --to-v2         convert a legacy my-o-memory data dir to the v2 layout
 
 Always preview with --dry-run first; nothing moves without confirmation.
+On Windows, if another program holds the legacy folder open, the backup
+rename fails with an actionable message instead of a stack trace — close
+the program and re-run.
 
 Examples:
   open-memex migrate --dry-run
@@ -275,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.
@@ -349,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
@@ -412,13 +424,20 @@ function parseFlags(argv: string[]): Record<string, string> {
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i]!;
     if (a.startsWith("--")) {
-      const key = a.slice(2);
+      const raw = a.slice(2);
+      const eq = raw.indexOf("=");
+      if (eq >= 0) {
+        // D44: accept --key=value as well as --key value (issue #7 — the
+        // = form was silently misparsed before, dropping the flag).
+        out[raw.slice(0, eq)] = raw.slice(eq + 1);
+        continue;
+      }
       const val = argv[i + 1];
       if (val !== undefined && !val.startsWith("--")) {
-        out[key] = val;
+        out[raw] = val;
         i++;
       } else {
-        out[key] = "true";
+        out[raw] = "true";
       }
     }
   }
@@ -548,7 +567,14 @@ async function main() {
   if (cmd === "migrate" && rest.includes("--to-v2")) {
     const flags = parseFlags(rest);
     const dryRun = flags["dry-run"] === "true";
-    const stats = migrateV2({ dryRun });
+    let stats;
+    try {
+      stats = migrateV2({ dryRun });
+    } catch (err) {
+      // D44: actionable message, not a raw syscall stack (issue #7).
+      console.error(`Error: ${(err as Error).message}`);
+      process.exit(1);
+    }
     console.log(
       `${dryRun ? "DRY RUN: " : ""}scanned ${stats.scanned} files: ` +
         `${stats.converted} to convert, ${stats.skippedV2} already v2`,
@@ -562,7 +588,9 @@ async function main() {
     }
     if (stats.legacyBackup) {
       console.log(
-        `\nlegacy my-o-memory data dir merged; backup kept at:\n  ${stats.legacyBackup}`,
+        dryRun
+          ? `\nDRY RUN: legacy my-o-memory data dir found — it would be merged and backed up at:\n  ${stats.legacyBackup}`
+          : `\nlegacy my-o-memory data dir merged; backup kept at:\n  ${stats.legacyBackup}`,
       );
     }
     if (!dryRun && stats.converted > 0) {
@@ -575,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");
@@ -584,6 +612,7 @@ async function main() {
       force: flags["force"] === "true",
       yes: flags["yes"] === "true",
       instructions: flags["instructions"],
+      global: flags["global"] === "true",
     });
     return;
   }