@tekmidian/pai 0.54.1 → 0.55.0

package/dist/search-B69cQwDB.mjs

@@ -1,303 +0,0 @@
-import { n as cosineSimilarity, r as deserializeEmbedding } from "./embeddings-DvRKcQyt.mjs";
-import { t as STOP_WORDS } from "./stop-words-BaMEGVeY.mjs";
-
-//#region src/memory/search.ts
-/**
-* Convert a free-text query into an FTS5 query string.
-*
-* Strategy:
-*  1. Tokenise by whitespace and punctuation
-*  2. Remove stop words and tokens shorter than 2 characters
-*  3. Double-quote each remaining token (exact word form)
-*  4. Join with OR so that any matching token returns a result
-*
-* Using OR instead of AND is critical for multi-word queries: the words rarely
-* all appear in the same chunk, so AND would return zero results.  FTS5 BM25
-* scoring naturally ranks chunks where more terms match higher, so the most
-* relevant chunks still surface at the top.
-*
-* Example: "Synchrotech interview follow-up Gilles"
-*   → `"synchrotech" OR "interview" OR "follow" OR "gilles"`
-*   → chunks matching any term, ranked by how many terms match
-*/
-/**
-* Did SQLite reject the QUERY, or fail at the STORE?
-*
-* Only the first justifies an empty result. FTS5 reports a bad MATCH expression
-* with a recognisable message; a missing table, a corrupt index or a locked
-* database do not, and must not be reported as "nothing found".
-*
-* Matching on message text is unlovely, and the alternative — treating every
-* failure as empty — is what produced a confidently wrong answer to a human.
-*/
-function isQuerySyntaxError(e) {
-	const msg = e instanceof Error ? e.message : String(e);
-	return /fts5|malformed MATCH|syntax error|unterminated string|no such column/i.test(msg);
-}
-function buildFtsQuery(query) {
-	const tokens = query.toLowerCase().split(/[\s\p{P}]+/u).filter(Boolean).filter((t) => t.length >= 2).filter((t) => !STOP_WORDS.has(t)).map((t) => `"${t.replace(/"/g, "\"\"")}"`);
-	if (tokens.length === 0) return `"${query.replace(/"/g, "\"\"")}"`;
-	return tokens.join(" OR ");
-}
-/**
-* Search across all indexed memory using FTS5 BM25 ranking.
-*
-* Results are ordered by BM25 score (most relevant first).
-* FTS5 bm25() returns negative values; closer to 0 = more relevant.
-* We negate the score so callers get positive values where higher = better.
-*
-* Multilingual note: SQLite FTS5 uses the `unicode61` tokenizer by default,
-* which handles Unicode correctly (German umlauts, French accents, etc.) without
-* language-specific stemming. No changes needed here — it is already
-* multilingual-safe.
-*/
-function searchMemory(db, query, opts) {
-	const maxResults = opts?.maxResults ?? 10;
-	const ftsQuery = buildFtsQuery(query);
-	const conditions = [];
-	const params = [ftsQuery];
-	if (opts?.projectIds && opts.projectIds.length > 0) {
-		const placeholders = opts.projectIds.map(() => "?").join(", ");
-		conditions.push(`c.project_id IN (${placeholders})`);
-		params.push(...opts.projectIds);
-	}
-	if (opts?.sources && opts.sources.length > 0) {
-		const placeholders = opts.sources.map(() => "?").join(", ");
-		conditions.push(`c.source IN (${placeholders})`);
-		params.push(...opts.sources);
-	}
-	if (opts?.tiers && opts.tiers.length > 0) {
-		const placeholders = opts.tiers.map(() => "?").join(", ");
-		conditions.push(`c.tier IN (${placeholders})`);
-		params.push(...opts.tiers);
-	}
-	const whereClause = conditions.length > 0 ? "AND " + conditions.join(" AND ") : "";
-	params.push(maxResults);
-	const sql = `
-    SELECT
-      c.id,
-      c.project_id,
-      c.path,
-      c.start_line,
-      c.end_line,
-      c.text             AS snippet,
-      c.tier,
-      c.source,
-      c.updated_at,
-      c.last_accessed_at,
-      c.relevance_score,
-      bm25(memory_fts) AS bm25_score
-    FROM memory_fts
-    JOIN memory_chunks c ON memory_fts.id = c.id
-    WHERE memory_fts MATCH ?
-      ${whereClause}
-    ORDER BY bm25_score
-    LIMIT ?
-  `;
-	let rows;
-	try {
-		rows = db.prepare(sql).all(...params);
-	} catch (e) {
-		if (!isQuerySyntaxError(e)) throw new Error(`Memory keyword search failed — the index is unusable, so this is NOT an empty result set. Cause: ${e instanceof Error ? e.message : String(e)}`);
-		return [];
-	}
-	const minScore = opts?.minScore ?? 0;
-	return rows.map((row) => {
-		const score = -row.bm25_score * (.5 + (row.relevance_score ?? .5));
-		return {
-			chunkId: row.id,
-			projectId: row.project_id,
-			path: row.path,
-			startLine: row.start_line,
-			endLine: row.end_line,
-			snippet: row.snippet,
-			score,
-			tier: row.tier,
-			source: row.source,
-			updatedAt: row.updated_at,
-			lastAccessedAt: row.last_accessed_at ?? void 0
-		};
-	}).filter((r) => r.score >= minScore);
-}
-/**
-* Search chunks using brute-force cosine similarity over stored embeddings.
-*
-* Only chunks that have a non-null embedding BLOB are considered.  Chunks
-* without embeddings are silently skipped (they can be embedded later via
-* `embedChunks()`).
-*
-* @param queryEmbedding  Pre-computed Float32Array for the search query.
-*/
-function searchMemorySemantic(db, queryEmbedding, opts) {
-	const maxResults = opts?.maxResults ?? 10;
-	const conditions = ["embedding IS NOT NULL"];
-	const params = [];
-	if (opts?.projectIds && opts.projectIds.length > 0) {
-		const placeholders = opts.projectIds.map(() => "?").join(", ");
-		conditions.push(`project_id IN (${placeholders})`);
-		params.push(...opts.projectIds);
-	}
-	if (opts?.sources && opts.sources.length > 0) {
-		const placeholders = opts.sources.map(() => "?").join(", ");
-		conditions.push(`source IN (${placeholders})`);
-		params.push(...opts.sources);
-	}
-	if (opts?.tiers && opts.tiers.length > 0) {
-		const placeholders = opts.tiers.map(() => "?").join(", ");
-		conditions.push(`tier IN (${placeholders})`);
-		params.push(...opts.tiers);
-	}
-	const sql = `
-    SELECT id, project_id, path, start_line, end_line, text, tier, source, embedding, updated_at, last_accessed_at, relevance_score
-    FROM memory_chunks
-    ${"WHERE " + conditions.join(" AND ")}
-    LIMIT 5000
-  `;
-	const rows = db.prepare(sql).all(...params);
-	if (rows.length === 0) return [];
-	const scored = rows.map((row) => {
-		const score = cosineSimilarity(queryEmbedding, deserializeEmbedding(row.embedding)) * (.5 + (row.relevance_score ?? .5));
-		return {
-			chunkId: row.id,
-			projectId: row.project_id,
-			path: row.path,
-			startLine: row.start_line,
-			endLine: row.end_line,
-			snippet: row.text,
-			score,
-			tier: row.tier,
-			source: row.source,
-			updatedAt: row.updated_at,
-			lastAccessedAt: row.last_accessed_at ?? void 0
-		};
-	});
-	const minScore = opts?.minScore ?? -Infinity;
-	return scored.filter((r) => r.score >= minScore).sort((a, b) => b.score - a.score).slice(0, maxResults);
-}
-/**
-* Combine BM25 keyword search and semantic search using normalized scores.
-*
-* Both score sets are min-max normalized to [0,1] before combining, so neither
-* dominates the other regardless of their raw scales.
-*
-* @param queryEmbedding  Pre-computed embedding for the query.
-* @param keywordWeight   Weight for BM25 score (default 0.5).
-* @param semanticWeight  Weight for cosine similarity score (default 0.5).
-*/
-function searchMemoryHybrid(db, query, queryEmbedding, opts) {
-	const maxResults = opts?.maxResults ?? 10;
-	const kw = opts?.keywordWeight ?? .5;
-	const sw = opts?.semanticWeight ?? .5;
-	const keywordResults = searchMemory(db, query, {
-		...opts,
-		maxResults: 50
-	});
-	const semanticResults = searchMemorySemantic(db, queryEmbedding, {
-		...opts,
-		maxResults: 50
-	});
-	if (keywordResults.length === 0 && semanticResults.length === 0) return [];
-	const keyFor = (r) => `${r.projectId}:${r.path}:${r.startLine}:${r.endLine}`;
-	function minMaxNormalize(items) {
-		if (items.length === 0) return /* @__PURE__ */ new Map();
-		const min = Math.min(...items.map((r) => r.score));
-		const range = Math.max(...items.map((r) => r.score)) - min;
-		const m = /* @__PURE__ */ new Map();
-		for (const r of items) m.set(keyFor(r), range === 0 ? 1 : (r.score - min) / range);
-		return m;
-	}
-	const kwNorm = minMaxNormalize(keywordResults);
-	const semNorm = minMaxNormalize(semanticResults);
-	const allKeys = new Set([...keywordResults.map(keyFor), ...semanticResults.map(keyFor)]);
-	const metaMap = /* @__PURE__ */ new Map();
-	for (const r of [...keywordResults, ...semanticResults]) metaMap.set(keyFor(r), r);
-	const combined = [];
-	for (const key of allKeys) {
-		const meta = metaMap.get(key);
-		const kwScore = kwNorm.get(key) ?? 0;
-		const semScore = semNorm.get(key) ?? 0;
-		const combinedScore = kw * kwScore + sw * semScore;
-		combined.push({
-			...meta,
-			score: combinedScore,
-			combinedScore
-		});
-	}
-	return combined.sort((a, b) => b.score - a.score).slice(0, maxResults).map(({ combinedScore: _unused, ...r }) => r);
-}
-/**
-* Update last_accessed_at for a set of chunk IDs to the current timestamp.
-*
-* Called after a successful search to record that these chunks were retrieved.
-* This enables the recency boost to account for access patterns, not just
-* modification time.
-*
-* Best-effort: errors are silently ignored so search is never blocked.
-*/
-function touchChunksLastAccessed(db, chunkIds) {
-	if (chunkIds.length === 0) return;
-	try {
-		const now = Date.now();
-		const placeholders = chunkIds.map(() => "?").join(", ");
-		db.prepare(`UPDATE memory_chunks SET last_accessed_at = ? WHERE id IN (${placeholders})`).run(now, ...chunkIds);
-	} catch {}
-}
-/**
-* Populate the projectSlug field on search results by looking up project IDs
-* in the registry database.
-*/
-function populateSlugs(results, registryDb) {
-	if (results.length === 0) return results;
-	const ids = [...new Set(results.map((r) => r.projectId))];
-	const placeholders = ids.map(() => "?").join(", ");
-	const rows = registryDb.prepare(`SELECT id, slug FROM projects WHERE id IN (${placeholders})`).all(...ids);
-	const slugMap = new Map(rows.map((r) => [r.id, r.slug]));
-	return results.map((r) => ({
-		...r,
-		projectSlug: slugMap.get(r.projectId)
-	}));
-}
-/**
-* Apply exponential recency boost to search scores.
-*
-* Scores are first min-max normalized to [0,1], then multiplied by an
-* exponential decay factor based on chunk age.  Normalization is required
-* because the cross-encoder reranker produces negative logit scores — naive
-* multiplication of a negative score by a decay factor (0 < d ≤ 1) would
-* make the score *less* negative, effectively boosting old results instead
-* of penalizing them.
-*
-* Formula: score_final = normalized * exp(-lambda * age_days)
-* where lambda = ln(2) / halfLifeDays, normalized ∈ [0,1]
-*
-* With default halfLifeDays=90, a 3-month-old chunk retains 50% of its
-* normalized score, a 6-month-old retains 25%, and a 1-year-old ~6%.
-*
-* Results without an updatedAt timestamp receive no decay penalty.
-* Results are re-sorted by the boosted score after application.
-*
-* @param results      Search results with optional updatedAt timestamps.
-* @param halfLifeDays Score halves every N days. Default 90 (~3 months).
-* @returns New array sorted by decayed normalized score (descending).
-*/
-function applyRecencyBoost(results, halfLifeDays = 90) {
-	if (halfLifeDays <= 0 || results.length === 0) return results;
-	const lambda = Math.LN2 / halfLifeDays;
-	const now = Date.now();
-	const scores = results.map((r) => r.score);
-	const minScore = Math.min(...scores);
-	const range = Math.max(...scores) - minScore;
-	return results.map((r) => {
-		const normalized = range === 0 ? 1 : (r.score - minScore) / range;
-		const effectiveTs = r.updatedAt != null && r.lastAccessedAt != null ? Math.max(r.updatedAt, r.lastAccessedAt) : r.lastAccessedAt ?? r.updatedAt;
-		const decay = effectiveTs ? Math.exp(-lambda * Math.max(0, (now - effectiveTs) / 864e5)) : 1;
-		return {
-			...r,
-			score: normalized * decay
-		};
-	}).sort((a, b) => b.score - a.score);
-}
-
-//#endregion
-export { searchMemory as a, touchChunksLastAccessed as c, populateSlugs as i, buildFtsQuery as n, searchMemoryHybrid as o, isQuerySyntaxError as r, searchMemorySemantic as s, applyRecencyBoost as t };
-//# sourceMappingURL=search-B69cQwDB.mjs.map

