context-vault 2.8.0 → 2.8.3

package/node_modules/@context-vault/core/src/server/tools/get-context.js

@@ -11,13 +11,36 @@ export const description =
   "Search your knowledge vault. Returns entries ranked by relevance using hybrid full-text + semantic search. Use this to find insights, decisions, patterns, or any saved context. Each result includes an `id` you can use with save_context or delete_context.";
 
 export const inputSchema = {
-  query: z.string().optional().describe("Search query (natural language or keywords). Optional if filters (tags, kind, category) are provided."),
-  kind: z.string().optional().describe("Filter by kind (e.g. 'insight', 'decision', 'pattern')"),
-  category: z.enum(["knowledge", "entity", "event"]).optional().describe("Filter by category"),
-  identity_key: z.string().optional().describe("For entity lookup: exact match on identity key. Requires kind."),
-  tags: z.array(z.string()).optional().describe("Filter by tags (entries must match at least one)"),
-  since: z.string().optional().describe("ISO date, return entries created after this"),
-  until: z.string().optional().describe("ISO date, return entries created before this"),
+  query: z
+    .string()
+    .optional()
+    .describe(
+      "Search query (natural language or keywords). Optional if filters (tags, kind, category) are provided.",
+    ),
+  kind: z
+    .string()
+    .optional()
+    .describe("Filter by kind (e.g. 'insight', 'decision', 'pattern')"),
+  category: z
+    .enum(["knowledge", "entity", "event"])
+    .optional()
+    .describe("Filter by category"),
+  identity_key: z
+    .string()
+    .optional()
+    .describe("For entity lookup: exact match on identity key. Requires kind."),
+  tags: z
+    .array(z.string())
+    .optional()
+    .describe("Filter by tags (entries must match at least one)"),
+  since: z
+    .string()
+    .optional()
+    .describe("ISO date, return entries created after this"),
+  until: z
+    .string()
+    .optional()
+    .describe("ISO date, return entries created before this"),
   limit: z.number().optional().describe("Max results to return (default 10)"),
 };
 
