aiex-cli 0.0.1-beta.9 → 0.0.2-beta.1

package/dist/cli.mjs

@@ -1,25 +1,41 @@
-import { C as doctorDiagnosticsTableRows, a as writeAIConfig, b as toSnakeCase, c as PLACEHOLDER_TEXT, d as seedConfig, f as description, g as createMigrationConfig, h as version, i as readAIConfig, l as AIConfigSchema, m as package_default, n as getDefaultAIConfig, o as DEFAULT_PROMPT_CONFIG, p as name, r as maskApiKey, s as PLACEHOLDER_SCHEMA, t as collectDoctorDiagnostics, u as createConfig, v as JsonSchemaDefinitionSchema, w as formatDoctorDiagnosticsJson, x as generateDrizzleSchema, y as parseJsonSchema } from "./doctor-BiU1lDp-.mjs";
+import { S as version, T as formatDoctorDiagnosticsJson, _ as createConfig, a as parseJsonSchema, b as name, c as getDefaultAIConfig, d as DEFAULT_MARKITDOWN_CONFIG, f as DEFAULT_MINERU_CONFIG, g as AIConfigSchema, h as PLACEHOLDER_TEXT, i as JsonSchemaDefinitionSchema, l as readAIConfig, m as PLACEHOLDER_SCHEMA, n as createMigrationConfig, o as toSnakeCase, p as DEFAULT_PROMPT_CONFIG, s as generateDrizzleSchema, t as collectDoctorDiagnostics, u as writeAIConfig, v as seedConfig, w as doctorDiagnosticsTableRows, x as package_default, y as description } from "./doctor-collector-Cbqgwx__.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 { readFile, writeFile } from "jsonfile";
+import { ZodError, z } from "zod";
 import { fileURLToPath } from "node:url";
-import { ZodError } from "zod";
-import fs from "node:fs/promises";
 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 { exec, execFile } from "node:child_process";
+import mime from "mime";
+import pRetry from "p-retry";
+import { jsonrepair } from "jsonrepair";
+import fs$1 from "node:fs";
+import Database from "better-sqlite3";
+import { glob, globSync } from "tinyglobby";
+import { execa } from "execa";
+import { extractText, getDocumentProxy, getMeta } from "unpdf";
+import { Buffer } from "node:buffer";
+import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import { serve } from "@hono/node-server";
+import open from "open";
 import { serveStatic } from "@hono/node-server/serve-static";
 import { Hono } from "hono";
 import { cors } from "hono/cors";
+import { Client } from "@notionhq/client";
+import { zValidator } from "@hono/zod-validator";
+import { Kysely, SqliteDialect, sql } from "kysely";
 
 //#region src/core/schema-sqlite/helpers.ts
 const __filename = fileURLToPath(import.meta.url);
