@bennys001/claude-code-memory 0.9.12 → 0.10.0

package/dist/index.js

@@ -4,7 +4,7 @@
 var package_default = {
   name: "@bennys001/claude-code-memory",
   publishConfig: { access: "public" },
-  version: "0.9.12",
+  version: "0.10.0",
   description: "MCP server that gives Claude Code persistent memory via an Obsidian knowledge vault",
   module: "dist/index.js",
   main: "dist/index.js",
@@ -866,6 +866,64 @@ function registerResearchTool(server, entries, vaultPath) {
   });
 }
 
+// src/index.ts
+import { spawn as spawn2 } from "child_process";
+
+// src/cli/claude-code.ts
+import { spawn } from "child_process";
+var SERVER_CMD = ["bunx", "@bennys001/claude-code-memory", "--stdio"];
+var REGISTER_ARGS = [
+  "mcp",
+  "add",
+  "--transport",
+  "stdio",
+  "--scope",
+  "user",
+  "ccm",
+  "--",
+  ...SERVER_CMD
+];
+var MANUAL_COMMAND = `claude mcp add --transport stdio --scope user ccm -- ${SERVER_CMD.join(" ")}`;
+function registerMcpServer() {
+  return new Promise((resolve4) => {
+    let stdout = "";
+    let stderr = "";
+    const proc = spawn("claude", REGISTER_ARGS, { stdio: "pipe" });
+    proc.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+    proc.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+    proc.on("error", (err) => {
+      if (err.code === "ENOENT") {
+        resolve4({
+          success: false,
+          error: "Claude CLI not found in PATH",
+          manualCommand: MANUAL_COMMAND
+        });
+      } else {
+        resolve4({
+          success: false,
+          error: err.message,
+          manualCommand: MANUAL_COMMAND
+        });
+      }
+    });
+    proc.on("close", (code) => {
+      if (code === 0) {
+        resolve4({ success: true, output: (stdout || stderr).trim() });
+      } else {
+        resolve4({
+          success: false,
+          error: (stderr || stdout).trim() || `Process exited with code ${code}`,
+          manualCommand: MANUAL_COMMAND
+        });
+      }
+    });
+  });
+}
+
 // src/cli/init.ts
 import { mkdir as mkdir2 } from "fs/promises";
 import { join as join6 } from "path";
@@ -1028,73 +1086,6 @@ async function registerVaultWithObsidian(vaultPath, configPath = DEFAULT_CONFIG_
   return { registered: true, vaultId };
 }
 
-// src/cli/claude-code.ts
-import { spawn } from "child_process";
-import { resolve as resolvePath } from "path";
-function buildServerCommand() {
-  const runtime = resolvePath(process.argv[0]);
-  const script = resolvePath(process.argv[1]);
-  return [runtime, script, "--stdio"];
-}
-function buildRegisterArgs(serverCmd) {
-  return [
-    "mcp",
-    "add",
-    "--transport",
-    "stdio",
-    "--scope",
-    "user",
-    "ccm",
-    "--",
-    ...serverCmd
-  ];
-}
-function formatManualCommand(serverCmd) {
-  return `claude mcp add --transport stdio --scope user ccm -- ${serverCmd.join(" ")}`;
-}
-function registerMcpServer() {
-  const serverCmd = buildServerCommand();
-  const registerArgs = buildRegisterArgs(serverCmd);
-  const manualCommand = formatManualCommand(serverCmd);
-  return new Promise((resolve4) => {
-    let stdout = "";
-    let stderr = "";
-    const proc = spawn("claude", registerArgs, { stdio: "pipe" });
-    proc.stdout.on("data", (data) => {
-      stdout += data.toString();
-    });
-    proc.stderr.on("data", (data) => {
-      stderr += data.toString();
-    });
-    proc.on("error", (err) => {
-      if (err.code === "ENOENT") {
-        resolve4({
-          success: false,
-          error: "Claude CLI not found in PATH",
-          manualCommand
-        });
-      } else {
-        resolve4({
-          success: false,
-          error: err.message,
-          manualCommand
-        });
-      }
-    });
-    proc.on("close", (code) => {
-      if (code === 0) {
-        resolve4({ success: true, output: (stdout || stderr).trim() });
-      } else {
-        resolve4({
-          success: false,
-          error: (stderr || stdout).trim() || `Process exited with code ${code}`,
-          manualCommand
-        });
-      }
-    });
-  });
-}
-
 // src/cli/init.ts
 var VAULT_PATH = join6(homedir3(), ".ccm", "knowledge-base");
 var SUBDIRS = ["gotchas", "decisions", "patterns", "references", "_templates"];
@@ -1181,6 +1172,10 @@ function formatInitSummary(result) {
 var VAULT_PATH2 = join7(homedir4(), ".ccm", "knowledge-base");
 function parseCliArgs() {
   const args = process.argv.slice(2);
+  if (args.includes("--version") || args.includes("-v"))
+    return "version";
+  if (args.includes("--update"))
+    return "update";
   if (args.includes("--init"))
     return "init";
   if (args.includes("--stdio"))
@@ -1191,11 +1186,47 @@ function printHelp() {
   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}
-  ${C.cyan}bunx @bennys001/claude-code-memory --init${C.reset}
+  ${C.cyan}bunx @bennys001/claude-code-memory --init${C.reset}    Set up vault and register MCP server
+  ${C.cyan}ccm --update${C.reset}                                  Update to the latest version
+  ${C.cyan}ccm --version${C.reset}                                 Show installed version
 
 ${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;
+}
+function runCommand(cmd, args) {
+  return new Promise((resolve4, reject) => {
+    const proc = spawn2(cmd, args, { stdio: "inherit" });
+    proc.on("error", reject);
+    proc.on("close", (code) => {
+      if (code === 0)
+        resolve4();
+      else
+        reject(new Error(`${cmd} ${args.join(" ")} exited with code ${code}`));
+    });
+  });
+}
+async function runUpdate() {
+  console.log(`${C.dim}Checking for updates...${C.reset}`);
+  const latest = await fetchLatestVersion();
+  if (latest === package_default.version) {
+    console.log(`Already on the latest version: ${C.green}v${package_default.version}${C.reset}`);
+    return;
+  }
+  console.log(`${C.dim}v${package_default.version}${C.reset} \u2192 ${C.green}v${latest}${C.reset}
+`);
+  await runCommand("bun", ["pm", "cache", "rm"]);
+  await runCommand("claude", ["mcp", "remove", "ccm"]);
+  await runCommand("claude", ["mcp", "add", "--transport", "stdio", "--scope", "user", "ccm", "--", ...SERVER_CMD]);
+  console.log(`
+${C.green}Updated to v${latest}${C.reset}`);
+}
 async function runInit() {
   const result = await executeInit();
   console.log(formatInitSummary(result));
@@ -1226,9 +1257,17 @@ async function runServer() {
   process.on("SIGTERM", shutdown);
 }
 var cli = parseCliArgs();
-if (cli === "help") {
+if (cli === "version") {
+  console.log(package_default.version);
+  process.exit(0);
+} else if (cli === "help") {
   printHelp();
   process.exit(0);
+} else if (cli === "update") {
+  runUpdate().catch((err) => {
+    console.error("Fatal:", err);
+    process.exit(1);
+  });
 } else if (cli === "init") {
   runInit().catch((err) => {
     console.error("Fatal:", err);

package/package.json

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