aiex-cli 0.0.6 → 0.0.7-beta.2

package/dist/{doctor-collector-SgMb2oQN.mjs → generate-drizzle-schema-D_oDmf4J.mjs}

@@ -9,83 +9,9 @@ import { readFile, writeFile } from "jsonfile";
 import Conf from "conf";
 import { z } from "zod";
 
-//#region src/core/doctor.ts
-function buildDoctorDiagnostics(input) {
-	return {
-		cli: {
-			name: input.pkg.name,
-			version: input.pkg.version,
-			executable: input.executable
-		},
-		runtime: {
-			node: input.node,
-			platform: input.platform,
-			arch: input.arch,
-			shell: input.shell,
-			packageManager: input.packageManager
-		},
-		system: {
-			os: `${input.osType} ${input.osRelease}`,
-			cwd: input.cwd
-		},
-		imageOcr: { ...input.imageOcr },
-		config: {
-			path: input.configPath,
-			keys: [...input.configStoreKeys].sort()
-		},
-		project: { ...input.project }
-	};
-}
-function formatDoctorDiagnosticsJson(d) {
-	return `${JSON.stringify(d, null, 2)}\n`;
-}
-function doctorDiagnosticsTableRows(d) {
-	const rows = [
-		["node", d.runtime.node],
-		["platform", d.runtime.platform],
-		["arch", d.runtime.arch],
-		["shell", d.runtime.shell],
-		["packageManager", d.runtime.packageManager],
-		["os", d.system.os],
-		["cwd", d.system.cwd],
-		["config", d.config.path],
-		["configKeys", d.config.keys.join(", ")]
-	];
-	const p = d.project;
-	rows.push(["aiexDir", p.aiexDir]);
-	rows.push(["dirExists", String(p.dirExists)]);
-	rows.push(["schemaFiles", `${p.schemaCount} (${p.schemaFiles.join(", ") || "none"})`]);
-	rows.push(["aiConfig", String(p.aiConfig)]);
-	rows.push(["aiApiKeySet", String(p.aiApiKeySet)]);
-	rows.push(["aiModels", p.aiModelCount ? p.aiModels.join(", ") : "none"]);
-	rows.push(["aiVisionModels", String(p.aiVisionModelCount)]);
-	rows.push(["aiStructuredOutputModels", String(p.aiStructuredOutputModelCount)]);
-	rows.push(["aiProvider", p.aiProvider ?? "none"]);
-	rows.push(["aiConnectionOk", p.aiConnectionOk === null ? "not tested" : String(p.aiConnectionOk)]);
-	rows.push(["pdfConverter", p.pdfConverter ?? "none"]);
-	rows.push(["pdfConverterOk", p.pdfConverterOk === null ? "not tested" : String(p.pdfConverterOk)]);
-	if (p.pdfConverterError) rows.push(["pdfConverterError", p.pdfConverterError]);
-	rows.push(["imageOcrPlatform", String(d.imageOcr.platformSupported)]);
-	rows.push(["imageOcrDependency", String(d.imageOcr.dependencyLoaded)]);
-	rows.push(["imageOcrOk", d.imageOcr.ocrOk === null ? "not tested" : String(d.imageOcr.ocrOk)]);
-	if (d.imageOcr.imagePath) rows.push(["imageOcrImage", d.imageOcr.imagePath]);
-	if (d.imageOcr.recognizedText) rows.push(["imageOcrText", d.imageOcr.recognizedText]);
-	if (typeof d.imageOcr.confidence === "number") rows.push(["imageOcrConfidence", `${(d.imageOcr.confidence * 100).toFixed(1)}%`]);
-	if (d.imageOcr.error) rows.push(["imageOcrError", d.imageOcr.error]);
-	rows.push(["hasDatabase", String(p.hasDatabase)]);
-	rows.push(["databaseTablesOk", p.databaseTablesOk === null ? "not tested" : String(p.databaseTablesOk)]);
-	if (p.missingDatabaseTables.length) rows.push(["missingDatabaseTables", p.missingDatabaseTables.join(", ")]);
-	rows.push(["migrations", String(p.migrationCount)]);
-	rows.push(["schemaValid", `${p.schemaValidCount}/${p.schemaCount}`]);
-	for (const invalid of p.invalidSchemas) rows.push(["invalidSchema", `${invalid.file}: ${invalid.error}`]);
-	for (const err of p.errors) rows.push(["error", err]);
-	return rows;
-}
-
-//#endregion
 //#region package.json
 var name = "aiex-cli";
