@context-vault/core 2.8.19 → 2.10.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@context-vault/core",
-  "version": "2.8.19",
+  "version": "2.10.0",
   "type": "module",
   "description": "Shared core: capture, index, retrieve, tools, and utilities for context-vault",
   "main": "src/index.js",
@@ -31,7 +31,7 @@
   ],
   "license": "MIT",
   "engines": {
-    "node": ">=20"
+    "node": ">=24"
   },
   "author": "Felix Hellstrom",
   "repository": {
@@ -45,7 +45,6 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.26.0",
-    "better-sqlite3": "^12.6.2",
     "sqlite-vec": "^0.1.0"
   },
   "optionalDependencies": {

package/src/core/error-log.js

@@ -0,0 +1,54 @@
+import {
+  appendFileSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  statSync,
+  writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+
+const MAX_LOG_SIZE = 1024 * 1024; // 1MB
+
+export function errorLogPath(dataDir) {
+  return join(dataDir, "error.log");
+}
+
+/**
+ * Append a structured JSON entry to the startup error log.
+ * Rotates the file if it exceeds MAX_LOG_SIZE.
+ * Never throws — logging failures must not mask the original error.
+ *
+ * @param {string} dataDir
+ * @param {object} entry
+ */
+export function appendErrorLog(dataDir, entry) {
+  try {
+    mkdirSync(dataDir, { recursive: true });
+    const logPath = errorLogPath(dataDir);
+    if (existsSync(logPath) && statSync(logPath).size >= MAX_LOG_SIZE) {
+      writeFileSync(logPath, "");
+    }
+    appendFileSync(logPath, JSON.stringify(entry) + "\n");
+  } catch {
+    // intentionally swallowed
+  }
+}
+
+/**
+ * Return number of log lines in the error log, or 0 if absent.
+ *
+ * @param {string} dataDir
+ * @returns {number}
+ */
+export function errorLogCount(dataDir) {
+  try {
+    const logPath = errorLogPath(dataDir);
+    if (!existsSync(logPath)) return 0;
+    return readFileSync(logPath, "utf-8")
+      .split("\n")
+      .filter((l) => l.trim()).length;
+  } catch {
+    return 0;
+  }
+}

package/src/core/status.js

@@ -128,6 +128,18 @@ export function gatherVaultStatus(ctx, opts = {}) {
   // Embedding model availability
   const embedModelAvailable = isEmbedAvailable();
 
+  // Count auto-captured feedback entries (written by tracked() on unhandled errors)
+  let autoCapturedFeedbackCount = 0;
+  try {
+    autoCapturedFeedbackCount = db
+      .prepare(
+        `SELECT COUNT(*) as c FROM vault WHERE kind = 'feedback' AND tags LIKE '%"auto-captured"%' ${userAnd}`,
+      )
+      .get(...userParams).c;
+  } catch (e) {
+    errors.push(`Auto-captured feedback count failed: ${e.message}`);
+  }
+
   return {
     fileCount,
     subdirs,
@@ -140,6 +152,7 @@ export function gatherVaultStatus(ctx, opts = {}) {
     expiredCount,
     embeddingStatus,
     embedModelAvailable,
+    autoCapturedFeedbackCount,
     resolvedFrom: config.resolvedFrom,
     errors,
   };

package/src/index/db.js

@@ -1,4 +1,5 @@
 import { unlinkSync, copyFileSync, existsSync } from "node:fs";
+import { DatabaseSync } from "node:sqlite";
 
 export class NativeModuleError extends Error {
   constructor(originalError) {
@@ -11,55 +12,34 @@ export class NativeModuleError extends Error {
 
 function formatNativeModuleError(err) {
   const msg = err.message || "";
-  const versionMatch = msg.match(
-    /was compiled against a different Node\.js version using\s+NODE_MODULE_VERSION (\d+)\. This version of Node\.js requires\s+NODE_MODULE_VERSION (\d+)/,
-  );
-
-  const lines = [
-    `Native module failed to load: ${msg}`,
+  return [
+    `sqlite-vec extension failed to load: ${msg}`,
     "",
     `  Running Node.js: ${process.version} (${process.execPath})`,
-  ];
-
-  if (versionMatch) {
-    lines.push(`  Module compiled for: NODE_MODULE_VERSION ${versionMatch[1]}`);
-    lines.push(`  Current runtime:     NODE_MODULE_VERSION ${versionMatch[2]}`);
-  }
-
-  lines.push(
-    "",
-    "  Fix: Rebuild native modules for your current Node.js:",
-    "    npm rebuild better-sqlite3 sqlite-vec",
     "",
-    "  Or reinstall:",
+    "  Fix: Reinstall context-vault:",
     "    npx -y context-vault@latest setup",
-  );
-
-  return lines.join("\n");
+  ].join("\n");
 }
 
-let _Database = null;
 let _sqliteVec = null;
 
-async function loadNativeModules() {
-  if (_Database && _sqliteVec)
-    return { Database: _Database, sqliteVec: _sqliteVec };
-
-  try {
-    const dbMod = await import("better-sqlite3");
-    _Database = dbMod.default;
-  } catch (e) {
-    throw new NativeModuleError(e);
-  }
+async function loadSqliteVec() {
+  if (_sqliteVec) return _sqliteVec;
+  const vecMod = await import("sqlite-vec");
+  _sqliteVec = vecMod;
+  return _sqliteVec;
+}
 
+function runTransaction(db, fn) {
+  db.exec("BEGIN");
   try {
-    const vecMod = await import("sqlite-vec");
-    _sqliteVec = vecMod;
+    fn();
+    db.exec("COMMIT");
   } catch (e) {
-    throw new NativeModuleError(e);
+    db.exec("ROLLBACK");
+    throw e;
   }
-
-  return { Database: _Database, sqliteVec: _sqliteVec };
 }
 
 export const SCHEMA_DDL = `
@@ -118,12 +98,12 @@ export const SCHEMA_DDL = `
 `;
 
 export async function initDatabase(dbPath) {
-  const { Database, sqliteVec } = await loadNativeModules();
+  const sqliteVec = await loadSqliteVec();
 
   function createDb(path) {
-    const db = new Database(path);
-    db.pragma("journal_mode = WAL");
-    db.pragma("foreign_keys = ON");
+    const db = new DatabaseSync(path, { allowExtension: true });
+    db.exec("PRAGMA journal_mode = WAL");
+    db.exec("PRAGMA foreign_keys = ON");
     try {
       sqliteVec.load(db);
     } catch (e) {
@@ -133,7 +113,7 @@ export async function initDatabase(dbPath) {
   }
 
   const db = createDb(dbPath);
-  const version = db.pragma("user_version", { simple: true });
+  const version = db.prepare("PRAGMA user_version").get().user_version;
 
   // Enforce fresh-DB-only — old schemas get a full rebuild (with backup)
   if (version > 0 && version < 5) {
@@ -167,17 +147,17 @@ export async function initDatabase(dbPath) {
 
     const freshDb = createDb(dbPath);
     freshDb.exec(SCHEMA_DDL);
-    freshDb.pragma("user_version = 7");
+    freshDb.exec("PRAGMA user_version = 7");
     return freshDb;
   }
 
   if (version < 5) {
     db.exec(SCHEMA_DDL);
-    db.pragma("user_version = 7");
+    db.exec("PRAGMA user_version = 7");
   } else if (version === 5) {
     // v5 -> v6 migration: add multi-tenancy + encryption columns
     // Wrapped in transaction with duplicate-column guards for idempotent retry
-    const migrate = db.transaction(() => {
+    runTransaction(db, () => {
       const addColumnSafe = (sql) => {
         try {
           db.exec(sql);
@@ -197,21 +177,19 @@ export async function initDatabase(dbPath) {
       db.exec(
         `CREATE UNIQUE INDEX IF NOT EXISTS idx_vault_identity ON vault(user_id, kind, identity_key) WHERE identity_key IS NOT NULL`,
       );
-      db.pragma("user_version = 7");
+      db.exec("PRAGMA user_version = 7");
     });
-    migrate();
   } else if (version === 6) {
     // v6 -> v7 migration: add team_id column
-    const migrate = db.transaction(() => {
+    runTransaction(db, () => {
       try {
         db.exec(`ALTER TABLE vault ADD COLUMN team_id TEXT`);
       } catch (e) {
         if (!e.message.includes("duplicate column")) throw e;
       }
       db.exec(`CREATE INDEX IF NOT EXISTS idx_vault_team ON vault(team_id)`);
-      db.pragma("user_version = 7");
+      db.exec("PRAGMA user_version = 7");
     });
-    migrate();
   }
 
   return db;
@@ -247,15 +225,15 @@ export function prepareStatements(db) {
   } catch (e) {
     throw new Error(
       `Failed to prepare database statements. The database may be corrupted.\n` +
-        `Try deleting and rebuilding: rm "${db.name}" && context-vault reindex\n` +
+        `Try deleting and rebuilding: context-vault reindex\n` +
         `Original error: ${e.message}`,
     );
   }
 }
 
 export function insertVec(stmts, rowid, embedding) {
-  // sqlite-vec requires BigInt for primary key — better-sqlite3 binds Number as REAL,
-  // but vec0 virtual tables only accept INTEGER rowids
+  // sqlite-vec requires BigInt for primary key — node:sqlite may bind Number as REAL
+  // for vec0 virtual tables which only accept INTEGER rowids
   const safeRowid = BigInt(rowid);
   if (safeRowid < 1n) throw new Error(`Invalid rowid: ${rowid}`);
   stmts.insertVecStmt.run(safeRowid, embedding);

package/src/server/helpers.js

@@ -2,12 +2,25 @@
  * helpers.js — Shared MCP response helpers and validation
  */
 
+import pkg from "../../package.json" with { type: "json" };
+
 export function ok(text) {
   return { content: [{ type: "text", text }] };
 }
 
-export function err(text, code = "UNKNOWN") {
-  return { content: [{ type: "text", text }], isError: true, code };
+export function err(text, code = "UNKNOWN", meta = {}) {
+  return {
+    content: [{ type: "text", text }],
+    isError: true,
+    code,
+    _meta: {
+      cv_version: pkg.version,
+      node_version: process.version,
+      platform: process.platform,
+      arch: process.arch,
+      ...meta,
+    },
+  };
 }
 
 export function ensureVaultExists(config) {

package/src/server/tools/context-status.js

@@ -1,6 +1,16 @@
 import { gatherVaultStatus } from "../../core/status.js";
+import { errorLogPath, errorLogCount } from "../../core/error-log.js";
 import { ok } from "../helpers.js";
 
+function relativeTime(ts) {
+  const secs = Math.floor((Date.now() - ts) / 1000);
+  if (secs < 60) return `${secs}s ago`;
+  const mins = Math.floor(secs / 60);
+  if (mins < 60) return `${mins} minute${mins === 1 ? "" : "s"} ago`;
+  const hrs = Math.floor(mins / 60);
+  return `${hrs} hour${hrs === 1 ? "" : "s"} ago`;
+}
+
 export const name = "context_status";
 
 export const description =
@@ -83,6 +93,33 @@ export function handler(_args, ctx) {
     lines.push(`Auto-reindex will fix this on next search or save.`);
   }
 
+  // Error log
+  const logPath = errorLogPath(config.dataDir);
+  const logCount = errorLogCount(config.dataDir);
+  if (logCount > 0) {
+    lines.push(``, `### Startup Error Log`);
+    lines.push(`- Path: ${logPath}`);
+    lines.push(`- Entries: ${logCount} (share this file for support)`);
+  }
+
+  // Health: session-level tool call stats
+  const ts = ctx.toolStats;
+  if (ts) {
+    lines.push(``, `### Health`);
+    lines.push(`- Tool calls (session): ${ts.ok} ok, ${ts.errors} errors`);
+    if (ts.lastError) {
+      const { tool, code, timestamp } = ts.lastError;
+      lines.push(
+        `- Last error: ${tool ?? "unknown"} — ${code} (${relativeTime(timestamp)})`,
+      );
+    }
+    if (status.autoCapturedFeedbackCount > 0) {
+      lines.push(
+        `- Auto-captured feedback entries: ${status.autoCapturedFeedbackCount} (run get_context with kind:feedback tags:auto-captured)`,
+      );
+    }
+  }
+
   // Suggested actions
   const actions = [];
   if (status.stalePaths)

package/src/server/tools/get-context.js

@@ -182,12 +182,21 @@ export async function handler(
     for (const r of filtered) r.score = 0;
   }
 
-  if (!filtered.length)
+  if (!filtered.length) {
+    if (autoWindowed) {
+      const days = config.eventDecayDays || 30;
+      return ok(
+        hasQuery
+          ? `No results found for "${query}" in events (last ${days} days).\nTry with \`since: "YYYY-MM-DD"\` to search older events.`
+          : `No entries found matching the given filters in events (last ${days} days).\nTry with \`since: "YYYY-MM-DD"\` to search older events.`,
+      );
+    }
     return ok(
       hasQuery
         ? "No results found for: " + query
         : "No entries found matching the given filters.",
     );
+  }
 
   // Decrypt encrypted entries if ctx.decrypt is available
   if (ctx.decrypt) {
@@ -212,6 +221,12 @@ export async function handler(
     );
   const heading = hasQuery ? `Results for "${query}"` : "Filtered entries";
   lines.push(`## ${heading} (${filtered.length} matches)\n`);
+  if (autoWindowed) {
+    const days = config.eventDecayDays || 30;
+    lines.push(
+      `> ℹ Event search limited to last ${days} days. Use \`since\` parameter for older results.\n`,
+    );
+  }
   for (let i = 0; i < filtered.length; i++) {
     const r = filtered[i];
     const entryTags = r.tags ? JSON.parse(r.tags) : [];
@@ -229,10 +244,5 @@ export async function handler(
     lines.push(r.body?.slice(0, 300) + (r.body?.length > 300 ? "..." : ""));
     lines.push("");
   }
-  if (autoWindowed) {
-    lines.push(
-      `_Showing events from last ${config.eventDecayDays || 30} days. Use since/until for custom range._`,
-    );
-  }
   return ok(lines.join("\n"));
 }

package/src/server/tools/list-context.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { normalizeKind } from "../../core/files.js";
+import { categoryFor } from "../../core/categories.js";
 import { ok } from "../helpers.js";
 
 export const name = "list_context";
@@ -50,6 +51,17 @@ export async function handler(
 
   await ensureIndexed();
 
+  const kindFilter = kind ? normalizeKind(kind) : null;
+  const effectiveCategory =
+    category || (kindFilter ? categoryFor(kindFilter) : null);
+  let effectiveSince = since || null;
+  let autoWindowed = false;
+  if (effectiveCategory === "event" && !since && !until) {
+    const decayMs = (config.eventDecayDays || 30) * 86400000;
+    effectiveSince = new Date(Date.now() - decayMs).toISOString();
+    autoWindowed = true;
+  }
+
   const clauses = [];
   const params = [];
 
@@ -57,17 +69,17 @@ export async function handler(
     clauses.push("user_id = ?");
     params.push(userId);
   }
-  if (kind) {
+  if (kindFilter) {
     clauses.push("kind = ?");
-    params.push(normalizeKind(kind));
+    params.push(kindFilter);
   }
   if (category) {
     clauses.push("category = ?");
     params.push(category);
   }
-  if (since) {
+  if (effectiveSince) {
     clauses.push("created_at >= ?");
-    params.push(since);
+    params.push(effectiveSince);
   }
   if (until) {
     clauses.push("created_at <= ?");
@@ -103,8 +115,15 @@ export async function handler(
         .slice(0, effectiveLimit)
     : rows;
 
-  if (!filtered.length)
+  if (!filtered.length) {
+    if (autoWindowed) {
+      const days = config.eventDecayDays || 30;
+      return ok(
+        `No entries found matching the given filters in events (last ${days} days).\nTry with \`since: "YYYY-MM-DD"\` to search older events.`,
+      );
+    }
     return ok("No entries found matching the given filters.");
+  }
 
   const lines = [];
   if (reindexFailed)
@@ -112,6 +131,12 @@ export async function handler(
       `> **Warning:** Auto-reindex failed. Results may be stale. Run \`context-vault reindex\` to fix.\n`,
     );
   lines.push(`## Vault Entries (${filtered.length} shown, ${total} total)\n`);
+  if (autoWindowed) {
+    const days = config.eventDecayDays || 30;
+    lines.push(
+      `> ℹ Event search limited to last ${days} days. Use \`since\` parameter for older results.\n`,
+    );
+  }
   for (const r of filtered) {
     const entryTags = r.tags ? JSON.parse(r.tags) : [];
     const tagStr = entryTags.length ? entryTags.join(", ") : "none";

package/src/server/tools.js

@@ -1,5 +1,7 @@
 import { reindex } from "../index/index.js";
+import { captureAndIndex } from "../capture/index.js";
 import { err } from "./helpers.js";
+import pkg from "../../package.json" with { type: "json" };
 
 import * as getContext from "./tools/get-context.js";
 import * as saveContext from "./tools/save-context.js";
@@ -24,14 +26,14 @@ const TOOL_TIMEOUT_MS = 60_000;
 export function registerTools(server, ctx) {
   const userId = ctx.userId !== undefined ? ctx.userId : undefined;
 
-  function tracked(handler) {
+  function tracked(handler, toolName) {
     return async (...args) => {
       if (ctx.activeOps) ctx.activeOps.count++;
       let timer;
       let handlerPromise;
       try {
         handlerPromise = Promise.resolve(handler(...args));
-        return await Promise.race([
+        const result = await Promise.race([
           handlerPromise,
           new Promise((_, reject) => {
             timer = setTimeout(
@@ -40,16 +42,49 @@ export function registerTools(server, ctx) {
             );
           }),
         ]);
+        if (ctx.toolStats) ctx.toolStats.ok++;
+        return result;
       } catch (e) {
         if (e.message === "TOOL_TIMEOUT") {
           // Suppress any late rejection from the still-running handler to
           // prevent unhandled promise rejection warnings in the host process.
           handlerPromise?.catch(() => {});
+          if (ctx.toolStats) {
+            ctx.toolStats.errors++;
+            ctx.toolStats.lastError = {
+              tool: toolName,
+              code: "TIMEOUT",
+              timestamp: Date.now(),
+            };
+          }
           return err(
             "Tool timed out after 60s. Try a simpler query or run `context-vault reindex` first.",
             "TIMEOUT",
           );
         }
+        if (ctx.toolStats) {
+          ctx.toolStats.errors++;
+          ctx.toolStats.lastError = {
+            tool: toolName,
+            code: "UNKNOWN",
+            timestamp: Date.now(),
+          };
+        }
+        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",
+            meta: {
+              tool: toolName,
+              error_type: e.constructor?.name,
+              cv_version: pkg.version,
+              auto: true,
+            },
+          });
+        } catch {} // never block on feedback capture
         throw e;
       } finally {
         clearTimeout(timer);
@@ -110,7 +145,7 @@ export function registerTools(server, ctx) {
       mod.name,
       mod.description,
       mod.inputSchema,
-      tracked((args) => mod.handler(args, ctx, shared)),
+      tracked((args) => mod.handler(args, ctx, shared), mod.name),
     );
   }
 }