aiex-cli 0.0.1 → 0.0.2-beta.1

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-Cbqgwx__.mjs";
 import { createRequire } from "node:module";
 import fs from "node:fs/promises";
 import os from "node:os";
@@ -33,6 +33,7 @@ import open from "open";
 import { serveStatic } from "@hono/node-server/serve-static";
 import { Hono } from "hono";
 import { cors } from "hono/cors";
+import { Client } from "@notionhq/client";
 import { zValidator } from "@hono/zod-validator";
 import { Kysely, SqliteDialect, sql } from "kysely";
 
@@ -13381,6 +13382,111 @@ 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/pdf-converter/external.ts
 function applyTemplate(value, context) {
@@ -13433,7 +13539,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 +13636,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,7 +13679,7 @@ 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 ensureDatabaseReady(dbPath, schema) {
 	try {
@@ -13628,7 +13738,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 +13803,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 +13821,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 +13848,57 @@ 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) {
+			await updateExtractionAuditRecord(aiexDir, audit.id, {
+				status: "succeeded",
+				outputPath: r.outputPath,
+				outputName: r.outputPath ? path.basename(r.outputPath) : void 0,
+				tablesInserted: r.tablesInserted,
+				tokensUsed: r.tokensUsed
+			});
 			consola.success(`Processed: ${path.basename(filePath)}`);
 			return true;
 		} else {
+			await updateExtractionAuditRecord(aiexDir, audit.id, {
+				status: "failed",
+				error: r.error || "Extraction failed"
+			});
 			consola.error(`Failed: ${r.error}`);
 			return false;
 		}
 	} catch (e) {
+		await updateExtractionAuditRecord(aiexDir, audit.id, {
+			status: "failed",
+			error: e instanceof Error ? e.message : String(e)
+		});
 		consola.error(`Error processing ${path.basename(filePath)}: ${e instanceof Error ? e.message : String(e)}`);
 		return false;
 	}
 }
-async function runBatchExtraction(aiexDir, config, aiConfig, schemaName, dir, globPattern, modelOverride) {
+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 +13923,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 +13936,199 @@ 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 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;
+	}
+	await updateExtractionAuditRecord(input.aiexDir, audit.id, {
+		status: "succeeded",
+		outputPath: result.outputPath,
+		outputName: result.outputPath ? path.basename(result.outputPath) : void 0,
+		tablesInserted: result.tablesInserted,
+		tokensUsed: result.tokensUsed
+	});
+	return true;
+}
+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,6 +14159,11 @@ 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 }) {
@@ -13836,29 +14178,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 +14191,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 +14224,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;
 		}
@@ -14181,8 +14521,192 @@ const schemaCommand = defineCommand({
 	}
 });
 
