@tekmidian/pai 0.66.0 → 0.66.2

package/dist/sqlite-CqsTy6xo.mjs

@@ -1,936 +0,0 @@
-import { i as fileContentHash, n as chunkMarkdown, s as sha256File } from "./chunker-BH4i-F2b.mjs";
-import { a as parseSessionTitleChunk, c as yieldToEventLoop, i as isPathTooBroadForContentScan, n as chunkId, o as walkContentFiles, r as detectTier, s as walkMdFiles, t as INDEX_YIELD_EVERY } from "./helpers-BRCJg0G3.mjs";
-import { t as STOP_WORDS } from "./stop-words-BdQuaE9K.mjs";
-import { n as buildFtsQuery, r as isQuerySyntaxError } from "./search-BOSphCJ1.mjs";
-import { n as cosineSimilarity, r as deserializeEmbedding } from "./embeddings-Bx3q0QOY.mjs";
-import { t as entityContentId } from "./kg-entity-DCOcsVFD.mjs";
-import { existsSync, readFileSync, statSync } from "node:fs";
-import { basename, join, relative } from "node:path";
-
-//#region src/storage/sqlite/indexer.ts
-/**
-* Synchronous (SQLite) indexer — moved from memory/indexer/sync.ts so the
-* only file that opens prepared statements against the federation database
-* lives under src/storage/ (design doc docs/design/postgres-only.md, unit 7).
-*
-* Scans project memory/ and Notes/ directories, chunks markdown files, and
-* inserts the resulting chunks into the federation memory store for BM25
-* search. Uses raw better-sqlite3 Database directly for maximum SQLite
-* performance (synchronous transactions, no serialisation overhead) — the
-* reason SQLiteBackend keeps this path instead of routing through the
-* generic (StorageBackend) indexer that Postgres uses.
-*/
-/**
-* Index a single file into the federation database.
-*
-* @returns true if the file was re-indexed (changed or new), false if skipped.
-*/
-function indexFile(db, projectId, rootPath, relativePath, source, tier) {
-	const absPath = join(rootPath, relativePath);
-	let content;
-	let stat;
-	try {
-		content = readFileSync(absPath, "utf8");
-		stat = statSync(absPath);
-	} catch {
-		return false;
-	}
-	const hash = fileContentHash(content);
-	const mtime = Math.floor(stat.mtimeMs);
-	const size = stat.size;
-	if (db.prepare("SELECT hash FROM memory_files WHERE project_id = ? AND path = ?").get(projectId, relativePath)?.hash === hash) return false;
-	const oldChunkIds = db.prepare("SELECT id FROM memory_chunks WHERE project_id = ? AND path = ?").all(projectId, relativePath);
-	const deleteFts = db.prepare("DELETE FROM memory_fts WHERE id = ?");
-	const deleteChunk = db.prepare("DELETE FROM memory_chunks WHERE project_id = ? AND path = ?");
-	db.transaction(() => {
-		for (const row of oldChunkIds) deleteFts.run(row.id);
-		deleteChunk.run(projectId, relativePath);
-	})();
-	const chunks = chunkMarkdown(content);
-	const insertChunk = db.prepare(`
-    INSERT INTO memory_chunks (id, project_id, source, tier, path, start_line, end_line, hash, text, updated_at)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-  `);
-	const insertFts = db.prepare(`
-    INSERT INTO memory_fts (text, id, project_id, path, source, tier, start_line, end_line)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-  `);
-	const upsertFile = 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
-  `);
-	const updatedAt = Date.now();
-	db.transaction(() => {
-		for (let i = 0; i < chunks.length; i++) {
-			const chunk = chunks[i];
-			const id = chunkId(projectId, relativePath, i, chunk.startLine, chunk.endLine);
-			insertChunk.run(id, projectId, source, tier, relativePath, chunk.startLine, chunk.endLine, chunk.hash, chunk.text, updatedAt);
-			insertFts.run(chunk.text, id, projectId, relativePath, source, tier, chunk.startLine, chunk.endLine);
-		}
-		upsertFile.run(projectId, relativePath, source, tier, hash, mtime, size);
-	})();
-	return true;
-}
-/**
-* Index all memory, Notes, and content files for a single registered project.
-*/
-async function indexProject(db, projectId, rootPath, claudeNotesDir) {
-	const result = {
-		filesProcessed: 0,
-		chunksCreated: 0,
-		filesSkipped: 0
-	};
-	const filesToIndex = [];
-	const rootMemoryMd = join(rootPath, "MEMORY.md");
-	if (existsSync(rootMemoryMd)) filesToIndex.push({
-		absPath: rootMemoryMd,
-		rootBase: rootPath,
-		source: "memory",
-		tier: "evergreen"
-	});
-	const memoryDir = join(rootPath, "memory");
-	for (const absPath of walkMdFiles(memoryDir)) {
-		const tier = detectTier(relative(rootPath, absPath));
-		filesToIndex.push({
-			absPath,
-			rootBase: rootPath,
-			source: "memory",
-			tier
-		});
-	}
-	const notesDir = join(rootPath, "Notes");
-	for (const absPath of walkMdFiles(notesDir)) filesToIndex.push({
-		absPath,
-		rootBase: rootPath,
-		source: "notes",
-		tier: "session"
-	});
-	{
-		const titleInsertChunk = db.prepare(`
-      INSERT OR IGNORE INTO memory_chunks (id, project_id, source, tier, path, start_line, end_line, hash, text, updated_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `);
-		const titleInsertFts = db.prepare(`
-      INSERT OR IGNORE INTO memory_fts (text, id, project_id, path, source, tier, start_line, end_line)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-    `);
-		const updatedAt = Date.now();
-		for (const absPath of walkMdFiles(notesDir)) {
-			const text = parseSessionTitleChunk(basename(absPath));
-			if (!text) continue;
-			const syntheticPath = `${relative(rootPath, absPath)}::title`;
-			const id = chunkId(projectId, syntheticPath, 0, 0, 0);
-			const hash = sha256File(text);
-			db.transaction(() => {
-				titleInsertChunk.run(id, projectId, "notes", "session", syntheticPath, 0, 0, hash, text, updatedAt);
-				titleInsertFts.run(text, id, projectId, syntheticPath, "notes", "session", 0, 0);
-			})();
-		}
-	}
-	if (!isPathTooBroadForContentScan(rootPath)) for (const absPath of walkContentFiles(rootPath)) filesToIndex.push({
-		absPath,
-		rootBase: rootPath,
-		source: "content",
-		tier: "topic"
-	});
-	if (claudeNotesDir && claudeNotesDir !== notesDir) {
-		for (const absPath of walkMdFiles(claudeNotesDir)) filesToIndex.push({
-			absPath,
-			rootBase: claudeNotesDir,
-			source: "notes",
-			tier: "session"
-		});
-		{
-			const updatedAt = Date.now();
-			const titleInsertChunk2 = db.prepare(`
-        INSERT OR IGNORE INTO memory_chunks (id, project_id, source, tier, path, start_line, end_line, hash, text, updated_at)
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-      `);
-			const titleInsertFts2 = db.prepare(`
-        INSERT OR IGNORE INTO memory_fts (text, id, project_id, path, source, tier, start_line, end_line)
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-      `);
-			for (const absPath of walkMdFiles(claudeNotesDir)) {
-				const text = parseSessionTitleChunk(basename(absPath));
-				if (!text) continue;
-				const syntheticPath = `${relative(claudeNotesDir, absPath)}::title`;
-				const id = chunkId(projectId, syntheticPath, 0, 0, 0);
-				const hash = sha256File(text);
-				db.transaction(() => {
-					titleInsertChunk2.run(id, projectId, "notes", "session", syntheticPath, 0, 0, hash, text, updatedAt);
-					titleInsertFts2.run(text, id, projectId, syntheticPath, "notes", "session", 0, 0);
-				})();
-			}
-		}
-		if (claudeNotesDir.endsWith("/Notes")) {
-			const claudeProjectDir = claudeNotesDir.slice(0, -6);
-			const claudeMemoryDir = join(claudeProjectDir, "memory");
-			const claudeMemoryMd = join(claudeProjectDir, "MEMORY.md");
-			if (existsSync(claudeMemoryMd)) filesToIndex.push({
-				absPath: claudeMemoryMd,
-				rootBase: claudeProjectDir,
-				source: "memory",
-				tier: "evergreen"
-			});
-			for (const absPath of walkMdFiles(claudeMemoryDir)) {
-				const tier = detectTier(relative(claudeProjectDir, absPath));
-				filesToIndex.push({
-					absPath,
-					rootBase: claudeProjectDir,
-					source: "memory",
-					tier
-				});
-			}
-		}
-	}
-	await yieldToEventLoop();
-	let filesSinceYield = 0;
-	for (const { absPath, rootBase, source, tier } of filesToIndex) {
-		if (filesSinceYield >= INDEX_YIELD_EVERY) {
-			await yieldToEventLoop();
-			filesSinceYield = 0;
-		}
-		filesSinceYield++;
-		const relPath = relative(rootBase, absPath);
-		if (indexFile(db, projectId, rootBase, relPath, source, tier)) {
-			const count = db.prepare("SELECT COUNT(*) as n FROM memory_chunks WHERE project_id = ? AND path = ?").get(projectId, relPath);
-			result.filesProcessed++;
-			result.chunksCreated += count.n;
-		} else result.filesSkipped++;
-	}
-	const livePaths = /* @__PURE__ */ new Set();
-	for (const { absPath, rootBase } of filesToIndex) livePaths.add(relative(rootBase, absPath));
-	const dbChunkPaths = db.prepare("SELECT DISTINCT path FROM memory_chunks WHERE project_id = ?").all(projectId);
-	const stalePaths = [];
-	for (const row of dbChunkPaths) {
-		const basePath = row.path.endsWith("::title") ? row.path.slice(0, -7) : row.path;
-		if (!livePaths.has(basePath)) stalePaths.push(row.path);
-	}
-	if (stalePaths.length > 0) {
-		const deleteChunksFts = db.prepare("DELETE FROM memory_fts WHERE id = ?");
-		const deleteChunks = db.prepare("DELETE FROM memory_chunks WHERE project_id = ? AND path = ?");
-		const deleteFile = db.prepare("DELETE FROM memory_files WHERE project_id = ? AND path = ?");
-		db.transaction(() => {
-			for (const stalePath of stalePaths) {
-				const chunkIds = db.prepare("SELECT id FROM memory_chunks WHERE project_id = ? AND path = ?").all(projectId, stalePath);
-				for (const { id } of chunkIds) deleteChunksFts.run(id);
-				deleteChunks.run(projectId, stalePath);
-				deleteFile.run(projectId, stalePath);
-			}
-		})();
-	}
-	return result;
-}
-/**
-* Index all active projects registered in the registry DB.
-*
-* Async: yields to the event loop between each project so that the daemon's
-* Unix socket server can process IPC requests (e.g. status) while indexing.
-*/
-async function indexAllSqlite(db, registry) {
-	const projects = await registry.listProjects({ status: "active" });
-	const totals = {
-		filesProcessed: 0,
-		chunksCreated: 0,
-		filesSkipped: 0
-	};
-	for (const project of projects) {
-		await yieldToEventLoop();
-		const r = await indexProject(db, project.id, project.root_path, project.claude_notes_dir);
-		totals.filesProcessed += r.filesProcessed;
-		totals.chunksCreated += r.chunksCreated;
-		totals.filesSkipped += r.filesSkipped;
-	}
-	return {
-		projects: projects.length,
-		result: totals
-	};
-}
-
-//#endregion
-//#region src/storage/sqlite/tunnels.ts
-async function findTunnelsForSlugMap(db, slugMap, opts) {
-	const projectIds = Object.keys(slugMap).map(Number);
-	if (projectIds.length < 2) return {
-		tunnels: [],
-		projects_analyzed: projectIds.length,
-		total_concepts_evaluated: 0
-	};
-	let candidateTerms = [];
-	try {
-		candidateTerms = db.prepare(`SELECT term, SUM(doc) AS doc_count, SUM(cnt) AS total_cnt
-         FROM memory_fts_v
-         GROUP BY term
-         HAVING SUM(cnt) >= ?
-         ORDER BY SUM(doc) DESC
-         LIMIT 500`).all(opts.min_occurrences).map((r) => r.term).filter((t) => t.length >= 3 && !STOP_WORDS.has(t));
-	} catch {
-		const sampleRows = db.prepare(`SELECT LOWER(text) AS text FROM memory_chunks
-         WHERE LENGTH(text) > 20
-         ORDER BY RANDOM()
-         LIMIT 2000`).all();
-		const freq = /* @__PURE__ */ new Map();
-		for (const { text } of sampleRows) {
-			const tokens = text.split(/[\s\p{P}]+/u).filter(Boolean).filter((t) => t.length >= 3 && !STOP_WORDS.has(t));
-			for (const t of tokens) freq.set(t, (freq.get(t) ?? 0) + 1);
-		}
-		candidateTerms = [...freq.entries()].filter(([, n]) => n >= opts.min_occurrences).sort((a, b) => b[1] - a[1]).slice(0, 200).map(([t]) => t);
-	}
-	if (candidateTerms.length === 0) return {
-		tunnels: [],
-		projects_analyzed: projectIds.length,
-		total_concepts_evaluated: 0
-	};
-	const tunnels = [];
-	for (const term of candidateTerms) try {
-		const rows = db.prepare(`SELECT c.project_id, COUNT(*) AS cnt,
-                  MIN(c.updated_at) AS first_seen,
-                  MAX(c.updated_at) AS last_seen
-           FROM memory_fts f
-           JOIN memory_chunks c ON c.id = f.id
-           WHERE memory_fts MATCH ?
-             AND c.project_id IN (${projectIds.map(() => "?").join(", ")})
-           GROUP BY c.project_id`).all(`"${term.replace(/"/g, "\"\"")}"`, ...projectIds);
-		if (rows.length < opts.min_projects) continue;
-		const totalOccurrences = rows.reduce((s, r) => s + Number(r.cnt), 0);
-		if (totalOccurrences < opts.min_occurrences) continue;
-		const projects = rows.map((r) => slugMap[r.project_id] ?? String(r.project_id)).filter(Boolean);
-		const firstSeen = Math.min(...rows.map((r) => r.first_seen));
-		const lastSeen = Math.max(...rows.map((r) => r.last_seen));
-		tunnels.push({
-			concept: term,
-			projects,
-			occurrences: totalOccurrences,
-			first_seen: firstSeen,
-			last_seen: lastSeen
-		});
-	} catch {
-		continue;
-	}
-	tunnels.sort((a, b) => {
-		const byProjects = b.projects.length - a.projects.length;
-		if (byProjects !== 0) return byProjects;
-		return b.occurrences - a.occurrences;
-	});
-	return {
-		tunnels: tunnels.slice(0, opts.limit),
-		projects_analyzed: projectIds.length,
-		total_concepts_evaluated: candidateTerms.length
-	};
-}
-/** Find cross-project concept tunnels against a SQLite federation database. */
-async function findTunnelsSqlite(db, registry, options) {
-	const opts = {
-		min_projects: options?.min_projects ?? 2,
-		min_occurrences: options?.min_occurrences ?? 3,
-		limit: options?.limit ?? 20
-	};
-	const projectRows = await registry.listProjects({ excludeArchived: true });
-	const slugMap = {};
-	for (const { id, slug } of projectRows) slugMap[id] = slug;
-	return findTunnelsForSlugMap(db, slugMap, opts);
-}
-
-//#endregion
-//#region src/storage/sqlite/sources.ts
-function getMemorySourcesReportSqlite(db) {
-	return {
-		composition: db.prepare(`SELECT source, tier, COUNT(*) AS chunks,
-              SUM(CASE WHEN embedding IS NOT NULL THEN 1 ELSE 0 END) AS embedded
-         FROM memory_chunks GROUP BY source, tier ORDER BY COUNT(*) DESC`).all(),
-		paths: db.prepare(`SELECT path, COUNT(*) AS chunks FROM memory_chunks GROUP BY path`).all(),
-		churn: db.prepare(`SELECT date(updated_at/1000,'unixepoch') AS day, COUNT(*) AS chunks,
-              SUM(CASE WHEN embedding IS NOT NULL THEN 1 ELSE 0 END) AS embedded
-         FROM memory_chunks GROUP BY day ORDER BY day DESC LIMIT 10`).all()
-	};
-}
-
-//#endregion
-//#region src/storage/sqlite/search.ts
-/**
-* 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.
-*/
-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.
-*
-* @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);
-}
-/**
-* Update last_accessed_at for a set of chunk IDs to the current timestamp.
-*
-* 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 {}
-}
-
-//#endregion
-//#region src/storage/sqlite/kg-entity.ts
-/**
-* Upsert a KG entity in the federation SQLite database.
-*
-* If the entity already exists for this tenant:
-*   - Updates last_seen to now
-*   - Increments mention_count
-*   - Updates description if provided (overwrites older description)
-*
-* Returns the entity_id for use as a foreign key in kg_triples.
-*/
-function upsertKgEntitySqlite(db, params) {
-	const tenantId = params.tenantId ?? "default";
-	const entityId = entityContentId(params.name, tenantId);
-	const now = Date.now();
-	db.prepare(`
-    INSERT INTO kg_entities
-      (entity_id, tenant_id, name, type, description, first_seen, last_seen, mention_count, feedback_weight)
-    VALUES
-      (?, ?, ?, ?, ?, ?, ?, 1, 0.5)
-    ON CONFLICT(entity_id) DO UPDATE SET
-      last_seen     = excluded.last_seen,
-      mention_count = mention_count + 1,
-      description   = COALESCE(excluded.description, description),
-      type          = CASE WHEN excluded.type != 'unknown' THEN excluded.type ELSE type END
-  `).run(entityId, tenantId, params.name, params.type ?? "unknown", params.description ?? null, now, now);
-	return entityId;
-}
-/**
-* Look up a KG entity by name within a tenant.
-* Returns null if the entity does not exist.
-*/
-function findKgEntitySqlite(db, name, tenantId = "default") {
-	const entityId = entityContentId(name, tenantId);
-	return db.prepare("SELECT * FROM kg_entities WHERE entity_id = ? AND tenant_id = ?").get(entityId, tenantId) ?? null;
-}
-/**
-* List KG entities for a tenant, optionally filtered by type.
-*/
-function listKgEntitiesSqlite(db, tenantId = "default", type, limit = 100) {
-	if (type) return db.prepare("SELECT * FROM kg_entities WHERE tenant_id = ? AND type = ? ORDER BY mention_count DESC LIMIT ?").all(tenantId, type, limit);
-	return db.prepare("SELECT * FROM kg_entities WHERE tenant_id = ? ORDER BY mention_count DESC LIMIT ?").all(tenantId, limit);
-}
-/**
-* Apply an EMA (Exponential Moving Average) feedback update to an entity's weight.
-*
-* EMA formula: new_weight = old_weight + alpha * (target - old_weight)
-*/
-function updateEntityFeedbackWeightSqlite(db, entityId, normalizedRating, alpha = .1) {
-	const row = db.prepare("SELECT feedback_weight FROM kg_entities WHERE entity_id = ?").get(entityId);
-	if (!row) return;
-	const newWeight = row.feedback_weight + alpha * (normalizedRating - row.feedback_weight);
-	db.prepare("UPDATE kg_entities SET feedback_weight = ? WHERE entity_id = ?").run(newWeight, entityId);
-}
-
-//#endregion
-//#region src/storage/sqlite.ts
-var SQLiteBackend = class {
-	backendType = "sqlite";
-	supportsPostgresFeatures = false;
-	db;
-	constructor(db) {
-		this.db = db;
-	}
-	/**
-	* Expose the raw better-sqlite3 Database handle. Storage-internal only —
-	* used by db-admin.ts for `pai db query|tables|schema` (the one place
-	* outside this class allowed to reach for it). Every other operation must
-	* be a StorageBackend method; nothing outside src/storage/ may call this.
-	*/
-	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 getProjectStats(projectId) {
-		return {
-			files: this.db.prepare("SELECT COUNT(*) AS n FROM memory_files WHERE project_id = ?").get(projectId).n,
-			chunks: this.db.prepare("SELECT COUNT(*) AS n FROM memory_chunks WHERE project_id = ?").get(projectId).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, after) {
-		const conditions = ["embedding IS NULL"];
-		const params = [];
-		if (projectId !== void 0) {
-			conditions.push("project_id = ?");
-			params.push(projectId);
-		}
-		const paginating = after !== void 0;
-		if (after) {
-			conditions.push("(project_id > ? OR (project_id = ? AND id > ?))");
-			params.push(after.projectId, after.projectId, after.id);
-		}
-		const where = "WHERE " + conditions.join(" AND ");
-		const orderBy = paginating ? "project_id, id" : `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`;
-		return this.db.prepare(`SELECT id, text, project_id, path FROM memory_chunks ${where}
-        ORDER BY ${orderBy}${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();
-	}
-	async upsertKgEntity(params) {
-		return upsertKgEntitySqlite(this.db, params);
-	}
-	async findKgEntity(name, tenantId = "default") {
-		return findKgEntitySqlite(this.db, name, tenantId);
-	}
-	async listKgEntities(tenantId = "default", type, limit = 100) {
-		return listKgEntitiesSqlite(this.db, tenantId, type, limit);
-	}
-	async updateEntityFeedbackWeight(entityId, normalizedRating, alpha = .1) {
-		return updateEntityFeedbackWeightSqlite(this.db, entityId, normalizedRating, alpha);
-	}
-	async getChunksForFeedback(chunkIds) {
-		if (chunkIds.length === 0) return [];
-		const placeholders = chunkIds.map(() => "?").join(", ");
-		return this.db.prepare(`SELECT id, text, relevance_score FROM memory_chunks WHERE id IN (${placeholders})`).all(...chunkIds).map((r) => ({
-			id: r.id,
-			text: r.text,
-			relevanceScore: r.relevance_score
-		}));
-	}
-	async updateChunkRelevanceScore(chunkId, score) {
-		this.db.prepare("UPDATE memory_chunks SET relevance_score = ? WHERE id = ?").run(score, chunkId);
-	}
-	async touchChunksLastAccessed(chunkIds) {
-		touchChunksLastAccessed(this.db, chunkIds);
-	}
-	async indexAll(registry) {
-		return indexAllSqlite(this.db, registry);
-	}
-	async findTunnels(registry, options) {
-		return findTunnelsSqlite(this.db, registry, options);
-	}
-	async getMemorySourcesReport() {
-		return getMemorySourcesReportSqlite(this.db);
-	}
-	postgresOnly(feature) {
-		throw new Error(`${feature} is not supported on the sqlite backend — set "storageBackend": "postgres" in the daemon config`);
-	}
-	async addKgTriple() {
-		this.postgresOnly("kg_triples");
-	}
-	async queryKgTriples() {
-		this.postgresOnly("kg_triples");
-	}
-	async invalidateKgTriple() {
-		this.postgresOnly("kg_triples");
-	}
-	async getKgContradictions() {
-		this.postgresOnly("kg_triples");
-	}
-	async getKgStats() {
-		this.postgresOnly("kg_triples");
-	}
-	async storeObservation() {
-		this.postgresOnly("observations");
-	}
-	async storeObservationWithProject() {
-		this.postgresOnly("observations");
-	}
-	async queryObservations() {
-		this.postgresOnly("observations");
-	}
-	async queryRecentObservations() {
-		this.postgresOnly("observations");
-	}
-	async querySessionObservations() {
-		this.postgresOnly("observations");
-	}
-	async getObservationStats() {
-		this.postgresOnly("observations");
-	}
-	async getObservationTypesForPaths() {
-		return /* @__PURE__ */ new Map();
-	}
-	async storeSessionSummary() {
-		this.postgresOnly("session summaries");
-	}
-	async queryRecentSummaries() {
-		this.postgresOnly("session summaries");
-	}
-	async recordSkillInvocation() {
-		this.postgresOnly("skill telemetry");
-	}
-	async querySkillTelemetry() {
-		this.postgresOnly("skill telemetry");
-	}
-	async countFilesWithPaths(paths) {
-		if (paths.length === 0) return 0;
-		const placeholders = paths.map(() => "?").join(", ");
-		return this.db.prepare(`SELECT COUNT(*) AS n FROM memory_files WHERE path IN (${placeholders})`).get(...paths).n;
-	}
-	async renameFilePaths(moves) {
-		if (moves.length === 0) return 0;
-		const updateFiles = this.db.prepare("UPDATE memory_files SET path = ? WHERE path = ?");
-		const updateChunks = this.db.prepare("UPDATE memory_chunks SET path = ? WHERE path = ?");
-		let filesUpdated = 0;
-		this.db.transaction(() => {
-			for (const { oldPath, newPath } of moves) {
-				const r = updateFiles.run(newPath, oldPath);
-				filesUpdated += r.changes;
-				updateChunks.run(newPath, oldPath);
-			}
-		})();
-		return filesUpdated;
-	}
-};
-
-//#endregion
-export { SQLiteBackend };
-//# sourceMappingURL=sqlite-CqsTy6xo.mjs.map