@bennys001/claude-code-memory 0.11.1 → 0.12.3

package/README.md

@@ -7,19 +7,37 @@ MCP server that gives Claude Code persistent memory via an Obsidian-compatible k
 Requires [Bun](https://bun.sh/) and [Claude Code](https://docs.anthropic.com/en/docs/claude-code).
 
 ```bash
-bunx @bennys001/claude-code-memory --init
+bun install -g @bennys001/claude-code-memory && ccm --init
 ```
 
-This scaffolds the vault at `~/.ccm/knowledge-base/`, registers it with Obsidian (if installed), and adds the MCP server to Claude Code.
+This installs the `ccm` binary globally, scaffolds the vault at `~/.ccm/knowledge-base/`, registers it with Obsidian (if installed), and adds the MCP server to Claude Code.
 
-### Manual setup
+### Update
+
+```bash
+ccm --update
+```
+
+### Uninstall
+
+```bash
+ccm --uninstall
+```
+
+Removes the MCP server registration, Obsidian vault registration, and the global binary. Prompts before deleting the vault.
+
+### Manual MCP setup
 
 If `--init` can't reach the `claude` CLI, register manually:
 
 ```bash
-claude mcp add --transport stdio --scope user ccm -- bunx @bennys001/claude-code-memory --stdio
+claude mcp add --transport stdio --scope user ccm -- ccm --stdio
 ```
 
+## Real-Time Sync
+
+The server watches the vault directory for changes while running. Edits made outside Claude — in Obsidian or your editor — are picked up automatically. New and modified `.md` files are re-parsed, deleted files are removed from the index, and new subdirectories are watched on creation. No restart required.
+
 ## MCP Tools
 
 ### `research`
@@ -63,6 +81,10 @@ Generates/updates a `## Knowledge Index` section in a project's `CLAUDE.md`. Inj
 |-------------|--------|----------|-------------------------------------|
 | `targetDir` | string | No       | Project directory (defaults to CWD) |
 
+### `diagnostics`
+
+Live runtime diagnostics — vault stats (entry counts by type, total tokens), file watcher activity (flushes, upserts, removes), process metrics (uptime, RSS, heap), and server version. No parameters.
+
 ### `fetch-page`
 
 Fetches a web page, extracts main content via Readability, converts to markdown. Returns a temp file path — read it, then `write` to vault.

package/dist/index.js

@@ -4,7 +4,7 @@
 var package_default = {
   name: "@bennys001/claude-code-memory",
   publishConfig: { access: "public" },
-  version: "0.11.1",
+  version: "0.12.3",
   description: "MCP server that gives Claude Code persistent memory via an Obsidian knowledge vault",
   module: "dist/index.js",
   main: "dist/index.js",
@@ -57,7 +57,7 @@ var package_default = {
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { homedir as homedir4 } from "os";
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 
 // src/vault/loader.ts
 import { globby } from "globby";
@@ -167,6 +167,127 @@ function filterEntries(entries, config) {
   });
 }
 
+// src/vault/watcher.ts
+import { watch, readdirSync } from "fs";
+import { resolve, relative as relative2, join } from "path";
+var {Glob } = globalThis.Bun;
+function sortEntries(entries) {
+  entries.sort((a, b) => NOTE_TYPE_PRIORITY[a.frontmatter.type] - NOTE_TYPE_PRIORITY[b.frontmatter.type]);
+}
+function removeEntry(entries, filePath) {
+  const idx = entries.findIndex((e) => e.filePath === filePath);
+  if (idx === -1)
+    return false;
+  entries.splice(idx, 1);
+  return true;
+}
+async function upsertEntry(entries, filePath, vaultPath) {
+  removeEntry(entries, filePath);
+  const entry = await parseNote(filePath, vaultPath);
+  if (entry) {
+    entries.push(entry);
+    sortEntries(entries);
+  }
+}
+function watchVault(vaultPath, entries) {
+  const watchers = new Map;
+  const pending = new Set;
+  let timer = null;
+  const stats = { activeWatchers: 0, totalFlushes: 0, totalUpserts: 0, totalRemoves: 0 };
+  const flush = async () => {
+    stats.totalFlushes++;
+    const paths = [...pending];
+    pending.clear();
+    for (const rel of paths) {
+      const abs = resolve(vaultPath, rel);
+      const exists = await Bun.file(abs).exists();
+      if (exists) {
+        await upsertEntry(entries, abs, vaultPath);
+        stats.totalUpserts++;
+        console.error(`[watcher] upserted ${rel}`);
+      } else {
+        const removed = removeEntry(entries, abs);
+        if (removed) {
+          stats.totalRemoves++;
+          console.error(`[watcher] removed ${rel}`);
+        }
+      }
+    }
+  };
+  const schedule = () => {
+    if (timer)
+      clearTimeout(timer);
+    timer = setTimeout(flush, 300);
+  };
+  const removeDirWatcher = (dirPath) => {
+    const w = watchers.get(dirPath);
+    if (w) {
+      w.close();
+      watchers.delete(dirPath);
+      stats.activeWatchers--;
+    }
+  };
+  const addDirWatcher = (dirPath) => {
+    if (watchers.has(dirPath))
+      return;
+    try {
+      const w = watch(dirPath, (event, filename) => {
+        if (!filename)
+          return;
+        const abs = join(dirPath, filename);
+        const rel = relative2(vaultPath, abs);
+        if (rel.split("/").some((seg) => seg.startsWith(".")))
+          return;
+        if (filename.endsWith(".md")) {
+          pending.add(rel);
+          schedule();
+          return;
+        }
+        if (event === "rename") {
+          try {
+            readdirSync(abs);
+            addDirWatcher(abs);
+            const glob = new Glob("**/*.md");
+            for (const match of glob.scanSync({ cwd: abs })) {
+              const mdRel = relative2(vaultPath, join(abs, match));
+              if (!mdRel.split("/").some((seg) => seg.startsWith("."))) {
+                pending.add(mdRel);
+              }
+            }
+            schedule();
+          } catch {
+            removeDirWatcher(abs);
+          }
+        }
+      });
+      watchers.set(dirPath, w);
+      stats.activeWatchers++;
+    } catch (err) {
+      console.error(`[watcher] failed to watch ${dirPath}: ${err}`);
+    }
+  };
+  const walkAndWatch = (dirPath) => {
+    addDirWatcher(dirPath);
+    try {
+      for (const entry of readdirSync(dirPath, { withFileTypes: true })) {
+        if (entry.isDirectory() && !entry.name.startsWith(".")) {
+          walkAndWatch(join(dirPath, entry.name));
+        }
+      }
+    } catch {}
+  };
+  walkAndWatch(vaultPath);
+  const stop = () => {
+    if (timer)
+      clearTimeout(timer);
+    for (const w of watchers.values())
+      w.close();
+    watchers.clear();
+    stats.activeWatchers = 0;
+  };
+  return { stop, stats };
+}
+
 // src/tools/index-tool.ts
 import { z as z2 } from "zod";
 
@@ -226,6 +347,62 @@ function injectKnowledgeSection(existingContent, entries) {
 `;
 }
 
+// src/update-checker.ts
+var NPM_URL = "https://registry.npmjs.org/@bennys001/claude-code-memory/latest";
+var CHANGELOG_URL = "https://raw.githubusercontent.com/Ben-Spn/claude-code-memory/master/CHANGELOG.md";
+var latestVersion = null;
+var releaseNotes = [];
+async function fetchLatestVersion() {
+  const res = await fetch(NPM_URL);
+  if (!res.ok)
+    throw new Error(`npm registry returned ${res.status}`);
+  const data = await res.json();
+  return data.version;
+}
+function parseChangelog(markdown, version) {
+  const heading = `## ${version}`;
+  const start = markdown.indexOf(heading);
+  if (start === -1)
+    return [];
+  const afterHeading = start + heading.length;
+  const nextSection = markdown.indexOf(`
+## `, afterHeading);
+  const section = nextSection === -1 ? markdown.substring(afterHeading) : markdown.substring(afterHeading, nextSection);
+  return section.split(`
+`).filter((l) => l.startsWith("- ")).map((l) => l.slice(2).trim());
+}
+async function fetchReleaseNotes(version) {
+  const res = await fetch(CHANGELOG_URL);
+  if (!res.ok)
+    return [];
+  const markdown = await res.text();
+  return parseChangelog(markdown, version);
+}
+function initUpdateCheck() {
+  fetchLatestVersion().then(async (v) => {
+    latestVersion = v;
+    if (v !== package_default.version) {
+      releaseNotes = await fetchReleaseNotes(v);
+    }
+  }).catch(() => {});
+}
+function getUpdateNotice() {
+  if (!latestVersion || latestVersion === package_default.version)
+    return "";
+  const lines = [`
+
+---
+Update available: v${package_default.version} \u2192 v${latestVersion}`];
+  if (releaseNotes.length > 0) {
+    lines.push("What's new:");
+    for (const note of releaseNotes)
+      lines.push(`  - ${note}`);
+  }
+  lines.push("Run `ccm --update` to upgrade");
+  return lines.join(`
+`);
+}
+
 // src/tools/index-tool.ts
 function executeIndex(args, entries) {
   let filtered = entries;
@@ -242,19 +419,19 @@ function registerIndexTool(server, entries) {
     })
   }, async (args) => {
     const result = executeIndex(args, entries);
-    return { content: [{ type: "text", text: result }] };
+    return { content: [{ type: "text", text: result + getUpdateNotice() }] };
   });
 }
 
 // src/tools/read-tool.ts