-var version = "0.0.6";
+var version = "0.0.7-beta.2";
 var description = "JSON Schema → SQLite with AI-powered data extraction";
 var package_default = {
 	name,
@@ -219,110 +145,7 @@ function seedConfig(config = createConfig()) {
 }
 
 //#endregion
-//#region src/core/ai-extraction/schemas.ts
-const ModelCapabilitiesSchema = z.object({
-	vision: z.boolean(),
-	structuredOutput: z.boolean(),
-	maxTokens: z.number().int().positive().optional(),
-	maxOutputTokens: z.number().int().positive().optional()
-});
-const AIModelConfigSchema = z.object({
-	name: z.string().min(1),
-	capabilities: ModelCapabilitiesSchema
-});
-const AIProviderConfigSchema = z.object({
-	baseURL: z.string().min(1),
-	apiKey: z.string(),
-	models: z.array(AIModelConfigSchema).min(1),
-	timeout: z.number().int().positive().default(300).optional()
-});
-const PromptConfigSchema = z.object({
-	systemTemplate: z.string().min(1),
-	userTemplate: z.string().min(1)
-});
-const ExtractionConfigSchema = z.object({ outputDir: z.string().min(1) });
-const ImageOcrFallbackSchema = z.preprocess((value) => [
-	"auto",
-	"off",
-	"local"
-].includes(String(value)) ? "localAuto" : value, z.literal("localAuto").default("localAuto").optional());
-const ImageOcrConfigSchema = z.object({
-	ocrFallback: ImageOcrFallbackSchema,
-	ocrLanguages: z.string().min(1).optional(),
-	ocrMinConfidence: z.number().min(0).max(1).optional()
-});
-const ExternalPdfConverterConfigSchema = z.object({
-	command: z.string().min(1),
-	args: z.array(z.string()).min(1).refine((args) => args.some((arg) => arg.includes("{input}")), { message: "args must contain {input} template variable" }),
-	outputFile: z.string().min(1).optional(),
-	timeout: z.number().int().positive().default(600).optional(),
-	fallbackToUnpdf: z.boolean().optional()
-});
-const MineruApiPdfConverterConfigSchema = z.object({
-	token: z.string(),
-	baseURL: z.string().url().optional(),
-	modelVersion: z.string().optional(),
-	isOcr: z.boolean().optional(),
-	enableFormula: z.boolean().optional(),
-	enableTable: z.boolean().optional()
-});
-const PdfConfigSchema = z.preprocess((value) => {
-	if (!value || typeof value !== "object") return value;
-	const config = { ...value };
-	if (config.converter === "markitdown" && config.markitdown) {
-		config.converter = "external";
-		config.external = config.markitdown;
-	} else if (config.converter === "marker" && config.marker) {
-		config.converter = "external";
-		config.external = config.marker;
-	} else if (config.converter === "markitdown" || config.converter === "marker") config.converter = "unpdf";
-	delete config.markitdown;
-	delete config.marker;
-	return config;
-}, z.object({
-	converter: z.enum([
-		"unpdf",
-		"mineru",
-		"mineru_api",
-		"external"
-	]),
-	mineru: ExternalPdfConverterConfigSchema.optional(),
-	mineruApi: MineruApiPdfConverterConfigSchema.optional(),
-	external: ExternalPdfConverterConfigSchema.optional()
-}));
-const LangfuseConfigSchema = z.object({
-	publicKey: z.string(),
-	secretKey: z.string(),
-	host: z.string().optional()
-});
-const NotionSchemaConfigSchema = z.object({
-	databaseId: z.string(),
-	titleProperty: z.string().optional(),
-	fieldMap: z.record(z.string()).optional()
-});
-const NotionConfigSchema = z.object({
-	enabled: z.boolean(),
-	token: z.string(),
-	schemas: z.record(NotionSchemaConfigSchema).default({})
-});
-const WebhookConfigSchema = z.object({
-	enabled: z.boolean(),
-	url: z.string(),
-	secret: z.string().optional()
-});
-const AIConfigSchema = z.object({
-	provider: AIProviderConfigSchema,
-	prompt: PromptConfigSchema,
-	extraction: ExtractionConfigSchema,
-	image: ImageOcrConfigSchema.optional(),
-	pdf: PdfConfigSchema.optional(),
-	langfuse: LangfuseConfigSchema.optional(),
-	notion: NotionConfigSchema.optional(),
-	webhook: WebhookConfigSchema.optional()
-});
-
-//#endregion
-//#region src/core/ai-extraction/types.ts
+//#region src/domain/ai/types.ts
 const PLACEHOLDER_SCHEMA = "{schema}";
 const PLACEHOLDER_TEXT = "{text}";
 const DEFAULT_MODELS = [{
@@ -395,63 +218,554 @@ const DEFAULT_AI_CONFIG = {
 };
 
 //#endregion
-//#region src/core/ai-extraction/config.ts
-const CONFIG_FILE_NAME = "ai-config.json";
-const GITIGNORE_FILE = ".gitignore";
-async function readAIConfig(aiexDir) {
-	const configPath = path.join(aiexDir, CONFIG_FILE_NAME);
-	try {
-		const parsed = await readFile(configPath);
-		return AIConfigSchema.parse(parsed);
-	} catch {
-		return null;
-	}
-}
-async function writeAIConfig(aiexDir, config) {
-	const configPath = path.join(aiexDir, CONFIG_FILE_NAME);
-	await fs.mkdir(aiexDir, { recursive: true });
-	await writeFile(configPath, config, {
-		spaces: 2,
-		EOL: "\n"
-	});
-	await addToGitignore(aiexDir, CONFIG_FILE_NAME);
-}
-function getDefaultAIConfig() {
-	return structuredClone(DEFAULT_AI_CONFIG);
+//#region src/domain/doctor/diagnostics.ts
+function buildDoctorDiagnostics(input) {
+	return {
+		cli: {
+			name: input.pkg.name,
+			version: input.pkg.version,
+			executable: input.executable
+		},
+		runtime: {
+			node: input.node,
+			platform: input.platform,
+			arch: input.arch,
+			shell: input.shell,
+			packageManager: input.packageManager
+		},
+		system: {
+			os: `${input.osType} ${input.osRelease}`,
+			cwd: input.cwd
+		},
+		imageOcr: { ...input.imageOcr },
+		config: {
+			path: input.configPath,
+			keys: [...input.configStoreKeys].sort()
+		},
+		project: { ...input.project }
+	};
 }
-async function addToGitignore(aiexDir, fileName) {
-	const projectRoot = path.dirname(aiexDir);
-	const gitignorePath = path.join(projectRoot, GITIGNORE_FILE);
-	try {
-		const content = await fs.readFile(gitignorePath, "utf-8");
-		if (content.split("\n").some((line) => line.trim() === fileName || line.includes(".aiex/"))) return;
-		const newContent = content.endsWith("\n") ? `${content}${fileName}\n` : `${content}\n${fileName}\n`;
-		await fs.writeFile(gitignorePath, newContent);
-	} catch {
-		await fs.writeFile(gitignorePath, `${fileName}\n`);
-	}
+function formatDoctorDiagnosticsJson(d) {
+	return `${JSON.stringify(d, null, 2)}\n`;
 }
-
-//#endregion
-//#region src/locales/en.ts
-const en = {
-	common: {
-		done: "Done!",
-		failed: "Failed!",
-		cancelled: "Cancelled",
-		save: "Save",
-		cancel: "Cancel",
-		delete: "Delete",
-		close: "Close",
-		loading: "Loading...",
-		unknownError: "Unknown error"
-	},
-	cli: { description: "JSON Schema → SQLite with AI-powered data extraction" },
-	command: {
-		web: {
-			description: "Start visual JSON Schema editor",
-			args: { port: "Port to listen on" },
-			starting: "Starting web server...",
+function doctorDiagnosticsTableRows(d) {
+	const rows = [
+		["node", d.runtime.node],
+		["platform", d.runtime.platform],
+		["arch", d.runtime.arch],
+		["shell", d.runtime.shell],
+		["packageManager", d.runtime.packageManager],
+		["os", d.system.os],
+		["cwd", d.system.cwd],
+		["config", d.config.path],
+		["configKeys", d.config.keys.join(", ")]
+	];
+	const p = d.project;
+	rows.push(["aiexDir", p.aiexDir]);
+	rows.push(["dirExists", String(p.dirExists)]);
+	rows.push(["schemaFiles", `${p.schemaCount} (${p.schemaFiles.join(", ") || "none"})`]);
+	rows.push(["aiConfig", String(p.aiConfig)]);
+	rows.push(["aiApiKeySet", String(p.aiApiKeySet)]);
+	rows.push(["aiModels", p.aiModelCount ? p.aiModels.join(", ") : "none"]);
+	rows.push(["aiVisionModels", String(p.aiVisionModelCount)]);
+	rows.push(["aiStructuredOutputModels", String(p.aiStructuredOutputModelCount)]);
+	rows.push(["aiProvider", p.aiProvider ?? "none"]);
+	rows.push(["aiConnectionOk", p.aiConnectionOk === null ? "not tested" : String(p.aiConnectionOk)]);
+	rows.push(["pdfConverter", p.pdfConverter ?? "none"]);
+	rows.push(["pdfConverterOk", p.pdfConverterOk === null ? "not tested" : String(p.pdfConverterOk)]);
+	if (p.pdfConverterError) rows.push(["pdfConverterError", p.pdfConverterError]);
+	rows.push(["imageOcrPlatform", String(d.imageOcr.platformSupported)]);
+	rows.push(["imageOcrDependency", String(d.imageOcr.dependencyLoaded)]);
+	rows.push(["imageOcrOk", d.imageOcr.ocrOk === null ? "not tested" : String(d.imageOcr.ocrOk)]);
+	if (d.imageOcr.imagePath) rows.push(["imageOcrImage", d.imageOcr.imagePath]);
+	if (d.imageOcr.recognizedText) rows.push(["imageOcrText", d.imageOcr.recognizedText]);
+	if (typeof d.imageOcr.confidence === "number") rows.push(["imageOcrConfidence", `${(d.imageOcr.confidence * 100).toFixed(1)}%`]);
+	if (d.imageOcr.error) rows.push(["imageOcrError", d.imageOcr.error]);
+	rows.push(["hasDatabase", String(p.hasDatabase)]);
+	rows.push(["databaseTablesOk", p.databaseTablesOk === null ? "not tested" : String(p.databaseTablesOk)]);
+	if (p.missingDatabaseTables.length) rows.push(["missingDatabaseTables", p.missingDatabaseTables.join(", ")]);
+	rows.push(["migrations", String(p.migrationCount)]);
+	rows.push(["schemaValid", `${p.schemaValidCount}/${p.schemaCount}`]);
+	for (const invalid of p.invalidSchemas) rows.push(["invalidSchema", `${invalid.file}: ${invalid.error}`]);
+	for (const err of p.errors) rows.push(["error", err]);
+	return rows;
+}
+
+//#endregion
+//#region src/domain/schema/parser.ts
+function toSnakeCase(str) {
+	return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+}
+function mapColumnType(property) {
+	switch (property.type) {
+		case "string": {
+			const format = property.format;
+			if (format === "date-time" || property.drizzle?.mode === "timestamp") return {
+				class: "integer",
+				mode: "timestamp"
+			};
+			if (format === "json" || property.drizzle?.mode === "json") return {
+				class: "text",
+				mode: "json"
+			};
+			return { class: "text" };
+		}
+		case "integer": {
+			const mode = property.drizzle?.mode;
+			if (mode === "boolean" || mode === "timestamp" || mode === "timestamp_ms" || mode === "bigint") return {
+				class: "integer",
+				mode
+			};
+			return { class: "integer" };
+		}
+		case "number": return { class: "real" };
+		case "boolean": return {
+			class: "integer",
+			mode: "boolean"
+		};
+		case "object":
+		case "array": return {
+			class: "text",
+			mode: "json"
+		};
+		case "null":
+		default: return { class: "text" };
+	}
+}
+function mapPropertyToColumn(name$1, property, isRequired) {
+	return {
+		name: toSnakeCase(name$1),
+		columnType: mapColumnType(property),
+		isPrimary: property.primary ?? false,
+		isAutoIncrement: property.autoIncrement ?? false,
+		isNullable: !isRequired && !property.primary,
+		isUnique: property.unique ?? false,
+		default: property.default,
+		isForeignKey: property.foreignKey !== void 0,
+		foreignKeyRef: property.foreignKey ?? void 0
+	};
+}
+function getColumnChecks(prop, colName) {
+	const checks = [];
+	if (prop.type === "string") {
+		if (prop.minLength !== void 0 && prop.minLength > 0) checks.push({
+			name: `${colName}_min_length`,
+			column: colName,
+			kind: "min_length",
+			value: prop.minLength
+		});
+		if (prop.maxLength !== void 0) checks.push({
+			name: `${colName}_max_length`,
+			column: colName,
+			kind: "max_length",
+			value: prop.maxLength
+		});
+	}
+	if (prop.type === "integer" || prop.type === "number") {
+		if (prop.minimum !== void 0) checks.push({
+			name: `${colName}_min`,
+			column: colName,
+			kind: "min_value",
+			value: prop.minimum
+		});
+		if (prop.maximum !== void 0) checks.push({
+			name: `${colName}_max`,
+			column: colName,
+			kind: "max_value",
+			value: prop.maximum
+		});
+	}
+	return checks;
+}
+function parseObjectToTable(schema, _warnings) {
+	const tableName = schema.table.name;
+	const columns = [];
+	const checks = [];
+	const requiredFields = new Set(schema.required ?? []);
+	const autoColumns = /* @__PURE__ */ new Set();
+	if (schema.table.timestamps) {
+		autoColumns.add("created_at");
+		autoColumns.add("updated_at");
+	}
+	if (schema.table.softDelete) autoColumns.add("deleted_at");
+	for (const [propName, prop] of Object.entries(schema.properties)) {
+		if (prop.nested?.enabled && (prop.type === "object" || prop.type === "array")) continue;
+		if (prop.type === "array" && prop.items?.nested?.enabled) continue;
+		const snakeName = toSnakeCase(propName);
+		if (autoColumns.has(snakeName)) continue;
+		const column = mapPropertyToColumn(propName, prop, requiredFields.has(propName));
+		columns.push(column);
+		checks.push(...getColumnChecks(prop, column.name));
+	}
+	if (schema.table.timestamps) {
+		const tsCol = {
+			name: "created_at",
+			columnType: {
+				class: "integer",
+				mode: "timestamp"
+			},
+			isPrimary: false,
+			isAutoIncrement: false,
+			isNullable: false,
+			isUnique: false
+		};
+		columns.push(tsCol);
+		columns.push({
+			...tsCol,
+			name: "updated_at"
+		});
+	}
+	if (schema.table.softDelete) columns.push({
+		name: "deleted_at",
+		columnType: {
+			class: "integer",
+			mode: "timestamp"
+		},
+		isPrimary: false,
+		isAutoIncrement: false,
+		isNullable: true,
+		isUnique: false
+	});
+	return checks.length > 0 ? {
+		name: tableName,
+		columns,
+		checks
+	} : {
+		name: tableName,
+		columns
+	};
+}
+function parseNestedObject(propName, property, parentTableName, warnings) {
+	const nestedTableName = `${parentTableName}_${toSnakeCase(propName)}`;
+	const columns = [];
+	const checks = [];
+	const relationType = property.nested?.relation === "has-many" ? "has-many" : "has-one";
+	columns.push({
+		name: "id",
+		columnType: { class: "integer" },
+		isPrimary: true,
+		isAutoIncrement: true,
+		isNullable: false,
+		isUnique: false
+	});
+	columns.push({
+		name: `${parentTableName}_id`,
+		columnType: { class: "integer" },
+		isPrimary: false,
+		isAutoIncrement: false,
+		isNullable: false,
+		isUnique: false,
+		isForeignKey: true,
+		foreignKeyRef: {
+			table: parentTableName,
+			column: "id"
+		}
+	});
+	if (property.type === "object" && property.properties) for (const [childName, childProp] of Object.entries(property.properties)) {
+		if (childProp.nested?.enabled) {
+			warnings.push(`Nested property "${childName}" inside "${nestedTableName}" is skipped — only one level of nesting is supported. Remove nested.enabled or use drizzle.mode: 'json' instead.`);
+			continue;
+		}
+		const column = mapPropertyToColumn(childName, childProp, false);
+		columns.push(column);
+		checks.push(...getColumnChecks(childProp, column.name));
+	}
+	const relation = {
+		fromTable: nestedTableName,
+		fromColumn: `${parentTableName}_id`,
+		toTable: parentTableName,
+		toColumn: "id",
+		name: parentTableName
+	};
+	const reverseRelation = {
+		type: relationType,
+		fromTable: parentTableName,
+		toTable: nestedTableName,
+		name: toSnakeCase(propName)
+	};
+	return {
+		table: checks.length > 0 ? {
+			name: nestedTableName,
+			columns,
+			checks
+		} : {
+			name: nestedTableName,
+			columns
+		},
+		relation,
+		reverseRelation
+	};
+}
+function parseJsonSchema(schema) {
+	const tables = [];
+	const relations = [];
+	const reverseRelations = [];
+	const warnings = [];
+	const mainTable = parseObjectToTable(schema, warnings);
+	tables.push(mainTable);
+	for (const [propName, prop] of Object.entries(schema.properties)) if (prop.type === "object" && prop.nested?.enabled) {
+		const nested = parseNestedObject(propName, prop, mainTable.name, warnings);
+		tables.push(nested.table);
+		relations.push(nested.relation);
+		reverseRelations.push(nested.reverseRelation);
+	} else if (prop.type === "array" && prop.items?.nested?.enabled && prop.items?.type === "object" && prop.items.properties) {
+		const nested = parseNestedObject(propName, prop.items, mainTable.name, warnings);
+		tables.push(nested.table);
+		relations.push(nested.relation);
+		reverseRelations.push(nested.reverseRelation);
+	}
+	return {
+		tables,
+		relations,
+		reverseRelations,
+		warnings
+	};
+}
+
+//#endregion
+//#region src/domain/schema/schemas.ts
+const DrizzleModeSchema = z.enum([
+	"json",
+	"timestamp",
+	"timestamp_ms",
+	"boolean",
+	"bigint"
+]);
+const DrizzleExtensionSchema = z.object({
+	mode: DrizzleModeSchema.optional(),
+	customType: z.string().optional()
+}).optional();
+const NestedConfigSchema = z.object({
+	enabled: z.literal(true),
+	relation: z.enum(["has-one", "has-many"])
+});
+const ForeignKeyRefSchema = z.object({
+	table: z.string().min(1),
+	column: z.string().min(1)
+});
+const JsonSchemaPropertySchema = z.lazy(() => z.object({
+	description: z.string().optional(),
+	type: z.enum([
+		"string",
+		"integer",
+		"number",
+		"boolean",
+		"object",
+		"array",
+		"null"
+	]),
+	format: z.string().optional(),
+	pattern: z.string().optional(),
+	enum: z.array(z.union([z.string(), z.number()])).optional(),
+	primary: z.boolean().optional(),
+	autoIncrement: z.boolean().optional(),
+	unique: z.boolean().optional(),
+	default: z.unknown().optional(),
+	maxLength: z.number().int().positive().optional(),
+	minLength: z.number().int().nonnegative().optional(),
+	minimum: z.number().optional(),
+	maximum: z.number().optional(),
+	examples: z.array(z.unknown()).optional(),
+	xPrompt: z.string().optional(),
+	drizzle: DrizzleExtensionSchema,
+	nested: NestedConfigSchema.optional(),
+	foreignKey: ForeignKeyRefSchema.optional(),
+	properties: z.record(z.string(), JsonSchemaPropertySchema).optional(),
+	items: JsonSchemaPropertySchema.optional(),
+	required: z.array(z.string()).optional()
+}));
+const TableConfigSchema = z.object({
+	name: z.string().min(1).regex(/^[a-z][a-z0-9_]*$/, "Table name must be snake_case (lowercase letters, digits, underscores)"),
+	timestamps: z.boolean().optional(),
+	softDelete: z.boolean().optional()
+});
+const ExamplePairSchema = z.object({
+	text: z.string().min(1),
+	output: z.record(z.string(), z.unknown())
+});
+const JsonSchemaDefinitionSchema = z.object({
+	$schema: z.string().optional(),
+	title: z.string().min(1),
+	description: z.string().optional(),
+	type: z.literal("object"),
+	table: TableConfigSchema,
+	properties: z.record(z.string(), JsonSchemaPropertySchema),
+	required: z.array(z.string()).optional(),
+	examples: z.array(ExamplePairSchema).optional()
+}).refine((schema) => Object.keys(schema.properties).length >= 1, {
+	message: "At least one property is required",
+	path: ["properties"]
+}).refine((schema) => !schema.required || schema.required.every((r) => r in schema.properties), {
+	message: "All required fields must be defined in properties",
+	path: ["required"]
+}).refine((schema) => {
+	return !Object.values(schema.properties).some((p) => p.primary) || Object.values(schema.properties).filter((p) => p.primary).length === 1;
+}, {
+	message: "Only one primary key is allowed per table",
+	path: ["properties"]
+});
+
+//#endregion
+//#region src/domain/ai/schemas.ts
+const ModelCapabilitiesSchema = z.object({
+	vision: z.boolean(),
+	structuredOutput: z.boolean(),
+	maxTokens: z.number().int().positive().optional(),
+	maxOutputTokens: z.number().int().positive().optional()
+});
+const AIModelConfigSchema = z.object({
+	name: z.string().min(1),
+	capabilities: ModelCapabilitiesSchema
+});
+const AIProviderConfigSchema = z.object({
+	baseURL: z.string().min(1),
+	apiKey: z.string(),
+	models: z.array(AIModelConfigSchema).min(1),
+	timeout: z.number().int().positive().default(300).optional()
+});
+const PromptConfigSchema = z.object({
+	systemTemplate: z.string().min(1),
+	userTemplate: z.string().min(1)
+});
+const ExtractionConfigSchema = z.object({ outputDir: z.string().min(1) });
+const ImageOcrFallbackSchema = z.preprocess((value) => [
+	"auto",
+	"off",
+	"local"
+].includes(String(value)) ? "localAuto" : value, z.literal("localAuto").default("localAuto").optional());
+const ImageOcrConfigSchema = z.object({
+	ocrFallback: ImageOcrFallbackSchema,
+	ocrLanguages: z.string().min(1).optional(),
+	ocrMinConfidence: z.number().min(0).max(1).optional()
+});
+const ExternalPdfConverterConfigSchema = z.object({
+	command: z.string().min(1),
+	args: z.array(z.string()).min(1).refine((args) => args.some((arg) => arg.includes("{input}")), { message: "args must contain {input} template variable" }),
+	outputFile: z.string().min(1).optional(),
+	timeout: z.number().int().positive().default(600).optional(),
+	fallbackToUnpdf: z.boolean().optional()
+});
+const MineruApiPdfConverterConfigSchema = z.object({
+	token: z.string(),
+	baseURL: z.string().url().optional(),
+	modelVersion: z.string().optional(),
+	isOcr: z.boolean().optional(),
+	enableFormula: z.boolean().optional(),
+	enableTable: z.boolean().optional()
+});
+const PdfConfigSchema = z.preprocess((value) => {
+	if (!value || typeof value !== "object") return value;
+	const config = { ...value };
+	if (config.converter === "markitdown" && config.markitdown) {
+		config.converter = "external";
+		config.external = config.markitdown;
+	} else if (config.converter === "marker" && config.marker) {
+		config.converter = "external";
+		config.external = config.marker;
+	} else if (config.converter === "markitdown" || config.converter === "marker") config.converter = "unpdf";
+	delete config.markitdown;
+	delete config.marker;
+	return config;
+}, z.object({
+	converter: z.enum([
+		"unpdf",
+		"mineru",
+		"mineru_api",
+		"external"
+	]),
+	mineru: ExternalPdfConverterConfigSchema.optional(),
+	mineruApi: MineruApiPdfConverterConfigSchema.optional(),
+	external: ExternalPdfConverterConfigSchema.optional()
+}));
+const LangfuseConfigSchema = z.object({
+	publicKey: z.string(),
+	secretKey: z.string(),
+	host: z.string().optional()
+});
+const NotionSchemaConfigSchema = z.object({
+	databaseId: z.string(),
+	titleProperty: z.string().optional(),
+	fieldMap: z.record(z.string()).optional()
+});
+const NotionConfigSchema = z.object({
+	enabled: z.boolean(),
+	token: z.string(),
+	schemas: z.record(NotionSchemaConfigSchema).default({})
+});
+const WebhookConfigSchema = z.object({
+	enabled: z.boolean(),
+	url: z.string(),
+	secret: z.string().optional()
+});
+const AIConfigSchema = z.object({
+	provider: AIProviderConfigSchema,
+	prompt: PromptConfigSchema,
+	extraction: ExtractionConfigSchema,
+	image: ImageOcrConfigSchema.optional(),
+	pdf: PdfConfigSchema.optional(),
+	langfuse: LangfuseConfigSchema.optional(),
+	notion: NotionConfigSchema.optional(),
+	webhook: WebhookConfigSchema.optional()
+});
+
+//#endregion
+//#region src/infrastructure/ai/ai-config-store.ts
+const CONFIG_FILE_NAME = "ai-config.json";
+const GITIGNORE_FILE = ".gitignore";
+async function readAIConfig(aiexDir) {
+	const configPath = path.join(aiexDir, CONFIG_FILE_NAME);
+	try {
+		const parsed = await readFile(configPath);
+		return AIConfigSchema.parse(parsed);
+	} catch {
+		return null;
+	}
+}
+async function writeAIConfig(aiexDir, config) {
+	const configPath = path.join(aiexDir, CONFIG_FILE_NAME);
+	await fs.mkdir(aiexDir, { recursive: true });
+	await writeFile(configPath, config, {
+		spaces: 2,
+		EOL: "\n"
+	});
+	await addToGitignore(aiexDir, CONFIG_FILE_NAME);
+}
+function getDefaultAIConfig() {
+	return structuredClone(DEFAULT_AI_CONFIG);
+}
+async function addToGitignore(aiexDir, fileName) {
+	const projectRoot = path.dirname(aiexDir);
+	const gitignorePath = path.join(projectRoot, GITIGNORE_FILE);
+	try {
+		const content = await fs.readFile(gitignorePath, "utf-8");
+		if (content.split("\n").some((line) => line.trim() === fileName || line.includes(".aiex/"))) return;
+		const newContent = content.endsWith("\n") ? `${content}${fileName}\n` : `${content}\n${fileName}\n`;
+		await fs.writeFile(gitignorePath, newContent);
+	} catch {
+		await fs.writeFile(gitignorePath, `${fileName}\n`);
+	}
+}
+
+//#endregion
+//#region src/locales/en.ts
+const en = {
+	common: {
+		done: "Done!",
+		failed: "Failed!",
+		cancelled: "Cancelled",
+		save: "Save",
+		cancel: "Cancel",
+		delete: "Delete",
+		close: "Close",
+		loading: "Loading...",
+		unknownError: "Unknown error"
+	},
+	cli: { description: "JSON Schema → SQLite with AI-powered data extraction" },
+	command: {
+		web: {
+			description: "Start visual JSON Schema editor",
+			args: { port: "Port to listen on" },
+			starting: "Starting web server...",
 			serverRunning: "Server running at {{url}}",
 			schemaDir: "Schema directory: {{path}}",
 			pressCtrlC: "Press Ctrl+C to stop",
@@ -959,7 +1273,7 @@ function t(key, options) {
 }
 
 //#endregion
-//#region src/core/image-ocr/index.ts
+//#region src/infrastructure/ocr/system-ocr.ts
 const DEFAULT_OCR_LANGUAGES = "en-US, zh-Hans";
 const SELF_CHECK_EXPECTED_TEXT = "AIEX";
 const defaultRuntime = {
@@ -983,417 +1297,87 @@ function shouldUseImageOcrFallback(aiConfig, modelOverride, runtime = defaultRun
 function isLocalOcrPlatform(platform) {
 	return platform === "darwin" || platform === "win32";
 }
-function parseOcrLanguages(languages) {
-	return (languages ?? DEFAULT_OCR_LANGUAGES).split(",").map((language) => language.trim()).filter(Boolean);
-}
-async function recognizeImageText(imagePath, config, runtime = defaultRuntime) {
-	if (!isLocalOcrPlatform(runtime.platform)) throw new Error(t("errors.ocr.platformUnsupported", { platform: runtime.platform }));
-	let localOcr;
-	try {
-		localOcr = await runtime.loadLocalOcr();
-	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error);
-		throw new Error(t("errors.ocr.unavailable", { error: message }));
-	}
-	const result = await localOcr.recognize(imagePath, localOcr.OcrAccuracy.Accurate, parseOcrLanguages(config?.ocrLanguages));
-	const text = result.text.trim();
-	if (!text) throw new Error(t("errors.ocr.noText"));
-	const confidence = result.confidence;
-	const minConfidence = config?.ocrMinConfidence ?? 0;
-	if (confidence < minConfidence) throw new Error(t("errors.ocr.lowConfidence", {
-		confidence: (confidence * 100).toFixed(1),
-		min: (minConfidence * 100).toFixed(1)
-	}));
-	return {
-		text,
-		confidence
-	};
-}
-function normalizeOcrText(text) {
-	return text.replace(/\s+/g, "").trim().toUpperCase();
-}
-async function checkImageOcrAvailability(imagePath, runtime = defaultRuntime) {
-	if (!isLocalOcrPlatform(runtime.platform)) return {
-		platformSupported: false,
-		dependencyLoaded: false,
-		ocrOk: null,
-		imagePath,
-		error: t("errors.ocr.platformUnsupported", { platform: runtime.platform })
-	};
-	let localOcr;
-	try {
-		localOcr = await runtime.loadLocalOcr();
-	} catch (error) {
-		return {
-			platformSupported: true,
-			dependencyLoaded: false,
-			ocrOk: null,
-			imagePath,
-			error: error instanceof Error ? error.message : String(error)
-		};
-	}
-	if (!imagePath) return {
-		platformSupported: true,
-		dependencyLoaded: true,
-		ocrOk: null,
-		error: "No OCR self-check image was found."
-	};
-	try {
-		const result = await localOcr.recognize(imagePath, localOcr.OcrAccuracy.Accurate, ["en-US"]);
-		const recognizedText = result.text.trim();
-		const ocrOk = normalizeOcrText(recognizedText).includes(SELF_CHECK_EXPECTED_TEXT);
-		return {
-			platformSupported: true,
-			dependencyLoaded: true,
-			ocrOk,
-			imagePath,
-			recognizedText,
-			confidence: result.confidence,
-			error: ocrOk ? void 0 : `Expected OCR text "${SELF_CHECK_EXPECTED_TEXT}" was not recognized.`
-		};
-	} catch (error) {
-		return {
-			platformSupported: true,
-			dependencyLoaded: true,
-			ocrOk: false,
-			imagePath,
-			error: error instanceof Error ? error.message : String(error)
-		};
-	}
-}
-
-//#endregion
-//#region src/core/schema-sqlite/generator.ts
-function generateColumnDefinition(column) {
-	if (column.isPrimary && column.isAutoIncrement) return `  ${column.name}: integer().primaryKey({ autoIncrement: true })`;
-	let def = `  ${column.name}: ${column.drizzleType}`;
-	if (column.isPrimary) def += ".primaryKey()";
-	if (!column.isNullable && !column.isPrimary) def += ".notNull()";
-	if (column.isUnique && !column.isPrimary) def += ".unique()";
-	if (column.defaultValue !== void 0) def += `.default(${column.defaultValue})`;
-	if (column.isForeignKey && column.foreignKeyRef) def += `.references(() => ${column.foreignKeyRef.table}.${column.foreignKeyRef.column})`;
-	return def;
-}
-function generateTableDefinition(table) {
-	const columns = table.columns.map(generateColumnDefinition);
-	return `export const ${table.name} = sqliteTable('${table.name}', {\n${columns.join(",\n")}\n})`;
-}
-function generateRelationDefinitions(relations, reverseRelations) {
-	if (relations.length === 0 && reverseRelations.length === 0) return "";
-	const definitions = [];
-	const childByTable = /* @__PURE__ */ new Map();
-	for (const rel of relations) {
-		const list = childByTable.get(rel.fromTable) ?? [];
-		list.push(rel);
-		childByTable.set(rel.fromTable, list);
-	}
-	const parentByTable = /* @__PURE__ */ new Map();
-	for (const rel of reverseRelations) {
-		const list = parentByTable.get(rel.fromTable) ?? [];
-		list.push(rel);
-		parentByTable.set(rel.fromTable, list);
-	}
-	const allTableNames = new Set([...childByTable.keys(), ...parentByTable.keys()]);
-	for (const tableName of allTableNames) {
-		const childRels = childByTable.get(tableName) ?? [];
-		const parentRels = parentByTable.get(tableName) ?? [];
-		const needsOne = childRels.length > 0 || parentRels.some((r) => r.type === "has-one");
-		const needsMany = parentRels.some((r) => r.type === "has-many");
-		const imports = [];
-		if (needsOne) imports.push("one");
-		if (needsMany) imports.push("many");
-		const importStr = imports.join(", ");
-		const relDefs = [];
-		for (const rel of childRels) relDefs.push(`    ${rel.name}: one(${rel.toTable}, {\n      fields: [${rel.fromTable}.${rel.fromColumn}],\n      references: [${rel.toTable}.${rel.toColumn}],\n    })`);
-		for (const rel of parentRels) if (rel.type === "has-many") relDefs.push(`    ${rel.name}: many(${rel.toTable})`);
-		else relDefs.push(`    ${rel.name}: one(${rel.toTable})`);
-		definitions.push(`export const ${tableName}Relations = relations(${tableName}, ({ ${importStr} }) => ({\n${relDefs.join(",\n")}\n}))`);
-	}
-	return definitions.join("\n\n");
-}
-function generateDrizzleSchema(result) {
-	const imports = `import { sqliteTable, text, integer, real } from 'drizzle-orm/sqlite-core'\nimport { relations } from 'drizzle-orm'`;
-	const tableDefs = result.tables.map(generateTableDefinition).join("\n\n");
-	const relationDefs = generateRelationDefinitions(result.relations, result.reverseRelations);
-	const parts = [
-		imports,
-		"",
-		tableDefs
-	];
-	if (relationDefs) parts.push("", relationDefs);
-	parts.push("");
-	return parts.join("\n");
-}
-
-//#endregion
-//#region src/core/schema-sqlite/parser.ts
-function toSnakeCase(str) {
-	return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
-}
-function mapPropertyToColumn(name$1, property, isRequired) {
-	const snakeName = toSnakeCase(name$1);
-	let drizzleType;
-	const isPrimary = property.primary ?? false;
-	const isAutoIncrement = property.autoIncrement ?? false;
-	switch (property.type) {
-		case "string": {
-			const format = property.format;
-			if (format === "date-time" || property.drizzle?.mode === "timestamp") drizzleType = `integer({ mode: 'timestamp' })`;
-			else if (format === "json" || property.drizzle?.mode === "json") drizzleType = `text({ mode: 'json' })`;
-			else drizzleType = "text()";
-			break;
-		}
-		case "integer": {
-			const mode = property.drizzle?.mode;
-			if (mode === "boolean") drizzleType = `integer({ mode: 'boolean' })`;
-			else if (mode === "timestamp" || mode === "timestamp_ms") drizzleType = `integer({ mode: '${mode}' })`;
-			else if (mode === "bigint") drizzleType = `integer({ mode: 'bigint' })`;
-			else drizzleType = "integer()";
-			break;
-		}
-		case "number":
-			drizzleType = "real()";
-			break;
-		case "boolean":
-			drizzleType = `integer({ mode: 'boolean' })`;
-			break;
-		case "object":
-		case "array":
-			drizzleType = `text({ mode: 'json' })`;
-			break;
-		case "null":
-			drizzleType = "text()";
-			break;
-		default: drizzleType = "text()";
-	}
-	return {
-		name: snakeName,
-		drizzleType,
-		isPrimary,
-		isAutoIncrement,
-		isNullable: !isRequired && !isPrimary,
-		isUnique: property.unique ?? false,
-		defaultValue: property.default !== void 0 ? JSON.stringify(property.default) : void 0,
-		isForeignKey: property.foreignKey !== void 0,
-		foreignKeyRef: property.foreignKey ?? void 0
-	};
-}
-function parseObjectToTable(schema, _warnings) {
-	const tableName = schema.table.name;
-	const columns = [];
-	const requiredFields = new Set(schema.required ?? []);
-	const autoColumns = /* @__PURE__ */ new Set();
-	if (schema.table.timestamps) {
-		autoColumns.add("created_at");
-		autoColumns.add("updated_at");
-	}
-	if (schema.table.softDelete) autoColumns.add("deleted_at");
-	for (const [propName, prop] of Object.entries(schema.properties)) {
-		if (prop.nested?.enabled && (prop.type === "object" || prop.type === "array")) continue;
-		if (prop.type === "array" && prop.items?.nested?.enabled) continue;
-		const snakeName = toSnakeCase(propName);
-		if (autoColumns.has(snakeName)) continue;
-		const column = mapPropertyToColumn(propName, prop, requiredFields.has(propName));
-		columns.push(column);
-	}
-	if (schema.table.timestamps) {
-		columns.push({
-			name: "created_at",
-			drizzleType: `integer({ mode: 'timestamp' })`,
-			isPrimary: false,
-			isAutoIncrement: false,
-			isNullable: false,
-			isUnique: false,
-			defaultValue: void 0
-		});
-		columns.push({
-			name: "updated_at",
-			drizzleType: `integer({ mode: 'timestamp' })`,
-			isPrimary: false,
-			isAutoIncrement: false,
-			isNullable: false,
-			isUnique: false,
-			defaultValue: void 0
-		});
-	}
-	if (schema.table.softDelete) columns.push({
-		name: "deleted_at",
-		drizzleType: `integer({ mode: 'timestamp' })`,
-		isPrimary: false,
-		isAutoIncrement: false,
-		isNullable: true,
-		isUnique: false,
-		defaultValue: void 0
-	});
-	return {
-		name: tableName,
-		columns
-	};
-}
-function parseNestedObject(propName, property, parentTableName, warnings) {
-	const nestedTableName = `${parentTableName}_${toSnakeCase(propName)}`;
-	const columns = [];
-	const relationType = property.nested?.relation === "has-many" ? "has-many" : "has-one";
-	columns.push({
-		name: "id",
-		drizzleType: "integer()",
-		isPrimary: true,
-		isAutoIncrement: true,
-		isNullable: false,
-		isUnique: false,
-		defaultValue: void 0
-	});
-	columns.push({
-		name: `${parentTableName}_id`,
-		drizzleType: "integer()",
-		isPrimary: false,
-		isAutoIncrement: false,
-		isNullable: false,
-		isUnique: false,
-		defaultValue: void 0,
-		isForeignKey: true,
-		foreignKeyRef: {
-			table: parentTableName,
-			column: "id"
-		}
-	});
-	if (property.type === "object" && property.properties) for (const [childName, childProp] of Object.entries(property.properties)) {
-		if (childProp.nested?.enabled) {
-			warnings.push(`Nested property "${childName}" inside "${nestedTableName}" is skipped — only one level of nesting is supported. Remove nested.enabled or use drizzle.mode: 'json' instead.`);
-			continue;
-		}
-		const column = mapPropertyToColumn(childName, childProp, false);
-		columns.push(column);
+function parseOcrLanguages(languages) {
+	return (languages ?? DEFAULT_OCR_LANGUAGES).split(",").map((language) => language.trim()).filter(Boolean);
+}
+async function recognizeImageText(imagePath, config, runtime = defaultRuntime) {
+	if (!isLocalOcrPlatform(runtime.platform)) throw new Error(t("errors.ocr.platformUnsupported", { platform: runtime.platform }));
+	let localOcr;
+	try {
+		localOcr = await runtime.loadLocalOcr();
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		throw new Error(t("errors.ocr.unavailable", { error: message }));
 	}
-	const relation = {
-		fromTable: nestedTableName,
-		fromColumn: `${parentTableName}_id`,
-		toTable: parentTableName,
-		toColumn: "id",
-		name: parentTableName
-	};
-	const reverseRelation = {
-		type: relationType,
-		fromTable: parentTableName,
-		toTable: nestedTableName,
-		name: toSnakeCase(propName)
-	};
+	const result = await localOcr.recognize(imagePath, localOcr.OcrAccuracy.Accurate, parseOcrLanguages(config?.ocrLanguages));
+	const text = result.text.trim();
+	if (!text) throw new Error(t("errors.ocr.noText"));
+	const confidence = result.confidence;
+	const minConfidence = config?.ocrMinConfidence ?? 0;
+	if (confidence < minConfidence) throw new Error(t("errors.ocr.lowConfidence", {
+		confidence: (confidence * 100).toFixed(1),
+		min: (minConfidence * 100).toFixed(1)
+	}));
 	return {
-		table: {
-			name: nestedTableName,
-			columns
-		},
-		relation,
-		reverseRelation
+		text,
+		confidence
 	};
 }
-function parseJsonSchema(schema) {
-	const tables = [];
-	const relations = [];
-	const reverseRelations = [];
-	const warnings = [];
-	const mainTable = parseObjectToTable(schema, warnings);
-	tables.push(mainTable);
-	for (const [propName, prop] of Object.entries(schema.properties)) if (prop.type === "object" && prop.nested?.enabled) {
-		const nested = parseNestedObject(propName, prop, mainTable.name, warnings);
-		tables.push(nested.table);
-		relations.push(nested.relation);
-		reverseRelations.push(nested.reverseRelation);
-	} else if (prop.type === "array" && prop.items?.nested?.enabled && prop.items?.type === "object" && prop.items.properties) {
-		const nested = parseNestedObject(propName, prop.items, mainTable.name, warnings);
-		tables.push(nested.table);
-		relations.push(nested.relation);
-		reverseRelations.push(nested.reverseRelation);
+function normalizeOcrText(text) {
+	return text.replace(/\s+/g, "").trim().toUpperCase();
+}
+async function checkImageOcrAvailability(imagePath, runtime = defaultRuntime) {
+	if (!isLocalOcrPlatform(runtime.platform)) return {
+		platformSupported: false,
+		dependencyLoaded: false,
+		ocrOk: null,
+		imagePath,
+		error: t("errors.ocr.platformUnsupported", { platform: runtime.platform })
+	};
+	let localOcr;
+	try {
+		localOcr = await runtime.loadLocalOcr();
+	} catch (error) {
+		return {
+			platformSupported: true,
+			dependencyLoaded: false,
+			ocrOk: null,
+			imagePath,
+			error: error instanceof Error ? error.message : String(error)
+		};
 	}
-	return {
-		tables,
-		relations,
-		reverseRelations,
-		warnings
+	if (!imagePath) return {
+		platformSupported: true,
+		dependencyLoaded: true,
+		ocrOk: null,
+		error: "No OCR self-check image was found."
 	};
+	try {
+		const result = await localOcr.recognize(imagePath, localOcr.OcrAccuracy.Accurate, ["en-US"]);
+		const recognizedText = result.text.trim();
+		const ocrOk = normalizeOcrText(recognizedText).includes(SELF_CHECK_EXPECTED_TEXT);
+		return {
+			platformSupported: true,
+			dependencyLoaded: true,
+			ocrOk,
+			imagePath,
+			recognizedText,
+			confidence: result.confidence,
+			error: ocrOk ? void 0 : `Expected OCR text "${SELF_CHECK_EXPECTED_TEXT}" was not recognized.`
+		};
+	} catch (error) {
+		return {
+			platformSupported: true,
+			dependencyLoaded: true,
+			ocrOk: false,
+			imagePath,
+			error: error instanceof Error ? error.message : String(error)
+		};
+	}
 }
 
 //#endregion
-//#region src/core/schema-sqlite/schemas.ts
-const DrizzleModeSchema = z.enum([
-	"json",
-	"timestamp",
-	"timestamp_ms",
-	"boolean",
-	"bigint"
-]);
-const DrizzleExtensionSchema = z.object({
-	mode: DrizzleModeSchema.optional(),
-	customType: z.string().optional()
-}).optional();
-const NestedConfigSchema = z.object({
-	enabled: z.literal(true),
-	relation: z.enum(["has-one", "has-many"])
-});
-const ForeignKeyRefSchema = z.object({
-	table: z.string().min(1),
-	column: z.string().min(1)
-});
-const JsonSchemaPropertySchema = z.lazy(() => z.object({
-	description: z.string().optional(),
-	type: z.enum([
-		"string",
-		"integer",
-		"number",
-		"boolean",
-		"object",
-		"array",
-		"null"
-	]),
-	format: z.string().optional(),
-	primary: z.boolean().optional(),
-	autoIncrement: z.boolean().optional(),
-	unique: z.boolean().optional(),
-	default: z.unknown().optional(),
-	maxLength: z.number().int().positive().optional(),
-	minLength: z.number().int().nonnegative().optional(),
-	minimum: z.number().optional(),
-	maximum: z.number().optional(),
-	drizzle: DrizzleExtensionSchema,
-	nested: NestedConfigSchema.optional(),
-	foreignKey: ForeignKeyRefSchema.optional(),
-	properties: z.record(z.string(), JsonSchemaPropertySchema).optional(),
-	items: JsonSchemaPropertySchema.optional(),
-	required: z.array(z.string()).optional()
-}));
-const TableConfigSchema = z.object({
-	name: z.string().min(1).regex(/^[a-z][a-z0-9_]*$/, "Table name must be snake_case (lowercase letters, digits, underscores)"),
-	timestamps: z.boolean().optional(),
-	softDelete: z.boolean().optional()
-});
-const ExamplePairSchema = z.object({
-	text: z.string().min(1),
-	output: z.record(z.string(), z.unknown())
-});
-const JsonSchemaDefinitionSchema = z.object({
-	$schema: z.string().optional(),
-	title: z.string().min(1),
-	description: z.string().optional(),
-	type: z.literal("object"),
-	table: TableConfigSchema,
-	properties: z.record(z.string(), JsonSchemaPropertySchema),
-	required: z.array(z.string()).optional(),
-	examples: z.array(ExamplePairSchema).optional()
-}).refine((schema) => Object.keys(schema.properties).length >= 1, {
-	message: "At least one property is required",
-	path: ["properties"]
-}).refine((schema) => !schema.required || schema.required.every((r) => r in schema.properties), {
-	message: "All required fields must be defined in properties",
-	path: ["required"]
-}).refine((schema) => {
-	return !Object.values(schema.properties).some((p) => p.primary) || Object.values(schema.properties).filter((p) => p.primary).length === 1;
-}, {
-	message: "Only one primary key is allowed per table",
-	path: ["properties"]
-});
-
-//#endregion
-//#region src/core/schema-sqlite/migrator.ts
+//#region src/infrastructure/schema/migration-config.ts
 function createMigrationConfig(cwd) {
 	return {
 		schemaPath: `${cwd}/.aiex/schema`,
@@ -1416,7 +1400,7 @@ function generateDrizzleConfig() {
 }
 
 //#endregion
-//#region src/core/doctor-collector.ts
+//#region src/application/doctor/collect-diagnostics.ts
 const V1_SUFFIX_RE = /\/v1\/?$/;
 const MODULE_DIR = path.dirname(fileURLToPath(import.meta.url));
 async function checkConnection(baseURL) {
@@ -1593,4 +1577,98 @@ async function collectDoctorDiagnostics(options = {}) {
 }
 
 //#endregion
-export { description as C, buildDoctorDiagnostics as D, version as E, doctorDiagnosticsTableRows as O, seedConfig as S, package_default as T, DEFAULT_PROMPT_CONFIG as _, parseJsonSchema as a, AIConfigSchema as b, recognizeImageText as c, t as d, getDefaultAIConfig as f, DEFAULT_MINERU_CONFIG as g, DEFAULT_MINERU_API_CONFIG as h, JsonSchemaDefinitionSchema as i, formatDoctorDiagnosticsJson as k, shouldUseImageOcrFallback as l, writeAIConfig as m, createMigrationConfig as n, toSnakeCase as o, readAIConfig as p, generateDrizzleConfig as r, generateDrizzleSchema as s, collectDoctorDiagnostics as t, initI18n as u, PLACEHOLDER_SCHEMA as v, name as w, createConfig as x, PLACEHOLDER_TEXT as y };
+//#region src/infrastructure/schema/generate-drizzle-schema.ts
+function renderColumnType(ct) {
+	switch (ct.class) {
+		case "text": return ct.mode === "json" ? `text({ mode: 'json' })` : "text()";
+		case "integer": return ct.mode ? `integer({ mode: '${ct.mode}' })` : "integer()";
+		case "real": return "real()";
+	}
+}
+function renderDefaultValue(value) {
+	return JSON.stringify(value);
+}
+function generateColumnDefinition(column) {
+	if (column.isPrimary && column.isAutoIncrement) return `  ${column.name}: integer().primaryKey({ autoIncrement: true })`;
+	let def = `  ${column.name}: ${renderColumnType(column.columnType)}`;
+	if (column.isPrimary) def += ".primaryKey()";
+	if (!column.isNullable && !column.isPrimary) def += ".notNull()";
+	if (column.isUnique && !column.isPrimary) def += ".unique()";
+	if (column.default !== void 0) def += `.default(${renderDefaultValue(column.default)})`;
+	if (column.isForeignKey && column.foreignKeyRef) def += `.references(() => ${column.foreignKeyRef.table}.${column.foreignKeyRef.column})`;
+	return def;
+}
+function renderCheckToDrizzle(check, tableVar) {
+	const colRef = `\${${tableVar}.${check.column}}`;
+	let expr;
+	switch (check.kind) {
+		case "min_length":
+			expr = `length(${colRef}) >= ${check.value}`;
+			break;
+		case "max_length":
+			expr = `length(${colRef}) <= ${check.value}`;
+			break;
+		case "min_value":
+			expr = `${colRef} >= ${check.value}`;
+			break;
+		case "max_value":
+			expr = `${colRef} <= ${check.value}`;
+			break;
+	}
+	return `    ${check.name}: check('${check.name}', sql\`${expr}\`)`;
+}
+function generateTableDefinition(table) {
+	const columns = table.columns.map(generateColumnDefinition);
+	if (!table.checks?.length) return `export const ${table.name} = sqliteTable('${table.name}', {\n${columns.join(",\n")}\n})`;
+	const checkLines = table.checks.map((c) => renderCheckToDrizzle(c, "table"));
+	return `export const ${table.name} = sqliteTable('${table.name}', {\n${columns.join(",\n")}\n}, (table) => ({\n${checkLines.join(",\n")}\n}))`;
+}
+function generateRelationDefinitions(relations, reverseRelations) {
+	if (relations.length === 0 && reverseRelations.length === 0) return "";
+	const definitions = [];
+	const childByTable = /* @__PURE__ */ new Map();
+	for (const rel of relations) {
+		const list = childByTable.get(rel.fromTable) ?? [];
+		list.push(rel);
+		childByTable.set(rel.fromTable, list);
+	}
+	const parentByTable = /* @__PURE__ */ new Map();
+	for (const rel of reverseRelations) {
+		const list = parentByTable.get(rel.fromTable) ?? [];
+		list.push(rel);
+		parentByTable.set(rel.fromTable, list);
+	}
+	const allTableNames = new Set([...childByTable.keys(), ...parentByTable.keys()]);
+	for (const tableName of allTableNames) {
+		const childRels = childByTable.get(tableName) ?? [];
+		const parentRels = parentByTable.get(tableName) ?? [];
+		const needsOne = childRels.length > 0 || parentRels.some((r) => r.type === "has-one");
+		const needsMany = parentRels.some((r) => r.type === "has-many");
+		const imports = [];
+		if (needsOne) imports.push("one");
+		if (needsMany) imports.push("many");
+		const importStr = imports.join(", ");
+		const relDefs = [];
+		for (const rel of childRels) relDefs.push(`    ${rel.name}: one(${rel.toTable}, {\n      fields: [${rel.fromTable}.${rel.fromColumn}],\n      references: [${rel.toTable}.${rel.toColumn}],\n    })`);
+		for (const rel of parentRels) if (rel.type === "has-many") relDefs.push(`    ${rel.name}: many(${rel.toTable})`);
+		else relDefs.push(`    ${rel.name}: one(${rel.toTable})`);
+		definitions.push(`export const ${tableName}Relations = relations(${tableName}, ({ ${importStr} }) => ({\n${relDefs.join(",\n")}\n}))`);
+	}
+	return definitions.join("\n\n");
+}
+function generateDrizzleSchema(result) {
+	const imports = `import { ${`sqliteTable, text, integer, real${result.tables.some((t$1) => t$1.checks?.length) ? ", check, sql" : ""}`} } from 'drizzle-orm/sqlite-core'\nimport { relations } from 'drizzle-orm'`;
+	const tableDefs = result.tables.map(generateTableDefinition).join("\n\n");
+	const relationDefs = generateRelationDefinitions(result.relations, result.reverseRelations);
+	const parts = [
+		imports,
+		"",
+		tableDefs
+	];
+	if (relationDefs) parts.push("", relationDefs);
+	parts.push("");
+	return parts.join("\n");
+}
+
+//#endregion
+export { PLACEHOLDER_TEXT as C, name as D, description as E, package_default as O, PLACEHOLDER_SCHEMA as S, seedConfig as T, doctorDiagnosticsTableRows as _, recognizeImageText as a, DEFAULT_MINERU_CONFIG as b, t as c, writeAIConfig as d, AIConfigSchema as f, buildDoctorDiagnostics as g, toSnakeCase as h, generateDrizzleConfig as i, version 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, formatDoctorDiagnosticsJson as v, createConfig as w, DEFAULT_PROMPT_CONFIG as x, DEFAULT_MINERU_API_CONFIG as y };