aiex-cli 0.0.6-beta.1 → 0.0.6-beta.3

package/dist/cli.mjs

@@ -1,4 +1,4 @@
-import { A as doctorDiagnosticsTableRows, C as createConfig, D as package_default, E as name, O as version, S as AIConfigSchema, T as description, _ as DEFAULT_MINERU_API_CONFIG, a as parseJsonSchema, b as PLACEHOLDER_SCHEMA, c as recognizeImageText, d as t, f as getDefaultAIConfig, g as DEFAULT_MARKITDOWN_CONFIG, h as DEFAULT_MARKER_CONFIG, i as JsonSchemaDefinitionSchema, j as formatDoctorDiagnosticsJson, l as shouldUseImageOcrFallback, m as writeAIConfig, n as createMigrationConfig, o as toSnakeCase, p as readAIConfig, s as generateDrizzleSchema, t as collectDoctorDiagnostics, u as initI18n, v as DEFAULT_MINERU_CONFIG, w as seedConfig, x as PLACEHOLDER_TEXT, y as DEFAULT_PROMPT_CONFIG } from "./doctor-collector-hWEvJ4lw.mjs";
+import { C as description, E as version, O as doctorDiagnosticsTableRows, S as seedConfig, T as package_default, _ as DEFAULT_PROMPT_CONFIG, a as parseJsonSchema, b as AIConfigSchema, c as recognizeImageText, d as t, f as getDefaultAIConfig, g as DEFAULT_MINERU_CONFIG, h as DEFAULT_MINERU_API_CONFIG, i as JsonSchemaDefinitionSchema, k as formatDoctorDiagnosticsJson, l as shouldUseImageOcrFallback, m as writeAIConfig, n as createMigrationConfig, o as toSnakeCase, p as readAIConfig, s as generateDrizzleSchema, t as collectDoctorDiagnostics, u as initI18n, v as PLACEHOLDER_SCHEMA, w as name, x as createConfig, y as PLACEHOLDER_TEXT } from "./doctor-collector-abgpqc5T.mjs";
 import { createRequire } from "node:module";
 import fs from "node:fs/promises";
 import os from "node:os";
@@ -21,6 +21,8 @@ import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
 import { APICallError, Output, generateText, jsonSchema } from "ai";
 import pRetry from "p-retry";
 import mime from "mime";
+import { TextDecoder, promisify } from "node:util";
+import { fileTypeFromBuffer, fileTypeFromFile } from "file-type";
 import { jsonrepair } from "jsonrepair";
 import { LangfuseSpanProcessor } from "@langfuse/otel";
 import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
@@ -31,7 +33,6 @@ import { glob, globSync } from "tinyglobby";
 import { extractText, getDocumentProxy, getMeta } from "unpdf";
 import AdmZip from "adm-zip";
 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";
@@ -12859,13 +12860,65 @@ async function withRetry(fn, onRetry, maxRetries = 5) {
 	});
 }
 
+//#endregion
+//#region src/core/input-file-kind.ts
+const UTF8_DECODER = new TextDecoder("utf-8", { fatal: true });
+const SVG_START_RE = /^\s*<svg[\s>]/i;
+const SVG_ANY_RE = /<svg[\s>]/i;
+function isSupportedImageMime(mime$1) {
+	return !!mime$1 && [
+		"image/png",
+		"image/jpeg",
+		"image/webp"
+	].includes(mime$1);
+}
+function detectTextKind(buffer) {
+	try {
+		const text$1 = UTF8_DECODER.decode(buffer);
+		if (SVG_START_RE.test(text$1) || SVG_ANY_RE.test(text$1.slice(0, 4096))) return {
+			kind: "unsupported",
+			mime: "image/svg+xml"
+		};
+		return {
+			kind: "text",
+			mime: "text/plain"
+		};
+	} catch {
+		return { kind: "unsupported" };
+	}
+}
+async function detectInputFileKind(filePath) {
+	const detected = await fileTypeFromFile(filePath);
+	if (detected?.mime === "application/pdf") return {
+		kind: "pdf",
+		mime: detected.mime
+	};
+	if (isSupportedImageMime(detected?.mime)) return {
+		kind: "image",
+		mime: detected?.mime
+	};
+	return detectTextKind(await fs.readFile(filePath));
+}
+async function detectInputBufferKind(buffer) {
+	const detected = await fileTypeFromBuffer(buffer);
+	if (detected?.mime === "application/pdf") return {
+		kind: "pdf",
+		mime: detected.mime
+	};
+	if (isSupportedImageMime(detected?.mime)) return {
+		kind: "image",
+		mime: detected?.mime
+	};
+	return detectTextKind(buffer);
+}
+
 //#endregion
 //#region src/core/ai-extraction/file-utils.ts