+//#endregion
+//#region src/core/notion-sink.ts
+const RICH_TEXT_LIMIT = 2e3;
+const UUID_RE = /^[0-9a-f]{32}$/i;
+const HYPHENATED_UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const UUID_IN_TEXT_RE = /[0-9a-f]{32}/i;
+function truncateText(value) {
+	return value.length > RICH_TEXT_LIMIT ? value.slice(0, RICH_TEXT_LIMIT) : value;
+}
+function stringifyValue(value) {
+	if (value === null || value === void 0) return "";
+	if (typeof value === "string") return value;
+	if (typeof value === "number" || typeof value === "boolean") return String(value);
+	return JSON.stringify(value);
+}
+function asNumber(value) {
+	if (typeof value === "number" && Number.isFinite(value)) return value;
+	if (typeof value === "string" && value.trim()) {
+		const parsed = Number(value);
+		return Number.isFinite(parsed) ? parsed : null;
+	}
+	return null;
+}
+function asBoolean(value) {
+	if (typeof value === "boolean") return value;
+	if (typeof value === "number") return value !== 0;
+	if (typeof value === "string") {
+		const normalized = value.trim().toLowerCase();
+		return [
+			"true",
+			"yes",
+			"1",
+			"y"
+		].includes(normalized);
+	}
+	return !!value;
+}
+function asDateStart(value) {
+	if (value instanceof Date && !Number.isNaN(value.getTime())) return value.toISOString();
+	if (typeof value === "number" && Number.isFinite(value)) {
+		const date = new Date(value);
+		return Number.isNaN(date.getTime()) ? null : date.toISOString();
+	}
+	if (typeof value === "string" && value.trim()) {
+		const ms = Date.parse(value);
+		if (Number.isNaN(ms)) return null;
+		return new Date(ms).toISOString();
+	}
+	return null;
+}
+function asStringArray(value) {
+	if (Array.isArray(value)) return value.map((item) => stringifyValue(item).trim()).filter(Boolean);
+	const text$1 = stringifyValue(value).trim();
+	return text$1 ? [text$1] : [];
+}
+function buildPropertyValue(type, value) {
+	const text$1 = truncateText(stringifyValue(value));
+	switch (type) {
+		case "title": return { title: text$1 ? [{ text: { content: text$1 } }] : [] };
+		case "rich_text": return { rich_text: text$1 ? [{ text: { content: text$1 } }] : [] };
+		case "number": return { number: asNumber(value) };
+		case "checkbox": return { checkbox: asBoolean(value) };
+		case "date": {
+			const start = asDateStart(value);
+			return { date: start ? { start } : null };
+		}
+		case "select": {
+			const name$1 = stringifyValue(value).trim();
+			return { select: name$1 ? { name: name$1 } : null };
+		}
+		case "multi_select": return { multi_select: asStringArray(value).map((name$1) => ({ name: name$1 })) };
+		case "url": return { url: text$1 || null };
+		case "email": return { email: text$1 || null };
+		case "phone_number": return { phone_number: text$1 || null };
+		default: return null;
+	}
+}
+function findTitleProperty(properties, preferred) {
+	if (preferred && properties[preferred]?.type === "title") return preferred;
+	return Object.entries(properties).find(([, property]) => property?.type === "title")?.[0] ?? null;
+}
+function hyphenateDatabaseId(value) {
+	const id = value.replace(/-/g, "");
+	if (!UUID_RE.test(id)) return value;
+	return `${id.slice(0, 8)}-${id.slice(8, 12)}-${id.slice(12, 16)}-${id.slice(16, 20)}-${id.slice(20)}`;
+}
+function parseNotionDatabaseId(value) {
+	const input = value.trim();
+	if (!input) return "";
+	if (HYPHENATED_UUID_RE.test(input)) return input;
+	if (UUID_RE.test(input)) return hyphenateDatabaseId(input);
+	const match = input.replace(/-/g, "").match(UUID_IN_TEXT_RE);
+	return match ? hyphenateDatabaseId(match[0]) : input;
+}
+function normalizeFieldName(value) {
+	return value.normalize("NFKC").toLowerCase().replace(/[^\p{Letter}\p{Number}]+/gu, "");
+}
+function buildMatchKeys(field) {
+	return [
+		field.name,
+		field.title,
+		field.description
+	].filter((value) => !!value?.trim()).map(normalizeFieldName).filter(Boolean);
+}
+function suggestFieldMap(schemaFields, databaseProperties) {
+	const propertyByKey = /* @__PURE__ */ new Map();
+	for (const propertyName of Object.keys(databaseProperties)) propertyByKey.set(normalizeFieldName(propertyName), propertyName);
+	const fieldMap = {};
+	for (const field of schemaFields) for (const key of buildMatchKeys(field)) {
+		const propertyName = propertyByKey.get(key);
+		if (propertyName) {
+			fieldMap[field.name] = propertyName;
+			break;
+		}
+	}
+	return fieldMap;
+}
+async function inspectNotionDatabase(input) {
+	if (!input.token.trim()) throw new Error("Notion integration token is required.");
+	const databaseId = parseNotionDatabaseId(input.databaseId);
+	if (!databaseId) throw new Error("Notion database URL or ID is required.");
+	const databaseProperties = (await new Client({ auth: input.token }).databases.retrieve({ database_id: databaseId })).properties;
+	return {
+		databaseId,
+		titleProperty: findTitleProperty(databaseProperties) ?? void 0,
+		properties: Object.entries(databaseProperties).map(([name$1, property]) => ({
+			name: name$1,
+			type: property?.type ?? "unknown"
+		})).sort((a, b) => a.name.localeCompare(b.name)),
+		suggestedFieldMap: suggestFieldMap(input.schemaFields, databaseProperties)
+	};
+}
+function validateNotionConfig(config) {
+	if (!config?.enabled) return "Notion export is not enabled. Configure Notion settings first.";
+	if (!config.token.trim()) return "Notion integration token is required.";
+	return null;
+}
+async function writeNotionPage(config, schemaName, data) {
+	const configError = validateNotionConfig(config);
+	if (configError) throw new Error(configError);
+	const notionConfig = config;
+	const schemaConfig = notionConfig.schemas[schemaName];
+	if (!schemaConfig) throw new Error(`Notion database is not configured for schema "${schemaName}".`);
+	if (!schemaConfig.databaseId.trim()) throw new Error(`Notion database ID is required for schema "${schemaName}".`);
+	const notion = new Client({ auth: notionConfig.token });
+	const databaseProperties = (await notion.databases.retrieve({ database_id: schemaConfig.databaseId })).properties;
+	const fieldMap = schemaConfig.fieldMap ?? {};
+	const properties = {};
+	for (const [sourceField, sourceValue] of Object.entries(data)) {
+		const notionPropertyName = fieldMap[sourceField] ?? sourceField;
+		const notionProperty = databaseProperties[notionPropertyName];
+		if (!notionProperty) continue;
+		const propertyValue = buildPropertyValue(notionProperty.type, sourceValue);
+		if (propertyValue) properties[notionPropertyName] = propertyValue;
+	}
+	const titleProperty = findTitleProperty(databaseProperties, schemaConfig.titleProperty);
+	if (titleProperty && !properties[titleProperty]) properties[titleProperty] = buildPropertyValue("title", Object.entries(data).find(([, value]) => typeof value === "string" && value.trim())?.[1] ?? schemaName);
+	if (Object.keys(properties).length === 0) throw new Error("No extracted fields matched Notion database properties.");
+	return {
+		pageId: (await notion.pages.create({
+			parent: { database_id: schemaConfig.databaseId },
+			properties
+		})).id,
+		databaseId: schemaConfig.databaseId
+	};
+}
+
 //#endregion
 //#region src/server/routes/ai.ts
