@tekmidian/pai 0.1.0

package/dist/search-PjftDxxs.mjs

@@ -0,0 +1,282 @@
+import { t as __exportAll } from "./rolldown-runtime-95iHPtFO.mjs";
+import { n as cosineSimilarity, r as deserializeEmbedding } from "./embeddings-mfqv-jFu.mjs";
+
+//#region src/memory/search.ts
+var search_exports = /* @__PURE__ */ __exportAll({
+	buildFtsQuery: () => buildFtsQuery,
+	populateSlugs: () => populateSlugs,
+	searchMemory: () => searchMemory,
+	searchMemoryHybrid: () => searchMemoryHybrid,
+	searchMemorySemantic: () => searchMemorySemantic
+});
+const STOP_WORDS = new Set([
+	"a",
+	"an",
+	"and",
+	"are",
+	"as",
+	"at",
+	"be",
+	"been",
+	"but",
+	"by",
+	"do",
+	"for",
+	"from",
+	"has",
+	"have",
+	"he",
+	"her",
+	"him",
+	"his",
+	"how",
+	"i",
+	"if",
+	"in",
+	"is",
+	"it",
+	"its",
+	"me",
+	"my",
+	"not",
+	"of",
+	"on",
+	"or",
+	"our",
+	"out",
+	"she",
+	"so",
+	"that",
+	"the",
+	"their",
+	"them",
+	"they",
+	"this",
+	"to",
+	"up",
+	"us",
+	"was",
+	"we",
+	"were",
+	"what",
+	"when",
+	"who",
+	"will",
+	"with",
+	"you",
+	"your"
+]);
+/**
+* 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
+*/
+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.project_id,
+      c.path,
+      c.start_line,
+      c.end_line,
+      c.text       AS snippet,
+      c.tier,
+      c.source,
+      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 {
+		return [];
+	}
+	const minScore = opts?.minScore ?? 0;
+	return rows.map((row) => ({
+		projectId: row.project_id,
+		path: row.path,
+		startLine: row.start_line,
+		endLine: row.end_line,
+		snippet: row.snippet,
+		score: -row.bm25_score,
+		tier: row.tier,
+		source: row.source
+	})).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
+    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));
+		return {
+			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
+		};
+	});
+	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);
+}
+/**
+* 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)
+	}));
+}
+
+//#endregion
+export { searchMemorySemantic as a, searchMemoryHybrid as i, populateSlugs as n, search_exports as o, searchMemory as r, buildFtsQuery as t };
+//# sourceMappingURL=search-PjftDxxs.mjs.map

package/dist/search-PjftDxxs.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"search-PjftDxxs.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\";\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}\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// ---------------------------------------------------------------------------\n// Stop words\n// ---------------------------------------------------------------------------\n\nconst STOP_WORDS = new Set([\n  \"a\", \"an\", \"and\", \"are\", \"as\", \"at\", \"be\", \"been\", \"but\", \"by\",\n  \"do\", \"for\", \"from\", \"has\", \"have\", \"he\", \"her\", \"him\", \"his\",\n  \"how\", \"i\", \"if\", \"in\", \"is\", \"it\", \"its\", \"me\", \"my\", \"not\",\n  \"of\", \"on\", \"or\", \"our\", \"out\", \"she\", \"so\", \"that\", \"the\",\n  \"their\", \"them\", \"they\", \"this\", \"to\", \"up\", \"us\", \"was\", \"we\",\n  \"were\", \"what\", \"when\", \"who\", \"will\", \"with\", \"you\", \"your\",\n]);\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 */\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.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      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    project_id: number;\n    path: string;\n    start_line: number;\n    end_line: number;\n    snippet: string;\n    tier: string;\n    source: string;\n    bm25_score: number;\n  }>;\n\n  try {\n    rows = db.prepare(sql).all(...params) as typeof rows;\n  } catch {\n    // FTS5 MATCH throws when the query is invalid — return empty results\n    return [];\n  }\n\n  const minScore = opts?.minScore ?? 0.0;\n\n  return rows\n    .map((row) => ({\n      projectId: row.project_id,\n      path: row.path,\n      startLine: row.start_line,\n      endLine: row.end_line,\n      snippet: row.snippet,\n      // Negate so higher = better match for callers\n      score: -row.bm25_score,\n      tier: row.tier,\n      source: row.source,\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\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  }>;\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 score = cosineSimilarity(queryEmbedding, vec);\n    return {\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    };\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// 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"],"mappings":"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"}

package/dist/sqlite-CHUrNtbI.mjs

@@ -0,0 +1,90 @@
+import "./embeddings-mfqv-jFu.mjs";
+import { a as searchMemorySemantic, r as searchMemory } from "./search-PjftDxxs.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;
+	}
+	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 getUnembeddedChunkIds(projectId) {
+		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 FROM memory_chunks ${where} ORDER BY id`).all(...params);
+	}
+	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);
+	}
+};
+
+//#endregion
+export { SQLiteBackend };
+//# sourceMappingURL=sqlite-CHUrNtbI.mjs.map

package/dist/sqlite-CHUrNtbI.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-CHUrNtbI.mjs","names":[],"sources":["../src/storage/sqlite.ts"],"sourcesContent":["/**\n * SQLiteBackend — wraps the existing better-sqlite3 federation.db\n * behind the StorageBackend interface.\n *\n * This is a thin adapter.  The heavy lifting is all in the existing\n * memory/indexer.ts and memory/search.ts code; we just provide a\n * backend-agnostic surface so the daemon and tools can call either\n * SQLite or Postgres transparently.\n */\n\nimport type { Database } from \"better-sqlite3\";\nimport type { StorageBackend, ChunkRow, FileRow, FederationStats } from \"./interface.js\";\nimport type { SearchResult, SearchOptions } from \"../memory/search.js\";\nimport { searchMemory, searchMemorySemantic } from \"../memory/search.js\";\n\nexport class SQLiteBackend implements StorageBackend {\n  readonly backendType = \"sqlite\" as const;\n\n  private db: Database;\n\n  constructor(db: Database) {\n    this.db = db;\n  }\n\n  /**\n   * Expose the raw better-sqlite3 Database handle.\n   * Used by the daemon to pass to indexAll() which still uses the synchronous API directly.\n   */\n  getRawDb(): Database {\n    return this.db;\n  }\n\n  // -------------------------------------------------------------------------\n  // Lifecycle\n  // -------------------------------------------------------------------------\n\n  async close(): Promise<void> {\n    try {\n      this.db.close();\n    } catch {\n      // ignore\n    }\n  }\n\n  async getStats(): Promise<FederationStats> {\n    const files = (\n      this.db.prepare(\"SELECT COUNT(*) AS n FROM memory_files\").get() as { n: number }\n    ).n;\n    const chunks = (\n      this.db.prepare(\"SELECT COUNT(*) AS n FROM memory_chunks\").get() as { n: number }\n    ).n;\n    return { files, chunks };\n  }\n\n  // -------------------------------------------------------------------------\n  // File tracking\n  // -------------------------------------------------------------------------\n\n  async getFileHash(projectId: number, path: string): Promise<string | undefined> {\n    const row = this.db\n      .prepare(\"SELECT hash FROM memory_files WHERE project_id = ? AND path = ?\")\n      .get(projectId, path) as { hash: string } | undefined;\n    return row?.hash;\n  }\n\n  async upsertFile(file: FileRow): Promise<void> {\n    this.db\n      .prepare(\n        `INSERT INTO memory_files (project_id, path, source, tier, hash, mtime, size)\n         VALUES (?, ?, ?, ?, ?, ?, ?)\n         ON CONFLICT(project_id, path) DO UPDATE SET\n           source = excluded.source,\n           tier   = excluded.tier,\n           hash   = excluded.hash,\n           mtime  = excluded.mtime,\n           size   = excluded.size`\n      )\n      .run(file.projectId, file.path, file.source, file.tier, file.hash, file.mtime, file.size);\n  }\n\n  // -------------------------------------------------------------------------\n  // Chunk management\n  // -------------------------------------------------------------------------\n\n  async getChunkIds(projectId: number, path: string): Promise<string[]> {\n    const rows = this.db\n      .prepare(\"SELECT id FROM memory_chunks WHERE project_id = ? AND path = ?\")\n      .all(projectId, path) as Array<{ id: string }>;\n    return rows.map((r) => r.id);\n  }\n\n  async deleteChunksForFile(projectId: number, path: string): Promise<void> {\n    const ids = await this.getChunkIds(projectId, path);\n    const deleteFts = this.db.prepare(\"DELETE FROM memory_fts WHERE id = ?\");\n    const deleteChunks = this.db.prepare(\n      \"DELETE FROM memory_chunks WHERE project_id = ? AND path = ?\"\n    );\n    this.db.transaction(() => {\n      for (const id of ids) {\n        deleteFts.run(id);\n      }\n      deleteChunks.run(projectId, path);\n    })();\n  }\n\n  async insertChunks(chunks: ChunkRow[]): Promise<void> {\n    if (chunks.length === 0) return;\n\n    const insertChunk = this.db.prepare(\n      `INSERT INTO memory_chunks (id, project_id, source, tier, path, start_line, end_line, hash, text, updated_at)\n       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`\n    );\n    const insertFts = this.db.prepare(\n      `INSERT INTO memory_fts (text, id, project_id, path, source, tier, start_line, end_line)\n       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`\n    );\n\n    this.db.transaction(() => {\n      for (const c of chunks) {\n        insertChunk.run(\n          c.id,\n          c.projectId,\n          c.source,\n          c.tier,\n          c.path,\n          c.startLine,\n          c.endLine,\n          c.hash,\n          c.text,\n          c.updatedAt\n        );\n        insertFts.run(\n          c.text,\n          c.id,\n          c.projectId,\n          c.path,\n          c.source,\n          c.tier,\n          c.startLine,\n          c.endLine\n        );\n      }\n    })();\n  }\n\n  async getUnembeddedChunkIds(projectId?: number): Promise<Array<{ id: string; text: string }>> {\n    const conditions = [\"embedding IS NULL\"];\n    const params: (string | number)[] = [];\n\n    if (projectId !== undefined) {\n      conditions.push(\"project_id = ?\");\n      params.push(projectId);\n    }\n\n    const where = \"WHERE \" + conditions.join(\" AND \");\n    const rows = this.db\n      .prepare(`SELECT id, text FROM memory_chunks ${where} ORDER BY id`)\n      .all(...params) as Array<{ id: string; text: string }>;\n    return rows;\n  }\n\n  async updateEmbedding(chunkId: string, embedding: Buffer): Promise<void> {\n    this.db\n      .prepare(\"UPDATE memory_chunks SET embedding = ? WHERE id = ?\")\n      .run(embedding, chunkId);\n  }\n\n  // -------------------------------------------------------------------------\n  // Search\n  // -------------------------------------------------------------------------\n\n  async searchKeyword(query: string, opts?: SearchOptions): Promise<SearchResult[]> {\n    return searchMemory(this.db, query, opts);\n  }\n\n  async searchSemantic(queryEmbedding: Float32Array, opts?: SearchOptions): Promise<SearchResult[]> {\n    return searchMemorySemantic(this.db, queryEmbedding, opts);\n  }\n}\n"],"mappings":";;;;AAeA,IAAa,gBAAb,MAAqD;CACnD,AAAS,cAAc;CAEvB,AAAQ;CAER,YAAY,IAAc;AACxB,OAAK,KAAK;;;;;;CAOZ,WAAqB;AACnB,SAAO,KAAK;;CAOd,MAAM,QAAuB;AAC3B,MAAI;AACF,QAAK,GAAG,OAAO;UACT;;CAKV,MAAM,WAAqC;AAOzC,SAAO;GAAE,OALP,KAAK,GAAG,QAAQ,yCAAyC,CAAC,KAAK,CAC/D;GAIc,QAFd,KAAK,GAAG,QAAQ,0CAA0C,CAAC,KAAK,CAChE;GACsB;;CAO1B,MAAM,YAAY,WAAmB,MAA2C;AAI9E,SAHY,KAAK,GACd,QAAQ,kEAAkE,CAC1E,IAAI,WAAW,KAAK,EACX;;CAGd,MAAM,WAAW,MAA8B;AAC7C,OAAK,GACF,QACC;;;;;;;mCAQD,CACA,IAAI,KAAK,WAAW,KAAK,MAAM,KAAK,QAAQ,KAAK,MAAM,KAAK,MAAM,KAAK,OAAO,KAAK,KAAK;;CAO7F,MAAM,YAAY,WAAmB,MAAiC;AAIpE,SAHa,KAAK,GACf,QAAQ,iEAAiE,CACzE,IAAI,WAAW,KAAK,CACX,KAAK,MAAM,EAAE,GAAG;;CAG9B,MAAM,oBAAoB,WAAmB,MAA6B;EACxE,MAAM,MAAM,MAAM,KAAK,YAAY,WAAW,KAAK;EACnD,MAAM,YAAY,KAAK,GAAG,QAAQ,sCAAsC;EACxE,MAAM,eAAe,KAAK,GAAG,QAC3B,8DACD;AACD,OAAK,GAAG,kBAAkB;AACxB,QAAK,MAAM,MAAM,IACf,WAAU,IAAI,GAAG;AAEnB,gBAAa,IAAI,WAAW,KAAK;IACjC,EAAE;;CAGN,MAAM,aAAa,QAAmC;AACpD,MAAI,OAAO,WAAW,EAAG;EAEzB,MAAM,cAAc,KAAK,GAAG,QAC1B;8CAED;EACD,MAAM,YAAY,KAAK,GAAG,QACxB;wCAED;AAED,OAAK,GAAG,kBAAkB;AACxB,QAAK,MAAM,KAAK,QAAQ;AACtB,gBAAY,IACV,EAAE,IACF,EAAE,WACF,EAAE,QACF,EAAE,MACF,EAAE,MACF,EAAE,WACF,EAAE,SACF,EAAE,MACF,EAAE,MACF,EAAE,UACH;AACD,cAAU,IACR,EAAE,MACF,EAAE,IACF,EAAE,WACF,EAAE,MACF,EAAE,QACF,EAAE,MACF,EAAE,WACF,EAAE,QACH;;IAEH,EAAE;;CAGN,MAAM,sBAAsB,WAAkE;EAC5F,MAAM,aAAa,CAAC,oBAAoB;EACxC,MAAM,SAA8B,EAAE;AAEtC,MAAI,cAAc,QAAW;AAC3B,cAAW,KAAK,iBAAiB;AACjC,UAAO,KAAK,UAAU;;EAGxB,MAAM,QAAQ,WAAW,WAAW,KAAK,QAAQ;AAIjD,SAHa,KAAK,GACf,QAAQ,sCAAsC,MAAM,cAAc,CAClE,IAAI,GAAG,OAAO;;CAInB,MAAM,gBAAgB,SAAiB,WAAkC;AACvE,OAAK,GACF,QAAQ,sDAAsD,CAC9D,IAAI,WAAW,QAAQ;;CAO5B,MAAM,cAAc,OAAe,MAA+C;AAChF,SAAO,aAAa,KAAK,IAAI,OAAO,KAAK;;CAG3C,MAAM,eAAe,gBAA8B,MAA+C;AAChG,SAAO,qBAAqB,KAAK,IAAI,gBAAgB,KAAK"}