aiex-cli 0.1.1-beta.6 → 0.1.1-beta.8

package/dist/cli.mjs

@@ -1,11 +1,10 @@
-import { A as seedConfig, C as CORRECTION_SYSTEM_PROMPT, D as PLACEHOLDER_TEXT, E as PLACEHOLDER_SCHEMA, M as name, N as package_default, O as buildCorrectionUserPrompt, P as version, S as DEFAULT_MINERU_CONFIG, T as EVIDENCE_INSTRUCTIONS, _ as doctorDiagnosticsSeverityRows, a as recognizeImageText, b as DEFAULT_LITEPARSE_CONFIG, c as t, d as writeAIConfig, f as AIConfigSchema, h as toSnakeCase, j as description, k as createConfig, l as getDefaultAIConfig, m as parseJsonSchema, n as collectDoctorDiagnostics, o as shouldUseImageOcrFallback, p as JsonSchemaDefinitionSchema, r as createMigrationConfig, s as initI18n, t as generateDrizzleSchema, u as readAIConfig, v as doctorDiagnosticsTableRows, w as DEFAULT_PROMPT_CONFIG, x as DEFAULT_MINERU_API_CONFIG, y as formatDoctorDiagnosticsJson } from "./generate-drizzle-schema-DAeXmyrZ.mjs";
+import { A as seedConfig, C as CORRECTION_SYSTEM_PROMPT, D as PLACEHOLDER_TEXT, E as PLACEHOLDER_SCHEMA, M as name, N as package_default, O as buildCorrectionUserPrompt, P as version, S as DEFAULT_MINERU_CONFIG, T as EVIDENCE_INSTRUCTIONS, _ as doctorDiagnosticsSeverityRows, a as recognizeImageText, b as DEFAULT_LITEPARSE_CONFIG, c as t, d as readAIConfig, f as writeAIConfig, h as parseJsonSchema, j as description, k as createConfig, l as createProjectDatabase, m as JsonSchemaDefinitionSchema, n as collectDoctorDiagnostics, o as shouldUseImageOcrFallback, p as AIConfigSchema, r as createMigrationConfig, s as initI18n, t as generateDrizzleSchema, u as getDefaultAIConfig, v as doctorDiagnosticsTableRows, w as DEFAULT_PROMPT_CONFIG, x as DEFAULT_MINERU_API_CONFIG, y as formatDoctorDiagnosticsJson } from "./generate-drizzle-schema-BcStmKUc.mjs";
 import { createRequire } from "node:module";
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import process from "node:process";
 import { fileURLToPath } from "node:url";
-import Database from "better-sqlite3";
 import { execa } from "execa";
 import { readFile, writeFile } from "jsonfile";
 import { ZodError, z } from "zod";
@@ -39,7 +38,6 @@ import { serveStatic } from "@hono/node-server/serve-static";
 import { Hono } from "hono";
 import { cors } from "hono/cors";
 import { zValidator } from "@hono/zod-validator";