-import { resolve, relative as relative2 } from "path";
+import { resolve as resolve2, relative as relative3 } from "path";
 import { z as z3 } from "zod";
 async function executeRead(notePath, vaultPath) {
   if (notePath.startsWith("/")) {
     return { ok: false, error: "Absolute paths not allowed. Use paths relative to vault root." };
   }
-  const resolved = resolve(vaultPath, notePath);
-  const rel = relative2(vaultPath, resolved);
+  const resolved = resolve2(vaultPath, notePath);
+  const rel = relative3(vaultPath, resolved);
   if (rel.startsWith("..")) {
     return { ok: false, error: "Path resolves outside vault. Use paths relative to vault root." };
   }
@@ -273,7 +450,7 @@ function registerReadTool(server, vaultPath) {
   }, async ({ path }) => {
     const result = await executeRead(path, vaultPath);
     if (result.ok) {
-      return { content: [{ type: "text", text: result.content }] };
+      return { content: [{ type: "text", text: result.content + getUpdateNotice() }] };
     }
     return { content: [{ type: "text", text: result.error }], isError: true };
   });
@@ -331,7 +508,7 @@ function registerSearchTool(server, entries) {
   }, async (args) => {
     const results = executeSearch(args, entries);
     if (results.length === 0) {
-      return { content: [{ type: "text", text: "No notes match that query." }] };
+      return { content: [{ type: "text", text: "No notes match that query." + getUpdateNotice() }] };
     }
     const table = [
       "| T | Title | Path | ~Tok | Score |",
@@ -339,19 +516,19 @@ function registerSearchTool(server, entries) {
       ...results.map((r) => `| ${r.icon} | ${r.title} | ${r.relativePath} | ${r.tokenDisplay} | ${r.score} |`)
     ].join(`
 `);
-    return { content: [{ type: "text", text: table }] };
+    return { content: [{ type: "text", text: table + getUpdateNotice() }] };
   });
 }
 
 // src/tools/sync-tool.ts
 import { z as z5 } from "zod";
