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

package/dist/cli.mjs

@@ -1,12 +1,12 @@
-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-CjFTz8p4.mjs";
+import { C as package_default, D as formatDoctorDiagnosticsJson, E as doctorDiagnosticsTableRows, S as name, _ as PLACEHOLDER_TEXT, a as parseJsonSchema, b as seedConfig, c as recognizeImageText, d as readAIConfig, f as writeAIConfig, g as PLACEHOLDER_SCHEMA, h as DEFAULT_PROMPT_CONFIG, i as JsonSchemaDefinitionSchema, l as shouldUseImageOcrFallback, m as DEFAULT_MINERU_CONFIG, n as createMigrationConfig, o as toSnakeCase, p as DEFAULT_MARKITDOWN_CONFIG, s as generateDrizzleSchema, t as collectDoctorDiagnostics, u as getDefaultAIConfig, v as AIConfigSchema, w as version, x as description, y as createConfig } from "./doctor-collector-Cz7mb2L8.mjs";
 import { createRequire } from "node:module";
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import process from "node:process";
+import { fileURLToPath } from "node:url";
 import { readFile, writeFile } from "jsonfile";
 import { ZodError, z } from "zod";
-import { fileURLToPath } from "node:url";
 import { defineCommand, runMain } from "citty";
 import { consola } from "consola";
 import updateNotifier from "update-notifier";
@@ -13513,6 +13513,73 @@ async function deleteExtractionAuditRecord(aiexDir, id) {
 	return true;
 }
 
+//#endregion
+//#region src/core/file-constants.ts
+const MAX_UPLOAD_SIZE = 150 * 1024 * 1024;
+const MAX_UPLOAD_SIZE_TEXT = "150MB";
+const SUPPORTED_FILE_TYPES_TEXT = "images, PDF, text, markdown, CSV, JSON, HTML, XML, YAML";
+const MISSING_UPLOAD_FILE_TEXT = "Uploaded file is no longer available. Re-run extraction with the original file.";
+const SUPPORTED_MIME_TYPES = new Set([
+	"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",
+	"text/csv": "csv",
+	"application/json": "json",
+	"text/html": "html",
+	"text/xml": "xml",
+	"application/x-yaml": "yaml",
+	"text/yaml": "yaml"
+};
+function bytesToMB(bytes) {
+	return bytes / (1024 * 1024);
+}
+function getExtensionFromMime(mimeType) {
+	return MIME_TO_EXT[mimeType];
+}
+function isAllowedMimeType(mimeType) {
+	return SUPPORTED_MIME_TYPES.has(mimeType);
+}
+function unsupportedFileTypeMessage(mimeType) {
+	return `Unsupported file type "${mimeType}". Supported: ${SUPPORTED_FILE_TYPES_TEXT}.`;
+}
+function isMissingUploadFileError(error) {
+	return !!error && typeof error === "object" && error.code === "ENOENT";
+}
+var FileValidationError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "FileValidationError";
+	}
+};
+function validateFileUpload(file) {
+	if (file.size === 0) throw new FileValidationError("Uploaded file is empty");
+	if (file.size > MAX_UPLOAD_SIZE) throw new FileValidationError(`File size (${bytesToMB(file.size).toFixed(1)}MB) exceeds ${MAX_UPLOAD_SIZE_TEXT} limit`);
+	if (!isAllowedMimeType(file.type)) throw new FileValidationError(unsupportedFileTypeMessage(file.type));
+}
+
 //#endregion
 //#region src/core/notion-sink.ts
 const RICH_TEXT_LIMIT = 2e3;
@@ -14011,17 +14078,21 @@ async function listSchemas(aiexDir) {
 		return [];
 	}
 }