-import { Kysely, SqliteDialect, sql } from "kysely";
 
 //#region src/infrastructure/completion/completion-scripts.ts
 function bashScript(name$1) {
@@ -164,6 +162,11 @@ function classifyInputError(error, inputProcessing) {
 	if (message.includes("pdf") || message.includes("converter")) return "file_conversion";
 	return "input_detection";
 }
+function qualityGateError(quality) {
+	const invalidEvidenceFields = quality?.ai?.evidence?.invalidFields ?? [];
+	if (invalidEvidenceFields.length > 0) return `Evidence mismatch for field(s): ${invalidEvidenceFields.join(", ")}`;
+	return null;
+}
 
 //#endregion
 //#region src/infrastructure/input/detect-file-kind.ts
@@ -619,26 +622,43 @@ const FILE_PART_EXTENSIONS = new Set([
 	"webp"
 ]);
 const PDF_EXT_RE = /\.pdf$/i;
+function textStatus(text$1) {
+	return text$1.trim().length > 0 ? "parsed" : "partially_parsed";
+}
+function withProcessingResult(inputProcessing, status, diagnostics = {}, warnings = []) {
+	return {
+		...inputProcessing,
+		status,
+		diagnostics,
+		warnings: warnings.length ? warnings : void 0
+	};
+}
 async function describeExtractFileInput(filePath, aiConfig, modelOverride) {
 	const detected = await detectInputFileKind(filePath);
-	if (detected.kind === "image") return {
-		kind: "image",
-		mime: detected.mime,
-		handler: shouldUseImageOcrFallback(aiConfig, modelOverride) ? "image_local_ocr" : "image_vision"
-	};
+	if (detected.kind === "image") {
+		const useLocalOcr = shouldUseImageOcrFallback(aiConfig, modelOverride);
+		return {
+			kind: "image",
+			mime: detected.mime,
+			handler: useLocalOcr ? "image_local_ocr" : "image_vision",
+			parser: useLocalOcr ? "system_ocr" : "vision_model"
+		};
+	}
 	if (detected.kind === "pdf") {
 		const converter = createPdfConverter(aiConfig?.pdf);
 		return {
 			kind: "pdf",
 			mime: detected.mime,
 			handler: "pdf_converter",
-			converter: converter.name
+			converter: converter.name,
+			parser: converter.name
 		};
 	}
 	if (detected.kind === "text") return {
 		kind: "text",
 		mime: detected.mime,
-		handler: "text"
+		handler: "text",
+		parser: "utf8_text"
 	};
 	throw new Error(unsupportedFileTypeMessage(detected.mime ?? "application/octet-stream"));
 }
@@ -656,7 +676,11 @@ async function readExtractFileInput(filePath, aiConfig, modelOverride) {
 			consola.info(t("command.extract.file.ocrText", { confidence: (result.confidence * 100).toFixed(1) }));
 			return {
 				text: result.text,
-				inputProcessing,
+				inputProcessing: withProcessingResult(inputProcessing, textStatus(result.text), {
+					confidence: result.confidence,
+					textLength: result.text.length,
+					platform: process.platform
+				}),
 				quality: { input: {
 					kind: "image",
 					textLength: result.text.length,
@@ -672,7 +696,7 @@ async function readExtractFileInput(filePath, aiConfig, modelOverride) {
 		return {
 			text: "",
 			filePath,
-			inputProcessing,
+			inputProcessing: withProcessingResult(inputProcessing, "parsed", { filePart: true }),
 			quality: { input: { kind: "image" } }
 		};
 	}
@@ -695,17 +719,23 @@ async function readExtractFileInput(filePath, aiConfig, modelOverride) {
 			consola.info(t("command.extract.file.markdownSaved", { path: fallbackMd }));
 		}
 		const textLength = result.text.length;
+		const emptyText = result.text.trim().length === 0;
 		return {
 			text: result.text,
-			inputProcessing,
+			inputProcessing: withProcessingResult(inputProcessing, emptyText ? "partially_parsed" : "parsed", {
+				pageCount: result.pageCount,
+				textLength,
+				emptyText,
+				fallbackUsed: result.metadata?.fallback === "true"
+			}, result.warnings),
 			quality: { input: {
 				kind: "pdf",
 				textLength,
-				emptyText: result.text.trim().length === 0,
+				emptyText,
 				pdf: {
 					pageCount: result.pageCount,
 					textLength,
-					emptyText: result.text.trim().length === 0,
+					emptyText,
 					fallbackUsed: result.metadata?.fallback === "true",
 					converter: result.metadata?.converter ?? converter.name
 				}
@@ -716,7 +746,10 @@ async function readExtractFileInput(filePath, aiConfig, modelOverride) {
 		const text$1 = await fs.readFile(filePath, "utf-8");
 		return {
 			text: text$1,
-			inputProcessing,
+			inputProcessing: withProcessingResult(inputProcessing, textStatus(text$1), {
+				textLength: text$1.length,
+				emptyText: text$1.trim().length === 0
+			}),
 			quality: { input: {
 				kind: "text",
 				textLength: text$1.length,
@@ -1223,6 +1256,46 @@ function verifyFieldEvidence(input) {
 	}
 	return Object.keys(verified).length > 0 ? verified : void 0;
 }
+function isEvidenceEligibleProperty(property) {
+	return property.type === "string" || property.type === "number" || property.type === "integer";
+}
+function buildFieldEvidenceQuality(input) {
+	if (!isRecord$3(input.data)) return void 0;
+	const fieldStatus = {};
+	const supportedFields = [];
+	const unsupportedFields = [];
+	const missingFields = [];
+	const invalidFields = [];
+	for (const [field, property] of Object.entries(input.schema.properties)) {
+		if (!isEvidenceEligibleProperty(property)) continue;
+		const value = input.data[field];
+		let status;
+		if (value === null || value === void 0) {
+			status = "missing";
+			missingFields.push(field);
+		} else if (input.verifiedEvidence?.[field]) {
+			status = "supported";
+			supportedFields.push(field);
+		} else if (input.rawEvidence?.[field]) {
+			status = "invalid";
+			invalidFields.push(field);
+		} else {
+			status = "unsupported";
+			unsupportedFields.push(field);
+		}
+		fieldStatus[field] = status;
+	}
+	const total = Object.keys(fieldStatus).length;
+	if (total === 0) return void 0;
+	return {
+		fieldStatus,
+		supportedFields,
+		unsupportedFields,
+		missingFields,
+		invalidFields,
+		supportedRate: supportedFields.length / total
+	};
+}
 
 //#endregion
 //#region src/domain/ai-extraction/json-utils.ts
@@ -1827,6 +1900,12 @@ async function extractStructuredData(input) {
 						data: businessData,
 						rawEvidence: stripped.rawEvidence
 					}) : void 0;
+					const evidenceQuality = canLocateEvidence ? buildFieldEvidenceQuality({
+						schema,
+						data: businessData,
+						rawEvidence: stripped.rawEvidence,
+						verifiedEvidence: evidence
+					}) : void 0;
 					return {
 						success: true,
 						outputPath: await writeExtractionOutput({
@@ -1848,7 +1927,8 @@ async function extractStructuredData(input) {
 							selfCorrectionCount: attempt - 1,
 							apiRetryCount,
 							missingFields: missing.fields,
-							missingFieldRate: missing.rate
+							missingFieldRate: missing.rate,
+							evidence: evidenceQuality
 						} }
 					};
 				} else validationError = validation.error;
@@ -1932,161 +2012,23 @@ async function listSchemas(aiexDir) {
 	}
 }
 
-//#endregion
-//#region src/infrastructure/extraction/insert-extracted-data.ts
-function convertValue(value, column) {
-	if (value === null || value === void 0) return null;
-	const mode = column.columnType.class !== "real" ? column.columnType.mode : void 0;
-	if (mode === "json") return typeof value === "string" ? value : JSON.stringify(value);
-	if (mode === "boolean") return value ? 1 : 0;
-	if (mode === "timestamp" || mode === "timestamp_ms") {
-		if (typeof value === "string") {
-			const ms = Date.parse(value);
-			if (Number.isNaN(ms)) return value;
-			return mode === "timestamp_ms" ? ms : Math.floor(ms / 1e3);
-		}
-		return value;
-	}
-	return value;
-}
-function buildInsertSql(table, data) {
-	const columns = [];
-	const values = [];
-	for (const col of table.columns) {
-		if (col.isAutoIncrement) continue;
-		const value = data[col.name];
-		if (value === void 0) {
-			if (col.default !== void 0) {
-				columns.push(col.name);
-				values.push(convertValue(col.default, col));
-			}
-			continue;
-		}
-		columns.push(col.name);
-		values.push(convertValue(value, col));
-	}
-	const placeholders = values.map(() => "?").join(", ");
-	return {
-		sql: `INSERT INTO ${table.name} (${columns.join(", ")}) VALUES (${placeholders})`,
-		values
-	};
-}
-function insertTableRow({ db, table, data, parentRowId, foreignKeyColumn }) {
-	const rowData = { ...data };
-	if (parentRowId !== void 0 && foreignKeyColumn) rowData[foreignKeyColumn] = parentRowId;
-	const { sql: sql$1, values } = buildInsertSql(table, rowData);
-	const info = db.prepare(sql$1).run(...values);
-	return Number(info.lastInsertRowid);
-}
-function parseDataByColumns(data, schema, table) {
-	const result = {};
-	if ("properties" in schema) {
-		const s = schema;
-		for (const [propName, prop] of Object.entries(s.properties)) {
-			if (prop.nested?.enabled) continue;
-			if (prop.type === "array" && prop.items?.nested?.enabled) continue;
-			const colName = toSnakeCase(propName);
-			if (table.columns.some((c) => c.name === colName && c.isAutoIncrement)) continue;
-			if (propName in data) result[colName] = data[propName];
-		}
-	}
-	if (schema.table?.timestamps) {
-		if (!("created_at" in result)) result.created_at = Math.floor(Date.now() / 1e3);
-		if (!("updated_at" in result)) result.updated_at = Math.floor(Date.now() / 1e3);
-	}
-	return result;
-}
-function insertExtractedData(db, schema, data) {
-	const inserted = [];
-	try {
-		const parseResult = parseJsonSchema(schema);
-		const mainTable = parseResult.tables[0];
-		db.transaction(() => {
-			const mainRowId = insertTableRow({
-				db,
-				table: mainTable,
-				data: parseDataByColumns(data, schema, mainTable)
-			});
-			inserted.push({
-				table: mainTable.name,
-				rowId: mainRowId
-			});
-			for (const revRel of parseResult.reverseRelations) {
-				const rel = parseResult.relations.find((r) => r.fromTable === revRel.toTable && r.toTable === revRel.fromTable);
-				if (!rel) continue;
-				const propEntry = Object.entries(schema.properties).find(([key]) => toSnakeCase(key) === revRel.name && key in data);
-				if (!propEntry) continue;
-				const [propName] = propEntry;
-				const nestedValue = data[propName];
-				if (nestedValue === null || nestedValue === void 0) continue;
-				const nestedTable = parseResult.tables.find((t$1) => t$1.name === revRel.toTable);
-				if (!nestedTable) continue;
-				if (revRel.type === "has-one") {
-					const rowId = insertTableRow({
-						db,
-						table: nestedTable,
-						data: parseDataByColumns(nestedValue, schema.properties[propName], nestedTable),
-						parentRowId: mainRowId,
-						foreignKeyColumn: rel.fromColumn
-					});
-					inserted.push({
-						table: revRel.toTable,
-						rowId
-					});
-				} else if (revRel.type === "has-many") {
-					const items = nestedValue;
-					for (const item of items) {
-						const rowId = insertTableRow({
-							db,
-							table: nestedTable,
-							data: parseDataByColumns(item, schema.properties[propName].items, nestedTable),
-							parentRowId: mainRowId,
-							foreignKeyColumn: rel.fromColumn
-						});
-						inserted.push({
-							table: revRel.toTable,
-							rowId
-						});
-					}
-				}
-			}
-			return mainRowId;
-		})();
-		return {
-			success: true,
-			tablesInserted: inserted
-		};
-	} catch (e) {
-		return {
-			success: false,
-			tablesInserted: inserted,
-			error: e instanceof Error ? e.message : String(e)
-		};
-	}
-}
-
 //#endregion
 //#region src/application/extraction/run-extraction.ts
-async function ensureDatabaseReady(dbPath, schema) {
+async function ensureDatabaseReady(config, schema) {
+	const database = createProjectDatabase(config);
+	if (!await database.exists()) return t("errors.db.notFound", {
+		path: pc.cyan(".aiex/database.db"),
+		cmd: pc.cyan("aiex schema")
+	});
 	try {
-		await fs.access(dbPath);
-	} catch {
-		return t("errors.db.notFound", {
-			path: pc.cyan(".aiex/database.db"),
+		const result = parseJsonSchema(schema);
+		const tableCheck = await database.verifyTables(result.tables.map((table) => table.name));
+		if (tableCheck.error) return t("errors.db.cannotVerify", { error: tableCheck.error });
+		const missing = tableCheck.missing[0];
+		if (missing) return t("errors.db.tableNotFound", {
+			name: missing,
 			cmd: pc.cyan("aiex schema")
 		});
-	}
-	try {
-		const result = parseJsonSchema(schema);
-		const db = new Database(dbPath);
-		try {
-			for (const table of result.tables) if (!db.prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name=?`).get(table.name)) return t("errors.db.tableNotFound", {
-				name: table.name,
-				cmd: pc.cyan("aiex schema")
-			});
-		} finally {
-			db.close();
-		}
 	} catch (e) {
 		return t("errors.db.cannotVerify", { error: e instanceof Error ? e.message : String(e) });
 	}
@@ -2139,55 +2081,75 @@ async function extractSingle(aiexDir, config, aiConfig, schemaName, text$1, file
 		total: result.tokensUsed.total
 	})));
 	if (result.data && options?.insert !== false) {
+		const qualityError = qualityGateError(result.quality);
+		if (qualityError) {
+			consola.error(qualityError);
+			return {
+				success: false,
+				error: qualityError,
+				outputPath: result.outputPath,
+				data: result.data,
+				tokensUsed: result.tokensUsed,
+				quality: result.quality,
+				failureStage: "ai_extraction",
+				evidence: result.evidence
+			};
+		}
 		const s2 = spinner();
 		if (!options?.quiet) s2.start(t("command.extract.file.insertingDb"));
-		const dbError = await ensureDatabaseReady(config.databasePath, schemaLoad.schema);
+		const dbError = await ensureDatabaseReady(config, schemaLoad.schema);
 		if (dbError) {
 			if (!options?.quiet) s2.stop(t("command.extract.file.dbNotReady"));
 			consola.error(dbError);
 			return {
 				success: false,
 				error: dbError,
+				outputPath: result.outputPath,
+				data: result.data,
+				tokensUsed: result.tokensUsed,
 				quality: result.quality,
-				failureStage: "db_insert"
+				failureStage: "db_insert",
+				evidence: result.evidence
 			};
 		}
 		try {
-			const db = new Database(config.databasePath);
-			try {
-				const insertResult = insertExtractedData(db, schemaLoad.schema, result.data);
-				if (insertResult.success) {
-					if (!options?.quiet) s2.stop(t("command.extract.file.insertedTables", { count: insertResult.tablesInserted.length }));
-					return {
-						success: true,
-						outputPath: result.outputPath,
-						data: result.data,
-						tablesInserted: insertResult.tablesInserted,
-						tokensUsed: result.tokensUsed,
-						quality: result.quality,
-						evidence: result.evidence
-					};
-				} else {
-					if (!options?.quiet) s2.stop(t("command.extract.file.dbInsertFail"));
-					consola.error(insertResult.error || t("common.unknownError"));
-					return {
-						success: false,
-						error: insertResult.error,
-						quality: result.quality,
-						failureStage: "db_insert"
-					};
-				}
-			} finally {
-				db.close();
+			const insertResult = createProjectDatabase(config).insertExtracted(schemaLoad.schema, result.data);
+			if (insertResult.success) {
+				if (!options?.quiet) s2.stop(t("command.extract.file.insertedTables", { count: insertResult.tablesInserted.length }));
+				return {
+					success: true,
+					outputPath: result.outputPath,
+					data: result.data,
+					tablesInserted: insertResult.tablesInserted,
+					tokensUsed: result.tokensUsed,
+					quality: result.quality,
+					evidence: result.evidence
+				};
 			}
+			if (!options?.quiet) s2.stop(t("command.extract.file.dbInsertFail"));
+			consola.error(insertResult.error || t("common.unknownError"));
+			return {
+				success: false,
+				error: insertResult.error,
+				outputPath: result.outputPath,
+				data: result.data,
+				tokensUsed: result.tokensUsed,
+				quality: result.quality,
+				failureStage: "db_insert",
+				evidence: result.evidence
+			};
 		} catch (e) {
 			if (!options?.quiet) s2.stop(t("command.extract.file.dbInsertFail"));
 			consola.error(e instanceof Error ? e.message : String(e));
 			return {
 				success: false,
 				error: String(e),
+				outputPath: result.outputPath,
+				data: result.data,
+				tokensUsed: result.tokensUsed,
 				quality: result.quality,
-				failureStage: "db_insert"
+				failureStage: "db_insert",
+				evidence: result.evidence
 			};
 		}
 	}
@@ -2206,19 +2168,7 @@ async function extractSingle(aiexDir, config, aiConfig, schemaName, text$1, file
 async function runAuditedExtraction(options) {
 	const { aiexDir, config, aiConfig, schemaName, source, modelOverride, retryOf, insert, force, quiet = false } = options;
 	let fileHash;
-	let isPlainTextFile = false;
 	if (source.type === "file") {
-		const ext = path.extname(source.filePath).toLowerCase().replace(".", "");
-		isPlainTextFile = [
-			"txt",
-			"md",
-			"csv",
-			"json",
-			"html",
-			"xml",
-			"yaml",
-			"yml"
-		].includes(ext);
 		try {
 			fileHash = await getFileHash(source.filePath);
 		} catch (e) {
@@ -2227,7 +2177,7 @@ async function runAuditedExtraction(options) {
 				error: e instanceof Error ? e.message : String(e)
 			}));
 		}
-		if (fileHash && !isPlainTextFile && !force) {
+		if (fileHash && !force) {
 			const existing = await findSucceededAuditByHash(aiexDir, schemaName, fileHash);
 			if (existing) {
 				if (!quiet) consola.info(t("command.extract.file.alreadyProcessed", {
@@ -2346,17 +2296,23 @@ async function runAuditedExtraction(options) {
 		await updateExtractionAuditRecord(aiexDir, audit.id, {
 			status: "failed",
 			error: r.error || "Extraction failed",
+			outputPath: r.outputPath,
+			outputName: r.outputPath ? path.basename(r.outputPath) : void 0,
+			tokensUsed: r.tokensUsed,
 			quality: mergeQuality(inputQuality, r.quality),
 			failureStage: r.failureStage ?? "ai_extraction",
 			evidence: r.evidence
 		});
 		if (!quiet) consola.error(t("command.extract.file.extractionFailed", { error: r.error }));
-		await triggerWebhook(aiConfig, audit.id, schemaName, "extraction.failed", source, void 0, r.error || "Extraction failed", void 0, quiet);
+		await triggerWebhook(aiConfig, audit.id, schemaName, "extraction.failed", source, r.data, r.error || "Extraction failed", r.tokensUsed, quiet);
 		return {
 			success: false,
 			error: r.error,
+			outputPath: r.outputPath,
+			outputName: r.outputPath ? path.basename(r.outputPath) : void 0,
 			auditId: audit.id,
 			fileHash,
+			tokensUsed: r.tokensUsed,
 			inputProcessing,
 			quality: mergeQuality(inputQuality, r.quality),
 			failureStage: r.failureStage ?? "ai_extraction",
@@ -2777,7 +2733,7 @@ function analyzeMigrationRisk(previousEntries, nextEntries) {
 			addRisk(items, "high", "column_removed", previous.table, previous.column, `Column "${key}" will be removed.`);
 			continue;
 		}
-		if (previous.sqliteType !== next.sqliteType || previous.drizzleType !== next.drizzleType) addRisk(items, "high", "column_type_changed", previous.table, previous.column, `Column "${key}" type changes from ${previous.drizzleType} to ${next.drizzleType}.`);
+		if (previous.databaseType !== next.databaseType || previous.drizzleType !== next.drizzleType) addRisk(items, "high", "column_type_changed", previous.table, previous.column, `Column "${key}" type changes from ${previous.drizzleType} to ${next.drizzleType}.`);
 		if (previous.nullable && !next.nullable) addRisk(items, "high", "nullable_tightened", previous.table, previous.column, `Column "${key}" changes from nullable to not null.`);
 		else if (!previous.nullable && next.nullable) addRisk(items, "medium", "nullable_relaxed", previous.table, previous.column, `Column "${key}" changes from not null to nullable.`);
 		if (!previous.unique && next.unique) addRisk(items, "high", "unique_added", previous.table, previous.column, `Column "${key}" adds a unique constraint.`);
@@ -2818,6 +2774,51 @@ function resolveHelperPath() {
 	}
 }
 
+//#endregion
+//#region src/infrastructure/database/migration-runner.ts
+const execFileAsync = promisify(execFile);
+function parseMigrationOutput(stdout, stderr) {
+	try {
+		const jsonLine = stdout.trim().split("\n").find((l) => l.startsWith("{") && l.endsWith("}"));
+		if (!jsonLine) return {
+			success: false,
+			error: t("errors.schema.migrationHelperInvalidOutput")
+		};
+		const result = JSON.parse(jsonLine);
+		if (!result.success) return {
+			success: false,
+			error: result.error || t("errors.schema.migrationFailed")
+		};
+		return result;
+	} catch {
+		return {
+			success: false,
+			error: stderr || stdout || t("errors.schema.migrationHelperFailed")
+		};
+	}
+}
+async function runDatabaseMigration(config, migrationName) {
+	const helperPath = resolveHelperPath();
+	const helperArgs = [
+		resolveTsxPath(),
+		helperPath,
+		config.drizzleSchemaPath,
+		config.migrationsPath,
+		config.databasePath
+	];
+	if (migrationName) helperArgs.push(migrationName);
+	try {
+		const { stdout, stderr } = await execFileAsync(process.execPath, helperArgs, { cwd: process.cwd() });
+		return parseMigrationOutput(stdout, stderr);
+	} catch (error) {
+		const execError = error;
+		return {
+			success: false,
+			error: execError.stderr || execError.stdout || execError.message || String(error)
+		};
+	}
+}
+
 //#endregion
 //#region src/domain/schema/dialect.ts
 const TOP_LEVEL_KEYS = new Set([
@@ -2914,6 +2915,14 @@ function collectDialectWarnings(schema, filePath) {
 	return warnings;
 }
 
+//#endregion
+//#region src/infrastructure/database/schema-generator.ts
+function generateDatabaseSchema(result, dialect = "sqlite") {
+	switch (dialect) {
+		case "sqlite": return generateDrizzleSchema(result);
+	}
+}
+
 //#endregion
 //#region src/application/schema/parse-all-schemas.ts
 function formatZodError(error, filePath) {
@@ -2962,7 +2971,7 @@ function parseAllSchemas(entries) {
 			reverseRelations,
 			warnings,
 			mapping,
-			drizzleCode: generateDrizzleSchema({
+			drizzleCode: generateDatabaseSchema({
 				tables,
 				relations,
 				reverseRelations,
@@ -2974,7 +2983,6 @@ function parseAllSchemas(entries) {
 
 //#endregion
 //#region src/application/schema/schema-sync.ts
-const execFileAsync = promisify(execFile);
 const NO_RISK_REPORT = {
 	level: "none",
 	items: [],
@@ -3024,7 +3032,8 @@ async function generateSchemaFromFiles(schemaFiles, config, options = {}) {
 	await fs.writeFile(config.drizzleSchemaPath, drizzleCode);
 	await fs.writeFile(schemaMapPath(config), `${JSON.stringify({
 		generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-		dialect: "aiex-drizzle-sqlite",
+		dialect: "aiex-drizzle",
+		databaseDialect: config.databaseDialect,
 		entries: mapping,
 		baselineEntries: riskReport.hasHighRisk && !options.force ? previousMapping : void 0,
 		warnings,
@@ -3040,46 +3049,8 @@ async function generateSchemaFromFiles(schemaFiles, config, options = {}) {
 		riskReport
 	};
 }
-function parseMigrationOutput(stdout, stderr) {
-	try {
-		const jsonLine = stdout.trim().split("\n").find((l) => l.startsWith("{") && l.endsWith("}"));
-		if (!jsonLine) return {
-			success: false,
-			error: t("errors.schema.migrationHelperInvalidOutput")
-		};
-		const result = JSON.parse(jsonLine);
-		if (!result.success) return {
-			success: false,
-			error: result.error || t("errors.schema.migrationFailed")
-		};
-		return result;
-	} catch {
-		return {
-			success: false,
-			error: stderr || stdout || t("errors.schema.migrationHelperFailed")
-		};
-	}
-}
 async function runSchemaMigration(config, migrationName) {
-	const helperPath = resolveHelperPath();
-	const helperArgs = [
-		resolveTsxPath(),
-		helperPath,
-		config.drizzleSchemaPath,
-		config.migrationsPath,
-		config.databasePath
-	];
-	if (migrationName) helperArgs.push(migrationName);
-	try {
-		const { stdout, stderr } = await execFileAsync(process.execPath, helperArgs, { cwd: process.cwd() });
-		return parseMigrationOutput(stdout, stderr);
-	} catch (error) {
-		const execError = error;
-		return {
-			success: false,
-			error: execError.stderr || execError.stdout || execError.message || String(error)
-		};
-	}
+	return runDatabaseMigration(config, migrationName);
 }
 async function runSchemaSync(config, options = {}) {
 	const schemaFiles = await listSchemaFiles(config.schemaPath);
@@ -16234,7 +16205,6 @@ function aiRoutes(config) {
 //#region src/application/data/data-service.ts
 const FILE_REGEX = /\.json$/;
 const EXTRACTION_TIMESTAMP_RE = /-\d{4}-\d{2}-\d{2}T/;
-const INTERNAL_ROWID_COLUMN = "__aiex_rowid";
 const TIMESTAMP_CLEANUP = /(\d{2})-(\d{2})-(\d{2})/;
 const TIMESTAMP_TZ = /(\d{3})Z/;
 function schemaNameFromExtractionFile(name$1) {
@@ -16268,9 +16238,6 @@ async function getRowExtractionActions(aiexDir, tableName) {
 	}
 	return actions;
 }
-function createReadonlyQueryDb(databasePath) {
-	return new Kysely({ dialect: new SqliteDialect({ database: new Database(databasePath, { readonly: true }) }) });
-}
 async function listExtractions(config) {
 	const aiexDir = path.dirname(config.schemaPath);
 	const extractedDir = path.join(aiexDir, "extracted");
@@ -16316,19 +16283,10 @@ async function listTables(config) {
 	} catch {
 		schemaFiles = [];
 	}
-	let db = null;
 	let dbTables = [];
 	try {
-		db = createReadonlyQueryDb(config.databasePath);
-		dbTables = (await sql`
-      select name
-      from sqlite_master
-      where type = 'table' and name not like 'sqlite_%' and name not like '_%'
-      order by name
-    `.execute(db)).rows.map((row) => row.name);
-	} catch {} finally {
-		await db?.destroy();
-	}
+		dbTables = await createProjectDatabase(config).listTableNames();
+	} catch {}
 	const tables = [];
 	for (const file of schemaFiles) try {
 		const schema = await readFile(path.join(schemaDir, file));
@@ -16347,57 +16305,26 @@ async function listTables(config) {
 async function getTableData(config, tableName, query) {
 	const { page, pageSize, search, sortField, sortOrder, all } = query;
 	const aiexDir = path.dirname(config.schemaPath);
-	let db;
+	const database = createProjectDatabase(config);
+	if (!await database.exists()) throw new Error(t("server.dbNotFound"));
 	try {
-		db = createReadonlyQueryDb(config.databasePath);
-	} catch {
-		throw new Error(t("server.dbNotFound"));
-	}
-	try {
-		if ((await sql`
-      select name
-      from sqlite_master
-      where type = 'table' and name = ${tableName}
-    `.execute(db)).rows.length === 0) throw new Error(t("server.tableNotFound", { name: tableName }));
-		const columns = (await sql`
-      pragma table_info(${sql.table(tableName)})
-    `.execute(db)).rows.map((col) => ({
-			name: col.name,
-			type: col.type,
-			notNull: !!col.notnull,
-			pk: !!col.pk
-		}));
-		const searchConditions = columns.map((col) => sql`${sql.ref(col.name)} like ${`%${search}%`}`);
-		const searchCondition = search ? sql`where ${sql.join(searchConditions, sql` or `)}` : sql``;
-		const sortColumn = columns.find((col) => col.name === sortField);
-		const orderBy = sortColumn ? sql`order by ${sql.ref(sortColumn.name)} ${sql.raw(sortOrder === "desc" ? "desc" : "asc")}` : sql``;
-		const total = (await sql`
-      select count(*) as count
-      from ${sql.table(tableName)}
-      ${searchCondition}
-    `.execute(db)).rows[0]?.count ?? 0;
-		const offset = (page - 1) * pageSize;
-		const totalPages = all ? 1 : Math.max(1, Math.ceil(total / pageSize));
-		const result = all ? await sql`
-          select rowid as ${sql.raw(INTERNAL_ROWID_COLUMN)}, *
-          from ${sql.table(tableName)}
-          ${searchCondition}
-          ${orderBy}
-        `.execute(db) : await sql`
-          select rowid as ${sql.raw(INTERNAL_ROWID_COLUMN)}, *
-          from ${sql.table(tableName)}
-          ${searchCondition}
-          ${orderBy}
-          limit ${pageSize}
-          offset ${offset}
-        `.execute(db);
+		const tableRows = await database.readTableRows({
+			tableName,
+			page,
+			pageSize,
+			search,
+			sortField,
+			sortOrder,
+			all
+		}).catch((error) => {
+			if (error instanceof Error && error.message === `Table not found: ${tableName}`) throw new Error(t("server.tableNotFound", { name: tableName }));
+			throw error;
+		});
 		const actionsByRowId = await getRowExtractionActions(aiexDir, tableName);
-		const rowActions = Object.fromEntries(result.rows.map((row, index) => {
-			const rowId = row[INTERNAL_ROWID_COLUMN];
-			const action = rowId === null || rowId === void 0 ? void 0 : actionsByRowId.get(String(rowId));
+		const rowActions = Object.fromEntries(tableRows.rowIds.map((rowId, index) => {
+			const action = rowId === void 0 ? void 0 : actionsByRowId.get(rowId);
 			return action ? [String(index), action] : null;
 		}).filter((entry) => !!entry));
-		const rows = result.rows.map(({ [INTERNAL_ROWID_COLUMN]: _rowid, ...row }) => row);
 		const schemaDir = config.schemaPath;
 		let schema = null;
 		try {
@@ -16411,17 +16338,18 @@ async function getTableData(config, tableName, query) {
 			}
 		} catch {}
 		return {
-			columns,
-			rows,
+			columns: tableRows.columns,
+			rows: tableRows.rows,
 			rowActions,
-			total,
-			page: all ? 1 : page,
-			pageSize: all ? total : pageSize,
-			totalPages,
+			total: tableRows.total,
+			page: tableRows.page,
+			pageSize: all ? tableRows.total : tableRows.pageSize,
+			totalPages: tableRows.totalPages,
 			schema
 		};
-	} finally {
-		await db.destroy();
+	} catch (error) {
+		if (error instanceof Error) throw error;
+		throw new Error(String(error));
 	}
 }
 async function retryNotionSync(config, fileName) {