-import { join as join3, resolve as resolve2 } from "path";
+import { join as join4, resolve as resolve3 } from "path";
 import { homedir } from "os";
 
 // src/vault/config.ts
 import { parse, stringify } from "smol-toml";
-import { join as join2, basename as basename2, extname } from "path";
-var {Glob } = globalThis.Bun;
+import { join as join3, basename as basename2, extname } from "path";
+var {Glob: Glob2 } = globalThis.Bun;
 var EXT_TO_TAGS = {
   rs: ["rust"],
   ts: ["typescript"],
@@ -382,7 +559,7 @@ var EXT_TO_TAGS = {
 };
 var IGNORE_DIRS = ["node_modules", ".*", "target", "dist", "build"];
 async function loadProjectConfig(dir) {
-  const configPath = join2(dir, ".context.toml");
+  const configPath = join3(dir, ".context.toml");
   const file = Bun.file(configPath);
   if (!await file.exists())
     return null;
@@ -410,7 +587,7 @@ function collectVaultTags(entries) {
   return tags;
 }
 async function detectTagsFromExtensions(dir, vaultTags) {
-  const glob = new Glob(`**/*.*`);
+  const glob = new Glob2(`**/*.*`);
   const extensions = new Set;
   for await (const path of glob.scan({ cwd: dir, dot: false, followSymlinks: false })) {
     const skip = IGNORE_DIRS.some((d) => d.startsWith(".") ? path.startsWith(".") : path.startsWith(d + "/"));
@@ -439,7 +616,7 @@ async function createDefaultConfig(dir, allEntries) {
       config.filter = { tags: inferred };
     }
   }
-  const configPath = join2(dir, ".context.toml");
+  const configPath = join3(dir, ".context.toml");
   await Bun.write(configPath, stringify(config) + `
 `);
   return config;
@@ -555,8 +732,8 @@ async function syncToFile(claudeMdPath, filtered) {
 async function executeSync(targetDir, allEntries, vaultPath, options = {}) {
   let config = await loadProjectConfig(targetDir);
   let autoCreated = false;
-  const globalClaudeDir = options.globalClaudeDir ?? resolve2(homedir(), ".claude");
-  const isGlobalDir = resolve2(targetDir) === resolve2(globalClaudeDir);
+  const globalClaudeDir = options.globalClaudeDir ?? resolve3(homedir(), ".claude");
+  const isGlobalDir = resolve3(targetDir) === resolve3(globalClaudeDir);
   if (!config && !isGlobalDir) {
     config = await createDefaultConfig(targetDir, allEntries);
     autoCreated = true;
@@ -570,7 +747,7 @@ async function executeSync(targetDir, allEntries, vaultPath, options = {}) {
   } else {
     filtered = filtered.filter((e) => e.frontmatter.projects.length === 0 && !hasTechTag(e));
   }
-  const { entryCount, totalTokens, changed } = await syncToFile(join3(targetDir, "CLAUDE.md"), filtered);
+  const { entryCount, totalTokens, changed } = await syncToFile(join4(targetDir, "CLAUDE.md"), filtered);
   let summary = changed ? `Synced ${entryCount} entries to CLAUDE.md (${formatTokenCount(totalTokens)} total index tokens)` : `CLAUDE.md already up to date (${entryCount} entries, ${formatTokenCount(totalTokens)} total index tokens)`;
   if (autoCreated) {
     const allTags = [...new Set(allEntries.flatMap((e) => e.frontmatter.tags))].sort();
@@ -589,7 +766,7 @@ Available vault tags: [${allTags.join(", ")}] \u2014 edit .context.toml filter.t
   }
   if (!isGlobalDir) {
     const globalEntries = allEntries.filter((e) => e.frontmatter.projects.length === 0 && !hasTechTag(e));
-    const globalResult = await syncToFile(join3(globalClaudeDir, "CLAUDE.md"), globalEntries);
+    const globalResult = await syncToFile(join4(globalClaudeDir, "CLAUDE.md"), globalEntries);
     summary += globalResult.changed ? `
 Synced ${globalResult.entryCount} global entries to ~/.claude/CLAUDE.md (${formatTokenCount(globalResult.totalTokens)} total index tokens)` : `
 ~/.claude/CLAUDE.md already up to date (${globalResult.entryCount} entries, ${formatTokenCount(globalResult.totalTokens)} total index tokens)`;
@@ -609,12 +786,12 @@ function registerSyncTool(server, entries, vaultPath) {
   }, async ({ targetDir }) => {
     const dir = targetDir ?? process.cwd();
     const result = await executeSync(dir, entries, vaultPath);
-    return { content: [{ type: "text", text: result.summary }] };
+    return { content: [{ type: "text", text: result.summary + getUpdateNotice() }] };
   });
 }
 
 // src/tools/write-tool.ts
-import { resolve as resolve3, relative as relative3, dirname } from "path";
+import { resolve as resolve4, relative as relative4, dirname } from "path";
 import { mkdir } from "fs/promises";
 import { z as z6 } from "zod";
 
@@ -645,7 +822,7 @@ function buildFrontmatter(args) {
     for (const t of args.tags)
       lines.push(`  - ${t}`);
   }
-  lines.push(`created: ${args.date}`, `updated: ${args.date}`, "---");
+  lines.push(`created: ${args.created}`, `updated: ${args.updated}`, "---");
   return lines.join(`
 `);
 }
@@ -653,20 +830,33 @@ async function executeWrite(args, entries, vaultPath) {
   if (args.path.startsWith("/")) {
     return { ok: false, error: "Absolute paths not allowed. Use paths relative to vault root." };
   }
-  const resolved = resolve3(vaultPath, args.path);
-  const rel = relative3(vaultPath, resolved);
+  const resolved = resolve4(vaultPath, args.path);
+  const rel = relative4(vaultPath, resolved);
   if (rel.startsWith("..")) {
     return { ok: false, error: "Path resolves outside vault. Use paths relative to vault root." };
   }
-  if (await Bun.file(resolved).exists()) {
-    return { ok: false, error: `File already exists: ${args.path}. Use a different path.` };
+  const fileExists = await Bun.file(resolved).exists();
+  if (fileExists && !args.overwrite) {
+    return { ok: false, error: `File already exists: ${args.path}. Pass overwrite: true to replace it.` };
   }
   const today = formatDate(new Date);
+  let createdDate = today;
+  if (fileExists) {
+    const existing = entries.find((e) => e.filePath === resolved);
+    if (existing) {
+      createdDate = formatDate(existing.frontmatter.created);
+    } else {
+      const parsed = await parseNote(resolved, vaultPath);
+      if (parsed)
+        createdDate = formatDate(parsed.frontmatter.created);
+    }
+  }
   const frontmatter = buildFrontmatter({
     type: args.type,
     tags: args.tags,
     projects: args.projects,
-    date: today
+    created: createdDate,
+    updated: today
   });
   const content = `${frontmatter}
 
@@ -678,33 +868,38 @@ ${args.body}
   await Bun.write(resolved, content);
   const entry = await parseNote(resolved, vaultPath);
   if (entry) {
+    const idx = entries.findIndex((e) => e.filePath === resolved);
+    if (idx !== -1)
+      entries.splice(idx, 1);
     entries.push(entry);
     entries.sort((a, b) => NOTE_TYPE_PRIORITY[a.frontmatter.type] - NOTE_TYPE_PRIORITY[b.frontmatter.type]);
   }
-  return { ok: true, path: rel };
+  return { ok: true, path: rel, updated: fileExists && !!args.overwrite };
 }
 function registerWriteTool(server, entries, vaultPath) {
   server.registerTool("write", {
-    description: "Create a new note in the vault with structured frontmatter. " + "Rejects writes to existing paths. " + "To write a web page to the vault, first use the fetch-page tool.",
+    description: "Create or update a note in the vault with structured frontmatter. " + "Rejects writes to existing paths unless overwrite is true. " + "To write a web page to the vault, first use the fetch-page tool.",
     inputSchema: z6.object({
       path: z6.string().describe("Relative path within vault (e.g. gotchas/my-new-note.md)"),
       type: NoteType.describe("Note type"),
       title: z6.string().describe("Note title (becomes the H1 heading)"),
       body: z6.string().describe("Markdown body content (after the H1)"),
       tags: z6.array(z6.string()).optional().describe("Searchable tags"),
-      projects: z6.array(z6.string()).optional().describe("Project names this note relates to")
+      projects: z6.array(z6.string()).optional().describe("Project names this note relates to"),
+      overwrite: z6.boolean().optional().describe("Set to true to overwrite an existing note")
     })
   }, async (args) => {
     const result = await executeWrite(args, entries, vaultPath);
     if (result.ok) {
-      return { content: [{ type: "text", text: `Created note: ${result.path}` }] };
+      const verb = result.updated ? "Updated" : "Created";
+      return { content: [{ type: "text", text: `${verb} note: ${result.path}` + getUpdateNotice() }] };
     }
     return { content: [{ type: "text", text: result.error }], isError: true };
   });
 }
 
 // src/tools/fetch-page-tool.ts
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 import { mkdtemp, writeFile } from "fs/promises";
 import { tmpdir } from "os";
 import { z as z7 } from "zod";
@@ -769,8 +964,8 @@ async function executeFetchPage(url, fetcher = fetchPageAsMarkdown) {
     const msg = err instanceof Error ? err.message : String(err);
     return { ok: false, error: `Failed to fetch URL: ${msg}` };
   }
-  const tempDir = await mkdtemp(join4(tmpdir(), "ccm-fetch-"));
-  const tempPath = join4(tempDir, "page.md");
+  const tempDir = await mkdtemp(join5(tmpdir(), "ccm-fetch-"));
+  const tempPath = join5(tempDir, "page.md");
   await writeFile(tempPath, page.markdown);
   return {
     ok: true,
@@ -798,7 +993,7 @@ function registerFetchPageTool(server) {
       if (result.siteName)
         parts.push(`Site: ${result.siteName}`);
       return { content: [{ type: "text", text: parts.join(`
-`) }] };
+`) + getUpdateNotice() }] };
     }
     return { content: [{ type: "text", text: result.error }], isError: true };
   });
