@context-vault/core 3.1.4 → 3.1.5

package/src/index.ts

@@ -12,12 +12,27 @@ const EMBED_BATCH_SIZE = 32;
 
 export async function indexEntry(
   ctx: BaseCtx,
-  entry: IndexEntryInput & { supersedes?: string[] | null; related_to?: string[] | null },
+  entry: IndexEntryInput & {
+    supersedes?: string[] | null;
+    related_to?: string[] | null;
+  },
   precomputedEmbedding?: Float32Array | null,
 ): Promise<void> {
   const {
-    id, kind, category, title, body, meta, tags, source,
-    filePath, createdAt, identity_key, expires_at, source_files, tier,
+    id,
+    kind,
+    category,
+    title,
+    body,
+    meta,
+    tags,
+    source,
+    filePath,
+    createdAt,
+    identity_key,
+    expires_at,
+    source_files,
+    tier,
   } = entry;
 
   if (expires_at && new Date(expires_at) <= new Date()) return;
@@ -31,13 +46,22 @@ export async function indexEntry(
   let wasUpdate = false;
 
   if (cat === "entity" && identity_key) {
-    const existing = ctx.stmts.getByIdentityKey.get(kind, identity_key) as Record<string, unknown> | undefined;
+    const existing = ctx.stmts.getByIdentityKey.get(kind, identity_key) as
+      | Record<string, unknown>
+      | undefined;
     if (existing) {
       ctx.stmts.upsertByIdentityKey.run(
-        title || null, body, metaJson, tagsJson,
-        source || "claude-code", cat, filePath,
-        expires_at || null, sourceFilesJson,
-        kind, identity_key,
+        title || null,
+        body,
+        metaJson,
+        tagsJson,
+        source || "claude-code",
+        cat,
+        filePath,
+        expires_at || null,
+        sourceFilesJson,
+        kind,
+        identity_key,
       );
       wasUpdate = true;
     }
@@ -46,20 +70,39 @@ export async function indexEntry(
   if (!wasUpdate) {
     try {
       ctx.stmts.insertEntry.run(
-        id, kind, cat, title || null, body, metaJson, tagsJson,
-        source || "claude-code", filePath,
-        identity_key || null, expires_at || null,
-        createdAt, createdAt, sourceFilesJson, effectiveTier,
+        id,
+        kind,
+        cat,
+        title || null,
+        body,
+        metaJson,
+        tagsJson,
+        source || "claude-code",
+        filePath,
+        identity_key || null,
+        expires_at || null,
+        createdAt,
+        createdAt,
+        sourceFilesJson,
+        effectiveTier,
       );
     } catch (e) {
       if ((e as Error).message.includes("UNIQUE constraint")) {
         ctx.stmts.updateEntry.run(
-          title || null, body, metaJson, tagsJson,
-          source || "claude-code", cat,
-          identity_key || null, expires_at || null, filePath,
+          title || null,
+          body,
+          metaJson,
+          tagsJson,
+          source || "claude-code",
+          cat,
+          identity_key || null,
+          expires_at || null,
+          filePath,
         );
         if (sourceFilesJson !== null && ctx.stmts.updateSourceFiles) {
-          const entryRow = ctx.stmts.getRowidByPath.get(filePath) as { rowid: number } | undefined;
+          const entryRow = ctx.stmts.getRowidByPath.get(filePath) as
+            | { rowid: number }
+            | undefined;
           if (entryRow) {
             const idRow = ctx.db
               .prepare("SELECT id FROM vault WHERE file_path = ?")
@@ -76,8 +119,8 @@ export async function indexEntry(
   }
 
   const rowidResult = wasUpdate
-    ? ctx.stmts.getRowidByPath.get(filePath) as { rowid: number } | undefined
-    : ctx.stmts.getRowid.get(id) as { rowid: number } | undefined;
+    ? (ctx.stmts.getRowidByPath.get(filePath) as { rowid: number } | undefined)
+    : (ctx.stmts.getRowid.get(id) as { rowid: number } | undefined);
 
   if (!rowidResult || rowidResult.rowid == null) {
     throw new Error(
@@ -100,12 +143,18 @@ export async function indexEntry(
       try {
         embedding = await ctx.embed([title, body].filter(Boolean).join(" "));
       } catch (embedErr) {
-        console.warn(`[context-vault] embed() failed for entry ${id} — skipping vec insert: ${(embedErr as Error).message}`);
+        console.warn(
+          `[context-vault] embed() failed for entry ${id} — skipping vec insert: ${(embedErr as Error).message}`,
+        );
       }
     }
 
     if (embedding) {
-      try { ctx.deleteVec(rowid); } catch { /* no-op */ }
+      try {
+        ctx.deleteVec(rowid);
+      } catch {
+        /* no-op */
+      }
       ctx.insertVec(rowid, embedding);
     }
   }
@@ -120,11 +169,17 @@ export async function pruneExpired(ctx: BaseCtx): Promise<number> {
 
   for (const row of expired) {
     if (row.file_path) {
-      try { unlinkSync(row.file_path); } catch {}
+      try {
+        unlinkSync(row.file_path);
+      } catch {}
     }
-    const vRowid = (ctx.stmts.getRowid.get(row.id) as { rowid: number } | undefined)?.rowid;
+    const vRowid = (
+      ctx.stmts.getRowid.get(row.id) as { rowid: number } | undefined
+    )?.rowid;
     if (vRowid) {
-      try { ctx.deleteVec(Number(vRowid)); } catch {}
+      try {
+        ctx.deleteVec(Number(vRowid));
+      } catch {}
     }
     ctx.stmts.deleteEntry.run(row.id);
   }
@@ -137,7 +192,12 @@ export async function reindex(
   opts: { fullSync?: boolean } = {},
 ): Promise<ReindexStats> {
   const { fullSync = true } = opts;
-  const stats: ReindexStats = { added: 0, updated: 0, removed: 0, unchanged: 0 };
+  const stats: ReindexStats = {
+    added: 0,
+    updated: 0,
+    removed: 0,
+    unchanged: 0,
+  };
 
   if (!existsSync(ctx.config.vaultDir)) return stats;
 
@@ -224,20 +284,32 @@ export async function reindex(
         if (!existing) {
           const id = (fmMeta.id as string) || ulid();
           const tagsJson = fmMeta.tags ? JSON.stringify(fmMeta.tags) : null;
-          const created = (fmMeta.created as string) || new Date().toISOString();
+          const created =
+            (fmMeta.created as string) || new Date().toISOString();
 
           const result = upsertEntry.run(
-            id, kind, category, parsed.title || null, parsed.body,
-            metaJson, tagsJson, (fmMeta.source as string) || "file",
-            filePath, identity_key, expires_at,
-            created, (fmMeta.updated as string) || created,
+            id,
+            kind,
+            category,
+            parsed.title || null,
+            parsed.body,
+            metaJson,
+            tagsJson,
+            (fmMeta.source as string) || "file",
+            filePath,
+            identity_key,
+            expires_at,
+            created,
+            (fmMeta.updated as string) || created,
           );
           if ((result as { changes: number }).changes > 0) {
             if (relatedToJson && ctx.stmts.updateRelatedTo) {
               ctx.stmts.updateRelatedTo.run(relatedToJson, id);
             }
             if (category !== "event") {
-              const rowidResult = ctx.stmts.getRowid.get(id) as { rowid: number } | undefined;
+              const rowidResult = ctx.stmts.getRowid.get(id) as
+                | { rowid: number }
+                | undefined;
               if (rowidResult?.rowid) {
                 const embeddingText = [parsed.title, parsed.body]
                   .filter(Boolean)
@@ -254,24 +326,45 @@ export async function reindex(
           }
         } else if (fullSync) {
           const tagsJson = fmMeta.tags ? JSON.stringify(fmMeta.tags) : null;
-          const titleChanged = (parsed.title || null) !== ((existing.title as string) || null);
+          const titleChanged =
+            (parsed.title || null) !== ((existing.title as string) || null);
           const bodyChanged = (existing.body as string) !== parsed.body;
           const tagsChanged = tagsJson !== ((existing.tags as string) || null);
           const metaChanged = metaJson !== ((existing.meta as string) || null);
-          const relatedToChanged = relatedToJson !== ((existing.related_to as string) || null);
-
-          if (bodyChanged || titleChanged || tagsChanged || metaChanged || relatedToChanged) {
+          const relatedToChanged =
+            relatedToJson !== ((existing.related_to as string) || null);
+
+          if (
+            bodyChanged ||
+            titleChanged ||
+            tagsChanged ||
+            metaChanged ||
+            relatedToChanged
+          ) {
             ctx.stmts.updateEntry.run(
-              parsed.title || null, parsed.body, metaJson, tagsJson,
-              (fmMeta.source as string) || "file", category,
-              identity_key, expires_at, filePath,
+              parsed.title || null,
+              parsed.body,
+              metaJson,
+              tagsJson,
+              (fmMeta.source as string) || "file",
+              category,
+              identity_key,
+              expires_at,
+              filePath,
             );
             if (relatedToChanged && ctx.stmts.updateRelatedTo) {
-              ctx.stmts.updateRelatedTo.run(relatedToJson, existing.id as string);
+              ctx.stmts.updateRelatedTo.run(
+                relatedToJson,
+                existing.id as string,
+              );
             }
 
             if ((bodyChanged || titleChanged) && category !== "event") {
-              const rowid = (ctx.stmts.getRowid.get(existing.id as string) as { rowid: number } | undefined)?.rowid;
+              const rowid = (
+                ctx.stmts.getRowid.get(existing.id as string) as
+                  | { rowid: number }
+                  | undefined
+              )?.rowid;
               if (rowid) {
                 const embeddingText = [parsed.title, parsed.body]
                   .filter(Boolean)
@@ -291,9 +384,15 @@ export async function reindex(
       if (fullSync) {
         for (const [dbPath, row] of dbByPath) {
           if (!diskPaths.has(dbPath)) {
-            const vRowid = (ctx.stmts.getRowid.get(row.id as string) as { rowid: number } | undefined)?.rowid;
+            const vRowid = (
+              ctx.stmts.getRowid.get(row.id as string) as
+                | { rowid: number }
+                | undefined
+            )?.rowid;
             if (vRowid) {
-              try { ctx.deleteVec(vRowid); } catch {}
+              try {
+                ctx.deleteVec(vRowid);
+              } catch {}
             }
             ctx.stmts.deleteEntry.run(row.id as string);
             stats.removed++;
@@ -313,7 +412,9 @@ export async function reindex(
             .prepare("SELECT id, rowid FROM vault WHERE kind = ?")
             .all(kind) as { id: string; rowid: number }[];
           for (const row of orphaned) {
-            try { ctx.deleteVec(row.rowid); } catch {}
+            try {
+              ctx.deleteVec(row.rowid);
+            } catch {}
             ctx.stmts.deleteEntry.run(row.id);
             stats.removed++;
           }
@@ -329,11 +430,17 @@ export async function reindex(
 
     for (const row of expired) {
       if (row.file_path) {
-        try { unlinkSync(row.file_path); } catch {}
+        try {
+          unlinkSync(row.file_path);
+        } catch {}
       }
-      const vRowid = (ctx.stmts.getRowid.get(row.id) as { rowid: number } | undefined)?.rowid;
+      const vRowid = (
+        ctx.stmts.getRowid.get(row.id) as { rowid: number } | undefined
+      )?.rowid;
       if (vRowid) {
-        try { ctx.deleteVec(Number(vRowid)); } catch {}
+        try {
+          ctx.deleteVec(Number(vRowid));
+        } catch {}
       }
       ctx.stmts.deleteEntry.run(row.id);
       stats.removed++;
@@ -350,7 +457,9 @@ export async function reindex(
     const embeddings = await embedBatch(batch.map((e) => e.text));
     for (let j = 0; j < batch.length; j++) {
       if (embeddings[j]) {
-        try { ctx.deleteVec(batch[j].rowid); } catch {}
+        try {
+          ctx.deleteVec(batch[j].rowid);
+        } catch {}
         ctx.insertVec(batch[j].rowid, embeddings[j]!);
       }
     }

package/src/ingest-url.ts

@@ -6,27 +6,81 @@ export function htmlToMarkdown(html: string): string {
   md = md.replace(/<header[\s\S]*?<\/header>/gi, "");
   md = md.replace(/<footer[\s\S]*?<\/footer>/gi, "");
   md = md.replace(/<aside[\s\S]*?<\/aside>/gi, "");
-  md = md.replace(/<h1[^>]*>([\s\S]*?)<\/h1>/gi, (_, c: string) => `\n# ${stripTags(c).trim()}\n`);
-  md = md.replace(/<h2[^>]*>([\s\S]*?)<\/h2>/gi, (_, c: string) => `\n## ${stripTags(c).trim()}\n`);
-  md = md.replace(/<h3[^>]*>([\s\S]*?)<\/h3>/gi, (_, c: string) => `\n### ${stripTags(c).trim()}\n`);
-  md = md.replace(/<h4[^>]*>([\s\S]*?)<\/h4>/gi, (_, c: string) => `\n#### ${stripTags(c).trim()}\n`);
-  md = md.replace(/<h5[^>]*>([\s\S]*?)<\/h5>/gi, (_, c: string) => `\n##### ${stripTags(c).trim()}\n`);
-  md = md.replace(/<h6[^>]*>([\s\S]*?)<\/h6>/gi, (_, c: string) => `\n###### ${stripTags(c).trim()}\n`);
-  md = md.replace(/<a[^>]*href="([^"]*)"[^>]*>([\s\S]*?)<\/a>/gi, (_, href: string, text: string) => {
-    const cleanText = stripTags(text).trim();
-    return cleanText ? `[${cleanText}](${href})` : "";
-  });
-  md = md.replace(/<pre[^>]*><code[^>]*>([\s\S]*?)<\/code><\/pre>/gi, (_, c: string) => `\n\`\`\`\n${decodeEntities(c).trim()}\n\`\`\`\n`);
-  md = md.replace(/<pre[^>]*>([\s\S]*?)<\/pre>/gi, (_, c: string) => `\n\`\`\`\n${decodeEntities(stripTags(c)).trim()}\n\`\`\`\n`);
-  md = md.replace(/<code[^>]*>([\s\S]*?)<\/code>/gi, (_, c: string) => `\`${decodeEntities(c).trim()}\``);
-  md = md.replace(/<(strong|b)[^>]*>([\s\S]*?)<\/\1>/gi, (_, __: string, c: string) => `**${stripTags(c).trim()}**`);
-  md = md.replace(/<(em|i)[^>]*>([\s\S]*?)<\/\1>/gi, (_, __: string, c: string) => `*${stripTags(c).trim()}*`);
-  md = md.replace(/<li[^>]*>([\s\S]*?)<\/li>/gi, (_, c: string) => `- ${stripTags(c).trim()}\n`);
+  md = md.replace(
+    /<h1[^>]*>([\s\S]*?)<\/h1>/gi,
+    (_, c: string) => `\n# ${stripTags(c).trim()}\n`,
+  );
+  md = md.replace(
+    /<h2[^>]*>([\s\S]*?)<\/h2>/gi,
+    (_, c: string) => `\n## ${stripTags(c).trim()}\n`,
+  );
+  md = md.replace(
+    /<h3[^>]*>([\s\S]*?)<\/h3>/gi,
+    (_, c: string) => `\n### ${stripTags(c).trim()}\n`,
+  );
+  md = md.replace(
+    /<h4[^>]*>([\s\S]*?)<\/h4>/gi,
+    (_, c: string) => `\n#### ${stripTags(c).trim()}\n`,
+  );
+  md = md.replace(
+    /<h5[^>]*>([\s\S]*?)<\/h5>/gi,
+    (_, c: string) => `\n##### ${stripTags(c).trim()}\n`,
+  );
+  md = md.replace(
+    /<h6[^>]*>([\s\S]*?)<\/h6>/gi,
+    (_, c: string) => `\n###### ${stripTags(c).trim()}\n`,
+  );
+  md = md.replace(
+    /<a[^>]*href="([^"]*)"[^>]*>([\s\S]*?)<\/a>/gi,
+    (_, href: string, text: string) => {
+      const cleanText = stripTags(text).trim();
+      return cleanText ? `[${cleanText}](${href})` : "";
+    },
+  );
+  md = md.replace(
+    /<pre[^>]*><code[^>]*>([\s\S]*?)<\/code><\/pre>/gi,
+    (_, c: string) => `\n\`\`\`\n${decodeEntities(c).trim()}\n\`\`\`\n`,
+  );
+  md = md.replace(
+    /<pre[^>]*>([\s\S]*?)<\/pre>/gi,
+    (_, c: string) =>
+      `\n\`\`\`\n${decodeEntities(stripTags(c)).trim()}\n\`\`\`\n`,
+  );
+  md = md.replace(
+    /<code[^>]*>([\s\S]*?)<\/code>/gi,
+    (_, c: string) => `\`${decodeEntities(c).trim()}\``,
+  );
+  md = md.replace(
+    /<(strong|b)[^>]*>([\s\S]*?)<\/\1>/gi,
+    (_, __: string, c: string) => `**${stripTags(c).trim()}**`,
+  );
+  md = md.replace(
+    /<(em|i)[^>]*>([\s\S]*?)<\/\1>/gi,
+    (_, __: string, c: string) => `*${stripTags(c).trim()}*`,
+  );
+  md = md.replace(
+    /<li[^>]*>([\s\S]*?)<\/li>/gi,
+    (_, c: string) => `- ${stripTags(c).trim()}\n`,
+  );
   md = md.replace(/<br\s*\/?>/gi, "\n");
-  md = md.replace(/<p[^>]*>([\s\S]*?)<\/p>/gi, (_, c: string) => `\n${stripTags(c).trim()}\n`);
-  md = md.replace(/<blockquote[^>]*>([\s\S]*?)<\/blockquote>/gi, (_, c: string) => {
-    return "\n" + stripTags(c).trim().split("\n").map((l: string) => `> ${l}`).join("\n") + "\n";
-  });
+  md = md.replace(
+    /<p[^>]*>([\s\S]*?)<\/p>/gi,
+    (_, c: string) => `\n${stripTags(c).trim()}\n`,
+  );
+  md = md.replace(
+    /<blockquote[^>]*>([\s\S]*?)<\/blockquote>/gi,
+    (_, c: string) => {
+      return (
+        "\n" +
+        stripTags(c)
+          .trim()
+          .split("\n")
+          .map((l: string) => `> ${l}`)
+          .join("\n") +
+        "\n"
+      );
+    },
+  );
   md = stripTags(md);
   md = decodeEntities(md);
   md = md.replace(/\n{3,}/g, "\n\n").trim();
@@ -39,15 +93,28 @@ function stripTags(html: string): string {
 
 function decodeEntities(text: string): string {
   return text
-    .replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">")
-    .replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&nbsp;/g, " ")
-    .replace(/&#(\d+);/g, (_, n: string) => String.fromCharCode(parseInt(n, 10)))
-    .replace(/&#x([0-9a-f]+);/gi, (_, n: string) => String.fromCharCode(parseInt(n, 16)));
+    .replace(/&amp;/g, "&")
+    .replace(/&lt;/g, "<")
+    .replace(/&gt;/g, ">")
+    .replace(/&quot;/g, '"')
+    .replace(/&#39;/g, "'")
+    .replace(/&nbsp;/g, " ")
+    .replace(/&#(\d+);/g, (_, n: string) =>
+      String.fromCharCode(parseInt(n, 10)),
+    )
+    .replace(/&#x([0-9a-f]+);/gi, (_, n: string) =>
+      String.fromCharCode(parseInt(n, 16)),
+    );
 }
 
-export function extractHtmlContent(html: string, _url: string): { title: string; body: string } {
+export function extractHtmlContent(
+  html: string,
+  _url: string,
+): { title: string; body: string } {
   const titleMatch = html.match(/<title[^>]*>([\s\S]*?)<\/title>/i);
-  const title = titleMatch ? stripTags(decodeEntities(titleMatch[1])).trim() : "";
+  const title = titleMatch
+    ? stripTags(decodeEntities(titleMatch[1])).trim()
+    : "";
   let contentHtml = "";
   const articleMatch = html.match(/<article[^>]*>([\s\S]*?)<\/article>/i);
   const mainMatch = html.match(/<main[^>]*>([\s\S]*?)<\/main>/i);
@@ -63,37 +130,83 @@ export function extractHtmlContent(html: string, _url: string): { title: string;
 
 export async function ingestUrl(
   url: string,
-  opts: { kind?: string; tags?: string[]; source?: string; maxBodyLength?: number; timeoutMs?: number } = {},
-): Promise<{ kind: string; title: string; body: string; tags: string[]; meta: Record<string, unknown>; source: string }> {
-  const { kind = "reference", tags = [], source, maxBodyLength = 50000, timeoutMs = 15000 } = opts;
+  opts: {
+    kind?: string;
+    tags?: string[];
+    source?: string;
+    maxBodyLength?: number;
+    timeoutMs?: number;
+  } = {},
+): Promise<{
+  kind: string;
+  title: string;
+  body: string;
+  tags: string[];
+  meta: Record<string, unknown>;
+  source: string;
+}> {
+  const {
+    kind = "reference",
+    tags = [],
+    source,
+    maxBodyLength = 50000,
+    timeoutMs = 15000,
+  } = opts;
   let domain: string;
-  try { domain = new URL(url).hostname; } catch { throw new Error(`Invalid URL: ${url}`); }
+  try {
+    domain = new URL(url).hostname;
+  } catch {
+    throw new Error(`Invalid URL: ${url}`);
+  }
   const controller = new AbortController();
   const timeout = setTimeout(() => controller.abort(), timeoutMs);
   let response: Response;
   try {
     response = await fetch(url, {
       signal: controller.signal,
-      headers: { "User-Agent": "ContextVault/1.0 (+https://github.com/fellanH/context-vault)", Accept: "text/html,application/xhtml+xml,text/plain,*/*" },
+      headers: {
+        "User-Agent":
+          "ContextVault/1.0 (+https://github.com/fellanH/context-vault)",
+        Accept: "text/html,application/xhtml+xml,text/plain,*/*",
+      },
     });
   } catch (err) {
-    if ((err as Error).name === "AbortError") throw new Error(`Request timed out after ${timeoutMs}ms`);
+    if ((err as Error).name === "AbortError")
+      throw new Error(`Request timed out after ${timeoutMs}ms`);
     throw new Error(`Fetch failed: ${(err as Error).message}`);
-  } finally { clearTimeout(timeout); }
-  if (!response.ok) throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+  } finally {
+    clearTimeout(timeout);
+  }
+  if (!response.ok)
+    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
   const contentType = response.headers.get("content-type") || "";
   const html = await response.text();
   let title: string, body: string;
-  if (contentType.includes("text/html") || contentType.includes("application/xhtml")) {
+  if (
+    contentType.includes("text/html") ||
+    contentType.includes("application/xhtml")
+  ) {
     const extracted = extractHtmlContent(html, url);
-    title = extracted.title; body = extracted.body;
-  } else { title = domain; body = html; }
-  if (body.length > maxBodyLength) body = body.slice(0, maxBodyLength) + "\n\n[Content truncated]";
+    title = extracted.title;
+    body = extracted.body;
+  } else {
+    title = domain;
+    body = html;
+  }
+  if (body.length > maxBodyLength)
+    body = body.slice(0, maxBodyLength) + "\n\n[Content truncated]";
   if (!body.trim()) throw new Error("No readable content extracted from URL");
   return {
-    kind, title: title || domain, body,
+    kind,
+    title: title || domain,
+    body,
     tags: [...tags, "web-import"],
-    meta: { url, domain, fetched_at: new Date().toISOString(), content_type: contentType.split(";")[0].trim() || "text/html" },
+    meta: {
+      url,
+      domain,
+      fetched_at: new Date().toISOString(),
+      content_type: contentType.split(";")[0].trim() || "text/html",
+    },
     source: source || domain,
   };
 }

package/src/main.ts

@@ -80,7 +80,12 @@ export {
 } from "./db.js";
 
 // Embeddings
-export { embed, embedBatch, resetEmbedPipeline, isEmbedAvailable } from "./embed.js";
+export {
+  embed,
+  embedBatch,
+  resetEmbedPipeline,
+  isEmbedAvailable,
+} from "./embed.js";
 
 // Index (reindex + indexEntry)
 export { indexEntry, reindex, pruneExpired } from "./index.js";
@@ -97,15 +102,7 @@ export {
 } from "./search.js";
 
 // Capture
-export {
-  writeEntry,
-  updateEntryFile,
-  captureAndIndex,
-} from "./capture.js";
+export { writeEntry, updateEntryFile, captureAndIndex } from "./capture.js";
 
 // Ingest URL
-export {
-  htmlToMarkdown,
-  extractHtmlContent,
-  ingestUrl,
-} from "./ingest-url.js";
+export { htmlToMarkdown, extractHtmlContent, ingestUrl } from "./ingest-url.js";

package/src/search.ts

@@ -1,9 +1,17 @@
-import type { BaseCtx, SearchResult, SearchOptions, VaultEntry } from "./types.js";
+import type {
+  BaseCtx,
+  SearchResult,
+  SearchOptions,
+  VaultEntry,
+} from "./types.js";
 
 const NEAR_DUP_THRESHOLD = 0.92;
 const RRF_K = 60;
 
-export function recencyDecayScore(updatedAt: string | null | undefined, decayRate = 0.05): number {
+export function recencyDecayScore(
+  updatedAt: string | null | undefined,
+  decayRate = 0.05,
+): number {
   if (updatedAt == null) return 0.5;
   const ageDays = (Date.now() - new Date(updatedAt).getTime()) / 86400000;
   return Math.exp(-decayRate * ageDays);
@@ -28,7 +36,11 @@ export function buildFtsQuery(query: string): string | null {
   return `${phrase} OR ${near} OR ${and}`;
 }
 
-export function recencyBoost(createdAt: string, category: string, decayDays = 30): number {
+export function recencyBoost(
+  createdAt: string,
+  category: string,
+  decayDays = 30,
+): number {
   if (category !== "event") return 1.0;
   const ageDays = (Date.now() - new Date(createdAt).getTime()) / 86400000;
   return 1 / (1 + ageDays / decayDays);
@@ -46,9 +58,9 @@ export function buildFilterClauses({
   since?: string | null;
   until?: string | null;
   includeSuperseeded?: boolean;
-}): { clauses: string[]; params: unknown[] } {
+}): { clauses: string[]; params: (string | number | null)[] } {
   const clauses: string[] = [];
-  const params: unknown[] = [];
+  const params: (string | number | null)[] = [];
   if (categoryFilter) {
     clauses.push("e.category = ?");
     params.push(categoryFilter);
@@ -120,7 +132,7 @@ export async function hybridSearch(
   if (ftsQuery) {
     try {
       const whereParts = ["vault_fts MATCH ?"];
-      const ftsParams: unknown[] = [ftsQuery];
+      const ftsParams: (string | number | null)[] = [ftsQuery];
 
       if (kindFilter) {
         whereParts.push("e.kind = ?");
@@ -130,8 +142,9 @@ export async function hybridSearch(
       ftsParams.push(...extraFilters.params);
 
       const ftsSQL = `SELECT e.*, rank FROM vault_fts f JOIN vault e ON f.rowid = e.rowid WHERE ${whereParts.join(" AND ")} ORDER BY rank LIMIT 15`;
-      // @ts-expect-error -- node:sqlite types are overly strict for dynamic SQL params
-      const rows = ctx.db.prepare(ftsSQL).all(...ftsParams) as unknown as (VaultEntry & { rank: number })[];
+      const rows = ctx.db
+        .prepare(ftsSQL)
+        .all(...ftsParams) as unknown as (VaultEntry & { rank: number })[];
 
       for (const { rank: _rank, ...row } of rows) {
         ftsRankedIds.push(row.id);
@@ -148,7 +161,11 @@ export async function hybridSearch(
   const vecSimMap = new Map<string, number>();
 
   try {
-    const vecCount = (ctx.db.prepare("SELECT COUNT(*) as c FROM vault_vec").get() as { c: number }).c;
+    const vecCount = (
+      ctx.db.prepare("SELECT COUNT(*) as c FROM vault_vec").get() as {
+        c: number;
+      }
+    ).c;
     if (vecCount > 0) {
       queryVec = await ctx.embed(query);
       if (queryVec) {
@@ -196,7 +213,9 @@ export async function hybridSearch(
     }
   } catch (err) {
     if (!(err as Error).message?.includes("no such table")) {
-      console.error(`[retrieve] Vector search error: ${(err as Error).message}`);
+      console.error(
+        `[retrieve] Vector search error: ${(err as Error).message}`,
+      );
     }
   }