context-vault 3.1.1 → 3.1.3

package/README.md

@@ -10,13 +10,16 @@ Persistent memory for AI agents — saves and searches knowledge across sessions
 ## Quick Start
 
 ```bash
-npx context-vault
+npm install -g context-vault
+context-vault setup
 ```
 
-One command — no global install required. Setup detects your AI tools (Claude Code, Codex, Claude Desktop, Cursor, Windsurf, Cline, and more), downloads the embedding model (~22MB), seeds your vault, and configures MCP.
+Setup detects your AI tools (Claude Code, Codex, Claude Desktop, Cursor, Windsurf, Cline, and more), downloads the embedding model (~22MB), seeds your vault, and configures MCP.
 
 Then open your AI tool and try: **"Search my vault for getting started"**
 
+> **Quick try without installing?** `npx context-vault` works too, but a global install is recommended for reliable MCP server startup.
+
 ## What It Does
 
 - **Save** — insights, decisions, patterns, contacts. Your AI agent writes them as you work.
@@ -73,7 +76,7 @@ Claude Code exposes shell hooks that fire on session events. context-vault integ
         "hooks": [
           {
             "type": "command",
-            "command": "npx context-vault flush",
+            "command": "context-vault flush",
             "timeout": 10
           }
         ]

package/bin/cli.js

@@ -379,6 +379,45 @@ async function runSetup() {
         green(`  ✓ context-vault v${VERSION} is up to date`) +
           dim(`  (vault: ${existingVault})`),
       );
+
+      // Check for stale tool configs using hardcoded node paths
+      const staleConfigs = findStaleToolConfigs();
+      if (staleConfigs.length > 0) {
+        console.log();
+        console.log(
+          yellow(`  ! ${staleConfigs.length} tool config(s) using legacy hardcoded paths`),
+        );
+        for (const s of staleConfigs) {
+          console.log(dim(`    ${s.name}: ${s.command}`));
+        }
+        console.log();
+        const fix = await prompt(
+          `  Auto-fix to use context-vault binary? (Y/n):`,
+          "Y",
+        );
+        if (fix.toLowerCase() !== "n") {
+          let customVaultDir = null;
+          try {
+            const cfg = JSON.parse(readFileSync(existingConfig, "utf-8"));
+            const defaultVDir = join(HOME, "vault");
+            if (cfg.vaultDir && resolve(cfg.vaultDir) !== resolve(defaultVDir)) {
+              customVaultDir = cfg.vaultDir;
+            }
+          } catch {}
+          for (const s of staleConfigs) {
+            try {
+              repairToolConfig(s, customVaultDir);
+              console.log(`  ${green("+")} ${s.name} — fixed`);
+            } catch (e) {
+              console.log(`  ${red("x")} ${s.name} — ${e.message}`);
+            }
+          }
+          console.log();
+          console.log(green("  ✓ Tool configs updated."));
+          console.log(dim("  Restart your AI tools to apply the changes."));
+        }
+      }
+
       console.log();
       return;
     }
@@ -1195,6 +1234,77 @@ async function configureCodex(tool, vaultDir) {
   }
 }
 
