coding-friend-cli 1.16.0 → 1.17.1

package/dist/memory-RGLM35HC.js

@@ -0,0 +1,647 @@
+import {
+  loadConfig,
+  resolveMemoryDir
+} from "./chunk-KTX4MGMR.js";
+import {
+  getLibPath
+} from "./chunk-RZRT7NGT.js";
+import "./chunk-POC2WHU2.js";
+import {
+  run
+} from "./chunk-CYQU33FY.js";
+import "./chunk-RWUTFVRB.js";
+import {
+  log
+} from "./chunk-W5CD7WTX.js";
+
+// src/commands/memory.ts
+import { createHash } from "crypto";
+import { existsSync, readdirSync, statSync, rmSync } from "fs";
+import { join, resolve, sep } from "path";
+import { homedir } from "os";
+import { confirm } from "@inquirer/prompts";
+import chalk from "chalk";
+function countMdFiles(dir) {
+  if (!existsSync(dir)) return 0;
+  let count = 0;
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    if (entry.isDirectory()) {
+      count += countMdFiles(join(dir, entry.name));
+    } else if (entry.name.endsWith(".md") && entry.name !== "README.md") {
+      count++;
+    }
+  }
+  return count;
+}
+function getMemoryDir(path) {
+  return resolveMemoryDir(path);
+}
+function ensureBuilt(mcpDir) {
+  if (!existsSync(join(mcpDir, "node_modules"))) {
+    log.step("Installing memory server dependencies (one-time setup)...");
+    const result = run("npm", ["install", "--silent"], { cwd: mcpDir });
+    if (result === null) {
+      log.error("Failed to install dependencies");
+      process.exit(1);
+    }
+    log.success("Done.");
+  }
+  if (!existsSync(join(mcpDir, "dist"))) {
+    log.step("Building memory server...");
+    const result = run("npm", ["run", "build", "--silent"], { cwd: mcpDir });
+    if (result === null) {
+      log.error("Failed to build memory server");
+      process.exit(1);
+    }
+    log.success("Done.");
+  }
+}
+function formatUptime(seconds) {
+  if (seconds < 60) return `${Math.round(seconds)}s`;
+  if (seconds < 3600) return `${Math.round(seconds / 60)}m`;
+  return `${Math.round(seconds / 3600)}h ${Math.round(seconds % 3600 / 60)}m`;
+}
+async function memoryStatusCommand() {
+  const memoryDir = getMemoryDir();
+  const docCount = countMdFiles(memoryDir);
+  const mcpDir = getLibPath("cf-memory");
+  ensureBuilt(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();
+  const running = await isDaemonRunning();
+  const daemonInfo = getDaemonInfo();
+  let tierLabel;
+  if (sqliteAvailable) {
+    tierLabel = chalk.cyan("Tier 1 (SQLite + Hybrid)");
+  } else if (running) {
+    tierLabel = chalk.cyan("Tier 2 (MiniSearch + Daemon)");
+  } else {
+    tierLabel = chalk.cyan("Tier 3 (Markdown)");
+  }
+  console.log("=== \u{1F9E0} Coding Friend Memory ===");
+  console.log();
+  log.info(`Tier: ${tierLabel}`);
+  log.info(`Memory dir: ${chalk.cyan(memoryDir)}`);
+  log.info(`Memories: ${chalk.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"')}`
+    );
+  } else if (sqliteAvailable) {
+    log.info(
+      `Daemon: ${chalk.dim("stopped")} ${chalk.dim("(not needed \u2014 Tier 1 uses SQLite directly)")}`
+    );
+  } else {
+    log.info(
+      `Daemon: ${chalk.dim("stopped")} ${chalk.dim('(run "cf memory start" for Tier 2 search)')}`
+    );
+  }
+  if (sqliteAvailable) {
+    log.info(`SQLite deps: ${chalk.green("installed")}`);
+  } else {
+    log.info(
+      `SQLite deps: ${chalk.dim("not installed")} (run "cf memory init" to enable Tier 1)`
+    );
+  }
+  if (existsSync(memoryDir)) {
+    const categories = readdirSync(memoryDir, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith(".")).map((d) => {
+      const catCount = countMdFiles(join(memoryDir, d.name));
+      return `${d.name} (${catCount})`;
+    }).filter((s) => !s.endsWith("(0)"));
+    if (categories.length > 0) {
+      log.info(`Categories: ${chalk.dim(categories.join(", "))}`);
+    }
+  }
+  console.log();
+  log.dim(`Docs: https://cf.dinhanhthi.com/docs/reference/memory-system/`);
+  console.log();
+}
+async function memorySearchCommand(query) {
+  const memoryDir = getMemoryDir();
+  if (!existsSync(memoryDir)) {
+    log.error(`Memory dir not found: ${memoryDir}`);
+    log.dim("Run `cf init` to create project folders.");
+    process.exit(1);
+  }
+  const mcpDir = getLibPath("cf-memory");
+  ensureBuilt(mcpDir);
+  const result = run(
+    "node",
+    [
+      "-e",
+      `
+      import { MarkdownBackend } from "${join(mcpDir, "dist/backends/markdown.js")}";
+      const backend = new MarkdownBackend("${memoryDir}");
+      const results = await backend.search({ query: process.env.CF_SEARCH_QUERY, limit: 10 });
+      for (const r of results) {
+        console.log(\`[\${r.score}] \${r.memory.frontmatter.title}\`);
+        console.log(\`    \${r.memory.frontmatter.description}\`);
+        console.log(\`    id: \${r.memory.id} | type: \${r.memory.frontmatter.type} | matched: \${r.matchedOn.join(", ")}\`);
+        console.log();
+      }
+      if (results.length === 0) console.log("No results found.");
+      `
+    ],
+    { cwd: memoryDir, env: { ...process.env, CF_SEARCH_QUERY: query } }
+  );
+  if (result !== null) {
+    console.log(result);
+  }
+}
+async function memoryListCommand(opts) {
+  if (opts.projects) {
+    return memoryListProjectsCommand();
+  }
+  const memoryDir = getMemoryDir();
+  if (!existsSync(memoryDir)) {
+    log.info(`No memory directory found at: ${memoryDir}`);
+    log.dim(
+      "This folder has no memories yet. Use --projects to list all project databases."
+    );
+    log.dim(
+      'Or run "cf init" to set up this project, then "/cf-scan" in Claude Code.'
+    );
+    return;
+  }
+  const mcpDir = getLibPath("cf-memory");
+  ensureBuilt(mcpDir);
+  const result = run(
+    "node",
+    [
+      "-e",
+      `
+      import { MarkdownBackend } from "${join(mcpDir, "dist/backends/markdown.js")}";
+      const backend = new MarkdownBackend("${memoryDir}");
+      const metas = await backend.list({});
+      if (metas.length === 0) { console.log("No memories found."); process.exit(0); }
+
+      // Compute column widths
+      const idxW = String(metas.length).length;
+      const typeW = Math.max(4, ...metas.map(m => m.frontmatter.type.length));
+      const idW = Math.max(2, ...metas.map(m => m.id.length));
+
+      // Header
+      const hdr = "#".padStart(idxW) + "  " + "TYPE".padEnd(typeW) + "  " + "ID".padEnd(idW) + "  " + "TITLE";
+      console.log(hdr);
+      console.log("-".repeat(hdr.length + 10));
+
+      metas.forEach((m, i) => {
+        const idx = String(i + 1).padStart(idxW);
+        const type = m.frontmatter.type.padEnd(typeW);
+        const id = m.id.padEnd(idW);
+        console.log(idx + "  " + type + "  " + id + "  " + m.frontmatter.title);
+      });
+
+      console.log();
+      console.log("Total: " + metas.length + " memories");
+      `
+    ],
+    { cwd: memoryDir }
+  );
+  if (result !== null) {
+    console.log(result);
+  }
+}
+async function memoryStartCommand() {
+  const memoryDir = getMemoryDir();
+  const mcpDir = getLibPath("cf-memory");
+  ensureBuilt(mcpDir);
+  const { isDaemonRunning, getDaemonInfo, spawnDaemon } = await import(join(mcpDir, "dist/daemon/process.js"));
+  if (await isDaemonRunning()) {
+    const info = getDaemonInfo();
+    log.info(`Daemon already running (PID ${info?.pid})`);
+    return;
+  }
+  log.step("Starting memory daemon...");
+  const config = loadConfig();
+  const embedding = config.memory?.embedding;
+  const result = await spawnDaemon(memoryDir, embedding);
+  if (result) {
+    log.success(`Daemon started (PID ${result.pid})`);
+    log.info(`Watching ${chalk.cyan(memoryDir)} for changes`);
+  } else {
+    log.error("Daemon did not start within 3 seconds");
+    process.exit(1);
+  }
+}
+async function memoryStopCommand() {
+  const mcpDir = getLibPath("cf-memory");
+  ensureBuilt(mcpDir);
+  const { stopDaemon, isDaemonRunning } = await import(join(mcpDir, "dist/daemon/process.js"));
+  if (!await isDaemonRunning()) {
+    log.info("Daemon is not running.");
+    return;
+  }
+  log.step("Stopping memory daemon...");
+  const stopped = await stopDaemon();
+  if (stopped) {
+    log.success("Daemon stopped.");
+  } else {
+    log.error("Failed to stop daemon.");
+  }
+}
+async function memoryRebuildCommand() {
+  const memoryDir = getMemoryDir();
+  const mcpDir = getLibPath("cf-memory");
+  ensureBuilt(mcpDir);
+  const { areSqliteDepsAvailable } = await import(join(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 config = loadConfig();
+    const embedding = config.memory?.embedding;
+    const opts = embedding ? { embedding, skipVec: false } : { skipVec: false };
+    const backend = new SqliteBackend(memoryDir, opts);
+    try {
+      await backend.rebuild();
+      const stats = await backend.stats();
+      log.success(`Rebuilt: ${stats.total} memories indexed.`);
+      if (backend.isVecEnabled()) {
+        log.info(`Vector search: ${chalk.green("enabled")}`);
+      }
+      if (!backend.isRebuildNeeded()) {
+        log.info("Embedding dimensions: up to date");
+      }
+    } finally {
+      await backend.close();
+    }
+    return;
+  }
+  const { isDaemonRunning, getDaemonPaths } = await import(join(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");
+    return;
+  }
+  const { DaemonClient } = await import(join(mcpDir, "dist/lib/daemon-client.js"));
+  const paths = getDaemonPaths();
+  const client = new DaemonClient(paths.socketPath);
+  log.step("Rebuilding search index via daemon...");
+  try {
+    await client.rebuild();
+    log.success("Index rebuilt.");
+  } catch {
+    log.error("Rebuild failed or not supported.");
+  }
+}
+async function memoryInitCommand() {
+  const memoryDir = getMemoryDir();
+  const mcpDir = getLibPath("cf-memory");
+  ensureBuilt(mcpDir);
+  log.step("Initializing Tier 1 (SQLite + Hybrid Search)...");
+  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 dependencies.");
+      log.dim(
+        "Ensure you have a C++ compiler installed (Xcode CLT on macOS, build-essential on Linux)."
+      );
+      process.exit(1);
+    }
+    log.success("Dependencies installed.");
+  }
+  if (!existsSync(memoryDir)) {
+    log.info("No memory directory found. Nothing to import.");
+    log.success(
+      "Tier 1 is ready. Memories will be indexed as they're created."
+    );
+    return;
+  }
+  const docCount = countMdFiles(memoryDir);
+  if (docCount === 0) {
+    log.info("No existing memories to import.");
+    log.success(
+      "Tier 1 is ready. Memories will be indexed as they're created."
+    );
+    return;
+  }
+  log.step(`Importing ${docCount} existing memories into SQLite...`);
+  const { SqliteBackend } = await import(join(mcpDir, "dist/backends/sqlite/index.js"));
+  const config = loadConfig();
+  const embedding = config.memory?.embedding;
+  const backend = new SqliteBackend(memoryDir, {
+    skipVec: false,
+    ...embedding && { embedding }
+  });
+  try {
+    await backend.rebuild();
+    const stats = await backend.stats();
+    log.success(`Imported ${stats.total} memories. DB: ${backend.getDbPath()}`);
+    if (backend.isVecEnabled()) {
+      log.info(`Vector search: ${chalk.green("enabled")}`);
+    } else {
+      log.info(
+        `Vector search: ${chalk.dim("disabled")} (sqlite-vec not available)`
+      );
+    }
+  } finally {
+    await backend.close();
+  }
+  log.success('Tier 1 initialized. Run "cf memory status" to verify.');
+  log.info(
+    `Tip: Run ${chalk.cyan("/cf-scan")} in Claude Code to populate memory with project knowledge.`
+  );
+}
+function getProjectsBaseDir() {
+  const home = homedir();
+  return join(home, ".coding-friend", "memory", "projects");
+}
+function formatSize(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  if (bytes < 1024 * 1024 * 1024)
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+  return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
+}
+function formatDate(raw) {
+  const d = new Date(raw);
+  if (isNaN(d.getTime())) return raw;
+  return d.toISOString().slice(0, 16).replace("T", " ");
+}
+function dirSize(dir) {
+  let total = 0;
+  if (!existsSync(dir)) return 0;
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const p = join(dir, entry.name);
+    if (entry.isFile()) {
+      total += statSync(p).size;
+    } else if (entry.isDirectory()) {
+      total += dirSize(p);
+    }
+  }
+  return total;
+}
+function getProjectInfo(projectDir, projectId, mcpDir, knownSourceDir) {
+  const dbPath = join(projectDir, "db.sqlite");
+  const size = dirSize(projectDir);
+  const info = {
+    id: projectId,
+    sourceDir: null,
+    memories: 0,
+    size,
+    lastUpdated: null
+  };
+  if (!existsSync(dbPath)) return info;
+  try {
+    const backfillDir = knownSourceDir ? JSON.stringify(knownSourceDir) : "null";
+    const result = run(
+      "node",
+      [
+        "-e",
+        `
+        const path = require("path");
+        const mod = require(path.join(${JSON.stringify(mcpDir)}, "dist/lib/lazy-install.js"));
+        if (!mod.areSqliteDepsAvailable()) { console.log(JSON.stringify({})); process.exit(0); }
+        const Database = require(mod.getDepsDir() + "/node_modules/better-sqlite3");
+        const backfill = ${backfillDir};
+        const db = new Database(${JSON.stringify(dbPath)}, { readonly: !backfill });
+        const getMeta = (key) => { try { const r = db.prepare("SELECT value FROM metadata WHERE key = ?").get(key); return r?.value ?? null; } catch { return null; } };
+        let sourceDir = getMeta("source_dir");
+        if (!sourceDir && backfill) {
+          try { db.prepare("INSERT OR REPLACE INTO metadata (key, value) VALUES (?, ?)").run("source_dir", backfill); sourceDir = backfill; } catch {}
+        }
+        const count = (() => { try { const r = db.prepare("SELECT COUNT(*) as c FROM memories").get(); return r?.c ?? 0; } catch { return 0; } })();
+        const lastUpdated = (() => { try { const r = db.prepare("SELECT updated FROM memories ORDER BY updated DESC LIMIT 1").get(); return r?.updated ?? null; } catch { return null; } })();
+        console.log(JSON.stringify({ sourceDir, memories: count, lastUpdated }));
+        db.close();
+        `
+      ],
+      { cwd: projectDir }
+    );
+    if (result) {
+      const parsed = JSON.parse(result.trim());
+      info.sourceDir = parsed.sourceDir ?? null;
+      info.memories = parsed.memories ?? 0;
+      info.lastUpdated = parsed.lastUpdated ?? null;
+    }
+  } catch {
+  }
+  return info;
+}
+async function memoryListProjectsCommand() {
+  const baseDir = getProjectsBaseDir();
+  const mcpDir = getLibPath("cf-memory");
+  ensureBuilt(mcpDir);
+  if (!existsSync(baseDir)) {
+    log.info("No memory projects found.");
+    log.dim('Run "cf memory init" in a project to create one.');
+    return;
+  }
+  const dirs = readdirSync(baseDir, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith(".")).map((d) => d.name);
+  if (dirs.length === 0) {
+    log.info("No memory projects found.");
+    return;
+  }
+  const currentMemoryDir = resolve(getMemoryDir());
+  const currentHash = createHash("sha256").update(currentMemoryDir).digest("hex").slice(0, 12);
+  log.step(`Scanning ${dirs.length} project(s)...
+`);
+  const projects = [];
+  for (const id of dirs) {
+    const knownDir = id === currentHash ? currentMemoryDir : void 0;
+    projects.push(getProjectInfo(join(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)));
+  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)");
+    console.log(
+      `${idx}  ${sizeStr}  ${memCount}  ${idStr}  ${dateStr}  ${pathStr}`
+    );
+  });
+  console.log();
+  console.log(
+    chalk.bold(
+      `Total: ${projects.length} project(s), ${formatSize(totalSize)}`
+    )
+  );
+  console.log();
+}
+async function memoryRmCommand(opts) {
+  const baseDir = getProjectsBaseDir();
+  if (!existsSync(baseDir)) {
+    log.info("No memory projects found. Nothing to remove.");
+    return;
+  }
+  if (opts.prune) {
+    const mcpDir = getLibPath("cf-memory");
+    ensureBuilt(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) {
+      const projectDir = join(baseDir, id);
+      const info = getProjectInfo(projectDir, id, mcpDir);
+      if (info.sourceDir && !existsSync(info.sourceDir)) {
+        orphaned.push({
+          id,
+          reason: `source dir missing: ${info.sourceDir}`,
+          size: info.size
+        });
+      } else if (info.memories === 0) {
+        orphaned.push({
+          id,
+          reason: info.sourceDir ? `0 memories (${info.sourceDir})` : "unknown path, 0 memories",
+          size: info.size
+        });
+      }
+    }
+    if (orphaned.length === 0) {
+      log.success("No orphaned projects found.");
+      return;
+    }
+    const totalSize = orphaned.reduce((sum, o) => sum + o.size, 0);
+    log.warn(
+      `Found ${orphaned.length} orphaned project(s) (${formatSize(totalSize)}):`
+    );
+    console.log();
+    for (const o of orphaned) {
+      console.log(`  ${chalk.cyan(o.id)}  ${chalk.dim(o.reason)}`);
+    }
+    console.log();
+    const ok = await confirm({
+      message: `Delete ${orphaned.length} orphaned project(s)?`,
+      default: false
+    });
+    if (!ok) {
+      log.info("Cancelled.");
+      return;
+    }
+    for (const o of orphaned) {
+      rmSync(join(baseDir, o.id), { recursive: true, force: true });
+    }
+    log.success(
+      `Deleted ${orphaned.length} orphaned project(s) (${formatSize(totalSize)}).`
+    );
+    return;
+  }
+  if (opts.all) {
+    const dirs = readdirSync(baseDir, { withFileTypes: true }).filter(
+      (d) => d.isDirectory() && !d.name.startsWith(".")
+    );
+    if (dirs.length === 0) {
+      log.info("No memory projects found. Nothing to remove.");
+      return;
+    }
+    const totalSize = dirs.reduce(
+      (sum, d) => sum + dirSize(join(baseDir, d.name)),
+      0
+    );
+    log.warn(
+      `This will delete ALL ${dirs.length} project database(s) (${formatSize(totalSize)}).`
+    );
+    log.warn("Markdown source files in docs/memory/ will NOT be affected.");
+    console.log();
+    const ok = await confirm({
+      message: "Are you sure you want to delete all memory databases?",
+      default: false
+    });
+    if (!ok) {
+      log.info("Cancelled.");
+      return;
+    }
+    for (const d of dirs) {
+      rmSync(join(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 resolved = resolve(projectDir);
+    if (!resolved.startsWith(resolve(baseDir) + sep)) {
+      log.error("Invalid project ID.");
+      process.exit(1);
+    }
+    if (!existsSync(projectDir)) {
+      log.error(`Project "${opts.projectId}" not found.`);
+      log.dim('Run "cf memory list --projects" to see available projects.');
+      process.exit(1);
+    }
+    const size = dirSize(projectDir);
+    log.warn(
+      `This will delete project "${opts.projectId}" (${formatSize(size)}).`
+    );
+    log.warn("Markdown source files in docs/memory/ will NOT be affected.");
+    console.log();
+    const ok = await confirm({
+      message: `Delete project ${opts.projectId}?`,
+      default: false
+    });
+    if (!ok) {
+      log.info("Cancelled.");
+      return;
+    }
+    rmSync(projectDir, { recursive: true, force: true });
+    log.success(`Deleted project "${opts.projectId}".`);
+    return;
+  }
+  log.error("Specify --project-id <id>, --all, or --prune.");
+  log.dim('Run "cf memory list --projects" to see available projects.');
+  process.exit(1);
+}
+async function memoryMcpCommand() {
+  const memoryDir = getMemoryDir();
+  const mcpDir = getLibPath("cf-memory");
+  ensureBuilt(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}"]
+    }
+  }
+}
+
+--- 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 {
+  memoryInitCommand,
+  memoryListCommand,
+  memoryMcpCommand,
+  memoryRebuildCommand,
+  memoryRmCommand,
+  memorySearchCommand,
+  memoryStartCommand,
+  memoryStatusCommand,
+  memoryStopCommand
+};

package/dist/postinstall.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   ensureShellCompletion
-} from "./chunk-KJUGTLPQ.js";
+} from "./chunk-YO6JKGR3.js";
 import "./chunk-W5CD7WTX.js";
 
 // src/postinstall.ts

