@bennys001/claude-code-memory 0.9.12 → 0.11.1

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.11.1",
   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,107 @@ function registerResearchTool(server, entries, vaultPath) {
   });
 }
 
+// src/cli/claude-code.ts
+import { spawn } from "child_process";
+var SERVER_CMD = ["ccm", "--stdio"];
+function installGlobal() {
+  return new Promise((resolve4) => {
+    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 });
+    });
+    proc.on("close", (code) => {
+      if (code === 0) {
+        resolve4({ success: true });
+      } else {
+        resolve4({ success: false, error: stderr.trim() || `bun install exited with code ${code}` });
+      }
+    });
+  });
+}
+function uninstallGlobal() {
+  return new Promise((resolve4) => {
+    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 });
+    });
+    proc.on("close", (code) => {
+      if (code === 0) {
+        resolve4({ success: true });
+      } else {
+        resolve4({ success: false, error: stderr.trim() || `bun remove exited with code ${code}` });
+      }
+    });
+  });
+}
+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 removeMcpServer() {
+  return new Promise((resolve4) => {
+    const proc = spawn("claude", ["mcp", "remove", "ccm"], { stdio: "ignore" });
+    proc.on("error", () => resolve4());
+    proc.on("close", () => resolve4());
+  });
+}
+async function registerMcpServer() {
+  await removeMcpServer();
+  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";
@@ -1027,72 +1128,17 @@ async function registerVaultWithObsidian(vaultPath, configPath = DEFAULT_CONFIG_
   await writeFile2(configPath, JSON.stringify(config, null, 2));
   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
-        });
-      }
-    });
-  });
+async function unregisterVaultFromObsidian(vaultPath, configPath = DEFAULT_CONFIG_PATH) {
+  const config = await loadObsidianConfig(configPath);
+  if (!config)
+    return false;
+  const vaultId = findVaultByPath(config, vaultPath);
+  if (!vaultId)
+    return false;
+  await copyFile(configPath, `${configPath}.backup`);
+  delete config.vaults[vaultId];
+  await writeFile2(configPath, JSON.stringify(config, null, 2));
+  return true;
 }
 
 // src/cli/init.ts
@@ -1135,6 +1181,12 @@ async function executeInit() {
       detail: obsidianResult.reason
     });
   }
+  const installResult = await installGlobal();
+  if (installResult.success) {
+    steps.push({ name: "global install", status: "created", detail: "ccm binary installed" });
+  } else {
+    steps.push({ name: "global install", status: "failed", detail: installResult.error });
+  }
   const mcpResult = await registerMcpServer();
   if (mcpResult.success) {
     steps.push({ name: "Claude Code MCP", status: "created", detail: mcpResult.output });
@@ -1178,24 +1230,100 @@ function formatInitSummary(result) {
 }
 
 // src/index.ts
+import { rm } from "fs/promises";
+import { createInterface } from "readline";
 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("--uninstall"))
+    return "uninstall";
   if (args.includes("--init"))
     return "init";
   if (args.includes("--stdio"))
     return "serve";
+  if (!process.stdin.isTTY)
+    return "serve";
   return "help";
 }
 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}ccm --init${C.reset}        Set up vault and register MCP server
+  ${C.cyan}ccm --update${C.reset}      Update to the latest version
+  ${C.cyan}ccm --uninstall${C.reset}   Remove ccm, MCP server, and optionally the vault
+  ${C.cyan}ccm --version${C.reset}     Show installed version
+
+${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;
+}
+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}
+`);
+  const installResult = await installGlobal();
+  if (!installResult.success) {
+    throw new Error(`Global install failed: ${installResult.error}`);
+  }
+  const mcpResult = await registerMcpServer();
+  if (!mcpResult.success) {
+    throw new Error(`MCP registration failed: ${mcpResult.error}`);
+  }
+  console.log(`
+${C.green}Updated to v${latest}${C.reset}`);
+}
+function promptConfirm(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve4) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve4(answer.toLowerCase() === "y");
+    });
+  });
+}
+async function runUninstall() {
+  console.log(`${C.bold}ccm uninstall${C.reset}
+`);
+  await removeMcpServer();
+  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 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 });
+    console.log(`  ${C.green}+${C.reset} Deleted vault`);
+  } else {
+    console.log(`  ${C.yellow}-${C.reset} Kept vault`);
+  }
+  const uninstallResult = await uninstallGlobal();
+  if (uninstallResult.success) {
+    console.log(`  ${C.green}+${C.reset} Uninstalled ccm binary`);
+  } else {
+    console.log(`  ${C.red}!${C.reset} Failed to uninstall: ${uninstallResult.error}`);
+  }
+  console.log(`
+${C.green}Done${C.reset}`);
+}
 async function runInit() {
   const result = await executeInit();
   console.log(formatInitSummary(result));
@@ -1226,9 +1354,22 @@ 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 === "uninstall") {
+  runUninstall().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.11.1",
   "description": "MCP server that gives Claude Code persistent memory via an Obsidian knowledge vault",
   "module": "dist/index.js",
   "main": "dist/index.js",