package/dist/search-B69cQwDB.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"search-B69cQwDB.mjs","names":[],"sources":["../src/memory/search.ts"],"sourcesContent":["/**\n * Search over the PAI federation memory index.\n *\n * Provides three search modes:\n *  - keyword  — BM25 full-text search (default, fast, no ML required)\n *  - semantic — Brute-force cosine similarity over pre-computed embeddings\n *  - hybrid   — Normalized combination of BM25 + cosine scores\n *\n * BM25 uses SQLite's FTS5 extension.  Semantic search requires embeddings to\n * have been generated first via `embedChunks()` in the indexer.\n */\n\nimport type { Database } from \"better-sqlite3\";\nimport { deserializeEmbedding, cosineSimilarity } from \"./embeddings.js\";\nimport { STOP_WORDS } from \"../utils/stop-words.js\";\n\n// ---------------------------------------------------------------------------\n// Types\n// ---------------------------------------------------------------------------\n\nexport interface SearchResult {\n  projectId: number;\n  projectSlug?: string;   // populated from registry after search when available\n  path: string;\n  startLine: number;\n  endLine: number;\n  snippet: string;\n  score: number;          // raw BM25 score (lower = more relevant in FTS5)\n  tier: string;\n  source: string;\n  updatedAt?: number;     // Unix ms from memory_chunks.updated_at\n  lastAccessedAt?: number; // Unix ms from memory_chunks.last_accessed_at (QW2)\n  chunkId?: string;        // chunk ID for last_accessed_at update (QW2)\n}\n\nexport interface SearchOptions {\n  /** Restrict search to these project IDs. */\n  projectIds?: number[];\n  /** Restrict to 'memory' or 'notes' sources. */\n  sources?: string[];\n  /** Restrict to specific tier(s): 'evergreen' | 'daily' | 'topic' | 'session' */\n  tiers?: string[];\n  /** Maximum number of results to return. Default 10. */\n  maxResults?: number;\n  /** Minimum BM25 score threshold (FTS5 scores are negative; 0.0 means no filter). */\n  minScore?: number;\n}\n\n// STOP_WORDS imported from utils/stop-words.ts\n\n// ---------------------------------------------------------------------------\n// Query builder\n// ---------------------------------------------------------------------------\n\n/**\n * Convert a free-text query into an FTS5 query string.\n *\n * Strategy:\n *  1. Tokenise by whitespace and punctuation\n *  2. Remove stop words and tokens shorter than 2 characters\n *  3. Double-quote each remaining token (exact word form)\n *  4. Join with OR so that any matching token returns a result\n *\n * Using OR instead of AND is critical for multi-word queries: the words rarely\n * all appear in the same chunk, so AND would return zero results.  FTS5 BM25\n * scoring naturally ranks chunks where more terms match higher, so the most\n * relevant chunks still surface at the top.\n *\n * Example: \"Synchrotech interview follow-up Gilles\"\n *   → `\"synchrotech\" OR \"interview\" OR \"follow\" OR \"gilles\"`\n *   → chunks matching any term, ranked by how many terms match\n */\n/**\n * Did SQLite reject the QUERY, or fail at the STORE?\n *\n * Only the first justifies an empty result. FTS5 reports a bad MATCH expression\n * with a recognisable message; a missing table, a corrupt index or a locked\n * database do not, and must not be reported as \"nothing found\".\n *\n * Matching on message text is unlovely, and the alternative — treating every\n * failure as empty — is what produced a confidently wrong answer to a human.\n */\nexport function isQuerySyntaxError(e: unknown): boolean {\n  const msg = e instanceof Error ? e.message : String(e);\n  return /fts5|malformed MATCH|syntax error|unterminated string|no such column/i.test(msg);\n}\n\nexport function buildFtsQuery(query: string): string {\n  const tokens = query\n    .toLowerCase()\n    .split(/[\\s\\p{P}]+/u)\n    .filter(Boolean)\n    .filter((t) => t.length >= 2)\n    .filter((t) => !STOP_WORDS.has(t))\n    // Escape any double-quotes inside the token (FTS5 uses them as delimiters)\n    .map((t) => `\"${t.replace(/\"/g, '\"\"')}\"`)\n\n  if (tokens.length === 0) {\n    // Fallback: use original query as a raw string (may produce no results)\n    return `\"${query.replace(/\"/g, '\"\"')}\"`;\n  }\n\n  return tokens.join(\" OR \");\n}\n\n// ---------------------------------------------------------------------------\n// Search\n// ---------------------------------------------------------------------------\n\n/**\n * Search across all indexed memory using FTS5 BM25 ranking.\n *\n * Results are ordered by BM25 score (most relevant first).\n * FTS5 bm25() returns negative values; closer to 0 = more relevant.\n * We negate the score so callers get positive values where higher = better.\n *\n * Multilingual note: SQLite FTS5 uses the `unicode61` tokenizer by default,\n * which handles Unicode correctly (German umlauts, French accents, etc.) without\n * language-specific stemming. No changes needed here — it is already\n * multilingual-safe.\n */\nexport function searchMemory(\n  db: Database,\n  query: string,\n  opts?: SearchOptions,\n): SearchResult[] {\n  const maxResults = opts?.maxResults ?? 10;\n  const ftsQuery = buildFtsQuery(query);\n\n  // Build the SQL with optional filters\n  const conditions: string[] = [];\n  const params: (string | number)[] = [ftsQuery];\n\n  if (opts?.projectIds && opts.projectIds.length > 0) {\n    const placeholders = opts.projectIds.map(() => \"?\").join(\", \");\n    conditions.push(`c.project_id IN (${placeholders})`);\n    params.push(...opts.projectIds);\n  }\n\n  if (opts?.sources && opts.sources.length > 0) {\n    const placeholders = opts.sources.map(() => \"?\").join(\", \");\n    conditions.push(`c.source IN (${placeholders})`);\n    params.push(...opts.sources);\n  }\n\n  if (opts?.tiers && opts.tiers.length > 0) {\n    const placeholders = opts.tiers.map(() => \"?\").join(\", \");\n    conditions.push(`c.tier IN (${placeholders})`);\n    params.push(...opts.tiers);\n  }\n\n  const whereClause = conditions.length > 0\n    ? \"AND \" + conditions.join(\" AND \")\n    : \"\";\n\n  params.push(maxResults);\n\n  // FTS5: join memory_fts with memory_chunks to get metadata\n  // bm25(memory_fts) returns negative values (lower = better match)\n  const sql = `\n    SELECT\n      c.id,\n      c.project_id,\n      c.path,\n      c.start_line,\n      c.end_line,\n      c.text             AS snippet,\n      c.tier,\n      c.source,\n      c.updated_at,\n      c.last_accessed_at,\n      c.relevance_score,\n      bm25(memory_fts) AS bm25_score\n    FROM memory_fts\n    JOIN memory_chunks c ON memory_fts.id = c.id\n    WHERE memory_fts MATCH ?\n      ${whereClause}\n    ORDER BY bm25_score\n    LIMIT ?\n  `;\n\n  let rows: Array<{\n    id: string;\n    project_id: number;\n    path: string;\n    start_line: number;\n    end_line: number;\n    snippet: string;\n    tier: string;\n    source: string;\n    updated_at: number;\n    last_accessed_at: number | null;\n    relevance_score: number | null;\n    bm25_score: number;\n  }>;\n\n  try {\n    rows = db.prepare(sql).all(...params) as typeof rows;\n  } catch (e) {\n    // FTS5 MATCH throws on a malformed query, and for THAT an empty result is the\n    // honest answer — nothing matches a query that cannot be parsed.\n    //\n    // Everything else is a failure of the store: a missing table, a corrupt\n    // index, a locked database. Those used to return [] as well, which made an\n    // unusable index byte-identical to a genuine miss. The Postgres path had the\n    // same defect and it cost a real wrong answer on 2026-08-04 — the backend was\n    // down for two hours, every search reported \"No results found\", and a sibling\n    // session told the owner a DMARC note did not exist. See\n    // storage/postgres/search.ts.\n    if (!isQuerySyntaxError(e)) {\n      throw new Error(\n        `Memory keyword search failed — the index is unusable, so this is NOT an ` +\n          `empty result set. Cause: ${e instanceof Error ? e.message : String(e)}`\n      );\n    }\n    return [];\n  }\n\n  const minScore = opts?.minScore ?? 0.0;\n\n  return rows\n    .map((row) => {\n      // Negate so higher = better match for callers\n      const baseScore = -row.bm25_score;\n      // MR2: scale by feedback relevance_score: multiplier in [0.5, 1.5]\n      const relevanceScore = row.relevance_score ?? 0.5;\n      const score = baseScore * (0.5 + relevanceScore);\n      return {\n        chunkId: row.id,\n        projectId: row.project_id,\n        path: row.path,\n        startLine: row.start_line,\n        endLine: row.end_line,\n        snippet: row.snippet,\n        score,\n        tier: row.tier,\n        source: row.source,\n        updatedAt: row.updated_at,\n        lastAccessedAt: row.last_accessed_at ?? undefined,\n      };\n    })\n    .filter((r) => r.score >= minScore);\n}\n\n// ---------------------------------------------------------------------------\n// Semantic search\n// ---------------------------------------------------------------------------\n\n/**\n * Search chunks using brute-force cosine similarity over stored embeddings.\n *\n * Only chunks that have a non-null embedding BLOB are considered.  Chunks\n * without embeddings are silently skipped (they can be embedded later via\n * `embedChunks()`).\n *\n * @param queryEmbedding  Pre-computed Float32Array for the search query.\n */\nexport function searchMemorySemantic(\n  db: Database,\n  queryEmbedding: Float32Array,\n  opts?: SearchOptions,\n): SearchResult[] {\n  const maxResults = opts?.maxResults ?? 10;\n\n  // Build the SQL filter conditions\n  const conditions: string[] = [\"embedding IS NOT NULL\"];\n  const params: (string | number)[] = [];\n\n  if (opts?.projectIds && opts.projectIds.length > 0) {\n    const placeholders = opts.projectIds.map(() => \"?\").join(\", \");\n    conditions.push(`project_id IN (${placeholders})`);\n    params.push(...opts.projectIds);\n  }\n\n  if (opts?.sources && opts.sources.length > 0) {\n    const placeholders = opts.sources.map(() => \"?\").join(\", \");\n    conditions.push(`source IN (${placeholders})`);\n    params.push(...opts.sources);\n  }\n\n  if (opts?.tiers && opts.tiers.length > 0) {\n    const placeholders = opts.tiers.map(() => \"?\").join(\", \");\n    conditions.push(`tier IN (${placeholders})`);\n    params.push(...opts.tiers);\n  }\n\n  const where = \"WHERE \" + conditions.join(\" AND \");\n\n  // Hard cap for SQLite semantic path — prevents OOM on large corpora.\n  // Use Postgres for production semantic search.\n  const sql = `\n    SELECT id, project_id, path, start_line, end_line, text, tier, source, embedding, updated_at, last_accessed_at, relevance_score\n    FROM memory_chunks\n    ${where}\n    LIMIT 5000\n  `;\n\n  const rows = db.prepare(sql).all(...params) as Array<{\n    id: string;\n    project_id: number;\n    path: string;\n    start_line: number;\n    end_line: number;\n    text: string;\n    tier: string;\n    source: string;\n    embedding: Buffer;\n    updated_at: number;\n    last_accessed_at: number | null;\n    relevance_score: number | null;\n  }>;\n\n  if (rows.length === 0) return [];\n\n  // Compute cosine similarity for every chunk\n  const scored = rows.map((row) => {\n    const vec = deserializeEmbedding(row.embedding);\n    const baseScore = cosineSimilarity(queryEmbedding, vec);\n    // MR2: scale by feedback relevance_score: multiplier in [0.5, 1.5]\n    const relevanceScore = row.relevance_score ?? 0.5;\n    const score = baseScore * (0.5 + relevanceScore);\n    return {\n      chunkId: row.id,\n      projectId: row.project_id,\n      path: row.path,\n      startLine: row.start_line,\n      endLine: row.end_line,\n      snippet: row.text,\n      score,\n      tier: row.tier,\n      source: row.source,\n      updatedAt: row.updated_at,\n      lastAccessedAt: row.last_accessed_at ?? undefined,\n    };\n  });\n\n  // Sort by descending similarity, apply optional min score filter, limit\n  const minScore = opts?.minScore ?? -Infinity;\n\n  return scored\n    .filter((r) => r.score >= minScore)\n    .sort((a, b) => b.score - a.score)\n    .slice(0, maxResults);\n}\n\n// ---------------------------------------------------------------------------\n// Hybrid search\n// ---------------------------------------------------------------------------\n\n/**\n * Combine BM25 keyword search and semantic search using normalized scores.\n *\n * Both score sets are min-max normalized to [0,1] before combining, so neither\n * dominates the other regardless of their raw scales.\n *\n * @param queryEmbedding  Pre-computed embedding for the query.\n * @param keywordWeight   Weight for BM25 score (default 0.5).\n * @param semanticWeight  Weight for cosine similarity score (default 0.5).\n */\nexport function searchMemoryHybrid(\n  db: Database,\n  query: string,\n  queryEmbedding: Float32Array,\n  opts?: SearchOptions & { keywordWeight?: number; semanticWeight?: number },\n): SearchResult[] {\n  const maxResults = opts?.maxResults ?? 10;\n  const kw = opts?.keywordWeight ?? 0.5;\n  const sw = opts?.semanticWeight ?? 0.5;\n\n  // Fetch keyword results — 50 candidates is sufficient for min-max normalization\n  const keywordResults = searchMemory(db, query, {\n    ...opts,\n    maxResults: 50,\n  });\n\n  // Fetch semantic results — 50 candidates is sufficient for min-max normalization\n  const semanticResults = searchMemorySemantic(db, queryEmbedding, {\n    ...opts,\n    maxResults: 50,\n  });\n\n  if (keywordResults.length === 0 && semanticResults.length === 0) return [];\n\n  // Build a map of chunk ID → combined result\n  // Use \"projectId:path:startLine:endLine\" as a stable key (same as chunk IDs)\n  const keyFor = (r: SearchResult) =>\n    `${r.projectId}:${r.path}:${r.startLine}:${r.endLine}`;\n\n  // Min-max normalize helper\n  function minMaxNormalize(items: SearchResult[]): Map<string, number> {\n    if (items.length === 0) return new Map();\n    const min = Math.min(...items.map((r) => r.score));\n    const max = Math.max(...items.map((r) => r.score));\n    const range = max - min;\n    const m = new Map<string, number>();\n    for (const r of items) {\n      m.set(keyFor(r), range === 0 ? 1 : (r.score - min) / range);\n    }\n    return m;\n  }\n\n  const kwNorm = minMaxNormalize(keywordResults);\n  const semNorm = minMaxNormalize(semanticResults);\n\n  // Union of all chunk keys\n  const allKeys = new Set<string>([\n    ...keywordResults.map(keyFor),\n    ...semanticResults.map(keyFor),\n  ]);\n\n  // Build a lookup from key → result metadata\n  const metaMap = new Map<string, SearchResult>();\n  for (const r of [...keywordResults, ...semanticResults]) {\n    metaMap.set(keyFor(r), r);\n  }\n\n  // Combine scores\n  const combined: Array<SearchResult & { combinedScore: number }> = [];\n  for (const key of allKeys) {\n    const meta = metaMap.get(key)!;\n    const kwScore = kwNorm.get(key) ?? 0;\n    const semScore = semNorm.get(key) ?? 0;\n    const combinedScore = kw * kwScore + sw * semScore;\n    combined.push({ ...meta, score: combinedScore, combinedScore });\n  }\n\n  // Sort by combined score descending\n  return combined\n    .sort((a, b) => b.score - a.score)\n    .slice(0, maxResults)\n    .map(({ combinedScore: _unused, ...r }) => r);\n}\n\n// ---------------------------------------------------------------------------\n// Access timestamp tracking (QW2)\n// ---------------------------------------------------------------------------\n\n/**\n * Update last_accessed_at for a set of chunk IDs to the current timestamp.\n *\n * Called after a successful search to record that these chunks were retrieved.\n * This enables the recency boost to account for access patterns, not just\n * modification time.\n *\n * Best-effort: errors are silently ignored so search is never blocked.\n */\nexport function touchChunksLastAccessed(db: Database, chunkIds: string[]): void {\n  if (chunkIds.length === 0) return;\n  try {\n    const now = Date.now();\n    const placeholders = chunkIds.map(() => \"?\").join(\", \");\n    db.prepare(\n      `UPDATE memory_chunks SET last_accessed_at = ? WHERE id IN (${placeholders})`\n    ).run(now, ...chunkIds);\n  } catch {\n    // non-critical — do not block search results\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Slug lookup helper\n// ---------------------------------------------------------------------------\n\n/**\n * Populate the projectSlug field on search results by looking up project IDs\n * in the registry database.\n */\nexport function populateSlugs(\n  results: SearchResult[],\n  registryDb: Database,\n): SearchResult[] {\n  if (results.length === 0) return results;\n\n  const ids = [...new Set(results.map((r) => r.projectId))];\n  const placeholders = ids.map(() => \"?\").join(\", \");\n  const rows = registryDb\n    .prepare(`SELECT id, slug FROM projects WHERE id IN (${placeholders})`)\n    .all(...ids) as Array<{ id: number; slug: string }>;\n\n  const slugMap = new Map(rows.map((r) => [r.id, r.slug]));\n\n  return results.map((r) => ({\n    ...r,\n    projectSlug: slugMap.get(r.projectId),\n  }));\n}\n\n// ---------------------------------------------------------------------------\n// Recency boost\n// ---------------------------------------------------------------------------\n\n/**\n * Apply exponential recency boost to search scores.\n *\n * Scores are first min-max normalized to [0,1], then multiplied by an\n * exponential decay factor based on chunk age.  Normalization is required\n * because the cross-encoder reranker produces negative logit scores — naive\n * multiplication of a negative score by a decay factor (0 < d ≤ 1) would\n * make the score *less* negative, effectively boosting old results instead\n * of penalizing them.\n *\n * Formula: score_final = normalized * exp(-lambda * age_days)\n * where lambda = ln(2) / halfLifeDays, normalized ∈ [0,1]\n *\n * With default halfLifeDays=90, a 3-month-old chunk retains 50% of its\n * normalized score, a 6-month-old retains 25%, and a 1-year-old ~6%.\n *\n * Results without an updatedAt timestamp receive no decay penalty.\n * Results are re-sorted by the boosted score after application.\n *\n * @param results      Search results with optional updatedAt timestamps.\n * @param halfLifeDays Score halves every N days. Default 90 (~3 months).\n * @returns New array sorted by decayed normalized score (descending).\n */\nexport function applyRecencyBoost(\n  results: SearchResult[],\n  halfLifeDays = 90,\n): SearchResult[] {\n  if (halfLifeDays <= 0 || results.length === 0) return results;\n\n  const lambda = Math.LN2 / halfLifeDays;\n  const now = Date.now();\n\n  // Min-max normalize scores to [0,1] so multiplicative decay works\n  // correctly regardless of the raw score sign/scale.\n  const scores = results.map((r) => r.score);\n  const minScore = Math.min(...scores);\n  const maxScore = Math.max(...scores);\n  const range = maxScore - minScore;\n\n  return results\n    .map((r) => {\n      const normalized = range === 0 ? 1 : (r.score - minScore) / range;\n      // QW2: use the more recent of updated_at and last_accessed_at for recency decay\n      const effectiveTs = r.updatedAt != null && r.lastAccessedAt != null\n        ? Math.max(r.updatedAt, r.lastAccessedAt)\n        : (r.lastAccessedAt ?? r.updatedAt);\n      const decay = effectiveTs\n        ? Math.exp(-lambda * Math.max(0, (now - effectiveTs) / 86_400_000))\n        : 1; // no timestamp → no penalty\n      return { ...r, score: normalized * decay };\n    })\n    .sort((a, b) => b.score - a.score);\n}\n"],"mappings":"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"}

