coding-friend-cli 1.32.0 → 1.32.2

package/dist/{chunk-5OXEUKOE.js → chunk-66EDSJ6W.js}

@@ -6,25 +6,25 @@ import {
   getMemoryMcpStatus,
   memoryConfigMenu,
   writeMemoryMcpEntry
-} from "./chunk-U7IVVN45.js";
-import {
-  getLibPath
-} from "./chunk-RZRT7NGT.js";
+} from "./chunk-3QK6S74O.js";
 import {
   loadConfig,
   resolveMemoryDir
 } from "./chunk-GTX6I57V.js";
 import {
-  showConfigHint
-} from "./chunk-HPNRQYLM.js";
+  getLibPath
+} from "./chunk-RZRT7NGT.js";
 import {
-  run,
-  runWithStderr
-} from "./chunk-EVGXUDX4.js";
+  showConfigHint
+} from "./chunk-Z5Q533UG.js";
 import {
   globalConfigPath,
   localConfigPath
 } from "./chunk-TWKNGPBO.js";
+import {
+  run,
+  runWithStderr
+} from "./chunk-EVGXUDX4.js";
 import {
   log,
   printBanner
@@ -34,17 +34,74 @@ import {
 } from "./chunk-5UVDWG5L.js";
 
 // src/commands/memory.ts
-import { existsSync, readdirSync, statSync, rmSync } from "fs";
-import { join, resolve, sep } from "path";
+import { existsSync as existsSync2, readdirSync, statSync, rmSync } from "fs";
+import { join as join2, resolve, sep } from "path";
 import { homedir } from "os";
 import { confirm } from "@inquirer/prompts";
+
+// src/lib/mcp-state.ts
+import { existsSync } from "fs";
+import { join } from "path";
 import chalk from "chalk";
+function warnStaleMcpJson(memoryDir) {
+  const localMcpPath = join(process.cwd(), ".mcp.json");
+  if (!existsSync(localMcpPath)) return;
+  const mcpJson = readJson(localMcpPath);
+  if (mcpJson === null) {
+    log.warn(".mcp.json exists but could not be parsed \u2014 check for syntax errors.");
+    return;
+  }
+  const state = detectMemoryMcpState(mcpJson, existsSync);
+  if (state.kind === "stale" || state.kind === "legacy-valid") {
+    if (memoryDir) {
+      writeMemoryMcpEntry(memoryDir);
+      if (state.kind === "stale") {
+        log.success("Auto-updated stale .mcp.json to version-stable npx format.");
+      } else {
+        log.success("Updated .mcp.json to version-stable npx format.");
+      }
+      console.log();
+    } else if (state.kind === "stale") {
+      console.log(chalk.yellow(`\u26A0 Stale MCP config detected in .mcp.json`));
+      console.log(chalk.dim(`  Path no longer exists: ${state.path}`));
+      console.log(chalk.dim(`  Run "cf memory mcp" to update to the new format.`));
+      console.log();
+    } else {
+      console.log(chalk.cyan(`\u2139 .mcp.json uses an absolute path for coding-friend-memory.`));
+      console.log(chalk.dim(`  Consider running "cf memory mcp" to switch to the version-stable format.`));
+      console.log();
+    }
+  }
+}
+function detectMemoryMcpState(mcpJson, pathExists) {
+  if (!mcpJson) return { kind: "none" };
+  const servers = mcpJson.mcpServers;
+  if (!servers) return { kind: "none" };
+  const entry = servers["coding-friend-memory"];
+  if (!entry) return { kind: "none" };
+  const command = entry.command;
+  if (!command) return { kind: "none" };
+  if (command === "npx") return { kind: "npx" };
+  if (command === "node") {
+    const args = entry.args;
+    const serverPath = args?.[0];
+    if (!serverPath) return { kind: "none" };
+    if (!pathExists(serverPath)) {
+      return { kind: "stale", path: serverPath };
+    }
+    return { kind: "legacy-valid", path: serverPath };
+  }
+  return { kind: "none" };
+}
+
+// src/commands/memory.ts
+import chalk2 from "chalk";
 function countMdFiles(dir) {
-  if (!existsSync(dir)) return 0;
+  if (!existsSync2(dir)) return 0;
   let count = 0;
   for (const entry of readdirSync(dir, { withFileTypes: true })) {
     if (entry.isDirectory()) {
-      count += countMdFiles(join(dir, entry.name));
+      count += countMdFiles(join2(dir, entry.name));
     } else if (entry.name.endsWith(".md") && entry.name !== "README.md") {
       count++;
     }
@@ -64,7 +121,7 @@ function truncateError(text) {
   return [...head, `  ... (${skipped} lines omitted) ...`, ...tail].join("\n");
 }
 function ensureMemoryBuilt(mcpDir) {
-  if (!existsSync(join(mcpDir, "node_modules"))) {
+  if (!existsSync2(join2(mcpDir, "node_modules"))) {
     log.step("Installing memory server dependencies (one-time setup)...");
     const result = runWithStderr("npm", ["install"], { cwd: mcpDir });
     if (result.exitCode !== 0) {
@@ -74,7 +131,7 @@ function ensureMemoryBuilt(mcpDir) {
     }
     log.success("Done.");
   }
-  if (!existsSync(join(mcpDir, "dist"))) {
+  if (!existsSync2(join2(mcpDir, "dist"))) {
     log.step("Building memory server...");
     const result = runWithStderr("npm", ["run", "build"], { cwd: mcpDir });
     if (result.exitCode !== 0) {
@@ -85,70 +142,25 @@ function ensureMemoryBuilt(mcpDir) {
     log.success("Done.");
   }
 }
-function printMemoryMcpConfig(serverPath, memoryDir) {
-  console.log(chalk.dim("Add this to your MCP client config:"));
-  console.log();
-  console.log(
-    chalk.yellow.bold("--- Claude Code (.mcp.json in project root) ---")
-  );
-  console.log(`
-{
-  "mcpServers": {
-    "coding-friend-memory": {
-      "command": "node",
-      "args": ["${serverPath}", "${memoryDir}"]
-    }
-  }
-}`);
+function printMemoryMcpConfig(memoryDir) {
+  console.log(chalk2.dim("Add this to your MCP client config:"));
   console.log();
-  console.log(
-    chalk.yellow.bold(
-      "--- Claude Desktop / Claude Chat (claude_desktop_config.json) ---"
-    )
-  );
-  console.log(`
-{
+  console.log(`{
   "mcpServers": {
     "coding-friend-memory": {
-      "command": "node",
-      "args": ["${serverPath}", "${memoryDir}"]
+      "command": "npx",
+      "args": [
+        "-y",
+        "coding-friend-cli",
+        "mcp-serve",
+        "${memoryDir}"
+      ]
     }
   }
 }`);
   console.log();
-  console.log(chalk.yellow.bold("--- Generic MCP client ---"));
-  console.log(`
-Server command: node ${serverPath} ${memoryDir}
-Transport: stdio`);
-  console.log();
-  console.log(chalk.yellow.bold("--- Available tools ---"));
-  console.log();
-  console.log(
-    `  ${chalk.white("memory_store")}       ${chalk.dim("Store a new memory")}`
-  );
-  console.log(
-    `  ${chalk.white("memory_search")}      ${chalk.dim("Search memories (keyword match)")}`
-  );
-  console.log(
-    `  ${chalk.white("memory_retrieve")}    ${chalk.dim("Get a specific memory by ID")}`
-  );
-  console.log(
-    `  ${chalk.white("memory_list")}        ${chalk.dim("List memories with filtering")}`
-  );
-  console.log(
-    `  ${chalk.white("memory_update")}      ${chalk.dim("Update existing memory")}`
-  );
-  console.log(
-    `  ${chalk.white("memory_delete")}      ${chalk.dim("Delete a memory")}`
-  );
-  console.log();
-  console.log(chalk.yellow.bold("--- Resources ---"));
-  console.log();
-  console.log(
-    `  ${chalk.white("memory://index")}     ${chalk.dim("Browse all memories")}`
-  );
-  console.log(
-    `  ${chalk.white("memory://stats")}     ${chalk.dim("Storage statistics")}`
+  log.dim(
+    "Available tools & resources: https://cf.dinhanhthi.com/docs/cli/cf-mcp/"
   );
   console.log();
   log.warn(
@@ -166,43 +178,43 @@ async function memoryStatusCommand() {
   const docCount = countMdFiles(memoryDir);
   const mcpDir = getLibPath("cf-memory");
   ensureMemoryBuilt(mcpDir);
-  const { isDaemonRunning, getDaemonInfo } = await import(join(mcpDir, "dist/daemon/process.js"));
-  const { areSqliteDepsAvailable } = await import(join(mcpDir, "dist/lib/lazy-install.js"));
+  const { isDaemonRunning, getDaemonInfo } = await import(join2(mcpDir, "dist/daemon/process.js"));
+  const { areSqliteDepsAvailable } = await import(join2(mcpDir, "dist/lib/lazy-install.js"));
   const sqliteAvailable = areSqliteDepsAvailable();
   const running = await isDaemonRunning();
   const daemonInfo = getDaemonInfo();
   let tierLabel;
   if (sqliteAvailable) {
-    tierLabel = chalk.cyan("Tier 1 (SQLite + Hybrid)");
+    tierLabel = chalk2.cyan("Tier 1 (SQLite + Hybrid)");
   } else if (running) {
-    tierLabel = chalk.cyan("Tier 2 (MiniSearch + Daemon)");
+    tierLabel = chalk2.cyan("Tier 2 (MiniSearch + Daemon)");
   } else {
-    tierLabel = chalk.cyan("Tier 3 (Markdown)");
+    tierLabel = chalk2.cyan("Tier 3 (Markdown)");
   }
   printBanner("\u{1F9E0} Coding Friend Memory");
   console.log();
   log.info(`Tier: ${tierLabel}`);
-  log.info(`Memory dir: ${chalk.cyan(memoryDir)}`);
-  log.info(`Memories in this dir: ${chalk.green(String(docCount))}`);
+  log.info(`Memory dir: ${chalk2.cyan(memoryDir)}`);
+  log.info(`Memories in this dir: ${chalk2.green(String(docCount))}`);
   if (running && daemonInfo) {
     const uptime = (Date.now() - daemonInfo.startedAt) / 1e3;
     log.info(
-      `Daemon: ${chalk.green("running")} (PID ${daemonInfo.pid}, uptime ${formatUptime(uptime)}) ${chalk.dim('Turn it off by "cf memory stop-daemon"')}`
+      `Daemon: ${chalk2.green("running")} (PID ${daemonInfo.pid}, uptime ${formatUptime(uptime)}) ${chalk2.dim('Turn it off by "cf memory stop-daemon"')}`
     );
   } else if (sqliteAvailable) {
     log.info(
-      `Daemon: ${chalk.dim("stopped")} ${chalk.dim("(not needed \u2014 Tier 1 uses SQLite directly)")}`
+      `Daemon: ${chalk2.dim("stopped")} ${chalk2.dim("(not needed \u2014 Tier 1 uses SQLite directly)")}`
     );
   } else {
     log.info(
-      `Daemon: ${chalk.dim("stopped")} ${chalk.dim('(run "cf memory start-daemon" for Tier 2 search)')}`
+      `Daemon: ${chalk2.dim("stopped")} ${chalk2.dim('(run "cf memory start-daemon" for Tier 2 search)')}`
     );
   }
   if (sqliteAvailable) {
-    log.info(`SQLite deps: ${chalk.green("installed")}`);
+    log.info(`SQLite deps: ${chalk2.green("installed")}`);
   } else {
     log.info(
-      `SQLite deps: ${chalk.dim("not installed")} (run "cf memory init" to enable Tier 1)`
+      `SQLite deps: ${chalk2.dim("not installed")} (run "cf memory init" to enable Tier 1)`
     );
   }
   const config = loadConfig();
@@ -210,33 +222,33 @@ async function memoryStatusCommand() {
   if (embeddingConfig?.provider || embeddingConfig?.model) {
     const provider = embeddingConfig.provider ?? "transformers";
     const model = embeddingConfig.model ?? (provider === "ollama" ? "all-minilm:l6-v2" : "Xenova/all-MiniLM-L6-v2");
-    log.info(`Embedding: ${chalk.cyan(model)} ${chalk.dim(`(${provider})`)}`);
+    log.info(`Embedding: ${chalk2.cyan(model)} ${chalk2.dim(`(${provider})`)}`);
   }
   const mcpStatus = getMemoryMcpStatus();
   if (mcpStatus.configured && mcpStatus.scope === "local") {
     log.info(
-      `MCP: ${chalk.green("configured")} ${chalk.dim("(local .mcp.json)")}`
+      `MCP: ${chalk2.green("configured")} ${chalk2.dim("(local .mcp.json)")}`
     );
   } else if (mcpStatus.configured && mcpStatus.scope === "global") {
     log.info(
-      `MCP: ${chalk.green("configured")} ${chalk.dim("(global ~/.claude/.mcp.json)")} ${chalk.yellow("\u26A0 global config uses a fixed path \u2014 only works for one project")}`
+      `MCP: ${chalk2.green("configured")} ${chalk2.dim("(global ~/.claude/.mcp.json)")} ${chalk2.yellow("\u26A0 global config uses a fixed path \u2014 only works for one project")}`
     );
   } else {
     log.info(
-      `MCP: ${chalk.dim("not configured in this project")} ${chalk.dim('(run "cf memory init" or add manually via "cf memory mcp")')}`
+      `MCP: ${chalk2.dim("not configured in this project")} ${chalk2.dim('(run "cf memory init" or add manually via "cf memory mcp")')}`
     );
   }
   const autoCapture = config.memory?.autoCapture ?? false;
   log.info(
-    `Auto-capture: ${autoCapture ? chalk.green("on") : chalk.dim("off")}`
+    `Auto-capture: ${autoCapture ? chalk2.green("on") : chalk2.dim("off")}`
   );
-  if (existsSync(memoryDir)) {
+  if (existsSync2(memoryDir)) {
     const categories = readdirSync(memoryDir, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith(".")).map((d) => {
-      const catCount = countMdFiles(join(memoryDir, d.name));
+      const catCount = countMdFiles(join2(memoryDir, d.name));
       return `${d.name} (${catCount})`;
     }).filter((s) => !s.endsWith("(0)"));
     if (categories.length > 0) {
-      log.info(`Categories: ${chalk.dim(categories.join(", "))}`);
+      log.info(`Categories: ${chalk2.dim(categories.join(", "))}`);
     }
   }
   console.log();
@@ -245,7 +257,7 @@ async function memoryStatusCommand() {
 }
 async function memorySearchCommand(query) {
   const memoryDir = getMemoryDir();
-  if (!existsSync(memoryDir)) {
+  if (!existsSync2(memoryDir)) {
     log.error(`Memory dir not found: ${memoryDir}`);
     log.dim("Run `cf init` to create project folders.");
     process.exit(1);
@@ -257,7 +269,7 @@ async function memorySearchCommand(query) {
     [
       "-e",
       `
-      import { MarkdownBackend } from ${JSON.stringify(join(mcpDir, "dist/backends/markdown.js"))};
+      import { MarkdownBackend } from ${JSON.stringify(join2(mcpDir, "dist/backends/markdown.js"))};
       const backend = new MarkdownBackend(${JSON.stringify(memoryDir)});
       const results = await backend.search({ query: process.env.CF_SEARCH_QUERY, limit: 10 });
       for (const r of results) {
@@ -280,7 +292,7 @@ async function memoryListCommand(opts) {
     return memoryListProjectsCommand();
   }
   const memoryDir = getMemoryDir();
-  if (!existsSync(memoryDir)) {
+  if (!existsSync2(memoryDir)) {
     log.info(`No memory directory found at: ${memoryDir}`);
     log.dim(
       "This folder has no memories yet. Use --projects to list all project databases."
@@ -297,7 +309,7 @@ async function memoryListCommand(opts) {
     [
       "-e",
       `
-      import { MarkdownBackend } from ${JSON.stringify(join(mcpDir, "dist/backends/markdown.js"))};
+      import { MarkdownBackend } from ${JSON.stringify(join2(mcpDir, "dist/backends/markdown.js"))};
       const backend = new MarkdownBackend(${JSON.stringify(memoryDir)});
       const metas = await backend.list({});
       if (metas.length === 0) { console.log("No memories found."); process.exit(0); }
@@ -333,7 +345,7 @@ async function memoryStartDaemonCommand() {
   const memoryDir = getMemoryDir();
   const mcpDir = getLibPath("cf-memory");
   ensureMemoryBuilt(mcpDir);
-  const { isDaemonRunning, getDaemonInfo, spawnDaemon } = await import(join(mcpDir, "dist/daemon/process.js"));
+  const { isDaemonRunning, getDaemonInfo, spawnDaemon } = await import(join2(mcpDir, "dist/daemon/process.js"));
   if (await isDaemonRunning()) {
     const info = getDaemonInfo();
     log.info(`Daemon already running (PID ${info?.pid})`);
@@ -345,7 +357,7 @@ async function memoryStartDaemonCommand() {
   const result = await spawnDaemon(memoryDir, embedding, {});
   if (result) {
     log.success(`Daemon started (PID ${result.pid})`);
-    log.info(`Watching ${chalk.cyan(memoryDir)} for changes`);
+    log.info(`Watching ${chalk2.cyan(memoryDir)} for changes`);
   } else {
     log.error("Daemon did not start within 3 seconds");
     process.exit(1);
@@ -354,7 +366,7 @@ async function memoryStartDaemonCommand() {
 async function memoryStopDaemonCommand() {
   const mcpDir = getLibPath("cf-memory");
   ensureMemoryBuilt(mcpDir);
-  const { stopDaemon, isDaemonRunning } = await import(join(mcpDir, "dist/daemon/process.js"));
+  const { stopDaemon, isDaemonRunning } = await import(join2(mcpDir, "dist/daemon/process.js"));
   if (!await isDaemonRunning()) {
     log.info("Daemon is not running.");
     return;
@@ -371,10 +383,10 @@ async function memoryRebuildCommand() {
   const memoryDir = getMemoryDir();
   const mcpDir = getLibPath("cf-memory");
   ensureMemoryBuilt(mcpDir);
-  const { areSqliteDepsAvailable } = await import(join(mcpDir, "dist/lib/lazy-install.js"));
+  const { areSqliteDepsAvailable } = await import(join2(mcpDir, "dist/lib/lazy-install.js"));
   if (areSqliteDepsAvailable()) {
     log.step("Rebuilding SQLite index + embeddings...");
-    const { SqliteBackend } = await import(join(mcpDir, "dist/backends/sqlite/index.js"));
+    const { SqliteBackend } = await import(join2(mcpDir, "dist/backends/sqlite/index.js"));
     const config = loadConfig();
     const embedding = config.memory?.embedding;
     const opts = embedding ? { embedding, skipVec: false } : { skipVec: false };
@@ -384,7 +396,7 @@ async function memoryRebuildCommand() {
       const stats = await backend.stats();
       log.success(`Rebuilt: ${stats.total} memories indexed.`);
       if (backend.isVecEnabled()) {
-        log.info(`Vector search: ${chalk.green("enabled")}`);
+        log.info(`Vector search: ${chalk2.green("enabled")}`);
       }
       if (!backend.isRebuildNeeded()) {
         log.info("Embedding dimensions: up to date");
@@ -394,14 +406,14 @@ async function memoryRebuildCommand() {
     }
     return;
   }
-  const { isDaemonRunning, getDaemonPaths } = await import(join(mcpDir, "dist/daemon/process.js"));
+  const { isDaemonRunning, getDaemonPaths } = await import(join2(mcpDir, "dist/daemon/process.js"));
   if (!await isDaemonRunning()) {
     log.info("No SQLite deps and daemon not running. Nothing to rebuild.");
     log.dim("Install Tier 1 deps: cf memory init");
     log.dim("Or start the daemon: cf memory start-daemon");
     return;
   }
-  const { DaemonClient } = await import(join(mcpDir, "dist/lib/daemon-client.js"));
+  const { DaemonClient } = await import(join2(mcpDir, "dist/lib/daemon-client.js"));
   const paths = getDaemonPaths();
   const client = new DaemonClient(paths.socketPath);
   log.step("Rebuilding search index via daemon...");
@@ -418,7 +430,7 @@ function getDbPath(memoryDir) {
     const stripped = resolved.replace(/\/docs\/memory$/, "").replace(/\/memory$/, "");
     const id = stripped.replace(/\//g, "-");
     const home = homedir();
-    const dbPath = join(
+    const dbPath = join2(
       home,
       ".coding-friend",
       "memory",
@@ -426,7 +438,7 @@ function getDbPath(memoryDir) {
       id,
       "db.sqlite"
     );
-    return existsSync(dbPath) ? dbPath : null;
+    return existsSync2(dbPath) ? dbPath : null;
   } catch {
     return null;
   }
@@ -435,7 +447,7 @@ async function ensureSqliteDepsIfNeeded(mcpDir) {
   const config = loadConfig();
   const tier = config.memory?.tier ?? "auto";
   if (tier === "markdown" || tier === "lite") return true;
-  const { ensureDeps, areSqliteDepsAvailable } = await import(join(mcpDir, "dist/lib/lazy-install.js"));
+  const { ensureDeps, areSqliteDepsAvailable } = await import(join2(mcpDir, "dist/lib/lazy-install.js"));
   if (areSqliteDepsAvailable()) return true;
   log.step("Installing SQLite dependencies...");
   const installed = await ensureDeps({
@@ -506,7 +518,7 @@ async function memoryInitWizard(memoryDir, mcpDir) {
   }
   const depsOk = await ensureSqliteDepsIfNeeded(mcpDir);
   if (!depsOk) return;
-  if (!existsSync(memoryDir)) {
+  if (!existsSync2(memoryDir)) {
     log.info(
       "No memory directory found. Memories will be indexed as they're created."
     );
@@ -522,7 +534,7 @@ async function memoryInitWizard(memoryDir, mcpDir) {
     return;
   }
   log.step(`Importing ${docCount} existing memories into SQLite...`);
-  const { SqliteBackend } = await import(join(mcpDir, "dist/backends/sqlite/index.js"));
+  const { SqliteBackend } = await import(join2(mcpDir, "dist/backends/sqlite/index.js"));
   const embedding = config.memory?.embedding;
   const backend = new SqliteBackend(memoryDir, {
     skipVec: false,
@@ -533,7 +545,7 @@ async function memoryInitWizard(memoryDir, mcpDir) {
     const stats = await backend.stats();
     log.success(`Imported ${stats.total} memories. DB: ${backend.getDbPath()}`);
     log.info(
-      `Vector search: ${backend.isVecEnabled() ? chalk.green("enabled") : chalk.dim("disabled (sqlite-vec not available)")}`
+      `Vector search: ${backend.isVecEnabled() ? chalk2.green("enabled") : chalk2.dim("disabled (sqlite-vec not available)")}`
     );
   } finally {
     await backend.close();
@@ -542,13 +554,13 @@ async function memoryInitWizard(memoryDir, mcpDir) {
   console.log();
   log.success('Memory initialized! Run "cf memory status" to verify.');
   log.info(
-    `Tip: Run ${chalk.cyan("/cf-scan")} in Claude Code to populate memory with project knowledge.`
+    `Tip: Run ${chalk2.cyan("/cf-scan")} in Claude Code to populate memory with project knowledge.`
   );
 }
-async function setupMemoryMcp(memoryDir, mcpDir) {
+async function setupMemoryMcp(memoryDir, _mcpDir) {
   const mcpStatus = getMemoryMcpStatus();
   if (mcpStatus.configured && mcpStatus.scope === "local") {
-    log.info(`MCP: ${chalk.green("already configured")} in .mcp.json`);
+    log.info(`MCP: ${chalk2.green("already configured")} in .mcp.json`);
     return;
   }
   console.log();
@@ -564,14 +576,7 @@ async function setupMemoryMcp(memoryDir, mcpDir) {
     log.dim('Skipped. Run "cf memory mcp" anytime to get the config.');
     return;
   }
-  const serverPath = join(mcpDir, "dist", "index.js");
-  if (!existsSync(serverPath)) {
-    log.warn(
-      "cf-memory not built yet. Run `cf memory mcp` after building to get the config."
-    );
-    return;
-  }
-  writeMemoryMcpEntry(serverPath, memoryDir);
+  writeMemoryMcpEntry(memoryDir);
 }
 async function memoryInitCommand() {
   const memoryDir = getMemoryDir();
@@ -604,7 +609,7 @@ async function memoryConfigCommand() {
 }
 function getProjectsBaseDir() {
   const home = homedir();
-  return join(home, ".coding-friend", "memory", "projects");
+  return join2(home, ".coding-friend", "memory", "projects");
 }
 function formatSize(bytes) {
   if (bytes < 1024) return `${bytes} B`;
@@ -622,9 +627,9 @@ function formatDate(raw) {
 }
 function dirSize(dir) {
   let total = 0;
-  if (!existsSync(dir)) return 0;
+  if (!existsSync2(dir)) return 0;
   for (const entry of readdirSync(dir, { withFileTypes: true })) {
-    const p = join(dir, entry.name);
+    const p = join2(dir, entry.name);
     if (entry.isFile()) {
       total += statSync(p).size;
     } else if (entry.isDirectory()) {
@@ -634,7 +639,7 @@ function dirSize(dir) {
   return total;
 }
 function getProjectInfo(projectDir, projectId, mcpDir, knownSourceDir) {
-  const dbPath = join(projectDir, "db.sqlite");
+  const dbPath = join2(projectDir, "db.sqlite");
   const size = dirSize(projectDir);
   const info = {
     id: projectId,
@@ -643,7 +648,7 @@ function getProjectInfo(projectDir, projectId, mcpDir, knownSourceDir) {
     size,
     lastUpdated: null
   };
-  if (!existsSync(dbPath)) return info;
+  if (!existsSync2(dbPath)) return info;
   try {
     const backfillDir = knownSourceDir ? JSON.stringify(knownSourceDir) : "null";
     const result = run(
@@ -684,7 +689,7 @@ async function memoryListProjectsCommand() {
   const baseDir = getProjectsBaseDir();
   const mcpDir = getLibPath("cf-memory");
   ensureMemoryBuilt(mcpDir);
-  if (!existsSync(baseDir)) {
+  if (!existsSync2(baseDir)) {
     log.info("No memory projects found.");
     log.dim('Run "cf memory init" in a project to create one.');
     return;
@@ -695,35 +700,35 @@ async function memoryListProjectsCommand() {
     return;
   }
   const currentMemoryDir = resolve(getMemoryDir());
-  const { projectId } = await import(join(mcpDir, "dist/backends/sqlite/index.js"));
+  const { projectId } = await import(join2(mcpDir, "dist/backends/sqlite/index.js"));
   const currentProjectId = projectId(currentMemoryDir);
   log.step(`Scanning ${dirs.length} project(s)...
 `);
   const projects = [];
   for (const id of dirs) {
     const knownDir = id === currentProjectId ? currentMemoryDir : void 0;
-    projects.push(getProjectInfo(join(baseDir, id), id, mcpDir, knownDir));
+    projects.push(getProjectInfo(join2(baseDir, id), id, mcpDir, knownDir));
   }
   projects.sort((a, b) => b.size - a.size);
   const totalSize = projects.reduce((sum, p) => sum + p.size, 0);
   const idxW = String(projects.length).length;
   const header = `${"#".padStart(idxW)}  ${"SIZE".padStart(10)}  ${"MEMS".padStart(4)}  ${"PROJECT ID".padEnd(12)}  ${"UPDATED".padEnd(16)}  PATH`;
-  console.log(chalk.bold(header));
-  console.log(chalk.dim("-".repeat(header.length + 10)));
+  console.log(chalk2.bold(header));
+  console.log(chalk2.dim("-".repeat(header.length + 10)));
   projects.forEach((p, i) => {
-    const idx = chalk.dim(String(i + 1).padStart(idxW));
-    const sizeStr = chalk.yellow(formatSize(p.size).padStart(10));
-    const memCount = chalk.green(String(p.memories).padStart(4));
-    const idStr = chalk.cyan(p.id.padEnd(12));
-    const dateStr = p.lastUpdated ? formatDate(p.lastUpdated).padEnd(16) : chalk.dim("n/a".padEnd(16));
-    const pathStr = p.sourceDir ? chalk.dim(p.sourceDir) : chalk.dim("(unknown)");
+    const idx = chalk2.dim(String(i + 1).padStart(idxW));
+    const sizeStr = chalk2.yellow(formatSize(p.size).padStart(10));
+    const memCount = chalk2.green(String(p.memories).padStart(4));
+    const idStr = chalk2.cyan(p.id.padEnd(12));
+    const dateStr = p.lastUpdated ? formatDate(p.lastUpdated).padEnd(16) : chalk2.dim("n/a".padEnd(16));
+    const pathStr = p.sourceDir ? chalk2.dim(p.sourceDir) : chalk2.dim("(unknown)");
     console.log(
       `${idx}  ${sizeStr}  ${memCount}  ${idStr}  ${dateStr}  ${pathStr}`
     );
   });
   console.log();
   console.log(
-    chalk.bold(
+    chalk2.bold(
       `Total: ${projects.length} project(s), ${formatSize(totalSize)}`
     )
   );
@@ -731,7 +736,7 @@ async function memoryListProjectsCommand() {
 }
 async function memoryRmCommand(opts) {
   const baseDir = getProjectsBaseDir();
-  if (!existsSync(baseDir)) {
+  if (!existsSync2(baseDir)) {
     log.info("No memory projects found. Nothing to remove.");
     return;
   }
@@ -741,9 +746,9 @@ async function memoryRmCommand(opts) {
     const dirs = readdirSync(baseDir, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith(".")).map((d) => d.name);
     const orphaned = [];
     for (const id of dirs) {
-      const projectDir = join(baseDir, id);
+      const projectDir = join2(baseDir, id);
       const info = getProjectInfo(projectDir, id, mcpDir);
-      if (info.sourceDir && !existsSync(info.sourceDir)) {
+      if (info.sourceDir && !existsSync2(info.sourceDir)) {
         orphaned.push({
           id,
           reason: `source dir missing: ${info.sourceDir}`,
@@ -767,7 +772,7 @@ async function memoryRmCommand(opts) {
     );
     console.log();
     for (const o of orphaned) {
-      console.log(`  ${chalk.cyan(o.id)}  ${chalk.dim(o.reason)}`);
+      console.log(`  ${chalk2.cyan(o.id)}  ${chalk2.dim(o.reason)}`);
     }
     console.log();
     const ok = await confirm({
@@ -779,7 +784,7 @@ async function memoryRmCommand(opts) {
       return;
     }
     for (const o of orphaned) {
-      rmSync(join(baseDir, o.id), { recursive: true, force: true });
+      rmSync(join2(baseDir, o.id), { recursive: true, force: true });
     }
     log.success(
       `Deleted ${orphaned.length} orphaned project(s) (${formatSize(totalSize)}).`
@@ -795,7 +800,7 @@ async function memoryRmCommand(opts) {
       return;
     }
     const totalSize = dirs.reduce(
-      (sum, d) => sum + dirSize(join(baseDir, d.name)),
+      (sum, d) => sum + dirSize(join2(baseDir, d.name)),
       0
     );
     log.warn(
@@ -812,19 +817,19 @@ async function memoryRmCommand(opts) {
       return;
     }
     for (const d of dirs) {
-      rmSync(join(baseDir, d.name), { recursive: true, force: true });
+      rmSync(join2(baseDir, d.name), { recursive: true, force: true });
     }
     log.success(`Deleted ${dirs.length} project database(s).`);
     return;
   }
   if (opts.projectId) {
-    const projectDir = join(baseDir, opts.projectId);
+    const projectDir = join2(baseDir, opts.projectId);
     const resolved = resolve(projectDir);
     if (!resolved.startsWith(resolve(baseDir) + sep)) {
       log.error("Invalid project ID.");
       process.exit(1);
     }
-    if (!existsSync(projectDir)) {
+    if (!existsSync2(projectDir)) {
       log.error(`Project "${opts.projectId}" not found.`);
       log.dim('Run "cf memory list --projects" to see available projects.');
       process.exit(1);
@@ -855,11 +860,13 @@ async function memoryMcpCommand() {
   const memoryDir = getMemoryDir();
   const mcpDir = getLibPath("cf-memory");
   ensureMemoryBuilt(mcpDir);
-  const serverPath = join(mcpDir, "dist", "index.js");
-  printMemoryMcpConfig(serverPath, memoryDir);
+  warnStaleMcpJson(memoryDir);
+  printMemoryMcpConfig(memoryDir);
 }
 
 export {
+  warnStaleMcpJson,
+  detectMemoryMcpState,
   ensureMemoryBuilt,
   printMemoryMcpConfig,
   memoryStatusCommand,