+function findStaleToolConfigs() {
+  const stale = [];
+
+  // Check Claude Code (~/.claude.json)
+  const claudePath = join(HOME, ".claude.json");
+  if (existsSync(claudePath)) {
+    try {
+      const cfg = JSON.parse(readFileSync(claudePath, "utf-8"));
+      const srv = cfg?.mcpServers?.["context-vault"];
+      if (srv && srv.command !== "context-vault" && srv.command !== "npx") {
+        stale.push({
+          name: "Claude Code",
+          id: "claude-code",
+          configType: "cli",
+          configPath: claudePath,
+          command: [srv.command, ...(srv.args || [])].join(" "),
+        });
+      }
+    } catch {}
+  }
+
+  // Check JSON-configured tools
+  for (const tool of TOOLS.filter((t) => t.configType === "json")) {
+    const cfgPath = tool.configPath;
+    if (!cfgPath || !existsSync(cfgPath)) continue;
+    try {
+      const cfg = JSON.parse(readFileSync(cfgPath, "utf-8"));
+      const srv = cfg?.[tool.configKey]?.["context-vault"];
+      if (srv && srv.command !== "context-vault" && srv.command !== "npx") {
+        stale.push({
+          name: tool.name,
+          id: tool.id,
+          configType: "json",
+          configPath: cfgPath,
+          configKey: tool.configKey,
+          command: [srv.command, ...(srv.args || [])].join(" "),
+        });
+      }
+    } catch {}
+  }
+
+  return stale;
+}
+
+function repairToolConfig(staleEntry, vaultDir) {
+  const serverArgs = ["serve"];
+  if (vaultDir) serverArgs.push("--vault-dir", vaultDir);
+  const newConfig = { command: "context-vault", args: serverArgs };
+
+  if (staleEntry.id === "claude-code") {
+    // Use `claude mcp remove` + `claude mcp add`
+    try {
+      execFileSync("claude", ["mcp", "remove", "context-vault"], {
+        stdio: "pipe",
+      });
+    } catch {}
+    execFileSync(
+      "claude",
+      ["mcp", "add", "context-vault", "--", "context-vault", ...serverArgs],
+      { stdio: "pipe" },
+    );
+    return;
+  }
+
+  // JSON config tools
+  const cfgPath = staleEntry.configPath;
+  const cfg = JSON.parse(readFileSync(cfgPath, "utf-8"));
+  cfg[staleEntry.configKey]["context-vault"] = newConfig;
+  writeFileSync(cfgPath, JSON.stringify(cfg, null, 2) + "\n");
+}
+
 function configureJsonTool(tool, vaultDir) {
   const configPath = tool.configPath;
   const configDir = dirname(configPath);
@@ -4729,6 +4839,8 @@ async function runDoctor() {
   console.log(bold("  Tool Configurations"));
   let anyToolConfigured = false;
 
+  const isStaleCmd = (cmd) => cmd !== "context-vault" && cmd !== "npx";
+
   // Check Claude Code
   const claudeConfigPath = join(HOME, ".claude.json");
   if (existsSync(claudeConfigPath)) {
@@ -4738,7 +4850,13 @@ async function runDoctor() {
       if (servers["context-vault"]) {
         const srv = servers["context-vault"];
         const cmd = [srv.command, ...(srv.args || [])].join(" ");
-        console.log(`  ${green("+")} Claude Code: ${dim(cmd)}`);
+        if (isStaleCmd(srv.command)) {
+          console.log(`  ${yellow("!")} Claude Code: ${dim(cmd)}`);
+          console.log(`    ${dim("Fix: run context-vault setup to update")}`);
+          allOk = false;
+        } else {
+          console.log(`  ${green("+")} Claude Code: ${dim(cmd)}`);
+        }
         anyToolConfigured = true;
       } else {
         console.log(`  ${dim("-")} Claude Code: not configured`);
@@ -4764,7 +4882,13 @@ async function runDoctor() {
       if (servers["context-vault"]) {
         const srv = servers["context-vault"];
         const cmd = [srv.command, ...(srv.args || [])].join(" ");
-        console.log(`  ${green("+")} ${tool.name}: ${dim(cmd)}`);
+        if (isStaleCmd(srv.command)) {
+          console.log(`  ${yellow("!")} ${tool.name}: ${dim(cmd)}`);
+          console.log(`    ${dim("Fix: run context-vault setup to update")}`);
+          allOk = false;
+        } else {
+          console.log(`  ${green("+")} ${tool.name}: ${dim(cmd)}`);
+        }
         anyToolConfigured = true;
       } else if (servers["context-mcp"]) {
         console.log(

package/node_modules/@context-vault/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@context-vault/core",
-  "version": "3.1.1",
+  "version": "3.1.3",
   "type": "module",
   "description": "Pure local engine: capture, index, search, and utilities for context-vault",
   "main": "dist/main.js",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "context-vault",
-  "version": "3.1.1",
+  "version": "3.1.3",
   "type": "module",
   "description": "Persistent memory for AI agents — saves and searches knowledge across sessions",
   "bin": {
@@ -57,7 +57,7 @@
     "@context-vault/core"
   ],
   "dependencies": {
-    "@context-vault/core": "^3.1.1",
+    "@context-vault/core": "^3.1.3",
     "@modelcontextprotocol/sdk": "^1.26.0",
     "adm-zip": "^0.5.16",
     "sqlite-vec": "^0.1.0"

package/src/linking.js

@@ -1,20 +1,15 @@
-import type { DatabaseSync } from "node:sqlite";
-
-export function parseRelatedTo(raw: string | null | undefined): string[] {
+export function parseRelatedTo(raw) {
   if (!raw) return [];
   try {
     const parsed = JSON.parse(raw);
     if (!Array.isArray(parsed)) return [];
-    return parsed.filter((id: unknown) => typeof id === "string" && (id as string).trim());
+    return parsed.filter((id) => typeof id === "string" && id.trim());
   } catch {
     return [];
   }
 }
 
-export function resolveLinks(
-  db: DatabaseSync,
-  ids: string[],
-): Record<string, unknown>[] {
+export function resolveLinks(db, ids) {
   if (!ids.length) return [];
   const unique = [...new Set(ids)];
   const placeholders = unique.map(() => "?").join(",");
@@ -26,16 +21,13 @@ export function resolveLinks(
            AND (expires_at IS NULL OR expires_at > datetime('now'))
            AND superseded_by IS NULL`,
       )
-      .all(...unique) as unknown as Record<string, unknown>[];
+      .all(...unique);
   } catch {
     return [];
   }
 }
 
-export function resolveBacklinks(
-  db: DatabaseSync,
-  entryId: string,
-): Record<string, unknown>[] {
+export function resolveBacklinks(db, entryId) {
   if (!entryId) return [];
   const likePattern = `%"${entryId}"%`;
   try {
@@ -46,36 +38,33 @@ export function resolveBacklinks(
            AND (expires_at IS NULL OR expires_at > datetime('now'))
            AND superseded_by IS NULL`,
       )
-      .all(likePattern) as unknown as Record<string, unknown>[];
+      .all(likePattern);
   } catch {
     return [];
   }
 }
 
-export function collectLinkedEntries(
-  db: DatabaseSync,
-  primaryEntries: Record<string, unknown>[],
-): { forward: Record<string, unknown>[]; backward: Record<string, unknown>[] } {
-  const primaryIds = new Set(primaryEntries.map((e) => e.id as string));
+export function collectLinkedEntries(db, primaryEntries) {
+  const primaryIds = new Set(primaryEntries.map((e) => e.id));
 
-  const forwardIds: string[] = [];
+  const forwardIds = [];
   for (const entry of primaryEntries) {
-    const ids = parseRelatedTo(entry.related_to as string);
+    const ids = parseRelatedTo(entry.related_to);
     for (const id of ids) {
       if (!primaryIds.has(id)) forwardIds.push(id);
     }
   }
   const forwardEntries = resolveLinks(db, forwardIds).filter(
-    (e) => !primaryIds.has(e.id as string),
+    (e) => !primaryIds.has(e.id),
   );
 
-  const backwardSeen = new Set<string>();
-  const backwardEntries: Record<string, unknown>[] = [];
+  const backwardSeen = new Set();
+  const backwardEntries = [];
   for (const entry of primaryEntries) {
-    const backlinks = resolveBacklinks(db, entry.id as string);
+    const backlinks = resolveBacklinks(db, entry.id);
     for (const bl of backlinks) {
-      if (!primaryIds.has(bl.id as string) && !backwardSeen.has(bl.id as string)) {
-        backwardSeen.add(bl.id as string);
+      if (!primaryIds.has(bl.id) && !backwardSeen.has(bl.id)) {
+        backwardSeen.add(bl.id);
         backwardEntries.push(bl);
       }
     }
@@ -84,7 +73,7 @@ export function collectLinkedEntries(
   return { forward: forwardEntries, backward: backwardEntries };
 }
 
-export function validateRelatedTo(relatedTo: unknown): string | null {
+export function validateRelatedTo(relatedTo) {
   if (relatedTo === undefined || relatedTo === null) return null;
   if (!Array.isArray(relatedTo))
     return "related_to must be an array of entry IDs";

package/src/telemetry.js

@@ -1,22 +1,18 @@
 import { existsSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { API_URL, MARKETING_URL, GITHUB_ISSUES_URL } from "@context-vault/core/constants";
-import type { VaultConfig } from "@context-vault/core/types";
 
 const TELEMETRY_ENDPOINT = `${API_URL}/telemetry`;
 const NOTICE_MARKER = ".telemetry-notice-shown";
 const FEEDBACK_PROMPT_MARKER = ".feedback-prompt-shown";
 
-export function isTelemetryEnabled(config: VaultConfig | undefined): boolean {
+export function isTelemetryEnabled(config) {
   const envVal = process.env.CONTEXT_VAULT_TELEMETRY;
   if (envVal !== undefined) return envVal === "1" || envVal === "true";
   return config?.telemetry === true;
 }
 
-export function sendTelemetryEvent(
-  config: VaultConfig | undefined,
-  payload: { event: string; code?: string | null; tool?: string | null; cv_version: string },
-): void {
+export function sendTelemetryEvent(config, payload) {
   if (!isTelemetryEnabled(config)) return;
 
   const event = {
@@ -38,7 +34,7 @@ export function sendTelemetryEvent(
   }).catch(() => {});
 }
 
-export function maybeShowTelemetryNotice(dataDir: string): void {
+export function maybeShowTelemetryNotice(dataDir) {
   try {
     const markerPath = join(dataDir, NOTICE_MARKER);
     if (existsSync(markerPath)) return;
@@ -60,7 +56,7 @@ export function maybeShowTelemetryNotice(dataDir: string): void {
   }
 }
 
-export function maybeShowFeedbackPrompt(dataDir: string): void {
+export function maybeShowFeedbackPrompt(dataDir) {
   try {
     const markerPath = join(dataDir, FEEDBACK_PROMPT_MARKER);
     if (existsSync(markerPath)) return;

package/src/temporal.js

@@ -1,16 +1,12 @@
 const SHORTCUT_RE = /^last[_ ](\d+)[_ ](day|days|week|weeks|month|months)$/i;
 
-function startOfToday(now: Date): Date {
+function startOfToday(now) {
   const d = new Date(now);
   d.setUTCHours(0, 0, 0, 0);
   return d;
 }
 
-export function resolveTemporalShortcut(
-  role: "since" | "until",
-  value: string,
-  now: Date = new Date(),
-): string {
+export function resolveTemporalShortcut(role, value, now = new Date()) {
   if (!value || typeof value !== "string") return value;
   const trimmed = value.trim().toLowerCase().replace(/\s+/g, "_");
 
@@ -57,7 +53,7 @@ export function resolveTemporalShortcut(
   if (m) {
     const n = parseInt(m[1], 10);
     const unit = m[2].replace(/s$/, "");
-    let ms: number;
+    let ms;
     if (unit === "day") ms = n * 86400000;
     else if (unit === "week") ms = n * 7 * 86400000;
     else ms = n * 30 * 86400000;
@@ -69,10 +65,7 @@ export function resolveTemporalShortcut(
   return value;
 }
 
-export function resolveTemporalParams(
-  params: { since?: string; until?: string },
-  now: Date = new Date(),
-): { since: string | undefined; until: string | undefined } {
+export function resolveTemporalParams(params, now = new Date()) {
   let { since, until } = params;
 
   if (