@@ -96,7 +112,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}() {
@@ -123,7 +139,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);
@@ -131,6 +147,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",
@@ -145,7 +164,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);
@@ -185,6 +204,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 = {
@@ -12727,26 +12754,26 @@ var model_capabilities_default = {
 
 //#endregion
 //#region src/core/ai-extraction/model-registry.ts
-const registry = model_capabilities_default;
+const registry$1 = model_capabilities_default;
 function normalize(name$1) {
 	return name$1.toLowerCase().replace(/[-_. ]/g, "");
 }
 const normalizedCache = /* @__PURE__ */ new Map();
 function buildNormalizedCache() {
 	if (normalizedCache.size > 0) return;
-	for (const key of Object.keys(registry)) {
+	for (const key of Object.keys(registry$1)) {
 		const nk = normalize(key);
 		if (!normalizedCache.has(nk)) normalizedCache.set(nk, key);
 	}
 }
 function lookupModel(name$1) {
-	const exact = registry[name$1];
+	const exact = registry$1[name$1];
 	if (exact) return { ...exact };
 	buildNormalizedCache();
 	const nk = normalize(name$1);
 	const matched = normalizedCache.get(nk);
 	if (matched) {
-		const entry = registry[matched];
+		const entry = registry$1[matched];
 		return entry ? { ...entry } : null;
 	}
 	return null;
@@ -12763,29 +12790,40 @@ 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 parseJsonLike(text$1) {
+	const trimmed = text$1.trim();
+	try {
+		return JSON.parse(trimmed);
+	} catch {
+		if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) throw new SyntaxError("JSON candidate must start with an object or array");
+		return JSON.parse(jsonrepair(trimmed));
+	}
+}
+function stripFences(text$1) {
+	const trimmed = text$1.trim();
 	if (!trimmed.startsWith("```")) return null;
 	const endIndex = trimmed.lastIndexOf("```");
 	if (endIndex <= 3) return null;
@@ -12794,8 +12832,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;
@@ -12806,20 +12844,20 @@ 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 {}
 	const fromFence = stripFences(cleaned);
 	if (fromFence) try {
-		return JSON.parse(fromFence);
+		return parseJsonLike(fromFence);
 	} catch {}
 	const extracted = extractFirstJSON(cleaned);
 	if (extracted) try {
-		return JSON.parse(extracted);
+		return parseJsonLike(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}`);
 }
 
@@ -12907,11 +12945,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) {
@@ -12934,39 +12972,40 @@ function generatePromptSnapshot(schema, promptConfig = DEFAULT_PROMPT_CONFIG) {
 
 //#endregion
 //#region src/core/ai-extraction/extractor.ts
+let langfuseInitialized = false;
+function initLangfuse(config) {
+	if (!config.langfuse?.publicKey || !config.langfuse.secretKey) return;
+	if (langfuseInitialized) return;
+	langfuseInitialized = true;
+	try {
+		new NodeTracerProvider({ spanProcessors: [new LangfuseSpanProcessor({
+			publicKey: config.langfuse.publicKey,
+			secretKey: config.langfuse.secretKey,
+			baseUrl: config.langfuse.host || "https://us.cloud.langfuse.com",
+			exportMode: "immediate"
+		})] }).register();
+	} catch (e) {
+		console.warn("[Langfuse] Failed to initialize tracing:", e instanceof Error ? e.message : e);
+	}
+}
 const SYSTEM_PROMPT_REGEX = /## System Prompt\n([\s\S]*?)(?=## User Prompt|$)/;
 const USER_PROMPT_REGEX = /## User Prompt Template\n([\s\S]*)$/;
-const MIME_TYPES = {
-	png: "image/png",
-	jpg: "image/jpeg",
-	jpeg: "image/jpeg",
-	gif: "image/gif",
-	webp: "image/webp",
-	bmp: "image/bmp",
-	svg: "image/svg+xml",
-	pdf: "application/pdf",
-	txt: "text/plain",
-	csv: "text/csv",
-	json: "application/json",
-	md: "text/markdown",
-	html: "text/html"
-};
 function detectMimeType(filePath) {
-	return MIME_TYPES[path.extname(filePath).toLowerCase().replace(".", "")] || "application/octet-stream";
+	return mime.getType(filePath) ?? "application/octet-stream";
 }
 async function readFilePart(filePath) {
-	const mime = detectMimeType(filePath);
+	const mime$1 = detectMimeType(filePath);
 	const buffer = await fs.readFile(filePath);
 	const name$1 = path.basename(filePath);
-	if (mime.startsWith("image/")) return {
+	if (mime$1.startsWith("image/")) return {
 		type: "image",
 		image: buffer,
-		mimeType: mime
+		mimeType: mime$1
 	};
 	return {
 		type: "file",
 		data: buffer,
-		mediaType: mime,
+		mediaType: mime$1,
 		filename: name$1
 	};
 }
@@ -13078,25 +13117,35 @@ 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;
-	const selected = modelOverride ?? selectModel({
-		models: config.provider.models,
-		isImage: isImageFile,
-		fileName: file,
-		inputTokens,
-		outputTokens
-	});
+	let selected;
+	try {
+		selected = modelOverride ?? selectModel({
+			models: config.provider.models,
+			isImage: isImageFile,
+			fileName: file,
+			inputTokens,
+			outputTokens
+		});
+	} catch (e) {
+		return {
+			success: false,
+			error: e.message
+		};
+	}
 	const useStructuredOutput = selected.capabilities.structuredOutput;
+	const useTelemetry = !!(config.langfuse?.publicKey && config.langfuse.secretKey);
 	try {
+		if (useTelemetry) initLangfuse(config);
 		const provider = createOpenAICompatible({
 			baseURL: config.provider.baseURL,
 			name: "qwen",
@@ -13105,7 +13154,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);
@@ -13116,12 +13165,13 @@ async function extractStructuredData(input) {
 		}
 		const outputSchema = jsonSchema(schemaToExtractionOutputSchema(schema));
 		let result;
+		const timeoutMs = (config.provider.timeout ?? 300) * 1e3;
 		if (useFileContent) {
 			const filePart = await readFilePart(file);
 			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),
@@ -13130,8 +13180,9 @@ async function extractStructuredData(input) {
 					role: "user",
 					content: contentParts
 				}],
-				abortSignal: AbortSignal.timeout(12e4),
-				maxRetries: 0
+				abortSignal: AbortSignal.timeout(timeoutMs),
+				maxRetries: 0,
+				experimental_telemetry: { isEnabled: useTelemetry }
 			};
 			if (useStructuredOutput) fileOpts.output = Output.object({ schema: outputSchema });
 			result = await withRetry(() => generateText(fileOpts), input.onRetry);
@@ -13140,8 +13191,9 @@ async function extractStructuredData(input) {
 				model: provider.chatModel(selected.name),
 				system,
 				prompt: user,
-				abortSignal: AbortSignal.timeout(6e4),
-				maxRetries: 0
+				abortSignal: AbortSignal.timeout(timeoutMs),
+				maxRetries: 0,
+				experimental_telemetry: { isEnabled: useTelemetry }
 			};
 			if (useStructuredOutput) textOpts.output = Output.object({ schema: outputSchema });
 			result = await withRetry(() => generateText(textOpts), input.onRetry);
@@ -13159,7 +13211,10 @@ async function extractStructuredData(input) {
 		const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
 		const outputFileName = `${schema.table.name}-${timestamp}.json`;
 		const outputPath = path.join(outputDir, outputFileName);
-		await fs.writeFile(outputPath, `${JSON.stringify(data, null, 2)}\n`);
+		await writeFile(outputPath, data, {
+			spaces: 2,
+			EOL: "\n"
+		});
 		return {
 			success: true,
 			outputPath,
@@ -13224,8 +13279,8 @@ function buildInsertSql(table, data) {
 function insertTableRow({ db, table, data, parentRowId, foreignKeyColumn }) {
 	const rowData = { ...data };
 	if (parentRowId !== void 0 && foreignKeyColumn) rowData[foreignKeyColumn] = parentRowId;
-	const { sql, values } = buildInsertSql(table, rowData);
-	const info = db.prepare(sql).run(...values);
+	const { sql: sql$1, values } = buildInsertSql(table, rowData);
+	const info = db.prepare(sql$1).run(...values);
 	return Number(info.lastInsertRowid);
 }
 function parseDataByColumns(data, schema, table) {
@@ -13328,7 +13383,280 @@ async function savePromptSnapshot(schema, aiexDir) {
 }
 
 //#endregion
-//#region src/commands/extract.ts
+//#region src/core/extraction-audit.ts
+const AUDIT_ID_RE = /^[\w.-]+$/;
+const STALE_AFTER_MS = 1800 * 1e3;
+function auditDir(aiexDir) {
+	return path.join(aiexDir, "extracted", "_audit");
+}
+function auditPath(aiexDir, id) {
+	return path.join(auditDir(aiexDir), `${id}.json`);
+}
+function createAuditId(schemaName) {
+	return `${schemaName}-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}-${Math.random().toString(36).slice(2, 8)}`;
+}
+async function createExtractionAuditRecord(aiexDir, input) {
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const record = {
+		id: createAuditId(input.schemaName),
+		status: "running",
+		schemaName: input.schemaName,
+		modelName: input.modelName || void 0,
+		source: input.source,
+		retryOf: input.retryOf,
+		createdAt: now,
+		updatedAt: now
+	};
+	await fs.mkdir(auditDir(aiexDir), { recursive: true });
+	await writeFile(auditPath(aiexDir, record.id), record, {
+		spaces: 2,
+		EOL: "\n"
+	});
+	return record;
+}
+async function updateExtractionAuditRecord(aiexDir, id, patch) {
+	const current = await readExtractionAuditRecord(aiexDir, id);
+	if (!current) throw new Error(`Extraction audit record not found: ${id}`);
+	const record = {
+		...current,
+		...patch,
+		source: patch.source ?? current.source,
+		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	await fs.mkdir(auditDir(aiexDir), { recursive: true });
+	await writeFile(auditPath(aiexDir, id), record, {
+		spaces: 2,
+		EOL: "\n"
+	});
+	return record;
+}
+async function readExtractionAuditRecord(aiexDir, id) {
+	if (!AUDIT_ID_RE.test(id)) return null;
+	try {
+		return await readFile(auditPath(aiexDir, id));
+	} catch {
+		return null;
+	}
+}
+function isStale(record) {
+	if (record.status !== "running") return false;
+	const updated = Date.parse(record.updatedAt);
+	return !Number.isNaN(updated) && Date.now() - updated > STALE_AFTER_MS;
+}
+async function markStaleIfNeeded(aiexDir, record) {
+	if (!isStale(record)) return record;
+	const staleRecord = {
+		...record,
+		status: "stale",
+		error: record.error ?? "Extraction did not finish. It may have been interrupted.",
+		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	await writeFile(auditPath(aiexDir, staleRecord.id), staleRecord, {
+		spaces: 2,
+		EOL: "\n"
+	});
+	return staleRecord;
+}
+async function listExtractionAuditRecords(aiexDir) {
+	try {
+		const dir = auditDir(aiexDir);
+		const files = await fs.readdir(dir);
+		return (await Promise.all(files.filter((file) => file.endsWith(".json")).map(async (file) => {
+			try {
+				return await markStaleIfNeeded(aiexDir, await readFile(path.join(dir, file)));
+			} catch {
+				return null;
+			}
+		}))).filter((record) => !!record).sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+	} catch {
+		return [];
+	}
+}
+function isPathInside(childPath, parentPath) {
+	const relative = path.relative(path.resolve(parentPath), path.resolve(childPath));
+	return !!relative && !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+async function deleteExtractionAuditRecord(aiexDir, id) {
+	const record = await readExtractionAuditRecord(aiexDir, id);
+	if (!record) return false;
+	const uploadsDir = path.join(aiexDir, "uploads");
+	if (record.source.type === "file" && record.source.filePath && isPathInside(record.source.filePath, uploadsDir)) await fs.unlink(record.source.filePath).catch(() => {});
+	const uploadFiles = await fs.readdir(uploadsDir).catch(() => []);
+	await Promise.all(uploadFiles.filter((file) => file.startsWith(`${id}-`)).map((file) => fs.unlink(path.join(uploadsDir, file)).catch(() => {})));
+	await fs.unlink(auditPath(aiexDir, id)).catch(() => {});
+	return true;
+}
+
+//#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) {
+	return (await glob("**/*.md", {
+		cwd: dir,
+		absolute: true,
+		onlyFiles: true
+	})).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"));
+}
+async function countPdfPages(input) {
+	try {
+		return (await getDocumentProxy(input)).numPages;
+	} catch {
+		return 0;
+	}
+}
+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-${this.name}-`));
+		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 pageCount = await countPdfPages(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,
+				metadata: {
+					converter: this.name,
+					outputPath,
+					...this.config.keepOutput ? { outputDir } : {}
+				}
+			};
+		} catch (error) {
+			throw formatCommandError(error, `${this.config.command} ${args.join(" ")}`);
+		} finally {
+			if (!this.config.keepOutput) await fs.rm(tempRoot, {
+				recursive: true,
+				force: true
+			}).catch(() => {});
+		}
+	}
+};
+
+//#endregion
+//#region src/core/pdf-converter/unpdf.ts
+var UnpdfConverter = class {
+	name = "unpdf";
+	async convert(input) {
+		const data = Buffer.isBuffer(input) ? new Uint8Array(input) : input;
+		const [textResult, meta] = await Promise.all([extractText(data, { mergePages: true }), getMeta(data).catch(() => null)]);
+		return {
+			text: textResult.text,
+			pageCount: textResult.totalPages,
+			metadata: {
+				converter: this.name,
+				...meta?.info ? Object.fromEntries(Object.entries(meta.info).map(([k, v]) => [k, String(v)])) : {}
+			}
+		};
+	}
+};
+
+//#endregion
+//#region src/core/pdf-converter/factory.ts
+const registry = /* @__PURE__ */ new Map();
+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 (err) {
+			consola.warn(`${this.primary.name} failed: ${err instanceof Error ? err.message : String(err)}`);
+			consola.info(`Falling back to ${this.fallback.name}`);
+			const result = await this.fallback.convert(input, filePath);
+			return {
+				...result,
+				metadata: {
+					...result.metadata,
+					fallback: "true"
+				}
+			};
+		}
+	}
+};
+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 === "markitdown") {
+			const markitdownConfig = config.markitdown ?? DEFAULT_MARKITDOWN_CONFIG;
+			return withFallback(new ExternalCommandPdfConverter("markitdown", markitdownConfig), markitdownConfig);
+		}
+		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);
+	}
+	return instance;
+}
+
+//#endregion
+//#region src/core/extract-runner.ts
 const FILE_PART_EXTENSIONS = new Set([
 	"png",
 	"jpg",
@@ -13338,11 +13666,21 @@ const FILE_PART_EXTENSIONS = new Set([
 	"bmp",
 	"svg"
 ]);
-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 PDF_EXT_RE = /\.pdf$/i;
+const JSON_EXT_RE$1 = /\.json$/;
+const SUPPORTED_FILE_PATTERN = `*.{${[...SUPPORTED_EXTENSIONS].join(",")}}`;
 async function ensureDatabaseReady(dbPath, schema) {
 	try {
 		await fs.access(dbPath);
@@ -13362,194 +13700,706 @@ async function ensureDatabaseReady(dbPath, schema) {
 	}
 	return null;
 }
-const extractCommand = defineCommand({
-	meta: {
-		name: "extract",
-		description: "Extract structured data from text or image files"
-	},
-	args: {
-		schema: {
-			type: "string",
-			alias: "s",
-			description: "Schema name (without .json extension)",
-			required: true
-		},
-		text: {
-			type: "string",
-			alias: "t",
-			description: "Text content to extract"
-		},
-		file: {
-			type: "string",
-			alias: "f",
-			description: "File path (image) to extract from"
-		},
-		model: {
-			type: "string",
-			alias: "m",
-			description: "AI model to use for extraction (overrides auto-selection)"
-		},
-		db: {
-			type: "boolean",
-			alias: "d",
-			description: "Insert extracted data into SQLite database",
-			default: false
-		}
-	},
-	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");
-			return;
-		}
-		if (args.text && args.file) {
-			fail$1("-t and -f cannot be used together");
-			return;
-		}
-		const aiConfig = await readAIConfig(aiexDir);
-		if (!aiConfig) {
-			fail$1("AI configuration not found. Please configure AI settings in the Web interface first");
-			return;
-		}
-		if (!aiConfig.provider.apiKey) {
-			fail$1("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");
-			return;
-		}
-		let modelOverride;
-		if (args.model) {
-			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}`);
-				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 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;
+function listSupportedFiles(dir, pattern) {
+	if (!fs$1.statSync(dir).isDirectory()) throw new Error(`Not a directory: ${dir}`);
+	return globSync(pattern ?? SUPPORTED_FILE_PATTERN, {
+		cwd: dir,
+		absolute: true,
+		onlyFiles: true
+	}).filter((file) => {
+		const ext = path.extname(file).toLowerCase().replace(".", "");
+		return SUPPORTED_EXTENSIONS.has(ext);
+	}).sort();
+}
+async function loadSchema(config, schemaName) {
+	const schemaPath = path.join(config.schemaPath, `${schemaName}.json`);
+	try {
+		const parsed = await readFile(schemaPath);
+		return { schema: JsonSchemaDefinitionSchema.parse(parsed) };
+	} catch (e) {
+		if (e instanceof ZodError) return {
+			schema: null,
+			error: `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$1, "")).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 converter = createPdfConverter(aiConfig?.pdf);
+		const result = await converter.convert(buffer, filePath);
+		if (result.metadata?.fallback === "true") consola.info(`Fell back to unpdf — ${result.pageCount} page(s) extracted`);
+		else consola.info(`Converted PDF via ${converter.name}, ${result.pageCount} page(s)`);
+		const mdPath = filePath.replace(PDF_EXT_RE, ".md");
 		try {
-			const content = await fs.readFile(schemaPath, "utf-8");
-			schema = JSON.parse(content);
+			await fs.writeFile(mdPath, result.text);
+			consola.info(`Markdown saved: ${mdPath}`);
 		} catch {
-			fail$1(`Cannot read schema file: ${schemaName}.json`);
-			return;
+			const fallbackMd = path.join(os.tmpdir(), `${path.basename(filePath, ".pdf")}.md`);
+			await fs.writeFile(fallbackMd, result.text);
+			consola.info(`Markdown saved: ${fallbackMd}`);
 		}
-		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}`);
-			}
-			fail$1();
-			return;
+		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})...`);
 		}