-function detectMimeType(filePath) {
-	return mime.getType(filePath) ?? "application/octet-stream";
+async function detectMimeType(filePath) {
+	return (await detectInputFileKind(filePath)).mime ?? mime.getType(filePath) ?? "application/octet-stream";
 }
 async function readFilePart(filePath) {
-	const mimeStr = detectMimeType(filePath);
+	const mimeStr = await detectMimeType(filePath);
 	const buffer = await fs.readFile(filePath);
 	const name$1 = path.basename(filePath);
 	if (mimeStr.startsWith("image/")) return {
@@ -13205,14 +13258,48 @@ function validateExtractedData(schema, data) {
 //#endregion
 //#region src/core/ai-extraction/extractor.ts
 const OPENAI_COMPATIBLE_PROVIDER_NAME = "openai-compatible";
+function expectedExtractionFields(schema) {
+	return Object.entries(schema.properties).filter(([, prop]) => !(prop.primary && prop.autoIncrement)).map(([name$1]) => name$1);
+}
+function calculateMissingFields(schema, data) {
+	const expected = expectedExtractionFields(schema);
+	if (expected.length === 0) return {
+		fields: [],
+		rate: 0
+	};
+	if (!data || typeof data !== "object" || Array.isArray(data)) return {
+		fields: expected,
+		rate: 1
+	};
+	const record = data;
+	const fields = expected.filter((field) => {
+		const value = record[field];
+		return value === void 0 || value === null || value === "";
+	});
+	return {
+		fields,
+		rate: fields.length / expected.length
+	};
+}
 async function extractStructuredData(input) {
 	const { config, schema, text: text$1, aiexDir, file, modelOverride } = input;
+	let apiRetryCount = 0;
+	const onApiRetry = (info) => {
+		apiRetryCount += 1;
+		input.onRetry?.(info);
+	};
 	if (!config.provider.apiKey) return {
 		success: false,
-		error: t("errors.ai.apiKeyMissing")
+		error: t("errors.ai.apiKeyMissing"),
+		quality: { ai: {
+			validationPassed: false,
+			attempts: 0,
+			selfCorrectionCount: 0,
+			apiRetryCount
+		} }
 	};
 	const useFileContent = !!file;
-	const isImageFile = useFileContent && detectMimeType(file).startsWith("image/");
+	const isImageFile = (useFileContent ? await detectMimeType(file) : "").startsWith("image/");
 	const inputTokens = text$1 ? Math.ceil(text$1.length / 2) : void 0;
 	const fieldCount = schema.properties ? Object.keys(schema.properties).length : 0;
 	const outputTokens = fieldCount > 0 ? fieldCount * 80 : void 0;
@@ -13228,7 +13315,13 @@ async function extractStructuredData(input) {
 	} catch (e) {
 		return {
 			success: false,
-			error: e.message
+			error: e.message,
+			quality: { ai: {
+				validationPassed: false,
+				attempts: 0,
+				selfCorrectionCount: 0,
+				apiRetryCount
+			} }
 		};
 	}
 	const useStructuredOutput = selected.capabilities.structuredOutput;
@@ -13286,7 +13379,7 @@ async function extractStructuredData(input) {
 						experimental_telemetry: { isEnabled: useTelemetry }
 					};
 					if (useStructuredOutput) fileOpts.output = Output.object({ schema: outputSchema });
-					result = await withRetry(() => generateText(fileOpts), input.onRetry);
+					result = await withRetry(() => generateText(fileOpts), onApiRetry);
 				} else {
 					const textOpts = {
 						model: provider.chatModel(selected.name),
@@ -13297,7 +13390,7 @@ async function extractStructuredData(input) {
 						experimental_telemetry: { isEnabled: useTelemetry }
 					};
 					if (useStructuredOutput) textOpts.output = Output.object({ schema: outputSchema });
-					result = await withRetry(() => generateText(textOpts), input.onRetry);
+					result = await withRetry(() => generateText(textOpts), onApiRetry);
 				}
 				if (result.usage) {
 					totalPromptTokens += result.usage.inputTokens ?? 0;
@@ -13315,6 +13408,7 @@ async function extractStructuredData(input) {
 			if (!parseError && data !== void 0) {
 				const validation = validateExtractedData(schema, data);
 				if (validation.success) {
+					const missing = calculateMissingFields(schema, data);
 					const outputDir = path.resolve(aiexDir, config.extraction.outputDir.replace(".aiex/", ""));
 					await fs.mkdir(outputDir, { recursive: true });
 					const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
@@ -13332,7 +13426,15 @@ async function extractStructuredData(input) {
 							prompt: totalPromptTokens,
 							completion: totalCompletionTokens,
 							total: totalPromptTokens + totalCompletionTokens
-						}
+						},
+						quality: { ai: {
+							validationPassed: true,
+							attempts: attempt,
+							selfCorrectionCount: attempt - 1,
+							apiRetryCount,
+							missingFields: missing.fields,
+							missingFieldRate: missing.rate
+						} }
 					};
 				} else validationError = validation.error;
 			}
@@ -13365,12 +13467,26 @@ Please output the corrected JSON object now:`;
 		}
 		return {
 			success: false,
-			error: lastError || "Extraction failed after self-reflection retries"
+			error: lastError || "Extraction failed after self-reflection retries",
+			quality: { ai: {
+				validationPassed: false,
+				attempts: maxAttempts,
+				selfCorrectionCount: maxAttempts - 1,
+				apiRetryCount,
+				validationError: lastError
+			} }
 		};
 	} catch (error) {
 		return {
 			success: false,
-			error: getErrorMessage(error)
+			error: getErrorMessage(error),
+			quality: { ai: {
+				validationPassed: false,
+				attempts: 0,
+				selfCorrectionCount: 0,
+				apiRetryCount,
+				validationError: getErrorMessage(error)
+			} }
 		};
 	}
 }
@@ -13953,30 +14069,10 @@ 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 = t("errors.file.missingUpload");
-const SUPPORTED_MIME_TYPES = new Set([
-	"image/png",
-	"image/jpeg",
-	"image/gif",
-	"image/webp",
-	"image/bmp",
-	"image/svg+xml",
-	"application/pdf",
-	"text/plain",
-	"text/markdown",
-	"text/csv",
-	"application/json",
-	"text/html",
-	"text/xml",
-	"application/x-yaml",
-	"text/yaml"
-]);
 const MIME_TO_EXT = {
 	"image/png": "png",
 	"image/jpeg": "jpg",
-	"image/gif": "gif",
 	"image/webp": "webp",
-	"image/bmp": "bmp",
-	"image/svg+xml": "svg",
 	"application/pdf": "pdf",
 	"text/plain": "txt",
 	"text/markdown": "md",
@@ -13993,8 +14089,8 @@ function bytesToMB(bytes) {
 function getExtensionFromMime(mimeType) {
 	return MIME_TO_EXT[mimeType];
 }
-function isAllowedMimeType(mimeType) {
-	return SUPPORTED_MIME_TYPES.has(mimeType);
+function getExtensionForDetectedFile(mimeType) {
+	return mimeType ? getExtensionFromMime(mimeType) ?? "txt" : "txt";
 }
 function unsupportedFileTypeMessage(mimeType) {
 	return t("errors.file.unsupportedType", {
@@ -14011,14 +14107,16 @@ var FileValidationError = class extends Error {
 		this.name = "FileValidationError";
 	}
 };
-function validateFileUpload(file) {
+async function validateFileUploadContent(file, buffer) {
 	if (file.size === 0) throw new FileValidationError(t("errors.file.empty"));
 	if (file.size > MAX_UPLOAD_SIZE) throw new FileValidationError(t("errors.file.sizeExceeded", {
 		size: bytesToMB(file.size).toFixed(1),
 		limit: MAX_UPLOAD_SIZE_TEXT,
 		file: file.name
 	}));
-	if (!isAllowedMimeType(file.type)) throw new FileValidationError(unsupportedFileTypeMessage(file.type));
+	const detected = await detectInputBufferKind(buffer);
+	if (detected.kind === "unsupported") throw new FileValidationError(unsupportedFileTypeMessage(detected.mime ?? (file.type || "application/octet-stream")));
+	return detected.mime ?? "text/plain";
 }
 
 //#endregion
@@ -14280,14 +14378,6 @@ function createPdfConverter(config) {
 			return withFallback(new ExternalCommandPdfConverter("mineru", mineruConfig), mineruConfig);
 		}
 		if (config.converter === "mineru_api") return new MineruApiPdfConverter(config.mineruApi ?? DEFAULT_MINERU_API_CONFIG);
-		if (config.converter === "markitdown") {
-			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(t("errors.pdf.externalNotConfigured"));
 			return new ExternalCommandPdfConverter("external", config.external);
@@ -14309,12 +14399,32 @@ const FILE_PART_EXTENSIONS = new Set([
 	"png",
 	"jpg",
 	"jpeg",
-	"gif",
-	"webp",
-	"bmp",
-	"svg"
+	"webp"
 ]);
 const PDF_EXT_RE = /\.pdf$/i;
+async function describeExtractFileInput(filePath, aiConfig, modelOverride) {
+	const detected = await detectInputFileKind(filePath);
+	if (detected.kind === "image") return {
+		kind: "image",
+		mime: detected.mime,
+		handler: shouldUseImageOcrFallback(aiConfig, modelOverride) ? "image_local_ocr" : "image_vision"
+	};
+	if (detected.kind === "pdf") {
+		const converter = createPdfConverter(aiConfig?.pdf);
+		return {
+			kind: "pdf",
+			mime: detected.mime,
+			handler: "pdf_converter",
+			converter: converter.name
+		};
+	}
+	if (detected.kind === "text") return {
+		kind: "text",
+		mime: detected.mime,
+		handler: "text"
+	};
+	throw new Error(unsupportedFileTypeMessage(detected.mime ?? "application/octet-stream"));
+}
 async function readExtractFileInput(filePath, aiConfig, modelOverride) {
 	const stat = fs$1.statSync(filePath);
 	if (stat.size > MAX_UPLOAD_SIZE) throw new Error(t("errors.file.sizeExceeded", {
@@ -14322,19 +14432,34 @@ async function readExtractFileInput(filePath, aiConfig, modelOverride) {
 		limit: MAX_UPLOAD_SIZE_TEXT,
 		file: filePath
 	}));
-	const ext = path.extname(filePath).toLowerCase().replace(".", "");
-	if (FILE_PART_EXTENSIONS.has(ext)) {
-		if (shouldUseImageOcrFallback(aiConfig, modelOverride)) {
-			const result = await recognizeImageText(filePath, aiConfig?.image);
+	const inputProcessing = await describeExtractFileInput(filePath, aiConfig, modelOverride);
+	if (inputProcessing.kind === "image") {
+		if (inputProcessing.handler === "image_local_ocr") {
+			const result = await recognizeImageText(filePath);
 			consola.info(t("command.extract.file.ocrText", { confidence: (result.confidence * 100).toFixed(1) }));
-			return { text: result.text };
+			return {
+				text: result.text,
+				inputProcessing,
+				quality: { input: {
+					kind: "image",
+					textLength: result.text.length,
+					emptyText: result.text.trim().length === 0,
+					ocr: {
+						confidence: result.confidence,
+						textLength: result.text.length,
+						platform: process.platform
+					}
+				} }
+			};
 		}
 		return {
 			text: "",
-			filePath
+			filePath,
+			inputProcessing,
+			quality: { input: { kind: "image" } }
 		};
 	}
-	if (ext === "pdf") {
+	if (inputProcessing.kind === "pdf") {
 		const buffer = await fs.readFile(filePath);
 		const converter = createPdfConverter(aiConfig?.pdf);
 		const result = await converter.convert(buffer, filePath);
@@ -14352,9 +14477,37 @@ async function readExtractFileInput(filePath, aiConfig, modelOverride) {
 			await fs.writeFile(fallbackMd, result.text);
 			consola.info(t("command.extract.file.markdownSaved", { path: fallbackMd }));
 		}
-		return { text: result.text };
+		const textLength = result.text.length;
+		return {
+			text: result.text,
+			inputProcessing,
+			quality: { input: {
+				kind: "pdf",
+				textLength,
+				emptyText: result.text.trim().length === 0,
+				pdf: {
+					pageCount: result.pageCount,
+					textLength,
+					emptyText: result.text.trim().length === 0,
+					fallbackUsed: result.metadata?.fallback === "true",
+					converter: result.metadata?.converter ?? converter.name
+				}
+			} }
+		};
 	}
-	return { text: await fs.readFile(filePath, "utf-8") };
+	if (inputProcessing.kind === "text") {
+		const text$1 = await fs.readFile(filePath, "utf-8");
+		return {
+			text: text$1,
+			inputProcessing,
+			quality: { input: {
+				kind: "text",
+				textLength: text$1.length,
+				emptyText: text$1.trim().length === 0
+			} }
+		};
+	}
+	throw new Error(unsupportedFileTypeMessage(inputProcessing.mime ?? "application/octet-stream"));
 }
 
 //#endregion
@@ -14548,7 +14701,9 @@ async function extractSingle(aiexDir, config, aiConfig, schemaName, text$1, file
 		}
 		return {
 			success: false,
-			error: result.error || t("common.unknownError")
+			error: result.error || t("common.unknownError"),
+			quality: result.quality,
+			failureStage: "ai_extraction"
 		};
 	}
 	if (!options?.quiet) s.stop(t("command.extract.file.extractComplete"));
@@ -14567,7 +14722,9 @@ async function extractSingle(aiexDir, config, aiConfig, schemaName, text$1, file
 			consola.error(dbError);
 			return {
 				success: false,
-				error: dbError
+				error: dbError,
+				quality: result.quality,
+				failureStage: "db_insert"
 			};
 		}
 		try {
@@ -14581,14 +14738,17 @@ async function extractSingle(aiexDir, config, aiConfig, schemaName, text$1, file
 						outputPath: result.outputPath,
 						data: result.data,
 						tablesInserted: insertResult.tablesInserted,
-						tokensUsed: result.tokensUsed
+						tokensUsed: result.tokensUsed,
+						quality: result.quality
 					};
 				} else {
 					if (!options?.quiet) s2.stop(t("command.extract.file.dbInsertFail"));
 					consola.error(insertResult.error || t("common.unknownError"));
 					return {
 						success: false,
-						error: insertResult.error
+						error: insertResult.error,
+						quality: result.quality,
+						failureStage: "db_insert"
 					};
 				}
 			} finally {
@@ -14599,7 +14759,9 @@ async function extractSingle(aiexDir, config, aiConfig, schemaName, text$1, file
 			consola.error(e instanceof Error ? e.message : String(e));
 			return {
 				success: false,
-				error: String(e)
+				error: String(e),
+				quality: result.quality,
+				failureStage: "db_insert"
 			};
 		}
 	}
@@ -14607,9 +14769,29 @@ async function extractSingle(aiexDir, config, aiConfig, schemaName, text$1, file
 		success: true,
 		outputPath: result.outputPath,
 		data: result.data,
-		tokensUsed: result.tokensUsed
+		tokensUsed: result.tokensUsed,
+		quality: result.quality
 	};
 }
+function formatInputProcessing$1(input) {
+	const handler = input.converter ? `${input.handler}(${input.converter})` : input.handler;
+	return `${input.mime ?? input.kind} -> ${handler}`;
+}
+function mergeQuality(inputQuality, aiQuality) {
+	if (!inputQuality && !aiQuality) return void 0;
+	return {
+		input: inputQuality?.input,
+		ai: aiQuality?.ai
+	};
+}
+function classifyInputError(error, inputProcessing) {
+	if (inputProcessing?.handler === "pdf_converter") return "file_conversion";
+	if (inputProcessing?.handler === "image_local_ocr") return "ocr";
+	const message = (error instanceof Error ? error.message : String(error)).toLowerCase();
+	if (message.includes("ocr")) return "ocr";
+	if (message.includes("pdf") || message.includes("converter")) return "file_conversion";
+	return "input_detection";
+}
 async function runAuditedExtraction(options) {
 	const { aiexDir, config, aiConfig, schemaName, source, modelOverride, retryOf, insert, force, quiet = false } = options;
 	let fileHash;
@@ -14650,7 +14832,10 @@ async function runAuditedExtraction(options) {
 					outputName: existing.outputName,
 					tablesInserted: existing.tablesInserted,
 					notionPages: existing.notionPages,
-					tokensUsed: existing.tokensUsed
+					tokensUsed: existing.tokensUsed,
+					inputProcessing: existing.inputProcessing,
+					quality: existing.quality,
+					failureStage: existing.failureStage
 				};
 			}
 		}
@@ -14669,6 +14854,8 @@ async function runAuditedExtraction(options) {
 		},
 		retryOf
 	});
+	let inputProcessing;
+	let inputQuality;
 	try {
 		let text$1 = "";
 		let filePath;
@@ -14676,6 +14863,13 @@ async function runAuditedExtraction(options) {
 			const input = await readExtractFileInput(source.filePath, aiConfig, modelOverride);
 			text$1 = input.text;
 			filePath = input.filePath;
+			inputProcessing = input.inputProcessing;
+			inputQuality = input.quality;
+			if (!quiet) consola.info(`Input: ${formatInputProcessing$1(inputProcessing)}`);
+			await updateExtractionAuditRecord(aiexDir, audit.id, {
+				inputProcessing,
+				quality: inputQuality
+			});
 		} else text$1 = source.text;
 		const r = await extractSingle(aiexDir, config, aiConfig, schemaName, text$1, filePath, modelOverride, {
 			quiet,
@@ -14693,6 +14887,8 @@ async function runAuditedExtraction(options) {
 					outputName: r.outputPath ? path.basename(r.outputPath) : void 0,
 					tablesInserted: r.tablesInserted,
 					tokensUsed: r.tokensUsed,
+					quality: mergeQuality(inputQuality, r.quality),
+					failureStage: "integration",
 					error: error instanceof Error ? error.message : String(error)
 				});
 				if (!quiet) consola.error(t("command.extract.file.notionSyncFail", { error: error instanceof Error ? error.message : String(error) }));
@@ -14701,7 +14897,10 @@ async function runAuditedExtraction(options) {
 					success: false,
 					error: error instanceof Error ? error.message : String(error),
 					auditId: audit.id,
-					fileHash
+					fileHash,
+					inputProcessing,
+					quality: mergeQuality(inputQuality, r.quality),
+					failureStage: "integration"
 				};
 			}
 			const updated = await updateExtractionAuditRecord(aiexDir, audit.id, {
@@ -14710,7 +14909,8 @@ async function runAuditedExtraction(options) {
 				outputName: r.outputPath ? path.basename(r.outputPath) : void 0,
 				tablesInserted: r.tablesInserted,
 				notionPages,
-				tokensUsed: r.tokensUsed
+				tokensUsed: r.tokensUsed,
+				quality: mergeQuality(inputQuality, r.quality)
 			});
 			await triggerWebhook(aiConfig, audit.id, schemaName, "extraction.success", source, r.data, void 0, r.tokensUsed, quiet);
 			return {
@@ -14721,12 +14921,17 @@ async function runAuditedExtraction(options) {
 				notionPages: updated.notionPages,
 				tokensUsed: updated.tokensUsed,
 				auditId: updated.id,
-				fileHash
+				fileHash,
+				inputProcessing: updated.inputProcessing,
+				quality: updated.quality,
+				failureStage: updated.failureStage
 			};
 		} else {
 			await updateExtractionAuditRecord(aiexDir, audit.id, {
 				status: "failed",
-				error: r.error || "Extraction failed"
+				error: r.error || "Extraction failed",
+				quality: mergeQuality(inputQuality, r.quality),
+				failureStage: r.failureStage ?? "ai_extraction"
 			});
 			if (!quiet) consola.error(t("command.extract.file.extractionFailed", { error: r.error }));
 			await triggerWebhook(aiConfig, audit.id, schemaName, "extraction.failed", source, void 0, r.error || "Extraction failed", void 0, quiet);
@@ -14734,13 +14939,19 @@ async function runAuditedExtraction(options) {
 				success: false,
 				error: r.error,
 				auditId: audit.id,
-				fileHash
+				fileHash,
+				inputProcessing,
+				quality: mergeQuality(inputQuality, r.quality),
+				failureStage: r.failureStage ?? "ai_extraction"
 			};
 		}
 	} catch (e) {
+		const failureStage = classifyInputError(e, inputProcessing);
 		await updateExtractionAuditRecord(aiexDir, audit.id, {
 			status: "failed",
-			error: e instanceof Error ? e.message : String(e)
+			error: e instanceof Error ? e.message : String(e),
+			quality: inputQuality,
+			failureStage
 		});
 		if (!quiet) {
 			const name$1 = source.type === "file" ? path.basename(source.filePath) : "text input";
@@ -14754,7 +14965,10 @@ async function runAuditedExtraction(options) {
 			success: false,
 			error: e instanceof Error ? e.message : String(e),
 			auditId: audit.id,
-			fileHash
+			fileHash,
+			inputProcessing,
+			quality: inputQuality,
+			failureStage
 		};
 	}
 }
@@ -14938,6 +15152,18 @@ function isExtractSubCommand(rawArgs) {
 function formatSource(source) {
 	return source.type === "file" ? source.fileName || "file" : "unknown";
 }
+function formatInputProcessing(input) {
+	if (!input) return "";
+	const handler = input.converter ? `${input.handler}(${input.converter})` : input.handler;
+	return ` [${input.mime ?? input.kind} -> ${handler}]`;
+}
+function formatQuality(quality, failureStage) {
+	if (failureStage) return ` [failed:${failureStage}]`;
+	if (quality?.input?.pdf) return ` [pdf:${quality.input.pdf.pageCount}p/${quality.input.pdf.textLength}chars${quality.input.pdf.fallbackUsed ? "/fallback" : ""}]`;
+	if (quality?.input?.ocr) return ` [ocr:${Math.round(quality.input.ocr.confidence * 100)}%/${quality.input.ocr.textLength}chars]`;
+	if (quality?.ai?.missingFieldRate !== void 0) return ` [missing:${Math.round(quality.ai.missingFieldRate * 100)}%]`;
+	return "";
+}
 async function loadConfiguredAI(aiexDir) {
 	const aiConfig = await readAIConfig(aiexDir);
 	if (!aiConfig) {
@@ -14980,7 +15206,7 @@ const historyCommand = defineCommand({
 		}
 		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}`);
+			consola.info(`${record.status.padEnd(9)} ${record.id}  ${record.schemaName}  ${formatSource(record.source)}${formatInputProcessing(record.inputProcessing)}${formatQuality(record.quality, record.failureStage)}${suffix}`);
 		}
 	}
 });
