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

package/README.md

@@ -37,10 +37,10 @@ aiex watch -s invoice -d ./watch_folder # watch folder daemon for automatic extr
 - **AI Extraction** — Extract structured data from files (text, images, PDFs) using any OpenAI-compatible provider (OpenAI, Anthropic, Ollama, DeepSeek, local models, etc.)
 - **Interactive Mode** — Run `aiex extract` without arguments for a guided extraction workflow
 - **Batch Mode** — `aiex extract -d <dir>` processes entire directories with optional glob filtering
-- **Incremental Extraction** — File hash deduplication skips already-processed files; use `--force` to override
+- **Incremental Extraction** — File hash deduplication skips already-processed file inputs; use `--force` to override
 - **Web Data Export** — Export SQLite table data to CSV, Excel (.xlsx), or JSON from the Web UI
 - **Notion Sync** — Optionally sync CLI extraction results to configured Notion data sources
-- **Extraction Audit Trail** — Every extraction is recorded with status, input source, output path, token usage, database inserts, Notion pages, and errors
+- **Extraction Audit Trail** — Every extraction is recorded with status, input source, parser diagnostics, evidence quality, output path, token usage, database inserts, Notion pages, and errors
 - **Built-in Model Registry** — Knows capabilities of 2000+ models (vision, structured output) so you don't have to guess
 
 <br>
@@ -90,7 +90,7 @@ Saves the extracted result to `.aiex/extracted/<schema-name>-<timestamp>.json` w
 
 By default, aiex automatically selects a model based on your input type (vision-capable for images, structured output for text). Use `--model` / `-m` to override and specify any model from your AI configuration.
 
