@context-vault/core 2.9.0 → 2.10.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@context-vault/core",
-  "version": "2.9.0",
+  "version": "2.10.0",
   "type": "module",
   "description": "Shared core: capture, index, retrieve, tools, and utilities for context-vault",
   "main": "src/index.js",

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/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),
     );
   }
 }