@@ -860,9 +1055,59 @@ function registerResearchTool(server, entries, vaultPath) {
   }, async (args) => {
     const result = await executeResearch(args, entries, vaultPath);
     if (result.notes.length === 0) {
-      return { content: [{ type: "text", text: "No notes match that query." }] };
+      return { content: [{ type: "text", text: "No notes match that query." + getUpdateNotice() }] };
     }
-    return { content: [{ type: "text", text: buildResearchOutput(result) }] };
+    return { content: [{ type: "text", text: buildResearchOutput(result) + getUpdateNotice() }] };
+  });
+}
+
+// src/tools/diagnostics-tool.ts
+function formatUptime(seconds) {
+  const h = Math.floor(seconds / 3600);
+  const m = Math.floor(seconds % 3600 / 60);
+  const s = Math.floor(seconds % 60);
+  return `${h}h ${m}m ${s}s`;
+}
+function formatMB(bytes) {
+  return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+}
+function executeDiagnostics(entries, watcherStats) {
+  const typeCounts = { gotchas: 0, decisions: 0, patterns: 0, references: 0 };
+  let totalTokens = 0;
+  for (const entry of entries) {
+    typeCounts[entry.frontmatter.type]++;
+    totalTokens += entry.tokenCount;
+  }
+  const mem = process.memoryUsage();
+  const lines = [
+    `${C.bold}Vault${C.reset}`,
+    `  Entries:  ${entries.length}`,
+    `  Gotchas: ${typeCounts.gotchas}  Decisions: ${typeCounts.decisions}  Patterns: ${typeCounts.patterns}  References: ${typeCounts.references}`,
+    `  Tokens:   ${totalTokens}`,
+    "",
+    `${C.bold}Watcher${C.reset}`,
+    `  Active:   ${watcherStats.activeWatchers}`,
+    `  Flushes:  ${watcherStats.totalFlushes}`,
+    `  Upserts:  ${watcherStats.totalUpserts}`,
+    `  Removes:  ${watcherStats.totalRemoves}`,
+    "",
+    `${C.bold}Process${C.reset}`,
+    `  Uptime:   ${formatUptime(process.uptime())}`,
+    `  RSS:      ${formatMB(mem.rss)}`,
+    `  Heap:     ${formatMB(mem.heapUsed)} / ${formatMB(mem.heapTotal)}`,
+    "",
+    `${C.bold}Server${C.reset}`,
+    `  Version:  ${package_default.version}`
+  ];
+  return lines.join(`
+`);
+}
+function registerDiagnosticsTool(server, entries, watcherStats) {
+  server.registerTool("diagnostics", {
+    description: "Show live runtime diagnostics: vault stats, watcher activity, process metrics, and server version"
+  }, async () => {
+    const result = executeDiagnostics(entries, watcherStats);
+    return { content: [{ type: "text", text: result + getUpdateNotice() }] };
   });
 }
 