-function getFileSizeMB(filePath) {
-	return fs$1.statSync(filePath).size / (1024 * 1024);
-}
-async function readExtractFileInput(filePath, aiConfig) {
-	const sizeMB = getFileSizeMB(filePath);
-	if (sizeMB > 150) throw new Error(`File size (${sizeMB.toFixed(1)}MB) exceeds 150MB limit: ${filePath}`);
+async function readExtractFileInput(filePath, aiConfig, modelOverride) {
+	const stat = fs$1.statSync(filePath);
+	if (stat.size > MAX_UPLOAD_SIZE) throw new Error(`File size (${bytesToMB(stat.size).toFixed(1)}MB) exceeds ${MAX_UPLOAD_SIZE_TEXT} limit: ${filePath}`);
 	const ext = path.extname(filePath).toLowerCase().replace(".", "");
-	if (FILE_PART_EXTENSIONS.has(ext)) return {
-		text: "",
-		filePath
-	};
+	if (FILE_PART_EXTENSIONS.has(ext)) {
+		if (shouldUseImageOcrFallback(aiConfig, modelOverride)) {
+			const result = await recognizeImageText(filePath, aiConfig?.image);
+			consola.info(`Extracted image text via local OCR (confidence: ${(result.confidence * 100).toFixed(1)}%)`);
+			return { text: result.text };
+		}
+		return {
+			text: "",
+			filePath
+		};
+	}
 	if (ext === "pdf") {
 		const buffer = await fs.readFile(filePath);
 		const converter = createPdfConverter(aiConfig?.pdf);
@@ -14139,7 +14210,7 @@ async function processOneFile(aiexDir, config, aiConfig, schemaName, filePath, m
 		}
 	});
 	try {
-		const input = await readExtractFileInput(filePath, aiConfig);
+		const input = await readExtractFileInput(filePath, aiConfig, modelOverride);
 		const r = await extractSingle(aiexDir, config, aiConfig, schemaName, input.text, input.filePath, modelOverride, {
 			quiet: false,
 			insert: options?.insert
@@ -14412,6 +14483,10 @@ const retryCommand = defineCommand({
 			}
 			outro("Done!");
 		} catch (error) {
+			if (isMissingUploadFileError(error)) {
+				failCommand(MISSING_UPLOAD_FILE_TEXT);
+				return;
+			}
 			failCommand(error instanceof Error ? error.message : String(error));
 		}
 	}
@@ -14464,7 +14539,7 @@ const extractCommand = defineCommand({
 		file: {
 			type: "string",
 			alias: "f",
-			description: "File path (image/PDF) to extract from"
+			description: `File path to extract from. Supported: ${SUPPORTED_FILE_TYPES_TEXT}.`
 		},
 		model: {
 			type: "string",
@@ -14538,7 +14613,7 @@ const extractCommand = defineCommand({
 		let text$1 = "";
 		let filePath;
 		if (args.file) try {
-			const input = await readExtractFileInput(args.file, aiConfig);
+			const input = await readExtractFileInput(args.file, aiConfig, modelOverride);
 			text$1 = input.text;
 			filePath = input.filePath;
 		} catch (e) {
@@ -14647,7 +14722,7 @@ async function runInteractive(aiexDir, config, aiConfig, modelOverride) {
 		}
 		const fp = filePathStr;
 		try {
-			const input = await readExtractFileInput(fp, aiConfig);
+			const input = await readExtractFileInput(fp, aiConfig, modelOverride);
 			return runAuditedSingleExtraction({
 				aiexDir,
 				config,
@@ -15268,62 +15343,6 @@ function dataRoutes(config) {
 	return app;
 }
 
-//#endregion
-//#region src/core/file-constants.ts
-const MAX_UPLOAD_SIZE = 150 * 1024 * 1024;
-const MAX_UPLOAD_SIZE_TEXT = "150MB";
-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",
-	"text/csv": "csv",
-	"application/json": "json",
-	"text/html": "html",
-	"text/xml": "xml",
-	"application/x-yaml": "yaml",
-	"text/yaml": "yaml"
-};
-function getExtensionFromMime(mimeType) {
-	return MIME_TO_EXT[mimeType];
-}
-function isAllowedMimeType(mimeType) {
-	return SUPPORTED_MIME_TYPES.has(mimeType);
-}
-var FileValidationError = class extends Error {
-	constructor(message) {
-		super(message);
-		this.name = "FileValidationError";
-	}
-};
-function validateFileUpload(file) {
-	if (file.size === 0) throw new FileValidationError("Uploaded file is empty");
-	if (file.size > MAX_UPLOAD_SIZE) throw new FileValidationError(`File size (${(file.size / 1024 / 1024).toFixed(1)}MB) exceeds ${MAX_UPLOAD_SIZE_TEXT} limit`);
-	if (!isAllowedMimeType(file.type)) throw new FileValidationError(`Unsupported file type "${file.type}". Supported types: ${[...SUPPORTED_MIME_TYPES].join(", ")}`);
-}
-
 //#endregion
 //#region src/server/routes/extract.ts
 function getFormString(value) {
@@ -15340,9 +15359,26 @@ function safeUploadName(name$1) {
 function safeUploadNameForMime(file) {
 	const safeName = safeUploadName(file.name);
 	const ext = getExtensionFromMime(file.type);
-	if (!ext) throw new FileValidationError(`Unsupported file type "${file.type}"`);
+	if (!ext) throw new FileValidationError(unsupportedFileTypeMessage(file.type));
 	return `${path.parse(safeName).name || "upload"}.${ext}`;
 }
+function jsonResponse(body, status) {
+	return new Response(JSON.stringify(body), {
+		status,
+		headers: { "content-type": "application/json" }
+	});
+}
+async function auditFailureResponse(aiexDir, auditId, error, status) {
+	const record = await updateExtractionAuditRecord(aiexDir, auditId, {
+		status: "failed",
+		error
+	});
+	return jsonResponse({
+		success: false,
+		error: record.error,
+		auditId: record.id
+	}, status);
+}
 async function saveUploadToFile(file, uploadsDir, id) {
 	validateFileUpload(file);
 	await fs.mkdir(uploadsDir, { recursive: true });
@@ -15353,85 +15389,23 @@ async function saveUploadToFile(file, uploadsDir, id) {
 }
 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" }
-		});
-	}
+	if (!aiConfig) return auditFailureResponse(input.aiexDir, input.auditId, "AI configuration not found. Configure AI settings first.", 400);
+	if (!aiConfig.provider.apiKey) return auditFailureResponse(input.aiexDir, input.auditId, "API Key not configured. Configure AI settings first.", 400);
+	if (!aiConfig.provider.models?.length) return auditFailureResponse(input.aiexDir, input.auditId, "No models configured. Add at least one model in AI Settings.", 400);
 	const modelOverride = input.modelName ? aiConfig.provider.models.find((model) => model.name === input.modelName) : void 0;
-	if (input.modelName && !modelOverride) {
-		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" }
-		});
-	}
+	if (input.modelName && !modelOverride) return auditFailureResponse(input.aiexDir, input.auditId, `Model "${input.modelName}" not found in AI settings`, 400);
 	let inputText = input.text;
 	let inputFilePath = input.filePath;
-	if (input.filePath) {
+	if (input.filePath) try {
 		const source = await readExtractFileInput(input.filePath, aiConfig);
 		inputText = source.text;
 		inputFilePath = source.filePath;
+	} catch (error) {
+		if (isMissingUploadFileError(error)) return auditFailureResponse(input.aiexDir, input.auditId, MISSING_UPLOAD_FILE_TEXT, 400);
+		throw error;
 	}
 	const result = await extractSingle(input.aiexDir, input.config, aiConfig, input.schemaName, inputText, inputFilePath, modelOverride, { quiet: true });
-	if (!result.success) {
-		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" }
-		});
-	}
+	if (!result.success) return auditFailureResponse(input.aiexDir, input.auditId, result.error || "Extraction failed", 500);
 	const notionPages = [];
 	if (aiConfig.notion?.enabled && aiConfig.notion.schemas?.[input.schemaName]?.databaseId?.trim()) try {
 		if (!result.data || typeof result.data !== "object" || Array.isArray(result.data)) throw new Error("Extraction result is not an object and cannot be written to Notion.");
@@ -15445,14 +15419,11 @@ async function executeAuditedExtraction(input) {
 			tokensUsed: result.tokensUsed,
 			error: error instanceof Error ? error.message : String(error)
 		});
-		return new Response(JSON.stringify({
+		return jsonResponse({
 			success: false,
 			error: record$1.error,
 			auditId: record$1.id
-		}), {
-			status: 500,
-			headers: { "content-type": "application/json" }
-		});
+		}, 500);
 	}
 	const record = await updateExtractionAuditRecord(input.aiexDir, input.auditId, {
 		status: "succeeded",
@@ -15462,7 +15433,7 @@ async function executeAuditedExtraction(input) {
 		notionPages: notionPages.length > 0 ? notionPages : void 0,
 		tokensUsed: result.tokensUsed
 	});
-	return new Response(JSON.stringify({
+	return jsonResponse({
 		success: true,
 		outputPath: record.outputPath,
 		outputName: record.outputName,
@@ -15470,10 +15441,7 @@ async function executeAuditedExtraction(input) {
 		notionPages: record.notionPages,
 		tokensUsed: record.tokensUsed,
 		auditId: record.id
-	}), {
-		status: 200,
-		headers: { "content-type": "application/json" }
-	});
+	}, 200);
 }
 function extractRoutes(config) {
 	const app = new Hono();
@@ -15524,7 +15492,8 @@ function extractRoutes(config) {
 						});
 						return c.json({
 							success: false,
-							error: e.message
+							error: e.message,
+							auditId: audit.id
 						}, 400);
 					}
 					throw e;

package/dist/core/schema-sqlite/migrate-helper.mjs

@@ -2,8 +2,8 @@ import { createRequire } from "node:module";
 import fs from "node:fs/promises";
 import path from "node:path";
 import process from "node:process";
-import { readFile, writeFile } from "jsonfile";
 import { fileURLToPath } from "node:url";
+import { readFile, writeFile } from "jsonfile";
 import Database from "better-sqlite3";
 import * as esbuild from "esbuild";
 import lockfile from "proper-lockfile";

package/dist/{doctor-collector-CjFTz8p4.mjs → doctor-collector-Cz7mb2L8.mjs}

@@ -2,6 +2,7 @@ import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import process from "node:process";
+import { fileURLToPath } from "node:url";
 import Conf from "conf";
 import { readFile, writeFile } from "jsonfile";
 import { z } from "zod";
@@ -25,6 +26,7 @@ function buildDoctorDiagnostics(input) {
 			os: `${input.osType} ${input.osRelease}`,
 			cwd: input.cwd
 		},
+		imageOcr: { ...input.imageOcr },
 		config: {
 			path: input.configPath,
 			keys: [...input.configStoreKeys].sort()
@@ -56,6 +58,13 @@ function doctorDiagnosticsTableRows(d) {
 	rows.push(["aiModels", p.aiModelCount ? p.aiModels.join(", ") : "none"]);
 	rows.push(["aiProvider", p.aiProvider ?? "none"]);
 	rows.push(["aiConnectionOk", p.aiConnectionOk === null ? "not tested" : String(p.aiConnectionOk)]);
+	rows.push(["imageOcrPlatform", String(d.imageOcr.platformSupported)]);
+	rows.push(["imageOcrDependency", String(d.imageOcr.dependencyLoaded)]);
+	rows.push(["imageOcrOk", d.imageOcr.ocrOk === null ? "not tested" : String(d.imageOcr.ocrOk)]);
+	if (d.imageOcr.imagePath) rows.push(["imageOcrImage", d.imageOcr.imagePath]);
+	if (d.imageOcr.recognizedText) rows.push(["imageOcrText", d.imageOcr.recognizedText]);
+	if (typeof d.imageOcr.confidence === "number") rows.push(["imageOcrConfidence", `${(d.imageOcr.confidence * 100).toFixed(1)}%`]);
+	if (d.imageOcr.error) rows.push(["imageOcrError", d.imageOcr.error]);
 	rows.push(["hasDatabase", String(p.hasDatabase)]);
 	rows.push(["migrations", String(p.migrationCount)]);
 	for (const err of p.errors) rows.push(["error", err]);
@@ -65,7 +74,7 @@ function doctorDiagnosticsTableRows(d) {
 //#endregion
 //#region package.json
 var name = "aiex-cli";
-var version = "0.0.3-beta.1";
+var version = "0.0.3-beta.3";
 var description = "JSON Schema → SQLite with AI-powered data extraction";
 var package_default = {
 	name,
@@ -156,6 +165,7 @@ var package_default = {
 		"update-notifier": "catalog:",
 		"zod": "catalog:"
 	},
+	optionalDependencies: { "@napi-rs/system-ocr": "catalog:" },
 	devDependencies: {
 		"@antfu/eslint-config": "catalog:cli",
 		"@antfu/ni": "catalog:cli",
@@ -210,6 +220,15 @@ const PromptConfigSchema = z.object({
 	userTemplate: z.string().min(1)
 });
 const ExtractionConfigSchema = z.object({ outputDir: z.string().min(1) });
+const ImageOcrConfigSchema = z.object({
+	ocrFallback: z.enum([
+		"auto",
+		"off",
+		"local"
+	]).default("auto").optional(),
+	ocrLanguages: z.string().min(1).optional(),
+	ocrMinConfidence: z.number().min(0).max(1).optional()
+});
 const ExternalPdfConverterConfigSchema = z.object({
 	command: z.string().min(1),
 	args: z.array(z.string()),
@@ -248,6 +267,7 @@ const AIConfigSchema = z.object({
 	provider: AIProviderConfigSchema,
 	prompt: PromptConfigSchema,
 	extraction: ExtractionConfigSchema,
+	image: ImageOcrConfigSchema.optional(),
 	pdf: PdfConfigSchema.optional(),
 	langfuse: LangfuseConfigSchema.optional(),
 	notion: NotionConfigSchema.optional()
@@ -290,6 +310,11 @@ Extraction requirements:
 {text}`
 };
 const DEFAULT_EXTRACTION_CONFIG = { outputDir: ".aiex/extracted" };
+const DEFAULT_IMAGE_OCR_CONFIG = {
+	ocrFallback: "auto",
+	ocrLanguages: "en-US, zh-Hans",
+	ocrMinConfidence: 0
+};
 const DEFAULT_MINERU_CONFIG = {
 	command: "mineru",
 	args: [
@@ -323,6 +348,7 @@ const DEFAULT_AI_CONFIG = {
 	provider: DEFAULT_PROVIDER_CONFIG,
 	prompt: DEFAULT_PROMPT_CONFIG,
 	extraction: DEFAULT_EXTRACTION_CONFIG,
+	image: DEFAULT_IMAGE_OCR_CONFIG,
 	pdf: DEFAULT_PDF_CONFIG
 };
 
@@ -364,6 +390,111 @@ async function addToGitignore(aiexDir, fileName) {
 	}
 }
 
+//#endregion
+//#region src/core/image-ocr/index.ts
+const DEFAULT_OCR_LANGUAGES = "en-US, zh-Hans";
+const SELF_CHECK_EXPECTED_TEXT = "AIEX";
+const defaultRuntime = {
+	platform: process.platform,
+	async loadLocalOcr() {
+		return await import("@napi-rs/system-ocr");
+	}
+};
+function imageOcrMode(config) {
+	return config?.ocrFallback ?? "auto";
+}
+function hasVisionModel(aiConfig, modelOverride) {
+	if (modelOverride) return modelOverride.capabilities.vision;
+	return aiConfig?.provider.models.some((model) => model.capabilities.vision) ?? true;
+}
+function shouldUseImageOcrFallback(aiConfig, modelOverride, runtime = defaultRuntime) {
+	if (hasVisionModel(aiConfig, modelOverride)) return false;
+	const mode = imageOcrMode(aiConfig?.image);
+	if (mode === "off") return false;
+	if (mode === "local") return true;
+	return isLocalOcrPlatform(runtime.platform);
+}
+function isLocalOcrPlatform(platform) {
+	return platform === "darwin" || platform === "win32";
+}
+function parseOcrLanguages(languages) {
+	return (languages ?? DEFAULT_OCR_LANGUAGES).split(",").map((language) => language.trim()).filter(Boolean);
+}
+async function recognizeImageText(imagePath, config, runtime = defaultRuntime) {
+	const mode = imageOcrMode(config);
+	if (!isLocalOcrPlatform(runtime.platform)) throw new Error(`Local OCR is only available on macOS or Windows. Current platform: ${runtime.platform}.`);
+	if (mode === "off") throw new Error("Image OCR fallback is disabled in AI settings.");
+	let localOcr;
+	try {
+		localOcr = await runtime.loadLocalOcr();
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		throw new Error(`Local OCR is unavailable. Install optional dependency @napi-rs/system-ocr and approve its native build scripts. ${message}`);
+	}
+	const result = await localOcr.recognize(imagePath, localOcr.OcrAccuracy.Accurate, parseOcrLanguages(config?.ocrLanguages));
+	const text = result.text.trim();
+	if (!text) throw new Error("Local OCR did not recognize any text in the image.");
+	const confidence = result.confidence;
+	const minConfidence = config?.ocrMinConfidence ?? 0;
+	if (confidence < minConfidence) throw new Error(`Local OCR confidence ${(confidence * 100).toFixed(1)}% is below the configured minimum ${(minConfidence * 100).toFixed(1)}%.`);
+	return {
+		text,
+		confidence
+	};
+}
+function normalizeOcrText(text) {
+	return text.replace(/\s+/g, "").trim().toUpperCase();
+}
+async function checkImageOcrAvailability(imagePath, runtime = defaultRuntime) {
+	if (!isLocalOcrPlatform(runtime.platform)) return {
+		platformSupported: false,
+		dependencyLoaded: false,
+		ocrOk: null,
+		imagePath,
+		error: `Local OCR is only available on macOS or Windows. Current platform: ${runtime.platform}.`
+	};
+	let localOcr;
+	try {
+		localOcr = await runtime.loadLocalOcr();
+	} catch (error) {
+		return {
+			platformSupported: true,
+			dependencyLoaded: false,
+			ocrOk: null,
+			imagePath,
+			error: error instanceof Error ? error.message : String(error)
+		};
+	}
+	if (!imagePath) return {
+		platformSupported: true,
+		dependencyLoaded: true,
+		ocrOk: null,
+		error: "No OCR self-check image was found."
+	};
+	try {
+		const result = await localOcr.recognize(imagePath, localOcr.OcrAccuracy.Accurate, ["en-US"]);
+		const recognizedText = result.text.trim();
+		const ocrOk = normalizeOcrText(recognizedText).includes(SELF_CHECK_EXPECTED_TEXT);
+		return {
+			platformSupported: true,
+			dependencyLoaded: true,
+			ocrOk,
+			imagePath,
+			recognizedText,
+			confidence: result.confidence,
+			error: ocrOk ? void 0 : `Expected OCR text "${SELF_CHECK_EXPECTED_TEXT}" was not recognized.`
+		};
+	} catch (error) {
+		return {
+			platformSupported: true,
+			dependencyLoaded: true,
+			ocrOk: false,
+			imagePath,
+			error: error instanceof Error ? error.message : String(error)
+		};
+	}
+}
+
 //#endregion
 //#region src/core/schema-sqlite/generator.ts
 function generateColumnDefinition(column) {
@@ -715,6 +846,7 @@ function generateDrizzleConfig() {
 //#endregion
 //#region src/core/doctor-collector.ts
 const V1_SUFFIX_RE = /\/v1\/?$/;
+const MODULE_DIR = path.dirname(fileURLToPath(import.meta.url));
 async function checkConnection(baseURL) {
 	try {
 		const base = baseURL.replace(V1_SUFFIX_RE, "");
@@ -723,10 +855,26 @@ async function checkConnection(baseURL) {
 		return false;
 	}
 }
+async function findImageOcrSelfCheckLogo() {
+	const candidates = [
+		path.resolve(MODULE_DIR, "logo.png"),
+		path.resolve(MODULE_DIR, "assets/logo.png"),
+		path.resolve(MODULE_DIR, "../../assets/logo.png"),
+		path.resolve(MODULE_DIR, "../../../web/public/logo.png"),
+		path.resolve(MODULE_DIR, "../../web/public/logo.png"),
+		path.resolve(MODULE_DIR, "../../dist/web/logo.png"),
+		path.resolve(MODULE_DIR, "web/logo.png")
+	];
+	for (const candidate of candidates) try {
+		await fs.access(candidate);
+		return candidate;
+	} catch {}
+}
 async function collectDoctorDiagnostics(options = {}) {
 	const config = options.config ?? createConfig();
 	const cwd = process.cwd();
 	const errors = [];
+	const imageOcrLogoPath = await findImageOcrSelfCheckLogo();
 	const migConfig = createMigrationConfig(cwd);
 	const aiexDir = path.dirname(migConfig.schemaPath);
 	const dirExists = await fs.stat(aiexDir).then((s) => s.isDirectory()).catch(() => false);
@@ -778,6 +926,7 @@ async function collectDoctorDiagnostics(options = {}) {
 		osType: os.type(),
 		osRelease: os.release(),
 		cwd,
+		imageOcr: await checkImageOcrAvailability(imageOcrLogoPath),
 		configPath: config.path,
 		configStoreKeys: Object.keys(config.store),
 		project: {
@@ -799,4 +948,4 @@ async function collectDoctorDiagnostics(options = {}) {
 }
 
 //#endregion
-export { buildDoctorDiagnostics as C, version as S, formatDoctorDiagnosticsJson as T, createConfig as _, parseJsonSchema as a, name as b, getDefaultAIConfig as c, DEFAULT_MARKITDOWN_CONFIG as d, DEFAULT_MINERU_CONFIG as f, AIConfigSchema as g, PLACEHOLDER_TEXT as h, JsonSchemaDefinitionSchema as i, readAIConfig as l, PLACEHOLDER_SCHEMA as m, createMigrationConfig as n, toSnakeCase as o, DEFAULT_PROMPT_CONFIG as p, generateDrizzleConfig as r, generateDrizzleSchema as s, collectDoctorDiagnostics as t, writeAIConfig as u, seedConfig as v, doctorDiagnosticsTableRows as w, package_default as x, description as y };
+export { package_default as C, formatDoctorDiagnosticsJson as D, doctorDiagnosticsTableRows as E, name as S, buildDoctorDiagnostics as T, PLACEHOLDER_TEXT as _, parseJsonSchema as a, seedConfig as b, recognizeImageText as c, readAIConfig as d, writeAIConfig as f, PLACEHOLDER_SCHEMA as g, DEFAULT_PROMPT_CONFIG as h, JsonSchemaDefinitionSchema as i, shouldUseImageOcrFallback as l, DEFAULT_MINERU_CONFIG as m, createMigrationConfig as n, toSnakeCase as o, DEFAULT_MARKITDOWN_CONFIG as p, generateDrizzleConfig as r, generateDrizzleSchema as s, collectDoctorDiagnostics as t, getDefaultAIConfig as u, AIConfigSchema as v, version as w, description as x, createConfig as y };

package/dist/index.d.mts

@@ -19,6 +19,15 @@ interface DoctorDiagnostics {
     os: string;
     cwd: string;
   };
+  imageOcr: {
+    platformSupported: boolean;
+    dependencyLoaded: boolean;
+    ocrOk: boolean | null;
+    imagePath?: string;
+    recognizedText?: string;
+    confidence?: number;
+    error?: string;
+  };
   config: {
     path: string;
     keys: string[];
@@ -53,6 +62,7 @@ declare function buildDoctorDiagnostics(input: {
   osType: string;
   osRelease: string;
   cwd: string;
+  imageOcr: DoctorDiagnostics['imageOcr'];
   configPath: string;
   configStoreKeys: string[];
   project: DoctorDiagnostics['project'];

package/dist/index.mjs

@@ -1,3 +1,3 @@
-import { C as buildDoctorDiagnostics, T as formatDoctorDiagnosticsJson, a as parseJsonSchema, i as JsonSchemaDefinitionSchema, n as createMigrationConfig, r as generateDrizzleConfig, s as generateDrizzleSchema, t as collectDoctorDiagnostics, w as doctorDiagnosticsTableRows } from "./doctor-collector-CjFTz8p4.mjs";
+import { D as formatDoctorDiagnosticsJson, E as doctorDiagnosticsTableRows, T as buildDoctorDiagnostics, a as parseJsonSchema, i as JsonSchemaDefinitionSchema, n as createMigrationConfig, r as generateDrizzleConfig, s as generateDrizzleSchema, t as collectDoctorDiagnostics } from "./doctor-collector-Cz7mb2L8.mjs";
 
 export { JsonSchemaDefinitionSchema, buildDoctorDiagnostics, collectDoctorDiagnostics, createMigrationConfig, doctorDiagnosticsTableRows, formatDoctorDiagnosticsJson, generateDrizzleConfig, generateDrizzleSchema, parseJsonSchema };