+const JSON_EXT_RE = /\.json$/i;
+function extractSchemaFields(schema) {
+	if (!schema?.properties || typeof schema.properties !== "object") return [];
+	return Object.entries(schema.properties).filter(([, property]) => {
+		if (property?.nested?.enabled) return false;
+		if (property?.type === "array" && property?.items?.nested?.enabled) return false;
+		return true;
+	}).map(([name$1, property]) => ({
+		name: name$1,
+		title: typeof property?.title === "string" ? property.title : void 0,
+		description: typeof property?.description === "string" ? property.description : void 0
+	}));
+}
+async function loadSchemaFields(config, schemaName) {
+	const safeName = path.basename(schemaName).replace(JSON_EXT_RE, "");
+	return extractSchemaFields(await readFile(path.join(config.schemaPath, `${safeName}.json`)));
+}
 function aiRoutes(config) {
 	const app = new Hono();
 	const aiexDir = path.dirname(config.schemaPath);
@@ -14209,6 +14733,32 @@ function aiRoutes(config) {
 			return c.json({});
 		}
 	});
+	app.post("/ai/notion/inspect", async (c) => {
+		try {
+			const body = await c.req.json();
+			const token = typeof body.token === "string" ? body.token : "";
+			const databaseId = typeof body.databaseId === "string" ? body.databaseId : "";
+			const schemaName = typeof body.schemaName === "string" ? body.schemaName : "";
+			if (!schemaName) return c.json({
+				success: false,
+				error: "Schema is required"
+			}, 400);
+			const result = await inspectNotionDatabase({
+				token,
+				databaseId,
+				schemaFields: await loadSchemaFields(config, schemaName)
+			});
+			return c.json({
+				success: true,
+				...result
+			});
+		} catch (error) {
+			return c.json({
+				success: false,
+				error: getErrorMessage(error)
+			}, 400);
+		}
+	});
 	app.put("/ai/config", async (c) => {
 		try {
 			const body = await c.req.json();
@@ -14226,6 +14776,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) {
@@ -14408,6 +14971,247 @@ function dataRoutes(config) {
 	return app;
 }
 
+//#endregion
+//#region src/server/routes/extract.ts
+function getFormString(value) {
+	if (Array.isArray(value)) return getFormString(value[0]);
+	return typeof value === "string" ? value.trim() : "";
+}
+function getFormFile(value) {
+	if (Array.isArray(value)) return getFormFile(value[0]);
+	return value instanceof File && value.size > 0 ? value : null;
+}
+function safeUploadName(name$1) {
+	return path.basename(name$1).replace(/[^\w.-]/g, "_") || "upload.txt";
+}
+async function saveUploadToFile(file, uploadsDir, id) {
+	await fs.mkdir(uploadsDir, { recursive: true });
+	const filePath = path.join(uploadsDir, `${id}-${safeUploadName(file.name)}`);
+	const buffer = Buffer.from(await file.arrayBuffer());
+	await fs.writeFile(filePath, buffer);
+	return filePath;
+}
+async function executeAuditedExtraction(input) {
+	const aiConfig = await readAIConfig(input.aiexDir);
+	if (!aiConfig) {
+		const record$1 = await updateExtractionAuditRecord(input.aiexDir, input.auditId, {
+			status: "failed",
+			error: "AI configuration not found. Configure AI settings first."
+		});
+		return new Response(JSON.stringify({
+			success: false,
+			error: record$1.error,
+			auditId: record$1.id
+		}), {
+			status: 400,
+			headers: { "content-type": "application/json" }
+		});
+	}
+	if (!aiConfig.provider.apiKey) {
+		const record$1 = await updateExtractionAuditRecord(input.aiexDir, input.auditId, {
+			status: "failed",
+			error: "API Key not configured. Configure AI settings first."
+		});
+		return new Response(JSON.stringify({
+			success: false,
+			error: record$1.error,
+			auditId: record$1.id
+		}), {
+			status: 400,
+			headers: { "content-type": "application/json" }
+		});
+	}
+	if (!aiConfig.provider.models?.length) {
+		const record$1 = await updateExtractionAuditRecord(input.aiexDir, input.auditId, {
+			status: "failed",
+			error: "No models configured. Add at least one model in AI Settings."
+		});
+		return new Response(JSON.stringify({
+			success: false,
+			error: record$1.error,
+			auditId: record$1.id
+		}), {
+			status: 400,
+			headers: { "content-type": "application/json" }
+		});
+	}
+	const modelOverride = input.modelName ? aiConfig.provider.models.find((model) => model.name === input.modelName) : void 0;
+	if (input.modelName && !modelOverride) {
+		const record$1 = await updateExtractionAuditRecord(input.aiexDir, input.auditId, {
+			status: "failed",
+			error: `Model "${input.modelName}" not found in AI settings`
+		});
+		return new Response(JSON.stringify({
+			success: false,
+			error: record$1.error,
+			auditId: record$1.id
+		}), {
+			status: 400,
+			headers: { "content-type": "application/json" }
+		});
+	}
+	let inputText = input.text;
+	let inputFilePath = input.filePath;
+	if (input.filePath) {
+		const source = await readExtractFileInput(input.filePath, aiConfig);
+		inputText = source.text;
+		inputFilePath = source.filePath;
+	}
+	const result = await extractSingle(input.aiexDir, input.config, aiConfig, input.schemaName, inputText, inputFilePath, modelOverride, { quiet: true });
+	if (!result.success) {
+		const record$1 = await updateExtractionAuditRecord(input.aiexDir, input.auditId, {
+			status: "failed",
+			error: result.error || "Extraction failed"
+		});
+		return new Response(JSON.stringify({
+			success: false,
+			error: record$1.error,
+			auditId: record$1.id
+		}), {
+			status: 500,
+			headers: { "content-type": "application/json" }
+		});
+	}
+	const notionPages = [];
+	if (input.syncNotion) try {
+		if (!result.data || typeof result.data !== "object" || Array.isArray(result.data)) throw new Error("Extraction result is not an object and cannot be written to Notion.");
+		notionPages.push(await writeNotionPage(aiConfig.notion, input.schemaName, result.data));
+	} catch (error) {
+		const record$1 = await updateExtractionAuditRecord(input.aiexDir, input.auditId, {
+			status: "failed",
+			outputPath: result.outputPath,
+			outputName: result.outputPath ? path.basename(result.outputPath) : void 0,
+			tablesInserted: result.tablesInserted,
+			tokensUsed: result.tokensUsed,
+			error: error instanceof Error ? error.message : String(error)
+		});
+		return new Response(JSON.stringify({
+			success: false,
+			error: record$1.error,
+			auditId: record$1.id
+		}), {
+			status: 500,
+			headers: { "content-type": "application/json" }
+		});
+	}
+	const record = await updateExtractionAuditRecord(input.aiexDir, input.auditId, {
+		status: "succeeded",
+		outputPath: result.outputPath,
+		outputName: result.outputPath ? path.basename(result.outputPath) : void 0,
+		tablesInserted: result.tablesInserted,
+		notionPages: notionPages.length > 0 ? notionPages : void 0,
+		tokensUsed: result.tokensUsed
+	});
+	return new Response(JSON.stringify({
+		success: true,
+		outputPath: record.outputPath,
+		outputName: record.outputName,
+		tablesInserted: record.tablesInserted,
+		notionPages: record.notionPages,
+		tokensUsed: record.tokensUsed,
+		auditId: record.id
+	}), {
+		status: 200,
+		headers: { "content-type": "application/json" }
+	});
+}
+function extractRoutes(config) {
+	const app = new Hono();
+	const aiexDir = path.dirname(config.schemaPath);
+	const uploadsDir = path.join(aiexDir, "uploads");
+	app.get("/extract/records", async (c) => {
+		return c.json(await listExtractionAuditRecords(aiexDir));
+	});
+	app.post("/extract", async (c) => {
+		try {
+			const body = await c.req.parseBody();
+			const schemaName = getFormString(body.schema);
+			const text$1 = getFormString(body.text);
+			const modelName = getFormString(body.model);
+			const syncNotion = getFormString(body.notion) === "true";
+			const file = getFormFile(body.file);
+			if (!schemaName) return c.json({
+				success: false,
+				error: "Schema is required"
+			}, 400);
+			if (!text$1 && !file) return c.json({
+				success: false,
+				error: "Provide text or upload a file to extract"
+			}, 400);
+			if (text$1 && file) return c.json({
+				success: false,
+				error: "Text and file input cannot be used together"
+			}, 400);
+			const audit = await createExtractionAuditRecord(aiexDir, {
+				schemaName,
+				modelName,
+				source: file ? {
+					type: "file",
+					fileName: safeUploadName(file.name)
+				} : {
+					type: "text",
+					text: text$1
+				}
+			});
+			let filePath;
+			if (file) {
+				filePath = await saveUploadToFile(file, uploadsDir, audit.id);
+				await updateExtractionAuditRecord(aiexDir, audit.id, { source: {
+					type: "file",
+					filePath,
+					fileName: safeUploadName(file.name)
+				} });
+			}
+			return executeAuditedExtraction({
+				aiexDir,
+				config,
+				auditId: audit.id,
+				schemaName,
+				text: text$1,
+				filePath,
+				modelName,
+				syncNotion
+			});
+		} catch (error) {
+			return c.json({
+				success: false,
+				error: error instanceof Error ? error.message : String(error)
+			}, 500);
+		}
+	});
+	app.post("/extract/records/:id/retry", async (c) => {
+		const original = await readExtractionAuditRecord(aiexDir, c.req.param("id"));
+		if (!original) return c.json({
+			success: false,
+			error: "Extraction record not found"
+		}, 404);
+		return executeAuditedExtraction({
+			aiexDir,
+			config,
+			auditId: (await createExtractionAuditRecord(aiexDir, {
+				schemaName: original.schemaName,
+				modelName: original.modelName,
+				source: original.source,
+				retryOf: original.id
+			})).id,
+			schemaName: original.schemaName,
+			text: original.source.type === "text" ? original.source.text ?? "" : "",
+			filePath: original.source.type === "file" ? original.source.filePath : void 0,
+			modelName: original.modelName
+		});
+	});
+	app.delete("/extract/records/:id", async (c) => {
+		const id = c.req.param("id");
+		if (!await readExtractionAuditRecord(aiexDir, id)) return c.json({
+			success: false,
+			error: "Extraction record not found"
+		}, 404);
+		await deleteExtractionAuditRecord(aiexDir, id);
+		return c.json({ success: true });
+	});
+	return app;
+}
+
 //#endregion
 //#region src/server/routes/schema.ts
 const schemaFileNameSchema = z.string().regex(/^[\w.-]+\.json$/).refine((name$1) => name$1 === path.basename(name$1) && !name$1.includes(".."));
@@ -14530,6 +15334,7 @@ function createApp(config, staticDir) {
 	app.use("*", cors({ origin: (origin) => LOCAL_ORIGIN_RE.test(origin) ? origin : null }));
 	app.route("/api", schemaRoutes(config));
 	app.route("/api", aiRoutes(config));
+	app.route("/api", extractRoutes(config));
 	app.route("/api", dataRoutes(config));
 	app.use("/*", serveStatic({
 		root: staticDir,