context-vault 2.7.1 → 2.8.3

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

@@ -19,7 +19,8 @@ export const inputSchema = {
 export async function handler({ id }, ctx, { ensureIndexed }) {
   const userId = ctx.userId !== undefined ? ctx.userId : undefined;
 
-  if (!id?.trim()) return err("Required: id (non-empty string)", "INVALID_INPUT");
+  if (!id?.trim())
+    return err("Required: id (non-empty string)", "INVALID_INPUT");
   await ensureIndexed();
 
   const entry = ctx.stmts.getEntryById.get(id);
@@ -32,13 +33,17 @@ export async function handler({ id }, ctx, { ensureIndexed }) {
 
   // Delete file from disk first (source of truth)
   if (entry.file_path) {
-    try { unlinkSync(entry.file_path); } catch {}
+    try {
+      unlinkSync(entry.file_path);
+    } catch {}
   }
 
   // Delete vector embedding
   const rowidResult = ctx.stmts.getRowid.get(id);
   if (rowidResult?.rowid) {
-    try { ctx.deleteVec(Number(rowidResult.rowid)); } catch {}
+    try {
+      ctx.deleteVec(Number(rowidResult.rowid));
+    } catch {}
   }
 
   // Delete DB row (FTS trigger handles FTS cleanup)

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,13 +1,13 @@
 import { z } from "zod";
 import { captureAndIndex } from "../../capture/index.js";
-import { indexEntry } from "../../index/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";
 
@@ -25,26 +25,40 @@ export const inputSchema = {
  * @param {import('../types.js').BaseCtx & Partial<import('../types.js').HostedCtxExtensions>} ctx
  * @param {import('../types.js').ToolShared} shared
  */
-export async function handler({ url: targetUrl, kind, tags }, ctx, { ensureIndexed }) {
+export async function handler(
+  { url: targetUrl, kind, tags },
+  ctx,
+  { ensureIndexed },
+) {
   const { config } = ctx;
   const userId = ctx.userId !== undefined ? ctx.userId : undefined;
 
   const vaultErr = ensureVaultExists(config);
   if (vaultErr) return vaultErr;
 
-  if (!targetUrl?.trim()) return err("Required: url (non-empty string)", "INVALID_INPUT");
-  if (targetUrl.length > MAX_URL_LENGTH) return err(`url must be under ${MAX_URL_LENGTH} chars`, "INVALID_INPUT");
+  if (!targetUrl?.trim())
+    return err("Required: url (non-empty string)", "INVALID_INPUT");
+  if (targetUrl.length > MAX_URL_LENGTH)
+    return err(`url must be under ${MAX_URL_LENGTH} chars`, "INVALID_INPUT");
   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 (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",
+        );
       }
     }
   }
@@ -55,15 +69,20 @@ export async function handler({ url: targetUrl, kind, tags }, ctx, { ensureIndex
   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",
+      );
     }
   }
 
   try {
     const { ingestUrl } = await import("../../capture/ingest-url.js");
     const entryData = await ingestUrl(targetUrl, { kind, tags });
-    const entry = await captureAndIndex(ctx, { ...entryData, userId }, indexEntry);
-    const relPath = entry.filePath ? entry.filePath.replace(config.vaultDir + "/", "") : entry.filePath;
+    const entry = await captureAndIndex(ctx, { ...entryData, userId });
+    const relPath = entry.filePath
+      ? entry.filePath.replace(config.vaultDir + "/", "")
+      : entry.filePath;
     const parts = [
       `✓ Ingested URL → ${relPath}`,
       `  id: ${entry.id}`,

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"));