membot 0.0.1 → 0.1.0

package/src/db/chunks.ts

@@ -0,0 +1,176 @@
+import { EMBEDDING_DIMENSION } from "../constants.ts";
+import { HelpfulError } from "../errors.ts";
+import type { DbConnection } from "./connection.ts";
+
+export interface ChunkInput {
+	chunk_index: number;
+	chunk_content: string;
+	search_text: string;
+	embedding: number[];
+}
+
+export interface ChunkRow extends ChunkInput {
+	logical_path: string;
+	version_id: string;
+}
+
+/**
+ * Insert all chunks for a given version. Throws `HelpfulError` if any
+ * embedding's dimensionality doesn't match `EMBEDDING_DIMENSION` — DuckDB's
+ * `FLOAT[N]` column would reject the bind, so we surface a clearer error
+ * before reaching the driver.
+ */
+export async function insertChunksForVersion(
+	db: DbConnection,
+	logical_path: string,
+	version_id: string,
+	chunks: ChunkInput[],
+): Promise<void> {
+	for (const c of chunks) {
+		if (c.embedding.length !== EMBEDDING_DIMENSION) {
+			throw new HelpfulError({
+				kind: "internal_error",
+				message: `Chunk embedding dimension ${c.embedding.length} does not match expected ${EMBEDDING_DIMENSION}`,
+				hint: `The embedding model must produce ${EMBEDDING_DIMENSION}-dim vectors. Check config.embedding_model.`,
+			});
+		}
+		await db.queryRun(
+			`INSERT INTO chunks (logical_path, version_id, chunk_index, chunk_content, search_text, embedding)
+			 VALUES (?1, CAST(?2 AS TIMESTAMP), ?3, ?4, ?5, ?6::FLOAT[${EMBEDDING_DIMENSION}])`,
+			logical_path,
+			version_id,
+			c.chunk_index,
+			c.chunk_content,
+			c.search_text,
+			c.embedding,
+		);
+	}
+}
+
+/** Drop every chunk for a single version. Called by `deleteVersionAndChunks` during prune. */
+export async function deleteChunksForVersion(
+	db: DbConnection,
+	logical_path: string,
+	version_id: string,
+): Promise<void> {
+	await db.queryRun(
+		`DELETE FROM chunks WHERE logical_path = ?1 AND version_id = CAST(?2 AS TIMESTAMP)`,
+		logical_path,
+		version_id,
+	);
+}
+
+interface RawChunkRow {
+	logical_path: string;
+	version_id: string;
+	chunk_index: number;
+	chunk_content: string;
+	search_text: string;
+	embedding: number[];
+	[key: string]: unknown;
+}
+
+/** All chunks for a single version, ordered by `chunk_index`. */
+export async function listChunksForVersion(
+	db: DbConnection,
+	logical_path: string,
+	version_id: string,
+): Promise<ChunkRow[]> {
+	const rows = await db.queryAll<RawChunkRow>(
+		`SELECT logical_path, CAST(version_id AS VARCHAR) AS version_id,
+		        chunk_index, chunk_content, search_text, embedding
+		 FROM chunks
+		 WHERE logical_path = ?1 AND version_id = CAST(?2 AS TIMESTAMP)
+		 ORDER BY chunk_index`,
+		logical_path,
+		version_id,
+	);
+	return rows.map((r) => ({
+		...r,
+		version_id: String(r.version_id),
+		chunk_index: Number(r.chunk_index),
+	}));
+}
+
+/**
+ * Outcome of a `rebuildFts` call. Distinct kinds let callers (and the
+ * `reindex` CLI) distinguish "empty DB — that's fine" from "extension truly
+ * couldn't load — search will degrade".
+ */
+export type RebuildFtsResult =
+	| { kind: "rebuilt"; chunk_count: number }
+	| { kind: "extension_unavailable"; cause?: string }
+	| { kind: "no_chunks" }
+	| { kind: "rebuild_failed"; cause?: string };
+
+let ftsAttempted = false;
+let ftsAvailable = false;
+let ftsLoadError: string | undefined;
+
+/**
+ * Build/refresh the FTS index over `current_chunks(search_text)`. DuckDB's FTS
+ * is a snapshot — call this after batch inserts/deletes that change the
+ * current_chunks set. The first call attempts to LOAD fts; on failure the
+ * underlying error is captured and returned via `extension_unavailable.cause`
+ * so callers can render it diagnostically.
+ */
+export async function rebuildFts(db: DbConnection): Promise<RebuildFtsResult> {
+	if (!ftsAttempted) {
+		ftsAttempted = true;
+		try {
+			await db.exec(`INSTALL fts`);
+			await db.exec(`LOAD fts`);
+			ftsAvailable = true;
+		} catch (e) {
+			ftsAvailable = false;
+			ftsLoadError = errorMessage(e);
+			return { kind: "extension_unavailable", cause: ftsLoadError };
+		}
+	}
+	if (!ftsAvailable) return { kind: "extension_unavailable", cause: ftsLoadError };
+
+	const sample = await db.queryGet<{ n: number }>(`SELECT COUNT(*) AS n FROM current_chunks`);
+	const chunkCount = sample ? Number(sample.n) : 0;
+	if (chunkCount === 0) return { kind: "no_chunks" };
+
+	try {
+		// FTS over current_chunks (a view) requires materializing into a table.
+		// Drop & recreate the materialized projection on each rebuild.
+		await db.exec(`DROP TABLE IF EXISTS _current_chunks_fts`);
+		await db.exec(
+			`CREATE TABLE _current_chunks_fts AS
+			 SELECT (logical_path || '::' || CAST(version_id AS VARCHAR) || '::' || chunk_index) AS row_key,
+			        logical_path, CAST(version_id AS VARCHAR) AS version_id, chunk_index, search_text
+			 FROM current_chunks`,
+		);
+		await db.exec(
+			`PRAGMA create_fts_index('_current_chunks_fts', 'row_key', 'search_text', stemmer='porter', overwrite=1)`,
+		);
+		await db.exec(`CHECKPOINT`);
+		return { kind: "rebuilt", chunk_count: chunkCount };
+	} catch (e) {
+		return { kind: "rebuild_failed", cause: errorMessage(e) };
+	}
+}
+
+function errorMessage(e: unknown): string {
+	if (e instanceof Error) return e.message;
+	return String(e);
+}
+
+/**
+ * True once `rebuildFts` has succeeded at least once in this process.
+ * False until then, or permanently false on platforms where the DuckDB
+ * `fts` extension cannot load — in which case search degrades to
+ * semantic-only without erroring.
+ */
+export function isFtsAvailable(): boolean {
+	return ftsAvailable;
+}
+
+/** Test-only: reset the cached extension-load state so per-test ephemeral DBs start clean. */
+export function _resetFtsState(): void {
+	ftsAttempted = false;
+	ftsAvailable = false;
+	ftsLoadError = undefined;
+}

