aiex-cli 0.0.1 → 0.0.2-beta.10

package/dist/cli.mjs

@@ -1,4 +1,4 @@
-import { C as doctorDiagnosticsTableRows, _ as seedConfig, a as parseJsonSchema, b as package_default, c as getDefaultAIConfig, d as DEFAULT_MINERU_CONFIG, f as DEFAULT_PROMPT_CONFIG, g as createConfig, h as AIConfigSchema, i as JsonSchemaDefinitionSchema, l as readAIConfig, m as PLACEHOLDER_TEXT, n as createMigrationConfig, o as toSnakeCase, p as PLACEHOLDER_SCHEMA, s as generateDrizzleSchema, t as collectDoctorDiagnostics, u as writeAIConfig, v as description, w as formatDoctorDiagnosticsJson, x as version, y as name } from "./doctor-collector-CykRm0fC.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-DlG_mJKG.mjs";
 import { createRequire } from "node:module";
 import fs from "node:fs/promises";
 import os from "node:os";
@@ -23,9 +23,10 @@ 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 { Buffer } from "node:buffer";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import { serve } from "@hono/node-server";
@@ -12989,6 +12990,7 @@ function initLangfuse(config) {
 }
 const SYSTEM_PROMPT_REGEX = /## System Prompt\n([\s\S]*?)(?=## User Prompt|$)/;
 const USER_PROMPT_REGEX = /## User Prompt Template\n([\s\S]*)$/;
+const OPENAI_COMPATIBLE_PROVIDER_NAME = "openai-compatible";
 function detectMimeType(filePath) {
 	return mime.getType(filePath) ?? "application/octet-stream";
 }
