aiex-cli 0.1.0 → 0.1.1-beta.2

package/dist/cli.mjs

@@ -1,4 +1,4 @@
-import { A as package_default, C as DEFAULT_PROMPT_CONFIG, D as seedConfig, E as createConfig, O as description, S as DEFAULT_MINERU_CONFIG, T as PLACEHOLDER_TEXT, _ as doctorDiagnosticsSeverityRows, a as recognizeImageText, b as DEFAULT_LITEPARSE_CONFIG, c as t, d as writeAIConfig, f as AIConfigSchema, h as toSnakeCase, j as version, k as name, 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 PLACEHOLDER_SCHEMA, x as DEFAULT_MINERU_API_CONFIG, y as formatDoctorDiagnosticsJson } from "./generate-drizzle-schema-BqSy0OMm.mjs";
+import { A as package_default, C as DEFAULT_PROMPT_CONFIG, D as seedConfig, E as createConfig, O as description, S as DEFAULT_MINERU_CONFIG, T as PLACEHOLDER_TEXT, _ as doctorDiagnosticsSeverityRows, a as recognizeImageText, b as DEFAULT_LITEPARSE_CONFIG, c as t, d as writeAIConfig, f as AIConfigSchema, h as toSnakeCase, j as version, k as name, 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 PLACEHOLDER_SCHEMA, x as DEFAULT_MINERU_API_CONFIG, y as formatDoctorDiagnosticsJson } from "./generate-drizzle-schema-sZ01QiYJ.mjs";
 import { createRequire } from "node:module";
 import fs from "node:fs/promises";
 import os from "node:os";
@@ -13,13 +13,12 @@ import { defineCommand, runMain } from "citty";
 import { consola } from "consola";
 import updateNotifier from "update-notifier";
 import CliTable3 from "cli-table3";
-import fs$1 from "node:fs";
 import { confirm, intro, isCancel, outro, select, spinner, text } from "@clack/prompts";
 import pc from "picocolors";
-import { Buffer } from "node:buffer";
-import * as XLSX from "xlsx";
+import fs$1 from "node:fs";
 import { TextDecoder, promisify } from "node:util";
 import { fileTypeFromBuffer, fileTypeFromFile } from "file-type";
+import { Buffer } from "node:buffer";
 import { glob, globSync } from "tinyglobby";
 import { extractText, getDocumentProxy, getMeta } from "unpdf";
 import AdmZip from "adm-zip";
@@ -144,260 +143,9 @@ const doctorCommand = defineCommand({
 	}
 });
 
