context-vault 2.7.1 → 2.8.3

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

@@ -4,59 +4,93 @@ 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.
  */
-function validateSaveInput({ kind, title, body, tags, meta, source, identity_key }) {
+function validateSaveInput({
+  kind,
+  title,
+  body,
+  tags,
+  meta,
+  source,
+  identity_key,
+}) {
   if (kind !== undefined && kind !== null) {
     if (typeof kind !== "string" || kind.length > MAX_KIND_LENGTH) {
-      return err(`kind must be a string, max ${MAX_KIND_LENGTH} chars`, "INVALID_INPUT");
+      return err(
+        `kind must be a string, max ${MAX_KIND_LENGTH} chars`,
+        "INVALID_INPUT",
+      );
     }
   }
   if (body !== undefined && body !== null) {
     if (typeof body !== "string" || body.length > MAX_BODY_LENGTH) {
-      return err(`body must be a string, max ${MAX_BODY_LENGTH / 1024}KB`, "INVALID_INPUT");
+      return err(
+        `body must be a string, max ${MAX_BODY_LENGTH / 1024}KB`,
+        "INVALID_INPUT",
+      );
     }
   }
   if (title !== undefined && title !== null) {
     if (typeof title !== "string" || title.length > MAX_TITLE_LENGTH) {
-      return err(`title must be a string, max ${MAX_TITLE_LENGTH} chars`, "INVALID_INPUT");
+      return err(
+        `title must be a string, max ${MAX_TITLE_LENGTH} chars`,
+        "INVALID_INPUT",
+      );
     }
   }
   if (tags !== undefined && tags !== null) {
-    if (!Array.isArray(tags)) return err("tags must be an array of strings", "INVALID_INPUT");
-    if (tags.length > MAX_TAGS_COUNT) return err(`tags: max ${MAX_TAGS_COUNT} tags allowed`, "INVALID_INPUT");
+    if (!Array.isArray(tags))
+      return err("tags must be an array of strings", "INVALID_INPUT");
+    if (tags.length > MAX_TAGS_COUNT)
+      return err(`tags: max ${MAX_TAGS_COUNT} tags allowed`, "INVALID_INPUT");
     for (const tag of tags) {
       if (typeof tag !== "string" || tag.length > MAX_TAG_LENGTH) {
-        return err(`each tag must be a string, max ${MAX_TAG_LENGTH} chars`, "INVALID_INPUT");
+        return err(
+          `each tag must be a string, max ${MAX_TAG_LENGTH} chars`,
+          "INVALID_INPUT",
+        );
       }
     }
   }
   if (meta !== undefined && meta !== null) {
     const metaStr = JSON.stringify(meta);
     if (metaStr.length > MAX_META_LENGTH) {
-      return err(`meta must be under ${MAX_META_LENGTH / 1024}KB when serialized`, "INVALID_INPUT");
+      return err(
+        `meta must be under ${MAX_META_LENGTH / 1024}KB when serialized`,
+        "INVALID_INPUT",
+      );
     }
   }
   if (source !== undefined && source !== null) {
     if (typeof source !== "string" || source.length > MAX_SOURCE_LENGTH) {
-      return err(`source must be a string, max ${MAX_SOURCE_LENGTH} chars`, "INVALID_INPUT");
+      return err(
+        `source must be a string, max ${MAX_SOURCE_LENGTH} chars`,
+        "INVALID_INPUT",
+      );
     }
   }
   if (identity_key !== undefined && identity_key !== null) {
-    if (typeof identity_key !== "string" || identity_key.length > MAX_IDENTITY_KEY_LENGTH) {
-      return err(`identity_key must be a string, max ${MAX_IDENTITY_KEY_LENGTH} chars`, "INVALID_INPUT");
+    if (
+      typeof identity_key !== "string" ||
+      identity_key.length > MAX_IDENTITY_KEY_LENGTH
+    ) {
+      return err(
+        `identity_key must be a string, max ${MAX_IDENTITY_KEY_LENGTH} chars`,
+        "INVALID_INPUT",
+      );
     }
   }
   return null;
@@ -68,15 +102,44 @@ export const description =
   "Save knowledge to your vault. Creates a .md file and indexes it for search. Use for any kind of context: insights, decisions, patterns, references, or any custom kind. To update an existing entry, pass its `id` — omitted fields are preserved.";
 
 export const inputSchema = {
-  id: z.string().optional().describe("Entry ULID to update. When provided, updates the existing entry instead of creating new. Omitted fields are preserved."),
-  kind: z.string().optional().describe("Entry kind — determines folder (e.g. 'insight', 'decision', 'pattern', 'reference', or any custom kind). Required for new entries."),
+  id: z
+    .string()
+    .optional()
+    .describe(
+      "Entry ULID to update. When provided, updates the existing entry instead of creating new. Omitted fields are preserved.",
+    ),
+  kind: z
+    .string()
+    .optional()
+    .describe(
+      "Entry kind — determines folder (e.g. 'insight', 'decision', 'pattern', 'reference', or any custom kind). Required for new entries.",
+    ),
   title: z.string().optional().describe("Entry title (optional for insights)"),
-  body: z.string().optional().describe("Main content. Required for new entries."),
-  tags: z.array(z.string()).optional().describe("Tags for categorization and search"),
-  meta: z.any().optional().describe("Additional structured metadata (JSON object, e.g. { language: 'js', status: 'accepted' })"),
-  folder: z.string().optional().describe("Subfolder within the kind directory (e.g. 'react/hooks')"),
+  body: z
+    .string()
+    .optional()
+    .describe("Main content. Required for new entries."),
+  tags: z
+    .array(z.string())
+    .optional()
+    .describe("Tags for categorization and search"),
+  meta: z
+    .any()
+    .optional()
+    .describe(
+      "Additional structured metadata (JSON object, e.g. { language: 'js', status: 'accepted' })",
+    ),
+  folder: z
+    .string()
+    .optional()
+    .describe("Subfolder within the kind directory (e.g. 'react/hooks')"),
   source: z.string().optional().describe("Where this knowledge came from"),
-  identity_key: z.string().optional().describe("Required for entity kinds (contact, project, tool, source). The unique identifier for this entity."),
+  identity_key: z
+    .string()
+    .optional()
+    .describe(
+      "Required for entity kinds (contact, project, tool, source). The unique identifier for this entity.",
+    ),
   expires_at: z.string().optional().describe("ISO date for TTL expiry"),
 };
 
@@ -85,14 +148,37 @@ export const inputSchema = {
  * @param {import('../types.js').BaseCtx & Partial<import('../types.js').HostedCtxExtensions>} ctx
  * @param {import('../types.js').ToolShared} shared
  */
-export async function handler({ id, kind, title, body, tags, meta, folder, source, identity_key, expires_at }, ctx, { ensureIndexed }) {
+export async function handler(
+  {
+    id,
+    kind,
+    title,
+    body,
+    tags,
+    meta,
+    folder,
+    source,
+    identity_key,
+    expires_at,
+  },
+  ctx,
+  { ensureIndexed },
+) {
   const { config } = ctx;
   const userId = ctx.userId !== undefined ? ctx.userId : undefined;
 
   const vaultErr = ensureVaultExists(config);
   if (vaultErr) return vaultErr;
 
-  const inputErr = validateSaveInput({ kind, title, body, tags, meta, source, identity_key });
+  const inputErr = validateSaveInput({
+    kind,
+    title,
+    body,
+    tags,
+    meta,
+    source,
+    identity_key,
+  });
   if (inputErr) return inputErr;
 
   // ── Update mode ──
@@ -108,10 +194,16 @@ export async function handler({ id, kind, title, body, tags, meta, folder, sourc
     }
 
     if (kind && normalizeKind(kind) !== existing.kind) {
-      return err(`Cannot change kind (current: "${existing.kind}"). Delete and re-create instead.`, "INVALID_UPDATE");
+      return err(
+        `Cannot change kind (current: "${existing.kind}"). Delete and re-create instead.`,
+        "INVALID_UPDATE",
+      );
     }
     if (identity_key && identity_key !== existing.identity_key) {
-      return err(`Cannot change identity_key (current: "${existing.identity_key}"). Delete and re-create instead.`, "INVALID_UPDATE");
+      return err(
+        `Cannot change identity_key (current: "${existing.identity_key}"). Delete and re-create instead.`,
+        "INVALID_UPDATE",
+      );
     }
 
     // Decrypt existing entry before merge if encrypted
@@ -122,9 +214,18 @@ export async function handler({ id, kind, title, body, tags, meta, folder, sourc
       if (decrypted.meta) existing.meta = JSON.stringify(decrypted.meta);
     }
 
-    const entry = updateEntryFile(ctx, existing, { title, body, tags, meta, source, expires_at });
+    const entry = updateEntryFile(ctx, existing, {
+      title,
+      body,
+      tags,
+      meta,
+      source,
+      expires_at,
+    });
     await indexEntry(ctx, entry);
-    const relPath = entry.filePath ? entry.filePath.replace(config.vaultDir + "/", "") : entry.filePath;
+    const relPath = entry.filePath
+      ? entry.filePath.replace(config.vaultDir + "/", "")
+      : entry.filePath;
     const parts = [`✓ Updated ${entry.kind} → ${relPath}`, `  id: ${entry.id}`];
     if (entry.title) parts.push(`  title: ${entry.title}`);
     const entryTags = entry.tags || [];
@@ -137,23 +238,33 @@ export async function handler({ id, kind, title, body, tags, meta, folder, sourc
   if (!kind) return err("Required: kind (for new entries)", "INVALID_INPUT");
   const kindErr = ensureValidKind(kind);
   if (kindErr) return kindErr;
-  if (!body?.trim()) return err("Required: body (for new entries)", "INVALID_INPUT");
+  if (!body?.trim())
+    return err("Required: body (for new entries)", "INVALID_INPUT");
 
   // Normalize kind to canonical singular form (e.g. "insights" → "insight")
   const normalizedKind = normalizeKind(kind);
 
   if (categoryFor(normalizedKind) === "entity" && !identity_key) {
-    return err(`Entity kind "${normalizedKind}" requires identity_key`, "MISSING_IDENTITY_KEY");
+    return err(
+      `Entity kind "${normalizedKind}" requires identity_key`,
+      "MISSING_IDENTITY_KEY",
+    );
   }
 
   // Hosted tier limit enforcement (skipped in local mode — no checkLimits on ctx)
   if (ctx.checkLimits) {
     const usage = ctx.checkLimits();
     if (usage.entryCount >= usage.maxEntries) {
-      return err(`Entry limit reached (${usage.maxEntries}). Upgrade to Pro for unlimited entries.`, "LIMIT_EXCEEDED");
+      return err(
+        `Entry limit reached (${usage.maxEntries}). Upgrade to Pro for unlimited entries.`,
+        "LIMIT_EXCEEDED",
+      );
     }
     if (usage.storageMb >= usage.maxStorageMb) {
-      return err(`Storage limit reached (${usage.maxStorageMb} MB). Upgrade to Pro for more storage.`, "LIMIT_EXCEEDED");
+      return err(
+        `Storage limit reached (${usage.maxStorageMb} MB). Upgrade to Pro for more storage.`,
+        "LIMIT_EXCEEDED",
+      );
     }
   }
 
@@ -163,8 +274,21 @@ export async function handler({ id, kind, title, body, tags, meta, folder, sourc
   if (folder) mergedMeta.folder = folder;
   const finalMeta = Object.keys(mergedMeta).length ? mergedMeta : undefined;
 
-  const entry = await captureAndIndex(ctx, { kind: normalizedKind, title, body, meta: finalMeta, tags, source, folder, identity_key, expires_at, userId }, indexEntry);
-  const relPath = entry.filePath ? entry.filePath.replace(config.vaultDir + "/", "") : entry.filePath;
+  const entry = await captureAndIndex(ctx, {
+    kind: normalizedKind,
+    title,
+    body,
+    meta: finalMeta,
+    tags,
+    source,
+    folder,
+    identity_key,
+    expires_at,
+    userId,
+  });
+  const relPath = entry.filePath
+    ? entry.filePath.replace(config.vaultDir + "/", "")
+    : entry.filePath;
   const parts = [`✓ Saved ${normalizedKind} → ${relPath}`, `  id: ${entry.id}`];
   if (title) parts.push(`  title: ${title}`);
   if (tags?.length) parts.push(`  tags: ${tags.join(", ")}`);

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

@@ -1,6 +1,5 @@
 import { z } from "zod";
 import { captureAndIndex } from "../../capture/index.js";
-import { indexEntry } from "../../index/index.js";
 import { ok, ensureVaultExists } from "../helpers.js";
 
 export const name = "submit_feedback";
@@ -12,7 +11,10 @@ export const inputSchema = {
   type: z.enum(["bug", "feature", "improvement"]).describe("Type of feedback"),
   title: z.string().describe("Short summary of the feedback"),
   body: z.string().describe("Detailed description"),
-  severity: z.enum(["low", "medium", "high"]).optional().describe("Severity level (default: medium)"),
+  severity: z
+    .enum(["low", "medium", "high"])
+    .optional()
+    .describe("Severity level (default: medium)"),
 };
 
 /**
@@ -20,7 +22,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({ type, title, body, severity }, ctx, { ensureIndexed }) {
+export async function handler(
+  { type, title, body, severity },
+  ctx,
+  { ensureIndexed },
+) {
   const { config } = ctx;
   const userId = ctx.userId !== undefined ? ctx.userId : undefined;
 
@@ -30,20 +36,20 @@ export async function handler({ type, title, body, severity }, ctx, { ensureInde
   await ensureIndexed();
 
   const effectiveSeverity = severity || "medium";
-  const entry = await captureAndIndex(
-    ctx,
-    {
-      kind: "feedback",
-      title,
-      body,
-      tags: [type, effectiveSeverity],
-      source: "submit_feedback",
-      meta: { feedback_type: type, severity: effectiveSeverity, status: "new" },
-      userId,
-    },
-    indexEntry
+  const entry = await captureAndIndex(ctx, {
+    kind: "feedback",
+    title,
+    body,
+    tags: [type, effectiveSeverity],
+    source: "submit_feedback",
+    meta: { feedback_type: type, severity: effectiveSeverity, status: "new" },
+    userId,
+  });
+
+  const relPath = entry.filePath
+    ? entry.filePath.replace(config.vaultDir + "/", "")
+    : entry.filePath;
+  return ok(
+    `Feedback submitted: ${type} [${effectiveSeverity}] → ${relPath}\n  id: ${entry.id}\n  title: ${title}`,
   );
-
-  const relPath = entry.filePath ? entry.filePath.replace(config.vaultDir + "/", "") : entry.filePath;
-  return ok(`Feedback submitted: ${type} [${effectiveSeverity}] → ${relPath}\n  id: ${entry.id}\n  title: ${title}`);
 }

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/node_modules/@context-vault/core/src/sync/sync.js

@@ -9,7 +9,6 @@
  */
 
 import { captureAndIndex } from "../capture/index.js";
-import { indexEntry } from "../index/index.js";
 
 /**
  * Build a manifest of local vault entries (id → { id, created_at, kind, title }).
@@ -19,7 +18,9 @@ import { indexEntry } from "../index/index.js";
  */
 export function buildLocalManifest(ctx) {
   const rows = ctx.db
-    .prepare("SELECT id, created_at, kind, title FROM vault WHERE (expires_at IS NULL OR expires_at > datetime('now'))")
+    .prepare(
+      "SELECT id, created_at, kind, title FROM vault WHERE (expires_at IS NULL OR expires_at > datetime('now'))",
+    )
     .all();
 
   const manifest = new Map();
@@ -111,7 +112,10 @@ export function computeSyncPlan(local, remote) {
  * @param {{ hostedUrl: string, apiKey: string, plan: SyncPlan, onProgress?: (phase: string, current: number, total: number) => void }} opts
  * @returns {Promise<{ pushed: number, pulled: number, failed: number, errors: string[] }>}
  */
-export async function executeSync(ctx, { hostedUrl, apiKey, plan, onProgress }) {
+export async function executeSync(
+  ctx,
+  { hostedUrl, apiKey, plan, onProgress },
+) {
   let pushed = 0;
   let pulled = 0;
   let failed = 0;
@@ -157,7 +161,9 @@ export async function executeSync(ctx, { hostedUrl, apiKey, plan, onProgress })
         if (!response.ok) {
           const errData = await response.json().catch(() => ({}));
           failed += batch.length;
-          errors.push(`Push batch failed: HTTP ${response.status} — ${errData.error || "unknown"}`);
+          errors.push(
+            `Push batch failed: HTTP ${response.status} — ${errData.error || "unknown"}`,
+          );
           continue;
         }
 
@@ -199,21 +205,20 @@ export async function executeSync(ctx, { hostedUrl, apiKey, plan, onProgress })
         if (onProgress) onProgress("pull", i + 1, entriesToPull.length);
 
         try {
-          await captureAndIndex(
-            ctx,
-            {
-              kind: entry.kind,
-              title: entry.title,
-              body: entry.body,
-              meta: entry.meta && typeof entry.meta === "object" ? entry.meta : undefined,
-              tags: Array.isArray(entry.tags) ? entry.tags : undefined,
-              source: entry.source || "sync-pull",
-              identity_key: entry.identity_key,
-              expires_at: entry.expires_at,
-              userId: ctx.userId || null,
-            },
-            indexEntry
-          );
+          await captureAndIndex(ctx, {
+            kind: entry.kind,
+            title: entry.title,
+            body: entry.body,
+            meta:
+              entry.meta && typeof entry.meta === "object"
+                ? entry.meta
+                : undefined,
+            tags: Array.isArray(entry.tags) ? entry.tags : undefined,
+            source: entry.source || "sync-pull",
+            identity_key: entry.identity_key,
+            expires_at: entry.expires_at,
+            userId: ctx.userId || null,
+          });
           pulled++;
         } catch (err) {
           failed++;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "context-vault",
-  "version": "2.7.1",
+  "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.7.1",
+    "@context-vault/core": "^2.8.3",
     "@modelcontextprotocol/sdk": "^1.26.0",
     "better-sqlite3": "^12.6.2",
     "sqlite-vec": "^0.1.0"