aiex-cli 0.0.3-beta.4 → 0.0.3-beta.5

package/dist/cli.mjs

@@ -1,4 +1,4 @@
-import { C as package_default, D as formatDoctorDiagnosticsJson, E as doctorDiagnosticsTableRows, S as name, _ as PLACEHOLDER_TEXT, a as parseJsonSchema, b as seedConfig, c as recognizeImageText, d as readAIConfig, f as writeAIConfig, g as PLACEHOLDER_SCHEMA, h as DEFAULT_PROMPT_CONFIG, i as JsonSchemaDefinitionSchema, l as shouldUseImageOcrFallback, m as DEFAULT_MINERU_CONFIG, n as createMigrationConfig, o as toSnakeCase, p as DEFAULT_MARKITDOWN_CONFIG, s as generateDrizzleSchema, t as collectDoctorDiagnostics, u as getDefaultAIConfig, v as AIConfigSchema, w as version, x as description, y as createConfig } from "./doctor-collector-nMMG_h-w.mjs";
+import { C as name, D as doctorDiagnosticsTableRows, O as formatDoctorDiagnosticsJson, S as description, T as version, _ as PLACEHOLDER_SCHEMA, a as parseJsonSchema, b as createConfig, c as recognizeImageText, d as readAIConfig, f as writeAIConfig, g as DEFAULT_PROMPT_CONFIG, h as DEFAULT_MINERU_CONFIG, i as JsonSchemaDefinitionSchema, l as shouldUseImageOcrFallback, m as DEFAULT_MARKITDOWN_CONFIG, n as createMigrationConfig, o as toSnakeCase, p as DEFAULT_MARKER_CONFIG, s as generateDrizzleSchema, t as collectDoctorDiagnostics, u as getDefaultAIConfig, v as PLACEHOLDER_TEXT, w as package_default, x as seedConfig, y as AIConfigSchema } from "./doctor-collector-DnH1Qu1e.mjs";
 import { createRequire } from "node:module";
 import fs from "node:fs/promises";
 import os from "node:os";
@@ -11,8 +11,12 @@ import { defineCommand, runMain } from "citty";
 import { consola } from "consola";
 import updateNotifier from "update-notifier";
 import CliTable3 from "cli-table3";
+import fs$1 from "node:fs";
 import { intro, isCancel, outro, select, spinner, text } from "@clack/prompts";
+import Database from "better-sqlite3";
 import pc from "picocolors";
+import * as XLSX from "xlsx";
+import { glob, globSync } from "tinyglobby";
 import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
 import { LangfuseSpanProcessor } from "@langfuse/otel";
 import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
@@ -20,15 +24,14 @@ import { APICallError, Output, generateText, jsonSchema } from "ai";
 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 { Client, extractNotionId } from "@notionhq/client";
 import { Buffer } from "node:buffer";
 import { execa } from "execa";
 import { extractText, getDocumentProxy, getMeta } from "unpdf";
+import crypto from "node:crypto";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
+import * as chokidar from "chokidar";
 import { serve } from "@hono/node-server";
 import open from "open";
 import { serveStatic } from "@hono/node-server/serve-static";
@@ -12943,6 +12946,22 @@ function schemaToDescription(schema) {
 		const property = prop;
 		lines.push(nestedPropertyToDescription(name$1, property));
 	}
