aiex-cli 0.0.1-beta.27 → 0.0.1-beta.29

package/dist/cli.mjs

@@ -1,24 +1,29 @@
-import { C as formatDoctorDiagnosticsJson, S as doctorDiagnosticsTableRows, _ as JsonSchemaDefinitionSchema, a as DEFAULT_PROMPT_CONFIG, b as generateDrizzleSchema, c as AIConfigSchema, d as description, f as name, h as createMigrationConfig, i as writeAIConfig, l as createConfig, m as version, n as getDefaultAIConfig, o as PLACEHOLDER_SCHEMA, p as package_default, r as readAIConfig, s as PLACEHOLDER_TEXT, t as collectDoctorDiagnostics, u as seedConfig, v as parseJsonSchema, y as toSnakeCase } from "./doctor-IvHYLDX6.mjs";
+import { C as doctorDiagnosticsTableRows, _ as seedConfig, a as parseJsonSchema, b as package_default, c as getDefaultAIConfig, d as DEFAULT_MINERU_CONFIG, f as DEFAULT_PROMPT_CONFIG, g as createConfig, h as AIConfigSchema, i as JsonSchemaDefinitionSchema, l as readAIConfig, m as PLACEHOLDER_TEXT, n as createMigrationConfig, o as toSnakeCase, p as PLACEHOLDER_SCHEMA, s as generateDrizzleSchema, t as collectDoctorDiagnostics, u as writeAIConfig, v as description, w as formatDoctorDiagnosticsJson, x as version, y as name } from "./doctor-collector-j2dG7dG1.mjs";
 import { createRequire } from "node:module";
+import fs from "node:fs/promises";
+import os from "node:os";
 import path from "node:path";
 import process from "node:process";
-import { fileURLToPath } from "node:url";
 import { ZodError } from "zod";
-import fs from "node:fs/promises";
+import { fileURLToPath } from "node:url";
 import { defineCommand, runMain } from "citty";
 import { consola } from "consola";
 import updateNotifier from "update-notifier";
 import CliTable3 from "cli-table3";
-import { intro, outro, spinner } from "@clack/prompts";
-import Database from "better-sqlite3";
+import { intro, isCancel, outro, select, spinner, text } from "@clack/prompts";
 import pc from "picocolors";
 import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
 import { LangfuseSpanProcessor } from "@langfuse/otel";
 import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
 import { APICallError, Output, generateText, jsonSchema } from "ai";
+import pRetry from "p-retry";
+import fs$1 from "node:fs";
+import Database from "better-sqlite3";
+import picomatch from "picomatch";
+import { execa } from "execa";
 import { Buffer } from "node:buffer";
 import { extractText, getMeta } from "unpdf";
-import { exec, execFile } from "node:child_process";
+import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import { serve } from "@hono/node-server";
 import { serveStatic } from "@hono/node-server/serve-static";
@@ -100,7 +105,7 @@ function parseAllSchemas(entries) {
 }
 
 //#endregion
-//#region src/commands/completion.ts
+//#region src/core/completion-scripts.ts
 function bashScript(name$1) {
 	return `# ${name$1} bash completion
 _${name$1}() {
@@ -127,7 +132,7 @@ function fishScript(name$1) {
 complete -c ${name$1} -f -a '(${name$1} _complete (commandline -cp) 2>/dev/null)'
 `;
 }
