@tekmidian/pai 0.66.1 → 0.66.3

package/dist/registry-postgres-nOfyBSIW.mjs

@@ -1,795 +0,0 @@
-import pg from "pg";
-
-//#region src/storage/registry-postgres.ts
-/**
-* PostgresRegistryBackend — implements RegistryBackend over the pg pool
-* pattern already used by PostgresBackend (src/storage/postgres/backend.ts).
-*
-* Same SQL shape as SQLiteRegistryBackend, translated to $-placeholders.
-* Behavioural notes where Postgres diverges from SQLite's "OR IGNORE":
-*  - `INSERT ... ON CONFLICT DO NOTHING` (no target) catches any unique
-*    violation on the table, matching SQLite's INSERT OR IGNORE.
-*  - SQLite's `UPDATE OR IGNORE` (used once, in reassignLinksTarget/
-*    applyProjectMerge's link retarget) has no direct Postgres equivalent —
-*    an UPDATE cannot specify ON CONFLICT. Replicated with a NOT EXISTS guard
-*    that skips rows whose new (session_id, target_project_id) would collide,
-*    leaving them for the caller's existing cleanup DELETE, exactly as the
-*    SQLite version does.
-*/
-const { Pool: PgPool } = pg;
-/**
-* node-postgres returns BIGINT columns (created_at/updated_at/archived_at/
-* closed_at, and MAX() over a BIGINT column) as strings — JS numbers can't
-* safely hold the full 64-bit range. Every value here is Date.now() ms and
-* well inside Number.isSafeInteger, so a plain Number() conversion keeps the
-* shape identical to better-sqlite3's row objects (same pattern as
-* rowToKgEntity in postgres/backend.ts).
-*/
-function toNum(v) {
-	return typeof v === "string" ? Number(v) : v;
-}
-function toNumOrNull(v) {
-	return v === null || v === void 0 ? null : toNum(v);
-}
-function mapProject(row) {
-	return {
-		...row,
-		created_at: toNum(row.created_at),
-		updated_at: toNum(row.updated_at),
-		archived_at: toNumOrNull(row.archived_at)
-	};
-}
-function mapProjectWithStats(row) {
-	return {
-		...mapProject(row),
-		session_count: toNum(row.session_count),
-		last_active: toNumOrNull(row.last_active)
-	};
-}
-function mapSession(row) {
-	return {
-		...row,
-		created_at: toNum(row.created_at),
-		closed_at: toNumOrNull(row.closed_at)
-	};
-}
-var PostgresRegistryBackend = class {
-	backendType = "postgres";
-	pool;
-	/** False when constructed from a pool owned elsewhere (the shared storage
-	*  backend pool, wired by src/storage/factory.ts) — close() must not end
-	*  a pool this instance doesn't own. */
-	ownsPool;
-	constructor(configOrPool) {
-		if (configOrPool instanceof PgPool) {
-			this.pool = configOrPool;
-			this.ownsPool = false;
-			return;
-		}
-		const config = configOrPool;
-		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,
-			allowExitOnIdle: true
-		});
-		this.ownsPool = true;
-		this.pool.on("error", (err) => {
-			process.stderr.write(`[pai-postgres] Registry pool error: ${err.message}\n`);
-		});
-	}
-	async close() {
-		if (this.ownsPool) await this.pool.end();
-	}
-	async resetRegistry() {
-		const client = await this.pool.connect();
-		try {
-			await client.query("BEGIN");
-			await client.query("DELETE FROM links");
-			await client.query("DELETE FROM compaction_log");
-			await client.query("DELETE FROM session_tags");
-			await client.query("DELETE FROM project_tags");
-			await client.query("DELETE FROM aliases");
-			await client.query("DELETE FROM sessions");
-			await client.query("DELETE FROM tags");
-			await client.query("DELETE FROM projects");
-			await client.query("COMMIT");
-		} catch (e) {
-			await client.query("ROLLBACK");
-			throw e;
-		} finally {
-			client.release();
-		}
-	}
-	async getProjectById(id) {
-		const r = await this.pool.query("SELECT * FROM projects WHERE id = $1", [id]);
-		return r.rows[0] ? mapProject(r.rows[0]) : null;
-	}
-	async getProjectBySlug(slug, opts = {}) {
-		let sql = opts.caseInsensitive ? "SELECT * FROM projects WHERE lower(slug) = lower($1)" : "SELECT * FROM projects WHERE slug = $1";
-		const params = [slug];
-		if (opts.excludeId !== void 0) {
-			params.push(opts.excludeId);
-			sql += ` AND id != $${params.length}`;
-		}
-		const r = await this.pool.query(sql, params);
-		return r.rows[0] ? mapProject(r.rows[0]) : null;
-	}
-	async getProjectByAlias(alias, opts = {}) {
-		const sql = opts.caseInsensitive ? "SELECT p.* FROM projects p JOIN aliases a ON a.project_id = p.id WHERE lower(a.alias) = lower($1)" : "SELECT p.* FROM projects p JOIN aliases a ON a.project_id = p.id WHERE a.alias = $1";
-		const r = await this.pool.query(sql, [alias]);
-		return r.rows[0] ? mapProject(r.rows[0]) : null;
-	}
-	async getProjectByRootPath(rootPath, opts = {}) {
-		let sql = "SELECT * FROM projects WHERE root_path = $1";
-		const params = [rootPath];
-		if (opts.excludeId !== void 0) {
-			params.push(opts.excludeId);
-			sql += ` AND id != $${params.length}`;
-		}
-		const r = await this.pool.query(sql, params);
-		return r.rows[0] ? mapProject(r.rows[0]) : null;
-	}
-	async getProjectByEncodedDir(encodedDir, opts = {}) {
-		let sql = "SELECT * FROM projects WHERE encoded_dir = $1";
-		const params = [encodedDir];
-		if (opts.excludeId !== void 0) {
-			params.push(opts.excludeId);
-			sql += ` AND id != $${params.length}`;
-		}
-		const r = await this.pool.query(sql, params);
-		return r.rows[0] ? mapProject(r.rows[0]) : null;
-	}
-	async findProjectByCwdPrefix(cwd) {
-		const r = await this.pool.query(`SELECT * FROM projects WHERE status = 'active' AND $1 LIKE root_path || '%'
-       ORDER BY length(root_path) DESC LIMIT 1`, [cwd]);
-		return r.rows[0] ? mapProject(r.rows[0]) : null;
-	}
-	async listProjects(opts = {}) {
-		const where = [];
-		const params = [];
-		if (opts.status) {
-			params.push(opts.status);
-			where.push(`p.status = $${params.length}`);
-		}
-		if (opts.excludeArchived) where.push("p.status != 'archived'");
-		if (opts.tagName) {
-			params.push(opts.tagName);
-			where.push(`p.id IN (SELECT pt.project_id FROM project_tags pt JOIN tags t ON pt.tag_id = t.id WHERE t.name = $${params.length})`);
-		}
-		let sql = "SELECT p.* FROM projects p";
-		if (where.length) sql += " WHERE " + where.join(" AND ");
-		switch (opts.orderBy) {
-			case "updated_desc":
-				sql += " ORDER BY p.updated_at DESC";
-				break;
-			case "slug":
-				sql += " ORDER BY p.slug ASC";
-				break;
-			case "id":
-				sql += " ORDER BY p.id";
-				break;
-			default:
-				sql += " ORDER BY p.status ASC, p.updated_at DESC";
-				break;
-		}
-		if (opts.limit !== void 0) {
-			params.push(opts.limit);
-			sql += ` LIMIT $${params.length}`;
-		}
-		return (await this.pool.query(sql, params)).rows.map(mapProject);
-	}
-	async listProjectsByPathLengthDesc(opts = {}) {
-		const where = opts.excludeArchived ? "WHERE status != 'archived'" : "";
-		return (await this.pool.query(`SELECT * FROM projects ${where} ORDER BY LENGTH(root_path) DESC`)).rows.map(mapProject);
-	}
-	async listProjectsWithSessionStats(opts = {}) {
-		const where = [];
-		const params = [];
-		if (opts.status) {
-			params.push(opts.status);
-			where.push(`p.status = $${params.length}`);
-		}
-		if (opts.tagId !== void 0) {
-			params.push(opts.tagId);
-			where.push(`p.id IN (SELECT project_id FROM project_tags WHERE tag_id = $${params.length})`);
-		}
-		let sql = `
-      SELECT p.*,
-        (SELECT COUNT(*) FROM sessions s WHERE s.project_id = p.id)::int AS session_count,
-        (SELECT MAX(s.created_at) FROM sessions s WHERE s.project_id = p.id) AS last_active
-      FROM projects p
-    `;
-		if (where.length) sql += " WHERE " + where.join(" AND ");
-		sql += opts.orderBy === "updated_desc" ? " ORDER BY p.updated_at DESC" : " ORDER BY p.status ASC, p.updated_at DESC";
-		return (await this.pool.query(sql, params)).rows.map(mapProjectWithStats);
-	}
-	async listNamedProjects(opts = {}) {
-		const sql = `
-      SELECT p.*, a.alias AS name,
-        (SELECT COUNT(*) FROM sessions s WHERE s.project_id = p.id)::int AS session_count,
-        (SELECT MAX(s.created_at) FROM sessions s WHERE s.project_id = p.id) AS last_active
-      FROM projects p
-      ${opts.includeUnnamed ? "LEFT JOIN" : "JOIN"} aliases a ON a.project_id = p.id
-      WHERE p.status = 'active'
-      ORDER BY p.updated_at DESC
-    `;
-		return (await this.pool.query(sql)).rows.map((row) => ({
-			...mapProjectWithStats(row),
-			name: row.name
-		}));
-	}
-	async searchProjects(query, limit = 20) {
-		const q = `%${query}%`;
-		return (await this.pool.query(`SELECT * FROM projects WHERE slug LIKE $1 OR display_name LIKE $1 OR root_path LIKE $1
-       ORDER BY updated_at DESC LIMIT $2`, [q, limit])).rows.map(mapProject);
-	}
-	async countProjects(opts = {}) {
-		const r = opts.status ? await this.pool.query("SELECT COUNT(*)::text AS n FROM projects WHERE status = $1", [opts.status]) : await this.pool.query("SELECT COUNT(*)::text AS n FROM projects");
-		return parseInt(r.rows[0].n, 10);
-	}
-	async getMostRecentProjectUpdatedAt() {
-		const r = await this.pool.query("SELECT updated_at FROM projects ORDER BY updated_at DESC LIMIT 1");
-		return r.rows[0] ? Number(r.rows[0].updated_at) : null;
-	}
-	async countChildProjects(parentId) {
-		const r = await this.pool.query("SELECT COUNT(*)::text AS n FROM projects WHERE parent_id = $1", [parentId]);
-		return parseInt(r.rows[0].n, 10);
-	}
-	async findSiblingProjectsBySlugPattern(excludeProjectId, slug, limit = 3) {
-		return (await this.pool.query(`SELECT p.slug, p.root_path, COUNT(s.id)::int AS session_count
-       FROM projects p LEFT JOIN sessions s ON s.project_id = p.id
-       WHERE p.id != $1 AND (p.slug = $2 OR p.slug LIKE $2 || '-%' OR $2 LIKE p.slug || '-%')
-       GROUP BY p.id HAVING COUNT(s.id) > 0 ORDER BY session_count DESC LIMIT $3`, [
-			excludeProjectId,
-			slug,
-			limit
-		])).rows;
-	}
-	async createProject(input) {
-		const type = input.type ?? "local";
-		const status = input.status ?? "active";
-		return mapProject((await this.pool.query(`INSERT INTO projects (slug, display_name, root_path, encoded_dir, type, status, created_at, updated_at)
-       VALUES ($1, $2, $3, $4, $5, $6, $7, $8) RETURNING *`, [
-			input.slug,
-			input.displayName,
-			input.rootPath,
-			input.encodedDir,
-			type,
-			status,
-			input.createdAt,
-			input.updatedAt
-		])).rows[0]);
-	}
-	async createProjectWithSlugRetry(input) {
-		let slug = input.baseSlug;
-		let attempt = 0;
-		while (true) {
-			const r = await this.pool.query(`INSERT INTO projects (slug, display_name, root_path, encoded_dir, type, status, created_at, updated_at)
-         VALUES ($1, $2, $3, $4, 'local', 'active', $5, $6)
-         ON CONFLICT DO NOTHING RETURNING id`, [
-				slug,
-				input.displayName,
-				input.rootPath,
-				input.encodedDir,
-				input.createdAt,
-				input.updatedAt
-			]);
-			if (r.rows.length > 0) return {
-				id: r.rows[0].id,
-				slug,
-				created: true
-			};
-			const existing = await this.pool.query("SELECT id FROM projects WHERE root_path = $1", [input.rootPath]);
-			if (existing.rows[0]) return {
-				id: existing.rows[0].id,
-				slug,
-				created: false
-			};
-			attempt++;
-			slug = `${input.baseSlug}-${attempt}`;
-		}
-	}
-	async updateProjectPath(id, patch, updatedAt) {
-		const sets = [];
-		const params = [];
-		if (patch.rootPath !== void 0) {
-			params.push(patch.rootPath);
-			sets.push(`root_path = $${params.length}`);
-		}
-		if (patch.encodedDir !== void 0) {
-			params.push(patch.encodedDir);
-			sets.push(`encoded_dir = $${params.length}`);
-		}
-		if (updatedAt !== void 0) {
-			params.push(updatedAt);
-			sets.push(`updated_at = $${params.length}`);
-		}
-		if (!sets.length) return;
-		params.push(id);
-		await this.pool.query(`UPDATE projects SET ${sets.join(", ")} WHERE id = $${params.length}`, params);
-	}
-	async updateProjectStatus(id, status, opts = {}) {
-		const sets = [];
-		const params = [status];
-		sets.push("status = $1");
-		if (opts.archivedAt !== void 0) {
-			params.push(opts.archivedAt);
-			sets.push(`archived_at = $${params.length}`);
-		}
-		if (opts.updatedAt !== void 0) {
-			params.push(opts.updatedAt);
-			sets.push(`updated_at = $${params.length}`);
-		}
-		params.push(id);
-		let sql = `UPDATE projects SET ${sets.join(", ")} WHERE id = $${params.length}`;
-		if (opts.requireCurrentStatus) {
-			params.push(opts.requireCurrentStatus);
-			sql += ` AND status = $${params.length}`;
-		}
-		await this.pool.query(sql, params);
-	}
-	async updateProjectDisplayName(id, displayName, updatedAt) {
-		if (updatedAt !== void 0) await this.pool.query("UPDATE projects SET display_name = $1, updated_at = $2 WHERE id = $3", [
-			displayName,
-			updatedAt,
-			id
-		]);
-		else await this.pool.query("UPDATE projects SET display_name = $1 WHERE id = $2", [displayName, id]);
-	}
-	async updateProjectType(id, type, updatedAt) {
-		if (updatedAt !== void 0) await this.pool.query("UPDATE projects SET type = $1, updated_at = $2 WHERE id = $3", [
-			type,
-			updatedAt,
-			id
-		]);
-		else await this.pool.query("UPDATE projects SET type = $1 WHERE id = $2", [type, id]);
-	}
-	async updateProjectSessionConfig(id, config, updatedAt) {
-		if (updatedAt !== void 0) await this.pool.query("UPDATE projects SET session_config = $1, updated_at = $2 WHERE id = $3", [
-			config,
-			updatedAt,
-			id
-		]);
-		else await this.pool.query("UPDATE projects SET session_config = $1 WHERE id = $2", [config, id]);
-	}
-	async updateProjectClaudeNotesDir(id, dir, updatedAt) {
-		if (updatedAt !== void 0) await this.pool.query("UPDATE projects SET claude_notes_dir = $1, updated_at = $2 WHERE id = $3", [
-			dir,
-			updatedAt,
-			id
-		]);
-		else await this.pool.query("UPDATE projects SET claude_notes_dir = $1 WHERE id = $2", [dir, id]);
-	}
-	async updateProjectObsidianLink(id, link, updatedAt) {
-		if (updatedAt !== void 0) await this.pool.query("UPDATE projects SET obsidian_link = $1, updated_at = $2 WHERE id = $3", [
-			link,
-			updatedAt,
-			id
-		]);
-		else await this.pool.query("UPDATE projects SET obsidian_link = $1 WHERE id = $2", [link, id]);
-	}
-	async updateProjectSlug(id, slug, updatedAt) {
-		await this.pool.query("UPDATE projects SET slug = $1, updated_at = $2 WHERE id = $3", [
-			slug,
-			updatedAt,
-			id
-		]);
-	}
-	async reassignProjectParent(fromParentId, toParentId) {
-		return (await this.pool.query("UPDATE projects SET parent_id = $1 WHERE parent_id = $2", [toParentId, fromParentId])).rowCount ?? 0;
-	}
-	async deleteProject(id) {
-		await this.pool.query("DELETE FROM projects WHERE id = $1", [id]);
-	}
-	async deleteProjectCascade(id) {
-		const client = await this.pool.connect();
-		try {
-			await client.query("BEGIN");
-			await client.query("DELETE FROM links WHERE target_project_id = $1", [id]);
-			await client.query("DELETE FROM links WHERE session_id IN (SELECT id FROM sessions WHERE project_id = $1)", [id]);
-			await client.query("DELETE FROM compaction_log WHERE project_id = $1", [id]);
-			await client.query("DELETE FROM project_tags WHERE project_id = $1", [id]);
-			await client.query("DELETE FROM aliases WHERE project_id = $1", [id]);
-			await client.query("DELETE FROM sessions WHERE project_id = $1", [id]);
-			await client.query("DELETE FROM projects WHERE id = $1", [id]);
-			await client.query("COMMIT");
-		} catch (e) {
-			await client.query("ROLLBACK");
-			throw e;
-		} finally {
-			client.release();
-		}
-	}
-	async listTagsForProject(projectId) {
-		return (await this.pool.query("SELECT t.name FROM tags t JOIN project_tags pt ON pt.tag_id = t.id WHERE pt.project_id = $1 ORDER BY t.name", [projectId])).rows.map((row) => row.name);
-	}
-	async listAllTags() {
-		return (await this.pool.query("SELECT id, name FROM tags ORDER BY name")).rows;
-	}
-	async upsertTag(name) {
-		await this.pool.query("INSERT INTO tags (name) VALUES ($1) ON CONFLICT (name) DO NOTHING", [name]);
-		return (await this.pool.query("SELECT id FROM tags WHERE name = $1", [name])).rows[0].id;
-	}
-	async addProjectTag(projectId, tagId) {
-		await this.pool.query("INSERT INTO project_tags (project_id, tag_id) VALUES ($1, $2)", [projectId, tagId]);
-	}
-	async projectHasTag(projectId, tagId) {
-		return ((await this.pool.query("SELECT 1 FROM project_tags WHERE project_id = $1 AND tag_id = $2", [projectId, tagId])).rowCount ?? 0) > 0;
-	}
-	async deleteProjectTag(projectId, tagId) {
-		await this.pool.query("DELETE FROM project_tags WHERE project_id = $1 AND tag_id = $2", [projectId, tagId]);
-	}
-	async reassignProjectTag(fromProjectId, toProjectId, tagId) {
-		await this.pool.query("UPDATE project_tags SET project_id = $1 WHERE project_id = $2 AND tag_id = $3", [
-			toProjectId,
-			fromProjectId,
-			tagId
-		]);
-	}
-	async listProjectTagIds(projectId) {
-		return (await this.pool.query("SELECT tag_id FROM project_tags WHERE project_id = $1", [projectId])).rows.map((row) => row.tag_id);
-	}
-	async countProjectTagsForProject(projectId) {
-		const r = await this.pool.query("SELECT COUNT(*)::text AS n FROM project_tags WHERE project_id = $1", [projectId]);
-		return parseInt(r.rows[0].n, 10);
-	}
-	async copyProjectTags(fromProjectId, toProjectId) {
-		await this.pool.query(`INSERT INTO project_tags (project_id, tag_id) SELECT $1, tag_id FROM project_tags WHERE project_id = $2
-       ON CONFLICT (project_id, tag_id) DO NOTHING`, [toProjectId, fromProjectId]);
-	}
-	async deleteProjectTagsForProject(projectId) {
-		await this.pool.query("DELETE FROM project_tags WHERE project_id = $1", [projectId]);
-	}
-	async resolveAlias(alias) {
-		return (await this.pool.query("SELECT project_id FROM aliases WHERE alias = $1", [alias])).rows[0]?.project_id ?? null;
-	}
-	async listAliasesForProject(projectId) {
-		return (await this.pool.query("SELECT alias FROM aliases WHERE project_id = $1 ORDER BY alias", [projectId])).rows.map((row) => row.alias);
-	}
-	async addAlias(alias, projectId) {
-		await this.pool.query("INSERT INTO aliases (alias, project_id) VALUES ($1, $2)", [alias, projectId]);
-	}
-	async removeAlias(alias) {
-		await this.pool.query("DELETE FROM aliases WHERE alias = $1", [alias]);
-	}
-	async countAliasesForProject(projectId) {
-		const r = await this.pool.query("SELECT COUNT(*)::text AS n FROM aliases WHERE project_id = $1", [projectId]);
-		return parseInt(r.rows[0].n, 10);
-	}
-	async moveProjectAliases(fromProjectId, toProjectId) {
-		await this.pool.query("UPDATE aliases SET project_id = $1 WHERE project_id = $2", [toProjectId, fromProjectId]);
-	}
-	async reassignAlias(alias, toProjectId) {
-		await this.pool.query("UPDATE aliases SET project_id = $1 WHERE alias = $2", [toProjectId, alias]);
-	}
-	async listAliasMap() {
-		return (await this.pool.query(`SELECT a.alias AS alias, p.slug AS slug, p.root_path AS root_path
-       FROM aliases a JOIN projects p ON p.id = a.project_id WHERE p.status != 'archived'`)).rows;
-	}
-	async getSessionById(id) {
-		const r = await this.pool.query("SELECT * FROM sessions WHERE id = $1", [id]);
-		return r.rows[0] ? mapSession(r.rows[0]) : null;
-	}
-	async getSessionByNumber(projectId, number) {
-		const r = await this.pool.query("SELECT * FROM sessions WHERE project_id = $1 AND number = $2", [projectId, number]);
-		return r.rows[0] ? mapSession(r.rows[0]) : null;
-	}
-	async getLatestSessionForProject(projectId) {
-		const r = await this.pool.query("SELECT * FROM sessions WHERE project_id = $1 ORDER BY number DESC LIMIT 1", [projectId]);
-		return r.rows[0] ? mapSession(r.rows[0]) : null;
-	}
-	async getMaxSessionNumber(projectId) {
-		return (await this.pool.query("SELECT COALESCE(MAX(number), 0) AS n FROM sessions WHERE project_id = $1", [projectId])).rows[0].n;
-	}
-	async listSessionsForProject(projectId, opts = {}) {
-		let sql = `SELECT * FROM sessions WHERE project_id = $1 ORDER BY ${opts.orderBy === "created_desc" ? "created_at DESC" : "number ASC"}`;
-		const params = [projectId];
-		if (opts.limit !== void 0) {
-			params.push(opts.limit);
-			sql += ` LIMIT $${params.length}`;
-		}
-		return (await this.pool.query(sql, params)).rows.map(mapSession);
-	}
-	async listSessions(opts = {}) {
-		const where = [];
-		const params = [];
-		if (opts.projectId !== void 0) {
-			params.push(opts.projectId);
-			where.push(`s.project_id = $${params.length}`);
-		}
-		if (opts.status) {
-			params.push(opts.status);
-			where.push(`s.status = $${params.length}`);
-		}
-		let sql = `
-      SELECT s.*, p.slug AS project_slug, p.display_name AS project_name
-      FROM sessions s JOIN projects p ON p.id = s.project_id
-    `;
-		if (where.length) sql += " WHERE " + where.join(" AND ");
-		sql += " ORDER BY s.date DESC, s.number DESC";
-		params.push(opts.limit ?? 20);
-		sql += ` LIMIT $${params.length}`;
-		return (await this.pool.query(sql, params)).rows.map((row) => ({
-			...mapSession(row),
-			project_slug: row.project_slug,
-			project_name: row.project_name
-		}));
-	}
-	async findSessionByFilename(projectId, filename) {
-		return (await this.pool.query("SELECT id FROM sessions WHERE project_id = $1 AND filename = $2 LIMIT 1", [projectId, filename])).rows[0] ?? null;
-	}
-	async sessionNumberTaken(projectId, number) {
-		return ((await this.pool.query("SELECT 1 FROM sessions WHERE project_id = $1 AND number = $2 LIMIT 1", [projectId, number])).rowCount ?? 0) > 0;
-	}
-	async createSession(input) {
-		const status = input.status ?? "completed";
-		return mapSession((await this.pool.query(`INSERT INTO sessions (project_id, number, date, slug, title, filename, status, created_at)
-       VALUES ($1, $2, $3, $4, $5, $6, $7, $8) RETURNING *`, [
-			input.projectId,
-			input.number,
-			input.date,
-			input.slug,
-			input.title,
-			input.filename,
-			status,
-			input.createdAt
-		])).rows[0]);
-	}
-	async upsertSessionIfAbsent(input) {
-		if (((await this.pool.query("SELECT id FROM sessions WHERE project_id = $1 AND number = $2", [input.projectId, input.number])).rowCount ?? 0) > 0) return false;
-		const status = input.status ?? "completed";
-		await this.pool.query(`INSERT INTO sessions (project_id, number, date, slug, title, filename, status, created_at)
-       VALUES ($1, $2, $3, $4, $5, $6, $7, $8)`, [
-			input.projectId,
-			input.number,
-			input.date,
-			input.slug,
-			input.title,
-			input.filename,
-			status,
-			input.createdAt
-		]);
-		return true;
-	}
-	async updateSessionMeta(id, patch) {
-		const sets = [];
-		const params = [];
-		if (patch.slug !== void 0) {
-			params.push(patch.slug);
-			sets.push(`slug = $${params.length}`);
-		}
-		if (patch.title !== void 0) {
-			params.push(patch.title);
-			sets.push(`title = $${params.length}`);
-		}
-		if (patch.filename !== void 0) {
-			params.push(patch.filename);
-			sets.push(`filename = $${params.length}`);
-		}
-		if (!sets.length) return;
-		params.push(id);
-		await this.pool.query(`UPDATE sessions SET ${sets.join(", ")} WHERE id = $${params.length}`, params);
-	}
-	async updateSessionNumber(id, number, opts = {}) {
-		if (opts.filename !== void 0) await this.pool.query("UPDATE sessions SET number = $1, filename = $2 WHERE id = $3", [
-			number,
-			opts.filename,
-			id
-		]);
-		else await this.pool.query("UPDATE sessions SET number = $1 WHERE id = $2", [number, id]);
-	}
-	async updateSessionFilename(id, filename) {
-		await this.pool.query("UPDATE sessions SET filename = $1 WHERE id = $2", [filename, id]);
-	}
-	async updateSessionStatus(id, status, opts = {}) {
-		if (opts.closedAt !== void 0) await this.pool.query("UPDATE sessions SET status = $1, closed_at = $2 WHERE id = $3", [
-			status,
-			opts.closedAt,
-			id
-		]);
-		else await this.pool.query("UPDATE sessions SET status = $1 WHERE id = $2", [status, id]);
-	}
-	async moveSessionToProject(id, projectId, opts = {}) {
-		if (opts.number !== void 0) await this.pool.query("UPDATE sessions SET project_id = $1, number = $2 WHERE id = $3", [
-			projectId,
-			opts.number,
-			id
-		]);
-		else await this.pool.query("UPDATE sessions SET project_id = $1 WHERE id = $2", [projectId, id]);
-	}
-	async deleteSession(id) {
-		await this.pool.query("DELETE FROM sessions WHERE id = $1", [id]);
-	}
-	async backfillFoldedSession(keepId, dropId) {
-		await this.pool.query(`UPDATE sessions SET
-         claude_session_id = COALESCE(claude_session_id,
-                                      (SELECT claude_session_id FROM sessions WHERE id = $1)),
-         token_count       = COALESCE(token_count,
-                                      (SELECT token_count FROM sessions WHERE id = $1)),
-         closed_at         = COALESCE(closed_at,
-                                      (SELECT closed_at FROM sessions WHERE id = $1)),
-         status            = CASE WHEN status = 'open'
-                                   AND (SELECT status FROM sessions WHERE id = $1) != 'open'
-                                  THEN (SELECT status FROM sessions WHERE id = $1)
-                                  ELSE status END
-       WHERE id = $2`, [dropId, keepId]);
-	}
-	async countSessionsForProject(projectId) {
-		const r = await this.pool.query("SELECT COUNT(*)::text AS n FROM sessions WHERE project_id = $1", [projectId]);
-		return parseInt(r.rows[0].n, 10);
-	}
-	async countSessions() {
-		const r = await this.pool.query("SELECT COUNT(*)::text AS n FROM sessions");
-		return parseInt(r.rows[0].n, 10);
-	}
-	async getMostRecentSessionDate(projectId) {
-		return (await this.pool.query("SELECT date FROM sessions WHERE project_id = $1 ORDER BY date DESC LIMIT 1", [projectId])).rows[0]?.date ?? null;
-	}
-	async getMostRecentSessionCreatedAt() {
-		const r = await this.pool.query("SELECT created_at FROM sessions ORDER BY created_at DESC LIMIT 1");
-		return r.rows[0] ? Number(r.rows[0].created_at) : null;
-	}
-	async listSessionTagIds(sessionId) {
-		return (await this.pool.query("SELECT tag_id FROM session_tags WHERE session_id = $1", [sessionId])).rows.map((row) => row.tag_id);
-	}
-	async sessionHasTag(sessionId, tagId) {
-		return ((await this.pool.query("SELECT 1 FROM session_tags WHERE session_id = $1 AND tag_id = $2", [sessionId, tagId])).rowCount ?? 0) > 0;
-	}
-	async addSessionTag(sessionId, tagId) {
-		await this.pool.query("INSERT INTO session_tags (session_id, tag_id) VALUES ($1, $2)", [sessionId, tagId]);
-	}
-	async deleteSessionTag(sessionId, tagId) {
-		await this.pool.query("DELETE FROM session_tags WHERE session_id = $1 AND tag_id = $2", [sessionId, tagId]);
-	}
-	async reassignSessionTag(fromSessionId, toSessionId, tagId) {
-		await this.pool.query("UPDATE session_tags SET session_id = $1 WHERE session_id = $2 AND tag_id = $3", [
-			toSessionId,
-			fromSessionId,
-			tagId
-		]);
-	}
-	async listTagsForSession(sessionId) {
-		return (await this.pool.query("SELECT t.name FROM tags t JOIN session_tags st ON st.tag_id = t.id WHERE st.session_id = $1 ORDER BY t.name", [sessionId])).rows.map((row) => row.name);
-	}
-	async addLink(input) {
-		await this.pool.query("INSERT INTO links (session_id, target_project_id, link_type, created_at) VALUES ($1, $2, $3, $4)", [
-			input.sessionId,
-			input.targetProjectId,
-			input.linkType,
-			input.createdAt
-		]);
-	}
-	async listLinksForSession(sessionId) {
-		return (await this.pool.query("SELECT id, target_project_id FROM links WHERE session_id = $1", [sessionId])).rows;
-	}
-	async listLinksForProject(projectId) {
-		return (await this.pool.query("SELECT id, session_id FROM links WHERE target_project_id = $1", [projectId])).rows;
-	}
-	async linkExists(sessionId, targetProjectId) {
-		return ((await this.pool.query("SELECT 1 FROM links WHERE session_id = $1 AND target_project_id = $2 LIMIT 1", [sessionId, targetProjectId])).rowCount ?? 0) > 0;
-	}
-	async deleteLink(id) {
-		await this.pool.query("DELETE FROM links WHERE id = $1", [id]);
-	}
-	async deleteLinksTargetingProject(projectId) {
-		await this.pool.query("DELETE FROM links WHERE target_project_id = $1", [projectId]);
-	}
-	async deleteLinksFromProjectSessions(projectId) {
-		await this.pool.query("DELETE FROM links WHERE session_id IN (SELECT id FROM sessions WHERE project_id = $1)", [projectId]);
-	}
-	async retargetLink(id, targetProjectId) {
-		await this.pool.query("UPDATE links SET target_project_id = $1 WHERE id = $2", [targetProjectId, id]);
-	}
-	async moveLinkToSession(id, sessionId) {
-		await this.pool.query("UPDATE links SET session_id = $1 WHERE id = $2", [sessionId, id]);
-	}
-	async reassignLinksTarget(fromProjectId, toProjectId) {
-		await this.pool.query(`UPDATE links SET target_project_id = $1 WHERE target_project_id = $2
-         AND NOT EXISTS (
-           SELECT 1 FROM links l2 WHERE l2.session_id = links.session_id AND l2.target_project_id = $1
-         )`, [toProjectId, fromProjectId]);
-	}
-	async countLinksForProject(projectId) {
-		const r = await this.pool.query("SELECT COUNT(*)::text AS n FROM links WHERE target_project_id = $1", [projectId]);
-		return parseInt(r.rows[0].n, 10);
-	}
-	async deleteSelfLinksForProject(projectId) {
-		await this.pool.query(`DELETE FROM links WHERE target_project_id = $1
-         AND session_id IN (SELECT id FROM sessions WHERE project_id = $2)`, [projectId, projectId]);
-	}
-	async appendCompactionLog(entry) {
-		await this.pool.query(`INSERT INTO compaction_log (project_id, session_id, trigger, files_written, token_count, created_at)
-       VALUES ($1, $2, $3, $4, $5, $6)`, [
-			entry.projectId,
-			entry.sessionId,
-			entry.trigger,
-			entry.filesWritten,
-			entry.tokenCount,
-			entry.createdAt
-		]);
-	}
-	async countCompactionLogsForProject(projectId) {
-		const r = await this.pool.query("SELECT COUNT(*)::text AS n FROM compaction_log WHERE project_id = $1", [projectId]);
-		return parseInt(r.rows[0].n, 10);
-	}
-	async moveCompactionLogsByProject(fromProjectId, toProjectId) {
-		return (await this.pool.query("UPDATE compaction_log SET project_id = $1 WHERE project_id = $2", [toProjectId, fromProjectId])).rowCount ?? 0;
-	}
-	async moveCompactionLogsBySession(fromSessionId, toSessionId) {
-		await this.pool.query("UPDATE compaction_log SET session_id = $1 WHERE session_id = $2", [toSessionId, fromSessionId]);
-	}
-	async deleteCompactionLogsForProject(projectId) {
-		await this.pool.query("DELETE FROM compaction_log WHERE project_id = $1", [projectId]);
-	}
-	async planProjectMerge(fromSlug, intoSlug) {
-		const { MergeError } = await import("./merge-2gqRPFu2.mjs");
-		if (fromSlug === intoSlug) throw new MergeError(`Cannot merge ${fromSlug} into itself.`);
-		const fromR = await this.pool.query("SELECT id, slug FROM projects WHERE slug = $1", [fromSlug]);
-		const intoR = await this.pool.query("SELECT id, slug FROM projects WHERE slug = $1", [intoSlug]);
-		const from = fromR.rows[0];
-		const into = intoR.rows[0];
-		if (!from) throw new MergeError(`No project with slug "${fromSlug}".`);
-		if (!into) throw new MergeError(`No project with slug "${intoSlug}".`);
-		let next = (await this.pool.query("SELECT COALESCE(MAX(number), 0) AS n FROM sessions WHERE project_id = $1", [into.id])).rows[0].n;
-		const sessions = (await this.pool.query("SELECT id, number FROM sessions WHERE project_id = $1 ORDER BY number ASC", [from.id])).rows.map((s) => ({
-			id: s.id,
-			from: s.number,
-			to: ++next
-		}));
-		const count = async (sql, ...args) => {
-			const r = await this.pool.query(sql, args);
-			return parseInt(r.rows[0].n, 10);
-		};
-		const aliasTaken = await count("SELECT COUNT(*)::text AS n FROM aliases WHERE alias = $1", from.slug) > 0 || await count("SELECT COUNT(*)::text AS n FROM projects WHERE slug = $1", from.slug) > 1;
-		return {
-			fromId: from.id,
-			fromSlug: from.slug,
-			intoId: into.id,
-			intoSlug: into.slug,
-			sessions,
-			tags: await count("SELECT COUNT(*)::text AS n FROM project_tags WHERE project_id = $1", from.id),
-			aliases: await count("SELECT COUNT(*)::text AS n FROM aliases WHERE project_id = $1", from.id),
-			compactions: await count("SELECT COUNT(*)::text AS n FROM compaction_log WHERE project_id = $1", from.id),
-			links: await count("SELECT COUNT(*)::text AS n FROM links WHERE target_project_id = $1", from.id),
-			aliasToAdd: aliasTaken ? void 0 : from.slug
-		};
-	}
-	async applyProjectMerge(plan) {
-		const client = await this.pool.connect();
-		try {
-			await client.query("BEGIN");
-			for (const s of plan.sessions) await client.query("UPDATE sessions SET project_id = $1, number = $2 WHERE id = $3", [
-				plan.intoId,
-				s.to,
-				s.id
-			]);
-			await client.query(`INSERT INTO project_tags (project_id, tag_id)
-         SELECT $1, tag_id FROM project_tags WHERE project_id = $2
-         ON CONFLICT (project_id, tag_id) DO NOTHING`, [plan.intoId, plan.fromId]);
-			await client.query("DELETE FROM project_tags WHERE project_id = $1", [plan.fromId]);
-			await client.query("UPDATE aliases SET project_id = $1 WHERE project_id = $2", [plan.intoId, plan.fromId]);
-			await client.query("UPDATE compaction_log SET project_id = $1 WHERE project_id = $2", [plan.intoId, plan.fromId]);
-			await client.query(`UPDATE links SET target_project_id = $1 WHERE target_project_id = $2
-           AND NOT EXISTS (
-             SELECT 1 FROM links l2 WHERE l2.session_id = links.session_id AND l2.target_project_id = $1
-           )`, [plan.intoId, plan.fromId]);
-			await client.query("DELETE FROM links WHERE target_project_id = $1", [plan.fromId]);
-			await client.query(`DELETE FROM links WHERE target_project_id = $1
-           AND session_id IN (SELECT id FROM sessions WHERE project_id = $2)`, [plan.intoId, plan.intoId]);
-			if (plan.aliasToAdd) await client.query("INSERT INTO aliases (alias, project_id) VALUES ($1, $2) ON CONFLICT (alias) DO NOTHING", [plan.aliasToAdd, plan.intoId]);
-			await client.query("DELETE FROM projects WHERE id = $1", [plan.fromId]);
-			await client.query("COMMIT");
-		} catch (e) {
-			await client.query("ROLLBACK");
-			throw e;
-		} finally {
-			client.release();
-		}
-	}
-};
-
-//#endregion
-export { PostgresRegistryBackend };
-//# sourceMappingURL=registry-postgres-nOfyBSIW.mjs.map