@@ -15493,10 +15719,7 @@ const SUPPORTED_EXTENSIONS = new Set([
 	"png",
 	"jpg",
 	"jpeg",
-	"gif",
 	"webp",
-	"bmp",
-	"svg",
 	"pdf",
 	"txt",
 	"md",
@@ -15909,7 +16132,10 @@ async function listExtractions(config) {
 				modifiedAt: stat.mtime.toISOString(),
 				notionStatus: notionPages ? "synced" : audit?.status === "failed" ? "failed" : "not_synced",
 				notionPages,
-				notionError: !notionPages && audit?.status === "failed" ? audit.error : void 0
+				notionError: !notionPages && audit?.status === "failed" ? audit.error : void 0,
+				inputProcessing: audit?.inputProcessing,
+				quality: audit?.quality,
+				failureStage: audit?.failureStage
 			});
 		} catch {
 			continue;
@@ -16180,10 +16406,9 @@ function getFormFile(value) {
 function safeUploadName(name$1) {
 	return path.basename(name$1).replace(/[^\w.-]/g, "_") || "upload.txt";
 }
-function safeUploadNameForMime(file) {
+function safeUploadNameForMime(file, mimeType) {
 	const safeName = safeUploadName(file.name);
-	const ext = getExtensionFromMime(file.type);
-	if (!ext) throw new FileValidationError(unsupportedFileTypeMessage(file.type));
+	const ext = getExtensionForDetectedFile(mimeType);
 	return `${path.parse(safeName).name || "upload"}.${ext}`;
 }
 function jsonResponse(body, status) {
@@ -16193,10 +16418,10 @@ function jsonResponse(body, status) {
 	});
 }
 async function saveUploadToFile(file, uploadsDir, id) {
-	validateFileUpload(file);
-	await fs.mkdir(uploadsDir, { recursive: true });
-	const filePath = path.join(uploadsDir, `${id}-${safeUploadNameForMime(file)}`);
 	const buffer = Buffer.from(await file.arrayBuffer());
+	const mimeType = await validateFileUploadContent(file, buffer);
+	await fs.mkdir(uploadsDir, { recursive: true });
+	const filePath = path.join(uploadsDir, `${id}-${safeUploadNameForMime(file, mimeType)}`);
 	await fs.writeFile(filePath, buffer);
 	return filePath;
 }
@@ -16277,7 +16502,10 @@ function extractRoutes(config) {
 			if (!result.success) return jsonResponse({
 				success: false,
 				error: result.error,
-				auditId: result.auditId
+				auditId: result.auditId,
+				inputProcessing: result.inputProcessing,
+				quality: result.quality,
+				failureStage: result.failureStage
 			}, 500);
 			return jsonResponse({
 				success: true,
@@ -16286,7 +16514,10 @@ function extractRoutes(config) {
 				tablesInserted: result.tablesInserted,
 				notionPages: result.notionPages,
 				tokensUsed: result.tokensUsed,
-				auditId: result.auditId
+				auditId: result.auditId,
+				inputProcessing: result.inputProcessing,
+				quality: result.quality,
+				failureStage: result.failureStage
 			}, 200);
 		} catch (error) {
 			if (isMissingUploadFileError(error)) return c.json({
@@ -16344,7 +16575,10 @@ function extractRoutes(config) {
 		if (!result.success) return jsonResponse({
 			success: false,
 			error: result.error,
-			auditId: result.auditId
+			auditId: result.auditId,
+			inputProcessing: result.inputProcessing,
+			quality: result.quality,
+			failureStage: result.failureStage
 		}, 500);
 		return jsonResponse({
 			success: true,
@@ -16353,7 +16587,10 @@ function extractRoutes(config) {
 			tablesInserted: result.tablesInserted,
 			notionPages: result.notionPages,
 			tokensUsed: result.tokensUsed,
-			auditId: result.auditId
+			auditId: result.auditId,
+			inputProcessing: result.inputProcessing,
+			quality: result.quality,
+			failureStage: result.failureStage
 		}, 200);
 	});
 	app.delete("/extract/records/:id", async (c) => {