-function generateScript(name$1, shell) {
+function generateCompletionScript(name$1, shell) {
 	switch (shell) {
 		case "bash": return bashScript(name$1);
 		case "zsh": return zshScript(name$1);
@@ -135,6 +140,9 @@ function generateScript(name$1, shell) {
 		default: throw new Error(`Unsupported shell: ${shell}. Use bash, zsh, or fish.`);
 	}
 }
+
+//#endregion
+//#region src/commands/completion.ts
 const completionCommand = defineCommand({
 	meta: {
 		name: "completion",
@@ -149,7 +157,7 @@ const completionCommand = defineCommand({
 		const name$1 = "aiex";
 		const shell = args.shell;
 		try {
-			process.stdout.write(generateScript(name$1, shell));
+			process.stdout.write(generateCompletionScript(name$1, shell));
 		} catch (error) {
 			process.stderr.write(`Error: ${error instanceof Error ? error.message : String(error)}\n`);
 			process.exit(1);
@@ -189,6 +197,14 @@ const doctorCommand = defineCommand({
 	}
 });
 
+//#endregion
+//#region src/commands/utils.ts
+function failCommand(message) {
+	if (message) consola.error(message);
+	outro("Failed!");
+	process.exitCode = 1;
+}
+
 //#endregion
 //#region src/core/ai-extraction/model-capabilities.json
 var model_capabilities_default = {
@@ -12767,29 +12783,31 @@ function lookupModelCapabilities(modelName) {
 //#endregion
 //#region src/utils/retry.ts
 async function withRetry(fn, onRetry, maxRetries = 5) {
-	let lastError;
-	for (let attempt = 0; attempt <= maxRetries; attempt++) try {
-		return await fn();
-	} catch (error) {
-		const err = error instanceof Error ? error : new Error(String(error));
-		lastError = err;
-		if (!(err instanceof APICallError && err.isRetryable && attempt < maxRetries)) throw err;
-		const delayMs = 1e3 * 2 ** attempt + Math.round(Math.random() * 500);
-		onRetry?.({
-			attempt: attempt + 1,
-			maxRetries,
-			delayMs,
-			statusCode: err.statusCode
-		});
-		await new Promise((resolve) => setTimeout(resolve, delayMs));
-	}
-	throw lastError ?? /* @__PURE__ */ new Error("Retry failed after all attempts");
+	return pRetry(async () => fn(), {
+		retries: maxRetries,
+		factor: 2,
+		minTimeout: 1e3,
+		randomize: true,
+		onFailedAttempt({ error, attemptNumber, retriesLeft }) {
+			if (!(error instanceof APICallError) || !error.isRetryable || retriesLeft <= 0) return;
+			const baseDelayMs = 1e3 * 2 ** (attemptNumber - 1);
+			onRetry?.({
+				attempt: attemptNumber,
+				maxRetries,
+				delayMs: baseDelayMs,
+				statusCode: error.statusCode
+			});
+		},
+		shouldRetry({ error }) {
+			return error instanceof APICallError && error.isRetryable;
+		}
+	});
 }
 
 //#endregion
 //#region src/core/ai-extraction/json-utils.ts
-function stripFences(text) {
-	const trimmed = text.trim();
+function stripFences(text$1) {
+	const trimmed = text$1.trim();
 	if (!trimmed.startsWith("```")) return null;
 	const endIndex = trimmed.lastIndexOf("```");
 	if (endIndex <= 3) return null;
@@ -12798,8 +12816,8 @@ function stripFences(text) {
 	if (firstNewline === -1) return null;
 	return inside.slice(firstNewline + 1).trim();
 }
-function extractFirstJSON(text) {
-	const trimmed = text.trim();
+function extractFirstJSON(text$1) {
+	const trimmed = text$1.trim();
 	const firstBrace = trimmed.indexOf("{");
 	const firstBracket = trimmed.indexOf("[");
 	let start = -1;
@@ -12810,8 +12828,8 @@ function extractFirstJSON(text) {
 	if (end <= start) return null;
 	return trimmed.slice(start, end);
 }
-function safeParseJSON(text) {
-	const cleaned = text.trim();
+function safeParseJSON(text$1) {
+	const cleaned = text$1.trim();
 	try {
 		return JSON.parse(cleaned);
 	} catch {}
@@ -12823,7 +12841,7 @@ function safeParseJSON(text) {
 	if (extracted) try {
 		return JSON.parse(extracted);
 	} catch {}
-	const truncated = text.length > 200 ? `${text.slice(0, 200)}...` : text;
+	const truncated = text$1.length > 200 ? `${text$1.slice(0, 200)}...` : text$1;
 	throw new Error(`Failed to parse JSON from model output. Expected a valid JSON object or array but received unparseable text. Raw output: ${truncated}`);
 }
 
@@ -12911,11 +12929,11 @@ function schemaToDescription(schema) {
 	}
 	return lines.join("\n");
 }
-function generateExtractionPrompt(schema, text, promptConfig = DEFAULT_PROMPT_CONFIG) {
+function generateExtractionPrompt(schema, text$1, promptConfig = DEFAULT_PROMPT_CONFIG) {
 	const schemaDescription = schemaToDescription(schema);
 	return {
 		system: promptConfig.systemTemplate.replaceAll(PLACEHOLDER_SCHEMA, schemaDescription),
-		user: promptConfig.userTemplate.replaceAll(PLACEHOLDER_TEXT, text)
+		user: promptConfig.userTemplate.replaceAll(PLACEHOLDER_TEXT, text$1)
 	};
 }
 function generatePromptSnapshot(schema, promptConfig = DEFAULT_PROMPT_CONFIG) {
@@ -13098,14 +13116,14 @@ async function loadPromptSnapshot(aiexDir, tableName) {
 	return null;
 }
 async function extractStructuredData(input) {
-	const { config, schema, text, aiexDir, file, modelOverride } = input;
+	const { config, schema, text: text$1, aiexDir, file, modelOverride } = input;
 	if (!config.provider.apiKey) return {
 		success: false,
 		error: "API Key not configured. Please configure AI settings in the web UI."
 	};
 	const useFileContent = !!file;
 	const isImageFile = useFileContent && detectMimeType(file).startsWith("image/");
-	const inputTokens = text ? Math.ceil(text.length / 2) : void 0;
+	const inputTokens = text$1 ? Math.ceil(text$1.length / 2) : void 0;
 	const fieldCount = schema.properties ? Object.keys(schema.properties).length : 0;
 	const outputTokens = fieldCount > 0 ? fieldCount * 80 : void 0;
 	let selected;
@@ -13135,7 +13153,7 @@ async function extractStructuredData(input) {
 		let system;
 		let user;
 		const snapshot = await loadPromptSnapshot(aiexDir, schema.table.name);
-		const promptText = file ? PLACEHOLDER_TEXT : text;
+		const promptText = file ? PLACEHOLDER_TEXT : text$1;
 		if (snapshot) {
 			system = snapshot.system;
 			user = snapshot.user.replaceAll(PLACEHOLDER_TEXT, promptText);
@@ -13152,7 +13170,7 @@ async function extractStructuredData(input) {
 			const fileName = filePart.type === "file" ? filePart.filename : path.basename(file);
 			const contentParts = [{
 				type: "text",
-				text: user.includes(PLACEHOLDER_TEXT) ? user.replaceAll(PLACEHOLDER_TEXT, text || `Data is contained in the attached file: ${fileName}`) : user
+				text: user.includes(PLACEHOLDER_TEXT) ? user.replaceAll(PLACEHOLDER_TEXT, text$1 || `Data is contained in the attached file: ${fileName}`) : user
 			}, filePart];
 			const fileOpts = {
 				model: provider.chatModel(selected.name),
@@ -13360,6 +13378,97 @@ async function savePromptSnapshot(schema, aiexDir) {
 	return outputPath;
 }
 
+//#endregion
+//#region src/core/pdf-converter/external.ts
+function applyTemplate(value, context) {
+	return value.replaceAll("{input}", context.input).replaceAll("{outputDir}", context.outputDir).replaceAll("{basename}", context.basename);
+}
+function isError(error) {
+	return error instanceof Error;
+}
+async function pathExists(filePath) {
+	try {
+		await fs.access(filePath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function collectMarkdownFiles(dir) {
+	const entries = await fs.readdir(dir, { withFileTypes: true });
+	const files = [];
+	for (const entry of entries) {
+		const entryPath = path.join(dir, entry.name);
+		if (entry.isDirectory()) {
+			files.push(...await collectMarkdownFiles(entryPath));
+			continue;
+		}
+		if (entry.isFile() && entry.name.toLowerCase().endsWith(".md")) files.push(entryPath);
+	}
+	return files.sort();
+}
+async function selectMarkdownFile(outputDir, basename) {
+	const files = await collectMarkdownFiles(outputDir);
+	if (files.length === 0) throw new Error(`External PDF converter did not produce a markdown file in ${outputDir}`);
+	const preferredName = `${basename}.md`.toLowerCase();
+	return files.find((file) => path.basename(file).toLowerCase() === preferredName) ?? files[0];
+}
+function formatCommandError(error, command$1) {
+	if (!isError(error)) return new Error(String(error));
+	const details = [`External PDF converter failed: ${command$1}`];
+	if ("exitCode" in error && typeof error.exitCode === "number") details.push(`exitCode=${error.exitCode}`);
+	if ("signal" in error && error.signal) details.push(`signal=${String(error.signal)}`);
+	if ("stderr" in error && typeof error.stderr === "string" && error.stderr.trim()) details.push(error.stderr.trim());
+	else if (error.message) details.push(error.message);
+	return new Error(details.join("\n"));
+}
+var ExternalCommandPdfConverter = class {
+	name;
+	constructor(name$1, config) {
+		this.config = config;
+		this.name = name$1;
+	}
+	async convert(input, filePath) {
+		const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "aiex-pdf-"));
+		const outputDir = path.join(tempRoot, "output");
+		await fs.mkdir(outputDir, { recursive: true });
+		const inputPath = filePath ?? path.join(tempRoot, "input.pdf");
+		if (!filePath) await fs.writeFile(inputPath, input);
+		const basename = path.basename(inputPath, path.extname(inputPath));
+		const context = {
+			input: inputPath,
+			outputDir,
+			basename
+		};
+		const args = this.config.args.map((arg) => applyTemplate(arg, context));
+		const timeoutMs = (this.config.timeout ?? 600) * 1e3;
+		try {
+			await execa(this.config.command, args, {
+				shell: false,
+				timeout: timeoutMs,
+				maxBuffer: 1024 * 1024 * 20
+			});
+			const outputPath = this.config.outputFile ? applyTemplate(this.config.outputFile, context) : await selectMarkdownFile(outputDir, basename);
+			if (!await pathExists(outputPath)) throw new Error(`External PDF converter output was not found: ${outputPath}`);
+			return {
+				text: await fs.readFile(outputPath, "utf-8"),
+				pageCount: 0,
+				metadata: {
+					converter: this.name,
+					outputPath
+				}
+			};
+		} catch (error) {
+			throw formatCommandError(error, `${this.config.command} ${args.join(" ")}`);
+		} finally {
+			await fs.rm(tempRoot, {
+				recursive: true,
+				force: true
+			});
+		}
+	}
+};
+
 //#endregion
 //#region src/core/pdf-converter/unpdf.ts
 var UnpdfConverter = class {
@@ -13378,10 +13487,40 @@ var UnpdfConverter = class {
 //#endregion
 //#region src/core/pdf-converter/factory.ts
 const registry = /* @__PURE__ */ new Map();
-function createPdfConverter(type) {
-	const key = type ?? "unpdf";
+var FallbackPdfConverter = class {
+	name;
+	constructor(primary, fallback) {
+		this.primary = primary;
+		this.fallback = fallback;
+		this.name = primary.name;
+	}
+	async convert(input, filePath) {
+		try {
+			return await this.primary.convert(input, filePath);
+		} catch {
+			return await this.fallback.convert(input, filePath);
+		}
+	}
+};
+function withFallback(converter, config) {
+	if (!config.fallbackToUnpdf) return converter;
+	return new FallbackPdfConverter(converter, new UnpdfConverter());
+}
+function createPdfConverter(config) {
+	if (typeof config === "object") {
+		if (config.converter === "mineru") {
+			const mineruConfig = config.mineru ?? DEFAULT_MINERU_CONFIG;
+			return withFallback(new ExternalCommandPdfConverter("mineru", mineruConfig), mineruConfig);
+		}
+		if (config.converter === "external") {
+			if (!config.external) throw new Error("External PDF converter is selected but no external command is configured.");
+			return withFallback(new ExternalCommandPdfConverter("external", config.external), config.external);
+		}
+	}
+	const key = typeof config === "string" ? config : "unpdf";
 	let instance = registry.get(key);
 	if (!instance) {
+		if (key !== "unpdf") throw new Error(`PDF converter "${key}" requires configuration.`);
 		instance = new UnpdfConverter();
 		registry.set(key, instance);
 	}
@@ -13389,7 +13528,7 @@ function createPdfConverter(type) {
 }
 
 //#endregion
-//#region src/commands/extract.ts
+//#region src/core/extract-runner.ts
 const FILE_PART_EXTENSIONS = new Set([
 	"png",
 	"jpg",
@@ -13399,12 +13538,19 @@ const FILE_PART_EXTENSIONS = new Set([
 	"bmp",
 	"svg"
 ]);
-const PDF_CONVERTER = createPdfConverter();
-function fail$1(message) {
-	if (message) consola.error(message);
-	outro("Failed!");
-	process.exitCode = 1;
-}
+const SUPPORTED_EXTENSIONS = new Set([
+	...FILE_PART_EXTENSIONS,
+	"pdf",
+	"txt",
+	"md",
+	"csv",
+	"json",
+	"html",
+	"xml",
+	"yaml",
+	"yml"
+]);
+const JSON_EXT_RE = /\.json$/;
 async function ensureDatabaseReady(dbPath, schema) {
 	try {
 		await fs.access(dbPath);
@@ -13424,6 +13570,194 @@ async function ensureDatabaseReady(dbPath, schema) {
 	}
 	return null;
 }
+function listSupportedFiles(dir, pattern) {
+	const entries = fs$1.readdirSync(dir, { withFileTypes: true });
+	const files = [];
+	for (const entry of entries) {
+		if (entry.isDirectory()) continue;
+		const ext = path.extname(entry.name).toLowerCase().replace(".", "");
+		if (!SUPPORTED_EXTENSIONS.has(ext)) continue;
+		if (pattern && !picomatch.isMatch(entry.name, pattern)) continue;
+		files.push(path.join(dir, entry.name));
+	}
+	return files.sort();
+}
+async function loadSchema(config, schemaName) {
+	const schemaPath = path.join(config.schemaPath, `${schemaName}.json`);
+	try {
+		const content = await fs.readFile(schemaPath, "utf-8");
+		const parsed = JSON.parse(content);
+		return { schema: JsonSchemaDefinitionSchema.parse(parsed) };
+	} catch (e) {
+		if (e instanceof ZodError) return {
+			schema: null,
+			error: `Schema validation failed: ${schemaName}.json\n${e.issues.map((i) => `  - ${i.path.join(".")}: ${i.message}`).join("\n")}`
+		};
+		if (e.code === "ENOENT") return {
+			schema: null,
+			error: `Cannot read schema file: ${schemaName}.json`
+		};
+		if (e instanceof SyntaxError) return {
+			schema: null,
+			error: `Invalid JSON in schema file: ${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, "")).sort();
+	} catch {
+		return [];
+	}
+}
+async function readExtractFileInput(filePath, aiConfig) {
+	const ext = path.extname(filePath).toLowerCase().replace(".", "");
+	if (FILE_PART_EXTENSIONS.has(ext)) return {
+		text: "",
+		filePath
+	};
+	if (ext === "pdf") {
+		const buffer = await fs.readFile(filePath);
+		const result = await createPdfConverter(aiConfig?.pdf).convert(buffer, filePath);
+		consola.info(`Extracted ${result.pageCount} page(s) from PDF`);
+		return { text: result.text };
+	}
+	return { text: await fs.readFile(filePath, "utf-8") };
+}
+async function extractSingle(aiexDir, config, aiConfig, schemaName, text$1, filePath, modelOverride, options) {
+	const schemaLoad = await loadSchema(config, schemaName);
+	if (!schemaLoad.schema) {
+		if (!options?.quiet) consola.error(schemaLoad.error);
+		return {
+			success: false,
+			error: schemaLoad.error
+		};
+	}
+	const s = spinner();
+	if (!options?.quiet) s.start(filePath ? `Extracting from ${path.basename(filePath)}...` : "Extracting data...");
+	const result = await extractStructuredData({
+		config: aiConfig,
+		schema: schemaLoad.schema,
+		text: text$1 ?? "",
+		aiexDir,
+		file: filePath,
+		modelOverride,
+		onRetry(info) {
+			if (!options?.quiet) s.message(`API responded with ${info.statusCode}, retrying in ${info.delayMs / 1e3}s (${info.attempt}/${info.maxRetries})...`);
+		}
+	});
+	if (!result.success) {
+		if (!options?.quiet) {
+			s.stop("Extraction failed");
+			consola.error(result.error || "Unknown error");
+		}
+		return {
+			success: false,
+			error: result.error || "Unknown error"
+		};
+	}
+	if (!options?.quiet) s.stop("Extraction complete");
+	if (result.outputPath && !options?.quiet) consola.success(`Result saved: ${pc.cyan(result.outputPath)}`);
+	if (result.tokensUsed && !options?.quiet) consola.info(pc.gray(`Token usage: prompt=${result.tokensUsed.prompt}, completion=${result.tokensUsed.completion}, total=${result.tokensUsed.total}`));
+	if (result.data) {
+		const s2 = spinner();
+		if (!options?.quiet) s2.start("Inserting into database...");
+		const dbError = await ensureDatabaseReady(config.databasePath, schemaLoad.schema);
+		if (dbError) {
+			if (!options?.quiet) s2.stop("Database not ready");
+			consola.error(dbError);
+			return {
+				success: false,
+				error: dbError
+			};
+		}
+		try {
+			const db = new Database(config.databasePath);
+			try {
+				const insertResult = insertExtractedData(db, schemaLoad.schema, result.data);
+				if (insertResult.success) {
+					if (!options?.quiet) s2.stop(`Inserted into ${insertResult.tablesInserted.length} table(s)`);
+				} else {
+					if (!options?.quiet) s2.stop("Database insert failed");
+					consola.error(insertResult.error || "Unknown error");
+					return {
+						success: false,
+						error: insertResult.error
+					};
+				}
+			} finally {
+				db.close();
+			}
+		} catch (e) {
+			if (!options?.quiet) s2.stop("Database insert failed");
+			consola.error(e instanceof Error ? e.message : String(e));
+			return {
+				success: false,
+				error: String(e)
+			};
+		}
+	}
+	return { success: true };
+}
+async function processOneFile(aiexDir, config, aiConfig, schemaName, filePath, modelOverride) {
+	try {
+		const input = await readExtractFileInput(filePath, aiConfig);
+		const r = await extractSingle(aiexDir, config, aiConfig, schemaName, input.text, input.filePath, modelOverride, { quiet: false });
+		if (r.success) {
+			consola.success(`Processed: ${path.basename(filePath)}`);
+			return true;
+		} else {
+			consola.error(`Failed: ${r.error}`);
+			return false;
+		}
+	} catch (e) {
+		consola.error(`Error processing ${path.basename(filePath)}: ${e instanceof Error ? e.message : String(e)}`);
+		return false;
+	}
+}
+async function runBatchExtraction(aiexDir, config, aiConfig, schemaName, dir, globPattern, modelOverride) {
+	consola.info(`Scanning ${pc.cyan(dir)} for supported files...`);
+	let files;
+	try {
+		files = listSupportedFiles(dir, globPattern);
+	} catch {
+		return {
+			ok: false,
+			successCount: 0,
+			failCount: 0,
+			error: `Cannot read directory: ${dir}`
+		};
+	}
+	if (files.length === 0) return {
+		ok: false,
+		successCount: 0,
+		failCount: 0,
+		error: `No supported files found in ${dir}`
+	};
+	consola.info(`Found ${files.length} file(s) to process`);
+	let successCount = 0;
+	let failCount = 0;
+	for (let i = 0; i < files.length; i++) {
+		const file = files[i];
+		consola.info(`\n[${i + 1}/${files.length}] Processing: ${pc.cyan(path.basename(file))}`);
+		if (await processOneFile(aiexDir, config, aiConfig, schemaName, file, modelOverride)) successCount++;
+		else failCount++;
+	}
+	consola.info(`\nBatch complete: ${pc.green(`${successCount} succeeded`)}, ${pc.red(`${failCount} failed`)}, ${files.length} total`);
+	return {
+		ok: true,
+		successCount,
+		failCount
+	};
+}
+
+//#endregion
+//#region src/commands/extract.ts
 const extractCommand = defineCommand({
 	meta: {
 		name: "extract",
@@ -13433,8 +13767,7 @@ const extractCommand = defineCommand({
 		schema: {
 			type: "string",
 			alias: "s",
-			description: "Schema name (without .json extension)",
-			required: true
+			description: "Schema name (without .json extension)"
 		},
 		text: {
 			type: "string",
@@ -13450,31 +13783,41 @@ const extractCommand = defineCommand({
 			type: "string",
 			alias: "m",
 			description: "AI model to use for extraction (overrides auto-selection)"
+		},
+		dir: {
+			type: "string",
+			alias: "d",
+			description: "Directory containing files to batch extract"
+		},
+		glob: {
+			type: "string",
+			alias: "g",
+			description: "Glob pattern to filter files in batch mode (e.g. \"*.pdf\")"
 		}
 	},
 	async run({ args }) {
 		intro(pc.inverse(" aiex extract "));
 		const config = createMigrationConfig(process.cwd());
 		const aiexDir = path.dirname(config.schemaPath);
-		if (!args.text && !args.file) {
-			fail$1("Please provide text (-t) or a file (-f) to extract from");
+		if (args.dir && args.text) {
+			failCommand("Cannot combine -t/--text with -d/--dir");
 			return;
 		}
-		if (args.text && args.file) {
-			fail$1("-t and -f cannot be used together");
+		if (args.dir && args.file) {
+			failCommand("Cannot combine -f/--file with -d/--dir");
 			return;
 		}
 		const aiConfig = await readAIConfig(aiexDir);
 		if (!aiConfig) {
-			fail$1("AI configuration not found. Please configure AI settings in the Web interface first");
+			failCommand("AI configuration not found. Please run \"aiex web\" to configure AI settings first");
 			return;
 		}
 		if (!aiConfig.provider.apiKey) {
-			fail$1("API Key not configured. Please configure AI settings in the Web interface first");
+			failCommand("API Key not configured. Please configure AI settings in the Web interface first");
 			return;
 		}
 		if (!aiConfig.provider.models?.length) {
-			fail$1("No models configured. Please add at least one model in AI Settings");
+			failCommand("No models configured. Please add at least one model in AI Settings");
 			return;
 		}
 		let modelOverride;
@@ -13482,108 +13825,265 @@ const extractCommand = defineCommand({
 			const matched = aiConfig.provider.models.find((m) => m.name === args.model);
 			if (!matched) {
 				const available = aiConfig.provider.models.map((m) => m.name).join(", ");
-				fail$1(`Model "${args.model}" not found in configuration. Available models: ${available}`);
+				failCommand(`Model "${args.model}" not found in configuration. Available models: ${available}`);
 				return;
 			}
 			modelOverride = matched;
 		}
-		let text = "";
-		let filePath;
-		if (args.file) {
-			const ext = path.extname(args.file).toLowerCase().replace(".", "");
-			if (FILE_PART_EXTENSIONS.has(ext)) filePath = args.file;
-			else if (ext === "pdf") {
-				const buffer = await fs.readFile(args.file);
-				const result$1 = await PDF_CONVERTER.convert(buffer);
-				text = result$1.text;
-				consola.info(`Extracted ${result$1.pageCount} page(s) from PDF`);
-			} else text = await fs.readFile(args.file, "utf-8");
-		} else if (args.text) text = args.text;
-		const schemaName = args.schema;
-		const schemaPath = path.join(config.schemaPath, `${schemaName}.json`);
-		let schema;
-		try {
-			const content = await fs.readFile(schemaPath, "utf-8");
-			schema = JSON.parse(content);
-		} catch {
-			fail$1(`Cannot read schema file: ${schemaName}.json`);
+		if (!args.schema && !args.text && !args.file && !args.dir) {
+			if (await runInteractive(aiexDir, config, aiConfig, modelOverride)) outro("Done!");
 			return;
 		}
-		try {
-			schema = JsonSchemaDefinitionSchema.parse(schema);
-		} catch (e) {
-			if (e instanceof ZodError) {
-				consola.error(`Schema validation failed: ${schemaName}.json`);
-				for (const issue of e.issues) consola.error(`  - ${issue.path.join(".")}: ${issue.message}`);
+		if (args.dir) {
+			if (!args.schema) {
+				failCommand("Schema name (-s) is required in batch mode");
+				return;
+			}
+			const result = await runBatchExtraction(aiexDir, config, aiConfig, args.schema, args.dir, args.glob, modelOverride);
+			if (!result.ok) {
+				failCommand(result.error);
+				return;
 			}
-			fail$1();
+			if (result.failCount > 0) process.exitCode = 1;
+			if (result.failCount > 0) outro(`Completed with failures (${result.failCount} failed)`);
+			else outro("Done!");
 			return;
 		}
-		const s = spinner();
-		s.start(filePath ? "Extracting data from image..." : "Extracting data...");
-		const result = await extractStructuredData({
-			config: aiConfig,
-			schema,
-			text,
-			aiexDir,
-			file: filePath,
-			modelOverride,
-			onRetry(info) {
-				s.message(`API responded with ${info.statusCode}, retrying in ${info.delayMs / 1e3}s (${info.attempt}/${info.maxRetries})...`);
+		if (!args.schema) {
+			failCommand("Please provide a schema name (-s) to extract from");
+			return;
+		}
+		if (!args.text && !args.file) {
+			failCommand("Please provide text (-t) or a file (-f) to extract from");
+			return;
+		}
+		if (args.text && args.file) {
+			failCommand("-t and -f cannot be used together");
+			return;
+		}
+		let text$1 = "";
+		let filePath;
+		if (args.file) try {
+			const input = await readExtractFileInput(args.file, aiConfig);
+			text$1 = input.text;
+			filePath = input.filePath;
+		} catch (e) {
+			failCommand(`Cannot read file: ${args.file} — ${e instanceof Error ? e.message : String(e)}`);
+			return;
+		}
+		else if (args.text) text$1 = args.text;
+		if (!(await extractSingle(aiexDir, config, aiConfig, args.schema, text$1, filePath, modelOverride)).success) {
+			failCommand();
+			return;
+		}
+		outro("Done!");
+	}
+});
+async function runInteractive(aiexDir, config, aiConfig, modelOverride) {
+	const schemas = await listSchemas(aiexDir);
+	if (schemas.length === 0) {
+		failCommand(`No schema files found in ${pc.cyan(".aiex/schema/")}. Run ${pc.cyan("aiex schema --init")} first, or add JSON Schema files.`);
+		return false;
+	}
+	const schemaName = await select({
+		message: "Select a schema to extract data for:",
+		options: schemas.map((s) => ({
+			label: s,
+			value: s
+		}))
+	});
+	if (isCancel(schemaName)) {
+		cancel("Cancelled");
+		return false;
+	}
+	const inputSource = await select({
+		message: "Choose input source:",
+		options: [
+			{
+				label: "Text content",
+				value: "text",
+				hint: "Paste or type text directly"
+			},
+			{
+				label: "Single file",
+				value: "file",
+				hint: "Extract from a file (txt, pdf, image)"
+			},
+			{
+				label: "Batch directory",
+				value: "dir",
+				hint: "Extract all supported files in a directory"
+			}
+		]
+	});
+	if (isCancel(inputSource)) {
+		cancel("Cancelled");
+		return false;
+	}
+	if (inputSource === "text") {
+		const textContent = await text({
+			message: "Enter text content to extract:",
+			validate(value) {
+				if (!value || value.trim().length === 0) return "Please enter some text";
 			}
 		});
-		if (!result.success) {
-			s.stop("Extraction failed");
-			fail$1(result.error || "Unknown error");
-			return;
+		if (isCancel(textContent)) {
+			cancel("Cancelled");
+			return false;
 		}
-		s.stop("Extraction complete");
-		if (result.outputPath) consola.success(`Result saved: ${pc.cyan(result.outputPath)}`);
-		if (result.tokensUsed) consola.info(pc.gray(`Token usage: prompt=${result.tokensUsed.prompt}, completion=${result.tokensUsed.completion}, total=${result.tokensUsed.total}`));
-		if (result.data) {
-			const s2 = spinner();
-			s2.start("Inserting into database...");
-			const dbError = await ensureDatabaseReady(config.databasePath, schema);
-			if (dbError) {
-				s2.stop("Database not ready");
-				fail$1(dbError);
-				return;
+		return (await extractSingle(aiexDir, config, aiConfig, schemaName, textContent, void 0, modelOverride)).success;
+	} else if (inputSource === "file") {
+		const filePathStr = await text({
+			message: "Enter file path:",
+			validate(value) {
+				if (!value || value.trim().length === 0) return "Please enter a file path";
 			}
-			try {
-				const db = new Database(config.databasePath);
-				try {
-					const insertResult = insertExtractedData(db, schema, result.data);
-					if (insertResult.success) s2.stop(`Inserted into ${insertResult.tablesInserted.length} table(s)`);
-					else {
-						s2.stop("Database insert failed");
-						fail$1(insertResult.error || "Unknown error");
-						return;
-					}
-				} finally {
-					db.close();
-				}
-			} catch (e) {
-				s2.stop("Database insert failed");
-				fail$1(e instanceof Error ? e.message : String(e));
-				return;
+		});
+		if (isCancel(filePathStr)) {
+			cancel("Cancelled");
+			return false;
+		}
+		const fp = filePathStr;
+		try {
+			const input = await readExtractFileInput(fp, aiConfig);
+			return (await extractSingle(aiexDir, config, aiConfig, schemaName, input.text, input.filePath, modelOverride)).success;
+		} catch (e) {
+			consola.error(`Cannot read file: ${fp} — ${e instanceof Error ? e.message : String(e)}`);
+			return false;
+		}
+	} else if (inputSource === "dir") {
+		const dirPath = await text({
+			message: "Enter directory path:",
+			validate(value) {
+				if (!value || value.trim().length === 0) return "Please enter a directory path";
 			}
+		});
+		if (isCancel(dirPath)) {
+			cancel("Cancelled");
+			return false;
 		}
-		outro("Done!");
+		const result = await runBatchExtraction(aiexDir, config, aiConfig, schemaName, dirPath, void 0, modelOverride);
+		if (!result.ok) failCommand(result.error);
+		return result.ok && result.failCount === 0;
 	}
-});
+	return false;
+}
+function cancel(msg) {
+	consola.info(msg);
+	outro("Cancelled");
+	process.exitCode = 0;
+}
 
 //#endregion
 //#region schemas/table-schema.json
 var $id = "https://raw.githubusercontent.com/OSpoon/aiex-cli/main/app/cli/schemas/table-schema.json";
 
 //#endregion
-//#region src/commands/schema.ts
+//#region src/core/schema-runner.ts
 const execFileAsync$1 = promisify(execFile);
-function fail(message) {
-	if (message) consola.error(message);
-	outro("Failed!");
-	process.exitCode = 1;
-}
+const EXAMPLE_SCORE_REPORT_SCHEMA = {
+	$schema: $id,
+	title: "ScoreReport",
+	type: "object",
+	table: {
+		name: "score_report",
+		timestamps: true
+	},
+	properties: {
+		name: {
+			type: "string",
+			description: "姓名"
+		},
+		reportNumber: {
+			type: "string",
+			description: "报告编号"
+		},
+		gender: {
+			type: "string",
+			description: "性别"
+		},
+		printDate: {
+			type: "string",
+			format: "date-time",
+			description: "打印日期"
+		},
+		examYear: {
+			type: "integer",
+			description: "考试年份"
+		},
+		examType: {
+			type: "string",
+			description: "考试类型，如全国统考"
+		},
+		examCategory: {
+			type: "string",
+			description: "考试类别，如普通高考"
+		},
+		province: {
+			type: "string",
+			description: "考试省份"
+		},
+		subjectCategory: {
+			type: "string",
+			description: "科类，如艺术（文）"
+		},
+		chinese: {
+			type: "integer",
+			description: "语文成绩"
+		},
+		chineseFull: {
+			type: "integer",
+			description: "语文满分"
+		},
+		math: {
+			type: "integer",
+			description: "数学成绩"
+		},
+		mathFull: {
+			type: "integer",
+			description: "数学满分"
+		},
+		foreignLang: {
+			type: "integer",
+			description: "外语成绩"
+		},
+		foreignLangFull: {
+			type: "integer",
+			description: "外语满分"
+		},
+		comprehensive: {
+			type: "integer",
+			description: "综合成绩"
+		},
+		comprehensiveFull: {
+			type: "integer",
+			description: "综合满分"
+		},
+		totalScore: {
+			type: "integer",
+			description: "总分"
+		},
+		totalFullScore: {
+			type: "integer",
+			description: "总分满分"
+		},
+		batchLineFirst: {
+			type: "integer",
+			description: "本科第一批录取分数线"
+		},
+		batchLineSecond: {
+			type: "integer",
+			description: "本科第二批录取分数线"
+		}
+	},
+	required: [
+		"name",
+		"examYear",
+		"examType",
+		"province",
+		"totalScore"
+	]
+};
 async function writeJsonIfAbsent(filePath, data) {
 	try {
 		await fs.writeFile(filePath, `${JSON.stringify(data, null, 2)}\n`, { flag: "wx" });
@@ -13593,24 +14093,66 @@ async function writeJsonIfAbsent(filePath, data) {
 		throw error;
 	}
 }
-async function generateFromFiles(schemaFiles, config) {
+async function initSchemaProject(config) {
+	await fs.mkdir(config.schemaPath, { recursive: true });
+	await fs.mkdir(path.dirname(config.drizzleSchemaPath), { recursive: true });
+	await fs.mkdir(config.migrationsPath, { recursive: true });
+	return { scoreReportStatus: await writeJsonIfAbsent(path.join(config.schemaPath, "score_report.json"), EXAMPLE_SCORE_REPORT_SCHEMA) };
+}
+async function listSchemaFiles(schemaDir) {
+	try {
+		return (await fs.readdir(schemaDir)).filter((f) => f.endsWith(".json")).map((f) => path.join(schemaDir, f)).sort();
+	} catch {
+		return [];
+	}
+}
+async function generateSchemaFromFiles(schemaFiles, config) {
 	const result = parseAllSchemas(await Promise.all(schemaFiles.map(async (filePath) => {
 		return {
 			filePath,
 			content: await fs.readFile(filePath, "utf-8")
 		};
 	})));
-	if (!result.success) {
-		consola.error(result.error);
-		return false;
-	}
-	for (const warning of result.data.warnings) consola.warn(warning);
+	if (!result.success) return {
+		success: false,
+		error: result.error,
+		warnings: [],
+		schemaCount: schemaFiles.length,
+		tables: 0,
+		relations: 0
+	};
+	const { tables, relations, reverseRelations, warnings, drizzleCode } = result.data;
 	await fs.mkdir(path.dirname(config.drizzleSchemaPath), { recursive: true });
-	await fs.writeFile(config.drizzleSchemaPath, result.data.drizzleCode);
-	consola.success(`Generated ${pc.cyan(".aiex/drizzle/schema.ts")} from ${schemaFiles.length} schema file(s)`);
-	return true;
+	await fs.writeFile(config.drizzleSchemaPath, drizzleCode);
+	return {
+		success: true,
+		warnings,
+		schemaCount: schemaFiles.length,
+		tables: tables.length,
+		relations: relations.length + reverseRelations.length
+	};
+}
+function parseMigrationOutput(stdout, stderr) {
+	try {
+		const jsonLine = stdout.trim().split("\n").find((l) => l.startsWith("{") && l.endsWith("}"));
+		if (!jsonLine) return {
+			success: false,
+			error: "Migration helper did not return valid output"
+		};
+		const result = JSON.parse(jsonLine);
+		if (!result.success) return {
+			success: false,
+			error: result.error || "Migration failed"
+		};
+		return result;
+	} catch {
+		return {
+			success: false,
+			error: stderr || stdout || "Migration helper failed"
+		};
+	}
 }
-async function migrate(config, migrationName) {
+async function runSchemaMigration(config, migrationName) {
 	const helperPath = resolveHelperPath();
 	const helperArgs = [
 		resolveTsxPath(),
@@ -13621,28 +14163,56 @@ async function migrate(config, migrationName) {
 	];
 	if (migrationName) helperArgs.push(migrationName);
 	try {
-		const { stdout } = await execFileAsync$1(process.execPath, helperArgs, { cwd: process.cwd() });
-		const result = JSON.parse(stdout.trim());
-		if (!result.success) {
-			consola.error("Failed to generate migration");
-			consola.error(result.error);
-			return false;
-		}
-		if (result.changes === 0) {
-			consola.info(pc.gray("No changes detected"));
-			return true;
-		}
-		consola.success(pc.green("Migration files generated"));
-		consola.success(pc.green("Database migrated"));
-		return true;
+		const { stdout, stderr } = await execFileAsync$1(process.execPath, helperArgs, { cwd: process.cwd() });
+		return parseMigrationOutput(stdout, stderr);
 	} catch (error) {
-		consola.error("Failed to generate migration");
 		const execError = error;
-		if (execError.stderr) consola.error(execError.stderr);
-		else consola.error(execError.message || String(error));
-		return false;
+		return {
+			success: false,
+			error: execError.stderr || execError.stdout || execError.message || String(error)
+		};
 	}
 }
+async function runSchemaSync(config, options = {}) {
+	const schemaFiles = await listSchemaFiles(config.schemaPath);
+	if (schemaFiles.length === 0) return {
+		success: false,
+		error: "No schema files found",
+		warnings: [],
+		schemaCount: 0,
+		tables: 0,
+		relations: 0
+	};
+	const generated = await generateSchemaFromFiles(schemaFiles, config);
+	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
+	};
+	const migration = await runSchemaMigration(config, options.migrationName);
+	return {
+		success: migration.success,
+		error: migration.error,
+		warnings: generated.warnings,
+		schemaCount: generated.schemaCount,
+		tables: generated.tables,
+		relations: generated.relations,
+		migration
+	};
+}
+
+//#endregion
+//#region src/commands/schema.ts
 const schemaCommand = defineCommand({
 	meta: {
 		name: "schema",
@@ -13670,137 +14240,28 @@ const schemaCommand = defineCommand({
 		intro(pc.inverse(" aiex schema "));
 		const config = createMigrationConfig(process.cwd());
 		if (args.init) {
-			await fs.mkdir(config.schemaPath, { recursive: true });
-			await fs.mkdir(path.dirname(config.drizzleSchemaPath), { recursive: true });
-			await fs.mkdir(config.migrationsPath, { recursive: true });
-			const examReportSchema = {
-				$schema: $id,
-				title: "ScoreReport",
-				type: "object",
-				table: {
-					name: "score_report",
-					timestamps: true
-				},
-				properties: {
-					name: {
-						type: "string",
-						description: "姓名"
-					},
-					reportNumber: {
-						type: "string",
-						description: "报告编号"
-					},
-					gender: {
-						type: "string",
-						description: "性别"
-					},
-					printDate: {
-						type: "string",
-						format: "date-time",
-						description: "打印日期"
-					},
-					examYear: {
-						type: "integer",
-						description: "考试年份"
-					},
-					examType: {
-						type: "string",
-						description: "考试类型，如全国统考"
-					},
-					examCategory: {
-						type: "string",
-						description: "考试类别，如普通高考"
-					},
-					province: {
-						type: "string",
-						description: "考试省份"
-					},
-					subjectCategory: {
-						type: "string",
-						description: "科类，如艺术（文）"
-					},
-					chinese: {
-						type: "integer",
-						description: "语文成绩"
-					},
-					chineseFull: {
-						type: "integer",
-						description: "语文满分"
-					},
-					math: {
-						type: "integer",
-						description: "数学成绩"
-					},
-					mathFull: {
-						type: "integer",
-						description: "数学满分"
-					},
-					foreignLang: {
-						type: "integer",
-						description: "外语成绩"
-					},
-					foreignLangFull: {
-						type: "integer",
-						description: "外语满分"
-					},
-					comprehensive: {
-						type: "integer",
-						description: "综合成绩"
-					},
-					comprehensiveFull: {
-						type: "integer",
-						description: "综合满分"
-					},
-					totalScore: {
-						type: "integer",
-						description: "总分"
-					},
-					totalFullScore: {
-						type: "integer",
-						description: "总分满分"
-					},
-					batchLineFirst: {
-						type: "integer",
-						description: "本科第一批录取分数线"
-					},
-					batchLineSecond: {
-						type: "integer",
-						description: "本科第二批录取分数线"
-					}
-				},
-				required: [
-					"name",
-					"examYear",
-					"examType",
-					"province",
-					"totalScore"
-				]
-			};
-			const examStatus = await writeJsonIfAbsent(path.join(config.schemaPath, "score_report.json"), examReportSchema);
+			const initResult = await initSchemaProject(config);
 			consola.success(`Initialized ${pc.cyan(".aiex/")} with example schemas`);
-			if (examStatus === "skipped") consola.warn(`${pc.cyan(".aiex/schema/score_report.json")} already exists, skipped`);
+			if (initResult.scoreReportStatus === "skipped") consola.warn(`${pc.cyan(".aiex/schema/score_report.json")} already exists, skipped`);
 			consola.info("Example includes: ScoreReport (college entrance exam score report)");
 			outro("Run: aiex schema");
 			return;
 		}
-		let schemaFiles;
-		try {
-			schemaFiles = await fs.readdir(config.schemaPath);
-			schemaFiles = schemaFiles.filter((f) => f.endsWith(".json")).map((f) => path.join(config.schemaPath, f));
-		} catch {
-			schemaFiles = [];
-		}
+		const schemaFiles = await listSchemaFiles(config.schemaPath);
 		if (schemaFiles.length === 0) {
 			consola.info("Use --init to initialize with an example schema");
-			fail(`No schema files found in ${pc.cyan(".aiex/schema/")}`);
+			failCommand(`No schema files found in ${pc.cyan(".aiex/schema/")}`);
 			return;
 		}
 		const s1 = spinner();
 		s1.start("Generating Drizzle schema...");
-		const genOk = await generateFromFiles(schemaFiles, config);
-		s1.stop(genOk ? "Schema generated" : "Generation failed");
-		if (!genOk) {
-			fail();
+		const generated = await generateSchemaFromFiles(schemaFiles, config);
+		for (const warning of generated.warnings) consola.warn(warning);
+		if (generated.success) consola.success(`Generated ${pc.cyan(".aiex/drizzle/schema.ts")} from ${generated.schemaCount} schema file(s)`);
+		else if (generated.error) consola.error(generated.error);
+		s1.stop(generated.success ? "Schema generated" : "Generation failed");
+		if (!generated.success) {
+			failCommand();
 			return;
 		}
 		if (args.generate) {
@@ -13809,10 +14270,18 @@ const schemaCommand = defineCommand({
 		}
 		const s2 = spinner();
 		s2.start("Running migrations...");
-		const migOk = await migrate(config, args.name);
-		s2.stop(migOk ? "Migrations applied" : "Migration failed");
-		if (!migOk) {
-			fail();
+		const migration = await runSchemaMigration(config, args.name);
+		if (!migration.success) {
+			consola.error("Failed to generate migration");
+			consola.error(migration.error || "Migration failed");
+		} else if (migration.changes === 0) consola.info(pc.gray("No changes detected"));
+		else {
+			consola.success(pc.green("Migration files generated"));
+			consola.success(pc.green("Database migrated"));
+		}
+		s2.stop(migration.success ? "Migrations applied" : "Migration failed");
+		if (!migration.success) {
+			failCommand();
 			return;
 		}
 		outro("Done!");
@@ -14025,7 +14494,6 @@ function dataRoutes(config) {
 
 //#endregion
 //#region src/server/routes/schema.ts
-const execFileAsync = promisify(execFile);
 const SCHEMA_FILE_RE = /^[\w.-]+\.json$/;
 const TABLE_NAME_RE = /^[a-z][a-z0-9_]*$/;
 function resolveSchemaFile(schemaDir, name$1) {
@@ -14113,59 +14581,21 @@ function schemaRoutes(config) {
 	app.post("/migrate", async (c) => {
 		try {
 			await ensureDir();
-			await fs.mkdir(path.dirname(config.drizzleSchemaPath), { recursive: true });
-			const jsonFiles = (await fs.readdir(schemaDir)).filter((f) => f.endsWith(".json"));
-			if (jsonFiles.length === 0) return c.json({
-				success: false,
-				error: "No schema files found"
-			}, 400);
-			const parsedResult = parseAllSchemas(await Promise.all(jsonFiles.map(async (fileName) => {
-				const filePath = path.join(schemaDir, fileName);
-				return {
-					filePath,
-					content: await fs.readFile(filePath, "utf-8")
-				};
-			})));
-			if (!parsedResult.success) return c.json({
-				success: false,
-				error: parsedResult.error
-			}, 400);
-			const { tables, relations, reverseRelations, warnings, drizzleCode } = parsedResult.data;
-			await fs.writeFile(config.drizzleSchemaPath, drizzleCode);
-			const helperPath = resolveHelperPath();
-			const tsxPath = resolveTsxPath();
-			const { stdout, stderr } = await execFileAsync(process.execPath, [
-				tsxPath,
-				helperPath,
-				config.drizzleSchemaPath,
-				config.migrationsPath,
-				config.databasePath
-			], { cwd: process.cwd() });
-			let migrationResult;
-			try {
-				const jsonLine = stdout.trim().split("\n").find((l) => l.startsWith("{") && l.endsWith("}"));
-				if (!jsonLine) return c.json({
-					success: false,
-					error: "Migration helper did not return valid output"
-				}, 500);
-				migrationResult = JSON.parse(jsonLine);
-			} catch {
+			const result = await runSchemaSync(config);
+			if (!result.success) {
+				const status = result.schemaCount === 0 ? 400 : 500;
 				return c.json({
 					success: false,
-					error: stderr || stdout || "Migration helper failed"
-				}, 500);
+					error: result.error || "Migration failed"
+				}, status);
 			}
-			if (!migrationResult.success) return c.json({
-				success: false,
-				error: migrationResult.error || "Migration failed"
-			}, 500);
 			return c.json({
 				success: true,
-				changes: migrationResult.changes ?? 0,
-				tag: migrationResult.tag,
-				tables: tables.length,
-				relations: relations.length + reverseRelations.length,
-				warnings
+				changes: result.migration?.changes ?? 0,
+				tag: result.migration?.tag,
+				tables: result.tables,
+				relations: result.relations,
+				warnings: result.warnings
 			});
 		} catch (error) {
 			return c.json({
@@ -14213,9 +14643,50 @@ function createApp(config, staticDir) {
 	return app;
 }
 
+//#endregion
+//#region src/core/web-runner.ts
+const execFileAsync = promisify(execFile);
+function resolveWebStaticDir() {
+	return path.join(resolvePackageRoot(), "dist/web");
+}
+async function openBrowser(url) {
+	if (process.platform === "darwin") {
+		await execFileAsync("open", [url]);
+		return;
+	}
+	if (process.platform === "win32") {
+		await execFileAsync("cmd", [
+			"/c",
+			"start",
+			"",
+			url
+		]);
+		return;
+	}
+	await execFileAsync("xdg-open", [url]);
+}
+async function startWebServer(input) {
+	const { config, port } = input;
+	const staticDir = input.staticDir ?? resolveWebStaticDir();
+	const url = `http://localhost:${port}`;
+	serve({
+		fetch: createApp(config, staticDir).fetch,
+		port
+	}, () => {
+		input.onStarted?.({
+			url,
+			schemaPath: config.schemaPath
+		});
+		if (input.open === false) return;
+		openBrowser(url).catch(() => {
+			input.onOpenFailed?.(url);
+		});
+	});
+	await new Promise(() => {});
+}
+
 //#endregion
 //#region src/commands/web.ts
-const execAsync = promisify(exec);
 const webCommand = defineCommand({
 	meta: {
 		name: "web",
@@ -14232,23 +14703,20 @@ const webCommand = defineCommand({
 		const cwd = process.cwd();
 		const port = Number(args.port) || 13e3;
 		const config = createMigrationConfig(cwd);
-		const packageRoot = resolvePackageRoot();
-		const staticDir = path.join(packageRoot, "dist/web");
 		const s = spinner();
 		s.start("Starting web server...");
-		serve({
-			fetch: createApp(config, staticDir).fetch,
-			port
-		}, () => {
-			s.stop(`Server running at ${pc.cyan(`http://localhost:${port}`)}`);
-			consola.info(`Schema directory: ${pc.dim(config.schemaPath)}`);
-			consola.info("Press Ctrl+C to stop");
-			const url = `http://localhost:${port}`;
-			execAsync(`${process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open"} ${url}`).catch(() => {
+		await startWebServer({
+			config,
+			port,
+			onStarted(info) {
+				s.stop(`Server running at ${pc.cyan(info.url)}`);
+				consola.info(`Schema directory: ${pc.dim(info.schemaPath)}`);
+				consola.info("Press Ctrl+C to stop");
+			},
+			onOpenFailed(url) {
 				consola.warn(`Could not open browser. Visit ${url} manually.`);
-			});
+			}
 		});
-		await new Promise(() => {});
 	}
 });