package/dist/{session-E3CZJJZQ.js → session-H4XW2WXH.js}

@@ -1,6 +1,6 @@
 import {
   loadConfig
-} from "./chunk-4DB4XTSL.js";
+} from "./chunk-KTX4MGMR.js";
 import "./chunk-POC2WHU2.js";
 import {
   claudeSessionDir,

package/dist/{statusline-6HQCDWBD.js → statusline-6Y2EBAFQ.js}

@@ -10,7 +10,7 @@ import {
 } from "./chunk-POC2WHU2.js";
 import {
   commandExists
-} from "./chunk-X5WEODUD.js";
+} from "./chunk-CYQU33FY.js";
 import "./chunk-RWUTFVRB.js";
 import {
   log

package/dist/{uninstall-JN5YIKKM.js → uninstall-3PSUDGI4.js}

@@ -5,14 +5,14 @@ import {
 import {
   hasShellCompletion,
   removeShellCompletion
-} from "./chunk-KJUGTLPQ.js";
+} from "./chunk-YO6JKGR3.js";
 import {
   resolveScope
-} from "./chunk-D4EWPGBL.js";
+} from "./chunk-C5LYVVEI.js";
 import {
   commandExists,
   run
-} from "./chunk-X5WEODUD.js";
+} from "./chunk-CYQU33FY.js";
 import {
   claudeSettingsPath,
   devStatePath,