+	if (schema.examples && schema.examples.length > 0) {
+		lines.push("");
+		lines.push("Examples / Few-shot Cases:");
+		schema.examples.forEach((example, idx) => {
+			lines.push("");
+			lines.push(`Example ${idx + 1}:`);
+			lines.push("Input text:");
+			lines.push("\"\"\"");
+			lines.push(example.text);
+			lines.push("\"\"\"");
+			lines.push("Expected JSON output:");
+			lines.push("```json");
+			lines.push(JSON.stringify(example.output, null, 2));
+			lines.push("```");
+		});
+	}
 	return lines.join("\n");
 }
 function generateExtractionPrompt(schema, text$1, promptConfig = DEFAULT_PROMPT_CONFIG) {
@@ -13512,11 +13531,17 @@ async function deleteExtractionAuditRecord(aiexDir, id) {
 	clearRecordCache(aiexDir);
 	return true;
 }
+/**
+* Finds the first succeeded extraction audit record matching a schema and file hash.
+*/
+async function findSucceededAuditByHash(aiexDir, schemaName, fileHash) {
+	return (await listExtractionAuditRecords(aiexDir)).find((r) => r.schemaName === schemaName && r.status === "succeeded" && r.source.fileHash === fileHash) || null;
+}
 
 //#endregion
 //#region src/core/file-constants.ts
-const MAX_UPLOAD_SIZE = 150 * 1024 * 1024;
-const MAX_UPLOAD_SIZE_TEXT = "150MB";
+const MAX_UPLOAD_SIZE = 30 * 1024 * 1024;
+const MAX_UPLOAD_SIZE_TEXT = "30MB";
 const SUPPORTED_FILE_TYPES_TEXT = "images, PDF, text, markdown, CSV, JSON, HTML, XML, YAML";
 const MISSING_UPLOAD_FILE_TEXT = "Uploaded file is no longer available. Re-run extraction with the original file.";
 const SUPPORTED_MIME_TYPES = new Set([
@@ -13964,6 +13989,10 @@ function createPdfConverter(config) {
 			const markitdownConfig = config.markitdown ?? DEFAULT_MARKITDOWN_CONFIG;
 			return withFallback(new ExternalCommandPdfConverter("markitdown", markitdownConfig), markitdownConfig);
 		}
+		if (config.converter === "marker") {
+			const markerConfig = config.marker ?? DEFAULT_MARKER_CONFIG;
+			return withFallback(new ExternalCommandPdfConverter("marker", markerConfig), markerConfig);
+		}
 		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);
@@ -13979,6 +14008,21 @@ function createPdfConverter(config) {
 	return instance;
 }
 
+//#endregion
+//#region src/utils/hash.ts
+/**
+* Helper to compute SHA-256 hash of a file asynchronously.
+*/
+function getFileHash(filePath) {
+	return new Promise((resolve, reject) => {
+		const hash = crypto.createHash("sha256");
+		const stream = fs$1.createReadStream(filePath);
+		stream.on("data", (data) => hash.update(data));
+		stream.on("end", () => resolve(hash.digest("hex")));
+		stream.on("error", (err) => reject(err));
+	});
+}
+
 //#endregion
 //#region src/core/extract-runner.ts
 const FILE_PART_EXTENSIONS = new Set([
@@ -13990,7 +14034,7 @@ const FILE_PART_EXTENSIONS = new Set([
 	"bmp",
 	"svg"
 ]);
-const SUPPORTED_EXTENSIONS = new Set([
+const SUPPORTED_EXTENSIONS$1 = new Set([
 	...FILE_PART_EXTENSIONS,
 	"pdf",
 	"txt",
@@ -14004,7 +14048,7 @@ const SUPPORTED_EXTENSIONS = new Set([
 ]);
 const PDF_EXT_RE = /\.pdf$/i;
 const JSON_EXT_RE$1 = /\.json$/;
-const SUPPORTED_FILE_PATTERN = `*.{${[...SUPPORTED_EXTENSIONS].join(",")}}`;
+const SUPPORTED_FILE_PATTERN = `*.{${[...SUPPORTED_EXTENSIONS$1].join(",")}}`;
 async function syncResultToNotion(aiConfig, schemaName, data) {
 	if (!data || typeof data !== "object" || Array.isArray(data)) throw new Error("Extraction result is not an object and cannot be written to Notion.");
 	const page = await writeNotionPage(aiConfig.notion, schemaName, data);
@@ -14043,7 +14087,7 @@ function listSupportedFiles(dir, pattern) {
 		onlyFiles: true
 	}).filter((file) => {
 		const ext = path.extname(file).toLowerCase().replace(".", "");
-		return SUPPORTED_EXTENSIONS.has(ext);
+		return SUPPORTED_EXTENSIONS$1.has(ext);
 	}).sort();
 }
 async function loadSchema(config, schemaName) {
@@ -14199,27 +14243,76 @@ async function extractSingle(aiexDir, config, aiConfig, schemaName, text$1, file
 		tokensUsed: result.tokensUsed
 	};
 }
-async function processOneFile(aiexDir, config, aiConfig, schemaName, filePath, modelOverride, options) {
+async function runAuditedExtraction(options) {
+	const { aiexDir, config, aiConfig, schemaName, source, modelOverride, retryOf, insert, force, quiet = false } = options;
+	let fileHash;
+	let isPlainTextFile = false;
+	if (source.type === "file") {
+		const ext = path.extname(source.filePath).toLowerCase().replace(".", "");
+		isPlainTextFile = [
+			"txt",
+			"md",
+			"csv",
+			"json",
+			"html",
+			"xml",
+			"yaml",
+			"yml"
+		].includes(ext);
+		try {
+			fileHash = await getFileHash(source.filePath);
+		} catch (e) {
+			if (!quiet) consola.warn(`Failed to calculate file hash for ${path.basename(source.filePath)}: ${e instanceof Error ? e.message : String(e)}`);
+		}
+		if (fileHash && !isPlainTextFile && !force) {
+			const existing = await findSucceededAuditByHash(aiexDir, schemaName, fileHash);
+			if (existing) {
+				if (!quiet) consola.info(`File ${pc.cyan(path.basename(source.filePath))} (hash: ${fileHash.slice(0, 8)}) has already been processed successfully. Skipping.`);
+				return {
+					success: true,
+					skipped: true,
+					auditId: existing.id,
+					fileHash,
+					outputPath: existing.outputPath,
+					outputName: existing.outputName,
+					tablesInserted: existing.tablesInserted,
+					notionPages: existing.notionPages,
+					tokensUsed: existing.tokensUsed
+				};
+			}
+		}
+	}
 	const audit = await createExtractionAuditRecord(aiexDir, {
 		schemaName,
 		modelName: modelOverride?.name,
-		source: {
+		source: source.type === "file" ? {
 			type: "file",
-			filePath,
-			fileName: path.basename(filePath)
-		}
+			filePath: source.filePath,
+			fileName: path.basename(source.filePath),
+			fileHash
+		} : {
+			type: "text",
+			text: source.text
+		},
+		retryOf
 	});
 	try {
-		const input = await readExtractFileInput(filePath, aiConfig, modelOverride);
-		const r = await extractSingle(aiexDir, config, aiConfig, schemaName, input.text, input.filePath, modelOverride, {
-			quiet: false,
-			insert: options?.insert
+		let text$1 = "";
+		let filePath;
+		if (source.type === "file") {
+			const input = await readExtractFileInput(source.filePath, aiConfig, modelOverride);
+			text$1 = input.text;
+			filePath = input.filePath;
+		} else text$1 = source.text;
+		const r = await extractSingle(aiexDir, config, aiConfig, schemaName, text$1, filePath, modelOverride, {
+			quiet,
+			insert
 		});
 		if (r.success) {
 			let notionPages;
 			if (shouldSyncNotion(aiConfig, schemaName)) try {
 				notionPages = await syncResultToNotion(aiConfig, schemaName, r.data);
-				consola.success(`Synced to Notion: ${notionPages.length} page(s)`);
+				if (!quiet) consola.success(`Synced to Notion: ${notionPages.length} page(s)`);
 			} catch (error) {
 				await updateExtractionAuditRecord(aiexDir, audit.id, {
 					status: "failed",
@@ -14229,10 +14322,15 @@ async function processOneFile(aiexDir, config, aiConfig, schemaName, filePath, m
 					tokensUsed: r.tokensUsed,
 					error: error instanceof Error ? error.message : String(error)
 				});
-				consola.error(`Notion sync failed: ${error instanceof Error ? error.message : String(error)}`);
-				return false;
+				if (!quiet) consola.error(`Notion sync failed: ${error instanceof Error ? error.message : String(error)}`);
+				return {
+					success: false,
+					error: error instanceof Error ? error.message : String(error),
+					auditId: audit.id,
+					fileHash
+				};
 			}
-			await updateExtractionAuditRecord(aiexDir, audit.id, {
+			const updated = await updateExtractionAuditRecord(aiexDir, audit.id, {
 				status: "succeeded",
 				outputPath: r.outputPath,
 				outputName: r.outputPath ? path.basename(r.outputPath) : void 0,
@@ -14240,24 +14338,66 @@ async function processOneFile(aiexDir, config, aiConfig, schemaName, filePath, m
 				notionPages,
 				tokensUsed: r.tokensUsed
 			});
-			consola.success(`Processed: ${path.basename(filePath)}`);
-			return true;
+			return {
+				success: true,
+				outputPath: updated.outputPath,
+				outputName: updated.outputName,
+				tablesInserted: updated.tablesInserted,
+				notionPages: updated.notionPages,
+				tokensUsed: updated.tokensUsed,
+				auditId: updated.id,
+				fileHash
+			};
 		} else {
 			await updateExtractionAuditRecord(aiexDir, audit.id, {
 				status: "failed",
 				error: r.error || "Extraction failed"
 			});
-			consola.error(`Failed: ${r.error}`);
-			return false;
+			if (!quiet) consola.error(`Failed: ${r.error}`);
+			return {
+				success: false,
+				error: r.error,
+				auditId: audit.id,
+				fileHash
+			};
 		}
 	} 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;
+		if (!quiet) {
+			const name$1 = source.type === "file" ? path.basename(source.filePath) : "text input";
+			consola.error(`Error processing ${name$1}: ${e instanceof Error ? e.message : String(e)}`);
+		}
+		return {
+			success: false,
+			error: e instanceof Error ? e.message : String(e),
+			auditId: audit.id,
+			fileHash
+		};
+	}
+}
+async function processOneFile(aiexDir, config, aiConfig, schemaName, filePath, modelOverride, options) {
+	const result = await runAuditedExtraction({
+		aiexDir,
+		config,
+		aiConfig,
+		schemaName,
+		source: {
+			type: "file",
+			filePath
+		},
+		modelOverride,
+		insert: options?.insert,
+		force: options?.force,
+		quiet: false
+	});
+	if (result.success) {
+		if (!result.skipped) consola.success(`Processed: ${path.basename(filePath)}`);
+		return true;
 	}
+	return false;
 }
 async function runBatchExtraction(aiexDir, config, aiConfig, schemaName, dir, globPattern, modelOverride, options) {
 	consola.info(`Scanning ${pc.cyan(dir)} for supported files...`);
@@ -14284,7 +14424,10 @@ async function runBatchExtraction(aiexDir, config, aiConfig, schemaName, dir, gl
 	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++;
+		if (await processOneFile(aiexDir, config, aiConfig, schemaName, file, modelOverride, {
+			insert: options?.insert,
+			force: options?.force
+		})) successCount++;
 		else failCount++;
 	}
 	consola.info(`\nBatch complete: ${pc.green(`${successCount} succeeded`)}, ${pc.red(`${failCount} failed`)}, ${files.length} total`);
@@ -14295,6 +14438,174 @@ async function runBatchExtraction(aiexDir, config, aiConfig, schemaName, dir, gl
 	};
 }
 
+//#endregion
+//#region src/commands/export.ts
+const exportCommand = defineCommand({
+	meta: {
+		name: "export",
+		description: "Export SQLite database table to Excel (.xlsx) or CSV (.csv)"
+	},
+	args: {
+		table: {
+			type: "string",
+			alias: "t",
+			description: "SQLite table name to export"
+		},
+		schema: {
+			type: "string",
+			alias: "s",
+			description: "Schema name (without .json extension) to export"
+		},
+		format: {
+			type: "string",
+			alias: "f",
+			description: "Export format: csv or xlsx (default: inferred from output or csv)"
+		},
+		output: {
+			type: "string",
+			alias: "o",
+			description: "Output file path (default: ./<tableName>.<format>)"
+		}
+	},
+	async run({ args }) {
+		intro(pc.inverse(" aiex export "));
+		if (!args.table && !args.schema) {
+			failCommand("Either table name (--table / -t) or schema name (--schema / -s) is required");
+			return;
+		}
+		const cwd = process.cwd();
+		const config = createMigrationConfig(cwd);
+		const schemaDir = config.schemaPath;
+		let tableName = args.table || "";
+		let schema = null;
+		if (args.schema) {
+			const schemaLoad = await loadSchema(config, args.schema);
+			if (!schemaLoad.schema) {
+				failCommand(schemaLoad.error || `Schema file for "${args.schema}" not found`);
+				return;
+			}
+			schema = schemaLoad.schema;
+			const tName = schema.table?.name;
+			if (!tName) {
+				failCommand(`Schema "${args.schema}" does not define a database table name.`);
+				return;
+			}
+			if (tableName && tableName !== tName) {
+				failCommand(`Specified table name "${tableName}" does not match schema table name "${tName}"`);
+				return;
+			}
+			tableName = tName;
+		} else try {
+			if (fs$1.existsSync(schemaDir)) {
+				const files = fs$1.readdirSync(schemaDir).filter((f) => f.endsWith(".json"));
+				for (const file of files) {
+					const s$1 = await readFile(path.join(schemaDir, file));
+					if (s$1.table?.name === tableName) {
+						schema = s$1;
+						break;
+					}
+				}
+			}
+		} catch {}
+		let format = args.format?.toLowerCase();
+		const outputPathArg = args.output;
+		if (outputPathArg) {
+			const ext = path.extname(outputPathArg).toLowerCase();
+			if (!format) {
+				if (ext === ".xlsx") format = "xlsx";
+				else if (ext === ".csv") format = "csv";
+			}
+		}
+		if (!format) format = "csv";
+		if (format !== "csv" && format !== "xlsx") {
+			failCommand(`Unsupported export format: "${format}". Supported formats: csv, xlsx`);
+			return;
+		}
+		const resolvedOutput = outputPathArg ? path.resolve(outputPathArg) : path.resolve(cwd, `${tableName}.${format}`);
+		if (!fs$1.existsSync(config.databasePath)) {
+			failCommand(`Database file not found at ${config.databasePath}. Please run "aiex schema" to create the database first.`);
+			return;
+		}
+		const s = spinner();
+		s.start(`Loading data from table "${tableName}"...`);
+		let columns = [];
+		let rows = [];
+		try {
+			const db = new Database(config.databasePath, { readonly: true });
+			if (!db.prepare(`
+        select name from sqlite_master
+        where type = 'table' and name = ?
+      `).get(tableName)) {
+				s.stop("Database query failed");
+				failCommand(`Table "${tableName}" not found in database. Run "aiex schema" first to migrate.`);
+				db.close();
+				return;
+			}
+			columns = db.pragma(`table_info(${tableName})`);
+			rows = db.prepare(`select * from ${tableName}`).all();
+			db.close();
+		} catch (error) {
+			s.stop("Database query failed");
+			failCommand(error instanceof Error ? error.message : String(error));
+			return;
+		}
+		if (rows.length === 0) {
+			s.stop("Empty table");
+			consola.warn(`Table "${tableName}" is empty. Exporting empty file...`);
+		} else s.stop(`Loaded ${rows.length} row(s)`);
+		const s2 = spinner();
+		s2.start("Formatting data...");
+		const formattedRows = rows.map((row) => {
+			const newRow = {};
+			columns.forEach((col) => {
+				const colName = col.name;
+				const val = row[colName];
+				const type = (schema?.properties?.[colName])?.type || "";
+				if (val === null || val === void 0) newRow[colName] = "";
+				else if (type === "boolean") if (format === "xlsx") newRow[colName] = val === 1 || val === "1" || val === true;
+				else newRow[colName] = val === 1 || val === "1" || val === true ? "true" : "false";
+				else if (type === "number" || type === "integer") if (val === "") newRow[colName] = "";
+				else {
+					const num = Number(val);
+					newRow[colName] = Number.isNaN(num) ? val : num;
+				}
+				else if (typeof val === "object") newRow[colName] = JSON.stringify(val);
+				else {
+					const dbType = (col.type || "").toLowerCase();
+					if ((dbType.includes("int") || dbType.includes("real") || dbType.includes("num") || dbType.includes("double") || dbType.includes("float")) && typeof val === "string" && val !== "") {
+						const num = Number(val);
+						newRow[colName] = Number.isNaN(num) ? val : num;
+					} else newRow[colName] = val;
+				}
+			});
+			return newRow;
+		});
+		s2.stop("Data formatted");
+		const s3 = spinner();
+		s3.start(`Writing ${format.toUpperCase()} file to ${resolvedOutput}...`);
+		try {
+			const ws = XLSX.utils.json_to_sheet(formattedRows, { header: columns.map((col) => col.name) });
+			const outputDir = path.dirname(resolvedOutput);
+			if (!fs$1.existsSync(outputDir)) fs$1.mkdirSync(outputDir, { recursive: true });
+			if (format === "xlsx") {
+				const wb = XLSX.utils.book_new();
+				XLSX.utils.book_append_sheet(wb, ws, tableName.slice(0, 31));
+				XLSX.writeFile(wb, resolvedOutput);
+			} else {
+				const csv = XLSX.utils.sheet_to_csv(ws);
+				fs$1.writeFileSync(resolvedOutput, "" + csv, "utf8");
+			}
+			s3.stop("Export completed successfully");
+			consola.success(`Successfully exported ${rows.length} row(s) to ${pc.cyan(resolvedOutput)}`);
+		} catch (error) {
+			s3.stop("File write failed");
+			failCommand(error instanceof Error ? error.message : String(error));
+			return;
+		}
+		outro("Done!");
+	}
+});
+
 //#endregion
 //#region src/commands/extract.ts
 function getIdArg(args) {
@@ -14312,7 +14623,7 @@ function isExtractSubCommand(rawArgs) {
 	].includes(arg));
 }
 function formatSource(source) {
-	return source.type === "file" ? source.fileName || "file" : "text";
+	return source.type === "file" ? source.fileName || "file" : "unknown";
 }
 async function loadConfiguredAI(aiexDir) {
 	const aiConfig = await readAIConfig(aiexDir);
@@ -14339,52 +14650,6 @@ function resolveModelOverride(aiConfig, modelName) {
 	}
 	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) {
-		await updateExtractionAuditRecord(input.aiexDir, audit.id, {
-			status: "failed",
-			error: result.error || "Extraction failed"
-		});
-		return false;
-	}
-	let notionPages;
-	if (input.aiConfig.notion?.enabled && input.aiConfig.notion.schemas?.[input.schemaName]?.databaseId?.trim()) 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.");
-		const page = await writeNotionPage(input.aiConfig.notion, input.schemaName, result.data);
-		notionPages = [{
-			databaseId: page.databaseId,
-			pageId: page.pageId
-		}];
-		consola.success(`Synced to Notion: ${notionPages.length} page(s)`);
-	} catch (error) {
-		await updateExtractionAuditRecord(input.aiexDir, audit.id, {
-			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)
-		});
-		consola.error(`Notion sync failed: ${error instanceof Error ? error.message : String(error)}`);
-		return false;
-	}
-	await updateExtractionAuditRecord(input.aiexDir, audit.id, {
-		status: "succeeded",
-		outputPath: result.outputPath,
-		outputName: result.outputPath ? path.basename(result.outputPath) : void 0,
-		tablesInserted: result.tablesInserted,
-		notionPages,
-		tokensUsed: result.tokensUsed
-	});
-	return true;
-}
 const historyCommand = defineCommand({
 	meta: {
 		name: "history",
@@ -14462,23 +14727,19 @@ const retryCommand = defineCommand({
 		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({
+			const result = await runAuditedExtraction({
 				aiexDir,
 				config,
 				aiConfig,
 				schemaName: record.schemaName,
-				text: sourceInput.text,
-				filePath: sourceInput.filePath,
 				source: record.source,
 				modelOverride,
 				retryOf: record.id,
-				insert: !args.noInsert
-			})) {
-				failCommand();
+				insert: !args.noInsert,
+				force: true
+			});
+			if (!result.success) {
+				failCommand(result.error);
 				return;
 			}
 			outro("Done!");
@@ -14531,11 +14792,6 @@ const extractCommand = defineCommand({
 			alias: "s",
 			description: "Schema name (without .json extension)"
 		},
-		text: {
-			type: "string",
-			alias: "t",
-			description: "Text content to extract"
-		},
 		file: {
 			type: "string",
 			alias: "f",
@@ -14560,6 +14816,11 @@ const extractCommand = defineCommand({
 			type: "boolean",
 			description: "Extract and save JSON without inserting into SQLite",
 			default: false
+		},
+		force: {
+			type: "boolean",
+			description: "Force re-extraction even if the file has already been processed successfully",
+			default: false
 		}
 	},
 	async run({ args, rawArgs }) {
@@ -14567,10 +14828,6 @@ const extractCommand = defineCommand({
 		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;
@@ -14579,7 +14836,7 @@ const extractCommand = defineCommand({
 		if (!aiConfig) return;
 		const modelOverride = resolveModelOverride(aiConfig, args.model);
 		if (modelOverride === null) return;
-		if (!args.schema && !args.text && !args.file && !args.dir) {
+		if (!args.schema && !args.file && !args.dir) {
 			if (await runInteractive(aiexDir, config, aiConfig, modelOverride)) outro("Done!");
 			return;
 		}
@@ -14588,13 +14845,16 @@ const extractCommand = defineCommand({
 				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);
+			const result$1 = await runBatchExtraction(aiexDir, config, aiConfig, args.schema, args.dir, args.glob, modelOverride, {
+				insert: !args.noInsert,
+				force: args.force
+			});
+			if (!result$1.ok) {
+				failCommand(result$1.error);
 				return;
 			}
-			if (result.failCount > 0) process.exitCode = 1;
-			if (result.failCount > 0) outro(`Completed with failures (${result.failCount} failed)`);
+			if (result$1.failCount > 0) process.exitCode = 1;
+			if (result$1.failCount > 0) outro(`Completed with failures (${result$1.failCount} failed)`);
 			else outro("Done!");
 			return;
 		}
@@ -14602,44 +14862,26 @@ const extractCommand = defineCommand({
 			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");
+		if (!args.file) {
+			failCommand("Please provide 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, modelOverride);
-			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({
+		const result = await runAuditedExtraction({
 			aiexDir,
 			config,
 			aiConfig,
 			schemaName: args.schema,
-			text: text$1,
-			filePath,
-			source: filePath ? {
+			source: {
 				type: "file",
-				filePath: args.file,
-				fileName: path.basename(args.file)
-			} : {
-				type: "text",
-				text: text$1
+				filePath: args.file
 			},
 			modelOverride,
-			insert: !args.noInsert
-		})) {
-			failCommand();
+			insert: !args.noInsert,
+			force: args.force,
+			quiet: false
+		});
+		if (!result.success) {
+			failCommand(result.error);
 			return;
 		}
 		outro("Done!");
@@ -14664,83 +14906,42 @@ async function runInteractive(aiexDir, config, aiConfig, modelOverride) {
 	}
 	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"
-			}
-		]
+		options: [{
+			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:",
+	if (inputSource === "file") {
+		const filePathStr = await text({
+			message: "Enter file path:",
 			validate(value) {
-				if (!value || value.trim().length === 0) return "Please enter some text";
+				if (!value || value.trim().length === 0) return "Please enter a file path";
 			}
 		});
-		if (isCancel(textContent)) {
+		if (isCancel(filePathStr)) {
 			cancel("Cancelled");
 			return false;
 		}
-		return runAuditedSingleExtraction({
+		return (await runAuditedExtraction({
 			aiexDir,
 			config,
 			aiConfig,
 			schemaName,
-			text: textContent,
 			source: {
-				type: "text",
-				text: textContent
+				type: "file",
+				filePath: filePathStr
 			},
 			modelOverride
-		});
-	} 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, modelOverride);
-			return runAuditedSingleExtraction({
-				aiexDir,
-				config,
-				aiConfig,
-				schemaName,
-				text: input.text,
-				filePath: input.filePath,
-				source: {
-					type: "file",
-					filePath: fp,
-					fileName: path.basename(fp)
-				},
-				modelOverride
-			});
-		} catch (e) {
-			consola.error(`Cannot read file: ${fp} — ${e instanceof Error ? e.message : String(e)}`);
-			return false;
-		}
+		})).success;
 	} else if (inputSource === "dir") {
 		const dirPath = await text({
 			message: "Enter directory path:",
@@ -14942,6 +15143,231 @@ const schemaCommand = defineCommand({
 	}
 });
 
+//#endregion
+//#region src/core/watch-service.ts
+const PDF_EXT_REGEXP = /\.pdf$/i;
+const SUPPORTED_EXTENSIONS = new Set([
+	"png",
+	"jpg",
+	"jpeg",
+	"gif",
+	"webp",
+	"bmp",
+	"svg",
+	"pdf",
+	"txt",
+	"md",
+	"csv",
+	"json",
+	"html",
+	"xml",
+	"yaml",
+	"yml"
+]);
+var WatchRegistry = class {
+	registryPath;
+	constructor(aiexDir) {
+		this.registryPath = path.join(aiexDir, "watch-registry.json");
+	}
+	async load() {
+		try {
+			const content = await fs.readFile(this.registryPath, "utf-8");
+			return JSON.parse(content);
+		} catch {
+			return { processed: {} };
+		}
+	}
+	async save(data) {
+		await fs.mkdir(path.dirname(this.registryPath), { recursive: true });
+		await fs.writeFile(this.registryPath, JSON.stringify(data, null, 2), "utf-8");
+	}
+	async markSucceeded(hash, filePath) {
+		const data = await this.load();
+		data.processed[hash] = {
+			filePath,
+			fileName: path.basename(filePath),
+			processedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			status: "succeeded"
+		};
+		await this.save(data);
+	}
+	async markFailed(hash, filePath, error) {
+		const data = await this.load();
+		data.processed[hash] = {
+			filePath,
+			fileName: path.basename(filePath),
+			processedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			status: "failed",
+			error
+		};
+		await this.save(data);
+	}
+	async getStatus(hash) {
+		return (await this.load()).processed[hash]?.status ?? null;
+	}
+};
+async function notifySuccess(fileName) {
+	if (process.platform === "darwin") try {
+		await execa("osascript", ["-e", `display notification "Successfully processed and inserted data." with title "AIEX Watch: ${fileName}"`]);
+		await execa("afplay", ["/System/Library/Sounds/Glass.aiff"]);
+	} catch {}
+	else process.stdout.write("\x07");
+}
+async function notifyFailure(fileName, errorMessage) {
+	if (process.platform === "darwin") try {
+		await execa("osascript", ["-e", `display notification "${errorMessage.replace(/"/g, "\\\"")}" with title "AIEX Watch Failed: ${fileName}"`]);
+		await execa("afplay", ["/System/Library/Sounds/Basso.aiff"]);
+	} catch {}
+	else process.stdout.write("\x07\x07");
+}
+function startWatcher(options) {
+	const { aiexDir, config, aiConfig, schemaName, watchDir, modelOverride, insert } = options;
+	const queueDirActive = path.join(aiexDir, "watch-queue", "active");
+	const queueDirFailed = path.join(aiexDir, "watch-queue", "failed");
+	const registry$2 = new WatchRegistry(aiexDir);
+	fs$1.mkdirSync(queueDirActive, { recursive: true });
+	fs$1.mkdirSync(queueDirFailed, { recursive: true });
+	consola.info(pc.green(`Starting watch on folder: ${pc.cyan(watchDir)}`));
+	consola.info(pc.green(`Schema: ${pc.cyan(schemaName)}`));
+	if (modelOverride) consola.info(pc.green(`Model Override: ${pc.cyan(modelOverride.name)}`));
+	const watcher = chokidar.watch(watchDir, {
+		persistent: true,
+		ignoreInitial: false,
+		awaitWriteFinish: {
+			stabilityThreshold: 2e3,
+			pollInterval: 500
+		}
+	});
+	watcher.on("add", async (filePath) => {
+		const resolvedPath = path.resolve(filePath);
+		if (resolvedPath.startsWith(path.resolve(aiexDir))) return;
+		const stat = await fs.stat(resolvedPath).catch(() => null);
+		if (!stat || !stat.isFile()) return;
+		const ext = path.extname(resolvedPath).toLowerCase().replace(".", "");
+		if (!SUPPORTED_EXTENSIONS.has(ext)) {
+			consola.warn(`[Watcher] Skipped unsupported file type: ${path.basename(resolvedPath)}`);
+			return;
+		}
+		const fileName = path.basename(resolvedPath);
+		consola.info(`[Watcher] New file detected: ${pc.cyan(fileName)}. Processing...`);
+		try {
+			const hash = await getFileHash(resolvedPath);
+			if (await registry$2.getStatus(hash) === "succeeded") {
+				consola.info(`[Watcher] File ${pc.cyan(fileName)} (hash: ${hash.slice(0, 8)}) has already been processed successfully. Skipping.`);
+				return;
+			}
+			const activeQueuePath = path.join(queueDirActive, `${hash}.${ext}`);
+			await fs.copyFile(resolvedPath, activeQueuePath);
+			if (await processOneFile(aiexDir, config, aiConfig, schemaName, activeQueuePath, modelOverride, { insert })) {
+				await registry$2.markSucceeded(hash, resolvedPath);
+				await fs.rm(activeQueuePath, { force: true }).catch(() => {});
+				await fs.rm(activeQueuePath.replace(PDF_EXT_REGEXP, ".md"), { force: true }).catch(() => {});
+				consola.success(`[Watcher] File processed successfully: ${pc.green(fileName)}`);
+				await notifySuccess(fileName);
+			} else {
+				const errorMsg = "Extraction failed. See extraction audit history.";
+				await registry$2.markFailed(hash, resolvedPath, errorMsg);
+				const failedQueuePath = path.join(queueDirFailed, `${hash}-${Date.now()}.${ext}`);
+				await fs.rename(activeQueuePath, failedQueuePath).catch(() => {});
+				await fs.rm(activeQueuePath.replace(PDF_EXT_REGEXP, ".md"), { force: true }).catch(() => {});
+				consola.error(`[Watcher] Processing failed for: ${pc.red(fileName)}`);
+				await notifyFailure(fileName, errorMsg);
+			}
+		} catch (e) {
+			const errorMsg = e instanceof Error ? e.message : String(e);
+			consola.error(`[Watcher] Error processing file ${fileName}: ${errorMsg}`);
+			await notifyFailure(fileName, errorMsg);
+		}
+	});
+	watcher.on("error", (error) => {
+		consola.error(`[Watcher] Watcher error: ${error?.message || String(error)}`);
+	});
+	return watcher;
+}
+
+//#endregion
+//#region src/commands/watch.ts
+const watchCommand = defineCommand({
+	meta: {
+		name: "watch",
+		description: "Watch a directory for new files and automatically extract data"
+	},
+	args: {
+		schema: {
+			type: "string",
+			alias: "s",
+			description: "Schema name (without .json extension) to use for extraction"
+		},
+		dir: {
+			type: "string",
+			alias: "d",
+			description: "Directory path to watch for incoming files"
+		},
+		model: {
+			type: "string",
+			alias: "m",
+			description: "AI model to use for extraction (overrides default/auto-selected model)"
+		},
+		noInsert: {
+			type: "boolean",
+			description: "Extract and save JSON without inserting into SQLite database",
+			default: false
+		}
+	},
+	async run({ args }) {
+		intro(pc.inverse(" aiex watch "));
+		if (!args.schema) {
+			failCommand("Schema name (-s) is required");
+			return;
+		}
+		if (!args.dir) {
+			failCommand("Watch directory path (-d) is required");
+			return;
+		}
+		const config = createMigrationConfig(process.cwd());
+		const aiexDir = path.dirname(config.schemaPath);
+		const schemaLoad = await loadSchema(config, args.schema);
+		if (!schemaLoad.schema) {
+			failCommand(schemaLoad.error || `Schema file for "${args.schema}" not found`);
+			return;
+		}
+		let watchDirStat;
+		try {
+			watchDirStat = fs$1.statSync(args.dir);
+		} catch (e) {
+			failCommand(`Watch directory does not exist: ${args.dir} — ${e instanceof Error ? e.message : String(e)}`);
+			return;
+		}
+		if (!watchDirStat.isDirectory()) {
+			failCommand(`Watch path is not a directory: ${args.dir}`);
+			return;
+		}
+		const watchDirAbs = path.resolve(args.dir);
+		const aiConfig = await loadConfiguredAI(aiexDir);
+		if (!aiConfig) return;
+		const modelOverride = resolveModelOverride(aiConfig, args.model);
+		if (modelOverride === null) return;
+		const watcher = startWatcher({
+			aiexDir,
+			config,
+			aiConfig,
+			schemaName: args.schema,
+			watchDir: watchDirAbs,
+			modelOverride,
+			insert: !args.noInsert
+		});
+		const cleanup = async () => {
+			consola.info("\nStopping watch directory daemon...");
+			await watcher.close();
+			consola.success("Daemon stopped.");
+			process.exit(0);
+		};
+		process.on("SIGINT", cleanup);
+		process.on("SIGTERM", cleanup);
+		consola.info("Press Ctrl+C to stop");
+	}
+});
+
 //#endregion
 //#region src/server/routes/ai.ts
 const JSON_EXT_RE = /\.json$/i;
@@ -15078,7 +15504,8 @@ const tableQuerySchema = z.object({
 	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"))
+	sortOrder: z.preprocess((value) => typeof value === "string" ? value.toLowerCase() : value, z.enum(["asc", "desc"]).catch("asc")),
+	all: z.preprocess((value) => value === "true" || value === true, z.boolean().catch(false))
 });
 function invalidParamResponse$1(message) {
 	return (result, c) => {
@@ -15201,7 +15628,7 @@ function dataRoutes(config) {
 	});
 	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");
+		const { page, pageSize, search, sortField, sortOrder, all } = c.req.valid("query");
 		let db;
 		try {
 			db = createReadonlyQueryDb(config.databasePath);
@@ -15232,15 +15659,20 @@ function dataRoutes(config) {
           ${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 rowid as ${sql.raw(INTERNAL_ROWID_COLUMN)}, *
-          from ${sql.table(tableName)}
-          ${searchCondition}
-          ${orderBy}
-          limit ${pageSize}
-          offset ${offset}
-        `.execute(db);
+			const totalPages = all ? 1 : Math.max(1, Math.ceil(total / pageSize));
+			const result = all ? await sql`
+              select rowid as ${sql.raw(INTERNAL_ROWID_COLUMN)}, *
+              from ${sql.table(tableName)}
+              ${searchCondition}
+              ${orderBy}
+            `.execute(db) : await sql`
+              select rowid as ${sql.raw(INTERNAL_ROWID_COLUMN)}, *
+              from ${sql.table(tableName)}
+              ${searchCondition}
+              ${orderBy}
+              limit ${pageSize}
+              offset ${offset}
+            `.execute(db);
 			const actionsByRowId = await getRowExtractionActions(aiexDir, tableName);
 			const rowActions = Object.fromEntries(result.rows.map((row, index) => {
 				const rowId = row[INTERNAL_ROWID_COLUMN];
@@ -15248,14 +15680,27 @@ function dataRoutes(config) {
 				return action ? [String(index), action] : null;
 			}).filter((entry) => !!entry));
 			const rows = result.rows.map(({ [INTERNAL_ROWID_COLUMN]: _rowid, ...row }) => row);
+			const schemaDir = config.schemaPath;
+			let schema = null;
+			try {
+				const schemaFiles = (await fs.readdir(schemaDir)).filter((f) => f.endsWith(".json"));
+				for (const file of schemaFiles) {
+					const s = await readFile(path.join(schemaDir, file));
+					if (s.table?.name === tableName) {
+						schema = s;
+						break;
+					}
+				}
+			} catch {}
 			return c.json({
 				columns,
 				rows,
 				rowActions,
 				total,
-				page,
-				pageSize,
-				totalPages
+				page: all ? 1 : page,
+				pageSize: all ? total : pageSize,
+				totalPages,
+				schema
 			});
 		} catch (error) {
 			return c.json({ error: error instanceof Error ? error.message : String(error) }, 500);
@@ -15368,17 +15813,6 @@ function jsonResponse(body, status) {
 		headers: { "content-type": "application/json" }
 	});
 }
-async function auditFailureResponse(aiexDir, auditId, error, status) {
-	const record = await updateExtractionAuditRecord(aiexDir, auditId, {
-		status: "failed",
-		error
-	});
-	return jsonResponse({
-		success: false,
-		error: record.error,
-		auditId: record.id
-	}, status);
-}
 async function saveUploadToFile(file, uploadsDir, id) {
 	validateFileUpload(file);
 	await fs.mkdir(uploadsDir, { recursive: true });
@@ -15387,62 +15821,6 @@ async function saveUploadToFile(file, uploadsDir, id) {
 	await fs.writeFile(filePath, buffer);
 	return filePath;
 }
-async function executeAuditedExtraction(input) {
-	const aiConfig = await readAIConfig(input.aiexDir);
-	if (!aiConfig) return auditFailureResponse(input.aiexDir, input.auditId, "AI configuration not found. Configure AI settings first.", 400);
-	if (!aiConfig.provider.apiKey) return auditFailureResponse(input.aiexDir, input.auditId, "API Key not configured. Configure AI settings first.", 400);
-	if (!aiConfig.provider.models?.length) return auditFailureResponse(input.aiexDir, input.auditId, "No models configured. Add at least one model in AI Settings.", 400);
-	const modelOverride = input.modelName ? aiConfig.provider.models.find((model) => model.name === input.modelName) : void 0;
-	if (input.modelName && !modelOverride) return auditFailureResponse(input.aiexDir, input.auditId, `Model "${input.modelName}" not found in AI settings`, 400);
-	let inputText = input.text;
-	let inputFilePath = input.filePath;
-	if (input.filePath) try {
-		const source = await readExtractFileInput(input.filePath, aiConfig);
-		inputText = source.text;
-		inputFilePath = source.filePath;
-	} catch (error) {
-		if (isMissingUploadFileError(error)) return auditFailureResponse(input.aiexDir, input.auditId, MISSING_UPLOAD_FILE_TEXT, 400);
-		throw error;
-	}
-	const result = await extractSingle(input.aiexDir, input.config, aiConfig, input.schemaName, inputText, inputFilePath, modelOverride, { quiet: true });
-	if (!result.success) return auditFailureResponse(input.aiexDir, input.auditId, result.error || "Extraction failed", 500);
-	const notionPages = [];
-	if (aiConfig.notion?.enabled && aiConfig.notion.schemas?.[input.schemaName]?.databaseId?.trim()) 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 jsonResponse({
-			success: false,
-			error: record$1.error,
-			auditId: record$1.id
-		}, 500);
-	}
-	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 jsonResponse({
-		success: true,
-		outputPath: record.outputPath,
-		outputName: record.outputName,
-		tablesInserted: record.tablesInserted,
-		notionPages: record.notionPages,
-		tokensUsed: record.tokensUsed,
-		auditId: record.id
-	}, 200);
-}
 function extractRoutes(config) {
 	const app = new Hono();
 	const aiexDir = path.dirname(config.schemaPath);
@@ -15469,51 +15847,73 @@ function extractRoutes(config) {
 				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;
+			let source;
 			if (file) {
+				const uploadId = `upload-${Date.now()}`;
+				let filePath;
 				try {
-					filePath = await saveUploadToFile(file, uploadsDir, audit.id);
+					filePath = await saveUploadToFile(file, uploadsDir, uploadId);
 				} catch (e) {
-					if (e instanceof FileValidationError) {
-						await updateExtractionAuditRecord(aiexDir, audit.id, {
-							status: "failed",
-							error: e.message
-						});
-						return c.json({
-							success: false,
-							error: e.message,
-							auditId: audit.id
-						}, 400);
-					}
+					if (e instanceof FileValidationError) return c.json({
+						success: false,
+						error: e.message
+					}, 400);
 					throw e;
 				}
-				await updateExtractionAuditRecord(aiexDir, audit.id, { source: {
+				source = {
 					type: "file",
-					filePath,
-					fileName: path.basename(filePath)
-				} });
-			}
-			return executeAuditedExtraction({
+					filePath
+				};
+			} else source = {
+				type: "text",
+				text: text$1
+			};
+			const aiConfig = await readAIConfig(aiexDir);
+			if (!aiConfig) return c.json({
+				success: false,
+				error: "AI configuration not found. Configure AI settings first."
+			}, 400);
+			if (!aiConfig.provider.apiKey) return c.json({
+				success: false,
+				error: "API Key not configured. Configure AI settings first."
+			}, 400);
+			if (!aiConfig.provider.models?.length) return c.json({
+				success: false,
+				error: "No models configured. Add at least one model in AI Settings."
+			}, 400);
+			const modelOverride = modelName ? aiConfig.provider.models.find((model) => model.name === modelName) : void 0;
+			if (modelName && !modelOverride) return c.json({
+				success: false,
+				error: `Model "${modelName}" not found in AI settings`
+			}, 400);
+			const result = await runAuditedExtraction({
 				aiexDir,
-				config,
-				auditId: audit.id,
+				config: createMigrationConfig(path.dirname(aiexDir)),
+				aiConfig,
 				schemaName,
-				text: text$1,
-				filePath,
-				modelName
+				source,
+				modelOverride,
+				quiet: true
 			});
+			if (!result.success) return jsonResponse({
+				success: false,
+				error: result.error,
+				auditId: result.auditId
+			}, 500);
+			return jsonResponse({
+				success: true,
+				outputPath: result.outputPath,
+				outputName: result.outputName,
+				tablesInserted: result.tablesInserted,
+				notionPages: result.notionPages,
+				tokensUsed: result.tokensUsed,
+				auditId: result.auditId
+			}, 200);
 		} catch (error) {
+			if (isMissingUploadFileError(error)) return c.json({
+				success: false,
+				error: MISSING_UPLOAD_FILE_TEXT
+			}, 400);
 			return c.json({
 				success: false,
 				error: error instanceof Error ? error.message : String(error)
@@ -15526,20 +15926,56 @@ function extractRoutes(config) {
 			success: false,
 			error: "Extraction record not found"
 		}, 404);
-		return executeAuditedExtraction({
+		const aiConfig = await readAIConfig(aiexDir);
+		if (!aiConfig) return c.json({
+			success: false,
+			error: "AI configuration not found. Configure AI settings first."
+		}, 400);
+		if (!aiConfig.provider.apiKey) return c.json({
+			success: false,
+			error: "API Key not configured. Configure AI settings first."
+		}, 400);
+		if (!aiConfig.provider.models?.length) return c.json({
+			success: false,
+			error: "No models configured. Add at least one model in AI Settings."
+		}, 400);
+		const modelOverride = original.modelName ? aiConfig.provider.models.find((m) => m.name === original.modelName) : void 0;
+		if (original.modelName && !modelOverride) return c.json({
+			success: false,
+			error: `Model "${original.modelName}" not found in AI settings`
+		}, 400);
+		const source = original.source.type === "file" && original.source.filePath ? {
+			type: "file",
+			filePath: original.source.filePath
+		} : {
+			type: "text",
+			text: original.source.text ?? ""
+		};
+		const result = await runAuditedExtraction({
 			aiexDir,
-			config,
-			auditId: (await createExtractionAuditRecord(aiexDir, {
-				schemaName: original.schemaName,
-				modelName: original.modelName,
-				source: original.source,
-				retryOf: original.id
-			})).id,
+			config: createMigrationConfig(path.dirname(aiexDir)),
+			aiConfig,
 			schemaName: original.schemaName,
-			text: original.source.type === "text" ? original.source.text ?? "" : "",
-			filePath: original.source.type === "file" ? original.source.filePath : void 0,
-			modelName: original.modelName
+			source,
+			modelOverride,
+			retryOf: original.id,
+			force: true,
+			quiet: true
 		});
+		if (!result.success) return jsonResponse({
+			success: false,
+			error: result.error,
+			auditId: result.auditId
+		}, 500);
+		return jsonResponse({
+			success: true,
+			outputPath: result.outputPath,
+			outputName: result.outputName,
+			tablesInserted: result.tablesInserted,
+			notionPages: result.notionPages,
+			tokensUsed: result.tokensUsed,
+			auditId: result.auditId
+		}, 200);
 	});
 	app.delete("/extract/records/:id", async (c) => {
 		const id = c.req.param("id");
@@ -15773,6 +16209,8 @@ const subCommands = {
 	web: webCommand,
 	schema: schemaCommand,
 	extract: extractCommand,
+	watch: watchCommand,
+	export: exportCommand,
 	completion: completionCommand,
 	doctor: doctorCommand
 };