@@ -870,39 +1115,39 @@ function registerResearchTool(server, entries, vaultPath) {
 import { spawn } from "child_process";
 var SERVER_CMD = ["ccm", "--stdio"];
 function installGlobal() {
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     let stderr = "";
     const proc = spawn("bun", ["install", "-g", "@bennys001/claude-code-memory"], { stdio: ["ignore", "ignore", "pipe"] });
     proc.stderr.on("data", (data) => {
       stderr += data.toString();
     });
     proc.on("error", (err) => {
-      resolve4({ success: false, error: err.message });
+      resolve5({ success: false, error: err.message });
     });
     proc.on("close", (code) => {
       if (code === 0) {
-        resolve4({ success: true });
+        resolve5({ success: true });
       } else {
-        resolve4({ success: false, error: stderr.trim() || `bun install exited with code ${code}` });
+        resolve5({ success: false, error: stderr.trim() || `bun install exited with code ${code}` });
       }
     });
   });
 }
 function uninstallGlobal() {
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     let stderr = "";
     const proc = spawn("bun", ["remove", "-g", "@bennys001/claude-code-memory"], { stdio: ["ignore", "ignore", "pipe"] });
     proc.stderr.on("data", (data) => {
       stderr += data.toString();
     });
     proc.on("error", (err) => {
-      resolve4({ success: false, error: err.message });
+      resolve5({ success: false, error: err.message });
     });
     proc.on("close", (code) => {
       if (code === 0) {
-        resolve4({ success: true });
+        resolve5({ success: true });
       } else {
-        resolve4({ success: false, error: stderr.trim() || `bun remove exited with code ${code}` });
+        resolve5({ success: false, error: stderr.trim() || `bun remove exited with code ${code}` });
       }
     });
   });