@@ -13147,8 +13149,9 @@ async function extractStructuredData(input) {
 		if (useTelemetry) initLangfuse(config);
 		const provider = createOpenAICompatible({
 			baseURL: config.provider.baseURL,
-			name: "qwen",
-			apiKey: config.provider.apiKey
+			name: OPENAI_COMPATIBLE_PROVIDER_NAME,
+			apiKey: config.provider.apiKey,
+			supportsStructuredOutputs: useStructuredOutput
 		});
 		let system;
 		let user;
@@ -13381,6 +13384,342 @@ async function savePromptSnapshot(schema, aiexDir) {
 	return outputPath;
 }
 
+//#endregion
+//#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/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;
+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 getValueAtPath(data, path$1) {
+	if (!path$1.includes(".")) return Object.hasOwn(data, path$1) ? {
+		found: true,
+		value: data[path$1]
+	} : {
+		found: false,
+		value: void 0
+	};
+	let current = data;
+	for (const part of path$1.split(".")) {
+		if (!current || typeof current !== "object" || Array.isArray(current)) return {
+			found: false,
+			value: void 0
+		};
+		const record = current;
+		if (!Object.hasOwn(record, part)) return {
+			found: false,
+			value: void 0
+		};
+		current = record[part];
+	}
+	return {
+		found: true,
+		value: current
+	};
+}
+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 "";
+	const extracted = extractNotionId(input);
+	if (extracted) return extracted;
+	if (HYPHENATED_UUID_RE.test(input)) return input;
+	if (UUID_RE.test(input)) return hyphenateDatabaseId(input);
+	return 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;
+}
+function hasProperties(value) {
+	return !!value && typeof value === "object" && !!value.properties && typeof value.properties === "object";
+}
+function firstDataSourceId(database) {
+	return (Array.isArray(database?.data_sources) ? database.data_sources : []).find((source) => typeof source?.id === "string" && source.id.trim())?.id;
+}
+async function resolveNotionDataSource(notion, inputId) {
+	const id = parseNotionDatabaseId(inputId);
+	if (!id) throw new Error("Notion database or data source URL/ID is required.");
+	try {
+		const dataSource$1 = await notion.dataSources.retrieve({ data_source_id: id });
+		if (hasProperties(dataSource$1)) return {
+			databaseId: typeof dataSource$1.parent?.database_id === "string" ? dataSource$1.parent.database_id : id,
+			dataSourceId: dataSource$1.id ?? id,
+			properties: dataSource$1.properties,
+			parent: { data_source_id: dataSource$1.id ?? id }
+		};
+	} catch {}
+	const database = await notion.databases.retrieve({ database_id: id });
+	const dataSourceId = firstDataSourceId(database);
+	if (!dataSourceId) throw new Error("No data source found for this Notion database. Copy the data source link from Notion, or share the source database with the integration.");
+	const dataSource = await notion.dataSources.retrieve({ data_source_id: dataSourceId });
+	if (!hasProperties(dataSource)) throw new Error("Notion data source did not return properties. Make sure it is shared with the integration and is not a linked data source.");
+	return {
+		databaseId: database.id ?? id,
+		dataSourceId: dataSource.id ?? dataSourceId,
+		properties: dataSource.properties,
+		parent: { data_source_id: dataSource.id ?? dataSourceId }
+	};
+}
+async function inspectNotionDatabase(input) {
+	if (!input.token.trim()) throw new Error("Notion integration token is required.");
+	const id = parseNotionDatabaseId(input.databaseId);
+	if (!id) throw new Error("Notion database or data source URL/ID is required.");
+	const resolved = await resolveNotionDataSource(new Client({ auth: input.token }), id);
+	const databaseProperties = resolved.properties;
+	const titleProperty = findTitleProperty(databaseProperties) ?? void 0;
+	return {
+		databaseId: resolved.databaseId,
+		dataSourceId: resolved.dataSourceId,
+		titleProperty,
+		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 resolved = await resolveNotionDataSource(notion, schemaConfig.databaseId);
+	const databaseProperties = resolved.properties;
+	const fieldMap = schemaConfig.fieldMap ?? {};
+	const properties = {};
+	const sourceFields = new Set([...Object.keys(data), ...Object.keys(fieldMap)]);
+	for (const sourceField of sourceFields) {
+		const source = getValueAtPath(data, sourceField);
+		if (!source.found) continue;
+		const notionPropertyName = fieldMap[sourceField] ?? sourceField;
+		const notionProperty = databaseProperties[notionPropertyName];
+		if (!notionProperty) continue;
+		const propertyValue = buildPropertyValue(notionProperty.type, source.value);
+		if (propertyValue) properties[notionPropertyName] = propertyValue;
+	}
+	const titleProperty = findTitleProperty(databaseProperties, schemaConfig.titleProperty);
+	if (titleProperty && !properties[titleProperty]) properties[titleProperty] = buildPropertyValue("title", schemaName);
+	if (Object.keys(properties).length === 0) throw new Error("No extracted fields matched Notion database properties.");
+	return {
+		pageId: (await notion.pages.create({
+			parent: resolved.parent,
+			properties
+		})).id,
+		databaseId: resolved.databaseId,
+		dataSourceId: resolved.dataSourceId
+	};
+}
+
 //#endregion
 //#region src/core/pdf-converter/external.ts
 function applyTemplate(value, context) {
@@ -13421,7 +13760,7 @@ function formatCommandError(error, command$1) {
 }
 async function countPdfPages(input) {
 	try {
-		return (await getDocumentProxy(input)).numPages;
+		return (await getDocumentProxy(Buffer.isBuffer(input) ? new Uint8Array(input) : input)).numPages;
 	} catch {
 		return 0;
 	}
@@ -13433,7 +13772,7 @@ var ExternalCommandPdfConverter = class {
 		this.name = name$1;
 	}
 	async convert(input, filePath) {
-		const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "aiex-mineru-"));
+		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");
@@ -13530,6 +13869,10 @@ function createPdfConverter(config) {
 			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);
@@ -13569,8 +13912,19 @@ const SUPPORTED_EXTENSIONS = new Set([
 	"yml"
 ]);
 const PDF_EXT_RE = /\.pdf$/i;
-const JSON_EXT_RE = /\.json$/;
+const JSON_EXT_RE$1 = /\.json$/;
 const SUPPORTED_FILE_PATTERN = `*.{${[...SUPPORTED_EXTENSIONS].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);
+	return [{
+		databaseId: page.databaseId,
+		pageId: page.pageId
+	}];
+}
+function shouldSyncNotion(aiConfig, schemaName) {
+	return !!aiConfig.notion?.enabled && !!aiConfig.notion.schemas?.[schemaName]?.databaseId?.trim();
+}
 async function ensureDatabaseReady(dbPath, schema) {
 	try {
 		await fs.access(dbPath);
@@ -13628,7 +13982,7 @@ async function loadSchema(config, schemaName) {
 async function listSchemas(aiexDir) {
 	try {
 		const dir = path.join(aiexDir, "schema");
-		return (await fs.readdir(dir)).filter((f) => f.endsWith(".json")).map((f) => f.replace(JSON_EXT_RE, "")).sort();
+		return (await fs.readdir(dir)).filter((f) => f.endsWith(".json")).map((f) => f.replace(JSON_EXT_RE$1, "")).sort();
 	} catch {
 		return [];
 	}
@@ -13693,7 +14047,7 @@ async function extractSingle(aiexDir, config, aiConfig, schemaName, text$1, file
 	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) {
+	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);
@@ -13711,6 +14065,13 @@ async function extractSingle(aiexDir, config, aiConfig, schemaName, text$1, file
 				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");
@@ -13731,25 +14092,74 @@ async function extractSingle(aiexDir, config, aiConfig, schemaName, text$1, file
 			};
 		}
 	}
-	return { success: true };
+	return {
+		success: true,
+		outputPath: result.outputPath,
+		data: result.data,
+		tokensUsed: result.tokensUsed
+	};
 }
-async function processOneFile(aiexDir, config, aiConfig, schemaName, filePath, modelOverride) {
+async function processOneFile(aiexDir, config, aiConfig, schemaName, filePath, modelOverride, options) {
+	const audit = await createExtractionAuditRecord(aiexDir, {
+		schemaName,
+		modelName: modelOverride?.name,
+		source: {
+			type: "file",
+			filePath,
+			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 });
+		const r = await extractSingle(aiexDir, config, aiConfig, schemaName, input.text, input.filePath, modelOverride, {
+			quiet: false,
+			insert: options?.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)`);
+			} catch (error) {
+				await updateExtractionAuditRecord(aiexDir, audit.id, {
+					status: "failed",
+					outputPath: r.outputPath,
+					outputName: r.outputPath ? path.basename(r.outputPath) : void 0,
+					tablesInserted: r.tablesInserted,
+					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;
+			}
+			await updateExtractionAuditRecord(aiexDir, audit.id, {
+				status: "succeeded",
+				outputPath: r.outputPath,
+				outputName: r.outputPath ? path.basename(r.outputPath) : void 0,
+				tablesInserted: r.tablesInserted,
+				notionPages,
+				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) {
+async function runBatchExtraction(aiexDir, config, aiConfig, schemaName, dir, globPattern, modelOverride, options) {
 	consola.info(`Scanning ${pc.cyan(dir)} for supported files...`);
 	let files;
 	try {
@@ -13774,7 +14184,7 @@ 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)) successCount++;
+		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`);
@@ -13787,11 +14197,230 @@ async function runBatchExtraction(aiexDir, config, aiConfig, schemaName, dir, gl
 
 //#endregion
 //#region src/commands/extract.ts
+function getIdArg(args) {
+	if (typeof args.id === "string") return args.id;
+	const positional = args._;
+	return Array.isArray(positional) && typeof positional[0] === "string" ? positional[0] : "";
+}
+function isExtractSubCommand(rawArgs) {
+	if (!Array.isArray(rawArgs)) return false;
+	return rawArgs.some((arg) => typeof arg === "string" && [
+		"history",
+		"show",
+		"retry",
+		"rm"
+	].includes(arg));
+}
+function formatSource(source) {
+	return source.type === "file" ? source.fileName || "file" : "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) {
+		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",
+		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",
@@ -13822,9 +14451,15 @@ const extractCommand = defineCommand({
 			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 }) {
+	async run({ args, rawArgs }) {
+		if (isExtractSubCommand(rawArgs)) return;
 		intro(pc.inverse(" aiex extract "));
 		const config = createMigrationConfig(process.cwd());
 		const aiexDir = path.dirname(config.schemaPath);
@@ -13836,29 +14471,10 @@ const extractCommand = defineCommand({
 			failCommand("Cannot combine -f/--file with -d/--dir");
 			return;
 		}
-		const aiConfig = await readAIConfig(aiexDir);
-		if (!aiConfig) {
-			failCommand("AI configuration not found. Please run \"aiex web\" to configure AI settings first");
-			return;
-		}
-		if (!aiConfig.provider.apiKey) {
-			failCommand("API Key not configured. Please configure AI settings in the Web interface first");
-			return;
-		}
-		if (!aiConfig.provider.models?.length) {
-			failCommand("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(", ");
-				failCommand(`Model "${args.model}" not found in configuration. Available models: ${available}`);
-				return;
-			}
-			modelOverride = matched;
-		}
+		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;
@@ -13868,7 +14484,7 @@ 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);
+			const result = await runBatchExtraction(aiexDir, config, aiConfig, args.schema, args.dir, args.glob, modelOverride, { insert: !args.noInsert });
 			if (!result.ok) {
 				failCommand(result.error);
 				return;
@@ -13901,7 +14517,24 @@ const extractCommand = defineCommand({
 			return;
 		}
 		else if (args.text) text$1 = args.text;
-		if (!(await extractSingle(aiexDir, config, aiConfig, args.schema, text$1, filePath, modelOverride)).success) {
+		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;
 		}
@@ -13960,7 +14593,18 @@ async function runInteractive(aiexDir, config, aiConfig, modelOverride) {
 			cancel("Cancelled");
 			return false;
 		}
-		return (await extractSingle(aiexDir, config, aiConfig, schemaName, textContent, void 0, modelOverride)).success;
+		return runAuditedSingleExtraction({
+			aiexDir,
+			config,
+			aiConfig,
+			schemaName,
+			text: textContent,
+			source: {
+				type: "text",
+				text: textContent
+			},
+			modelOverride
+		});
 	} else if (inputSource === "file") {
 		const filePathStr = await text({
 			message: "Enter file path:",
@@ -13975,7 +14619,20 @@ async function runInteractive(aiexDir, config, aiConfig, modelOverride) {
 		const fp = filePathStr;
 		try {
 			const input = await readExtractFileInput(fp, aiConfig);
-			return (await extractSingle(aiexDir, config, aiConfig, schemaName, input.text, input.filePath, modelOverride)).success;
+			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;
@@ -14183,6 +14840,32 @@ const schemaCommand = defineCommand({
 
 //#endregion
 //#region src/server/routes/ai.ts
+const JSON_EXT_RE = /\.json$/i;
+function extractSchemaFields(schema) {
+	if (!schema?.properties || typeof schema.properties !== "object") return [];
+	const fields = [];
+	function visitProperties(properties, prefix = "") {
+		for (const [name$1, property] of Object.entries(properties)) {
+			const fieldName = prefix ? `${prefix}.${name$1}` : name$1;
+			if (property?.type === "object" && property?.properties && typeof property.properties === "object") {
+				visitProperties(property.properties, fieldName);
+				continue;
+			}
+			if (property?.type === "array" && property?.items?.type === "object") continue;
+			fields.push({
+				name: fieldName,
+				title: typeof property?.title === "string" ? property.title : void 0,
+				description: typeof property?.description === "string" ? property.description : void 0
+			});
+		}
+	}
+	visitProperties(schema.properties);
+	return fields;
+}
+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);
@@ -14209,6 +14892,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();
@@ -14226,6 +14935,19 @@ function aiRoutes(config) {
 				success: false,
 				error: "At least one model must be configured"
 			}, 400);
+			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 });
 		} catch (error) {
@@ -14241,6 +14963,7 @@ function aiRoutes(config) {
 //#endregion
 //#region src/server/routes/data.ts
 const FILE_REGEX = /\.json$/;
+const EXTRACTION_TIMESTAMP_RE = /-\d{4}-\d{2}-\d{2}T/;
 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_]*$/) });
@@ -14257,6 +14980,12 @@ function invalidParamResponse$1(message) {
 		if (!result.success) return c.json({ error: message }, 400);
 	};
 }
+function schemaNameFromExtractionFile(name$1) {
+	const stem = name$1.replace(FILE_REGEX, "");
+	const match = stem.match(EXTRACTION_TIMESTAMP_RE);
+	if (!match || typeof match.index !== "number" || match.index <= 0) return null;
+	return stem.slice(0, match.index);
+}
 function createReadonlyQueryDb(databasePath) {
 	return new Kysely({ dialect: new SqliteDialect({ database: new Database(databasePath, { readonly: true }) }) });
 }
@@ -14268,22 +14997,27 @@ function dataRoutes(config) {
 		try {
 			await fs.mkdir(extractedDir, { recursive: true });
 			const jsonFiles = (await fs.readdir(extractedDir)).filter((f) => f.endsWith(".json") && !f.endsWith(".prompt.md"));
+			const auditRecords = await listExtractionAuditRecords(aiexDir);
+			const auditByOutputName = new Map(auditRecords.map((record) => [record.outputName, record]));
 			const records = [];
 			for (const file of jsonFiles) {
-				const name$1 = file.replace(FILE_REGEX, "");
-				const idx = name$1.lastIndexOf("-");
-				if (idx === -1) continue;
-				const schemaName = name$1.slice(0, idx);
-				const timestamp = name$1.slice(idx + 1).replace(/-/g, (d, i) => i === 4 || i === 7 ? "-" : d).replace(TIMESTAMP_CLEANUP, (_, h, m, s) => `${h}:${m}:${s}`).replace(TIMESTAMP_TZ, ".$1Z");
+				const schemaName = schemaNameFromExtractionFile(file);
+				if (!schemaName) continue;
+				const timestamp = file.replace(FILE_REGEX, "").slice(schemaName.length + 1).replace(/-/g, (d, i) => i === 4 || i === 7 ? "-" : d).replace(TIMESTAMP_CLEANUP, (_, h, m, s) => `${h}:${m}:${s}`).replace(TIMESTAMP_TZ, ".$1Z");
 				const filePath = path.join(extractedDir, file);
 				try {
 					const stat = await fs.stat(filePath);
+					const audit = auditByOutputName.get(file);
+					const notionPages = audit?.notionPages?.length ? audit.notionPages : void 0;
 					records.push({
 						name: file,
 						schemaName,
 						timestamp,
 						fileSize: stat.size,
-						modifiedAt: stat.mtime.toISOString()
+						modifiedAt: stat.mtime.toISOString(),
+						notionStatus: notionPages ? "synced" : audit?.status === "failed" ? "failed" : "not_synced",
+						notionPages,
+						notionError: !notionPages && audit?.status === "failed" ? audit.error : void 0
 					});
 				} catch {
 					continue;
@@ -14405,6 +15139,308 @@ function dataRoutes(config) {
 			return c.json({ error: "Extraction result not found" }, 404);
 		}
 	});
+	app.post("/data/:name/notion/retry", 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);
+		const schemaName = schemaNameFromExtractionFile(name$1);
+		if (!schemaName) return c.json({
+			success: false,
+			error: "Cannot infer schema name from extraction file name"
+		}, 400);
+		const aiConfig = await readAIConfig(aiexDir);
+		if (!aiConfig?.notion?.enabled) return c.json({
+			success: false,
+			error: "Notion export is not enabled. Configure Notion settings first."
+		}, 400);
+		if (!aiConfig.notion.schemas?.[schemaName]?.databaseId?.trim()) return c.json({
+			success: false,
+			error: `Notion database is not configured for schema "${schemaName}".`
+		}, 400);
+		try {
+			const data = await readFile(filePath);
+			if (!data || typeof data !== "object" || Array.isArray(data)) return c.json({
+				success: false,
+				error: "Extraction result is not a JSON object and cannot be written to Notion."
+			}, 400);
+			const page = await writeNotionPage(aiConfig.notion, schemaName, data);
+			const notionPages = [{
+				databaseId: page.databaseId,
+				pageId: page.pageId
+			}];
+			let record = (await listExtractionAuditRecords(aiexDir)).find((record$1) => record$1.outputName === name$1);
+			if (!record) record = await createExtractionAuditRecord(aiexDir, {
+				schemaName,
+				source: {
+					type: "file",
+					filePath,
+					fileName: name$1
+				}
+			});
+			if (record) await updateExtractionAuditRecord(aiexDir, record.id, {
+				status: "succeeded",
+				outputPath: filePath,
+				outputName: name$1,
+				notionPages,
+				error: void 0
+			});
+			return c.json({
+				success: true,
+				notionPages
+			});
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			const record = (await listExtractionAuditRecords(aiexDir)).find((record$1) => record$1.outputName === name$1);
+			if (record) await updateExtractionAuditRecord(aiexDir, record.id, {
+				status: "failed",
+				outputPath: filePath,
+				outputName: name$1,
+				error: message
+			});
+			return c.json({
+				success: false,
+				error: message
+			}, 500);
+		}
+	});
+	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 (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 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 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
+			});
+		} 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;
 }
 
@@ -14530,6 +15566,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,