@@ -26,25 +49,42 @@ export const inputSchema = {
  * @param {import('../types.js').BaseCtx & Partial<import('../types.js').HostedCtxExtensions>} ctx
  * @param {import('../types.js').ToolShared} shared
  */
-export async function handler({ query, kind, category, identity_key, tags, since, until, limit }, ctx, { ensureIndexed, reindexFailed }) {
+export async function handler(
+  { query, kind, category, identity_key, tags, since, until, limit },
+  ctx,
+  { ensureIndexed, reindexFailed },
+) {
   const { config } = ctx;
   const userId = ctx.userId !== undefined ? ctx.userId : undefined;
 
   const hasQuery = query?.trim();
-  const hasFilters = kind || category || tags?.length || since || until || identity_key;
-  if (!hasQuery && !hasFilters) return err("Required: query or at least one filter (kind, category, tags, since, until, identity_key)", "INVALID_INPUT");
+  const hasFilters =
+    kind || category || tags?.length || since || until || identity_key;
+  if (!hasQuery && !hasFilters)
+    return err(
+      "Required: query or at least one filter (kind, category, tags, since, until, identity_key)",
+      "INVALID_INPUT",
+    );
   await ensureIndexed();
 
   const kindFilter = kind ? normalizeKind(kind) : null;
 
   // Gap 1: Entity exact-match by identity_key
   if (identity_key) {
-    if (!kindFilter) return err("identity_key requires kind to be specified", "INVALID_INPUT");
-    const match = ctx.stmts.getByIdentityKey.get(kindFilter, identity_key, userId !== undefined ? userId : null);
+    if (!kindFilter)
+      return err("identity_key requires kind to be specified", "INVALID_INPUT");
+    const match = ctx.stmts.getByIdentityKey.get(
+      kindFilter,
+      identity_key,
+      userId !== undefined ? userId : null,
+    );
     if (match) {
       const entryTags = match.tags ? JSON.parse(match.tags) : [];
       const tagStr = entryTags.length ? entryTags.join(", ") : "none";
-      const relPath = match.file_path && config.vaultDir ? match.file_path.replace(config.vaultDir + "/", "") : match.file_path || "n/a";
+      const relPath =
+        match.file_path && config.vaultDir
+          ? match.file_path.replace(config.vaultDir + "/", "")
+          : match.file_path || "n/a";
       const lines = [
         `## Entity Match (exact)\n`,
         `### ${match.title || "(untitled)"} [${match.kind}/${match.category}]`,
@@ -57,7 +97,8 @@ export async function handler({ query, kind, category, identity_key, tags, since
   }
 
   // Gap 2: Event default time-window
-  const effectiveCategory = category || (kindFilter ? categoryFor(kindFilter) : null);
+  const effectiveCategory =
+    category || (kindFilter ? categoryFor(kindFilter) : null);
   let effectiveSince = since || null;
   let effectiveUntil = until || null;
   let autoWindowed = false;
@@ -86,38 +127,64 @@ export async function handler({ query, kind, category, identity_key, tags, since
 
     // Post-filter by tags if provided, then apply requested limit
     filtered = tags?.length
-      ? sorted.filter((r) => {
-          const entryTags = r.tags ? JSON.parse(r.tags) : [];
-          return tags.some((t) => entryTags.includes(t));
-        }).slice(0, effectiveLimit)
+      ? sorted
+          .filter((r) => {
+            const entryTags = r.tags ? JSON.parse(r.tags) : [];
+            return tags.some((t) => entryTags.includes(t));
+          })
+          .slice(0, effectiveLimit)
       : sorted;
   } else {
     // Filter-only mode (no query, use SQL directly)
     const clauses = [];
     const params = [];
-    if (userId !== undefined) { clauses.push("user_id = ?"); params.push(userId); }
-    if (kindFilter) { clauses.push("kind = ?"); params.push(kindFilter); }
-    if (category) { clauses.push("category = ?"); params.push(category); }
-    if (effectiveSince) { clauses.push("created_at >= ?"); params.push(effectiveSince); }
-    if (effectiveUntil) { clauses.push("created_at <= ?"); params.push(effectiveUntil); }
+    if (userId !== undefined) {
+      clauses.push("user_id = ?");
+      params.push(userId);
+    }
+    if (kindFilter) {
+      clauses.push("kind = ?");
+      params.push(kindFilter);
+    }
+    if (category) {
+      clauses.push("category = ?");
+      params.push(category);
+    }
+    if (effectiveSince) {
+      clauses.push("created_at >= ?");
+      params.push(effectiveSince);
+    }
+    if (effectiveUntil) {
+      clauses.push("created_at <= ?");
+      params.push(effectiveUntil);
+    }
     clauses.push("(expires_at IS NULL OR expires_at > datetime('now'))");
     const where = clauses.length ? `WHERE ${clauses.join(" AND ")}` : "";
     params.push(fetchLimit);
-    const rows = ctx.db.prepare(`SELECT * FROM vault ${where} ORDER BY created_at DESC LIMIT ?`).all(...params);
+    const rows = ctx.db
+      .prepare(`SELECT * FROM vault ${where} ORDER BY created_at DESC LIMIT ?`)
+      .all(...params);
 
     // Post-filter by tags if provided, then apply requested limit
     filtered = tags?.length
-      ? rows.filter((r) => {
-          const entryTags = r.tags ? JSON.parse(r.tags) : [];
-          return tags.some((t) => entryTags.includes(t));
-        }).slice(0, effectiveLimit)
+      ? rows
+          .filter((r) => {
+            const entryTags = r.tags ? JSON.parse(r.tags) : [];
+            return tags.some((t) => entryTags.includes(t));
+          })
+          .slice(0, effectiveLimit)
       : rows;
 
     // Add score field for consistent output
     for (const r of filtered) r.score = 0;
   }
 
-  if (!filtered.length) return ok(hasQuery ? "No results found for: " + query : "No entries found matching the given filters.");
+  if (!filtered.length)
+    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) {
@@ -132,22 +199,37 @@ export async function handler({ query, kind, category, identity_key, tags, since
   }
 
   const lines = [];
-  if (reindexFailed) lines.push(`> **Warning:** Auto-reindex failed. Results may be stale. Run \`context-vault reindex\` to fix.\n`);
-  if (hasQuery && isEmbedAvailable() === false) lines.push(`> **Note:** Semantic search unavailable — results ranked by keyword match only. Run \`context-vault setup\` to download the embedding model.\n`);
+  if (reindexFailed)
+    lines.push(
+      `> **Warning:** Auto-reindex failed. Results may be stale. Run \`context-vault reindex\` to fix.\n`,
+    );
+  if (hasQuery && isEmbedAvailable() === false)
+    lines.push(
+      `> **Note:** Semantic search unavailable — results ranked by keyword match only. Run \`context-vault setup\` to download the embedding model.\n`,
+    );
   const heading = hasQuery ? `Results for "${query}"` : "Filtered entries";
   lines.push(`## ${heading} (${filtered.length} matches)\n`);
   for (let i = 0; i < filtered.length; i++) {
     const r = filtered[i];
     const entryTags = r.tags ? JSON.parse(r.tags) : [];
     const tagStr = entryTags.length ? entryTags.join(", ") : "none";
-    const relPath = r.file_path && config.vaultDir ? r.file_path.replace(config.vaultDir + "/", "") : r.file_path || "n/a";
-    lines.push(`### [${i + 1}/${filtered.length}] ${r.title || "(untitled)"} [${r.kind}/${r.category}]`);
-    lines.push(`${r.score.toFixed(3)} · ${tagStr} · ${relPath} · id: \`${r.id}\``);
+    const relPath =
+      r.file_path && config.vaultDir
+        ? r.file_path.replace(config.vaultDir + "/", "")
+        : r.file_path || "n/a";
+    lines.push(
+      `### [${i + 1}/${filtered.length}] ${r.title || "(untitled)"} [${r.kind}/${r.category}]`,
+    );
+    lines.push(
+      `${r.score.toFixed(3)} · ${tagStr} · ${relPath} · id: \`${r.id}\``,
+    );
     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._`);
+    lines.push(
+      `_Showing events from last ${config.eventDecayDays || 30} days. Use since/until for custom range._`,
+    );
   }
   return ok(lines.join("\n"));
 }

package/node_modules/@context-vault/core/src/server/tools/ingest-url.js

@@ -1,12 +1,13 @@
 import { z } from "zod";
 import { captureAndIndex } from "../../capture/index.js";
 import { ok, err, ensureVaultExists } from "../helpers.js";
+import {
+  MAX_KIND_LENGTH,
+  MAX_TAG_LENGTH,
+  MAX_TAGS_COUNT,
+} from "../../constants.js";
 
-// ─── Input size limits (mirrors hosted validation) ────────────────────────────
 const MAX_URL_LENGTH = 2048;
-const MAX_KIND_LENGTH = 64;
-const MAX_TAG_LENGTH = 100;
-const MAX_TAGS_COUNT = 20;
 
 export const name = "ingest_url";
 

package/node_modules/@context-vault/core/src/server/tools/list-context.js

@@ -8,12 +8,30 @@ export const description =
   "Browse vault entries without a search query. Returns id, title, kind, category, tags, created_at. Use get_context with a query for semantic search. Use this to browse by tags or find recent entries.";
 
 export const inputSchema = {
-  kind: z.string().optional().describe("Filter by kind (e.g. 'insight', 'decision', 'pattern')"),
-  category: z.enum(["knowledge", "entity", "event"]).optional().describe("Filter by category"),
-  tags: z.array(z.string()).optional().describe("Filter by tags (entries must match at least one)"),
-  since: z.string().optional().describe("ISO date, return entries created after this"),
-  until: z.string().optional().describe("ISO date, return entries created before this"),
-  limit: z.number().optional().describe("Max results to return (default 20, max 100)"),
+  kind: z
+    .string()
+    .optional()
+    .describe("Filter by kind (e.g. 'insight', 'decision', 'pattern')"),
+  category: z
+    .enum(["knowledge", "entity", "event"])
+    .optional()
+    .describe("Filter by category"),
+  tags: z
+    .array(z.string())
+    .optional()
+    .describe("Filter by tags (entries must match at least one)"),
+  since: z
+    .string()
+    .optional()
+    .describe("ISO date, return entries created after this"),
+  until: z
+    .string()
+    .optional()
+    .describe("ISO date, return entries created before this"),
+  limit: z
+    .number()
+    .optional()
+    .describe("Max results to return (default 20, max 100)"),
   offset: z.number().optional().describe("Skip first N results for pagination"),
 };
 
@@ -22,7 +40,11 @@ export const inputSchema = {
  * @param {import('../types.js').BaseCtx & Partial<import('../types.js').HostedCtxExtensions>} ctx
  * @param {import('../types.js').ToolShared} shared
  */
-export async function handler({ kind, category, tags, since, until, limit, offset }, ctx, { ensureIndexed, reindexFailed }) {
+export async function handler(
+  { kind, category, tags, since, until, limit, offset },
+  ctx,
+  { ensureIndexed, reindexFailed },
+) {
   const { config } = ctx;
   const userId = ctx.userId !== undefined ? ctx.userId : undefined;
 
@@ -60,33 +82,52 @@ export async function handler({ kind, category, tags, since, until, limit, offse
   const fetchLimit = tags?.length ? effectiveLimit * 10 : effectiveLimit;
 
   const countParams = [...params];
-  const total = ctx.db.prepare(`SELECT COUNT(*) as c FROM vault ${where}`).get(...countParams).c;
+  const total = ctx.db
+    .prepare(`SELECT COUNT(*) as c FROM vault ${where}`)
+    .get(...countParams).c;
 
   params.push(fetchLimit, effectiveOffset);
-  const rows = ctx.db.prepare(`SELECT id, title, kind, category, tags, created_at, SUBSTR(body, 1, 120) as preview FROM vault ${where} ORDER BY created_at DESC LIMIT ? OFFSET ?`).all(...params);
+  const rows = ctx.db
+    .prepare(
+      `SELECT id, title, kind, category, tags, created_at, SUBSTR(body, 1, 120) as preview FROM vault ${where} ORDER BY created_at DESC LIMIT ? OFFSET ?`,
+    )
+    .all(...params);
 
   // Post-filter by tags if provided, then apply requested limit
   const filtered = tags?.length
-    ? rows.filter((r) => {
-        const entryTags = r.tags ? JSON.parse(r.tags) : [];
-        return tags.some((t) => entryTags.includes(t));
-      }).slice(0, effectiveLimit)
+    ? rows
+        .filter((r) => {
+          const entryTags = r.tags ? JSON.parse(r.tags) : [];
+          return tags.some((t) => entryTags.includes(t));
+        })
+        .slice(0, effectiveLimit)
     : rows;
 
-  if (!filtered.length) return ok("No entries found matching the given filters.");
+  if (!filtered.length)
+    return ok("No entries found matching the given filters.");
 
   const lines = [];
-  if (reindexFailed) lines.push(`> **Warning:** Auto-reindex failed. Results may be stale. Run \`context-vault reindex\` to fix.\n`);
+  if (reindexFailed)
+    lines.push(
+      `> **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`);
   for (const r of filtered) {
     const entryTags = r.tags ? JSON.parse(r.tags) : [];
     const tagStr = entryTags.length ? entryTags.join(", ") : "none";
-    lines.push(`- **${r.title || "(untitled)"}** [${r.kind}/${r.category}] — ${tagStr} — ${r.created_at} — \`${r.id}\``);
-    if (r.preview) lines.push(`  ${r.preview.replace(/\n+/g, " ").trim()}${r.preview.length >= 120 ? "…" : ""}`);
+    lines.push(
+      `- **${r.title || "(untitled)"}** [${r.kind}/${r.category}] — ${tagStr} — ${r.created_at} — \`${r.id}\``,
+    );
+    if (r.preview)
+      lines.push(
+        `  ${r.preview.replace(/\n+/g, " ").trim()}${r.preview.length >= 120 ? "…" : ""}`,
+      );
   }
 
   if (effectiveOffset + effectiveLimit < total) {
-    lines.push(`\n_Page ${Math.floor(effectiveOffset / effectiveLimit) + 1}. Use offset: ${effectiveOffset + effectiveLimit} for next page._`);
+    lines.push(
+      `\n_Page ${Math.floor(effectiveOffset / effectiveLimit) + 1}. Use offset: ${effectiveOffset + effectiveLimit} for next page._`,
+    );
   }
 
   return ok(lines.join("\n"));

package/node_modules/@context-vault/core/src/server/tools/save-context.js

@@ -4,16 +4,16 @@ import { indexEntry } from "../../index/index.js";
 import { categoryFor } from "../../core/categories.js";
 import { normalizeKind } from "../../core/files.js";
 import { ok, err, ensureVaultExists, ensureValidKind } from "../helpers.js";
-
-// ─── Input size limits (mirrors hosted validation) ────────────────────────────
-const MAX_BODY_LENGTH = 100 * 1024; // 100KB
-const MAX_TITLE_LENGTH = 500;
-const MAX_KIND_LENGTH = 64;
-const MAX_TAG_LENGTH = 100;
-const MAX_TAGS_COUNT = 20;
-const MAX_META_LENGTH = 10 * 1024; // 10KB
-const MAX_SOURCE_LENGTH = 200;
-const MAX_IDENTITY_KEY_LENGTH = 200;
+import {
+  MAX_BODY_LENGTH,
+  MAX_TITLE_LENGTH,
+  MAX_KIND_LENGTH,
+  MAX_TAG_LENGTH,
+  MAX_TAGS_COUNT,
+  MAX_META_LENGTH,
+  MAX_SOURCE_LENGTH,
+  MAX_IDENTITY_KEY_LENGTH,
+} from "../../constants.js";
 
 /**
  * Validate input fields for save_context. Returns an error response or null.

package/node_modules/@context-vault/core/src/server/tools.js

@@ -1,12 +1,3 @@
-/**
- * tools.js — MCP tool registrations (orchestrator)
- *
- * Seven tools: get_context (search), save_context (write/update), list_context (browse),
- * delete_context (remove), submit_feedback (bug/feature reports), ingest_url (fetch+save),
- * context_status (diag).
- * Auto-reindex runs transparently on first tool call per session.
- */
-
 import { reindex } from "../index/index.js";
 import { err } from "./helpers.js";
 
@@ -30,17 +21,9 @@ const toolModules = [
 
 const TOOL_TIMEOUT_MS = 60_000;
 
-/**
- * Register all MCP tools on the server.
- *
- * @param {import("@modelcontextprotocol/sdk/server/mcp.js").McpServer} server
- * @param {import('./types.js').BaseCtx & Partial<import('./types.js').HostedCtxExtensions>} ctx
- */
 export function registerTools(server, ctx) {
   const userId = ctx.userId !== undefined ? ctx.userId : undefined;
 
-  // ─── Tool wrapper: tracks in-flight ops for graceful shutdown + timeout ────
-
   function tracked(handler) {
     return async (...args) => {
       if (ctx.activeOps) ctx.activeOps.count++;
@@ -49,12 +32,18 @@ export function registerTools(server, ctx) {
         return await Promise.race([
           Promise.resolve(handler(...args)),
           new Promise((_, reject) => {
-            timer = setTimeout(() => reject(new Error("TOOL_TIMEOUT")), TOOL_TIMEOUT_MS);
+            timer = setTimeout(
+              () => reject(new Error("TOOL_TIMEOUT")),
+              TOOL_TIMEOUT_MS,
+            );
           }),
         ]);
       } catch (e) {
         if (e.message === "TOOL_TIMEOUT") {
-          return err("Tool timed out after 60s. Try a simpler query or run `context-vault reindex` first.", "TIMEOUT");
+          return err(
+            "Tool timed out after 60s. Try a simpler query or run `context-vault reindex` first.",
+            "TIMEOUT",
+          );
         }
         throw e;
       } finally {
@@ -64,8 +53,6 @@ export function registerTools(server, ctx) {
     };
   }
 
-  // ─── Auto-Reindex (runs once per session, on first tool call) ──────────────
-
   // In hosted mode, skip reindex — DB is always in sync via writeEntry→indexEntry
   let reindexDone = userId !== undefined ? true : false;
   let reindexPromise = null;
@@ -82,14 +69,20 @@ export function registerTools(server, ctx) {
         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)`);
+          console.error(
+            `[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}`);
+        console.error(
+          `[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.`);
+          console.error(
+            `[context-vault] Giving up on auto-reindex. Run \`context-vault reindex\` manually to diagnose.`,
+          );
           reindexDone = true;
           reindexFailed = true;
         } else {
@@ -100,16 +93,19 @@ export function registerTools(server, ctx) {
     return reindexPromise;
   }
 
-  // ─── Register all tool handlers ─────────────────────────────────────────────
-
-  const shared = { ensureIndexed, get reindexFailed() { return reindexFailed; } };
+  const shared = {
+    ensureIndexed,
+    get reindexFailed() {
+      return reindexFailed;
+    },
+  };
 
   for (const mod of toolModules) {
     server.tool(
       mod.name,
       mod.description,
       mod.inputSchema,
-      tracked((args) => mod.handler(args, ctx, shared))
+      tracked((args) => mod.handler(args, ctx, shared)),
     );
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "context-vault",
-  "version": "2.8.0",
+  "version": "2.8.3",
   "type": "module",
   "description": "Persistent memory for AI agents — saves and searches knowledge across sessions",
   "bin": {
@@ -56,7 +56,7 @@
     "@context-vault/core"
   ],
   "dependencies": {
-    "@context-vault/core": "^2.8.0",
+    "@context-vault/core": "^2.8.3",
     "@modelcontextprotocol/sdk": "^1.26.0",
     "better-sqlite3": "^12.6.2",
     "sqlite-vec": "^0.1.0"