@@ -920,15 +1165,15 @@ var REGISTER_ARGS = [
 ];
 var MANUAL_COMMAND = `claude mcp add --transport stdio --scope user ccm -- ${SERVER_CMD.join(" ")}`;
 function removeMcpServer() {
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     const proc = spawn("claude", ["mcp", "remove", "ccm"], { stdio: "ignore" });
-    proc.on("error", () => resolve4());
-    proc.on("close", () => resolve4());
+    proc.on("error", () => resolve5());
+    proc.on("close", () => resolve5());
   });
 }
 async function registerMcpServer() {
   await removeMcpServer();
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     let stdout = "";
     let stderr = "";
     const proc = spawn("claude", REGISTER_ARGS, { stdio: "pipe" });
@@ -940,13 +1185,13 @@ async function registerMcpServer() {
     });
     proc.on("error", (err) => {
       if (err.code === "ENOENT") {
-        resolve4({
+        resolve5({
           success: false,
           error: "Claude CLI not found in PATH",
           manualCommand: MANUAL_COMMAND
         });
       } else {
-        resolve4({
+        resolve5({
           success: false,
           error: err.message,
           manualCommand: MANUAL_COMMAND
@@ -955,9 +1200,9 @@ async function registerMcpServer() {
     });
     proc.on("close", (code) => {
       if (code === 0) {
-        resolve4({ success: true, output: (stdout || stderr).trim() });
+        resolve5({ success: true, output: (stdout || stderr).trim() });
       } else {
-        resolve4({
+        resolve5({
           success: false,
           error: (stderr || stdout).trim() || `Process exited with code ${code}`,
           manualCommand: MANUAL_COMMAND
@@ -969,7 +1214,7 @@ async function registerMcpServer() {
 
 // src/cli/init.ts
 import { mkdir as mkdir2 } from "fs/promises";
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 import { homedir as homedir3 } from "os";
 
 // src/cli/seed.ts
@@ -1087,10 +1332,10 @@ function buildSeedNotes(dateStr) {
 
 // src/cli/obsidian.ts
 import { readFile, writeFile as writeFile2, copyFile } from "fs/promises";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 import { randomBytes } from "crypto";
 import { homedir as homedir2 } from "os";
-var DEFAULT_CONFIG_PATH = join5(homedir2(), ".config/obsidian/obsidian.json");
+var DEFAULT_CONFIG_PATH = join6(homedir2(), ".config/obsidian/obsidian.json");
 function generateVaultId() {
   return randomBytes(8).toString("hex");
 }
@@ -1142,27 +1387,27 @@ async function unregisterVaultFromObsidian(vaultPath, configPath = DEFAULT_CONFI
 }
 
 // src/cli/init.ts
-var VAULT_PATH = join6(homedir3(), ".ccm", "knowledge-base");
+var VAULT_PATH = join7(homedir3(), ".ccm", "knowledge-base");
 var SUBDIRS = ["gotchas", "decisions", "patterns", "references", "_templates"];
 async function executeInit() {
   const steps = [];
   await mkdir2(VAULT_PATH, { recursive: true });
   steps.push({ name: "vault directory", status: "created", detail: VAULT_PATH });
   for (const sub of SUBDIRS) {
-    await mkdir2(join6(VAULT_PATH, sub), { recursive: true });
+    await mkdir2(join7(VAULT_PATH, sub), { recursive: true });
   }
   steps.push({ name: "subdirectories", status: "created", detail: SUBDIRS.join(", ") });
-  const dotObsidian = join6(VAULT_PATH, ".obsidian");
+  const dotObsidian = join7(VAULT_PATH, ".obsidian");
   await mkdir2(dotObsidian, { recursive: true });
   const dateStr = formatDate(new Date);
   const seedNotes = buildSeedNotes(dateStr);
   for (const note of seedNotes) {
-    const fullPath = join6(VAULT_PATH, note.relativePath);
+    const fullPath = join7(VAULT_PATH, note.relativePath);
     const file = Bun.file(fullPath);
     if (await file.exists()) {
       steps.push({ name: note.relativePath, status: "skipped", detail: "already exists" });
     } else {
-      await mkdir2(join6(VAULT_PATH, note.relativePath, ".."), { recursive: true });
+      await mkdir2(join7(VAULT_PATH, note.relativePath, ".."), { recursive: true });
       await Bun.write(fullPath, note.content);
       steps.push({ name: note.relativePath, status: "created", detail: "" });
     }
@@ -1232,7 +1477,7 @@ function formatInitSummary(result) {
 // src/index.ts
 import { rm } from "fs/promises";
 import { createInterface } from "readline";
-var VAULT_PATH2 = join7(homedir4(), ".ccm", "knowledge-base");
+var VAULT_PATH2 = join8(homedir4(), ".ccm", "knowledge-base");
 function parseCliArgs() {
   const args = process.argv.slice(2);
   if (args.includes("--version") || args.includes("-v"))
@@ -1249,7 +1494,24 @@ function parseCliArgs() {
     return "serve";
   return "help";
 }
-function printHelp() {
+async function printHelp() {
+  let updateLine = "";
+  try {
+    const latest = await fetchLatestVersion();
+    if (latest !== package_default.version) {
+      const notes = await fetchReleaseNotes(latest);
+      const parts = [`
+${C.yellow}Update available:${C.reset} v${package_default.version} \u2192 ${C.green}v${latest}${C.reset}`];
+      if (notes.length > 0) {
+        parts.push(`${C.bold}What's new:${C.reset}`);
+        for (const note of notes)
+          parts.push(`  ${C.dim}-${C.reset} ${note}`);
+      }
+      parts.push(`Run ${C.cyan}ccm --update${C.reset} to upgrade`);
+      updateLine = parts.join(`
+`);
+    }
+  } catch {}
   console.log(`${C.bold}claude-code-memory${C.reset} ${C.dim}(ccm)${C.reset} \u2014 Persistent memory for Claude Code
 
 ${C.bold}Usage:${C.reset}
@@ -1262,14 +1524,7 @@ ${C.bold}First-time install:${C.reset}
   ${C.cyan}bun install -g @bennys001/claude-code-memory && ccm --init${C.reset}
 
 ${C.dim}Vault:${C.reset} ~/.ccm/knowledge-base/
-${C.dim}Docs:${C.reset}  https://github.com/bennys001/claude-code-memory`);
-}
-async function fetchLatestVersion() {
-  const res = await fetch("https://registry.npmjs.org/@bennys001/claude-code-memory/latest");
-  if (!res.ok)
-    throw new Error(`npm registry returned ${res.status}`);
-  const data = await res.json();
-  return data.version;
+${C.dim}Docs:${C.reset}  https://github.com/bennys001/claude-code-memory${updateLine}`);
 }
 async function runUpdate() {
   console.log(`${C.dim}Checking for updates...${C.reset}`);
@@ -1293,10 +1548,10 @@ ${C.green}Updated to v${latest}${C.reset}`);
 }
 function promptConfirm(question) {
   const rl = createInterface({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     rl.question(question, (answer) => {
       rl.close();
-      resolve4(answer.toLowerCase() === "y");
+      resolve5(answer.toLowerCase() === "y");
     });
   });
 }
@@ -1307,7 +1562,7 @@ async function runUninstall() {
   console.log(`  ${C.green}+${C.reset} Removed MCP server`);
   await unregisterVaultFromObsidian(VAULT_PATH);
   console.log(`  ${C.green}+${C.reset} Unregistered Obsidian vault`);
-  const ccmDir = join7(homedir4(), ".ccm");
+  const ccmDir = join8(homedir4(), ".ccm");
   const deleteVault = await promptConfirm(`  Delete vault at ${C.dim}${VAULT_PATH}${C.reset}? ${C.dim}(y/N)${C.reset} `);
   if (deleteVault) {
     await rm(ccmDir, { recursive: true, force: true });
@@ -1332,6 +1587,8 @@ async function runInit() {
 }
 async function runServer() {
   const entries = await loadVault(VAULT_PATH2);
+  const { stop: stopWatcher, stats: watcherStats } = watchVault(VAULT_PATH2, entries);
+  initUpdateCheck();
   console.error(`Loaded ${entries.length} notes from ${VAULT_PATH2}`);
   const server = new McpServer({
     name: "ccm",
@@ -1344,9 +1601,11 @@ async function runServer() {
   registerWriteTool(server, entries, VAULT_PATH2);
   registerFetchPageTool(server);
   registerResearchTool(server, entries, VAULT_PATH2);
+  registerDiagnosticsTool(server, entries, watcherStats);
   const transport = new StdioServerTransport;
   await server.connect(transport);
   const shutdown = async () => {
+    stopWatcher();
     await server.close();
     process.exit(0);
   };
@@ -1358,8 +1617,7 @@ if (cli === "version") {
   console.log(package_default.version);
   process.exit(0);
 } else if (cli === "help") {
-  printHelp();
-  process.exit(0);
+  printHelp().then(() => process.exit(0)).catch(() => process.exit(0));
 } else if (cli === "update") {
   runUpdate().catch((err) => {
     console.error("Fatal:", err);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@bennys001/claude-code-memory",
   "publishConfig": { "access": "public" },
-  "version": "0.11.1",
+  "version": "0.12.3",
   "description": "MCP server that gives Claude Code persistent memory via an Obsidian knowledge vault",
   "module": "dist/index.js",
   "main": "dist/index.js",