-Every extraction is also recorded under `.aiex/extracted/_audit/`. Audit records include the run status (`running`, `succeeded`, `failed`, or `stale`), schema name, input source, output file, token usage, inserted table rows, synced Notion pages, retry lineage, and error message. Use the Web UI to inspect, retry, or delete extraction records.
+Every extraction is also recorded under `.aiex/extracted/_audit/`. Audit records include the run status (`running`, `succeeded`, `failed`, or `stale`), schema name, input source, parser status, parser diagnostics, input quality, field evidence quality, output file, token usage, inserted table rows, synced Notion pages, retry lineage, failure stage, and error message. Use the Web UI to inspect, retry, or delete extraction records.
 
 ### 4. Watch Folder Daemon (Auto-Extraction)
 

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-B6ocPcWd.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) {

package/dist/{generate-drizzle-schema-DAeXmyrZ.mjs → generate-drizzle-schema-B6ocPcWd.mjs}

@@ -3,15 +3,16 @@ 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 Conf from "conf";
 import { z } from "zod";
+import Database from "better-sqlite3";
+import { Kysely, SqliteDialect, sql } from "kysely";
 
 //#region package.json
 var name = "aiex-cli";
-var version = "0.1.1-beta.6";
+var version = "0.1.1-beta.7";
 var description = "JSON Schema → SQLite with AI-powered data extraction";
 var package_default = {
 	name,
@@ -452,15 +453,15 @@ function describeColumnType(columnType) {
 	switch (columnType.class) {
 		case "text": return {
 			drizzleType: columnType.mode === "json" ? `text({ mode: 'json' })` : "text()",
-			sqliteType: "text"
+			databaseType: "text"
 		};
 		case "integer": return {
 			drizzleType: columnType.mode ? `integer({ mode: '${columnType.mode}' })` : "integer()",
-			sqliteType: "integer"
+			databaseType: "integer"
 		};
 		case "real": return {
 			drizzleType: "real()",
-			sqliteType: "real"
+			databaseType: "real"
 		};
 	}
 }
@@ -480,7 +481,7 @@ function mapColumnToReport(schemaPath, table, property, column, relation) {
 		table,
 		column: column.name,
 		drizzleType: columnType.drizzleType,
-		sqliteType: columnType.sqliteType,
+		databaseType: columnType.databaseType,
 		nullable: column.isNullable,
 		primary: column.isPrimary,
 		unique: column.isUnique,
@@ -586,7 +587,7 @@ function parseNestedObject(propName, property, parentTableName, warnings, mappin
 		table: nestedTableName,
 		column: "id",
 		drizzleType: "integer().primaryKey({ autoIncrement: true })",
-		sqliteType: "integer",
+		databaseType: "integer",
 		nullable: false,
 		primary: true,
 		unique: false,
@@ -611,7 +612,7 @@ function parseNestedObject(propName, property, parentTableName, warnings, mappin
 		table: nestedTableName,
 		column: `${parentTableName}_id`,
 		drizzleType: "integer().references(...)",
-		sqliteType: "integer",
+		databaseType: "integer",
 		nullable: false,
 		primary: false,
 		unique: false,
@@ -916,6 +917,262 @@ async function addToGitignore(aiexDir, fileName) {
 	}
 }
 
+//#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/infrastructure/database/sqlite-database.ts
+const INTERNAL_ROWID_COLUMN = "__aiex_rowid";
+function createReadonlyQueryDb(databasePath) {
+	return new Kysely({ dialect: new SqliteDialect({ database: new Database(databasePath, { readonly: true }) }) });
+}
+var SqliteProjectDatabase = class {
+	dialect = "sqlite";
+	constructor(databasePath) {
+		this.databasePath = databasePath;
+	}
+	async exists() {
+		try {
+			return (await fs.stat(this.databasePath)).isFile();
+		} catch {
+			return false;
+		}
+	}
+	async listTableNames() {
+		let db = null;
+		try {
+			db = createReadonlyQueryDb(this.databasePath);
+			return (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);
+		} finally {
+			await db?.destroy();
+		}
+	}
+	async verifyTables(tableNames) {
+		const db = new Database(this.databasePath, { readonly: true });
+		try {
+			const missing = tableNames.filter((table) => {
+				return !db.prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name=?`).get(table);
+			});
+			return {
+				ok: missing.length === 0,
+				missing
+			};
+		} catch (error) {
+			return {
+				ok: false,
+				missing: [],
+				error: error instanceof Error ? error.message : String(error)
+			};
+		} finally {
+			db.close();
+		}
+	}
+	insertExtracted(schema, data) {
+		const db = new Database(this.databasePath);
+		try {
+			return insertExtractedData(db, schema, data);
+		} finally {
+			db.close();
+		}
+	}
+	async readTableRows(query) {
+		const { tableName, page, pageSize, search, sortField, sortOrder, all } = query;
+		const db = createReadonlyQueryDb(this.databasePath);
+		try {
+			if ((await sql`
+        select name
+        from sqlite_master
+        where type = 'table' and name = ${tableName}
+      `.execute(db)).rows.length === 0) throw new Error(`Table not found: ${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 rowIds = result.rows.map((row) => {
+				const rowId = row[INTERNAL_ROWID_COLUMN];
+				return rowId === null || rowId === void 0 ? void 0 : String(rowId);
+			});
+			return {
+				columns,
+				rows: result.rows.map(({ [INTERNAL_ROWID_COLUMN]: _rowid, ...row }) => row),
+				rowIds,
+				total,
+				page,
+				pageSize,
+				totalPages
+			};
+		} finally {
+			await db.destroy();
+		}
+	}
+};
+function createProjectDatabase(config) {
+	return new SqliteProjectDatabase(config.databasePath);
+}
+
 //#endregion
 //#region src/locales/en.ts
 const en = {
@@ -1498,6 +1755,7 @@ async function checkImageOcrAvailability(imagePath, runtime = defaultRuntime) {
 //#region src/infrastructure/schema/migration-config.ts
 function createMigrationConfig(cwd) {
 	return {
+		databaseDialect: "sqlite",
 		schemaPath: `${cwd}/.aiex/schema`,
 		drizzleSchemaPath: `${cwd}/.aiex/drizzle/schema.ts`,
 		migrationsPath: `${cwd}/.aiex/migrations`,
@@ -1636,26 +1894,18 @@ async function collectDoctorDiagnostics(options = {}) {
 			error: error instanceof Error ? error.message : String(error)
 		});
 	}
-	let dbExists = false;
-	if (dirExists) try {
-		dbExists = (await fs.stat(migConfig.databasePath)).isFile();
-	} catch {
-		dbExists = false;
-	}
+	const database = createProjectDatabase(migConfig);
+	const dbExists = dirExists ? await database.exists() : false;
 	let databaseTablesOk = null;
 	let missingDatabaseTables = [];
 	if (dbExists && expectedTables.size > 0) {
-		const db = new Database(migConfig.databasePath, { readonly: true });
-		try {
-			missingDatabaseTables = [...expectedTables].filter((table) => {
-				return !db.prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name=?`).get(table);
-			});
-			databaseTablesOk = missingDatabaseTables.length === 0;
-		} catch (error) {
+		const tableCheck = await database.verifyTables([...expectedTables]);
+		if (tableCheck.error) {
 			databaseTablesOk = false;
-			errors.push(`Could not inspect database tables: ${error instanceof Error ? error.message : String(error)}`);
-		} finally {
-			db.close();
+			errors.push(`Could not inspect database tables: ${tableCheck.error}`);
+		} else {
+			missingDatabaseTables = tableCheck.missing;
+			databaseTablesOk = tableCheck.ok;
 		}
 	} else if (dbExists) databaseTablesOk = true;
 	let migrationCount = 0;
@@ -1807,4 +2057,4 @@ function generateDrizzleSchema(result) {
 }
 
 //#endregion
-export { seedConfig as A, CORRECTION_SYSTEM_PROMPT as C, PLACEHOLDER_TEXT as D, PLACEHOLDER_SCHEMA as E, name as M, package_default as N, buildCorrectionUserPrompt as O, version as P, DEFAULT_MINERU_CONFIG as S, EVIDENCE_INSTRUCTIONS as T, doctorDiagnosticsSeverityRows as _, recognizeImageText as a, DEFAULT_LITEPARSE_CONFIG as b, t as c, writeAIConfig as d, AIConfigSchema as f, buildDoctorDiagnostics as g, toSnakeCase as h, generateDrizzleConfig as i, description as j, createConfig as k, getDefaultAIConfig as l, parseJsonSchema as m, collectDoctorDiagnostics as n, shouldUseImageOcrFallback as o, JsonSchemaDefinitionSchema as p, createMigrationConfig as r, initI18n as s, generateDrizzleSchema as t, readAIConfig as u, doctorDiagnosticsTableRows as v, DEFAULT_PROMPT_CONFIG as w, DEFAULT_MINERU_API_CONFIG as x, formatDoctorDiagnosticsJson as y };
+export { seedConfig as A, CORRECTION_SYSTEM_PROMPT as C, PLACEHOLDER_TEXT as D, PLACEHOLDER_SCHEMA as E, name as M, package_default as N, buildCorrectionUserPrompt as O, version as P, DEFAULT_MINERU_CONFIG as S, EVIDENCE_INSTRUCTIONS as T, doctorDiagnosticsSeverityRows as _, recognizeImageText as a, DEFAULT_LITEPARSE_CONFIG as b, t as c, readAIConfig as d, writeAIConfig as f, buildDoctorDiagnostics as g, parseJsonSchema as h, generateDrizzleConfig as i, description as j, createConfig as k, createProjectDatabase as l, JsonSchemaDefinitionSchema as m, collectDoctorDiagnostics as n, shouldUseImageOcrFallback as o, AIConfigSchema as p, createMigrationConfig as r, initI18n as s, generateDrizzleSchema as t, getDefaultAIConfig as u, doctorDiagnosticsTableRows as v, DEFAULT_PROMPT_CONFIG as w, DEFAULT_MINERU_API_CONFIG as x, formatDoctorDiagnosticsJson as y };

package/dist/index.d.mts

@@ -326,7 +326,7 @@ interface SchemaMappingEntry {
   table: string;
   column: string;
   drizzleType: string;
-  sqliteType: 'text' | 'integer' | 'real';
+  databaseType: 'text' | 'integer' | 'real';
   nullable: boolean;
   primary: boolean;
   unique: boolean;
@@ -362,6 +362,7 @@ interface ParseResult {
   mapping?: SchemaMappingEntry[];
 }
 interface MigrationConfig {
+  databaseDialect: 'sqlite';
   schemaPath: string;
   drizzleSchemaPath: string;
   migrationsPath: string;

package/dist/index.mjs

@@ -1,3 +1,3 @@
-import { _ as doctorDiagnosticsSeverityRows, g as buildDoctorDiagnostics, i as generateDrizzleConfig, m as parseJsonSchema, n as collectDoctorDiagnostics, p as JsonSchemaDefinitionSchema, r as createMigrationConfig, t as generateDrizzleSchema, v as doctorDiagnosticsTableRows, y as formatDoctorDiagnosticsJson } from "./generate-drizzle-schema-DAeXmyrZ.mjs";
+import { _ as doctorDiagnosticsSeverityRows, g as buildDoctorDiagnostics, h as parseJsonSchema, i as generateDrizzleConfig, m as JsonSchemaDefinitionSchema, n as collectDoctorDiagnostics, r as createMigrationConfig, t as generateDrizzleSchema, v as doctorDiagnosticsTableRows, y as formatDoctorDiagnosticsJson } from "./generate-drizzle-schema-B6ocPcWd.mjs";
 
 export { JsonSchemaDefinitionSchema, buildDoctorDiagnostics, collectDoctorDiagnostics, createMigrationConfig, doctorDiagnosticsSeverityRows, doctorDiagnosticsTableRows, formatDoctorDiagnosticsJson, generateDrizzleConfig, generateDrizzleSchema, parseJsonSchema };

package/dist/infrastructure/schema/migrate-helper.mjs

@@ -3,8 +3,8 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import process from "node:process";
 import { fileURLToPath } from "node:url";
-import Database from "better-sqlite3";
 import { readFile, writeFile } from "jsonfile";
+import Database from "better-sqlite3";
 import * as esbuild from "esbuild";
 import lockfile from "proper-lockfile";
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "aiex-cli",
   "type": "module",
-  "version": "0.1.1-beta.6",
+  "version": "0.1.1-beta.7",
   "description": "JSON Schema → SQLite with AI-powered data extraction",
   "author": "OSpoon <zxin088@gmail.com>",
   "license": "MIT",