package/src/db/connection.ts

@@ -0,0 +1,173 @@
+import {
+	blobValue,
+	DuckDBInstance,
+	type DuckDBConnection as DuckDBNativeConnection,
+	type DuckDBValue,
+	listValue,
+} from "@duckdb/node-api";
+
+import { EMBEDDING_DIMENSION } from "../constants.ts";
+import { asHelpful } from "../errors.ts";
+import { applyMigrations } from "./migrations.ts";
+
+/** Subset of @duckdb/node-api types we feed into / get out of queries. */
+export type SqlScalar = string | number | boolean | bigint | null | Uint8Array;
+export type SqlParam = SqlScalar | number[] | SqlScalar[];
+
+export interface RunResult {
+	changes: number;
+}
+
+/**
+ * Thin async wrapper around a DuckDB connection. Uses ?N placeholders
+ * (translated to $N internally) and returns plain JS objects.
+ */
+export class DbConnection {
+	private readonly conn: DuckDBNativeConnection;
+	private readonly instance: DuckDBInstance | null;
+	readonly path: string;
+	private closed = false;
+
+	constructor(conn: DuckDBNativeConnection, instance: DuckDBInstance | null, path: string) {
+		this.conn = conn;
+		this.instance = instance;
+		this.path = path;
+	}
+
+	/** Run a parameter-less SQL statement (DDL, PRAGMA, batch SQL). */
+	async exec(sql: string): Promise<void> {
+		await this.conn.run(sql);
+	}
+
+	/** Run a query and return the first row, or null. SQL uses `?N` placeholders. */
+	async queryGet<T extends Record<string, unknown> = Record<string, unknown>>(
+		sql: string,
+		...params: SqlParam[]
+	): Promise<T | null> {
+		const result = await this.conn.runAndReadAll(translateParams(sql), flattenParams(params) as DuckDBValue[]);
+		const rows = (await result.getRowObjectsJS()) as Record<string, unknown>[];
+		if (!rows[0]) return null;
+		return convertRow(rows[0]) as T;
+	}
+
+	/** Run a query and return all rows. SQL uses `?N` placeholders. */
+	async queryAll<T extends Record<string, unknown> = Record<string, unknown>>(
+		sql: string,
+		...params: SqlParam[]
+	): Promise<T[]> {
+		const result = await this.conn.runAndReadAll(translateParams(sql), flattenParams(params) as DuckDBValue[]);
+		const rows = (await result.getRowObjectsJS()) as Record<string, unknown>[];
+		return rows.map(convertRow) as T[];
+	}
+
+	/** Run a mutation (INSERT/UPDATE/DELETE) and report rows changed. SQL uses `?N` placeholders. */
+	async queryRun(sql: string, ...params: SqlParam[]): Promise<RunResult> {
+		const result = await this.conn.run(translateParams(sql), flattenParams(params) as DuckDBValue[]);
+		return { changes: Number(result.rowsChanged) };
+	}
+
+	/** Disconnect and close the owning DuckDB instance. Idempotent; subsequent calls are no-ops. */
+	async close(): Promise<void> {
+		if (this.closed) return;
+		this.closed = true;
+		this.conn.disconnectSync();
+		if (this.instance) {
+			try {
+				this.instance.closeSync();
+			} catch {
+				// best effort
+			}
+		}
+	}
+}
+
+/** Type guard for the JS values DuckDB returns directly without further coercion. */
+function isDuckDBPrimitive(v: unknown): v is string | number | boolean | bigint | null | Uint8Array | Date {
+	if (v === null) return true;
+	const t = typeof v;
+	return (
+		t === "string" ||
+		t === "number" ||
+		t === "boolean" ||
+		t === "bigint" ||
+		v instanceof Uint8Array ||
+		v instanceof Date
+	);
+}
+
+/**
+ * Normalize a value coming out of DuckDB into something the rest of the
+ * codebase expects: `bigint` → `number` (we never have row counts that
+ * exceed Number.MAX_SAFE_INTEGER), `Date` → ISO string (so JSON
+ * serialization is stable), and recurse into arrays/objects.
+ */
+function convertValue(v: unknown): unknown {
+	if (typeof v === "bigint") {
+		// Bigints from row counts and TIMESTAMP fit in Number safely for our use.
+		return Number(v);
+	}
+	if (v instanceof Date) return v.toISOString();
+	if (Array.isArray(v)) return v.map(convertValue);
+	if (v && typeof v === "object" && !(v instanceof Uint8Array)) {
+		const out: Record<string, unknown> = {};
+		for (const [k, val] of Object.entries(v as Record<string, unknown>)) {
+			out[k] = convertValue(val);
+		}
+		return out;
+	}
+	if (isDuckDBPrimitive(v)) return v;
+	return v;
+}
+
+/** Apply `convertValue` to every column of a row. */
+function convertRow(row: Record<string, unknown>): Record<string, unknown> {
+	const out: Record<string, unknown> = {};
+	for (const [k, v] of Object.entries(row)) {
+		out[k] = convertValue(v);
+	}
+	return out;
+}
+
+/** Rewrite our `?N` placeholder convention to DuckDB's native `$N` form. */
+function translateParams(sql: string): string {
+	return sql.replace(/\?(\d+)/g, "$$$1");
+}
+
+/**
+ * Coerce JS values into types that `@duckdb/node-api` knows how to bind.
+ * Plain JS arrays and Uint8Arrays both fall through to ANY in DuckDB's
+ * type-inference path, so we wrap them with the proper value classes here.
+ * Use `?N::FLOAT[384]` / `?N::BLOB` SQL casts at the binding site to land
+ * the value in the right column type.
+ */
+function flattenParams(params: SqlParam[]): unknown[] {
+	return params.map((p) => {
+		if (p instanceof Uint8Array) return blobValue(p);
+		if (Array.isArray(p)) return listValue(p as readonly (string | number | boolean | bigint | null)[]);
+		return p;
+	});
+}
+
+/**
+ * Open a DuckDB-backed connection for the given file path. Runs all migrations
+ * against the connection before returning. Pass `:memory:` for in-process tests.
+ */
+export async function openDb(path: string): Promise<DbConnection> {
+	let instance: DuckDBInstance;
+	try {
+		instance = await DuckDBInstance.create(path);
+	} catch (err) {
+		throw asHelpful(
+			err,
+			`while opening DuckDB at ${path}`,
+			`Check that ${path} is writable and not held open by another process. Delete the file to start fresh.`,
+			"internal_error",
+		);
+	}
+	const conn = await instance.connect();
+	const wrapper = new DbConnection(conn, instance, path);
+	await applyMigrations(wrapper);
+	return wrapper;
+}
+
+export { EMBEDDING_DIMENSION };