-//#endregion
-//#region src/application/export/export-manager.ts
-function formatRowsConformingToSchema(rows, columns, schema, format) {
-	return rows.map((row) => {
-		const newRow = {};
-		columns.forEach((col) => {
-			const colName = col.name;
-			const val = row[colName];
-			const type = (schema?.properties?.[colName])?.type || "";
-			if (val === null || val === void 0) newRow[colName] = "";
-			else if (type === "boolean") if (format === "xlsx") newRow[colName] = val === 1 || val === "1" || val === true;
-			else newRow[colName] = val === 1 || val === "1" || val === true ? "true" : "false";
-			else if (type === "number" || type === "integer") if (val === "") newRow[colName] = "";
-			else {
-				const num = Number(val);
-				newRow[colName] = Number.isNaN(num) ? val : num;
-			}
-			else if (typeof val === "object") newRow[colName] = JSON.stringify(val);
-			else {
-				const dbType = (col.type || "").toLowerCase();
-				if ((dbType.includes("int") || dbType.includes("real") || dbType.includes("num") || dbType.includes("double") || dbType.includes("float")) && typeof val === "string" && val !== "") {
-					const num = Number(val);
-					newRow[colName] = Number.isNaN(num) ? val : num;
-				} else newRow[colName] = val;
-			}
-		});
-		return newRow;
-	});
-}
-function generateExportBuffer(tableName, formattedRows, columns, format) {
-	const ws = XLSX.utils.json_to_sheet(formattedRows, { header: columns.map((col) => col.name) });
-	if (format === "xlsx") {
-		const wb = XLSX.utils.book_new();
-		XLSX.utils.book_append_sheet(wb, ws, tableName.slice(0, 31));
-		return XLSX.write(wb, {
-			bookType: "xlsx",
-			type: "buffer"
-		});
-	} else {
-		const csv = XLSX.utils.sheet_to_csv(ws);
-		return Buffer.from("" + csv, "utf8");
-	}
-}
-
-//#endregion
-//#region src/application/schema/load-schema.ts
-const JSON_EXT_RE$1 = /\.json$/;
-async function loadSchema(config, schemaName) {
-	const schemaPath = path.join(config.schemaPath, `${schemaName}.json`);
-	try {
-		const parsed = await readFile(schemaPath);
-		return { schema: JsonSchemaDefinitionSchema.parse(parsed) };
-	} catch (e) {
-		if (e instanceof ZodError) return {
-			schema: null,
-			error: t("errors.schema.validationFailed", {
-				name: `${schemaName}.json`,
-				issues: e.issues.map((i) => `  - ${i.path.join(".")}: ${i.message}`).join("\n")
-			})
-		};
-		if (e.code === "ENOENT") return {
-			schema: null,
-			error: t("errors.schema.cannotRead", { name: `${schemaName}.json` })
-		};
-		if (e instanceof SyntaxError) return {
-			schema: null,
-			error: t("errors.schema.invalidJson", { name: `${schemaName}.json` })
-		};
-		return {
-			schema: null,
-			error: String(e)
-		};
-	}
-}
-async function listSchemas(aiexDir) {
-	try {
-		const dir = path.join(aiexDir, "schema");
-		return (await fs.readdir(dir)).filter((f) => f.endsWith(".json")).map((f) => f.replace(JSON_EXT_RE$1, "")).sort();
-	} catch {
-		return [];
-	}
-}
-
-//#endregion
-//#region src/commands/utils.ts
-function failCommand(message) {
-	if (message) consola.error(message);
-	outro(t("common.failed"));
-	process.exitCode = 1;
-}
-
-//#endregion
-//#region src/commands/dump.ts
-const dumpCommand = defineCommand({
-	meta: {
-		name: "dump",
-		description: t("command.dump.description")
-	},
-	args: {
-		table: {
-			type: "string",
-			alias: "t",
-			description: t("command.dump.args.table")
-		},
-		schema: {
-			type: "string",
-			alias: "s",
-			description: t("command.dump.args.schema")
-		},
-		format: {
-			type: "string",
-			alias: "f",
-			description: t("command.dump.args.format")
-		},
-		output: {
-			type: "string",
-			alias: "o",
-			description: t("command.dump.args.output")
-		}
-	},
-	async run({ args }) {
-		intro(pc.inverse(" aiex dump "));
-		await initI18n();
-		if (!args.table && !args.schema) {
-			failCommand(t("command.dump.errors.tableOrSchemaRequired"));
-			return;
-		}
-		const cwd = process.cwd();
-		const config = createMigrationConfig(cwd);
-		const schemaDir = config.schemaPath;
-		let tableName = args.table || "";
-		let schema = null;
-		if (args.schema) {
-			const schemaLoad = await loadSchema(config, args.schema);
-			if (!schemaLoad.schema) {
-				failCommand(schemaLoad.error || t("command.dump.errors.schemaNotFound", { name: args.schema }));
-				return;
-			}
-			schema = schemaLoad.schema;
-			const tName = schema.table?.name;
-			if (!tName) {
-				failCommand(t("command.dump.errors.noTableName", { name: args.schema }));
-				return;
-			}
-			if (tableName && tableName !== tName) {
-				failCommand(t("command.dump.errors.tableMismatch", {
-					table: tableName,
-					schemaTable: tName
-				}));
-				return;
-			}
-			tableName = tName;
-		} else try {
-			if (fs$1.existsSync(schemaDir)) {
-				const files = fs$1.readdirSync(schemaDir).filter((f) => f.endsWith(".json"));
-				for (const file of files) {
-					const s$1 = await readFile(path.join(schemaDir, file));
-					if (s$1.table?.name === tableName) {
-						schema = s$1;
-						break;
-					}
-				}
-			}
-		} catch {}
-		let format = args.format?.toLowerCase();
-		const outputPathArg = args.output;
-		if (outputPathArg) {
-			const ext = path.extname(outputPathArg).toLowerCase();
-			if (!format) {
-				if (ext === ".xlsx") format = "xlsx";
-				else if (ext === ".csv") format = "csv";
-			}
-		}
-		if (!format) format = "csv";
-		if (format !== "csv" && format !== "xlsx") {
-			failCommand(t("command.dump.errors.unsupportedFormat", { format }));
-			return;
-		}
-		const resolvedOutput = outputPathArg ? path.resolve(outputPathArg) : path.resolve(cwd, `${tableName}.${format}`);
-		if (!fs$1.existsSync(config.databasePath)) {
-			failCommand(t("command.dump.errors.dbNotFound", {
-				path: config.databasePath,
-				cmd: "aiex schema"
-			}));
-			return;
-		}
-		const s = spinner();
-		s.start(t("command.dump.loading", { name: tableName }));
-		let columns = [];
-		let rows = [];
-		try {
-			const db = new Database(config.databasePath, { readonly: true });
-			if (!db.prepare(`
-        select name from sqlite_master
-        where type = 'table' and name = ?
-      `).get(tableName)) {
-				s.stop(t("command.dump.dbQueryFailed"));
-				failCommand(t("command.dump.errors.tableNotFound", {
-					name: tableName,
-					cmd: "aiex schema"
-				}));
-				db.close();
-				return;
-			}
-			columns = db.pragma(`table_info(${tableName})`);
-			rows = db.prepare(`select * from ${tableName}`).all();
-			db.close();
-		} catch (error) {
-			s.stop(t("command.dump.dbQueryFailed"));
-			failCommand(error instanceof Error ? error.message : String(error));
-			return;
-		}
-		if (rows.length === 0) {
-			s.stop(t("command.dump.emptyTable"));
-			consola.warn(t("command.dump.errors.tableEmpty", { name: tableName }));
-		} else s.stop(t("command.dump.loaded", { count: rows.length }));
-		const s2 = spinner();
-		s2.start(t("command.dump.formatting"));
-		let formattedRows;
-		try {
-			formattedRows = formatRowsConformingToSchema(rows, columns, schema, format);
-			s2.stop(t("command.dump.formatted"));
-		} catch (error) {
-			s2.stop(t("command.dump.dbQueryFailed"));
-			failCommand(error instanceof Error ? error.message : String(error));
-			return;
-		}
-		const s3 = spinner();
-		s3.start(t("command.dump.writing", {
-			format: format.toUpperCase(),
-			path: resolvedOutput
-		}));
-		try {
-			const buffer = generateExportBuffer(tableName, formattedRows, columns, format);
-			const outputDir = path.dirname(resolvedOutput);
-			if (!fs$1.existsSync(outputDir)) fs$1.mkdirSync(outputDir, { recursive: true });
-			fs$1.writeFileSync(resolvedOutput, buffer);
-			s3.stop(t("command.dump.dumpCompleted"));
-			consola.success(t("command.dump.successMsg", {
-				count: rows.length,
-				path: pc.cyan(resolvedOutput)
-			}));
-		} catch (error) {
-			s3.stop(t("command.dump.fileWriteFailed"));
-			failCommand(error instanceof Error ? error.message : String(error));
-			return;
-		}
-		outro(t("common.done"));
-	}
-});
-
 //#endregion
 //#region src/application/extraction/quality.ts