-		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 (!result.success) {
+	});
+	if (!result.success) {
+		if (!options?.quiet) {
 			s.stop("Extraction failed");
-			fail$1(result.error || "Unknown error");
-			return;
+			consola.error(result.error || "Unknown error");
 		}
-		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 (args.db && 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 {
+			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 && options?.insert !== false) {
+		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 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();
+				const insertResult = insertExtractedData(db, schemaLoad.schema, result.data);
+				if (insertResult.success) {
+					if (!options?.quiet) s2.stop(`Inserted into ${insertResult.tablesInserted.length} table(s)`);
+					return {
+						success: true,
+						outputPath: result.outputPath,
+						data: result.data,
+						tablesInserted: insertResult.tablesInserted,
+						tokensUsed: result.tokensUsed
+					};
+				} else {
+					if (!options?.quiet) s2.stop("Database insert failed");
+					consola.error(insertResult.error || "Unknown error");
+					return {
+						success: false,
+						error: insertResult.error
+					};
 				}
-			} catch (e) {
-				s2.stop("Database insert failed");
-				fail$1(e instanceof Error ? e.message : String(e));
-				return;
+			} 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)
+			};
 		}
-		outro("Done!");
-	}
-});
-
-//#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
-const execFileAsync$1 = promisify(execFile);
-function fail(message) {
-	if (message) consola.error(message);
-	outro("Failed!");
-	process.exitCode = 1;
-}
-async function writeJsonIfAbsent(filePath, data) {
-	try {
-		await fs.writeFile(filePath, `${JSON.stringify(data, null, 2)}\n`, { flag: "wx" });
-		return "created";
-	} catch (error) {
-		if (error.code === "EEXIST") return "skipped";
-		throw error;
 	}
+	return {
+		success: true,
+		outputPath: result.outputPath,
+		data: result.data,
+		tokensUsed: result.tokensUsed
+	};
 }
