coding-friend-cli 1.21.0 → 1.22.0

package/dist/{chunk-3KXYEC2T.js → chunk-LCABODSZ.js}

@@ -1,6 +1,9 @@
 import {
   getLibPath
 } from "./chunk-RZRT7NGT.js";
+import {
+  resolveMemoryDir
+} from "./chunk-SIQJPT47.js";
 import {
   BACK,
   askScope,
@@ -9,7 +12,8 @@ import {
 } from "./chunk-BIX7AJU3.js";
 import {
   mergeJson,
-  readJson
+  readJson,
+  writeJson
 } from "./chunk-5UVDWG5L.js";
 import {
   globalConfigPath,
@@ -20,7 +24,10 @@ import {
 } from "./chunk-W5CD7WTX.js";
 
 // src/lib/memory-prompts.ts
+import { existsSync } from "fs";
+import { homedir } from "os";
 import { confirm, input, select } from "@inquirer/prompts";
+import chalk from "chalk";
 import { join } from "path";
 function getMemoryFieldScope(field, globalCfg, localCfg) {
   const globalSection = globalCfg?.memory;
@@ -235,6 +242,67 @@ async function editMemoryDaemonTimeout(globalCfg, localCfg) {
     idleTimeout: Number(value) * 6e4
   });
 }
+function writeMemoryMcpEntry(serverPath, memoryDir) {
+  const mcpPath = join(process.cwd(), ".mcp.json");
+  const existing = readJson(mcpPath) ?? {};
+  const servers = existing.mcpServers ?? {};
+  writeJson(mcpPath, {
+    ...existing,
+    mcpServers: {
+      ...servers,
+      "coding-friend-memory": {
+        command: "node",
+        args: [serverPath, memoryDir]
+      }
+    }
+  });
+  log.success("Added coding-friend-memory to .mcp.json");
+}
+function getMemoryMcpStatus() {
+  const localMcpPath = join(process.cwd(), ".mcp.json");
+  const localMcp = readJson(localMcpPath);
+  const localServers = localMcp?.mcpServers;
+  if (localServers != null && "coding-friend-memory" in localServers) {
+    return { configured: true, scope: "local" };
+  }
+  const globalMcpPath = join(homedir(), ".claude", ".mcp.json");
+  const globalMcp = readJson(globalMcpPath);
+  const globalServers = globalMcp?.mcpServers;
+  if (globalServers != null && "coding-friend-memory" in globalServers) {
+    return { configured: true, scope: "global" };
+  }
+  return { configured: false, scope: null };
+}
+async function editMemoryMcp() {
+  const status = getMemoryMcpStatus();
+  if (status.configured) {
+    const label = status.scope === "local" ? chalk.green("configured") + chalk.dim(" (local .mcp.json)") : chalk.green("configured") + chalk.dim(" (global ~/.claude/.mcp.json)") + " " + chalk.yellow("\u26A0 only works for one project");
+    log.info(`MCP: ${label}`);
+    const reconfigure = await confirm({
+      message: "Reconfigure Memory MCP in local .mcp.json?",
+      default: false
+    });
+    if (!reconfigure) return;
+  }
+  let mcpDir;
+  try {
+    mcpDir = getLibPath("cf-memory");
+  } catch {
+    log.warn(
+      "cf-memory package not found. Install the CLI first: npm i -g coding-friend-cli"
+    );
+    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;
+  }
+  const memoryDir = resolveMemoryDir();
+  writeMemoryMcpEntry(serverPath, memoryDir);
+}
 async function memoryConfigMenu(opts) {
   while (true) {
     const globalCfg = readJson(globalConfigPath());
@@ -274,6 +342,8 @@ async function memoryConfigMenu(opts) {
     const daemonScope = getMemoryFieldScope("daemon", globalCfg, localCfg);
     const daemonVal = getMergedMemoryValue("daemon", globalCfg, localCfg);
     const embeddingLabel = embeddingVal?.provider ? embeddingVal.model ? `${embeddingVal.model} (${embeddingVal.provider})` : embeddingVal.provider : "";
+    const mcpStatus = getMemoryMcpStatus();
+    const mcpLabel = mcpStatus.configured ? mcpStatus.scope === "local" ? chalk.green("configured") + chalk.dim(" (.mcp.json)") : chalk.green("configured") + chalk.dim(" (global)") + " " + chalk.yellow("\u26A0") : chalk.dim("not configured");
     const choice = await select({
       message: "Memory settings:",
       choices: injectBackChoice(
@@ -297,6 +367,10 @@ async function memoryConfigMenu(opts) {
           {
             name: `Daemon timeout ${formatScopeLabel(daemonScope)}${daemonVal?.idleTimeout ? ` (${daemonVal.idleTimeout / 6e4}min)` : ""}`,
             value: "daemon"
+          },
+          {
+            name: `MCP setup (${mcpLabel})`,
+            value: "mcp"
           }
         ],
         opts?.exitLabel ?? "Back"
@@ -319,6 +393,9 @@ async function memoryConfigMenu(opts) {
       case "daemon":
         await editMemoryDaemonTimeout(globalCfg, localCfg);
         break;
+      case "mcp":
+        await editMemoryMcp();
+        break;
     }
   }
 }
@@ -329,5 +406,7 @@ export {
   editMemoryAutoStart,
   editMemoryEmbedding,
   editMemoryDaemonTimeout,
+  writeMemoryMcpEntry,
+  getMemoryMcpStatus,
   memoryConfigMenu
 };

package/dist/{memory-PDENAODU.js → chunk-TPLH46BH.js}

@@ -4,16 +4,17 @@ import {
   editMemoryDaemonTimeout,
   editMemoryEmbedding,
   editMemoryTier,
-  memoryConfigMenu
-} from "./chunk-3KXYEC2T.js";
+  getMemoryMcpStatus,
+  memoryConfigMenu,
+  writeMemoryMcpEntry
+} from "./chunk-LCABODSZ.js";
+import {
+  getLibPath
+} from "./chunk-RZRT7NGT.js";
 import {
   loadConfig,
   resolveMemoryDir
 } from "./chunk-SIQJPT47.js";
-import {
-  getLibPath
-} from "./chunk-RZRT7NGT.js";
-import "./chunk-PRIH34UB.js";
 import {
   showConfigHint
 } from "./chunk-BIX7AJU3.js";
@@ -62,7 +63,7 @@ function truncateError(text) {
   const skipped = lines.length - 28;
   return [...head, `  ... (${skipped} lines omitted) ...`, ...tail].join("\n");
 }
-function ensureBuilt(mcpDir) {
+function ensureMemoryBuilt(mcpDir) {
   if (!existsSync(join(mcpDir, "node_modules"))) {
     log.step("Installing memory server dependencies (one-time setup)...");
     const result = runWithStderr("npm", ["install"], { cwd: mcpDir });
@@ -84,6 +85,55 @@ function ensureBuilt(mcpDir) {
     log.success("Done.");
   }
 }
+function printMemoryMcpConfig(serverPath, memoryDir) {
+  console.log(`Add this to your MCP client config:
+
+--- Claude Code (.mcp.json in project root) ---
+
+{
+  "mcpServers": {
+    "coding-friend-memory": {
+      "command": "node",
+      "args": ["${serverPath}", "${memoryDir}"]
+    }
+  }
+}
+
+--- Claude Desktop / Claude Chat (claude_desktop_config.json) ---
+
+{
+  "mcpServers": {
+    "coding-friend-memory": {
+      "command": "node",
+      "args": ["${serverPath}", "${memoryDir}"]
+    }
+  }
+}
+
+--- Generic MCP client ---
+
+Server command: node ${serverPath} ${memoryDir}
+Transport: stdio
+
+--- Available tools ---
+
+  memory_store       Store a new memory
+  memory_search      Search memories (keyword match)
+  memory_retrieve    Get a specific memory by ID
+  memory_list        List memories with filtering
+  memory_update      Update existing memory
+  memory_delete      Delete a memory
+
+--- Resources ---
+
+  memory://index     Browse all memories
+  memory://stats     Storage statistics
+`);
+  log.warn(
+    "Note: The memory path is project-specific. Use local .mcp.json (per project), not global ~/.claude/.mcp.json."
+  );
+  console.log();
+}
 function formatUptime(seconds) {
   if (seconds < 60) return `${Math.round(seconds)}s`;
   if (seconds < 3600) return `${Math.round(seconds / 60)}m`;
@@ -93,7 +143,7 @@ async function memoryStatusCommand() {
   const memoryDir = getMemoryDir();
   const docCount = countMdFiles(memoryDir);
   const mcpDir = getLibPath("cf-memory");
-  ensureBuilt(mcpDir);
+  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 sqliteAvailable = areSqliteDepsAvailable();
@@ -140,6 +190,20 @@ async function memoryStatusCommand() {
     const model = embeddingConfig.model ?? (provider === "ollama" ? "all-minilm:l6-v2" : "Xenova/all-MiniLM-L6-v2");
     log.info(`Embedding: ${chalk.cyan(model)} ${chalk.dim(`(${provider})`)}`);
   }
+  const mcpStatus = getMemoryMcpStatus();
+  if (mcpStatus.configured && mcpStatus.scope === "local") {
+    log.info(
+      `MCP: ${chalk.green("configured")} ${chalk.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")}`
+    );
+  } else {
+    log.info(
+      `MCP: ${chalk.dim("not configured")} ${chalk.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")}`
@@ -165,7 +229,7 @@ async function memorySearchCommand(query) {
     process.exit(1);
   }
   const mcpDir = getLibPath("cf-memory");
-  ensureBuilt(mcpDir);
+  ensureMemoryBuilt(mcpDir);
   const result = run(
     "node",
     [
@@ -205,7 +269,7 @@ async function memoryListCommand(opts) {
     return;
   }
   const mcpDir = getLibPath("cf-memory");
-  ensureBuilt(mcpDir);
+  ensureMemoryBuilt(mcpDir);
   const result = run(
     "node",
     [
@@ -246,7 +310,7 @@ async function memoryListCommand(opts) {
 async function memoryStartDaemonCommand() {
   const memoryDir = getMemoryDir();
   const mcpDir = getLibPath("cf-memory");
-  ensureBuilt(mcpDir);
+  ensureMemoryBuilt(mcpDir);
   const { isDaemonRunning, getDaemonInfo, spawnDaemon } = await import(join(mcpDir, "dist/daemon/process.js"));
   if (await isDaemonRunning()) {
     const info = getDaemonInfo();
@@ -256,7 +320,8 @@ async function memoryStartDaemonCommand() {
   log.step("Starting memory daemon...");
   const config = loadConfig();
   const embedding = config.memory?.embedding;
-  const result = await spawnDaemon(memoryDir, embedding);
+  const idleTimeoutMs = config.memory?.daemon?.idleTimeout;
+  const result = await spawnDaemon(memoryDir, embedding, { idleTimeoutMs });
   if (result) {
     log.success(`Daemon started (PID ${result.pid})`);
     log.info(`Watching ${chalk.cyan(memoryDir)} for changes`);
@@ -267,7 +332,7 @@ async function memoryStartDaemonCommand() {
 }
 async function memoryStopDaemonCommand() {
   const mcpDir = getLibPath("cf-memory");
-  ensureBuilt(mcpDir);
+  ensureMemoryBuilt(mcpDir);
   const { stopDaemon, isDaemonRunning } = await import(join(mcpDir, "dist/daemon/process.js"));
   if (!await isDaemonRunning()) {
     log.info("Daemon is not running.");
@@ -284,7 +349,7 @@ async function memoryStopDaemonCommand() {
 async function memoryRebuildCommand() {
   const memoryDir = getMemoryDir();
   const mcpDir = getLibPath("cf-memory");
-  ensureBuilt(mcpDir);
+  ensureMemoryBuilt(mcpDir);
   const { areSqliteDepsAvailable } = await import(join(mcpDir, "dist/lib/lazy-install.js"));
   if (areSqliteDepsAvailable()) {
     log.step("Rebuilding SQLite index + embeddings...");
@@ -346,10 +411,61 @@ function getDbPath(memoryDir) {
   }
 }
 var em = chalk.hex("#10b981");
+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"));
+  if (areSqliteDepsAvailable()) return true;
+  log.step("Installing SQLite dependencies...");
+  const installed = await ensureDeps({
+    onProgress: (msg) => log.step(msg)
+  });
+  if (!installed) {
+    log.error("Failed to install SQLite dependencies.");
+    log.dim(
+      "Ensure you have a C++ compiler installed (Xcode CLT on macOS, build-essential on Linux)."
+    );
+    log.dim(
+      'Memory will fall back to a lower tier. You can retry later with "cf memory init".'
+    );
+    return false;
+  }
+  log.success("Dependencies installed.");
+  return true;
+}
+async function setupMemoryMcp(memoryDir, mcpDir) {
+  const mcpStatus = getMemoryMcpStatus();
+  if (mcpStatus.configured && mcpStatus.scope === "local") {
+    log.info(`MCP: ${chalk.green("already configured")} in .mcp.json`);
+    return;
+  }
+  console.log();
+  log.step("MCP setup");
+  log.dim(
+    "The Memory MCP connects Claude Code to the memory system so skills can store and search memories."
+  );
+  const addMcp = await confirm({
+    message: "Add coding-friend-memory to .mcp.json?",
+    default: true
+  });
+  if (!addMcp) {
+    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);
+}
 async function memoryInitCommand() {
   const memoryDir = getMemoryDir();
   const mcpDir = getLibPath("cf-memory");
-  ensureBuilt(mcpDir);
+  ensureMemoryBuilt(mcpDir);
   const dbExists = getDbPath(memoryDir) !== null;
   if (dbExists) {
     console.log();
@@ -359,6 +475,7 @@ async function memoryInitCommand() {
     log.dim('To re-import memories, run "cf memory rebuild".');
     console.log();
     await memoryConfigMenu({ exitLabel: "Done" });
+    await ensureSqliteDepsIfNeeded(mcpDir);
     return;
   }
   console.log();
@@ -403,47 +520,33 @@ async function memoryInitCommand() {
   const config = loadConfig();
   const tier = config.memory?.tier ?? "auto";
   if (tier === "markdown") {
+    await setupMemoryMcp(memoryDir, mcpDir);
     log.success(
       'Memory initialized with Tier 3 (markdown). Run "cf memory status" to verify.'
     );
     return;
   }
   if (tier === "lite") {
+    await setupMemoryMcp(memoryDir, mcpDir);
     log.success(
       'Memory initialized. Run "cf memory start-daemon" to enable Tier 2 search.'
     );
     return;
   }
-  log.step("Installing SQLite dependencies...");
-  const { ensureDeps, areSqliteDepsAvailable } = await import(join(mcpDir, "dist/lib/lazy-install.js"));
-  if (areSqliteDepsAvailable()) {
-    log.info("SQLite dependencies already installed.");
-  } else {
-    const installed = await ensureDeps({
-      onProgress: (msg) => log.step(msg)
-    });
-    if (!installed) {
-      log.error("Failed to install SQLite dependencies.");
-      log.dim(
-        "Ensure you have a C++ compiler installed (Xcode CLT on macOS, build-essential on Linux)."
-      );
-      log.dim(
-        'Memory will fall back to a lower tier. You can retry later with "cf memory init".'
-      );
-      return;
-    }
-    log.success("Dependencies installed.");
-  }
+  const depsOk = await ensureSqliteDepsIfNeeded(mcpDir);
+  if (!depsOk) return;
   if (!existsSync(memoryDir)) {
     log.info(
       "No memory directory found. Memories will be indexed as they're created."
     );
+    await setupMemoryMcp(memoryDir, mcpDir);
     log.success('Memory initialized. Run "cf memory status" to verify.');
     return;
   }
   const docCount = countMdFiles(memoryDir);
   if (docCount === 0) {
     log.info("No existing memories to import.");
+    await setupMemoryMcp(memoryDir, mcpDir);
     log.success('Memory initialized. Run "cf memory status" to verify.');
     return;
   }
@@ -464,6 +567,7 @@ async function memoryInitCommand() {
   } finally {
     await backend.close();
   }
+  await setupMemoryMcp(memoryDir, mcpDir);
   console.log();
   log.success('Memory initialized! Run "cf memory status" to verify.');
   log.info(
@@ -563,7 +667,7 @@ function getProjectInfo(projectDir, projectId, mcpDir, knownSourceDir) {
 async function memoryListProjectsCommand() {
   const baseDir = getProjectsBaseDir();
   const mcpDir = getLibPath("cf-memory");
-  ensureBuilt(mcpDir);
+  ensureMemoryBuilt(mcpDir);
   if (!existsSync(baseDir)) {
     log.info("No memory projects found.");
     log.dim('Run "cf memory init" in a project to create one.');
@@ -617,7 +721,7 @@ async function memoryRmCommand(opts) {
   }
   if (opts.prune) {
     const mcpDir = getLibPath("cf-memory");
-    ensureBuilt(mcpDir);
+    ensureMemoryBuilt(mcpDir);
     const dirs = readdirSync(baseDir, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith(".")).map((d) => d.name);
     const orphaned = [];
     for (const id of dirs) {
@@ -734,50 +838,22 @@ async function memoryRmCommand(opts) {
 async function memoryMcpCommand() {
   const memoryDir = getMemoryDir();
   const mcpDir = getLibPath("cf-memory");
-  ensureBuilt(mcpDir);
+  ensureMemoryBuilt(mcpDir);
   const serverPath = join(mcpDir, "dist", "index.js");
-  console.log(`Add this to your MCP client config:
-
---- Claude Desktop / Claude Chat (claude_desktop_config.json) ---
-
-{
-  "mcpServers": {
-    "coding-friend-memory": {
-      "command": "node",
-      "args": ["${serverPath}", "${memoryDir}"]
-    }
-  }
+  printMemoryMcpConfig(serverPath, memoryDir);
 }
 
---- Generic MCP client ---
-
-Server command: node ${serverPath} ${memoryDir}
-Transport: stdio
-
---- Available tools ---
-
-  memory_store       Store a new memory
-  memory_search      Search memories (keyword match)
-  memory_retrieve    Get a specific memory by ID
-  memory_list        List memories with filtering
-  memory_update      Update existing memory
-  memory_delete      Delete a memory
-
---- Resources ---
-
-  memory://index     Browse all memories
-  memory://stats     Storage statistics
-`);
-}
 export {
-  memoryConfigCommand,
-  memoryInitCommand,
+  ensureMemoryBuilt,
+  printMemoryMcpConfig,
+  memoryStatusCommand,
+  memorySearchCommand,
   memoryListCommand,
-  memoryMcpCommand,
+  memoryStartDaemonCommand,
+  memoryStopDaemonCommand,
   memoryRebuildCommand,
+  memoryInitCommand,
+  memoryConfigCommand,
   memoryRmCommand,
-  memorySearchCommand,
-  memoryStartDaemonCommand,
-  memoryStatusCommand,
-  memoryStopDaemonCommand
+  memoryMcpCommand
 };

package/dist/{config-5I3XJEEL.js → config-K2S23A5R.js}

@@ -1,11 +1,12 @@
 import {
   memoryConfigMenu
-} from "./chunk-3KXYEC2T.js";
+} from "./chunk-LCABODSZ.js";
 import {
   getAllRules,
   getExistingRules
 } from "./chunk-HEBLANJO.js";
 import "./chunk-RZRT7NGT.js";
+import "./chunk-SIQJPT47.js";
 import {
   findStatuslineHookPath,
   isStatuslineConfigured,

package/dist/index.js

@@ -30,19 +30,19 @@ program.command("enable").description("Re-enable the Coding Friend plugin").opti
   await enableCommand(opts);
 });
 program.command("init").description("Initialize coding-friend in current project").action(async () => {
-  const { initCommand } = await import("./init-3XMC6YJI.js");
+  const { initCommand } = await import("./init-FMPOE2MN.js");
   await initCommand();
 });
 program.command("config").description("Manage Coding Friend configuration").action(async () => {
-  const { configCommand } = await import("./config-5I3XJEEL.js");
+  const { configCommand } = await import("./config-K2S23A5R.js");
   await configCommand();
 });
 program.command("host").description("Build and serve learning docs as a static website").argument("[path]", "path to docs folder").option("-p, --port <port>", "port number", "3333").action(async (path, opts) => {
-  const { hostCommand } = await import("./host-V5O3PDCF.js");
+  const { hostCommand } = await import("./host-E644BDZK.js");
   await hostCommand(path, opts);
 });
 program.command("mcp").description("Setup MCP server for learning docs").argument("[path]", "path to docs folder").action(async (path) => {
-  const { mcpCommand } = await import("./mcp-U34LFD34.js");
+  const { mcpCommand } = await import("./mcp-SQWZXF5Q.js");
   await mcpCommand(path);
 });
 program.command("permission").description("Manage Claude Code permission rules for Coding Friend").option("--all", "Apply all recommended permissions without prompts").option("--user", "Save to user-level settings (~/.claude/settings.json)").option(
@@ -61,7 +61,7 @@ program.command("update").description("Update coding-friend plugin, CLI, and sta
   await updateCommand(opts);
 });
 program.command("status").description("Show comprehensive Coding Friend status").action(async () => {
-  const { statusCommand } = await import("./status-F6WASK7N.js");
+  const { statusCommand } = await import("./status-CGYNNMYF.js");
   await statusCommand();
 });
 var session = program.command("session").description("Save and load Claude Code sessions across machines");
@@ -100,43 +100,43 @@ Memory subcommands:
   memory mcp          Show MCP server setup instructions`
 );
 memory.command("status").description("Show memory system status").action(async () => {
-  const { memoryStatusCommand } = await import("./memory-PDENAODU.js");
+  const { memoryStatusCommand } = await import("./memory-7WLVIFAZ.js");
   await memoryStatusCommand();
 });
 memory.command("search").description("Search memories by query").argument("<query>", "search query").action(async (query) => {
-  const { memorySearchCommand } = await import("./memory-PDENAODU.js");
+  const { memorySearchCommand } = await import("./memory-7WLVIFAZ.js");
   await memorySearchCommand(query);
 });
 memory.command("list").description(
   "List memories in current project, or all projects with --projects"
 ).option("--projects", "List all project databases with size and metadata").action(async (opts) => {
-  const { memoryListCommand } = await import("./memory-PDENAODU.js");
+  const { memoryListCommand } = await import("./memory-7WLVIFAZ.js");
   await memoryListCommand(opts);
 });
 memory.command("init").description(
   "Initialize memory system \u2014 interactive wizard (first time) or config menu"
 ).action(async () => {
-  const { memoryInitCommand } = await import("./memory-PDENAODU.js");
+  const { memoryInitCommand } = await import("./memory-7WLVIFAZ.js");
   await memoryInitCommand();
 });
 memory.command("config").description("Configure memory system settings").action(async () => {
-  const { memoryConfigCommand } = await import("./memory-PDENAODU.js");
+  const { memoryConfigCommand } = await import("./memory-7WLVIFAZ.js");
   await memoryConfigCommand();
 });
 memory.command("start-daemon").description("Start the memory daemon (Tier 2 \u2014 MiniSearch)").action(async () => {
-  const { memoryStartDaemonCommand } = await import("./memory-PDENAODU.js");
+  const { memoryStartDaemonCommand } = await import("./memory-7WLVIFAZ.js");
   await memoryStartDaemonCommand();
 });
 memory.command("stop-daemon").description("Stop the memory daemon").action(async () => {
-  const { memoryStopDaemonCommand } = await import("./memory-PDENAODU.js");
+  const { memoryStopDaemonCommand } = await import("./memory-7WLVIFAZ.js");
   await memoryStopDaemonCommand();
 });
 memory.command("rebuild").description("Rebuild the daemon search index").action(async () => {
-  const { memoryRebuildCommand } = await import("./memory-PDENAODU.js");
+  const { memoryRebuildCommand } = await import("./memory-7WLVIFAZ.js");
   await memoryRebuildCommand();
 });
 memory.command("mcp").description("Show MCP server setup instructions").action(async () => {
-  const { memoryMcpCommand } = await import("./memory-PDENAODU.js");
+  const { memoryMcpCommand } = await import("./memory-7WLVIFAZ.js");
   await memoryMcpCommand();
 });
 memory.command("rm").description("Remove a project database").option("--project-id <id>", "Project ID to remove").option("--all", "Remove all project databases").option(
@@ -144,7 +144,7 @@ memory.command("rm").description("Remove a project database").option("--project-
   "Remove orphaned projects (source dir missing or 0 memories)"
 ).action(
   async (opts) => {
-    const { memoryRmCommand } = await import("./memory-PDENAODU.js");
+    const { memoryRmCommand } = await import("./memory-7WLVIFAZ.js");
     await memoryRmCommand(opts);
   }
 );

package/dist/{init-3XMC6YJI.js → init-FMPOE2MN.js}

@@ -1,3 +1,7 @@
+import {
+  getMemoryMcpStatus,
+  writeMemoryMcpEntry
+} from "./chunk-LCABODSZ.js";
 import {
   applyPermissions,
   buildLearnDirRules,
@@ -10,6 +14,7 @@ import {
 import {
   getLibPath
 } from "./chunk-RZRT7NGT.js";
+import "./chunk-SIQJPT47.js";
 import {
   findStatuslineHookPath,
   isStatuslineConfigured,
@@ -587,15 +592,9 @@ async function stepStatusline() {
   writeStatuslineSettings(hookResult.hookPath);
   log.success("Statusline configured!");
 }
-function isMemoryMcpConfigured() {
-  const mcpPath = join(process.cwd(), ".mcp.json");
-  const config = readJson(mcpPath);
-  if (!config) return false;
-  const servers = config.mcpServers;
-  return servers != null && "coding-friend-memory" in servers;
-}
 async function stepMemory(docsDir) {
-  if (isMemoryMcpConfigured()) {
+  const mcpStatus = getMemoryMcpStatus();
+  if (mcpStatus.configured) {
     printStepHeader(
       `CF Memory MCP ${chalk.green("[done]")}`,
       "Connects the memory system to Claude Code via MCP."
@@ -642,20 +641,7 @@ async function stepMemory(docsDir) {
     return;
   }
   const memoryDir = join(process.cwd(), docsDir, "memory");
-  const mcpPath = join(process.cwd(), ".mcp.json");
-  const existing = readJson(mcpPath) ?? {};
-  const servers = existing.mcpServers ?? {};
-  writeJson(mcpPath, {
-    ...existing,
-    mcpServers: {
-      ...servers,
-      "coding-friend-memory": {
-        command: "node",
-        args: [serverPath, memoryDir]
-      }
-    }
-  });
-  log.success(`Added coding-friend-memory to .mcp.json`);
+  writeMemoryMcpEntry(serverPath, memoryDir);
   const autoCapture = await confirm({
     message: "Enable auto-capture? (saves session summaries to memory before context compaction)",
     default: false

package/dist/{mcp-U34LFD34.js → mcp-SQWZXF5Q.js}

@@ -1,10 +1,17 @@
 import {
-  resolveDocsDir
-} from "./chunk-SIQJPT47.js";
+  ensureMemoryBuilt,
+  printMemoryMcpConfig
+} from "./chunk-TPLH46BH.js";
+import "./chunk-LCABODSZ.js";
 import {
   getLibPath
 } from "./chunk-RZRT7NGT.js";
+import {
+  resolveDocsDir,
+  resolveMemoryDir
+} from "./chunk-SIQJPT47.js";
 import "./chunk-PRIH34UB.js";
+import "./chunk-BIX7AJU3.js";
 import {
   run
 } from "./chunk-EVGXUDX4.js";
@@ -43,7 +50,7 @@ async function mcpCommand(path) {
     log.dim("Run /cf-learn first to generate some docs.");
     process.exit(1);
   }
-  console.log("=== \u{1F33F} Coding Friend MCP \u{1F33F} ===");
+  console.log(chalk.green.bold("=== \u{1F4DA} Learn MCP ==="));
   log.info(`Docs folder: ${chalk.cyan(docsDir)}`);
   log.info(`Found: ${chalk.green(docCount)} docs`);
   console.log();
@@ -100,6 +107,26 @@ Write:
   improve-doc        Get improvement suggestions
   track-knowledge    Record understanding level (remembered/needs-review/new)
 `);
+  printMemoryMcp();
+}
+function printMemoryMcp() {
+  const memoryDir = resolveMemoryDir();
+  let mcpDir;
+  try {
+    mcpDir = getLibPath("cf-memory");
+  } catch {
+    log.dim(
+      'Memory MCP: cf-memory package not found. Run "cf memory init" to set it up.'
+    );
+    return;
+  }
+  ensureMemoryBuilt(mcpDir);
+  const serverPath = join(mcpDir, "dist", "index.js");
+  console.log();
+  console.log(chalk.magenta.bold("=== \u{1F9E0} Memory MCP ==="));
+  log.info(`Memory dir: ${chalk.cyan(memoryDir)}`);
+  console.log();
+  printMemoryMcpConfig(serverPath, memoryDir);
 }
 export {
   mcpCommand

package/dist/memory-7WLVIFAZ.js

@@ -0,0 +1,37 @@
+import {
+  ensureMemoryBuilt,
+  memoryConfigCommand,
+  memoryInitCommand,
+  memoryListCommand,
+  memoryMcpCommand,
+  memoryRebuildCommand,
+  memoryRmCommand,
+  memorySearchCommand,
+  memoryStartDaemonCommand,
+  memoryStatusCommand,
+  memoryStopDaemonCommand,
+  printMemoryMcpConfig
+} from "./chunk-TPLH46BH.js";
+import "./chunk-LCABODSZ.js";
+import "./chunk-RZRT7NGT.js";
+import "./chunk-SIQJPT47.js";
+import "./chunk-PRIH34UB.js";
+import "./chunk-BIX7AJU3.js";
+import "./chunk-EVGXUDX4.js";
+import "./chunk-5UVDWG5L.js";
+import "./chunk-DO6FV6BL.js";
+import "./chunk-W5CD7WTX.js";
+export {
+  ensureMemoryBuilt,
+  memoryConfigCommand,
+  memoryInitCommand,
+  memoryListCommand,
+  memoryMcpCommand,
+  memoryRebuildCommand,
+  memoryRmCommand,
+  memorySearchCommand,
+  memoryStartDaemonCommand,
+  memoryStatusCommand,
+  memoryStopDaemonCommand,
+  printMemoryMcpConfig
+};

package/lib/cf-memory/CHANGELOG.md

@@ -1,5 +1,11 @@
 # CF Memory Changelog
 
+## v0.2.2 (2026-03-25)
+
+- Add NaN guard for `MEMORY_DAEMON_IDLE_TIMEOUT` env var to prevent invalid timeout values [#d4401fa](https://github.com/dinhanhthi/coding-friend/commit/d4401fa)
+- Fix `ping()` to use raw request instead of triggering daemon respawn during tier detection [#d4401fa](https://github.com/dinhanhthi/coding-friend/commit/d4401fa)
+- Pass `daemonOptions` consistently in index.ts instead of inline object [#d4401fa](https://github.com/dinhanhthi/coding-friend/commit/d4401fa)
+
 ## v0.2.1 (2026-03-22)
 
 - Fix flaky tier detection tests — mock `isDaemonRunning` to prevent local daemon from affecting test results [#d786f08](https://github.com/dinhanhthi/coding-friend/commit/d786f08)

package/lib/cf-memory/README.md

@@ -229,6 +229,8 @@ node dist/daemon/entry.js ./docs/memory 1800000 --tier=lite
 
 The daemon runs a Hono HTTP server on a Unix Domain Socket at `~/.coding-friend/memory/daemon.sock`, with PID tracking at `~/.coding-friend/memory/daemon.pid`.
 
+**Auto-reconnect:** If the daemon dies (e.g., idle timeout expires), the `DaemonClient` automatically respawns it on the next request. This means mid-session daemon restarts are transparent — no manual intervention needed.
+
 ### Lazy dependencies (Tier 1)
 
 Heavy dependencies for Tier 1 (SQLite + embeddings) are installed on-demand into `~/.coding-friend/memory/node_modules/`, not in this package's `node_modules/`. These include:
@@ -302,6 +304,7 @@ If these are missing, `cf memory init` will fail at the "Installing SQLite depen
 | ----------------------------- | ------------------------ | ------------------------------------------------- |
 | `MEMORY_DOCS_DIR`             | `./docs/memory`          | Path to memory storage directory                  |
 | `MEMORY_TIER`                 | `auto`                   | Force a tier: `auto`, `full`, `lite`, `markdown`  |
+| `MEMORY_DAEMON_IDLE_TIMEOUT`  | `1800000` (30 min)       | Daemon idle timeout in ms (`0` = never auto-stop) |
 | `MEMORY_EMBEDDING_PROVIDER`   | `transformers`           | Embedding provider: `transformers` or `ollama`    |
 | `MEMORY_EMBEDDING_MODEL`      | (provider default)       | Embedding model name (e.g., `nomic-embed-text`)   |
 | `MEMORY_EMBEDDING_OLLAMA_URL` | `http://localhost:11434` | Ollama server URL                                 |

package/lib/cf-memory/package.json

@@ -1,6 +1,6 @@
 {
   "name": "coding-friend-cf-memory",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "private": true,
   "type": "module",
   "bin": {

package/lib/cf-memory/src/__tests__/daemon-client.test.ts

@@ -0,0 +1,146 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { mkdirSync, rmSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+import { DaemonClient } from "../lib/daemon-client.js";
+import { startDaemonServer, type DaemonPaths } from "../daemon/process.js";
+import { MiniSearchBackend } from "../backends/minisearch.js";
+
+let testDir: string;
+let testPaths: DaemonPaths;
+let counter = 0;
+
+beforeEach(() => {
+  testDir = join(tmpdir(), `cf-daemon-client-test-${Date.now()}-${++counter}`);
+  mkdirSync(testDir, { recursive: true });
+
+  const daemonDir = join(testDir, "daemon");
+  mkdirSync(daemonDir, { recursive: true });
+
+  testPaths = {
+    socketPath: join(daemonDir, "daemon.sock"),
+    pidFile: join(daemonDir, "daemon.pid"),
+    logFile: join(daemonDir, "daemon.log"),
+  };
+});
+
+afterEach(() => {
+  rmSync(testDir, { recursive: true, force: true });
+});
+
+describe("DaemonClient auto-reconnect", () => {
+  it("calls respawn and retries on connection error", async () => {
+    const docsDir = join(testDir, "docs");
+    mkdirSync(docsDir, { recursive: true });
+
+    // Start daemon
+    const backend = new MiniSearchBackend(docsDir);
+    let handle = startDaemonServer(backend, {
+      paths: testPaths,
+      idleTimeoutMs: 0,
+    });
+    await new Promise<void>((resolve) => {
+      handle.server.once("listening", resolve);
+    });
+
+    const respawn = vi.fn(async () => {
+      // Re-create a fresh backend and server on same paths
+      const newBackend = new MiniSearchBackend(docsDir);
+      handle = startDaemonServer(newBackend, {
+        paths: testPaths,
+        idleTimeoutMs: 0,
+      });
+      await new Promise<void>((resolve) => {
+        handle.server.once("listening", resolve);
+      });
+      return true;
+    });
+
+    const client = new DaemonClient(testPaths.socketPath, { respawn });
+
+    // Verify initial connection works
+    const alive = await client.ping();
+    expect(alive).toBe(true);
+
+    // Kill daemon and wait for socket cleanup
+    await new Promise<void>((resolve) => {
+      handle.server.close(() => resolve());
+    });
+    rmSync(testPaths.socketPath, { force: true });
+    rmSync(testPaths.pidFile, { force: true });
+    // Small delay to ensure OS fully releases the socket
+    await new Promise((r) => setTimeout(r, 50));
+
+    // Next request should trigger respawn and succeed
+    const stats = await client.stats();
+    expect(stats.total).toBe(0);
+    expect(respawn).toHaveBeenCalledOnce();
+
+    // Cleanup
+    await new Promise<void>((resolve) => {
+      handle.server.close(() => resolve());
+    });
+    rmSync(testPaths.socketPath, { force: true });
+    rmSync(testPaths.pidFile, { force: true });
+  });
+
+  it("throws original error when respawn fails", async () => {
+    const respawn = vi.fn(async () => false);
+    const client = new DaemonClient(
+      "/tmp/nonexistent-cf-test-sock-" + Date.now(),
+      { respawn },
+    );
+
+    await expect(client.stats()).rejects.toThrow();
+    expect(respawn).toHaveBeenCalledOnce();
+  });
+
+  it("throws directly without respawn callback", async () => {
+    const client = new DaemonClient(
+      "/tmp/nonexistent-cf-test-sock-" + Date.now(),
+    );
+
+    await expect(client.stats()).rejects.toThrow();
+  });
+
+  it("ping does not trigger respawn", async () => {
+    const respawn = vi.fn(async () => true);
+    const client = new DaemonClient(
+      "/tmp/nonexistent-cf-test-sock-" + Date.now(),
+      { respawn },
+    );
+
+    // ping() should return false without attempting respawn
+    const alive = await client.ping();
+    expect(alive).toBe(false);
+    expect(respawn).not.toHaveBeenCalled();
+  });
+
+  it("does not call respawn for HTTP 4xx errors", async () => {
+    const docsDir = join(testDir, "docs");
+    mkdirSync(docsDir, { recursive: true });
+
+    const backend = new MiniSearchBackend(docsDir);
+    const handle = startDaemonServer(backend, {
+      paths: testPaths,
+      idleTimeoutMs: 0,
+    });
+    await new Promise<void>((resolve) => {
+      handle.server.once("listening", resolve);
+    });
+
+    const respawn = vi.fn(async () => true);
+    const client = new DaemonClient(testPaths.socketPath, { respawn });
+
+    // 404 is not a connection error — should not trigger respawn
+    const result = await client.retrieve("nonexistent/id");
+    expect(result).toBeNull();
+    expect(respawn).not.toHaveBeenCalled();
+
+    await new Promise<void>((resolve) => {
+      handle.server.close(() => resolve());
+    });
+    rmSync(testPaths.socketPath, { force: true });
+    rmSync(testPaths.pidFile, { force: true });
+  });
+});

package/lib/cf-memory/src/daemon/process.ts

@@ -189,6 +189,9 @@ export async function spawnDaemon(
     model?: string;
     ollamaUrl?: string;
   },
+  opts?: {
+    idleTimeoutMs?: number;
+  },
 ): Promise<{ pid: number } | null> {
   if (await isDaemonRunning()) return null;
 
@@ -201,6 +204,10 @@ export async function spawnDaemon(
   if (!fs.existsSync(entryPath)) return null;
 
   const args = [entryPath, docsDir];
+  // Pass idle timeout as positional arg (entry.js expects it as argv[3])
+  if (opts?.idleTimeoutMs !== undefined) {
+    args.push(String(opts.idleTimeoutMs));
+  }
   if (embeddingConfig?.provider)
     args.push(`--embedding-provider=${embeddingConfig.provider}`);
   if (embeddingConfig?.model)

package/lib/cf-memory/src/index.ts

@@ -12,6 +12,13 @@ const rawDir =
 const docsDir = path.resolve(rawDir);
 const tierConfig = (process.env.MEMORY_TIER ?? "auto") as TierConfig;
 
+// Daemon idle timeout from env (in milliseconds, 0 = disable)
+const idleTimeoutMs = (() => {
+  if (!process.env.MEMORY_DAEMON_IDLE_TIMEOUT) return undefined;
+  const parsed = parseInt(process.env.MEMORY_DAEMON_IDLE_TIMEOUT, 10);
+  return isNaN(parsed) ? undefined : parsed;
+})();
+
 // Embedding config from environment variables
 const embeddingConfig: Partial<EmbeddingConfig> | undefined = (() => {
   const provider = process.env.MEMORY_EMBEDDING_PROVIDER as
@@ -27,10 +34,15 @@ const embeddingConfig: Partial<EmbeddingConfig> | undefined = (() => {
   };
 })();
 
+const daemonOptions =
+  idleTimeoutMs !== undefined ? { idleTimeoutMs } : undefined;
+
 const { backend, tier } = await createBackendForTier(
   docsDir,
   tierConfig,
   embeddingConfig,
+  undefined,
+  daemonOptions,
 );
 
 // Auto-start daemon for file watching (Tier 1 & 2)
@@ -38,7 +50,7 @@ const { backend, tier } = await createBackendForTier(
 // and rebuilds the search index automatically.
 if (tier.name !== "markdown") {
   const { spawnDaemon } = await import("./daemon/process.js");
-  spawnDaemon(docsDir, embeddingConfig).catch(() => {});
+  spawnDaemon(docsDir, embeddingConfig, daemonOptions).catch(() => {});
 }
 
 const server = new McpServer({

package/lib/cf-memory/src/lib/daemon-client.ts

@@ -11,13 +11,32 @@ import type {
   UpdateInput,
 } from "./types.js";
 
+export interface DaemonClientOptions {
+  /** Called to respawn the daemon when a connection fails. */
+  respawn?: () => Promise<boolean>;
+}
+
 /**
  * MemoryBackend implementation that talks to the daemon over UDS.
+ *
+ * When a `respawn` callback is provided, connection errors automatically
+ * trigger a single respawn attempt followed by a retry of the original request.
  */
 export class DaemonClient implements MemoryBackend {
-  constructor(private socketPath: string) {}
+  private respawn?: () => Promise<boolean>;
+
+  constructor(
+    private socketPath: string,
+    opts?: DaemonClientOptions,
+  ) {
+    this.respawn = opts?.respawn;
+  }
 
-  private request<T>(method: string, path: string, body?: unknown): Promise<T> {
+  private rawRequest<T>(
+    method: string,
+    path: string,
+    body?: unknown,
+  ): Promise<T> {
     return new Promise((resolve, reject) => {
       const options: http.RequestOptions = {
         socketPath: this.socketPath,
@@ -68,6 +87,27 @@ export class DaemonClient implements MemoryBackend {
     });
   }
 
+  /**
+   * Send a request to the daemon. On connection error (ECONNREFUSED, ENOENT),
+   * attempt to respawn the daemon once and retry.
+   */
+  private async request<T>(
+    method: string,
+    path: string,
+    body?: unknown,
+  ): Promise<T> {
+    try {
+      return await this.rawRequest<T>(method, path, body);
+    } catch (err) {
+      if (!this.respawn || !isConnectionError(err)) throw err;
+
+      const ok = await this.respawn();
+      if (!ok) throw err;
+
+      return this.rawRequest<T>(method, path, body);
+    }
+  }
+
   async store(input: StoreInput): Promise<Memory> {
     const result = await this.request<{
       id: string;
@@ -143,7 +183,11 @@ export class DaemonClient implements MemoryBackend {
    */
   async ping(): Promise<boolean> {
     try {
-      const result = await this.request<{ status: string }>("GET", "/health");
+      // Use rawRequest — ping checks liveness, must not trigger respawn
+      const result = await this.rawRequest<{ status: string }>(
+        "GET",
+        "/health",
+      );
       return result.status === "ok";
     } catch {
       return false;
@@ -161,3 +205,10 @@ export class DaemonClient implements MemoryBackend {
     }
   }
 }
+
+/** Connection-level errors that indicate the daemon process is gone. */
+function isConnectionError(err: unknown): boolean {
+  if (!(err instanceof Error)) return false;
+  const code = (err as NodeJS.ErrnoException).code;
+  return code === "ECONNREFUSED" || code === "ENOENT" || code === "ECONNRESET";
+}

package/lib/cf-memory/src/lib/tier.ts

@@ -1,7 +1,11 @@
 import type { MemoryBackend } from "./backend.js";
 import { DaemonClient } from "./daemon-client.js";
 import { MarkdownBackend } from "../backends/markdown.js";
-import { getDaemonPaths, isDaemonRunning } from "../daemon/process.js";
+import {
+  getDaemonPaths,
+  isDaemonRunning,
+  spawnDaemon,
+} from "../daemon/process.js";
 import { areSqliteDepsAvailable } from "./lazy-install.js";
 import type { EmbeddingConfig } from "../backends/sqlite/embeddings.js";
 import type { SqliteBackendOptions } from "../backends/sqlite/index.js";
@@ -46,6 +50,20 @@ export async function detectTier(configTier?: TierConfig): Promise<TierInfo> {
   return TIERS.markdown;
 }
 
+/** Build a respawn callback that DaemonClient can call when the daemon is gone. */
+function makeRespawn(
+  docsDir: string,
+  embeddingConfig?: Partial<EmbeddingConfig>,
+  idleTimeoutMs?: number,
+): () => Promise<boolean> {
+  return async () => {
+    const result = await spawnDaemon(docsDir, embeddingConfig, {
+      idleTimeoutMs,
+    });
+    return result !== null;
+  };
+}
+
 /**
  * Create the appropriate backend for the detected tier.
  */
@@ -54,8 +72,14 @@ export async function createBackendForTier(
   configTier?: TierConfig,
   embeddingConfig?: Partial<EmbeddingConfig>,
   sqliteOptions?: Pick<SqliteBackendOptions, "dbPath">,
+  daemonOptions?: { idleTimeoutMs?: number },
 ): Promise<{ backend: MemoryBackend; tier: TierInfo }> {
   const tier = await detectTier(configTier);
+  const respawn = makeRespawn(
+    docsDir,
+    embeddingConfig,
+    daemonOptions?.idleTimeoutMs,
+  );
 
   switch (tier.name) {
     case "full": {
@@ -71,7 +95,7 @@ export async function createBackendForTier(
         // SQLite backend failed — fall through to daemon or markdown
         if (await isDaemonRunning()) {
           const paths = getDaemonPaths();
-          const client = new DaemonClient(paths.socketPath);
+          const client = new DaemonClient(paths.socketPath, { respawn });
           const alive = await client.ping();
           if (alive) {
             return { backend: client, tier: TIERS.lite };
@@ -86,7 +110,7 @@ export async function createBackendForTier(
     case "lite": {
       // Use daemon client
       const paths = getDaemonPaths();
-      const client = new DaemonClient(paths.socketPath);
+      const client = new DaemonClient(paths.socketPath, { respawn });
       const alive = await client.ping();
       if (alive) {
         return { backend: client, tier };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "coding-friend-cli",
-  "version": "1.21.0",
+  "version": "1.22.0",
   "description": "CLI for coding-friend — host learning docs, setup MCP server, initialize projects",
   "type": "module",
   "bin": {

package/dist/{host-V5O3PDCF.js → host-E644BDZK.js}

@@ -1,9 +1,9 @@
-import {
-  resolveDocsDir
-} from "./chunk-SIQJPT47.js";
 import {
   getLibPath
 } from "./chunk-RZRT7NGT.js";
+import {
+  resolveDocsDir
+} from "./chunk-SIQJPT47.js";
 import "./chunk-PRIH34UB.js";
 import {
   run,

package/dist/{status-F6WASK7N.js → status-CGYNNMYF.js}

@@ -1,6 +1,3 @@
-import {
-  resolveMemoryDir
-} from "./chunk-SIQJPT47.js";
 import {
   getCliVersion,
   getLatestCliVersion,
@@ -17,6 +14,9 @@ import {
 import {
   getLibPath
 } from "./chunk-RZRT7NGT.js";
+import {
+  resolveMemoryDir
+} from "./chunk-SIQJPT47.js";
 import {
   getInstalledVersion
 } from "./chunk-TRIALFOQ.js";