@tekmidian/pai 0.5.7 → 0.6.0

package/dist/postgres-CKf-EDtS.mjs

@@ -0,0 +1,846 @@
+import { t as STOP_WORDS } from "./stop-words-BaMEGVeY.mjs";
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import pg from "pg";
+
+//#region src/storage/postgres/helpers.ts
+/**
+* Internal helper utilities for the Postgres storage backend.
+*/
+/**
+* Convert a Buffer of Float32 LE bytes (as stored in SQLite) to number[].
+*/
+function bufferToVector(buf) {
+	const floats = [];
+	for (let i = 0; i < buf.length; i += 4) floats.push(buf.readFloatLE(i));
+	return floats;
+}
+/**
+* Convert a free-text query to a Postgres tsquery string.
+*
+* Uses OR (|) semantics so that a chunk matching ANY query term is returned,
+* ranked by ts_rank (which scores higher when more terms match). AND (&)
+* semantics are too strict for multi-word queries because all terms rarely
+* co-occur in a single chunk.
+*
+* Example: "Synchrotech interview follow-up Gilles"
+*   → "synchrotech | interview | follow | gilles"
+*/
+function buildPgTsQuery(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, "''").replace(/[&|!():]/g, "")).filter(Boolean);
+	if (tokens.length === 0) return query.replace(/[^a-z0-9]/gi, " ").trim().split(/\s+/).filter(Boolean).join(" | ") || "";
+	return tokens.join(" | ");
+}
+
+//#endregion
+//#region src/storage/postgres/search.ts
+/**
+* Full-text keyword search using Postgres tsvector/tsquery with 'simple' dictionary.
+*/
+async function searchKeyword(pool, query, opts) {
+	const maxResults = opts?.maxResults ?? 10;
+	const tsQuery = buildPgTsQuery(query);
+	if (!tsQuery) return [];
+	const conditions = ["fts_vector @@ to_tsquery('simple', $1)"];
+	const params = [tsQuery];
+	let paramIdx = 2;
+	if (opts?.projectIds && opts.projectIds.length > 0) {
+		const placeholders = opts.projectIds.map(() => `$${paramIdx++}`).join(", ");
+		conditions.push(`project_id IN (${placeholders})`);
+		params.push(...opts.projectIds);
+	}
+	if (opts?.sources && opts.sources.length > 0) {
+		const placeholders = opts.sources.map(() => `$${paramIdx++}`).join(", ");
+		conditions.push(`source IN (${placeholders})`);
+		params.push(...opts.sources);
+	}
+	if (opts?.tiers && opts.tiers.length > 0) {
+		const placeholders = opts.tiers.map(() => `$${paramIdx++}`).join(", ");
+		conditions.push(`tier IN (${placeholders})`);
+		params.push(...opts.tiers);
+	}
+	params.push(maxResults);
+	const limitParam = `$${paramIdx}`;
+	const sql = `
+    SELECT
+      project_id,
+      path,
+      start_line,
+      end_line,
+      text AS snippet,
+      tier,
+      source,
+      ts_rank(fts_vector, to_tsquery('simple', $1)) AS rank_score
+    FROM pai_chunks
+    WHERE ${conditions.join(" AND ")}
+    ORDER BY rank_score DESC
+    LIMIT ${limitParam}
+  `;
+	try {
+		return (await pool.query(sql, params)).rows.map((row) => ({
+			projectId: row.project_id,
+			path: row.path,
+			startLine: row.start_line,
+			endLine: row.end_line,
+			snippet: row.snippet,
+			score: row.rank_score,
+			tier: row.tier,
+			source: row.source
+		}));
+	} catch (e) {
+		process.stderr.write(`[pai-postgres] searchKeyword error: ${e}\n`);
+		return [];
+	}
+}
+/**
+* Semantic vector similarity search using pgvector cosine distance (<=>).
+*/
+async function searchSemantic(pool, queryEmbedding, opts) {
+	const maxResults = opts?.maxResults ?? 10;
+	const conditions = ["embedding IS NOT NULL"];
+	const params = [];
+	let paramIdx = 1;
+	const vecStr = "[" + Array.from(queryEmbedding).join(",") + "]";
+	params.push(vecStr);
+	const vecParam = `$${paramIdx++}`;
+	if (opts?.projectIds && opts.projectIds.length > 0) {
+		const placeholders = opts.projectIds.map(() => `$${paramIdx++}`).join(", ");
+		conditions.push(`project_id IN (${placeholders})`);
+		params.push(...opts.projectIds);
+	}
+	if (opts?.sources && opts.sources.length > 0) {
+		const placeholders = opts.sources.map(() => `$${paramIdx++}`).join(", ");
+		conditions.push(`source IN (${placeholders})`);
+		params.push(...opts.sources);
+	}
+	if (opts?.tiers && opts.tiers.length > 0) {
+		const placeholders = opts.tiers.map(() => `$${paramIdx++}`).join(", ");
+		conditions.push(`tier IN (${placeholders})`);
+		params.push(...opts.tiers);
+	}
+	params.push(maxResults);
+	const limitParam = `$${paramIdx}`;
+	const sql = `
+    SELECT
+      project_id,
+      path,
+      start_line,
+      end_line,
+      text AS snippet,
+      tier,
+      source,
+      1 - (embedding <=> ${vecParam}::vector) AS cosine_similarity
+    FROM pai_chunks
+    WHERE ${conditions.join(" AND ")}
+    ORDER BY embedding <=> ${vecParam}::vector
+    LIMIT ${limitParam}
+  `;
+	try {
+		const result = await pool.query(sql, params);
+		const minScore = opts?.minScore ?? -Infinity;
+		return result.rows.map((row) => ({
+			projectId: row.project_id,
+			path: row.path,
+			startLine: row.start_line,
+			endLine: row.end_line,
+			snippet: row.snippet,
+			score: row.cosine_similarity,
+			tier: row.tier,
+			source: row.source
+		})).filter((r) => r.score >= minScore);
+	} catch (e) {
+		process.stderr.write(`[pai-postgres] searchSemantic error: ${e}\n`);
+		return [];
+	}
+}
+
+//#endregion
+//#region src/storage/postgres/vault.ts
+async function upsertVaultFile(pool, file) {
+	await pool.query(`INSERT INTO vault_files (vault_path, inode, device, hash, title, indexed_at)
+     VALUES ($1, $2, $3, $4, $5, $6)
+     ON CONFLICT (vault_path) DO UPDATE SET
+       inode = EXCLUDED.inode, device = EXCLUDED.device,
+       hash = EXCLUDED.hash, title = EXCLUDED.title,
+       indexed_at = EXCLUDED.indexed_at`, [
+		file.vaultPath,
+		file.inode,
+		file.device,
+		file.hash,
+		file.title,
+		file.indexedAt
+	]);
+}
+async function deleteVaultFile(pool, vaultPath) {
+	const client = await pool.connect();
+	try {
+		await client.query("BEGIN");
+		await client.query("DELETE FROM vault_links WHERE source_path = $1", [vaultPath]);
+		await client.query("DELETE FROM vault_health WHERE vault_path = $1", [vaultPath]);
+		await client.query("DELETE FROM vault_name_index WHERE vault_path = $1", [vaultPath]);
+		await client.query("DELETE FROM vault_aliases WHERE vault_path = $1 OR canonical_path = $1", [vaultPath]);
+		await client.query("DELETE FROM vault_files WHERE vault_path = $1", [vaultPath]);
+		await client.query("COMMIT");
+	} catch (e) {
+		await client.query("ROLLBACK");
+		throw e;
+	} finally {
+		client.release();
+	}
+}
+function mapVaultFileRow(row) {
+	return {
+		vaultPath: row.vault_path,
+		inode: Number(row.inode),
+		device: Number(row.device),
+		hash: row.hash,
+		title: row.title,
+		indexedAt: Number(row.indexed_at)
+	};
+}
+async function getVaultFile(pool, vaultPath) {
+	const r = await pool.query("SELECT vault_path, inode, device, hash, title, indexed_at FROM vault_files WHERE vault_path = $1", [vaultPath]);
+	return r.rows.length === 0 ? null : mapVaultFileRow(r.rows[0]);
+}
+async function getVaultFileByInode(pool, inode, device) {
+	const r = await pool.query("SELECT vault_path, inode, device, hash, title, indexed_at FROM vault_files WHERE inode = $1 AND device = $2 LIMIT 1", [inode, device]);
+	return r.rows.length === 0 ? null : mapVaultFileRow(r.rows[0]);
+}
+async function getAllVaultFiles(pool) {
+	return (await pool.query("SELECT vault_path, inode, device, hash, title, indexed_at FROM vault_files")).rows.map(mapVaultFileRow);
+}
+async function getRecentVaultFiles(pool, sinceMs) {
+	return (await pool.query("SELECT vault_path, inode, device, hash, title, indexed_at FROM vault_files WHERE indexed_at > $1", [sinceMs])).rows.map(mapVaultFileRow);
+}
+async function countVaultFiles(pool) {
+	const r = await pool.query("SELECT COUNT(*)::text AS n FROM vault_files");
+	return parseInt(r.rows[0]?.n ?? "0", 10);
+}
+async function countVaultFilesWithPrefix(pool, prefix) {
+	const r = await pool.query("SELECT COUNT(*) AS n FROM vault_files WHERE vault_path LIKE $1", [`${prefix}%`]);
+	return Number(r.rows[0]?.n ?? 0);
+}
+async function countVaultFilesAfter(pool, sinceMs) {
+	const r = await pool.query("SELECT COUNT(*) AS n FROM vault_files WHERE indexed_at > $1", [sinceMs]);
+	return Number(r.rows[0]?.n ?? 0);
+}
+async function getVaultFilesByPaths(pool, paths) {
+	if (paths.length === 0) return [];
+	const placeholders = paths.map((_, i) => `$${i + 1}`).join(", ");
+	return (await pool.query(`SELECT vault_path, inode, device, hash, title, indexed_at FROM vault_files WHERE vault_path IN (${placeholders})`, paths)).rows.map(mapVaultFileRow);
+}
+async function getVaultFilesByPathsAfter(pool, paths, sinceMs) {
+	if (paths.length === 0) return [];
+	const placeholders = paths.map((_, i) => `$${i + 1}`).join(", ");
+	return (await pool.query(`SELECT vault_path, inode, device, hash, title, indexed_at FROM vault_files WHERE vault_path IN (${placeholders}) AND indexed_at >= $${paths.length + 1} ORDER BY indexed_at ASC`, [...paths, sinceMs])).rows.map(mapVaultFileRow);
+}
+async function getAllVaultFilePaths(pool) {
+	return (await pool.query("SELECT vault_path FROM vault_files")).rows.map((row) => row.vault_path);
+}
+async function getVaultFilePathsWithPrefix(pool, prefix) {
+	return (await pool.query("SELECT vault_path FROM vault_files WHERE vault_path LIKE $1", [`${prefix}%`])).rows.map((row) => row.vault_path);
+}
+async function getVaultFilePathsAfter(pool, sinceMs) {
+	return (await pool.query("SELECT vault_path FROM vault_files WHERE indexed_at > $1", [sinceMs])).rows.map((row) => row.vault_path);
+}
+async function upsertVaultAliases(pool, aliases) {
+	if (aliases.length === 0) return;
+	const client = await pool.connect();
+	try {
+		await client.query("BEGIN");
+		for (const a of aliases) await client.query(`INSERT INTO vault_aliases (vault_path, canonical_path, inode, device)
+         VALUES ($1, $2, $3, $4)
+         ON CONFLICT (vault_path) DO UPDATE SET
+           canonical_path = EXCLUDED.canonical_path,
+           inode = EXCLUDED.inode, device = EXCLUDED.device`, [
+			a.vaultPath,
+			a.canonicalPath,
+			a.inode,
+			a.device
+		]);
+		await client.query("COMMIT");
+	} catch (e) {
+		await client.query("ROLLBACK");
+		throw e;
+	} finally {
+		client.release();
+	}
+}
+async function deleteVaultAliases(pool, canonicalPath) {
+	await pool.query("DELETE FROM vault_aliases WHERE canonical_path = $1", [canonicalPath]);
+}
+async function getVaultAlias(pool, vaultPath) {
+	const r = await pool.query("SELECT canonical_path FROM vault_aliases WHERE vault_path = $1", [vaultPath]);
+	return r.rows.length > 0 ? { canonicalPath: r.rows[0].canonical_path } : null;
+}
+function mapVaultLinkRow(row) {
+	return {
+		sourcePath: row.source_path,
+		targetRaw: row.target_raw,
+		targetPath: row.target_path,
+		linkType: row.link_type,
+		lineNumber: row.line_number
+	};
+}
+async function replaceLinksForSources(pool, sourcePaths, links) {
+	const client = await pool.connect();
+	try {
+		await client.query("BEGIN");
+		if (sourcePaths.length > 0) await client.query("DELETE FROM vault_links WHERE source_path = ANY($1::text[])", [sourcePaths]);
+		for (let i = 0; i < links.length; i += 500) {
+			const batch = links.slice(i, i + 500);
+			const values = [];
+			const params = [];
+			let idx = 1;
+			for (const l of batch) {
+				values.push(`($${idx++}, $${idx++}, $${idx++}, $${idx++}, $${idx++})`);
+				params.push(l.sourcePath, l.targetRaw, l.targetPath, l.linkType, l.lineNumber);
+			}
+			await client.query(`INSERT INTO vault_links (source_path, target_raw, target_path, link_type, line_number)
+         VALUES ${values.join(", ")}
+         ON CONFLICT (source_path, target_raw, line_number) DO UPDATE SET
+           target_path = EXCLUDED.target_path, link_type = EXCLUDED.link_type`, params);
+		}
+		await client.query("COMMIT");
+	} catch (e) {
+		await client.query("ROLLBACK");
+		throw e;
+	} finally {
+		client.release();
+	}
+}
+async function getLinksFromSource(pool, sourcePath) {
+	return (await pool.query("SELECT source_path, target_raw, target_path, link_type, line_number FROM vault_links WHERE source_path = $1", [sourcePath])).rows.map(mapVaultLinkRow);
+}
+async function getLinksToTarget(pool, targetPath) {
+	return (await pool.query("SELECT source_path, target_raw, target_path, link_type, line_number FROM vault_links WHERE target_path = $1", [targetPath])).rows.map(mapVaultLinkRow);
+}
+async function getVaultLinkGraph(pool) {
+	return (await pool.query("SELECT source_path, target_path FROM vault_links WHERE target_path IS NOT NULL")).rows;
+}
+async function getDeadLinks(pool) {
+	return (await pool.query("SELECT source_path, target_raw FROM vault_links WHERE target_path IS NULL")).rows.map((row) => ({
+		sourcePath: row.source_path,
+		targetRaw: row.target_raw
+	}));
+}
+async function getDeadLinksWithLineNumbers(pool) {
+	return (await pool.query("SELECT source_path, target_raw, line_number FROM vault_links WHERE target_path IS NULL")).rows.map((row) => ({
+		sourcePath: row.source_path,
+		targetRaw: row.target_raw,
+		lineNumber: row.line_number
+	}));
+}
+async function getDeadLinksWithPrefix(pool, prefix) {
+	return (await pool.query("SELECT source_path, target_raw, line_number FROM vault_links WHERE target_path IS NULL AND source_path LIKE $1", [`${prefix}%`])).rows.map((row) => ({
+		sourcePath: row.source_path,
+		targetRaw: row.target_raw,
+		lineNumber: row.line_number
+	}));
+}
+async function getDeadLinksAfter(pool, sinceMs) {
+	return (await pool.query("SELECT source_path, target_raw, line_number FROM vault_links WHERE target_path IS NULL AND source_path IN (SELECT vault_path FROM vault_files WHERE indexed_at > $1)", [sinceMs])).rows.map((row) => ({
+		sourcePath: row.source_path,
+		targetRaw: row.target_raw,
+		lineNumber: row.line_number
+	}));
+}
+async function countVaultLinksWithPrefix(pool, prefix) {
+	const r = await pool.query("SELECT COUNT(*) AS n FROM vault_links WHERE source_path LIKE $1", [`${prefix}%`]);
+	return Number(r.rows[0]?.n ?? 0);
+}
+async function countVaultLinksAfter(pool, sinceMs) {
+	const r = await pool.query("SELECT COUNT(*) AS n FROM vault_links WHERE source_path IN (SELECT vault_path FROM vault_files WHERE indexed_at > $1)", [sinceMs]);
+	return Number(r.rows[0]?.n ?? 0);
+}
+async function getVaultLinksFromPaths(pool, sourcePaths) {
+	if (sourcePaths.length === 0) return [];
+	const placeholders = sourcePaths.map((_, i) => `$${i + 1}`).join(", ");
+	return (await pool.query(`SELECT source_path, target_raw, target_path, link_type, line_number FROM vault_links WHERE source_path IN (${placeholders}) AND target_path IS NOT NULL`, sourcePaths)).rows.map(mapVaultLinkRow);
+}
+async function getVaultLinkEdges(pool) {
+	return (await pool.query("SELECT DISTINCT source_path AS source, target_path AS target FROM vault_links WHERE target_path IS NOT NULL")).rows;
+}
+async function getVaultLinkEdgesWithPrefix(pool, prefix) {
+	return (await pool.query("SELECT DISTINCT source_path AS source, target_path AS target FROM vault_links WHERE target_path IS NOT NULL AND source_path LIKE $1", [`${prefix}%`])).rows;
+}
+async function getVaultLinkEdgesAfter(pool, sinceMs) {
+	return (await pool.query("SELECT DISTINCT source_path AS source, target_path AS target FROM vault_links WHERE target_path IS NOT NULL AND source_path IN (SELECT vault_path FROM vault_files WHERE indexed_at > $1)", [sinceMs])).rows;
+}
+function mapVaultHealthRow(row) {
+	return {
+		vaultPath: row.vault_path,
+		inboundCount: row.inbound_count,
+		outboundCount: row.outbound_count,
+		deadLinkCount: row.dead_link_count,
+		isOrphan: row.is_orphan === 1,
+		computedAt: Number(row.computed_at)
+	};
+}
+async function upsertVaultHealth(pool, rows) {
+	if (rows.length === 0) return;
+	const client = await pool.connect();
+	try {
+		await client.query("BEGIN");
+		for (const h of rows) await client.query(`INSERT INTO vault_health (vault_path, inbound_count, outbound_count, dead_link_count, is_orphan, computed_at)
+         VALUES ($1, $2, $3, $4, $5, $6)
+         ON CONFLICT (vault_path) DO UPDATE SET
+           inbound_count = EXCLUDED.inbound_count,
+           outbound_count = EXCLUDED.outbound_count,
+           dead_link_count = EXCLUDED.dead_link_count,
+           is_orphan = EXCLUDED.is_orphan,
+           computed_at = EXCLUDED.computed_at`, [
+			h.vaultPath,
+			h.inboundCount,
+			h.outboundCount,
+			h.deadLinkCount,
+			h.isOrphan ? 1 : 0,
+			h.computedAt
+		]);
+		await client.query("COMMIT");
+	} catch (e) {
+		await client.query("ROLLBACK");
+		throw e;
+	} finally {
+		client.release();
+	}
+}
+async function getVaultHealth(pool, vaultPath) {
+	const r = await pool.query("SELECT vault_path, inbound_count, outbound_count, dead_link_count, is_orphan, computed_at FROM vault_health WHERE vault_path = $1", [vaultPath]);
+	return r.rows.length === 0 ? null : mapVaultHealthRow(r.rows[0]);
+}
+async function getOrphans(pool) {
+	return (await pool.query("SELECT vault_path, inbound_count, outbound_count, dead_link_count, is_orphan, computed_at FROM vault_health WHERE is_orphan = 1")).rows.map((row) => ({
+		...mapVaultHealthRow(row),
+		isOrphan: true
+	}));
+}
+async function getOrphansWithPrefix(pool, prefix) {
+	return (await pool.query("SELECT vault_path FROM vault_health WHERE is_orphan = 1 AND vault_path LIKE $1", [`${prefix}%`])).rows.map((row) => row.vault_path);
+}
+async function getOrphansAfter(pool, sinceMs) {
+	return (await pool.query("SELECT vh.vault_path FROM vault_health vh JOIN vault_files vf ON vh.vault_path = vf.vault_path WHERE vh.is_orphan = 1 AND vf.indexed_at > $1", [sinceMs])).rows.map((row) => row.vault_path);
+}
+async function getLowConnectivity(pool) {
+	return (await pool.query("SELECT vault_path FROM vault_health WHERE inbound_count + outbound_count <= 1")).rows.map((row) => row.vault_path);
+}
+async function getLowConnectivityWithPrefix(pool, prefix) {
+	return (await pool.query("SELECT vault_path FROM vault_health WHERE inbound_count + outbound_count <= 1 AND vault_path LIKE $1", [`${prefix}%`])).rows.map((row) => row.vault_path);
+}
+async function getLowConnectivityAfter(pool, sinceMs) {
+	return (await pool.query("SELECT vh.vault_path FROM vault_health vh JOIN vault_files vf ON vh.vault_path = vf.vault_path WHERE vh.inbound_count + vh.outbound_count <= 1 AND vf.indexed_at > $1", [sinceMs])).rows.map((row) => row.vault_path);
+}
+async function upsertNameIndex(pool, entries) {
+	if (entries.length === 0) return;
+	const client = await pool.connect();
+	try {
+		await client.query("BEGIN");
+		for (const e of entries) await client.query(`INSERT INTO vault_name_index (name, vault_path)
+         VALUES ($1, $2) ON CONFLICT (name, vault_path) DO NOTHING`, [e.name, e.vaultPath]);
+		await client.query("COMMIT");
+	} catch (e_) {
+		await client.query("ROLLBACK");
+		throw e_;
+	} finally {
+		client.release();
+	}
+}
+async function replaceNameIndex(pool, entries) {
+	const client = await pool.connect();
+	try {
+		await client.query("BEGIN");
+		await client.query("DELETE FROM vault_name_index");
+		for (let i = 0; i < entries.length; i += 500) {
+			const batch = entries.slice(i, i + 500);
+			const values = [];
+			const params = [];
+			let idx = 1;
+			for (const e of batch) {
+				values.push(`($${idx++}, $${idx++})`);
+				params.push(e.name, e.vaultPath);
+			}
+			await client.query(`INSERT INTO vault_name_index (name, vault_path) VALUES ${values.join(", ")}`, params);
+		}
+		await client.query("COMMIT");
+	} catch (e) {
+		await client.query("ROLLBACK");
+		throw e;
+	} finally {
+		client.release();
+	}
+}
+async function resolveVaultName(pool, name) {
+	return (await pool.query("SELECT vault_path FROM vault_name_index WHERE name = $1", [name])).rows.map((row) => row.vault_path);
+}
+async function searchVaultNameIndex(pool, query, limit = 100) {
+	return (await pool.query("SELECT DISTINCT vault_path FROM vault_name_index WHERE lower(name) LIKE lower($1) LIMIT $2", [`%${query}%`, limit])).rows.map((row) => row.vault_path);
+}
+
+//#endregion
+//#region src/storage/postgres/backend.ts
+/**
+* PostgresBackend — implements StorageBackend using PostgreSQL + pgvector.
+*
+* Vector similarity: pgvector's <=> cosine distance operator
+* Full-text search:  PostgreSQL tsvector/tsquery (replaces SQLite FTS5)
+* Connection pooling: node-postgres Pool
+*
+* Schema is auto-initialized on first connection if tables don't exist.
+* Per-user database isolation: each macOS user gets their own database (pai_<username>).
+*/
+const { Pool: PgPool } = pg;
+var PostgresBackend = class {
+	backendType = "postgres";
+	pool;
+	/**
+	* Ensure the per-user database exists and has the required schema.
+	* Connects to the default 'postgres' database to CREATE DATABASE if needed,
+	* then connects to the target database to apply init.sql schema.
+	* Safe to call multiple times (fully idempotent).
+	*/
+	static async ensureDatabase(config) {
+		const connStr = config.connectionString ?? `postgresql://${config.user ?? "pai"}:${config.password ?? "pai"}@${config.host ?? "localhost"}:${config.port ?? 5432}/${config.database ?? "pai"}`;
+		const targetDb = new URL(connStr).pathname.slice(1);
+		const adminUrl = new URL(connStr);
+		adminUrl.pathname = "/postgres";
+		const adminPool = new PgPool({
+			connectionString: adminUrl.toString(),
+			max: 1,
+			connectionTimeoutMillis: 5e3
+		});
+		try {
+			if ((await adminPool.query("SELECT 1 FROM pg_database WHERE datname = $1", [targetDb])).rowCount === 0) {
+				await adminPool.query(`CREATE DATABASE "${targetDb}"`);
+				process.stderr.write(`[pai-postgres] Created database: ${targetDb}\n`);
+			}
+		} finally {
+			await adminPool.end();
+		}
+		const targetPool = new PgPool({
+			connectionString: connStr,
+			max: 1,
+			connectionTimeoutMillis: 5e3
+		});
+		try {
+			if ((await targetPool.query("SELECT 1 FROM information_schema.tables WHERE table_name = 'pai_chunks'")).rowCount === 0) {
+				const __dirname = dirname(fileURLToPath(import.meta.url));
+				const initSqlPath = join(__dirname, "../../docker/init.sql");
+				let initSql;
+				try {
+					initSql = readFileSync(initSqlPath, "utf-8");
+				} catch {
+					initSql = readFileSync(join(__dirname, "../docker/init.sql"), "utf-8");
+				}
+				await targetPool.query(initSql);
+				process.stderr.write(`[pai-postgres] Applied schema to database: ${targetDb}\n`);
+			}
+		} finally {
+			await targetPool.end();
+		}
+	}
+	constructor(config) {
+		this.pool = new PgPool({
+			connectionString: config.connectionString ?? `postgresql://${config.user ?? "pai"}:${config.password ?? "pai"}@${config.host ?? "localhost"}:${config.port ?? 5432}/${config.database ?? "pai"}`,
+			max: config.maxConnections ?? 5,
+			connectionTimeoutMillis: config.connectionTimeoutMs ?? 5e3,
+			idleTimeoutMillis: 3e4
+		});
+		this.pool.on("error", (err) => {
+			process.stderr.write(`[pai-postgres] Pool error: ${err.message}\n`);
+		});
+	}
+	async close() {
+		await this.pool.end();
+	}
+	/**
+	* Expose the underlying pg.Pool for callers that need direct query access
+	* (e.g. the daemon's observation IPC methods).
+	*/
+	getPool() {
+		return this.pool;
+	}
+	async getStats() {
+		const client = await this.pool.connect();
+		try {
+			const filesResult = await client.query("SELECT COUNT(*)::text AS n FROM pai_files");
+			const chunksResult = await client.query("SELECT COUNT(*)::text AS n FROM pai_chunks");
+			return {
+				files: parseInt(filesResult.rows[0]?.n ?? "0", 10),
+				chunks: parseInt(chunksResult.rows[0]?.n ?? "0", 10)
+			};
+		} finally {
+			client.release();
+		}
+	}
+	/**
+	* Test the connection by running a trivial query.
+	* Returns null on success, error message on failure.
+	*/
+	async testConnection() {
+		let client = null;
+		try {
+			client = await this.pool.connect();
+			await client.query("SELECT 1");
+			return null;
+		} catch (e) {
+			return e instanceof Error ? e.message : String(e);
+		} finally {
+			client?.release();
+		}
+	}
+	async getFileHash(projectId, path) {
+		return (await this.pool.query("SELECT hash FROM pai_files WHERE project_id = $1 AND path = $2", [projectId, path])).rows[0]?.hash;
+	}
+	async upsertFile(file) {
+		await this.pool.query(`INSERT INTO pai_files (project_id, path, source, tier, hash, mtime, size)
+       VALUES ($1, $2, $3, $4, $5, $6, $7)
+       ON CONFLICT (project_id, path) DO UPDATE SET
+         source = EXCLUDED.source,
+         tier   = EXCLUDED.tier,
+         hash   = EXCLUDED.hash,
+         mtime  = EXCLUDED.mtime,
+         size   = EXCLUDED.size`, [
+			file.projectId,
+			file.path,
+			file.source,
+			file.tier,
+			file.hash,
+			file.mtime,
+			file.size
+		]);
+	}
+	async getChunkIds(projectId, path) {
+		return (await this.pool.query("SELECT id FROM pai_chunks WHERE project_id = $1 AND path = $2", [projectId, path])).rows.map((r) => r.id);
+	}
+	async deleteChunksForFile(projectId, path) {
+		await this.pool.query("DELETE FROM pai_chunks WHERE project_id = $1 AND path = $2", [projectId, path]);
+	}
+	async insertChunks(chunks) {
+		if (chunks.length === 0) return;
+		const client = await this.pool.connect();
+		try {
+			await client.query("BEGIN");
+			for (const c of chunks) {
+				const safeText = c.text.replace(/\0/g, "");
+				await client.query(`INSERT INTO pai_chunks
+             (id, project_id, source, tier, path, start_line, end_line, hash, text, updated_at, fts_vector)
+           VALUES
+             ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10,
+              to_tsvector('simple', $9))
+           ON CONFLICT (id) DO UPDATE SET
+             project_id = EXCLUDED.project_id,
+             source     = EXCLUDED.source,
+             tier       = EXCLUDED.tier,
+             path       = EXCLUDED.path,
+             start_line = EXCLUDED.start_line,
+             end_line   = EXCLUDED.end_line,
+             hash       = EXCLUDED.hash,
+             text       = EXCLUDED.text,
+             updated_at = EXCLUDED.updated_at,
+             fts_vector = EXCLUDED.fts_vector`, [
+					c.id,
+					c.projectId,
+					c.source,
+					c.tier,
+					c.path,
+					c.startLine,
+					c.endLine,
+					c.hash,
+					safeText,
+					c.updatedAt
+				]);
+			}
+			await client.query("COMMIT");
+		} catch (e) {
+			await client.query("ROLLBACK");
+			throw e;
+		} finally {
+			client.release();
+		}
+	}
+	async getDistinctChunkPaths(projectId) {
+		return (await this.pool.query("SELECT DISTINCT path FROM pai_chunks WHERE project_id = $1", [projectId])).rows.map((r) => r.path);
+	}
+	async deletePaths(projectId, paths) {
+		if (paths.length === 0) return;
+		const client = await this.pool.connect();
+		try {
+			await client.query("BEGIN");
+			for (const path of paths) {
+				await client.query("DELETE FROM pai_chunks WHERE project_id = $1 AND path = $2", [projectId, path]);
+				await client.query("DELETE FROM pai_files WHERE project_id = $1 AND path = $2", [projectId, path]);
+			}
+			await client.query("COMMIT");
+		} catch (e) {
+			await client.query("ROLLBACK");
+			throw e;
+		} finally {
+			client.release();
+		}
+	}
+	async getUnembeddedChunkIds(projectId) {
+		if (projectId !== void 0) return (await this.pool.query("SELECT id, text, project_id, path FROM pai_chunks WHERE embedding IS NULL AND project_id = $1 ORDER BY id", [projectId])).rows;
+		return (await this.pool.query("SELECT id, text, project_id, path FROM pai_chunks WHERE embedding IS NULL ORDER BY id")).rows;
+	}
+	async updateEmbedding(chunkId, embedding) {
+		const vecStr = "[" + bufferToVector(embedding).join(",") + "]";
+		await this.pool.query("UPDATE pai_chunks SET embedding = $1::vector WHERE id = $2", [vecStr, chunkId]);
+	}
+	async searchKeyword(query, opts) {
+		return searchKeyword(this.pool, query, opts);
+	}
+	async searchSemantic(queryEmbedding, opts) {
+		return searchSemantic(this.pool, queryEmbedding, opts);
+	}
+	async upsertVaultFile(file) {
+		return upsertVaultFile(this.pool, file);
+	}
+	async deleteVaultFile(vaultPath) {
+		return deleteVaultFile(this.pool, vaultPath);
+	}
+	async getVaultFile(vaultPath) {
+		return getVaultFile(this.pool, vaultPath);
+	}
+	async getVaultFileByInode(inode, device) {
+		return getVaultFileByInode(this.pool, inode, device);
+	}
+	async getAllVaultFiles() {
+		return getAllVaultFiles(this.pool);
+	}
+	async getRecentVaultFiles(sinceMs) {
+		return getRecentVaultFiles(this.pool, sinceMs);
+	}
+	async countVaultFiles() {
+		return countVaultFiles(this.pool);
+	}
+	async countVaultFilesWithPrefix(prefix) {
+		return countVaultFilesWithPrefix(this.pool, prefix);
+	}
+	async countVaultFilesAfter(sinceMs) {
+		return countVaultFilesAfter(this.pool, sinceMs);
+	}
+	async getVaultFilesByPaths(paths) {
+		return getVaultFilesByPaths(this.pool, paths);
+	}
+	async getVaultFilesByPathsAfter(paths, sinceMs) {
+		return getVaultFilesByPathsAfter(this.pool, paths, sinceMs);
+	}
+	async getAllVaultFilePaths() {
+		return getAllVaultFilePaths(this.pool);
+	}
+	async getVaultFilePathsWithPrefix(prefix) {
+		return getVaultFilePathsWithPrefix(this.pool, prefix);
+	}
+	async getVaultFilePathsAfter(sinceMs) {
+		return getVaultFilePathsAfter(this.pool, sinceMs);
+	}
+	async upsertVaultAliases(aliases) {
+		return upsertVaultAliases(this.pool, aliases);
+	}
+	async deleteVaultAliases(canonicalPath) {
+		return deleteVaultAliases(this.pool, canonicalPath);
+	}
+	async getVaultAlias(vaultPath) {
+		return getVaultAlias(this.pool, vaultPath);
+	}
+	async replaceLinksForSources(sourcePaths, links) {
+		return replaceLinksForSources(this.pool, sourcePaths, links);
+	}
+	async getLinksFromSource(sourcePath) {
+		return getLinksFromSource(this.pool, sourcePath);
+	}
+	async getLinksToTarget(targetPath) {
+		return getLinksToTarget(this.pool, targetPath);
+	}
+	async getVaultLinkGraph() {
+		return getVaultLinkGraph(this.pool);
+	}
+	async getDeadLinks() {
+		return getDeadLinks(this.pool);
+	}
+	async getDeadLinksWithLineNumbers() {
+		return getDeadLinksWithLineNumbers(this.pool);
+	}
+	async getDeadLinksWithPrefix(prefix) {
+		return getDeadLinksWithPrefix(this.pool, prefix);
+	}
+	async getDeadLinksAfter(sinceMs) {
+		return getDeadLinksAfter(this.pool, sinceMs);
+	}
+	async countVaultLinksWithPrefix(prefix) {
+		return countVaultLinksWithPrefix(this.pool, prefix);
+	}
+	async countVaultLinksAfter(sinceMs) {
+		return countVaultLinksAfter(this.pool, sinceMs);
+	}
+	async getVaultLinksFromPaths(sourcePaths) {
+		return getVaultLinksFromPaths(this.pool, sourcePaths);
+	}
+	async getVaultLinkEdges() {
+		return getVaultLinkEdges(this.pool);
+	}
+	async getVaultLinkEdgesWithPrefix(prefix) {
+		return getVaultLinkEdgesWithPrefix(this.pool, prefix);
+	}
+	async getVaultLinkEdgesAfter(sinceMs) {
+		return getVaultLinkEdgesAfter(this.pool, sinceMs);
+	}
+	async upsertVaultHealth(rows) {
+		return upsertVaultHealth(this.pool, rows);
+	}
+	async getVaultHealth(vaultPath) {
+		return getVaultHealth(this.pool, vaultPath);
+	}
+	async getOrphans() {
+		return getOrphans(this.pool);
+	}
+	async getOrphansWithPrefix(prefix) {
+		return getOrphansWithPrefix(this.pool, prefix);
+	}
+	async getOrphansAfter(sinceMs) {
+		return getOrphansAfter(this.pool, sinceMs);
+	}
+	async getLowConnectivity() {
+		return getLowConnectivity(this.pool);
+	}
+	async getLowConnectivityWithPrefix(prefix) {
+		return getLowConnectivityWithPrefix(this.pool, prefix);
+	}
+	async getLowConnectivityAfter(sinceMs) {
+		return getLowConnectivityAfter(this.pool, sinceMs);
+	}
+	async upsertNameIndex(entries) {
+		return upsertNameIndex(this.pool, entries);
+	}
+	async replaceNameIndex(entries) {
+		return replaceNameIndex(this.pool, entries);
+	}
+	async resolveVaultName(name) {
+		return resolveVaultName(this.pool, name);
+	}
+	async searchVaultNameIndex(query, limit) {
+		return searchVaultNameIndex(this.pool, query, limit);
+	}
+	async getChunksWithEmbeddings(projectId, limit) {
+		return (await this.pool.query(`SELECT path, text, embedding FROM memory_chunks WHERE project_id = $1 AND embedding IS NOT NULL ORDER BY path, start_line LIMIT $2`, [projectId, limit])).rows;
+	}
+	async getChunksForPath(projectId, path, limit = 20) {
+		return (await this.pool.query(`SELECT text, embedding FROM memory_chunks WHERE project_id = $1 AND path = $2 AND embedding IS NOT NULL ORDER BY start_line LIMIT $3`, [
+			projectId,
+			path,
+			limit
+		])).rows;
+	}
+	async searchChunksByText(projectId, query, limit) {
+		return (await this.pool.query(`SELECT DISTINCT path, text FROM memory_chunks WHERE project_id = $1 AND lower(text) LIKE lower($2) LIMIT $3`, [
+			projectId,
+			`%${query}%`,
+			limit
+		])).rows;
+	}
+};
+
+//#endregion
+export { PostgresBackend };
+//# sourceMappingURL=postgres-CKf-EDtS.mjs.map