-async function generateFromFiles(schemaFiles, config) {
-	const result = parseAllSchemas(await Promise.all(schemaFiles.map(async (filePath) => {
-		return {
+async function processOneFile(aiexDir, config, aiConfig, schemaName, filePath, modelOverride, options) {
+	const audit = await createExtractionAuditRecord(aiexDir, {
+		schemaName,
+		modelName: modelOverride?.name,
+		source: {
+			type: "file",
 			filePath,
-			content: await fs.readFile(filePath, "utf-8")
-		};
-	})));
+			fileName: path.basename(filePath)
+		}
+	});
+	try {
+		const input = await readExtractFileInput(filePath, aiConfig);
+		const r = await extractSingle(aiexDir, config, aiConfig, schemaName, input.text, input.filePath, modelOverride, {
+			quiet: false,
+			insert: options?.insert
+		});
+		if (r.success) {
+			await updateExtractionAuditRecord(aiexDir, audit.id, {
+				status: "succeeded",
+				outputPath: r.outputPath,
+				outputName: r.outputPath ? path.basename(r.outputPath) : void 0,
+				tablesInserted: r.tablesInserted,
+				tokensUsed: r.tokensUsed
+			});
+			consola.success(`Processed: ${path.basename(filePath)}`);
+			return true;
+		} else {
+			await updateExtractionAuditRecord(aiexDir, audit.id, {
+				status: "failed",
+				error: r.error || "Extraction failed"
+			});
+			consola.error(`Failed: ${r.error}`);
+			return false;
+		}
+	} catch (e) {
+		await updateExtractionAuditRecord(aiexDir, audit.id, {
+			status: "failed",
+			error: e instanceof Error ? e.message : String(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, options) {
+	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, options)) 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
+function getIdArg(args) {
+	if (typeof args.id === "string") return args.id;
+	const positional = args._;
+	return Array.isArray(positional) && typeof positional[0] === "string" ? positional[0] : "";
+}
+function formatSource(source) {
+	return source.type === "file" ? source.fileName || "file" : "text";
+}
+async function loadConfiguredAI(aiexDir) {
+	const aiConfig = await readAIConfig(aiexDir);
+	if (!aiConfig) {
+		failCommand("AI configuration not found. Please run \"aiex web\" to configure AI settings first");
+		return null;
+	}
+	if (!aiConfig.provider.apiKey) {
+		failCommand("API Key not configured. Please configure AI settings in the Web interface first");
+		return null;
+	}
+	if (!aiConfig.provider.models?.length) {
+		failCommand("No models configured. Please add at least one model in AI Settings");
+		return null;
+	}
+	return aiConfig;
+}
+function resolveModelOverride(aiConfig, modelName) {
+	if (!modelName) return void 0;
+	const matched = aiConfig.provider.models.find((m) => m.name === modelName);
+	if (!matched) {
+		failCommand(`Model "${modelName}" not found in configuration. Available models: ${aiConfig.provider.models.map((m) => m.name).join(", ")}`);
+		return null;
+	}
+	return matched;
+}
+async function runAuditedSingleExtraction(input) {
+	const audit = await createExtractionAuditRecord(input.aiexDir, {
+		schemaName: input.schemaName,
+		modelName: input.modelOverride?.name,
+		source: input.source,
+		retryOf: input.retryOf
+	});
+	const result = await extractSingle(input.aiexDir, input.config, input.aiConfig, input.schemaName, input.text, input.filePath, input.modelOverride, { insert: input.insert });
 	if (!result.success) {
-		consola.error(result.error);
+		await updateExtractionAuditRecord(input.aiexDir, audit.id, {
+			status: "failed",
+			error: result.error || "Extraction failed"
+		});
 		return false;
 	}
-	for (const warning of result.data.warnings) consola.warn(warning);
-	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)`);
+	await updateExtractionAuditRecord(input.aiexDir, audit.id, {
+		status: "succeeded",
+		outputPath: result.outputPath,
+		outputName: result.outputPath ? path.basename(result.outputPath) : void 0,
+		tablesInserted: result.tablesInserted,
+		tokensUsed: result.tokensUsed
+	});
 	return true;
 }
-async function migrate(config, migrationName) {
+const historyCommand = defineCommand({
+	meta: {
+		name: "history",
+		description: "List extraction audit records"
+	},
+	async run() {
+		const config = createMigrationConfig(process.cwd());
+		const records = await listExtractionAuditRecords(path.dirname(config.schemaPath));
+		if (records.length === 0) {
+			consola.info("No extraction history found");
+			return;
+		}
+		for (const record of records) {
+			const suffix = record.error ? ` — ${record.error}` : record.outputName ? ` — ${record.outputName}` : "";
+			consola.info(`${record.status.padEnd(9)} ${record.id}  ${record.schemaName}  ${formatSource(record.source)}${suffix}`);
+		}
+	}
+});
+const showCommand = defineCommand({
+	meta: {
+		name: "show",
+		description: "Show an extraction audit record"
+	},
+	args: { id: {
+		type: "string",
+		description: "Audit record id"
+	} },
+	async run({ args }) {
+		const id = getIdArg(args);
+		if (!id) {
+			failCommand("Audit record id is required");
+			return;
+		}
+		const config = createMigrationConfig(process.cwd());
+		const record = await readExtractionAuditRecord(path.dirname(config.schemaPath), id);
+		if (!record) {
+			failCommand(`Extraction record not found: ${id}`);
+			return;
+		}
+		consola.info(JSON.stringify(record, null, 2));
+	}
+});
+const retryCommand = defineCommand({
+	meta: {
+		name: "retry",
+		description: "Retry an extraction audit record"
+	},
+	args: {
+		id: {
+			type: "string",
+			description: "Audit record id"
+		},
+		noInsert: {
+			type: "boolean",
+			description: "Extract and save JSON without inserting into SQLite",
+			default: false
+		}
+	},
+	async run({ args }) {
+		intro(pc.inverse(" aiex extract retry "));
+		const id = getIdArg(args);
+		if (!id) {
+			failCommand("Audit record id is required");
+			return;
+		}
+		const config = createMigrationConfig(process.cwd());
+		const aiexDir = path.dirname(config.schemaPath);
+		const record = await readExtractionAuditRecord(aiexDir, id);
+		if (!record) {
+			failCommand(`Extraction record not found: ${id}`);
+			return;
+		}
+		const aiConfig = await loadConfiguredAI(aiexDir);
+		if (!aiConfig) return;
+		const modelOverride = resolveModelOverride(aiConfig, record.modelName);
+		if (modelOverride === null) return;
+		try {
+			const sourceInput = record.source.type === "file" ? await readExtractFileInput(record.source.filePath || "", aiConfig) : {
+				text: record.source.text || "",
+				filePath: void 0
+			};
+			if (!await runAuditedSingleExtraction({
+				aiexDir,
+				config,
+				aiConfig,
+				schemaName: record.schemaName,
+				text: sourceInput.text,
+				filePath: sourceInput.filePath,
+				source: record.source,
+				modelOverride,
+				retryOf: record.id,
+				insert: !args.noInsert
+			})) {
+				failCommand();
+				return;
+			}
+			outro("Done!");
+		} catch (error) {
+			failCommand(error instanceof Error ? error.message : String(error));
+		}
+	}
+});
+const rmCommand = defineCommand({
+	meta: {
+		name: "rm",
+		description: "Delete an extraction audit record and cached upload"
+	},
+	args: { id: {
+		type: "string",
+		description: "Audit record id"
+	} },
+	async run({ args }) {
+		const id = getIdArg(args);
+		if (!id) {
+			failCommand("Audit record id is required");
+			return;
+		}
+		const config = createMigrationConfig(process.cwd());
+		if (!await deleteExtractionAuditRecord(path.dirname(config.schemaPath), id)) {
+			failCommand(`Extraction record not found: ${id}`);
+			return;
+		}
+		consola.success(`Deleted extraction record: ${id}`);
+	}
+});
+const extractCommand = defineCommand({
+	meta: {
+		name: "extract",
+		description: "Extract structured data from text, images, or PDFs"
+	},
+	subCommands: {
+		history: historyCommand,
+		show: showCommand,
+		retry: retryCommand,
+		rm: rmCommand
+	},
+	args: {
+		schema: {
+			type: "string",
+			alias: "s",
+			description: "Schema name (without .json extension)"
+		},
+		text: {
+			type: "string",
+			alias: "t",
+			description: "Text content to extract"
+		},
+		file: {
+			type: "string",
+			alias: "f",
+			description: "File path (image/PDF) to extract from"
+		},
+		model: {
+			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\")"
+		},
+		noInsert: {
+			type: "boolean",
+			description: "Extract and save JSON without inserting into SQLite",
+			default: false
+		}
+	},
+	async run({ args }) {
+		intro(pc.inverse(" aiex extract "));
+		const config = createMigrationConfig(process.cwd());
+		const aiexDir = path.dirname(config.schemaPath);
+		if (args.dir && args.text) {
+			failCommand("Cannot combine -t/--text with -d/--dir");
+			return;
+		}
+		if (args.dir && args.file) {
+			failCommand("Cannot combine -f/--file with -d/--dir");
+			return;
+		}
+		const aiConfig = await loadConfiguredAI(aiexDir);
+		if (!aiConfig) return;
+		const modelOverride = resolveModelOverride(aiConfig, args.model);
+		if (modelOverride === null) return;
+		if (!args.schema && !args.text && !args.file && !args.dir) {
+			if (await runInteractive(aiexDir, config, aiConfig, modelOverride)) outro("Done!");
+			return;
+		}
+		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, { insert: !args.noInsert });
+			if (!result.ok) {
+				failCommand(result.error);
+				return;
+			}
+			if (result.failCount > 0) process.exitCode = 1;
+			if (result.failCount > 0) outro(`Completed with failures (${result.failCount} failed)`);
+			else outro("Done!");
+			return;
+		}
+		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 runAuditedSingleExtraction({
+			aiexDir,
+			config,
+			aiConfig,
+			schemaName: args.schema,
+			text: text$1,
+			filePath,
+			source: filePath ? {
+				type: "file",
+				filePath: args.file,
+				fileName: path.basename(args.file)
+			} : {
+				type: "text",
+				text: text$1
+			},
+			modelOverride,
+			insert: !args.noInsert
+		})) {
+			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 web")} to create and configure schemas first.`);
+		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 (isCancel(textContent)) {
+			cancel("Cancelled");
+			return false;
+		}
+		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";
+			}
+		});
+		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;
+		}
+		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 src/core/schema-runner.ts
+const execFileAsync = promisify(execFile);
+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) 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, 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 runSchemaMigration(config, migrationName) {
 	const helperPath = resolveHelperPath();
 	const helperArgs = [
 		resolveTsxPath(),
@@ -13560,40 +14410,62 @@ 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(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",
 		description: "Sync JSON Schema to SQLite database"
 	},
 	args: {
-		init: {
-			type: "boolean",
-			alias: "i",
-			description: "Only initialize .aiex/ directory with example schema",
-			default: false
-		},
 		generate: {
 			type: "boolean",
 			alias: "g",
@@ -13608,226 +14480,21 @@ const schemaCommand = defineCommand({
 	async run({ args }) {
 		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 userSchema = {
-				$schema: $id,
-				title: "User",
-				type: "object",
-				table: {
-					name: "users",
-					timestamps: true,
-					softDelete: true
-				},
-				properties: {
-					id: {
-						type: "integer",
-						primary: true,
-						autoIncrement: true
-					},
-					email: {
-						type: "string",
-						format: "email",
-						unique: true
-					},
-					username: {
-						type: "string",
-						minLength: 3,
-						maxLength: 50,
-						unique: true
-					},
-					displayName: {
-						type: "string",
-						maxLength: 100
-					},
-					bio: {
-						type: "string",
-						maxLength: 500
-					},
-					avatarUrl: {
-						type: "string",
-						format: "uri"
-					},
-					role: {
-						type: "string",
-						default: "member"
-					},
-					isActive: {
-						type: "boolean",
-						default: true
-					},
-					lastLoginAt: {
-						type: "string",
-						format: "date-time"
-					},
-					profile: {
-						type: "object",
-						drizzle: { mode: "json" },
-						properties: {
-							website: { type: "string" },
-							location: { type: "string" },
-							socialLinks: {
-								type: "array",
-								items: {
-									type: "object",
-									properties: {
-										platform: { type: "string" },
-										url: { type: "string" }
-									}
-								}
-							}
-						}
-					},
-					preferences: {
-						type: "object",
-						nested: {
-							enabled: true,
-							relation: "has-one"
-						},
-						properties: {
-							theme: {
-								type: "string",
-								default: "light"
-							},
-							language: {
-								type: "string",
-								default: "en"
-							},
-							emailNotifications: {
-								type: "boolean",
-								default: true
-							},
-							pushNotifications: {
-								type: "boolean",
-								default: false
-							}
-						}
-					}
-				},
-				required: ["email", "username"]
-			};
-			const postSchema = {
-				$schema: $id,
-				title: "Post",
-				type: "object",
-				table: {
-					name: "posts",
-					timestamps: true,
-					softDelete: true
-				},
-				properties: {
-					id: {
-						type: "integer",
-						primary: true,
-						autoIncrement: true
-					},
-					title: {
-						type: "string",
-						minLength: 5,
-						maxLength: 200
-					},
-					slug: {
-						type: "string",
-						maxLength: 250,
-						unique: true
-					},
-					content: { type: "string" },
-					excerpt: {
-						type: "string",
-						maxLength: 300
-					},
-					authorId: { type: "integer" },
-					status: {
-						type: "string",
-						default: "draft"
-					},
-					viewCount: {
-						type: "integer",
-						default: 0,
-						minimum: 0
-					},
-					likeCount: {
-						type: "integer",
-						default: 0,
-						minimum: 0
-					},
-					publishedAt: {
-						type: "string",
-						format: "date-time"
-					},
-					tags: {
-						type: "array",
-						items: { type: "string" }
-					},
-					metadata: {
-						type: "object",
-						drizzle: { mode: "json" },
-						properties: {
-							featuredImage: { type: "string" },
-							readingTime: { type: "integer" },
-							seoTitle: { type: "string" },
-							seoDescription: { type: "string" }
-						}
-					},
-					comments: {
-						type: "array",
-						items: {
-							type: "object",
-							nested: {
-								enabled: true,
-								relation: "has-many"
-							},
-							properties: {
-								content: {
-									type: "string",
-									minLength: 1,
-									maxLength: 1e3
-								},
-								authorId: { type: "integer" },
-								status: {
-									type: "string",
-									default: "pending"
-								},
-								parentId: { type: "integer" }
-							}
-						}
-					}
-				},
-				required: [
-					"title",
-					"slug",
-					"authorId"
-				]
-			};
-			const userStatus = await writeJsonIfAbsent(path.join(config.schemaPath, "user.json"), userSchema);
-			const postStatus = await writeJsonIfAbsent(path.join(config.schemaPath, "post.json"), postSchema);
-			consola.success(`Initialized ${pc.cyan(".aiex/")} with example schemas`);
-			if (userStatus === "skipped") consola.warn(`${pc.cyan(".aiex/schema/user.json")} already exists, skipped`);
-			if (postStatus === "skipped") consola.warn(`${pc.cyan(".aiex/schema/post.json")} already exists, skipped`);
-			consola.info("Example includes: User (with preferences has-one), Post (with comments has-many)");
-			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/")}`);
+			consola.info(`Run ${pc.cyan("aiex web")} to create and configure schemas in the Web UI`);
+			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) {
@@ -13836,18 +14503,210 @@ 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!");
 	}
 });
 
+//#endregion
+//#region src/core/notion-sink.ts
+const RICH_TEXT_LIMIT = 2e3;
+const UUID_RE = /^[0-9a-f]{32}$/i;
+const HYPHENATED_UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const UUID_IN_TEXT_RE = /[0-9a-f]{32}/i;
+function truncateText(value) {
+	return value.length > RICH_TEXT_LIMIT ? value.slice(0, RICH_TEXT_LIMIT) : value;
+}
+function stringifyValue(value) {
+	if (value === null || value === void 0) return "";
+	if (typeof value === "string") return value;
+	if (typeof value === "number" || typeof value === "boolean") return String(value);
+	return JSON.stringify(value);
+}
+function asNumber(value) {
+	if (typeof value === "number" && Number.isFinite(value)) return value;
+	if (typeof value === "string" && value.trim()) {
+		const parsed = Number(value);
+		return Number.isFinite(parsed) ? parsed : null;
+	}
+	return null;
+}
+function asBoolean(value) {
+	if (typeof value === "boolean") return value;
+	if (typeof value === "number") return value !== 0;
+	if (typeof value === "string") {
+		const normalized = value.trim().toLowerCase();
+		return [
+			"true",
+			"yes",
+			"1",
+			"y"
+		].includes(normalized);
+	}
+	return !!value;
+}
+function asDateStart(value) {
+	if (value instanceof Date && !Number.isNaN(value.getTime())) return value.toISOString();
+	if (typeof value === "number" && Number.isFinite(value)) {
+		const date = new Date(value);
+		return Number.isNaN(date.getTime()) ? null : date.toISOString();
+	}
+	if (typeof value === "string" && value.trim()) {
+		const ms = Date.parse(value);
+		if (Number.isNaN(ms)) return null;
+		return new Date(ms).toISOString();
+	}
+	return null;
+}
+function asStringArray(value) {
+	if (Array.isArray(value)) return value.map((item) => stringifyValue(item).trim()).filter(Boolean);
+	const text$1 = stringifyValue(value).trim();
+	return text$1 ? [text$1] : [];
+}
+function buildPropertyValue(type, value) {
+	const text$1 = truncateText(stringifyValue(value));
+	switch (type) {
+		case "title": return { title: text$1 ? [{ text: { content: text$1 } }] : [] };
+		case "rich_text": return { rich_text: text$1 ? [{ text: { content: text$1 } }] : [] };
+		case "number": return { number: asNumber(value) };
+		case "checkbox": return { checkbox: asBoolean(value) };
+		case "date": {
+			const start = asDateStart(value);
+			return { date: start ? { start } : null };
+		}
+		case "select": {
+			const name$1 = stringifyValue(value).trim();
+			return { select: name$1 ? { name: name$1 } : null };
+		}
+		case "multi_select": return { multi_select: asStringArray(value).map((name$1) => ({ name: name$1 })) };
+		case "url": return { url: text$1 || null };
+		case "email": return { email: text$1 || null };
+		case "phone_number": return { phone_number: text$1 || null };
+		default: return null;
+	}
+}
+function findTitleProperty(properties, preferred) {
+	if (preferred && properties[preferred]?.type === "title") return preferred;
+	return Object.entries(properties).find(([, property]) => property?.type === "title")?.[0] ?? null;
+}
+function hyphenateDatabaseId(value) {
+	const id = value.replace(/-/g, "");
+	if (!UUID_RE.test(id)) return value;
+	return `${id.slice(0, 8)}-${id.slice(8, 12)}-${id.slice(12, 16)}-${id.slice(16, 20)}-${id.slice(20)}`;
+}
+function parseNotionDatabaseId(value) {
+	const input = value.trim();
+	if (!input) return "";
+	if (HYPHENATED_UUID_RE.test(input)) return input;
+	if (UUID_RE.test(input)) return hyphenateDatabaseId(input);
+	const match = input.replace(/-/g, "").match(UUID_IN_TEXT_RE);
+	return match ? hyphenateDatabaseId(match[0]) : input;
+}
+function normalizeFieldName(value) {
+	return value.normalize("NFKC").toLowerCase().replace(/[^\p{Letter}\p{Number}]+/gu, "");
+}
+function buildMatchKeys(field) {
+	return [
+		field.name,
+		field.title,
+		field.description
+	].filter((value) => !!value?.trim()).map(normalizeFieldName).filter(Boolean);
+}
+function suggestFieldMap(schemaFields, databaseProperties) {
+	const propertyByKey = /* @__PURE__ */ new Map();
+	for (const propertyName of Object.keys(databaseProperties)) propertyByKey.set(normalizeFieldName(propertyName), propertyName);
+	const fieldMap = {};
+	for (const field of schemaFields) for (const key of buildMatchKeys(field)) {
+		const propertyName = propertyByKey.get(key);
+		if (propertyName) {
+			fieldMap[field.name] = propertyName;
+			break;
+		}
+	}
+	return fieldMap;
+}
+async function inspectNotionDatabase(input) {
+	if (!input.token.trim()) throw new Error("Notion integration token is required.");
+	const databaseId = parseNotionDatabaseId(input.databaseId);
+	if (!databaseId) throw new Error("Notion database URL or ID is required.");
+	const databaseProperties = (await new Client({ auth: input.token }).databases.retrieve({ database_id: databaseId })).properties;
+	return {
+		databaseId,
+		titleProperty: findTitleProperty(databaseProperties) ?? void 0,
+		properties: Object.entries(databaseProperties).map(([name$1, property]) => ({
+			name: name$1,
+			type: property?.type ?? "unknown"
+		})).sort((a, b) => a.name.localeCompare(b.name)),
+		suggestedFieldMap: suggestFieldMap(input.schemaFields, databaseProperties)
+	};
+}
+function validateNotionConfig(config) {
+	if (!config?.enabled) return "Notion export is not enabled. Configure Notion settings first.";
+	if (!config.token.trim()) return "Notion integration token is required.";
+	return null;
+}
+async function writeNotionPage(config, schemaName, data) {
+	const configError = validateNotionConfig(config);
+	if (configError) throw new Error(configError);
+	const notionConfig = config;
+	const schemaConfig = notionConfig.schemas[schemaName];
+	if (!schemaConfig) throw new Error(`Notion database is not configured for schema "${schemaName}".`);
+	if (!schemaConfig.databaseId.trim()) throw new Error(`Notion database ID is required for schema "${schemaName}".`);
+	const notion = new Client({ auth: notionConfig.token });
+	const databaseProperties = (await notion.databases.retrieve({ database_id: schemaConfig.databaseId })).properties;
+	const fieldMap = schemaConfig.fieldMap ?? {};
+	const properties = {};
+	for (const [sourceField, sourceValue] of Object.entries(data)) {
+		const notionPropertyName = fieldMap[sourceField] ?? sourceField;
+		const notionProperty = databaseProperties[notionPropertyName];
+		if (!notionProperty) continue;
+		const propertyValue = buildPropertyValue(notionProperty.type, sourceValue);
+		if (propertyValue) properties[notionPropertyName] = propertyValue;
+	}
+	const titleProperty = findTitleProperty(databaseProperties, schemaConfig.titleProperty);
+	if (titleProperty && !properties[titleProperty]) properties[titleProperty] = buildPropertyValue("title", Object.entries(data).find(([, value]) => typeof value === "string" && value.trim())?.[1] ?? schemaName);
+	if (Object.keys(properties).length === 0) throw new Error("No extracted fields matched Notion database properties.");
+	return {
+		pageId: (await notion.pages.create({
+			parent: { database_id: schemaConfig.databaseId },
+			properties
+		})).id,
+		databaseId: schemaConfig.databaseId
+	};
+}
+
 //#endregion
 //#region src/server/routes/ai.ts
+const JSON_EXT_RE = /\.json$/i;
+function extractSchemaFields(schema) {
+	if (!schema?.properties || typeof schema.properties !== "object") return [];
+	return Object.entries(schema.properties).filter(([, property]) => {
+		if (property?.nested?.enabled) return false;
+		if (property?.type === "array" && property?.items?.nested?.enabled) return false;
+		return true;
+	}).map(([name$1, property]) => ({
+		name: name$1,
+		title: typeof property?.title === "string" ? property.title : void 0,
+		description: typeof property?.description === "string" ? property.description : void 0
+	}));
+}
+async function loadSchemaFields(config, schemaName) {
+	const safeName = path.basename(schemaName).replace(JSON_EXT_RE, "");
+	return extractSchemaFields(await readFile(path.join(config.schemaPath, `${safeName}.json`)));
+}
 function aiRoutes(config) {
 	const app = new Hono();
 	const aiexDir = path.dirname(config.schemaPath);
@@ -13863,13 +14722,7 @@ function aiRoutes(config) {
 				}
 			});
 		}
-		return c.json({
-			...aiConfig,
-			provider: {
-				...aiConfig.provider,
-				apiKey: maskApiKey(aiConfig.provider.apiKey)
-			}
-		});
+		return c.json(aiConfig);
 	});
 	app.post("/ai/registry-lookup", async (c) => {
 		try {
@@ -13880,6 +14733,32 @@ function aiRoutes(config) {
 			return c.json({});
 		}
 	});
+	app.post("/ai/notion/inspect", async (c) => {
+		try {
+			const body = await c.req.json();
+			const token = typeof body.token === "string" ? body.token : "";
+			const databaseId = typeof body.databaseId === "string" ? body.databaseId : "";
+			const schemaName = typeof body.schemaName === "string" ? body.schemaName : "";
+			if (!schemaName) return c.json({
+				success: false,
+				error: "Schema is required"
+			}, 400);
+			const result = await inspectNotionDatabase({
+				token,
+				databaseId,
+				schemaFields: await loadSchemaFields(config, schemaName)
+			});
+			return c.json({
+				success: true,
+				...result
+			});
+		} catch (error) {
+			return c.json({
+				success: false,
+				error: getErrorMessage(error)
+			}, 400);
+		}
+	});
 	app.put("/ai/config", async (c) => {
 		try {
 			const body = await c.req.json();
@@ -13897,10 +14776,18 @@ function aiRoutes(config) {
 				success: false,
 				error: "At least one model must be configured"
 			}, 400);
-			if (body.provider?.apiKey?.startsWith("sk-***")) {
-				const existing = await readAIConfig(aiexDir);
-				if (existing) body.provider.apiKey = existing.provider.apiKey;
-				else body.provider.apiKey = "";
+			if (body.notion?.enabled) {
+				if (!body.notion.token?.trim()) return c.json({
+					success: false,
+					error: "Notion token is required when Notion export is enabled"
+				}, 400);
+				for (const [schemaName, schemaConfig] of Object.entries(body.notion.schemas ?? {})) {
+					if (typeof schemaConfig.databaseId === "string") schemaConfig.databaseId = parseNotionDatabaseId(schemaConfig.databaseId);
+					if (!schemaConfig.databaseId?.trim()) return c.json({
+						success: false,
+						error: `Notion database ID is required for schema "${schemaName}"`
+					}, 400);
+				}
 			}
 			await writeAIConfig(aiexDir, AIConfigSchema.parse(body));
 			return c.json({ success: true });
@@ -13917,10 +14804,25 @@ function aiRoutes(config) {
 //#endregion
 //#region src/server/routes/data.ts
 const FILE_REGEX = /\.json$/;
-const EXTRACTION_FILE_RE = /^[\w.-]+\.json$/;
-const TABLE_NAME_RE$1 = /^[a-z][a-z0-9_]*$/;
 const TIMESTAMP_CLEANUP = /(\d{2})-(\d{2})-(\d{2})/;
 const TIMESTAMP_TZ = /(\d{3})Z/;
+const tableParamSchema = z.object({ name: z.string().regex(/^[a-z][a-z0-9_]*$/) });
+const extractionFileParamSchema = z.object({ name: z.string().regex(/^[\w.-]+\.json$/).refine((name$1) => name$1 === path.basename(name$1) && !name$1.includes("..")) });
+const tableQuerySchema = z.object({
+	page: z.coerce.number().int().min(1).catch(1),
+	pageSize: z.coerce.number().int().min(1).max(500).catch(50),
+	search: z.string().catch(""),
+	sortField: z.string().optional(),
+	sortOrder: z.preprocess((value) => typeof value === "string" ? value.toLowerCase() : value, z.enum(["asc", "desc"]).catch("asc"))
+});
+function invalidParamResponse$1(message) {
+	return (result, c) => {
+		if (!result.success) return c.json({ error: message }, 400);
+	};
+}
+function createReadonlyQueryDb(databasePath) {
+	return new Kysely({ dialect: new SqliteDialect({ database: new Database(databasePath, { readonly: true }) }) });
+}
 function dataRoutes(config) {
 	const app = new Hono();
 	const aiexDir = path.dirname(config.schemaPath);
@@ -13968,15 +14870,19 @@ function dataRoutes(config) {
 			let db = null;
 			let dbTables = [];
 			try {
-				db = new Database(config.databasePath, { readonly: true });
-				dbTables = db.prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' AND name NOT LIKE '_%' ORDER BY name`).all().map((r) => r.name);
+				db = createReadonlyQueryDb(config.databasePath);
+				dbTables = (await sql`
+          select name
+          from sqlite_master
+          where type = 'table' and name not like 'sqlite_%' and name not like '_%'
+          order by name
+        `.execute(db)).rows.map((row) => row.name);
 			} catch {} finally {
-				db?.close();
+				await db?.destroy();
 			}
 			const tables = [];
 			for (const file of schemaFiles) try {
-				const content = await fs.readFile(path.join(schemaDir, file), "utf-8");
-				const schema = JSON.parse(content);
+				const schema = await readFile(path.join(schemaDir, file));
 				const tableName = schema.table?.name;
 				if (!tableName) continue;
 				tables.push({
@@ -13992,46 +14898,64 @@ function dataRoutes(config) {
 			return c.json({ error: error instanceof Error ? error.message : String(error) }, 500);
 		}
 	});
-	app.get("/data/tables/:name", async (c) => {
-		const tableName = c.req.param("name");
-		if (!TABLE_NAME_RE$1.test(tableName)) return c.json({ error: "Invalid table name" }, 400);
-		const sortField = c.req.query("sortField");
-		const sortOrder = c.req.query("sortOrder") || "asc";
+	app.get("/data/tables/:name", zValidator("param", tableParamSchema, invalidParamResponse$1("Invalid table name")), zValidator("query", tableQuerySchema), async (c) => {
+		const { name: tableName } = c.req.valid("param");
+		const { page, pageSize, search, sortField, sortOrder } = c.req.valid("query");
 		let db;
 		try {
-			db = new Database(config.databasePath, { readonly: true });
+			db = createReadonlyQueryDb(config.databasePath);
 		} catch {
 			return c.json({ error: "Database not found. Run `aiex schema` first." }, 400);
 		}
 		try {
-			if (!db.prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name=?`).get(tableName)) {
-				db.close();
-				return c.json({ error: `Table "${tableName}" not found in database` }, 404);
-			}
-			const columns = db.prepare(`PRAGMA table_info(\`${tableName}\`)`).all().map((col) => ({
+			if ((await sql`
+          select name
+          from sqlite_master
+          where type = 'table' and name = ${tableName}
+        `.execute(db)).rows.length === 0) return c.json({ error: `Table "${tableName}" not found in database` }, 404);
+			const columns = (await sql`
+          pragma table_info(${sql.table(tableName)})
+        `.execute(db)).rows.map((col) => ({
 				name: col.name,
 				type: col.type,
 				notNull: !!col.notnull,
 				pk: !!col.pk
 			}));
-			let orderClause = "";
-			if (sortField && columns.some((c$1) => c$1.name === sortField)) orderClause = ` ORDER BY \`${sortField}\` ${sortOrder.toLowerCase() === "desc" ? "DESC" : "ASC"}`;
-			const total = db.prepare(`SELECT COUNT(*) as count FROM \`${tableName}\``).get().count;
-			const rows = db.prepare(`SELECT * FROM \`${tableName}\`${orderClause} LIMIT 200`).all();
+			const searchConditions = columns.map((col) => sql`${sql.ref(col.name)} like ${`%${search}%`}`);
+			const searchCondition = search ? sql`where ${sql.join(searchConditions, sql` or `)}` : sql``;
+			const sortColumn = columns.find((col) => col.name === sortField);
+			const orderBy = sortColumn ? sql`order by ${sql.ref(sortColumn.name)} ${sql.raw(sortOrder === "desc" ? "desc" : "asc")}` : sql``;
+			const total = (await sql`
+          select count(*) as count
+          from ${sql.table(tableName)}
+          ${searchCondition}
+        `.execute(db)).rows[0]?.count ?? 0;
+			const offset = (page - 1) * pageSize;
+			const totalPages = Math.max(1, Math.ceil(total / pageSize));
+			const result = await sql`
+          select *
+          from ${sql.table(tableName)}
+          ${searchCondition}
+          ${orderBy}
+          limit ${pageSize}
+          offset ${offset}
+        `.execute(db);
 			return c.json({
 				columns,
-				rows,
-				total
+				rows: result.rows,
+				total,
+				page,
+				pageSize,
+				totalPages
 			});
 		} catch (error) {
 			return c.json({ error: error instanceof Error ? error.message : String(error) }, 500);
 		} finally {
-			db.close();
+			await db.destroy();
 		}
 	});
-	app.get("/data/:name", async (c) => {
-		const name$1 = c.req.param("name");
-		if (name$1 !== path.basename(name$1) || !EXTRACTION_FILE_RE.test(name$1) || name$1.includes("..")) return c.json({ error: "Invalid extraction file name" }, 400);
+	app.get("/data/:name", zValidator("param", extractionFileParamSchema, invalidParamResponse$1("Invalid extraction file name")), async (c) => {
+		const { name: name$1 } = c.req.valid("param");
 		const filePath = path.join(extractedDir, name$1);
 		try {
 			const content = await fs.readFile(filePath, "utf-8");
@@ -14047,14 +14971,256 @@ function dataRoutes(config) {
 	return app;
 }
 
+//#endregion
+//#region src/server/routes/extract.ts
+function getFormString(value) {
+	if (Array.isArray(value)) return getFormString(value[0]);
+	return typeof value === "string" ? value.trim() : "";
+}
+function getFormFile(value) {
+	if (Array.isArray(value)) return getFormFile(value[0]);
+	return value instanceof File && value.size > 0 ? value : null;
+}
+function safeUploadName(name$1) {
+	return path.basename(name$1).replace(/[^\w.-]/g, "_") || "upload.txt";
+}
+async function saveUploadToFile(file, uploadsDir, id) {
+	await fs.mkdir(uploadsDir, { recursive: true });
+	const filePath = path.join(uploadsDir, `${id}-${safeUploadName(file.name)}`);
+	const buffer = Buffer.from(await file.arrayBuffer());
+	await fs.writeFile(filePath, buffer);
+	return filePath;
+}
+async function executeAuditedExtraction(input) {
+	const aiConfig = await readAIConfig(input.aiexDir);
+	if (!aiConfig) {
+		const record$1 = await updateExtractionAuditRecord(input.aiexDir, input.auditId, {
+			status: "failed",
+			error: "AI configuration not found. Configure AI settings first."
+		});
+		return new Response(JSON.stringify({
+			success: false,
+			error: record$1.error,
+			auditId: record$1.id
+		}), {
+			status: 400,
+			headers: { "content-type": "application/json" }
+		});
+	}
+	if (!aiConfig.provider.apiKey) {
+		const record$1 = await updateExtractionAuditRecord(input.aiexDir, input.auditId, {
+			status: "failed",
+			error: "API Key not configured. Configure AI settings first."
+		});
+		return new Response(JSON.stringify({
+			success: false,
+			error: record$1.error,
+			auditId: record$1.id
+		}), {
+			status: 400,
+			headers: { "content-type": "application/json" }
+		});
+	}
+	if (!aiConfig.provider.models?.length) {
+		const record$1 = await updateExtractionAuditRecord(input.aiexDir, input.auditId, {
+			status: "failed",
+			error: "No models configured. Add at least one model in AI Settings."
+		});
+		return new Response(JSON.stringify({
+			success: false,
+			error: record$1.error,
+			auditId: record$1.id
+		}), {
+			status: 400,
+			headers: { "content-type": "application/json" }
+		});
+	}
+	const modelOverride = input.modelName ? aiConfig.provider.models.find((model) => model.name === input.modelName) : void 0;
+	if (input.modelName && !modelOverride) {
+		const record$1 = await updateExtractionAuditRecord(input.aiexDir, input.auditId, {
+			status: "failed",
+			error: `Model "${input.modelName}" not found in AI settings`
+		});
+		return new Response(JSON.stringify({
+			success: false,
+			error: record$1.error,
+			auditId: record$1.id
+		}), {
+			status: 400,
+			headers: { "content-type": "application/json" }
+		});
+	}
+	let inputText = input.text;
+	let inputFilePath = input.filePath;
+	if (input.filePath) {
+		const source = await readExtractFileInput(input.filePath, aiConfig);
+		inputText = source.text;
+		inputFilePath = source.filePath;
+	}
+	const result = await extractSingle(input.aiexDir, input.config, aiConfig, input.schemaName, inputText, inputFilePath, modelOverride, { quiet: true });
+	if (!result.success) {
+		const record$1 = await updateExtractionAuditRecord(input.aiexDir, input.auditId, {
+			status: "failed",
+			error: result.error || "Extraction failed"
+		});
+		return new Response(JSON.stringify({
+			success: false,
+			error: record$1.error,
+			auditId: record$1.id
+		}), {
+			status: 500,
+			headers: { "content-type": "application/json" }
+		});
+	}
+	const notionPages = [];
+	if (input.syncNotion) try {
+		if (!result.data || typeof result.data !== "object" || Array.isArray(result.data)) throw new Error("Extraction result is not an object and cannot be written to Notion.");
+		notionPages.push(await writeNotionPage(aiConfig.notion, input.schemaName, result.data));
+	} catch (error) {
+		const record$1 = await updateExtractionAuditRecord(input.aiexDir, input.auditId, {
+			status: "failed",
+			outputPath: result.outputPath,
+			outputName: result.outputPath ? path.basename(result.outputPath) : void 0,
+			tablesInserted: result.tablesInserted,
+			tokensUsed: result.tokensUsed,
+			error: error instanceof Error ? error.message : String(error)
+		});
+		return new Response(JSON.stringify({
+			success: false,
+			error: record$1.error,
+			auditId: record$1.id
+		}), {
+			status: 500,
+			headers: { "content-type": "application/json" }
+		});
+	}
+	const record = await updateExtractionAuditRecord(input.aiexDir, input.auditId, {
+		status: "succeeded",
+		outputPath: result.outputPath,
+		outputName: result.outputPath ? path.basename(result.outputPath) : void 0,
+		tablesInserted: result.tablesInserted,
+		notionPages: notionPages.length > 0 ? notionPages : void 0,
+		tokensUsed: result.tokensUsed
+	});
+	return new Response(JSON.stringify({
+		success: true,
+		outputPath: record.outputPath,
+		outputName: record.outputName,
+		tablesInserted: record.tablesInserted,
+		notionPages: record.notionPages,
+		tokensUsed: record.tokensUsed,
+		auditId: record.id
+	}), {
+		status: 200,
+		headers: { "content-type": "application/json" }
+	});
+}
+function extractRoutes(config) {
+	const app = new Hono();
+	const aiexDir = path.dirname(config.schemaPath);
+	const uploadsDir = path.join(aiexDir, "uploads");
+	app.get("/extract/records", async (c) => {
+		return c.json(await listExtractionAuditRecords(aiexDir));
+	});
+	app.post("/extract", async (c) => {
+		try {
+			const body = await c.req.parseBody();
+			const schemaName = getFormString(body.schema);
+			const text$1 = getFormString(body.text);
+			const modelName = getFormString(body.model);
+			const syncNotion = getFormString(body.notion) === "true";
+			const file = getFormFile(body.file);
+			if (!schemaName) return c.json({
+				success: false,
+				error: "Schema is required"
+			}, 400);
+			if (!text$1 && !file) return c.json({
+				success: false,
+				error: "Provide text or upload a file to extract"
+			}, 400);
+			if (text$1 && file) return c.json({
+				success: false,
+				error: "Text and file input cannot be used together"
+			}, 400);
+			const audit = await createExtractionAuditRecord(aiexDir, {
+				schemaName,
+				modelName,
+				source: file ? {
+					type: "file",
+					fileName: safeUploadName(file.name)
+				} : {
+					type: "text",
+					text: text$1
+				}
+			});
+			let filePath;
+			if (file) {
+				filePath = await saveUploadToFile(file, uploadsDir, audit.id);
+				await updateExtractionAuditRecord(aiexDir, audit.id, { source: {
+					type: "file",
+					filePath,
+					fileName: safeUploadName(file.name)
+				} });
+			}
+			return executeAuditedExtraction({
+				aiexDir,
+				config,
+				auditId: audit.id,
+				schemaName,
+				text: text$1,
+				filePath,
+				modelName,
+				syncNotion
+			});
+		} catch (error) {
+			return c.json({
+				success: false,
+				error: error instanceof Error ? error.message : String(error)
+			}, 500);
+		}
+	});
+	app.post("/extract/records/:id/retry", async (c) => {
+		const original = await readExtractionAuditRecord(aiexDir, c.req.param("id"));
+		if (!original) return c.json({
+			success: false,
+			error: "Extraction record not found"
+		}, 404);
+		return executeAuditedExtraction({
+			aiexDir,
+			config,
+			auditId: (await createExtractionAuditRecord(aiexDir, {
+				schemaName: original.schemaName,
+				modelName: original.modelName,
+				source: original.source,
+				retryOf: original.id
+			})).id,
+			schemaName: original.schemaName,
+			text: original.source.type === "text" ? original.source.text ?? "" : "",
+			filePath: original.source.type === "file" ? original.source.filePath : void 0,
+			modelName: original.modelName
+		});
+	});
+	app.delete("/extract/records/:id", async (c) => {
+		const id = c.req.param("id");
+		if (!await readExtractionAuditRecord(aiexDir, id)) return c.json({
+			success: false,
+			error: "Extraction record not found"
+		}, 404);
+		await deleteExtractionAuditRecord(aiexDir, id);
+		return c.json({ success: true });
+	});
+	return app;
+}
+
 //#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) {
-	if (name$1 !== path.basename(name$1) || !SCHEMA_FILE_RE.test(name$1) || name$1.includes("..")) return null;
-	return path.join(schemaDir, name$1);
+const schemaFileNameSchema = z.string().regex(/^[\w.-]+\.json$/).refine((name$1) => name$1 === path.basename(name$1) && !name$1.includes(".."));
+const schemaFileParamSchema = z.object({ name: schemaFileNameSchema });
+const tableNameParamSchema = z.object({ name: z.string().regex(/^[a-z][a-z0-9_]*$/) });
+function invalidParamResponse(message) {
+	return (result, c) => {
+		if (!result.success) return c.json({ error: message }, 400);
+	};
 }
 function schemaRoutes(config) {
 	const app = new Hono();
@@ -14067,23 +15233,25 @@ function schemaRoutes(config) {
 		const jsonFiles = (await fs.readdir(schemaDir)).filter((f) => f.endsWith(".json"));
 		return c.json(jsonFiles);
 	});
-	app.get("/schema/:name", async (c) => {
-		const filePath = resolveSchemaFile(schemaDir, c.req.param("name"));
-		if (!filePath) return c.json({ error: "Invalid schema file name" }, 400);
+	app.get("/schema/:name", zValidator("param", schemaFileParamSchema, invalidParamResponse("Invalid schema file name")), async (c) => {
+		const { name: name$1 } = c.req.valid("param");
+		const filePath = path.join(schemaDir, name$1);
 		try {
-			const content = await fs.readFile(filePath, "utf-8");
-			return c.json(JSON.parse(content));
+			return c.json(await readFile(filePath));
 		} catch {
 			return c.json({ error: "Schema not found" }, 404);
 		}
 	});
-	app.post("/schema/:name", async (c) => {
-		const filePath = resolveSchemaFile(schemaDir, c.req.param("name"));
-		if (!filePath) return c.json({ error: "Invalid schema file name" }, 400);
+	app.post("/schema/:name", zValidator("param", schemaFileParamSchema, invalidParamResponse("Invalid schema file name")), async (c) => {
+		const { name: name$1 } = c.req.valid("param");
+		const filePath = path.join(schemaDir, name$1);
 		try {
 			const body = await c.req.json();
 			await ensureDir();
-			await fs.writeFile(filePath, `${JSON.stringify(body, null, 2)}\n`);
+			await writeFile(filePath, body, {
+				spaces: 2,
+				EOL: "\n"
+			});
 			const aiexDir = path.dirname(schemaDir);
 			try {
 				await savePromptSnapshot(JsonSchemaDefinitionSchema.parse(body), aiexDir);
@@ -14093,12 +15261,8 @@ function schemaRoutes(config) {
 			return c.json({ error: "Failed to save schema" }, 500);
 		}
 	});
-	app.get("/prompt-snapshot/:name", async (c) => {
-		const name$1 = c.req.param("name");
-		if (!TABLE_NAME_RE.test(name$1)) return c.json({
-			success: false,
-			error: "Invalid table name"
-		}, 400);
+	app.get("/prompt-snapshot/:name", zValidator("param", tableNameParamSchema, invalidParamResponse("Invalid table name")), async (c) => {
+		const { name: name$1 } = c.req.valid("param");
 		const aiexDir = path.dirname(schemaDir);
 		const snapshotPath = path.join(aiexDir, "extracted", `${name$1}.prompt.md`);
 		try {
@@ -14114,14 +15278,13 @@ function schemaRoutes(config) {
 			}, 404);
 		}
 	});
-	app.delete("/schema/:name", async (c) => {
-		const filePath = resolveSchemaFile(schemaDir, c.req.param("name"));
-		if (!filePath) return c.json({ error: "Invalid schema file name" }, 400);
+	app.delete("/schema/:name", zValidator("param", schemaFileParamSchema, invalidParamResponse("Invalid schema file name")), async (c) => {
+		const { name: name$1 } = c.req.valid("param");
+		const filePath = path.join(schemaDir, name$1);
 		try {
 			const aiexDir = path.dirname(schemaDir);
 			try {
-				const content = await fs.readFile(filePath, "utf-8");
-				const parsed = JsonSchemaDefinitionSchema.safeParse(JSON.parse(content));
+				const parsed = JsonSchemaDefinitionSchema.safeParse(await readFile(filePath));
 				if (parsed.success) {
 					const tableName = parsed.data.table.name;
 					const snapshotPath = path.join(aiexDir, "extracted", `${tableName}.prompt.md`);
@@ -14137,59 +15300,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({
@@ -14209,6 +15334,7 @@ function createApp(config, staticDir) {
 	app.use("*", cors({ origin: (origin) => LOCAL_ORIGIN_RE.test(origin) ? origin : null }));
 	app.route("/api", schemaRoutes(config));
 	app.route("/api", aiRoutes(config));
+	app.route("/api", extractRoutes(config));
 	app.route("/api", dataRoutes(config));
 	app.use("/*", serveStatic({
 		root: staticDir,
@@ -14237,9 +15363,36 @@ function createApp(config, staticDir) {
 	return app;
 }
 
+//#endregion
+//#region src/core/web-runner.ts
+function resolveWebStaticDir() {
+	return path.join(resolvePackageRoot(), "dist/web");
+}
+async function openBrowser(url) {
+	await 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",
@@ -14256,23 +15409,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(() => {});
 	}
 });
 
@@ -14300,7 +15450,7 @@ process.on("unhandledRejection", (reason) => {
 	process.exit(1);
 });
 if (process.argv[2] === "_complete") {
-	const { getCompletions } = await import("./completions-ygS1okck.mjs");
+	const { getCompletions } = await import("./completions-C3rmTwXZ.mjs");
 	const suggestions = getCompletions(subCommands, process.argv.slice(3));
 	for (const s of suggestions) process.stdout.write(`${s}\n`);
 	process.exit(0);