package/dist/search-fb-5ovj4.mjs

@@ -1,4 +0,0 @@
-import "./embeddings-DvRKcQyt.mjs";
-import { a as searchMemory, c as touchChunksLastAccessed, i as populateSlugs, n as buildFtsQuery, o as searchMemoryHybrid, r as isQuerySyntaxError, s as searchMemorySemantic, t as applyRecencyBoost } from "./search-B69cQwDB.mjs";
-
-export { applyRecencyBoost, searchMemory, searchMemorySemantic };

package/dist/sources-KBGEA_E6.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"sources-KBGEA_E6.mjs","names":[],"sources":["../src/cli/commands/memory/sources.ts"],"sourcesContent":["/**\n * `pai memory sources` — what the indexer is actually taking in.\n *\n * The index had grown to ~1.5M chunks against a vault of ~2,700 notes, and\n * nothing in the CLI could show why. `memory status` refuses to report at all\n * when the backend is not SQLite, and `daemon status` gives three totals with no\n * composition — so answering \"what is it indexing, and why is it re-indexing\"\n * meant hand-writing aggregate SQL against the container.\n *\n * The cause, when it was finally measured, was visible in one breakdown: the\n * vault indexer follows symlinks out of the vault into cloud-synced trees, and\n * those trees have mtimes rewritten by the sync client on content that has not\n * changed. Each rewrite re-chunks the file, and re-chunking assigns new chunk\n * ids, which discards the embeddings — so the embedder was re-doing work\n * indefinitely while never catching up.\n *\n * Hence the four sections below. Each one exists because it was needed:\n *   composition — the vault dwarfing everything else is the first clue\n *   roots       — where content enters from, which is how symlink leakage shows\n *   heaviest    — single files contributing thousands of chunks (attachments)\n *   churn       — chunks rewritten per day, which is what distinguishes a\n *                 backlog that will finish from a treadmill that never will\n */\n\nimport { ok, warn, dim, bold, header, renderTable } from \"../../utils.js\";\nimport type { StorageBackend } from \"../../../storage/interface.js\";\n\ninterface Row {\n  label: string;\n  chunks: number;\n  embedded: number;\n}\n\ninterface ChurnRow {\n  day: string;\n  chunks: number;\n  embedded: number;\n}\n\n/** A backend that can answer aggregate SQL. Both concrete backends can. */\ninterface Queryable {\n  backendType: \"sqlite\" | \"postgres\";\n  getPool?: () => { query: (sql: string) => Promise<{ rows: unknown[] }> };\n  getSqliteDb?: () => { prepare: (sql: string) => { all: () => unknown[] } };\n}\n\n/**\n * Run one aggregate query against whichever backend is configured.\n *\n * The two dialects differ only in the epoch conversion, so the SQL is passed in\n * per-dialect rather than abstracted — an abstraction over four reporting\n * queries would cost more than it saves.\n */\nasync function queryRows(\n  backend: Queryable,\n  pgSql: string,\n  sqliteSql: string\n): Promise<Record<string, unknown>[]> {\n  if (backend.backendType === \"postgres\" && backend.getPool) {\n    const res = await backend.getPool().query(pgSql);\n    return res.rows as Record<string, unknown>[];\n  }\n  if (backend.getSqliteDb) {\n    return backend.getSqliteDb().prepare(sqliteSql).all() as Record<string, unknown>[];\n  }\n  return [];\n}\n\nconst num = (v: unknown): number => Number(v ?? 0);\nconst pct = (part: number, whole: number): string =>\n  whole === 0 ? \"—\" : `${Math.round((part / whole) * 100)}%`;\n\n/** Group the leading path segments, which is where content enters the index. */\nexport function rootOf(path: string, depth = 2): string {\n  const parts = path.split(\"/\").filter(Boolean);\n  if (parts.length <= depth) return path;\n  return parts.slice(0, depth).join(\"/\") + \"/…\";\n}\n\nexport async function cmdMemorySources(\n  backend: StorageBackend,\n  opts: { limit?: number } = {}\n): Promise<void> {\n  const q = backend as unknown as Queryable;\n  const limit = opts.limit ?? 8;\n\n  // ---- composition -------------------------------------------------------\n  const comp = (await queryRows(\n    q,\n    `SELECT source, tier, COUNT(*) AS chunks, COUNT(embedding) AS embedded\n       FROM pai_chunks GROUP BY source, tier ORDER BY COUNT(*) DESC`,\n    `SELECT source, tier, COUNT(*) AS chunks,\n            SUM(CASE WHEN embedding IS NOT NULL THEN 1 ELSE 0 END) AS embedded\n       FROM memory_chunks GROUP BY source, tier ORDER BY COUNT(*) DESC`\n  )) as Array<{ source: string; tier: string; chunks: unknown; embedded: unknown }>;\n\n  if (comp.length === 0) {\n    console.log();\n    console.log(warn(`  Nothing indexed yet, or the backend is unreachable.`));\n    console.log(dim(`  Backend: ${q.backendType}`));\n    console.log();\n    return;\n  }\n\n  const totalChunks = comp.reduce((s, r) => s + num(r.chunks), 0);\n  const totalEmbedded = comp.reduce((s, r) => s + num(r.embedded), 0);\n\n  console.log();\n  console.log(header(`What the indexer has taken in`));\n  console.log();\n  console.log(\n    `  ${bold(totalChunks.toLocaleString())} chunks   ` +\n      `${totalEmbedded.toLocaleString()} embedded (${pct(totalEmbedded, totalChunks)})   ` +\n      dim(`backend: ${q.backendType}`)\n  );\n  console.log();\n\n  console.log(\n    renderTable(\n      [\"source / tier\", \"chunks\", \"share\", \"embedded\"],\n      comp.map((r) => [\n        `${r.source} / ${r.tier}`,\n        num(r.chunks).toLocaleString(),\n        pct(num(r.chunks), totalChunks),\n        `${num(r.embedded).toLocaleString()} (${pct(num(r.embedded), num(r.chunks))})`,\n      ])\n    )\n  );\n\n  // ---- where it enters from ---------------------------------------------\n  const paths = (await queryRows(\n    q,\n    `SELECT path, COUNT(*) AS chunks FROM pai_chunks GROUP BY path`,\n    `SELECT path, COUNT(*) AS chunks FROM memory_chunks GROUP BY path`\n  )) as Array<{ path: string; chunks: unknown }>;\n\n  const byRoot = new Map<string, number>();\n  for (const r of paths) {\n    const k = rootOf(String(r.path ?? \"\"));\n    byRoot.set(k, (byRoot.get(k) ?? 0) + num(r.chunks));\n  }\n  const roots = [...byRoot.entries()].sort((a, b) => b[1] - a[1]).slice(0, limit);\n\n  console.log();\n  console.log(header(`Where it comes from`));\n  console.log(dim(`  A root you did not expect here is usually a symlink leading out of the vault.`));\n  console.log();\n  console.log(\n    renderTable(\n      [\"root\", \"chunks\", \"share\"],\n      roots.map(([k, v]) => [k, v.toLocaleString(), pct(v, totalChunks)])\n    )\n  );\n\n  // ---- heaviest single files -------------------------------------------\n  const heaviest = [...paths]\n    .sort((a, b) => num(b.chunks) - num(a.chunks))\n    .slice(0, limit);\n\n  console.log();\n  console.log(header(`Heaviest single files`));\n  console.log();\n  console.log(\n    renderTable(\n      [\"chunks\", \"path\"],\n      heaviest.map((r) => [num(r.chunks).toLocaleString(), tail(String(r.path ?? \"\"), 62)])\n    )\n  );\n\n  // ---- churn ------------------------------------------------------------\n  // The section that distinguishes a backlog from a treadmill. A day with a\n  // large chunk count and a small embedded count means those chunks were\n  // rewritten and their embeddings thrown away.\n  const churn = (await queryRows(\n    q,\n    `SELECT to_char(to_timestamp(updated_at/1000),'YYYY-MM-DD') AS day,\n            COUNT(*) AS chunks, COUNT(embedding) AS embedded\n       FROM pai_chunks GROUP BY day ORDER BY day DESC LIMIT 10`,\n    `SELECT date(updated_at/1000,'unixepoch') AS day, COUNT(*) AS chunks,\n            SUM(CASE WHEN embedding IS NOT NULL THEN 1 ELSE 0 END) AS embedded\n       FROM memory_chunks GROUP BY day ORDER BY day DESC LIMIT 10`\n  )) as unknown as ChurnRow[];\n\n  console.log();\n  console.log(header(`Rewritten per day`));\n  console.log(\n    dim(`  Many chunks with few embedded means they were re-chunked and their`)\n  );\n  console.log(dim(`  embeddings discarded — work the embedder has to redo.`));\n  console.log();\n  console.log(\n    renderTable(\n      [\"day\", \"chunks touched\", \"of those embedded\"],\n      churn.map((r) => [\n        String(r.day),\n        num(r.chunks).toLocaleString(),\n        `${num(r.embedded).toLocaleString()} (${pct(num(r.embedded), num(r.chunks))})`,\n      ])\n    )\n  );\n\n  const missing = totalChunks - totalEmbedded;\n  console.log();\n  if (missing > 0) {\n    console.log(`  ${bold(missing.toLocaleString())} chunks still need embedding.`);\n  } else {\n    console.log(ok(`  Everything indexed is embedded.`));\n  }\n  console.log();\n}\n\n/** Keep the informative end of a long path. */\nfunction tail(s: string, n: number): string {\n  return s.length <= n ? s : \"…\" + s.slice(-(n - 1));\n}\n\n"],"mappings":"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"}