-function formatInputProcessing$1(input) {
+function formatInputProcessing(input) {
 	const handler = input.converter ? `${input.handler}(${input.converter})` : input.handler;
 	return `${input.mime ?? input.kind} -> ${handler}`;
 }
@@ -1414,16 +1162,16 @@ function getFileHash(filePath) {
 //#endregion
 //#region src/domain/ai-extraction/evidence.ts
 const NUMERIC_RE = /^-?\d+(?:\.\d+)?$/;
-function isRecord$2(value) {
+function isRecord$3(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function stripEvidence(data) {
-	if (!isRecord$2(data)) return { data };
+	if (!isRecord$3(data)) return { data };
 	const { _evidence, ...businessData } = data;
-	if (!isRecord$2(_evidence)) return { data: businessData };
+	if (!isRecord$3(_evidence)) return { data: businessData };
 	return {
 		data: businessData,
-		rawEvidence: Object.fromEntries(Object.entries(_evidence).filter(([, value]) => isRecord$2(value)).map(([field, value]) => [field, value]))
+		rawEvidence: Object.fromEntries(Object.entries(_evidence).filter(([, value]) => isRecord$3(value)).map(([field, value]) => [field, value]))
 	};
 }
 function findExactUnique(text$1, quote) {
@@ -1455,7 +1203,7 @@ function quoteContainsValue(quote, value, property) {
 	return false;
 }
 function verifyFieldEvidence(input) {
-	if (!input.text || !isRecord$2(input.data) || !input.rawEvidence) return void 0;
+	if (!input.text || !isRecord$3(input.data) || !input.rawEvidence) return void 0;
 	const verified = {};
 	for (const [field, raw] of Object.entries(input.rawEvidence)) {
 		const property = input.schema.properties[field];
@@ -1689,7 +1437,7 @@ function propertyToExtractionSchema(property) {
 	}
 	return { type: nullableType(property.type) };
 }
-function isRecord$1(value) {
+function isRecord$2(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function schemaToExtractionOutputSchema(schema) {
@@ -1727,7 +1475,7 @@ function validatePropertyValue(path$1, property, value, issues) {
 			}
 			return;
 		case "object":
-			if (!isRecord$1(value)) {
+			if (!isRecord$2(value)) {
 				issues.push(`${path$1}: expected object or null`);
 				return;
 			}
@@ -1750,7 +1498,7 @@ function validateProperties(basePath, properties, data, issues) {
 	}
 }
 function validateExtractedData(schema, data) {
-	if (!isRecord$1(data)) return {
+	if (!isRecord$2(data)) return {
 		success: false,
 		error: "Extracted data must be a JSON object."
 	};
@@ -1771,11 +1519,11 @@ const EVIDENCE_INSTRUCTIONS = `Evidence requirements:
 - The quote must be an exact contiguous substring copied from the input text.
 - Do not invent offsets. Only provide quotes.
 - If no exact quote supports a field, omit that field from "_evidence".`;
-function isRecord(value) {
+function isRecord$1(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function withEvidenceSchema(schema) {
-	const properties = isRecord(schema.properties) ? schema.properties : {};
+	const properties = isRecord$1(schema.properties) ? schema.properties : {};
 	const required = Array.isArray(schema.required) ? schema.required : [];
 	return {
 		...schema,
@@ -2166,6 +1914,45 @@ Please output the corrected JSON object now:`;
 	}
 }
 
+//#endregion
+//#region src/application/schema/load-schema.ts
+const JSON_EXT_RE$1 = /\.json$/;
+async function loadSchema(config, schemaName) {
+	const schemaPath = path.join(config.schemaPath, `${schemaName}.json`);
+	try {
+		const parsed = await readFile(schemaPath);
+		return { schema: JsonSchemaDefinitionSchema.parse(parsed) };
+	} catch (e) {
+		if (e instanceof ZodError) return {
+			schema: null,
+			error: t("errors.schema.validationFailed", {
+				name: `${schemaName}.json`,
+				issues: e.issues.map((i) => `  - ${i.path.join(".")}: ${i.message}`).join("\n")
+			})
+		};
+		if (e.code === "ENOENT") return {
+			schema: null,
+			error: t("errors.schema.cannotRead", { name: `${schemaName}.json` })
+		};
+		if (e instanceof SyntaxError) return {
+			schema: null,
+			error: t("errors.schema.invalidJson", { name: `${schemaName}.json` })
+		};
+		return {
+			schema: null,
+			error: String(e)
+		};
+	}
+}
+async function listSchemas(aiexDir) {
+	try {
+		const dir = path.join(aiexDir, "schema");
+		return (await fs.readdir(dir)).filter((f) => f.endsWith(".json")).map((f) => f.replace(JSON_EXT_RE$1, "")).sort();
+	} catch {
+		return [];
+	}
+}
+
 //#endregion
 //#region src/infrastructure/extraction/insert-extracted-data.ts
 function convertValue(value, column) {
@@ -2511,7 +2298,7 @@ async function runAuditedExtraction(options) {
 			filePath = input.filePath;
 			inputProcessing = input.inputProcessing;
 			inputQuality = input.quality;
-			if (!quiet) consola.info(`Input: ${formatInputProcessing$1(inputProcessing)}`);
+			if (!quiet) consola.info(`Input: ${formatInputProcessing(inputProcessing)}`);
 			await updateExtractionAuditRecord(aiexDir, audit.id, {
 				inputProcessing,
 				quality: inputQuality
@@ -2719,36 +2506,15 @@ async function runBatchExtraction(aiexDir, config, aiConfig, schemaName, dir, gl
 }
 
 //#endregion
-//#region src/commands/extract.ts
-function getIdArg(args) {
-	if (typeof args.id === "string") return args.id;
-	const positional = args._;
-	return Array.isArray(positional) && typeof positional[0] === "string" ? positional[0] : "";
-}
-function isExtractSubCommand(rawArgs) {
-	if (!Array.isArray(rawArgs)) return false;
-	return rawArgs.some((arg) => typeof arg === "string" && [
-		"history",
-		"show",
-		"retry",
-		"rm"
-	].includes(arg));
-}
-function formatSource(source) {
-	return source.type === "file" ? source.fileName || "file" : "unknown";
-}
-function formatInputProcessing(input) {
-	if (!input) return "";
-	const handler = input.converter ? `${input.handler}(${input.converter})` : input.handler;
-	return ` [${input.mime ?? input.kind} -> ${handler}]`;
-}
-function formatQuality(quality, failureStage) {
-	if (failureStage) return ` [failed:${failureStage}]`;
-	if (quality?.input?.pdf) return ` [pdf:${quality.input.pdf.pageCount}p/${quality.input.pdf.textLength}chars${quality.input.pdf.fallbackUsed ? "/fallback" : ""}]`;
-	if (quality?.input?.ocr) return ` [ocr:${Math.round(quality.input.ocr.confidence * 100)}%/${quality.input.ocr.textLength}chars]`;
-	if (quality?.ai?.missingFieldRate !== void 0) return ` [missing:${Math.round(quality.ai.missingFieldRate * 100)}%]`;
-	return "";
+//#region src/commands/utils.ts
+function failCommand(message) {
+	if (message) consola.error(message);
+	outro(t("common.failed"));
+	process.exitCode = 1;
 }
+
+//#endregion
+//#region src/commands/extract.ts
 async function loadConfiguredAI(aiexDir) {
 	const aiConfig = await readAIConfig(aiexDir);
 	if (!aiConfig) {
@@ -2777,143 +2543,11 @@ function resolveModelOverride(aiConfig, modelName) {
 	}
 	return matched;
 }
-const historyCommand = defineCommand({
-	meta: {
-		name: "history",
-		description: t("command.extract.history.description")
-	},
-	async run() {
-		const config = createMigrationConfig(process.cwd());
-		const records = await listExtractionAuditRecords(path.dirname(config.schemaPath));
-		if (records.length === 0) {
-			consola.info(t("command.extract.history.empty"));
-			return;
-		}
-		for (const record of records) {
-			const suffix = record.error ? ` — ${record.error}` : record.outputName ? ` — ${record.outputName}` : "";
-			consola.info(`${record.status.padEnd(9)} ${record.id}  ${record.schemaName}  ${formatSource(record.source)}${formatInputProcessing(record.inputProcessing)}${formatQuality(record.quality, record.failureStage)}${suffix}`);
-		}
-	}
-});
-const showCommand = defineCommand({
-	meta: {
-		name: "show",
-		description: t("command.extract.show.description")
-	},
-	args: { id: {
-		type: "string",
-		description: t("command.extract.show.args.id")
-	} },
-	async run({ args }) {
-		const id = getIdArg(args);
-		if (!id) {
-			failCommand(t("command.extract.history.errors.idRequired"));
-			return;
-		}
-		const config = createMigrationConfig(process.cwd());
-		const record = await readExtractionAuditRecord(path.dirname(config.schemaPath), id);
-		if (!record) {
-			failCommand(t("command.extract.history.errors.recordNotFound", { id }));
-			return;
-		}
-		consola.info(JSON.stringify(record, null, 2));
-	}
-});
-const retryCommand = defineCommand({
-	meta: {
-		name: "retry",
-		description: t("command.extract.retry.description")
-	},
-	args: {
-		id: {
-			type: "string",
-			description: t("command.extract.retry.args.id")
-		},
-		noInsert: {
-			type: "boolean",
-			description: t("command.extract.retry.args.noInsert"),
-			default: false
-		}
-	},
-	async run({ args }) {
-		intro(pc.inverse(" aiex extract retry "));
-		await initI18n();
-		const id = getIdArg(args);
-		if (!id) {
-			failCommand(t("command.extract.history.errors.idRequired"));
-			return;
-		}
-		const config = createMigrationConfig(process.cwd());
-		const aiexDir = path.dirname(config.schemaPath);
-		const record = await readExtractionAuditRecord(aiexDir, id);
-		if (!record) {
-			failCommand(t("command.extract.history.errors.recordNotFound", { id }));
-			return;
-		}
-		const aiConfig = await loadConfiguredAI(aiexDir);
-		if (!aiConfig) return;
-		const modelOverride = resolveModelOverride(aiConfig, record.modelName);
-		if (modelOverride === null) return;
-		try {
-			const result = await runAuditedExtraction({
-				aiexDir,
-				config,
-				aiConfig,
-				schemaName: record.schemaName,
-				source: record.source,
-				modelOverride,
-				retryOf: record.id,
-				insert: !args.noInsert,
-				force: true
-			});
-			if (!result.success) {
-				failCommand(result.error);
-				return;
-			}
-			outro(t("common.done"));
-		} catch (error) {
-			if (isMissingUploadFileError(error)) {
-				failCommand(MISSING_UPLOAD_FILE_TEXT);
-				return;
-			}
-			failCommand(error instanceof Error ? error.message : String(error));
-		}
-	}
-});
-const rmCommand = defineCommand({
-	meta: {
-		name: "rm",
-		description: t("command.extract.rm.description")
-	},
-	args: { id: {
-		type: "string",
-		description: t("command.extract.rm.args.id")
-	} },
-	async run({ args }) {
-		const id = getIdArg(args);
-		if (!id) {
-			failCommand(t("command.extract.history.errors.idRequired"));
-			return;
-		}
-		const config = createMigrationConfig(process.cwd());
-		if (!await deleteExtractionAuditRecord(path.dirname(config.schemaPath), id)) {
-			failCommand(t("command.extract.history.errors.recordNotFound", { id }));
-			return;
-		}
-		consola.success(t("command.extract.history.deleted", { id }));
-	}
-});
 const extractCommand = defineCommand({
 	meta: {
 		name: "extract",
 		description: t("command.extract.description")
 	},
-	subCommands: {
-		history: historyCommand,
-		show: showCommand,
-		retry: retryCommand,
-		rm: rmCommand
-	},
 	args: {
 		schema: {
 			type: "string",
@@ -2951,8 +2585,7 @@ const extractCommand = defineCommand({
 			default: false
 		}
 	},
-	async run({ args, rawArgs }) {
-		if (isExtractSubCommand(rawArgs)) return;
+	async run({ args }) {
 		intro(pc.inverse(" aiex extract "));
 		await initI18n();
 		const config = createMigrationConfig(process.cwd());
@@ -3033,7 +2666,7 @@ async function runInteractive(aiexDir, config, aiConfig, modelOverride) {
 		}))
 	});
 	if (isCancel(schemaName)) {
-		cancel(t("common.cancelled"));
+		cancel$1(t("common.cancelled"));
 		return false;
 	}
 	const inputSource = await select({
@@ -3049,7 +2682,7 @@ async function runInteractive(aiexDir, config, aiConfig, modelOverride) {
 		}]
 	});
 	if (isCancel(inputSource)) {
-		cancel(t("common.cancelled"));
+		cancel$1(t("common.cancelled"));
 		return false;
 	}
 	if (inputSource === "file") {
@@ -3060,7 +2693,7 @@ async function runInteractive(aiexDir, config, aiConfig, modelOverride) {
 			}
 		});
 		if (isCancel(filePathStr)) {
-			cancel(t("common.cancelled"));
+			cancel$1(t("common.cancelled"));
 			return false;
 		}
 		const fp = filePathStr;
@@ -3069,7 +2702,7 @@ async function runInteractive(aiexDir, config, aiConfig, modelOverride) {
 			initialValue: false
 		});
 		if (isCancel(force)) {
-			cancel(t("common.cancelled"));
+			cancel$1(t("common.cancelled"));
 			return false;
 		}
 		return (await runAuditedExtraction({
@@ -3092,7 +2725,7 @@ async function runInteractive(aiexDir, config, aiConfig, modelOverride) {
 			}
 		});
 		if (isCancel(dirPath)) {
-			cancel(t("common.cancelled"));
+			cancel$1(t("common.cancelled"));
 			return false;
 		}
 		const force = await confirm({
@@ -3100,7 +2733,7 @@ async function runInteractive(aiexDir, config, aiConfig, modelOverride) {
 			initialValue: false
 		});
 		if (isCancel(force)) {
-			cancel(t("common.cancelled"));
+			cancel$1(t("common.cancelled"));
 			return false;
 		}
 		const result = await runBatchExtraction(aiexDir, config, aiConfig, schemaName, dirPath, void 0, modelOverride, { force });
@@ -3109,12 +2742,79 @@ async function runInteractive(aiexDir, config, aiConfig, modelOverride) {
 	}
 	return false;
 }
-function cancel(msg) {
+function cancel$1(msg) {
 	consola.info(msg);
 	outro(t("common.cancelled"));
 	process.exitCode = 0;
 }
 
+//#endregion
+//#region src/domain/schema/migration-risk.ts
+function keyOf(entry) {
+	return `${entry.table}.${entry.column}`;
+}
+function maxSeverity(items) {
+	if (items.some((item) => item.severity === "high")) return "high";
+	if (items.some((item) => item.severity === "medium")) return "medium";
+	if (items.some((item) => item.severity === "low")) return "low";
+	return "none";
+}
+function addRisk(items, severity, kind, table, column, message) {
+	items.push({
+		severity,
+		kind,
+		table,
+		column,
+		message
+	});
+}
+function enumValues(entry) {
+	return new Set((entry.constraints?.enumValues ?? []).map((value) => JSON.stringify(value)));
+}
+function isEnumNarrowed(previous, next) {
+	const prev = enumValues(previous);
+	const current = enumValues(next);
+	if (prev.size === 0 || current.size === 0 || current.size >= prev.size) return false;
+	return [...current].every((value) => prev.has(value));
+}
+function enumChanged(previous, next) {
+	const prev = enumValues(previous);
+	const current = enumValues(next);
+	if (prev.size === 0 && current.size === 0) return false;
+	if (prev.size !== current.size) return true;
+	return [...prev].some((value) => !current.has(value));
+}
+function analyzeMigrationRisk(previousEntries, nextEntries) {
+	const items = [];
+	const previousByKey = new Map(previousEntries.map((entry) => [keyOf(entry), entry]));
+	const nextByKey = new Map(nextEntries.map((entry) => [keyOf(entry), entry]));
+	const previousTables = new Set(previousEntries.map((entry) => entry.table));
+	const nextTables = new Set(nextEntries.map((entry) => entry.table));
+	for (const table of previousTables) if (!nextTables.has(table)) addRisk(items, "high", "table_removed", table, void 0, `Table "${table}" will be removed.`);
+	for (const table of nextTables) if (!previousTables.has(table)) addRisk(items, "low", "table_added", table, void 0, `Table "${table}" will be added.`);
+	for (const [key, previous] of previousByKey) {
+		const next = nextByKey.get(key);
+		if (!next) {
+			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.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.`);
+		if (previous.primary !== next.primary) addRisk(items, "high", "primary_changed", previous.table, previous.column, `Column "${key}" primary key status changes.`);
+		if (isEnumNarrowed(previous, next)) addRisk(items, "high", "enum_narrowed", previous.table, previous.column, `Column "${key}" enum values are narrowed.`);
+		else if (enumChanged(previous, next)) addRisk(items, "medium", "enum_changed", previous.table, previous.column, `Column "${key}" enum values change.`);
+	}
+	for (const [key, next] of nextByKey) if (!previousByKey.has(key)) addRisk(items, next.nullable ? "low" : "medium", "column_added", next.table, next.column, `Column "${key}" will be added.`);
+	const level = maxSeverity(items);
+	return {
+		level,
+		items,
+		hasHighRisk: level === "high"
+	};
+}
+
 //#endregion
 //#region src/infrastructure/runtime/package-paths.ts
 const __filename = fileURLToPath(import.meta.url);
@@ -3139,6 +2839,102 @@ function resolveHelperPath() {
 	}
 }
 
+//#endregion
+//#region src/domain/schema/dialect.ts
+const TOP_LEVEL_KEYS = new Set([
+	"$schema",
+	"title",
+	"description",
+	"type",
+	"table",
+	"properties",
+	"required",
+	"examples"
+]);
+const PROPERTY_KEYS = new Set([
+	"description",
+	"type",
+	"format",
+	"pattern",
+	"enum",
+	"primary",
+	"autoIncrement",
+	"unique",
+	"default",
+	"maxLength",
+	"minLength",
+	"minimum",
+	"maximum",
+	"examples",
+	"xPrompt",
+	"drizzle",
+	"nested",
+	"foreignKey",
+	"properties",
+	"items",
+	"required"
+]);
+const DRIZZLE_KEYS = new Set(["mode", "customType"]);
+const NESTED_KEYS = new Set(["enabled", "relation"]);
+const FOREIGN_KEY_KEYS = new Set(["table", "column"]);
+const TABLE_KEYS = new Set([
+	"name",
+	"timestamps",
+	"softDelete"
+]);
+const UNSUPPORTED_JSON_SCHEMA_KEYWORDS = new Set([
+	"oneOf",
+	"anyOf",
+	"allOf",
+	"not",
+	"if",
+	"then",
+	"else",
+	"const",
+	"contains",
+	"prefixItems",
+	"additionalItems",
+	"additionalProperties",
+	"patternProperties",
+	"propertyNames",
+	"dependentRequired",
+	"dependentSchemas",
+	"dependencies",
+	"unevaluatedItems",
+	"unevaluatedProperties",
+	"multipleOf",
+	"exclusiveMinimum",
+	"exclusiveMaximum"
+]);
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function warnUnsupportedKey(warnings, path$1, key) {
+	const reason = UNSUPPORTED_JSON_SCHEMA_KEYWORDS.has(key) ? "is not part of the AIEX Drizzle-backed schema dialect and cannot be mapped reliably" : "is not recognized by the AIEX Drizzle-backed schema dialect";
+	warnings.push(`${path$1}.${key} ${reason}.`);
+}
+function inspectRecordKeys(warnings, value, path$1, allowedKeys) {
+	if (!isRecord(value)) return;
+	for (const key of Object.keys(value)) if (!allowedKeys.has(key)) warnUnsupportedKey(warnings, path$1, key);
+}
+function inspectProperty(warnings, property, path$1) {
+	if (!isRecord(property)) return;
+	inspectRecordKeys(warnings, property, path$1, PROPERTY_KEYS);
+	inspectRecordKeys(warnings, property.drizzle, `${path$1}.drizzle`, DRIZZLE_KEYS);
+	inspectRecordKeys(warnings, property.nested, `${path$1}.nested`, NESTED_KEYS);
+	inspectRecordKeys(warnings, property.foreignKey, `${path$1}.foreignKey`, FOREIGN_KEY_KEYS);
+	if (isRecord(property.properties)) for (const [name$1, child] of Object.entries(property.properties)) inspectProperty(warnings, child, `${path$1}.properties.${name$1}`);
+	if (property.items) inspectProperty(warnings, property.items, `${path$1}.items`);
+}
+function collectDialectWarnings(schema, filePath) {
+	if (!isRecord(schema)) return [];
+	const warnings = [];
+	inspectRecordKeys(warnings, schema, filePath, TOP_LEVEL_KEYS);
+	inspectRecordKeys(warnings, schema.table, `${filePath}.table`, TABLE_KEYS);
+	if (isRecord(schema.properties)) for (const [name$1, property] of Object.entries(schema.properties)) inspectProperty(warnings, property, `${filePath}.properties.${name$1}`);
+	return warnings;
+}
+
 //#endregion
 //#region src/application/schema/parse-all-schemas.ts
 function formatZodError(error, filePath) {
@@ -3149,6 +2945,7 @@ function parseAllSchemas(entries) {
 	const relations = [];
 	const reverseRelations = [];
 	const warnings = [];
+	const mapping = [];
 	for (const { filePath, content } of entries) {
 		let schema;
 		try {
@@ -3160,11 +2957,16 @@ function parseAllSchemas(entries) {
 			};
 		}
 		try {
+			warnings.push(...collectDialectWarnings(schema, filePath));
 			const result = parseJsonSchema(JsonSchemaDefinitionSchema.parse(schema));
 			tables.push(...result.tables);
 			relations.push(...result.relations);
 			reverseRelations.push(...result.reverseRelations);
 			warnings.push(...result.warnings);
+			mapping.push(...(result.mapping ?? []).map((entry) => ({
+				...entry,
+				schemaPath: `${filePath}${entry.schemaPath.slice(1)}`
+			})));
 		} catch (e) {
 			if (e instanceof ZodError) return {
 				success: false,
@@ -3180,6 +2982,7 @@ function parseAllSchemas(entries) {
 			relations,
 			reverseRelations,
 			warnings,
+			mapping,
 			drizzleCode: generateDrizzleSchema({
 				tables,
 				relations,
@@ -3193,6 +2996,24 @@ function parseAllSchemas(entries) {
 //#endregion
 //#region src/application/schema/schema-sync.ts
 const execFileAsync = promisify(execFile);
+const NO_RISK_REPORT = {
+	level: "none",
+	items: [],
+	hasHighRisk: false
+};
+function schemaMapPath(config) {
+	return path.join(path.dirname(config.drizzleSchemaPath), "schema-map.json");
+}
+async function readPreviousSchemaMap(config) {
+	try {
+		const content = await fs.readFile(schemaMapPath(config), "utf-8");
+		const parsed = JSON.parse(content);
+		if (Array.isArray(parsed.baselineEntries)) return parsed.baselineEntries;
+		return Array.isArray(parsed.entries) ? parsed.entries : [];
+	} catch {
+		return [];
+	}
+}
 async function listSchemaFiles(schemaDir) {
 	try {
 		return (await fs.readdir(schemaDir)).filter((f) => f.endsWith(".json")).map((f) => path.join(schemaDir, f)).sort();
@@ -3200,7 +3021,8 @@ async function listSchemaFiles(schemaDir) {
 		return [];
 	}
 }
-async function generateSchemaFromFiles(schemaFiles, config) {
+async function generateSchemaFromFiles(schemaFiles, config, options = {}) {
+	const previousMapping = await readPreviousSchemaMap(config);
 	const result = parseAllSchemas(await Promise.all(schemaFiles.map(async (filePath) => {
 		return {
 			filePath,
@@ -3213,17 +3035,30 @@ async function generateSchemaFromFiles(schemaFiles, config) {
 		warnings: [],
 		schemaCount: schemaFiles.length,
 		tables: 0,
-		relations: 0
+		relations: 0,
+		mappingEntries: 0,
+		riskReport: NO_RISK_REPORT
 	};
-	const { tables, relations, reverseRelations, warnings, drizzleCode } = result.data;
+	const { tables, relations, reverseRelations, warnings, mapping, drizzleCode } = result.data;
+	const riskReport = previousMapping.length > 0 ? analyzeMigrationRisk(previousMapping, mapping) : NO_RISK_REPORT;
 	await fs.mkdir(path.dirname(config.drizzleSchemaPath), { recursive: true });
 	await fs.writeFile(config.drizzleSchemaPath, drizzleCode);
+	await fs.writeFile(schemaMapPath(config), `${JSON.stringify({
+		generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		dialect: "aiex-drizzle-sqlite",
+		entries: mapping,
+		baselineEntries: riskReport.hasHighRisk && !options.force ? previousMapping : void 0,
+		warnings,
+		migrationRisk: riskReport
+	}, null, 2)}\n`);
 	return {
 		success: true,
 		warnings,
 		schemaCount: schemaFiles.length,
 		tables: tables.length,
-		relations: relations.length + reverseRelations.length
+		relations: relations.length + reverseRelations.length,
+		mappingEntries: mapping.length,
+		riskReport
 	};
 }
 function parseMigrationOutput(stdout, stderr) {
@@ -3275,24 +3110,34 @@ async function runSchemaSync(config, options = {}) {
 		warnings: [],
 		schemaCount: 0,
 		tables: 0,
-		relations: 0
+		relations: 0,
+		mappingEntries: 0,
+		riskReport: NO_RISK_REPORT
 	};
-	const generated = await generateSchemaFromFiles(schemaFiles, config);
+	const generated = await generateSchemaFromFiles(schemaFiles, config, { force: options.force });
 	if (!generated.success) return {
 		success: false,
 		error: generated.error,
 		warnings: generated.warnings,
 		schemaCount: generated.schemaCount,
 		tables: generated.tables,
-		relations: generated.relations
-	};
-	if (options.generateOnly) return {
-		success: true,
-		warnings: generated.warnings,
-		schemaCount: generated.schemaCount,
-		tables: generated.tables,
-		relations: generated.relations
+		relations: generated.relations,
+		mappingEntries: generated.mappingEntries,
+		riskReport: generated.riskReport
 	};
+	if (options.generateOnly || generated.riskReport.hasHighRisk && !options.force) {
+		const blockedByRisk = generated.riskReport.hasHighRisk && !options.force && !options.generateOnly;
+		return {
+			success: !blockedByRisk,
+			error: blockedByRisk ? t("errors.schema.highRiskMigrationBlocked") : void 0,
+			warnings: generated.warnings,
+			schemaCount: generated.schemaCount,
+			tables: generated.tables,
+			relations: generated.relations,
+			mappingEntries: generated.mappingEntries,
+			riskReport: generated.riskReport
+		};
+	}
 	const migration = await runSchemaMigration(config, options.migrationName);
 	return {
 		success: migration.success,
@@ -3301,6 +3146,8 @@ async function runSchemaSync(config, options = {}) {
 		schemaCount: generated.schemaCount,
 		tables: generated.tables,
 		relations: generated.relations,
+		mappingEntries: generated.mappingEntries,
+		riskReport: generated.riskReport,
 		migration
 	};
 }
@@ -3322,6 +3169,11 @@ const schemaCommand = defineCommand({
 		name: {
 			type: "string",
 			description: t("command.schema.args.name")
+		},
+		force: {
+			type: "boolean",
+			description: t("command.schema.args.force"),
+			default: false
 		}
 	},
 	async run({ args }) {
@@ -3336,7 +3188,7 @@ const schemaCommand = defineCommand({
 		}
 		const s1 = spinner();
 		s1.start(t("command.schema.generating"));
-		const generated = await generateSchemaFromFiles(schemaFiles, config);
+		const generated = await generateSchemaFromFiles(schemaFiles, config, { force: args.force });
 		for (const warning of generated.warnings) consola.warn(warning);
 		if (generated.success) consola.success(t("command.schema.generated", {
 			path: pc.cyan(".aiex/drizzle/schema.ts"),
@@ -3348,10 +3200,21 @@ const schemaCommand = defineCommand({
 			failCommand(t("common.failed"));
 			return;
 		}
+		if (generated.riskReport.items.length > 0) {
+			consola.info(t("command.schema.riskSummary", {
+				level: generated.riskReport.level,
+				count: generated.riskReport.items.length
+			}));
+			for (const item of generated.riskReport.items) consola.warn(`[${item.severity}] ${item.message}`);
+		}
 		if (args.generate) {
 			outro(t("command.schema.runWithoutGenerate"));
 			return;
 		}
+		if (generated.riskReport.hasHighRisk && !args.force) {
+			failCommand(t("command.schema.highRiskBlocked", { flag: pc.cyan("--force") }));
+			return;
+		}
 		const s2 = spinner();
 		s2.start(t("command.schema.runningMigrations"));
 		const migration = await runSchemaMigration(config, args.name);
@@ -3549,6 +3412,14 @@ const watchCommand = defineCommand({
 	async run({ args }) {
 		intro(pc.inverse(" aiex watch "));
 		await initI18n();
+		const config = createMigrationConfig(process.cwd());
+		const aiexDir = path.dirname(config.schemaPath);
+		if (!args.schema && !args.dir && !args.model) {
+			const aiConfig$1 = await loadConfiguredAI(aiexDir);
+			if (!aiConfig$1) return;
+			if (await runInteractiveWatch(aiexDir, config, aiConfig$1)) consola.info(t("command.watch.events.pressCtrlC"));
+			return;
+		}
 		if (!args.schema) {
 			failCommand(t("command.watch.errors.schemaRequired"));
 			return;
@@ -3557,33 +3428,18 @@ const watchCommand = defineCommand({
 			failCommand(t("command.watch.errors.dirRequired"));
 			return;
 		}
-		const config = createMigrationConfig(process.cwd());
-		const aiexDir = path.dirname(config.schemaPath);
 		const schemaLoad = await loadSchema(config, args.schema);
 		if (!schemaLoad.schema) {
 			failCommand(schemaLoad.error || t("command.watch.errors.schemaNotFound", { name: args.schema }));
 			return;
 		}
-		let watchDirStat;
-		try {
-			watchDirStat = fs$1.statSync(args.dir);
-		} catch (e) {
-			failCommand(t("command.watch.errors.dirNotExist", {
-				dir: args.dir,
-				error: e instanceof Error ? e.message : String(e)
-			}));
-			return;
-		}
-		if (!watchDirStat.isDirectory()) {
-			failCommand(t("command.watch.errors.notADirectory", { dir: args.dir }));
-			return;
-		}
 		const watchDirAbs = path.resolve(args.dir);
+		if (!validateWatchDir(watchDirAbs)) return;
 		const aiConfig = await loadConfiguredAI(aiexDir);
 		if (!aiConfig) return;
 		const modelOverride = resolveModelOverride(aiConfig, args.model);
 		if (modelOverride === null) return;
-		const watcher = startWatcher({
+		registerCleanup(startWatch({
 			aiexDir,
 			config,
 			aiConfig,
@@ -3591,18 +3447,112 @@ const watchCommand = defineCommand({
 			watchDir: watchDirAbs,
 			modelOverride,
 			insert: !args.noInsert
-		});
-		const cleanup = async () => {
-			consola.info(t("command.watch.events.stopped"));
-			await watcher.close();
-			consola.success(t("command.watch.events.stoppedOk"));
-			process.exit(0);
-		};
-		process.on("SIGINT", cleanup);
-		process.on("SIGTERM", cleanup);
+		}));
 		consola.info(t("command.watch.events.pressCtrlC"));
 	}
 });
+async function runInteractiveWatch(aiexDir, config, aiConfig) {
+	const schemas = await listSchemas(aiexDir);
+	if (schemas.length === 0) {
+		failCommand(t("command.extract.errors.noSchemas", {
+			path: pc.cyan(".aiex/schema/"),
+			cmd: pc.cyan("aiex web")
+		}));
+		return false;
+	}
+	const schemaName = await select({
+		message: t("command.watch.interactive.selectSchema"),
+		options: schemas.map((s) => ({
+			label: s,
+			value: s
+		}))
+	});
+	if (isCancel(schemaName)) {
+		cancel(t("common.cancelled"));
+		return false;
+	}
+	const dirPath = await text({
+		message: t("command.watch.interactive.enterDirPath"),
+		validate(value) {
+			if (!value || value.trim().length === 0) return t("command.watch.interactive.dirPathRequired");
+		}
+	});
+	if (isCancel(dirPath)) {
+		cancel(t("common.cancelled"));
+		return false;
+	}
+	const selectedModel = await select({
+		message: t("command.watch.interactive.selectModel"),
+		options: [{
+			label: t("command.watch.interactive.autoModel"),
+			value: ""
+		}, ...aiConfig.provider.models.map((model) => ({
+			label: model.name,
+			value: model.name
+		}))]
+	});
+	if (isCancel(selectedModel)) {
+		cancel(t("common.cancelled"));
+		return false;
+	}
+	const noInsert = await confirm({
+		message: t("command.watch.interactive.askNoInsert"),
+		initialValue: false
+	});
+	if (isCancel(noInsert)) {
+		cancel(t("common.cancelled"));
+		return false;
+	}
+	const watchDir = path.resolve(dirPath);
+	if (!validateWatchDir(watchDir)) return false;
+	const modelOverride = resolveModelOverride(aiConfig, selectedModel ? selectedModel : void 0);
+	if (modelOverride === null) return false;
+	registerCleanup(startWatch({
+		aiexDir,
+		config,
+		aiConfig,
+		schemaName,
+		watchDir,
+		modelOverride,
+		insert: !noInsert
+	}));
+	return true;
+}
+function validateWatchDir(dir) {
+	let watchDirStat;
+	try {
+		watchDirStat = fs$1.statSync(dir);
+	} catch (e) {
+		failCommand(t("command.watch.errors.dirNotExist", {
+			dir,
+			error: e instanceof Error ? e.message : String(e)
+		}));
+		return false;
+	}
+	if (!watchDirStat.isDirectory()) {
+		failCommand(t("command.watch.errors.notADirectory", { dir }));
+		return false;
+	}
+	return true;
+}
+function startWatch(options) {
+	return startWatcher(options);
+}
+function registerCleanup(watcher) {
+	const cleanup = async () => {
+		consola.info(t("command.watch.events.stopped"));
+		await watcher.close();
+		consola.success(t("command.watch.events.stoppedOk"));
+		process.exit(0);
+	};
+	process.on("SIGINT", cleanup);
+	process.on("SIGTERM", cleanup);
+}
+function cancel(msg) {
+	consola.info(msg);
+	outro(t("common.cancelled"));
+	process.exitCode = 0;
+}
 
 //#endregion
 //#region src/domain/ai-extraction/model-capabilities.json
@@ -16928,12 +16878,13 @@ function schemaRoutes(config) {
 	app.post("/migrate", async (c) => {
 		try {
 			await ensureDir();
-			const result = await runSchemaSync(config);
+			const result = await runSchemaSync(config, { force: c.req.query("force") === "true" });
 			if (!result.success) {
-				const status = result.schemaCount === 0 ? 400 : 500;
+				const status = result.schemaCount === 0 ? 400 : result.riskReport.hasHighRisk ? 409 : 500;
 				return c.json({
 					success: false,
-					error: result.error || t("server.migrationFailed")
+					error: result.error || t("server.migrationFailed"),
+					riskReport: result.riskReport
 				}, status);
 			}
 			return c.json({
@@ -16942,7 +16893,8 @@ function schemaRoutes(config) {
 				tag: result.migration?.tag,
 				tables: result.tables,
 				relations: result.relations,
-				warnings: result.warnings
+				warnings: result.warnings,
+				riskReport: result.riskReport
 			});
 		} catch (error) {
 			return c.json({
@@ -17062,7 +17014,6 @@ const subCommands = {
 	schema: schemaCommand,
 	extract: extractCommand,
 	watch: watchCommand,
-	dump: dumpCommand,
 	completion: completionCommand,
 	doctor: doctorCommand
 };