context-vault 3.1.6 → 3.1.7

package/src/register-tools.js

@@ -1,27 +1,25 @@
-import { reindex } from "@context-vault/core/index";
-import { captureAndIndex } from "@context-vault/core/capture";
-import { err } from "./helpers.js";
-import { sendTelemetryEvent } from "./telemetry.js";
-import { readFileSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
+import { reindex } from '@context-vault/core/index';
+import { captureAndIndex } from '@context-vault/core/capture';
+import { err } from './helpers.js';
+import { sendTelemetryEvent } from './telemetry.js';
+import { readFileSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
-const pkg = JSON.parse(
-  readFileSync(join(__dirname, "..", "package.json"), "utf-8"),
-);
+const pkg = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf-8'));
 
-import * as getContext from "./tools/get-context.js";
-import * as saveContext from "./tools/save-context.js";
-import * as listContext from "./tools/list-context.js";
-import * as deleteContext from "./tools/delete-context.js";
-import * as ingestUrl from "./tools/ingest-url.js";
-import * as contextStatus from "./tools/context-status.js";
-import * as clearContext from "./tools/clear-context.js";
-import * as createSnapshot from "./tools/create-snapshot.js";
-import * as sessionStart from "./tools/session-start.js";
-import * as listBuckets from "./tools/list-buckets.js";
-import * as ingestProject from "./tools/ingest-project.js";
+import * as getContext from './tools/get-context.js';
+import * as saveContext from './tools/save-context.js';
+import * as listContext from './tools/list-context.js';
+import * as deleteContext from './tools/delete-context.js';
+import * as ingestUrl from './tools/ingest-url.js';
+import * as contextStatus from './tools/context-status.js';
+import * as clearContext from './tools/clear-context.js';
+import * as createSnapshot from './tools/create-snapshot.js';
+import * as sessionStart from './tools/session-start.js';
+import * as listBuckets from './tools/list-buckets.js';
+import * as ingestProject from './tools/ingest-project.js';
 
 const toolModules = [
   getContext,
@@ -37,7 +35,7 @@ const toolModules = [
   listBuckets,
 ];
 
-const TOOL_TIMEOUT_MS = 60_000;
+const TOOL_TIMEOUT_MS = 120_000;
 
 export function registerTools(server, ctx) {
   function tracked(handler, toolName) {
@@ -50,57 +48,54 @@ export function registerTools(server, ctx) {
         const result = await Promise.race([
           handlerPromise,
           new Promise((_, reject) => {
-            timer = setTimeout(
-              () => reject(new Error("TOOL_TIMEOUT")),
-              TOOL_TIMEOUT_MS,
-            );
+            timer = setTimeout(() => reject(new Error('TOOL_TIMEOUT')), TOOL_TIMEOUT_MS);
           }),
         ]);
         if (ctx.toolStats) ctx.toolStats.ok++;
         return result;
       } catch (e) {
-        if (e.message === "TOOL_TIMEOUT") {
+        if (e.message === 'TOOL_TIMEOUT') {
           handlerPromise?.catch(() => {});
           if (ctx.toolStats) {
             ctx.toolStats.errors++;
             ctx.toolStats.lastError = {
               tool: toolName,
-              code: "TIMEOUT",
+              code: 'TIMEOUT',
               timestamp: Date.now(),
             };
           }
           sendTelemetryEvent(ctx.config, {
-            event: "tool_error",
-            code: "TIMEOUT",
+            event: 'tool_error',
+            code: 'TIMEOUT',
             tool: toolName,
             cv_version: pkg.version,
           });
           return err(
-            "Tool timed out after 60s. Try a simpler query or run `context-vault reindex` first.",
-            "TIMEOUT",
+            'Tool timed out after 120s. Try a simpler query or run `context-vault reindex` first.',
+            'TIMEOUT'
           );
         }
         if (ctx.toolStats) {
           ctx.toolStats.errors++;
           ctx.toolStats.lastError = {
             tool: toolName,
-            code: "UNKNOWN",
+            code: 'UNKNOWN',
             timestamp: Date.now(),
           };
         }
         sendTelemetryEvent(ctx.config, {
-          event: "tool_error",
-          code: "UNKNOWN",
+          event: 'tool_error',
+          code: 'UNKNOWN',
           tool: toolName,
           cv_version: pkg.version,
         });
         try {
           await captureAndIndex(ctx, {
-            kind: "feedback",
-            title: `Unhandled error in ${toolName ?? "tool"} call`,
-            body: `${e.message}\n\n${e.stack ?? ""}`,
-            tags: ["bug", "auto-captured"],
-            source: "auto-capture",
+            kind: 'feedback',
+            title: `Unhandled error in ${toolName ?? 'tool'} call`,
+            body: `${e.message}\n\n${e.stack ?? ''}`,
+            tags: ['bug', 'auto-captured'],
+            source: 'auto-capture',
             meta: {
               tool: toolName,
               error_type: e.constructor?.name,
@@ -109,7 +104,7 @@ export function registerTools(server, ctx) {
             },
           });
         } catch {}
-        return err(e.message, "INTERNAL_ERROR");
+        return err(e.message, 'INTERNAL_ERROR');
       } finally {
         clearTimeout(timer);
         if (ctx.activeOps) ctx.activeOps.count--;
@@ -123,27 +118,30 @@ export function registerTools(server, ctx) {
   let reindexFailed = false;
   const MAX_REINDEX_ATTEMPTS = 2;
 
-  async function ensureIndexed() {
+  async function ensureIndexed({ blocking = true } = {}) {
     if (reindexDone) return;
-    if (reindexPromise) return reindexPromise;
+    if (reindexPromise) {
+      if (blocking) return reindexPromise;
+      return; // non-blocking: just ensure it's started
+    }
     const promise = reindex(ctx, { fullSync: true })
       .then((stats) => {
         reindexDone = true;
         const total = stats.added + stats.updated + stats.removed;
         if (total > 0) {
           console.error(
-            `[context-vault] Auto-reindex: +${stats.added} ~${stats.updated} -${stats.removed} (${stats.unchanged} unchanged)`,
+            `[context-vault] Auto-reindex: +${stats.added} ~${stats.updated} -${stats.removed} (${stats.unchanged} unchanged)`
           );
         }
       })
       .catch((e) => {
         reindexAttempts++;
         console.error(
-          `[context-vault] Auto-reindex failed (attempt ${reindexAttempts}/${MAX_REINDEX_ATTEMPTS}): ${e.message}`,
+          `[context-vault] Auto-reindex failed (attempt ${reindexAttempts}/${MAX_REINDEX_ATTEMPTS}): ${e.message}`
         );
         if (reindexAttempts >= MAX_REINDEX_ATTEMPTS) {
           console.error(
-            `[context-vault] Giving up on auto-reindex. Run \`context-vault reindex\` manually to diagnose.`,
+            `[context-vault] Giving up on auto-reindex. Run \`context-vault reindex\` manually to diagnose.`
           );
           reindexDone = true;
           reindexFailed = true;
@@ -152,7 +150,7 @@ export function registerTools(server, ctx) {
         }
       });
     reindexPromise = promise;
-    return reindexPromise;
+    if (blocking) return reindexPromise;
   }
 
   const shared = {
@@ -167,7 +165,7 @@ export function registerTools(server, ctx) {
       mod.name,
       mod.description,
       mod.inputSchema,
-      tracked((args) => mod.handler(args, ctx, shared), mod.name),
+      tracked((args) => mod.handler(args, ctx, shared), mod.name)
     );
   }
 

package/src/server.js

@@ -1,69 +1,57 @@
 #!/usr/bin/env node
 
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import {
-  existsSync,
-  mkdirSync,
-  writeFileSync,
-  readFileSync,
-  unlinkSync,
-} from "node:fs";
-import { join, dirname } from "node:path";
-import { homedir } from "node:os";
-import { fileURLToPath } from "node:url";
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { existsSync, mkdirSync, writeFileSync, readFileSync, unlinkSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { homedir } from 'node:os';
+import { fileURLToPath } from 'node:url';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
-const pkg = JSON.parse(
-  readFileSync(join(__dirname, "..", "package.json"), "utf-8"),
-);
+const pkg = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf-8'));
 
-import { resolveConfig } from "@context-vault/core/config";
-import { appendErrorLog } from "./error-log.js";
-import { sendTelemetryEvent, maybeShowTelemetryNotice } from "./telemetry.js";
-import { embed } from "@context-vault/core/embed";
+import { resolveConfig } from '@context-vault/core/config';
+import { appendErrorLog } from './error-log.js';
+import { sendTelemetryEvent, maybeShowTelemetryNotice } from './telemetry.js';
+import { embed } from '@context-vault/core/embed';
 import {
   initDatabase,
   NativeModuleError,
   prepareStatements,
   insertVec,
   deleteVec,
-} from "@context-vault/core/db";
-import { registerTools } from "./register-tools.js";
-import { pruneExpired } from "@context-vault/core/index";
+} from '@context-vault/core/db';
+import { registerTools } from './register-tools.js';
+import { pruneExpired } from '@context-vault/core/index';
 
 async function main() {
-  let phase = "CONFIG";
+  let phase = 'CONFIG';
   let db;
   let config;
 
   try {
     config = resolveConfig();
 
-    phase = "DIRS";
+    phase = 'DIRS';
     mkdirSync(config.dataDir, { recursive: true });
     mkdirSync(config.vaultDir, { recursive: true });
     maybeShowTelemetryNotice(config.dataDir);
 
     try {
-      const probe = join(config.vaultDir, ".write-probe");
-      writeFileSync(probe, "");
+      const probe = join(config.vaultDir, '.write-probe');
+      writeFileSync(probe, '');
       unlinkSync(probe);
     } catch (writeErr) {
-      console.error(
-        `[context-vault] FATAL: Vault directory is not writable: ${config.vaultDir}`,
-      );
+      console.error(`[context-vault] FATAL: Vault directory is not writable: ${config.vaultDir}`);
       console.error(`[context-vault] ${writeErr.message}`);
-      console.error(
-        `[context-vault] Fix permissions: chmod u+w "${config.vaultDir}"`,
-      );
+      console.error(`[context-vault] Fix permissions: chmod u+w "${config.vaultDir}"`);
       process.exit(1);
     }
 
     try {
-      const markerPath = join(config.vaultDir, ".context-mcp");
+      const markerPath = join(config.vaultDir, '.context-mcp');
       const markerData = existsSync(markerPath)
-        ? JSON.parse(readFileSync(markerPath, "utf-8"))
+        ? JSON.parse(readFileSync(markerPath, 'utf-8'))
         : {};
       writeFileSync(
         markerPath,
@@ -73,13 +61,11 @@ async function main() {
             version: pkg.version,
           },
           null,
-          2,
-        ) + "\n",
+          2
+        ) + '\n'
       );
     } catch (markerErr) {
-      console.error(
-        `[context-vault] Warning: could not write marker file: ${markerErr.message}`,
-      );
+      console.error(`[context-vault] Warning: could not write marker file: ${markerErr.message}`);
     }
 
     config.vaultDirExists = existsSync(config.vaultDir);
@@ -91,7 +77,7 @@ async function main() {
       console.error(`[context-vault] WARNING: Vault directory not found!`);
     }
 
-    phase = "DB";
+    phase = 'DB';
     db = await initDatabase(config.dbPath);
     const stmts = prepareStatements(db);
 
@@ -110,29 +96,25 @@ async function main() {
       const pruned = await pruneExpired(ctx);
       if (pruned > 0) {
         console.error(
-          `[context-vault] Pruned ${pruned} expired ${pruned === 1 ? "entry" : "entries"}`,
+          `[context-vault] Pruned ${pruned} expired ${pruned === 1 ? 'entry' : 'entries'}`
         );
       }
     } catch (pruneErr) {
-      console.error(
-        `[context-vault] Warning: startup prune failed: ${pruneErr.message}`,
-      );
+      console.error(`[context-vault] Warning: startup prune failed: ${pruneErr.message}`);
     }
 
-    phase = "SERVER";
+    phase = 'SERVER';
     const server = new McpServer(
-      { name: "context-vault", version: pkg.version },
-      { capabilities: { tools: {} } },
+      { name: 'context-vault', version: pkg.version },
+      { capabilities: { tools: {} } }
     );
 
     let lastVaultDir = config.vaultDir;
-    Object.defineProperty(ctx, "config", {
+    Object.defineProperty(ctx, 'config', {
       get() {
         const fresh = resolveConfig();
         if (fresh.vaultDir !== lastVaultDir) {
-          console.error(
-            `[context-vault] Config reloaded: vaultDir changed to ${fresh.vaultDir}`,
-          );
+          console.error(`[context-vault] Config reloaded: vaultDir changed to ${fresh.vaultDir}`);
           lastVaultDir = fresh.vaultDir;
           fresh.vaultDirExists = existsSync(fresh.vaultDir);
         }
@@ -146,12 +128,12 @@ async function main() {
     function closeDb() {
       try {
         if (db.inTransaction) {
-          console.error("[context-vault] Rolling back active transaction...");
-          db.exec("ROLLBACK");
+          console.error('[context-vault] Rolling back active transaction...');
+          db.exec('ROLLBACK');
         }
-        db.pragma("wal_checkpoint(TRUNCATE)");
+        db.pragma('wal_checkpoint(TRUNCATE)');
         db.close();
-        console.error("[context-vault] Database closed cleanly.");
+        console.error('[context-vault] Database closed cleanly.');
       } catch (shutdownErr) {
         console.error(`[context-vault] Shutdown error: ${shutdownErr.message}`);
       }
@@ -163,7 +145,7 @@ async function main() {
 
       if (ctx.activeOps.count > 0) {
         console.error(
-          `[context-vault] Waiting for ${ctx.activeOps.count} in-flight operation(s)...`,
+          `[context-vault] Waiting for ${ctx.activeOps.count} in-flight operation(s)...`
         );
         const check = setInterval(() => {
           if (ctx.activeOps.count === 0) {
@@ -174,7 +156,7 @@ async function main() {
         setTimeout(() => {
           clearInterval(check);
           console.error(
-            `[context-vault] Force shutdown — ${ctx.activeOps.count} operation(s) still running`,
+            `[context-vault] Force shutdown — ${ctx.activeOps.count} operation(s) still running`
           );
           closeDb();
         }, 5000);
@@ -182,25 +164,25 @@ async function main() {
         closeDb();
       }
     }
-    process.on("SIGINT", () => shutdown("SIGINT"));
-    process.on("SIGTERM", () => shutdown("SIGTERM"));
+    process.on('SIGINT', () => shutdown('SIGINT'));
+    process.on('SIGTERM', () => shutdown('SIGTERM'));
 
-    phase = "CONNECTED";
+    phase = 'CONNECTED';
     const transport = new StdioServerTransport();
     await server.connect(transport);
 
     setTimeout(() => {
-      import("node:child_process")
+      import('node:child_process')
         .then(({ execSync }) => {
           try {
-            const latest = execSync("npm view context-vault version", {
-              encoding: "utf-8",
+            const latest = execSync('npm view context-vault version', {
+              encoding: 'utf-8',
               timeout: 5000,
-              stdio: ["pipe", "pipe", "pipe"],
+              stdio: ['pipe', 'pipe', 'pipe'],
             }).trim();
             if (latest && latest !== pkg.version) {
               console.error(
-                `[context-vault] Update available: v${pkg.version} → v${latest}. Run: context-vault update`,
+                `[context-vault] Update available: v${pkg.version} → v${latest}. Run: context-vault update`
               );
             }
           } catch {}
@@ -208,11 +190,11 @@ async function main() {
         .catch(() => {});
     }, 3000);
   } catch (err) {
-    const dataDir = config?.dataDir || join(homedir(), ".context-mcp");
+    const dataDir = config?.dataDir || join(homedir(), '.context-mcp');
 
     const logEntry = {
       timestamp: new Date().toISOString(),
-      error_type: err.constructor?.name || "Error",
+      error_type: err.constructor?.name || 'Error',
       message: err.message,
       node_version: process.version,
       platform: process.platform,
@@ -224,59 +206,51 @@ async function main() {
     try {
       mkdirSync(dataDir, { recursive: true });
       writeFileSync(
-        join(dataDir, ".last-error"),
-        `${logEntry.timestamp} [${phase}] ${err.message}`,
+        join(dataDir, '.last-error'),
+        `${logEntry.timestamp} [${phase}] ${err.message}`
       );
     } catch {}
 
     sendTelemetryEvent(config, {
-      event: "startup_error",
+      event: 'startup_error',
       code: phase,
       tool: null,
       cv_version: pkg.version,
     });
 
     if (err instanceof NativeModuleError) {
-      console.error("");
-      console.error(
-        "╔══════════════════════════════════════════════════════════════╗",
-      );
-      console.error(
-        "║  context-vault: Native Module Error                         ║",
-      );
-      console.error(
-        "╚══════════════════════════════════════════════════════════════╝",
-      );
-      console.error("");
+      console.error('');
+      console.error('╔══════════════════════════════════════════════════════════════╗');
+      console.error('║  context-vault: Native Module Error                         ║');
+      console.error('╚══════════════════════════════════════════════════════════════╝');
+      console.error('');
       console.error(err.message);
-      console.error("");
+      console.error('');
       console.error(`  Node.js path:    ${process.execPath}`);
       console.error(`  Node.js version: ${process.version}`);
-      console.error(`  Error log:       ${join(dataDir, "error.log")}`);
-      console.error("");
+      console.error(`  Error log:       ${join(dataDir, 'error.log')}`);
+      console.error('');
       process.exit(78);
     }
 
-    console.error(
-      `[context-vault] Fatal error during ${phase} phase: ${err.message}`,
-    );
-    console.error(`[context-vault] Error log: ${join(dataDir, "error.log")}`);
-    if (phase === "DB") {
+    console.error(`[context-vault] Fatal error during ${phase} phase: ${err.message}`);
+    console.error(`[context-vault] Error log: ${join(dataDir, 'error.log')}`);
+    if (phase === 'DB') {
       console.error(
-        `[context-vault] Try deleting the DB file and restarting: rm "${config?.dbPath || "vault.db"}"`,
+        `[context-vault] Try deleting the DB file and restarting: rm "${config?.dbPath || 'vault.db'}"`
       );
     }
     process.exit(1);
   }
 }
 
-process.on("uncaughtException", (err) => {
-  const dataDir = join(homedir(), ".context-mcp");
+process.on('uncaughtException', (err) => {
+  const dataDir = join(homedir(), '.context-mcp');
   const logEntry = {
     timestamp: new Date().toISOString(),
-    error_type: "uncaughtException",
+    error_type: 'uncaughtException',
     message: err.message,
-    stack: err.stack?.split("\n").slice(0, 5).join(" | "),
+    stack: err.stack?.split('\n').slice(0, 5).join(' | '),
     node_version: process.version,
     platform: process.platform,
     arch: process.arch,
@@ -284,17 +258,17 @@ process.on("uncaughtException", (err) => {
   };
   appendErrorLog(dataDir, logEntry);
   console.error(`[context-vault] Uncaught exception: ${err.message}`);
-  console.error(`[context-vault] Error log: ${join(dataDir, "error.log")}`);
+  console.error(`[context-vault] Error log: ${join(dataDir, 'error.log')}`);
   console.error(`[context-vault] Run: context-vault doctor`);
   process.exit(1);
 });
 
-process.on("unhandledRejection", (reason) => {
-  const dataDir = join(homedir(), ".context-mcp");
+process.on('unhandledRejection', (reason) => {
+  const dataDir = join(homedir(), '.context-mcp');
   const message = reason instanceof Error ? reason.message : String(reason);
   const logEntry = {
     timestamp: new Date().toISOString(),
-    error_type: "unhandledRejection",
+    error_type: 'unhandledRejection',
     message,
     node_version: process.version,
     platform: process.platform,
@@ -303,7 +277,7 @@ process.on("unhandledRejection", (reason) => {
   };
   appendErrorLog(dataDir, logEntry);
   console.error(`[context-vault] Unhandled rejection: ${message}`);
-  console.error(`[context-vault] Error log: ${join(dataDir, "error.log")}`);
+  console.error(`[context-vault] Error log: ${join(dataDir, 'error.log')}`);
   console.error(`[context-vault] Run: context-vault doctor`);
   process.exit(1);
 });