package/src/db/files.ts

@@ -0,0 +1,325 @@
+import type { DbConnection, SqlParam } from "./connection.ts";
+
+export type SourceType = "local" | "remote" | "inline";
+export type FetcherKind = "http" | "mcpx" | "local" | "inline";
+
+export interface FileRow {
+	logical_path: string;
+	version_id: string;
+	tombstone: boolean;
+	source_type: SourceType;
+	source_path: string | null;
+	source_mtime_ms: number | null;
+	source_sha256: string | null;
+	blob_sha256: string | null;
+	content_sha256: string | null;
+	content: string | null;
+	description: string | null;
+	mime_type: string | null;
+	size_bytes: number | null;
+	fetcher: FetcherKind | null;
+	fetcher_server: string | null;
+	fetcher_tool: string | null;
+	fetcher_args: Record<string, unknown> | null;
+	refresh_frequency_sec: number | null;
+	refreshed_at: string | null;
+	last_refresh_status: string | null;
+	change_note: string | null;
+	created_at: string;
+}
+
+export interface NewFileVersion {
+	logical_path: string;
+	version_id?: string;
+	tombstone?: boolean;
+	source_type: SourceType;
+	source_path?: string | null;
+	source_mtime_ms?: number | null;
+	source_sha256?: string | null;
+	blob_sha256?: string | null;
+	content_sha256?: string | null;
+	content?: string | null;
+	description?: string | null;
+	mime_type?: string | null;
+	size_bytes?: number | null;
+	fetcher?: FetcherKind | null;
+	fetcher_server?: string | null;
+	fetcher_tool?: string | null;
+	fetcher_args?: Record<string, unknown> | null;
+	refresh_frequency_sec?: number | null;
+	refreshed_at?: string | null;
+	last_refresh_status?: string | null;
+	change_note?: string | null;
+}
+
+const ROW_COLUMNS = [
+	"logical_path",
+	"version_id",
+	"tombstone",
+	"source_type",
+	"source_path",
+	"source_mtime_ms",
+	"source_sha256",
+	"blob_sha256",
+	"content_sha256",
+	"content",
+	"description",
+	"mime_type",
+	"size_bytes",
+	"fetcher",
+	"fetcher_server",
+	"fetcher_tool",
+	"fetcher_args",
+	"refresh_frequency_sec",
+	"refreshed_at",
+	"last_refresh_status",
+	"change_note",
+	"created_at",
+] as const;
+
+const COLUMN_LIST = ROW_COLUMNS.join(", ");
+
+/**
+ * Insert a new (logical_path, version_id) row. Returns the assigned version_id.
+ * If `version_id` is omitted, uses `now()` at millisecond precision; the caller
+ * should retry with a bumped timestamp on the rare collision case.
+ */
+export async function insertVersion(db: DbConnection, file: NewFileVersion): Promise<string> {
+	const versionId = file.version_id ?? millisIso(Date.now());
+	const fetcherArgsJson = file.fetcher_args ? JSON.stringify(file.fetcher_args) : null;
+
+	await db.queryRun(
+		`INSERT INTO files (
+			logical_path, version_id, tombstone, source_type,
+			source_path, source_mtime_ms, source_sha256, blob_sha256,
+			content_sha256, content, description, mime_type, size_bytes,
+			fetcher, fetcher_server, fetcher_tool, fetcher_args,
+			refresh_frequency_sec, refreshed_at, last_refresh_status, change_note
+		) VALUES (
+			?1, CAST(?2 AS TIMESTAMP), ?3, ?4,
+			?5, ?6, ?7, ?8,
+			?9, ?10, ?11, ?12, ?13,
+			?14, ?15, ?16, ?17,
+			?18, ?19, ?20, ?21
+		)`,
+		file.logical_path,
+		versionId,
+		!!file.tombstone,
+		file.source_type,
+		file.source_path ?? null,
+		file.source_mtime_ms ?? null,
+		file.source_sha256 ?? null,
+		file.blob_sha256 ?? null,
+		file.content_sha256 ?? null,
+		file.content ?? null,
+		file.description ?? null,
+		file.mime_type ?? null,
+		file.size_bytes ?? null,
+		file.fetcher ?? null,
+		file.fetcher_server ?? null,
+		file.fetcher_tool ?? null,
+		fetcherArgsJson,
+		file.refresh_frequency_sec ?? null,
+		file.refreshed_at ?? null,
+		file.last_refresh_status ?? null,
+		file.change_note ?? null,
+	);
+	return versionId;
+}
+
+/** Convert a unix-millis number to an ISO string at ms precision. */
+export function millisIso(ms: number): string {
+	return new Date(ms).toISOString();
+}
+
+interface RawFileRow extends Omit<FileRow, "fetcher_args" | "tombstone"> {
+	fetcher_args: string | null | Record<string, unknown>;
+	tombstone: boolean | number;
+	[key: string]: unknown;
+}
+
+/**
+ * Coerce a raw DuckDB row into a typed `FileRow`. JSON-parses the
+ * `fetcher_args` column (DuckDB returns it as text or a parsed object
+ * depending on driver version) and normalizes `tombstone` to a boolean
+ * (some drivers return 0/1).
+ */
+function toFileRow(row: RawFileRow | null): FileRow | null {
+	if (!row) return null;
+	let parsed: Record<string, unknown> | null = null;
+	if (row.fetcher_args && typeof row.fetcher_args === "string") {
+		try {
+			parsed = JSON.parse(row.fetcher_args);
+		} catch {
+			parsed = null;
+		}
+	} else if (row.fetcher_args && typeof row.fetcher_args === "object") {
+		parsed = row.fetcher_args;
+	}
+	return {
+		...row,
+		fetcher_args: parsed,
+		tombstone: !!row.tombstone,
+	};
+}
+
+/** Fetch the current (latest non-tombstoned) row for a logical_path, or null. */
+export async function getCurrent(db: DbConnection, logicalPath: string): Promise<FileRow | null> {
+	const row = await db.queryGet<RawFileRow>(
+		`SELECT ${COLUMN_LIST} FROM current_files WHERE logical_path = ?1`,
+		logicalPath,
+	);
+	return toFileRow(row);
+}
+
+/** Fetch the exact (logical_path, version_id) row, or null if it doesn't exist. */
+export async function getVersion(db: DbConnection, logicalPath: string, versionId: string): Promise<FileRow | null> {
+	const row = await db.queryGet<RawFileRow>(
+		`SELECT ${COLUMN_LIST} FROM files
+		 WHERE logical_path = ?1 AND version_id = CAST(?2 AS TIMESTAMP)`,
+		logicalPath,
+		versionId,
+	);
+	return toFileRow(row);
+}
+
+/** All versions for a logical_path (including tombstones), newest first. */
+export async function listVersions(db: DbConnection, logicalPath: string): Promise<FileRow[]> {
+	const rows = await db.queryAll<RawFileRow>(
+		`SELECT ${COLUMN_LIST} FROM files WHERE logical_path = ?1 ORDER BY version_id DESC`,
+		logicalPath,
+	);
+	return rows.map((r) => toFileRow(r) as FileRow);
+}
+
+export interface ListCurrentOptions {
+	prefix?: string;
+	limit?: number;
+	offset?: number;
+}
+
+/**
+ * List current (latest, non-tombstoned) rows ordered by logical_path.
+ * `prefix` filters to paths starting with the given string. `limit` defaults
+ * to 1000 and `offset` to 0; together they support cursor-style pagination.
+ */
+export async function listCurrent(db: DbConnection, options: ListCurrentOptions = {}): Promise<FileRow[]> {
+	const where: string[] = [];
+	const params: SqlParam[] = [];
+	if (options.prefix) {
+		where.push(`logical_path LIKE ?${params.length + 1}`);
+		params.push(`${options.prefix}%`);
+	}
+	const limit = options.limit ?? 1000;
+	const offset = options.offset ?? 0;
+	const sql = `SELECT ${COLUMN_LIST} FROM current_files
+		${where.length ? `WHERE ${where.join(" AND ")}` : ""}
+		ORDER BY logical_path
+		LIMIT ${Number(limit)} OFFSET ${Number(offset)}`;
+	const rows = await db.queryAll<RawFileRow>(sql, ...params);
+	return rows.map((r) => toFileRow(r) as FileRow);
+}
+
+/** Just the logical_paths of every current row, alphabetized. Used by `tree` and discovery flows. */
+export async function listAllCurrentPaths(db: DbConnection): Promise<string[]> {
+	const rows = await db.queryAll<{ logical_path: string }>(
+		`SELECT logical_path FROM current_files ORDER BY logical_path`,
+	);
+	return rows.map((r) => r.logical_path);
+}
+
+/** Insert a tombstone version for the given path. */
+export async function tombstone(db: DbConnection, logicalPath: string, changeNote?: string): Promise<string> {
+	return insertVersion(db, {
+		logical_path: logicalPath,
+		source_type: "inline",
+		tombstone: true,
+		content: "",
+		change_note: changeNote ?? null,
+	});
+}
+
+/** Update only the mutable status fields on the latest row for a logical_path. */
+export async function updateRefreshStatus(
+	db: DbConnection,
+	logicalPath: string,
+	versionId: string,
+	status: { refreshed_at: string; last_refresh_status: string },
+): Promise<void> {
+	await db.queryRun(
+		`UPDATE files
+		 SET refreshed_at = CAST(?1 AS TIMESTAMP),
+		     last_refresh_status = ?2
+		 WHERE logical_path = ?3 AND version_id = CAST(?4 AS TIMESTAMP)`,
+		status.refreshed_at,
+		status.last_refresh_status,
+		logicalPath,
+		versionId,
+	);
+}
+
+export interface DueRefreshRow {
+	logical_path: string;
+	version_id: string;
+	refresh_frequency_sec: number;
+	refreshed_at: string | null;
+	[key: string]: unknown;
+}
+
+/** Rows whose refresh frequency has elapsed (current versions only). */
+export async function listDueRefreshes(db: DbConnection): Promise<DueRefreshRow[]> {
+	const rows = await db.queryAll<DueRefreshRow>(
+		`SELECT logical_path, CAST(version_id AS VARCHAR) AS version_id,
+		        refresh_frequency_sec,
+		        CAST(refreshed_at AS VARCHAR) AS refreshed_at
+		 FROM current_files
+		 WHERE refresh_frequency_sec IS NOT NULL
+		   AND (refreshed_at IS NULL
+				OR CURRENT_TIMESTAMP > refreshed_at + (refresh_frequency_sec * INTERVAL '1 second'))`,
+	);
+	return rows.map((r) => ({
+		logical_path: r.logical_path,
+		version_id: String(r.version_id),
+		refresh_frequency_sec: Number(r.refresh_frequency_sec),
+		refreshed_at: r.refreshed_at ? String(r.refreshed_at) : null,
+	}));
+}
+
+/**
+ * Delete non-current versions whose version_id is older than `beforeIso`.
+ * Returns the count of removed file rows. Tombstones for paths with no
+ * newer version are preserved (they are themselves the current row).
+ */
+export async function pruneOldVersions(db: DbConnection, beforeIso: string): Promise<{ removed: number }> {
+	// Versions older than cutoff that are NOT the current version for their path.
+	const result = await db.queryRun(
+		`DELETE FROM files
+		 WHERE version_id < CAST(?1 AS TIMESTAMP)
+		   AND (logical_path, version_id) NOT IN (
+		     SELECT logical_path, MAX(version_id) FROM files GROUP BY logical_path
+		   )`,
+		beforeIso,
+	);
+	return { removed: result.changes };
+}
+
+/**
+ * Hard-delete a single (logical_path, version_id) row and its chunks.
+ * Bypasses the append-only versioning model — used by `prune` to reclaim
+ * space. Prefer `tombstone()` for user-driven deletes so history is
+ * preserved.
+ */
+export async function deleteVersionAndChunks(db: DbConnection, logicalPath: string, versionId: string): Promise<void> {
+	await db.queryRun(
+		`DELETE FROM chunks WHERE logical_path = ?1 AND version_id = CAST(?2 AS TIMESTAMP)`,
+		logicalPath,
+		versionId,
+	);
+	await db.queryRun(
+		`DELETE FROM files WHERE logical_path = ?1 AND version_id = CAST(?2 AS TIMESTAMP)`,
+		logicalPath,
+		versionId,
+	);
+}
+
+export { COLUMN_LIST as FILE_COLUMNS };