package/dist/sqlite-By6r2YhZ.mjs

@@ -1,271 +0,0 @@
-import "./embeddings-DvRKcQyt.mjs";
-import { a as searchMemory, s as searchMemorySemantic } from "./search-B69cQwDB.mjs";
-
-//#region src/storage/sqlite.ts
-var SQLiteBackend = class {
-	backendType = "sqlite";
-	db;
-	constructor(db) {
-		this.db = db;
-	}
-	/**
-	* Expose the raw better-sqlite3 Database handle.
-	* Used by the daemon to pass to indexAll() which still uses the synchronous API directly.
-	*/
-	getRawDb() {
-		return this.db;
-	}
-	/**
-	* Alias for getRawDb() — used by the dispatcher for operations that require
-	* direct SQLite access (e.g. memory_feedback, touchChunksLastAccessed).
-	*/
-	getSqliteDb() {
-		return this.db;
-	}
-	async close() {
-		try {
-			this.db.close();
-		} catch {}
-	}
-	async getStats() {
-		return {
-			files: this.db.prepare("SELECT COUNT(*) AS n FROM memory_files").get().n,
-			chunks: this.db.prepare("SELECT COUNT(*) AS n FROM memory_chunks").get().n
-		};
-	}
-	async getFileHash(projectId, path) {
-		return this.db.prepare("SELECT hash FROM memory_files WHERE project_id = ? AND path = ?").get(projectId, path)?.hash;
-	}
-	async upsertFile(file) {
-		this.db.prepare(`INSERT INTO memory_files (project_id, path, source, tier, hash, mtime, size)
-         VALUES (?, ?, ?, ?, ?, ?, ?)
-         ON CONFLICT(project_id, path) DO UPDATE SET
-           source = excluded.source,
-           tier   = excluded.tier,
-           hash   = excluded.hash,
-           mtime  = excluded.mtime,
-           size   = excluded.size`).run(file.projectId, file.path, file.source, file.tier, file.hash, file.mtime, file.size);
-	}
-	async getChunkIds(projectId, path) {
-		return this.db.prepare("SELECT id FROM memory_chunks WHERE project_id = ? AND path = ?").all(projectId, path).map((r) => r.id);
-	}
-	async deleteChunksForFile(projectId, path) {
-		const ids = await this.getChunkIds(projectId, path);
-		const deleteFts = this.db.prepare("DELETE FROM memory_fts WHERE id = ?");
-		const deleteChunks = this.db.prepare("DELETE FROM memory_chunks WHERE project_id = ? AND path = ?");
-		this.db.transaction(() => {
-			for (const id of ids) deleteFts.run(id);
-			deleteChunks.run(projectId, path);
-		})();
-	}
-	async insertChunks(chunks) {
-		if (chunks.length === 0) return;
-		const insertChunk = this.db.prepare(`INSERT INTO memory_chunks (id, project_id, source, tier, path, start_line, end_line, hash, text, updated_at)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
-		const insertFts = this.db.prepare(`INSERT INTO memory_fts (text, id, project_id, path, source, tier, start_line, end_line)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`);
-		this.db.transaction(() => {
-			for (const c of chunks) {
-				insertChunk.run(c.id, c.projectId, c.source, c.tier, c.path, c.startLine, c.endLine, c.hash, c.text, c.updatedAt);
-				insertFts.run(c.text, c.id, c.projectId, c.path, c.source, c.tier, c.startLine, c.endLine);
-			}
-		})();
-	}
-	async getDistinctChunkPaths(projectId) {
-		return this.db.prepare("SELECT DISTINCT path FROM memory_chunks WHERE project_id = ?").all(projectId).map((r) => r.path);
-	}
-	async deletePaths(projectId, paths) {
-		if (paths.length === 0) return;
-		const deleteFts = this.db.prepare("DELETE FROM memory_fts WHERE id = ?");
-		const deleteChunks = this.db.prepare("DELETE FROM memory_chunks WHERE project_id = ? AND path = ?");
-		const deleteFile = this.db.prepare("DELETE FROM memory_files WHERE project_id = ? AND path = ?");
-		this.db.transaction(() => {
-			for (const path of paths) {
-				const ids = this.db.prepare("SELECT id FROM memory_chunks WHERE project_id = ? AND path = ?").all(projectId, path);
-				for (const { id } of ids) deleteFts.run(id);
-				deleteChunks.run(projectId, path);
-				deleteFile.run(projectId, path);
-			}
-		})();
-	}
-	async getUnembeddedChunkIds(projectId, limit) {
-		const conditions = ["embedding IS NULL"];
-		const params = [];
-		if (projectId !== void 0) {
-			conditions.push("project_id = ?");
-			params.push(projectId);
-		}
-		const where = "WHERE " + conditions.join(" AND ");
-		return this.db.prepare(`SELECT id, text, project_id, path FROM memory_chunks ${where}
-        ORDER BY CASE
-          WHEN path LIKE '🧠 Ideaverse/%' THEN 0
-          WHEN path LIKE 'Z - Zettelkasten/%' THEN 0
-          WHEN path LIKE '💼 Business/%' THEN 0
-          WHEN path LIKE '📆 Meetings/%' THEN 1
-          WHEN path LIKE '💡 Insights/%' THEN 1
-          WHEN path LIKE '👨‍💻 People/%' THEN 1
-          WHEN path LIKE 'University/%' THEN 1
-          WHEN path LIKE 'Copilot/%' THEN 1
-          WHEN path LIKE '🗓️ Daily Notes/%' THEN 2
-          WHEN path LIKE 'PAI/%' THEN 3
-          WHEN path LIKE '09-job-search/%' THEN 4
-          WHEN path LIKE 'seriousletter/%' THEN 4
-          WHEN path LIKE 'Attachments/%' THEN 5
-          ELSE 2
-        END, id${limit !== void 0 ? " LIMIT ?" : ""}`).all(...params, ...limit !== void 0 ? [limit] : []);
-	}
-	async updateEmbedding(chunkId, embedding) {
-		this.db.prepare("UPDATE memory_chunks SET embedding = ? WHERE id = ?").run(embedding, chunkId);
-	}
-	async searchKeyword(query, opts) {
-		return searchMemory(this.db, query, opts);
-	}
-	async searchSemantic(queryEmbedding, opts) {
-		return searchMemorySemantic(this.db, queryEmbedding, opts);
-	}
-	vaultNotSupported() {
-		throw new Error("Vault operations require the Postgres backend");
-	}
-	async upsertVaultFile() {
-		this.vaultNotSupported();
-	}
-	async deleteVaultFile() {
-		this.vaultNotSupported();
-	}
-	async getVaultFile() {
-		this.vaultNotSupported();
-	}
-	async getVaultFileByInode() {
-		this.vaultNotSupported();
-	}
-	async getAllVaultFiles() {
-		this.vaultNotSupported();
-	}
-	async getRecentVaultFiles() {
-		this.vaultNotSupported();
-	}
-	async countVaultFiles() {
-		this.vaultNotSupported();
-	}
-	async upsertVaultAliases() {
-		this.vaultNotSupported();
-	}
-	async deleteVaultAliases() {
-		this.vaultNotSupported();
-	}
-	async replaceLinksForSources() {
-		this.vaultNotSupported();
-	}
-	async getLinksFromSource() {
-		this.vaultNotSupported();
-	}
-	async getLinksToTarget() {
-		this.vaultNotSupported();
-	}
-	async getVaultLinkGraph() {
-		this.vaultNotSupported();
-	}
-	async upsertVaultHealth() {
-		this.vaultNotSupported();
-	}
-	async getVaultHealth() {
-		this.vaultNotSupported();
-	}
-	async getOrphans() {
-		this.vaultNotSupported();
-	}
-	async getDeadLinks() {
-		this.vaultNotSupported();
-	}
-	async upsertNameIndex() {
-		this.vaultNotSupported();
-	}
-	async replaceNameIndex() {
-		this.vaultNotSupported();
-	}
-	async resolveVaultName() {
-		this.vaultNotSupported();
-	}
-	async searchVaultNameIndex() {
-		this.vaultNotSupported();
-	}
-	async getVaultFilesByPaths() {
-		this.vaultNotSupported();
-	}
-	async getVaultFilesByPathsAfter() {
-		this.vaultNotSupported();
-	}
-	async getVaultLinksFromPaths() {
-		this.vaultNotSupported();
-	}
-	async getChunksWithEmbeddings() {
-		this.vaultNotSupported();
-	}
-	async getChunksForPath() {
-		this.vaultNotSupported();
-	}
-	async searchChunksByText() {
-		this.vaultNotSupported();
-	}
-	async countVaultFilesWithPrefix() {
-		this.vaultNotSupported();
-	}
-	async countVaultFilesAfter() {
-		this.vaultNotSupported();
-	}
-	async countVaultLinksWithPrefix() {
-		this.vaultNotSupported();
-	}
-	async countVaultLinksAfter() {
-		this.vaultNotSupported();
-	}
-	async getDeadLinksWithLineNumbers() {
-		this.vaultNotSupported();
-	}
-	async getDeadLinksWithPrefix() {
-		this.vaultNotSupported();
-	}
-	async getDeadLinksAfter() {
-		this.vaultNotSupported();
-	}
-	async getOrphansWithPrefix() {
-		this.vaultNotSupported();
-	}
-	async getOrphansAfter() {
-		this.vaultNotSupported();
-	}
-	async getLowConnectivity() {
-		this.vaultNotSupported();
-	}
-	async getLowConnectivityWithPrefix() {
-		this.vaultNotSupported();
-	}
-	async getLowConnectivityAfter() {
-		this.vaultNotSupported();
-	}
-	async getAllVaultFilePaths() {
-		this.vaultNotSupported();
-	}
-	async getVaultFilePathsWithPrefix() {
-		this.vaultNotSupported();
-	}
-	async getVaultFilePathsAfter() {
-		this.vaultNotSupported();
-	}
-	async getVaultLinkEdges() {
-		this.vaultNotSupported();
-	}
-	async getVaultLinkEdgesWithPrefix() {
-		this.vaultNotSupported();
-	}
-	async getVaultLinkEdgesAfter() {
-		this.vaultNotSupported();
-	}
-	async getVaultAlias() {
-		this.vaultNotSupported();
-	}
-};
-
-//#endregion
-export { SQLiteBackend };
-//# sourceMappingURL=sqlite-By6r2YhZ.mjs.map