@context-vault/core 2.10.3 → 2.12.0

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

@@ -4,6 +4,7 @@ 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";
+import { maybeShowFeedbackPrompt } from "../../core/telemetry.js";
 import {
   MAX_BODY_LENGTH,
   MAX_TITLE_LENGTH,
@@ -15,6 +16,63 @@ import {
   MAX_IDENTITY_KEY_LENGTH,
 } from "../../constants.js";
 
+const DEFAULT_SIMILARITY_THRESHOLD = 0.85;
+
+async function findSimilar(ctx, embedding, threshold, userId) {
+  try {
+    const vecCount = ctx.db
+      .prepare("SELECT COUNT(*) as c FROM vault_vec")
+      .get().c;
+    if (vecCount === 0) return [];
+
+    const vecRows = ctx.db
+      .prepare(
+        `SELECT v.rowid, v.distance FROM vault_vec v WHERE embedding MATCH ? ORDER BY distance LIMIT ?`,
+      )
+      .all(embedding, 10);
+
+    if (!vecRows.length) return [];
+
+    const rowids = vecRows.map((vr) => vr.rowid);
+    const placeholders = rowids.map(() => "?").join(",");
+    const hydrated = ctx.db
+      .prepare(
+        `SELECT rowid, id, title, category, user_id FROM vault WHERE rowid IN (${placeholders})`,
+      )
+      .all(...rowids);
+
+    const byRowid = new Map();
+    for (const row of hydrated) byRowid.set(row.rowid, row);
+
+    const results = [];
+    for (const vr of vecRows) {
+      const similarity = Math.max(0, 1 - vr.distance / 2);
+      if (similarity < threshold) continue;
+      const row = byRowid.get(vr.rowid);
+      if (!row) continue;
+      if (userId !== undefined && row.user_id !== userId) continue;
+      if (row.category === "entity") continue;
+      results.push({ id: row.id, title: row.title, score: similarity });
+    }
+    return results;
+  } catch {
+    return [];
+  }
+}
+
+function formatSimilarWarning(similar) {
+  const lines = ["", "⚠ Similar entries already exist:"];
+  for (const e of similar) {
+    const score = e.score.toFixed(2);
+    const title = e.title ? `"${e.title}"` : "(no title)";
+    lines.push(`  - ${title} (${score}) — id: ${e.id}`);
+  }
+  lines.push(
+    "  Consider using `id: <existing>` in save_context to update instead.",
+  );
+  return lines.join("\n");
+}
+
 /**
  * Validate input fields for save_context. Returns an error response or null.
  */
@@ -150,6 +208,26 @@ export const inputSchema = {
       "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"),
+  supersedes: z
+    .array(z.string())
+    .optional()
+    .describe(
+      "Array of entry IDs that this entry supersedes/replaces. Those entries will be marked with superseded_by pointing to this new entry and excluded from future search results by default.",
+    ),
+  dry_run: z
+    .boolean()
+    .optional()
+    .describe(
+      "If true, check for similar entries without saving. Returns similarity results without creating a new entry. Only applies to knowledge and event categories.",
+    ),
+  similarity_threshold: z
+    .number()
+    .min(0)
+    .max(1)
+    .optional()
+    .describe(
+      "Cosine similarity threshold for duplicate detection (0–1, default 0.85). Entries above this score are flagged as similar. Only applies to knowledge and event categories.",
+    ),
 };
 
 /**
@@ -169,6 +247,9 @@ export async function handler(
     source,
     identity_key,
     expires_at,
+    supersedes,
+    dry_run,
+    similarity_threshold,
   },
   ctx,
   { ensureIndexed },
@@ -231,6 +312,7 @@ export async function handler(
       meta,
       source,
       expires_at,
+      supersedes,
     });
     await indexEntry(ctx, entry);
     const relPath = entry.filePath
@@ -261,25 +343,45 @@ export async function handler(
     );
   }
 
-  // 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",
+  await ensureIndexed();
+
+  // ── Similarity check (knowledge + event only) ────────────────────────────
+  const category = categoryFor(normalizedKind);
+  let similarEntries = [];
+
+  if (category === "knowledge" || category === "event") {
+    const threshold = similarity_threshold ?? DEFAULT_SIMILARITY_THRESHOLD;
+    const embeddingText = [title, body].filter(Boolean).join(" ");
+    const queryEmbedding = await ctx.embed(embeddingText);
+    if (queryEmbedding) {
+      similarEntries = await findSimilar(
+        ctx,
+        queryEmbedding,
+        threshold,
+        userId,
       );
     }
-    if (usage.storageMb >= usage.maxStorageMb) {
-      return err(
-        `Storage limit reached (${usage.maxStorageMb} MB). Upgrade to Pro for more storage.`,
-        "LIMIT_EXCEEDED",
+  }
+
+  if (dry_run) {
+    const parts = ["(dry run — nothing saved)"];
+    if (similarEntries.length) {
+      parts.push("", "⚠ Similar entries already exist:");
+      for (const e of similarEntries) {
+        const score = e.score.toFixed(2);
+        const titleDisplay = e.title ? `"${e.title}"` : "(no title)";
+        parts.push(`  - ${titleDisplay} (${score}) — id: ${e.id}`);
+      }
+      parts.push(
+        "",
+        "Use save_context with `id: <existing>` to update one, or omit `dry_run` to save as new.",
       );
+    } else {
+      parts.push("", "No similar entries found. Safe to save.");
     }
+    return ok(parts.join("\n"));
   }
 
-  await ensureIndexed();
-
   const mergedMeta = { ...(meta || {}) };
   if (folder) mergedMeta.folder = folder;
   const finalMeta = Object.keys(mergedMeta).length ? mergedMeta : undefined;
@@ -294,8 +396,14 @@ export async function handler(
     folder,
     identity_key,
     expires_at,
+    supersedes,
     userId,
   });
+
+  if (ctx.config?.dataDir) {
+    maybeShowFeedbackPrompt(ctx.config.dataDir);
+  }
+
   const relPath = entry.filePath
     ? entry.filePath.replace(config.vaultDir + "/", "")
     : entry.filePath;
@@ -303,5 +411,28 @@ export async function handler(
   if (title) parts.push(`  title: ${title}`);
   if (tags?.length) parts.push(`  tags: ${tags.join(", ")}`);
   parts.push("", "_Use this id to update or delete later._");
+  if (similarEntries.length) {
+    parts.push(formatSimilarWarning(similarEntries));
+  }
+
+  const criticalLimit = config.thresholds?.totalEntries?.critical;
+  if (criticalLimit != null) {
+    try {
+      const countRow = ctx.db
+        .prepare(
+          userId !== undefined
+            ? "SELECT COUNT(*) as c FROM vault WHERE user_id = ?"
+            : "SELECT COUNT(*) as c FROM vault",
+        )
+        .get(...(userId !== undefined ? [userId] : []));
+      if (countRow.c >= criticalLimit) {
+        parts.push(
+          ``,
+          `ℹ Vault has ${countRow.c.toLocaleString()} entries. Consider running \`context-vault reindex\` or reviewing old entries.`,
+        );
+      }
+    } catch {}
+  }
+
   return ok(parts.join("\n"));
 }

package/src/server/tools.js

@@ -1,6 +1,7 @@
 import { reindex } from "../index/index.js";
 import { captureAndIndex } from "../capture/index.js";
 import { err } from "./helpers.js";
+import { sendTelemetryEvent } from "../core/telemetry.js";
 import pkg from "../../package.json" with { type: "json" };
 
 import * as getContext from "./tools/get-context.js";
@@ -57,6 +58,12 @@ export function registerTools(server, ctx) {
               timestamp: Date.now(),
             };
           }
+          sendTelemetryEvent(ctx.config, {
+            event: "tool_error",
+            code: "TIMEOUT",
+            tool: toolName,
+            cv_version: pkg.version,
+          });
           return err(
             "Tool timed out after 60s. Try a simpler query or run `context-vault reindex` first.",
             "TIMEOUT",
@@ -70,6 +77,12 @@ export function registerTools(server, ctx) {
             timestamp: Date.now(),
           };
         }
+        sendTelemetryEvent(ctx.config, {
+          event: "tool_error",
+          code: "UNKNOWN",
+          tool: toolName,
+          cv_version: pkg.version,
+        });
         try {
           await captureAndIndex(ctx, {
             kind: "feedback",