aiex-cli 0.0.1-beta.9 → 0.0.1

package/dist/cli.mjs

@@ -1,25 +1,40 @@
-import { C as doctorDiagnosticsTableRows, a as writeAIConfig, b as toSnakeCase, c as PLACEHOLDER_TEXT, d as seedConfig, f as description, g as createMigrationConfig, h as version, i as readAIConfig, l as AIConfigSchema, m as package_default, n as getDefaultAIConfig, o as DEFAULT_PROMPT_CONFIG, p as name, r as maskApiKey, s as PLACEHOLDER_SCHEMA, t as collectDoctorDiagnostics, u as createConfig, v as JsonSchemaDefinitionSchema, w as formatDoctorDiagnosticsJson, x as generateDrizzleSchema, y as parseJsonSchema } from "./doctor-BiU1lDp-.mjs";
+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 { 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 { readFile, writeFile } from "jsonfile";
+import { ZodError, z } from "zod";
 import { fileURLToPath } from "node:url";
-import { ZodError } from "zod";
-import fs from "node:fs/promises";
 import { defineCommand, runMain } from "citty";
 import { consola } from "consola";
 import updateNotifier from "update-notifier";
 import CliTable3 from "cli-table3";
-import { intro, outro, spinner } from "@clack/prompts";
-import Database from "better-sqlite3";
+import { intro, isCancel, outro, select, spinner, text } from "@clack/prompts";
 import pc from "picocolors";
 import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+import { LangfuseSpanProcessor } from "@langfuse/otel";
+import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
 import { APICallError, Output, generateText, jsonSchema } from "ai";
-import { exec, execFile } from "node:child_process";
+import mime from "mime";
+import pRetry from "p-retry";
+import { jsonrepair } from "jsonrepair";
+import fs$1 from "node:fs";
+import Database from "better-sqlite3";
+import { glob, globSync } from "tinyglobby";
+import { execa } from "execa";
+import { extractText, getDocumentProxy, getMeta } from "unpdf";
+import { Buffer } from "node:buffer";
+import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import { serve } from "@hono/node-server";
+import open from "open";
 import { serveStatic } from "@hono/node-server/serve-static";
 import { Hono } from "hono";
 import { cors } from "hono/cors";
+import { zValidator } from "@hono/zod-validator";
+import { Kysely, SqliteDialect, sql } from "kysely";
 
 //#region src/core/schema-sqlite/helpers.ts
 const __filename = fileURLToPath(import.meta.url);
@@ -96,7 +111,7 @@ function parseAllSchemas(entries) {
 }
 
 //#endregion
-//#region src/commands/completion.ts
+//#region src/core/completion-scripts.ts
 function bashScript(name$1) {
 	return `# ${name$1} bash completion
 _${name$1}() {
@@ -123,7 +138,7 @@ function fishScript(name$1) {
 complete -c ${name$1} -f -a '(${name$1} _complete (commandline -cp) 2>/dev/null)'
 `;
 }
-function generateScript(name$1, shell) {
+function generateCompletionScript(name$1, shell) {
 	switch (shell) {
 		case "bash": return bashScript(name$1);
 		case "zsh": return zshScript(name$1);
@@ -131,6 +146,9 @@ function generateScript(name$1, shell) {
 		default: throw new Error(`Unsupported shell: ${shell}. Use bash, zsh, or fish.`);
 	}
 }
+
+//#endregion
+//#region src/commands/completion.ts
 const completionCommand = defineCommand({
 	meta: {
 		name: "completion",
@@ -145,7 +163,7 @@ const completionCommand = defineCommand({
 		const name$1 = "aiex";
 		const shell = args.shell;
 		try {
-			process.stdout.write(generateScript(name$1, shell));
+			process.stdout.write(generateCompletionScript(name$1, shell));
 		} catch (error) {
 			process.stderr.write(`Error: ${error instanceof Error ? error.message : String(error)}\n`);
 			process.exit(1);
@@ -185,6 +203,14 @@ const doctorCommand = defineCommand({
 	}
 });
 
+//#endregion
+//#region src/commands/utils.ts
+function failCommand(message) {
+	if (message) consola.error(message);
+	outro("Failed!");
+	process.exitCode = 1;
+}
+
 //#endregion
 //#region src/core/ai-extraction/model-capabilities.json
 var model_capabilities_default = {
@@ -12727,26 +12753,26 @@ var model_capabilities_default = {
 
 //#endregion
 //#region src/core/ai-extraction/model-registry.ts
-const registry = model_capabilities_default;
+const registry$1 = model_capabilities_default;
 function normalize(name$1) {
 	return name$1.toLowerCase().replace(/[-_. ]/g, "");
 }
 const normalizedCache = /* @__PURE__ */ new Map();
 function buildNormalizedCache() {
 	if (normalizedCache.size > 0) return;
-	for (const key of Object.keys(registry)) {
+	for (const key of Object.keys(registry$1)) {
 		const nk = normalize(key);
 		if (!normalizedCache.has(nk)) normalizedCache.set(nk, key);
 	}
 }
 function lookupModel(name$1) {
-	const exact = registry[name$1];
+	const exact = registry$1[name$1];
 	if (exact) return { ...exact };
 	buildNormalizedCache();
 	const nk = normalize(name$1);
 	const matched = normalizedCache.get(nk);
 	if (matched) {
-		const entry = registry[matched];
+		const entry = registry$1[matched];
 		return entry ? { ...entry } : null;
 	}
 	return null;
@@ -12763,29 +12789,40 @@ function lookupModelCapabilities(modelName) {
 //#endregion
 //#region src/utils/retry.ts
 async function withRetry(fn, onRetry, maxRetries = 5) {
-	let lastError;
-	for (let attempt = 0; attempt <= maxRetries; attempt++) try {
-		return await fn();
-	} catch (error) {
-		const err = error instanceof Error ? error : new Error(String(error));
-		lastError = err;
-		if (!(err instanceof APICallError && err.isRetryable && attempt < maxRetries)) throw err;
-		const delayMs = 1e3 * 2 ** attempt + Math.round(Math.random() * 500);
-		onRetry?.({
-			attempt: attempt + 1,
-			maxRetries,
-			delayMs,
-			statusCode: err.statusCode
-		});
-		await new Promise((resolve) => setTimeout(resolve, delayMs));
-	}
-	throw lastError ?? /* @__PURE__ */ new Error("Retry failed after all attempts");
+	return pRetry(async () => fn(), {
+		retries: maxRetries,
+		factor: 2,
+		minTimeout: 1e3,
+		randomize: true,
+		onFailedAttempt({ error, attemptNumber, retriesLeft }) {
+			if (!(error instanceof APICallError) || !error.isRetryable || retriesLeft <= 0) return;
+			const baseDelayMs = 1e3 * 2 ** (attemptNumber - 1);
+			onRetry?.({
+				attempt: attemptNumber,
+				maxRetries,
+				delayMs: baseDelayMs,
+				statusCode: error.statusCode
+			});
+		},
+		shouldRetry({ error }) {
+			return error instanceof APICallError && error.isRetryable;
+		}
+	});
 }
 
 //#endregion
 //#region src/core/ai-extraction/json-utils.ts
-function stripFences(text) {
-	const trimmed = text.trim();
+function parseJsonLike(text$1) {
+	const trimmed = text$1.trim();
+	try {
+		return JSON.parse(trimmed);
+	} catch {
+		if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) throw new SyntaxError("JSON candidate must start with an object or array");
+		return JSON.parse(jsonrepair(trimmed));
+	}
+}
+function stripFences(text$1) {
+	const trimmed = text$1.trim();
 	if (!trimmed.startsWith("```")) return null;
 	const endIndex = trimmed.lastIndexOf("```");
 	if (endIndex <= 3) return null;
@@ -12794,8 +12831,8 @@ function stripFences(text) {
 	if (firstNewline === -1) return null;
 	return inside.slice(firstNewline + 1).trim();
 }
-function extractFirstJSON(text) {
-	const trimmed = text.trim();
+function extractFirstJSON(text$1) {
+	const trimmed = text$1.trim();
 	const firstBrace = trimmed.indexOf("{");
 	const firstBracket = trimmed.indexOf("[");
 	let start = -1;
@@ -12806,20 +12843,20 @@ function extractFirstJSON(text) {
 	if (end <= start) return null;
 	return trimmed.slice(start, end);
 }
-function safeParseJSON(text) {
-	const cleaned = text.trim();
+function safeParseJSON(text$1) {
+	const cleaned = text$1.trim();
 	try {
 		return JSON.parse(cleaned);
 	} catch {}
 	const fromFence = stripFences(cleaned);
 	if (fromFence) try {
-		return JSON.parse(fromFence);
+		return parseJsonLike(fromFence);
 	} catch {}
 	const extracted = extractFirstJSON(cleaned);
 	if (extracted) try {
-		return JSON.parse(extracted);
+		return parseJsonLike(extracted);
 	} catch {}
-	const truncated = text.length > 200 ? `${text.slice(0, 200)}...` : text;
+	const truncated = text$1.length > 200 ? `${text$1.slice(0, 200)}...` : text$1;
 	throw new Error(`Failed to parse JSON from model output. Expected a valid JSON object or array but received unparseable text. Raw output: ${truncated}`);
 }
 
@@ -12907,11 +12944,11 @@ function schemaToDescription(schema) {
 	}
 	return lines.join("\n");
 }
-function generateExtractionPrompt(schema, text, promptConfig = DEFAULT_PROMPT_CONFIG) {
+function generateExtractionPrompt(schema, text$1, promptConfig = DEFAULT_PROMPT_CONFIG) {
 	const schemaDescription = schemaToDescription(schema);
 	return {
 		system: promptConfig.systemTemplate.replaceAll(PLACEHOLDER_SCHEMA, schemaDescription),
-		user: promptConfig.userTemplate.replaceAll(PLACEHOLDER_TEXT, text)
+		user: promptConfig.userTemplate.replaceAll(PLACEHOLDER_TEXT, text$1)
 	};
 }
 function generatePromptSnapshot(schema, promptConfig = DEFAULT_PROMPT_CONFIG) {
@@ -12934,39 +12971,40 @@ function generatePromptSnapshot(schema, promptConfig = DEFAULT_PROMPT_CONFIG) {
 
 //#endregion
 //#region src/core/ai-extraction/extractor.ts
+let langfuseInitialized = false;
+function initLangfuse(config) {
+	if (!config.langfuse?.publicKey || !config.langfuse.secretKey) return;
+	if (langfuseInitialized) return;
+	langfuseInitialized = true;
+	try {
+		new NodeTracerProvider({ spanProcessors: [new LangfuseSpanProcessor({
+			publicKey: config.langfuse.publicKey,
+			secretKey: config.langfuse.secretKey,
+			baseUrl: config.langfuse.host || "https://us.cloud.langfuse.com",
+			exportMode: "immediate"
+		})] }).register();
+	} catch (e) {
+		console.warn("[Langfuse] Failed to initialize tracing:", e instanceof Error ? e.message : e);
+	}
+}
 const SYSTEM_PROMPT_REGEX = /## System Prompt\n([\s\S]*?)(?=## User Prompt|$)/;
 const USER_PROMPT_REGEX = /## User Prompt Template\n([\s\S]*)$/;
-const MIME_TYPES = {
-	png: "image/png",
-	jpg: "image/jpeg",
-	jpeg: "image/jpeg",
-	gif: "image/gif",
-	webp: "image/webp",
-	bmp: "image/bmp",
-	svg: "image/svg+xml",
-	pdf: "application/pdf",
-	txt: "text/plain",
-	csv: "text/csv",
-	json: "application/json",
-	md: "text/markdown",
-	html: "text/html"
-};
 function detectMimeType(filePath) {
-	return MIME_TYPES[path.extname(filePath).toLowerCase().replace(".", "")] || "application/octet-stream";
+	return mime.getType(filePath) ?? "application/octet-stream";
 }
 async function readFilePart(filePath) {
-	const mime = detectMimeType(filePath);
+	const mime$1 = detectMimeType(filePath);
 	const buffer = await fs.readFile(filePath);
 	const name$1 = path.basename(filePath);
-	if (mime.startsWith("image/")) return {
+	if (mime$1.startsWith("image/")) return {
 		type: "image",
 		image: buffer,
-		mimeType: mime
+		mimeType: mime$1
 	};
 	return {
 		type: "file",
 		data: buffer,
-		mediaType: mime,
+		mediaType: mime$1,
 		filename: name$1
 	};
 }
@@ -13078,25 +13116,35 @@ async function loadPromptSnapshot(aiexDir, tableName) {
 	return null;
 }
 async function extractStructuredData(input) {
-	const { config, schema, text, aiexDir, file, modelOverride } = input;
+	const { config, schema, text: text$1, aiexDir, file, modelOverride } = input;
 	if (!config.provider.apiKey) return {
 		success: false,
 		error: "API Key not configured. Please configure AI settings in the web UI."
 	};
 	const useFileContent = !!file;
 	const isImageFile = useFileContent && detectMimeType(file).startsWith("image/");
-	const inputTokens = text ? Math.ceil(text.length / 2) : void 0;
+	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;
-	const selected = modelOverride ?? selectModel({
-		models: config.provider.models,
-		isImage: isImageFile,
-		fileName: file,
-		inputTokens,
-		outputTokens
-	});
+	let selected;
+	try {
+		selected = modelOverride ?? selectModel({
+			models: config.provider.models,
+			isImage: isImageFile,
+			fileName: file,
+			inputTokens,
+			outputTokens
+		});
+	} catch (e) {
+		return {
+			success: false,
+			error: e.message
+		};
+	}
 	const useStructuredOutput = selected.capabilities.structuredOutput;
+	const useTelemetry = !!(config.langfuse?.publicKey && config.langfuse.secretKey);
 	try {
+		if (useTelemetry) initLangfuse(config);
 		const provider = createOpenAICompatible({
 			baseURL: config.provider.baseURL,
 			name: "qwen",
@@ -13105,7 +13153,7 @@ async function extractStructuredData(input) {
 		let system;
 		let user;
 		const snapshot = await loadPromptSnapshot(aiexDir, schema.table.name);
-		const promptText = file ? PLACEHOLDER_TEXT : text;
+		const promptText = file ? PLACEHOLDER_TEXT : text$1;
 		if (snapshot) {
 			system = snapshot.system;
 			user = snapshot.user.replaceAll(PLACEHOLDER_TEXT, promptText);
@@ -13116,12 +13164,13 @@ async function extractStructuredData(input) {
 		}
 		const outputSchema = jsonSchema(schemaToExtractionOutputSchema(schema));
 		let result;
+		const timeoutMs = (config.provider.timeout ?? 300) * 1e3;
 		if (useFileContent) {
 			const filePart = await readFilePart(file);
 			const fileName = filePart.type === "file" ? filePart.filename : path.basename(file);
 			const contentParts = [{
 				type: "text",
-				text: user.includes(PLACEHOLDER_TEXT) ? user.replaceAll(PLACEHOLDER_TEXT, text || `Data is contained in the attached file: ${fileName}`) : user
+				text: user.includes(PLACEHOLDER_TEXT) ? user.replaceAll(PLACEHOLDER_TEXT, text$1 || `Data is contained in the attached file: ${fileName}`) : user
 			}, filePart];
 			const fileOpts = {
 				model: provider.chatModel(selected.name),
@@ -13130,8 +13179,9 @@ async function extractStructuredData(input) {
 					role: "user",
 					content: contentParts
 				}],
-				abortSignal: AbortSignal.timeout(12e4),
-				maxRetries: 0
+				abortSignal: AbortSignal.timeout(timeoutMs),
+				maxRetries: 0,
+				experimental_telemetry: { isEnabled: useTelemetry }
 			};
 			if (useStructuredOutput) fileOpts.output = Output.object({ schema: outputSchema });
 			result = await withRetry(() => generateText(fileOpts), input.onRetry);
@@ -13140,8 +13190,9 @@ async function extractStructuredData(input) {
 				model: provider.chatModel(selected.name),
 				system,
 				prompt: user,
-				abortSignal: AbortSignal.timeout(6e4),
-				maxRetries: 0
+				abortSignal: AbortSignal.timeout(timeoutMs),
+				maxRetries: 0,
+				experimental_telemetry: { isEnabled: useTelemetry }
 			};
 			if (useStructuredOutput) textOpts.output = Output.object({ schema: outputSchema });
 			result = await withRetry(() => generateText(textOpts), input.onRetry);
@@ -13159,7 +13210,10 @@ async function extractStructuredData(input) {
 		const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
 		const outputFileName = `${schema.table.name}-${timestamp}.json`;
 		const outputPath = path.join(outputDir, outputFileName);
-		await fs.writeFile(outputPath, `${JSON.stringify(data, null, 2)}\n`);
+		await writeFile(outputPath, data, {
+			spaces: 2,
+			EOL: "\n"
+		});
 		return {
 			success: true,
 			outputPath,
@@ -13224,8 +13278,8 @@ function buildInsertSql(table, data) {
 function insertTableRow({ db, table, data, parentRowId, foreignKeyColumn }) {
 	const rowData = { ...data };
 	if (parentRowId !== void 0 && foreignKeyColumn) rowData[foreignKeyColumn] = parentRowId;
-	const { sql, values } = buildInsertSql(table, rowData);
-	const info = db.prepare(sql).run(...values);
+	const { sql: sql$1, values } = buildInsertSql(table, rowData);
+	const info = db.prepare(sql$1).run(...values);
 	return Number(info.lastInsertRowid);
 }
 function parseDataByColumns(data, schema, table) {
@@ -13328,7 +13382,171 @@ async function savePromptSnapshot(schema, aiexDir) {
 }
 
 //#endregion
-//#region src/commands/extract.ts
+//#region src/core/pdf-converter/external.ts
+function applyTemplate(value, context) {
+	return value.replaceAll("{input}", context.input).replaceAll("{outputDir}", context.outputDir).replaceAll("{basename}", context.basename);
+}
+function isError(error) {
+	return error instanceof Error;
+}
+async function pathExists(filePath) {
+	try {
+		await fs.access(filePath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function collectMarkdownFiles(dir) {
+	return (await glob("**/*.md", {
+		cwd: dir,
+		absolute: true,
+		onlyFiles: true
+	})).sort();
+}
+async function selectMarkdownFile(outputDir, basename) {
+	const files = await collectMarkdownFiles(outputDir);
+	if (files.length === 0) throw new Error(`External PDF converter did not produce a markdown file in ${outputDir}`);
+	const preferredName = `${basename}.md`.toLowerCase();
+	return files.find((file) => path.basename(file).toLowerCase() === preferredName) ?? files[0];
+}
+function formatCommandError(error, command$1) {
+	if (!isError(error)) return new Error(String(error));
+	const details = [`External PDF converter failed: ${command$1}`];
+	if ("exitCode" in error && typeof error.exitCode === "number") details.push(`exitCode=${error.exitCode}`);
+	if ("signal" in error && error.signal) details.push(`signal=${String(error.signal)}`);
+	if ("stderr" in error && typeof error.stderr === "string" && error.stderr.trim()) details.push(error.stderr.trim());
+	else if (error.message) details.push(error.message);
+	return new Error(details.join("\n"));
+}
+async function countPdfPages(input) {
+	try {
+		return (await getDocumentProxy(input)).numPages;
+	} catch {
+		return 0;
+	}
+}
+var ExternalCommandPdfConverter = class {
+	name;
+	constructor(name$1, config) {
+		this.config = config;
+		this.name = name$1;
+	}
+	async convert(input, filePath) {
+		const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "aiex-mineru-"));
+		const outputDir = path.join(tempRoot, "output");
+		await fs.mkdir(outputDir, { recursive: true });
+		const inputPath = filePath ?? path.join(tempRoot, "input.pdf");
+		if (!filePath) await fs.writeFile(inputPath, input);
+		const pageCount = await countPdfPages(input);
+		const basename = path.basename(inputPath, path.extname(inputPath));
+		const context = {
+			input: inputPath,
+			outputDir,
+			basename
+		};
+		const args = this.config.args.map((arg) => applyTemplate(arg, context));
+		const timeoutMs = (this.config.timeout ?? 600) * 1e3;
+		try {
+			await execa(this.config.command, args, {
+				shell: false,
+				timeout: timeoutMs,
+				maxBuffer: 1024 * 1024 * 20
+			});
+			const outputPath = this.config.outputFile ? applyTemplate(this.config.outputFile, context) : await selectMarkdownFile(outputDir, basename);
+			if (!await pathExists(outputPath)) throw new Error(`External PDF converter output was not found: ${outputPath}`);
+			return {
+				text: await fs.readFile(outputPath, "utf-8"),
+				pageCount,
+				metadata: {
+					converter: this.name,
+					outputPath,
+					...this.config.keepOutput ? { outputDir } : {}
+				}
+			};
+		} catch (error) {
+			throw formatCommandError(error, `${this.config.command} ${args.join(" ")}`);
+		} finally {
+			if (!this.config.keepOutput) await fs.rm(tempRoot, {
+				recursive: true,
+				force: true
+			}).catch(() => {});
+		}
+	}
+};
+
+//#endregion
+//#region src/core/pdf-converter/unpdf.ts
+var UnpdfConverter = class {
+	name = "unpdf";
+	async convert(input) {
+		const data = Buffer.isBuffer(input) ? new Uint8Array(input) : input;
+		const [textResult, meta] = await Promise.all([extractText(data, { mergePages: true }), getMeta(data).catch(() => null)]);
+		return {
+			text: textResult.text,
+			pageCount: textResult.totalPages,
+			metadata: {
+				converter: this.name,
+				...meta?.info ? Object.fromEntries(Object.entries(meta.info).map(([k, v]) => [k, String(v)])) : {}
+			}
+		};
+	}
+};
+
+//#endregion
+//#region src/core/pdf-converter/factory.ts
+const registry = /* @__PURE__ */ new Map();
+var FallbackPdfConverter = class {
+	name;
+	constructor(primary, fallback) {
+		this.primary = primary;
+		this.fallback = fallback;
+		this.name = primary.name;
+	}
+	async convert(input, filePath) {
+		try {
+			return await this.primary.convert(input, filePath);
+		} catch (err) {
+			consola.warn(`${this.primary.name} failed: ${err instanceof Error ? err.message : String(err)}`);
+			consola.info(`Falling back to ${this.fallback.name}`);
+			const result = await this.fallback.convert(input, filePath);
+			return {
+				...result,
+				metadata: {
+					...result.metadata,
+					fallback: "true"
+				}
+			};
+		}
+	}
+};
+function withFallback(converter, config) {
+	if (!config.fallbackToUnpdf) return converter;
+	return new FallbackPdfConverter(converter, new UnpdfConverter());
+}
+function createPdfConverter(config) {
+	if (typeof config === "object") {
+		if (config.converter === "mineru") {
+			const mineruConfig = config.mineru ?? DEFAULT_MINERU_CONFIG;
+			return withFallback(new ExternalCommandPdfConverter("mineru", mineruConfig), mineruConfig);
+		}
+		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);
+		}
+	}
+	const key = typeof config === "string" ? config : "unpdf";
+	let instance = registry.get(key);
+	if (!instance) {
+		if (key !== "unpdf") throw new Error(`PDF converter "${key}" requires configuration.`);
+		instance = new UnpdfConverter();
+		registry.set(key, instance);
+	}
+	return instance;
+}
+
+//#endregion
+//#region src/core/extract-runner.ts
 const FILE_PART_EXTENSIONS = new Set([
 	"png",
 	"jpg",
@@ -13338,11 +13556,21 @@ const FILE_PART_EXTENSIONS = new Set([
 	"bmp",
 	"svg"
 ]);
-function fail$1(message) {
-	if (message) consola.error(message);
-	outro("Failed!");
-	process.exitCode = 1;
-}
+const SUPPORTED_EXTENSIONS = new Set([
+	...FILE_PART_EXTENSIONS,
+	"pdf",
+	"txt",
+	"md",
+	"csv",
+	"json",
+	"html",
+	"xml",
+	"yaml",
+	"yml"
+]);
+const PDF_EXT_RE = /\.pdf$/i;
+const JSON_EXT_RE = /\.json$/;
+const SUPPORTED_FILE_PATTERN = `*.{${[...SUPPORTED_EXTENSIONS].join(",")}}`;
 async function ensureDatabaseReady(dbPath, schema) {
 	try {
 		await fs.access(dbPath);
@@ -13362,17 +13590,213 @@ async function ensureDatabaseReady(dbPath, schema) {
 	}
 	return null;
 }
+function listSupportedFiles(dir, pattern) {
+	if (!fs$1.statSync(dir).isDirectory()) throw new Error(`Not a directory: ${dir}`);
+	return globSync(pattern ?? SUPPORTED_FILE_PATTERN, {
+		cwd: dir,
+		absolute: true,
+		onlyFiles: true
+	}).filter((file) => {
+		const ext = path.extname(file).toLowerCase().replace(".", "");
+		return SUPPORTED_EXTENSIONS.has(ext);
+	}).sort();
+}
+async function loadSchema(config, schemaName) {
+	const schemaPath = path.join(config.schemaPath, `${schemaName}.json`);
+	try {
+		const parsed = await readFile(schemaPath);
+		return { schema: JsonSchemaDefinitionSchema.parse(parsed) };
+	} catch (e) {
+		if (e instanceof ZodError) return {
+			schema: null,
+			error: `Schema validation failed: ${schemaName}.json\n${e.issues.map((i) => `  - ${i.path.join(".")}: ${i.message}`).join("\n")}`
+		};
+		if (e.code === "ENOENT") return {
+			schema: null,
+			error: `Cannot read schema file: ${schemaName}.json`
+		};
+		if (e instanceof SyntaxError) return {
+			schema: null,
+			error: `Invalid JSON in schema file: ${schemaName}.json`
+		};
+		return {
+			schema: null,
+			error: String(e)
+		};
+	}
+}
+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();
+	} catch {
+		return [];
+	}
+}
+async function readExtractFileInput(filePath, aiConfig) {
+	const ext = path.extname(filePath).toLowerCase().replace(".", "");
+	if (FILE_PART_EXTENSIONS.has(ext)) return {
+		text: "",
+		filePath
+	};
+	if (ext === "pdf") {
+		const buffer = await fs.readFile(filePath);
+		const converter = createPdfConverter(aiConfig?.pdf);
+		const result = await converter.convert(buffer, filePath);
+		if (result.metadata?.fallback === "true") consola.info(`Fell back to unpdf — ${result.pageCount} page(s) extracted`);
+		else consola.info(`Converted PDF via ${converter.name}, ${result.pageCount} page(s)`);
+		const mdPath = filePath.replace(PDF_EXT_RE, ".md");
+		try {
+			await fs.writeFile(mdPath, result.text);
+			consola.info(`Markdown saved: ${mdPath}`);
+		} catch {
+			const fallbackMd = path.join(os.tmpdir(), `${path.basename(filePath, ".pdf")}.md`);
+			await fs.writeFile(fallbackMd, result.text);
+			consola.info(`Markdown saved: ${fallbackMd}`);
+		}
+		return { text: result.text };
+	}
+	return { text: await fs.readFile(filePath, "utf-8") };
+}
+async function extractSingle(aiexDir, config, aiConfig, schemaName, text$1, filePath, modelOverride, options) {
+	const schemaLoad = await loadSchema(config, schemaName);
+	if (!schemaLoad.schema) {
+		if (!options?.quiet) consola.error(schemaLoad.error);
+		return {
+			success: false,
+			error: schemaLoad.error
+		};
+	}
+	const s = spinner();
+	if (!options?.quiet) s.start(filePath ? `Extracting from ${path.basename(filePath)}...` : "Extracting data...");
+	const result = await extractStructuredData({
+		config: aiConfig,
+		schema: schemaLoad.schema,
+		text: text$1 ?? "",
+		aiexDir,
+		file: filePath,
+		modelOverride,
+		onRetry(info) {
+			if (!options?.quiet) s.message(`API responded with ${info.statusCode}, retrying in ${info.delayMs / 1e3}s (${info.attempt}/${info.maxRetries})...`);
+		}
+	});
+	if (!result.success) {
+		if (!options?.quiet) {
+			s.stop("Extraction failed");
+			consola.error(result.error || "Unknown error");
+		}
+		return {
+			success: false,
+			error: result.error || "Unknown error"
+		};
+	}
+	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) {
+		const s2 = spinner();
+		if (!options?.quiet) s2.start("Inserting into database...");
+		const dbError = await ensureDatabaseReady(config.databasePath, schemaLoad.schema);
+		if (dbError) {
+			if (!options?.quiet) s2.stop("Database not ready");
+			consola.error(dbError);
+			return {
+				success: false,
+				error: dbError
+			};
+		}
+		try {
+			const db = new Database(config.databasePath);
+			try {
+				const insertResult = insertExtractedData(db, schemaLoad.schema, result.data);
+				if (insertResult.success) {
+					if (!options?.quiet) s2.stop(`Inserted into ${insertResult.tablesInserted.length} table(s)`);
+				} else {
+					if (!options?.quiet) s2.stop("Database insert failed");
+					consola.error(insertResult.error || "Unknown error");
+					return {
+						success: false,
+						error: insertResult.error
+					};
+				}
+			} finally {
+				db.close();
+			}
+		} catch (e) {
+			if (!options?.quiet) s2.stop("Database insert failed");
+			consola.error(e instanceof Error ? e.message : String(e));
+			return {
+				success: false,
+				error: String(e)
+			};
+		}
+	}
+	return { success: true };
+}
+async function processOneFile(aiexDir, config, aiConfig, schemaName, filePath, modelOverride) {
+	try {
+		const input = await readExtractFileInput(filePath, aiConfig);
+		const r = await extractSingle(aiexDir, config, aiConfig, schemaName, input.text, input.filePath, modelOverride, { quiet: false });
+		if (r.success) {
+			consola.success(`Processed: ${path.basename(filePath)}`);
+			return true;
+		} else {
+			consola.error(`Failed: ${r.error}`);
+			return false;
+		}
+	} catch (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) {
+	consola.info(`Scanning ${pc.cyan(dir)} for supported files...`);
+	let files;
+	try {
+		files = listSupportedFiles(dir, globPattern);
+	} catch {
+		return {
+			ok: false,
+			successCount: 0,
+			failCount: 0,
+			error: `Cannot read directory: ${dir}`
+		};
+	}
+	if (files.length === 0) return {
+		ok: false,
+		successCount: 0,
+		failCount: 0,
+		error: `No supported files found in ${dir}`
+	};
+	consola.info(`Found ${files.length} file(s) to process`);
+	let successCount = 0;
+	let failCount = 0;
+	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++;
+		else failCount++;
+	}
+	consola.info(`\nBatch complete: ${pc.green(`${successCount} succeeded`)}, ${pc.red(`${failCount} failed`)}, ${files.length} total`);
+	return {
+		ok: true,
+		successCount,
+		failCount
+	};
+}
+
+//#endregion
+//#region src/commands/extract.ts
 const extractCommand = defineCommand({
 	meta: {
 		name: "extract",
-		description: "Extract structured data from text or image files"
+		description: "Extract structured data from text, images, or PDFs"
 	},
 	args: {
 		schema: {
 			type: "string",
 			alias: "s",
-			description: "Schema name (without .json extension)",
-			required: true
+			description: "Schema name (without .json extension)"
 		},
 		text: {
 			type: "string",
@@ -13382,43 +13806,47 @@ const extractCommand = defineCommand({
 		file: {
 			type: "string",
 			alias: "f",
-			description: "File path (image) to extract from"
+			description: "File path (image/PDF) to extract from"
 		},
 		model: {
 			type: "string",
 			alias: "m",
 			description: "AI model to use for extraction (overrides auto-selection)"
 		},
-		db: {
-			type: "boolean",
+		dir: {
+			type: "string",
 			alias: "d",
-			description: "Insert extracted data into SQLite database",
-			default: false
+			description: "Directory containing files to batch extract"
+		},
+		glob: {
+			type: "string",
+			alias: "g",
+			description: "Glob pattern to filter files in batch mode (e.g. \"*.pdf\")"
 		}
 	},
 	async run({ args }) {
 		intro(pc.inverse(" aiex extract "));
 		const config = createMigrationConfig(process.cwd());
 		const aiexDir = path.dirname(config.schemaPath);
-		if (!args.text && !args.file) {
-			fail$1("Please provide text (-t) or a file (-f) to extract from");
+		if (args.dir && args.text) {
+			failCommand("Cannot combine -t/--text with -d/--dir");
 			return;
 		}
-		if (args.text && args.file) {
-			fail$1("-t and -f cannot be used together");
+		if (args.dir && args.file) {
+			failCommand("Cannot combine -f/--file with -d/--dir");
 			return;
 		}
 		const aiConfig = await readAIConfig(aiexDir);
 		if (!aiConfig) {
-			fail$1("AI configuration not found. Please configure AI settings in the Web interface first");
+			failCommand("AI configuration not found. Please run \"aiex web\" to configure AI settings first");
 			return;
 		}
 		if (!aiConfig.provider.apiKey) {
-			fail$1("API Key not configured. Please configure AI settings in the Web interface first");
+			failCommand("API Key not configured. Please configure AI settings in the Web interface first");
 			return;
 		}
 		if (!aiConfig.provider.models?.length) {
-			fail$1("No models configured. Please add at least one model in AI Settings");
+			failCommand("No models configured. Please add at least one model in AI Settings");
 			return;
 		}
 		let modelOverride;
@@ -13426,130 +13854,212 @@ const extractCommand = defineCommand({
 			const matched = aiConfig.provider.models.find((m) => m.name === args.model);
 			if (!matched) {
 				const available = aiConfig.provider.models.map((m) => m.name).join(", ");
-				fail$1(`Model "${args.model}" not found in configuration. Available models: ${available}`);
+				failCommand(`Model "${args.model}" not found in configuration. Available models: ${available}`);
 				return;
 			}
 			modelOverride = matched;
 		}
-		let text = "";
-		let filePath;
-		if (args.file) {
-			const ext = path.extname(args.file).toLowerCase().replace(".", "");
-			if (FILE_PART_EXTENSIONS.has(ext)) filePath = args.file;
-			else text = await fs.readFile(args.file, "utf-8");
-		} else if (args.text) text = args.text;
-		const schemaName = args.schema;
-		const schemaPath = path.join(config.schemaPath, `${schemaName}.json`);
-		let schema;
-		try {
-			const content = await fs.readFile(schemaPath, "utf-8");
-			schema = JSON.parse(content);
-		} catch {
-			fail$1(`Cannot read schema file: ${schemaName}.json`);
+		if (!args.schema && !args.text && !args.file && !args.dir) {
+			if (await runInteractive(aiexDir, config, aiConfig, modelOverride)) outro("Done!");
 			return;
 		}
-		try {
-			schema = JsonSchemaDefinitionSchema.parse(schema);
-		} catch (e) {
-			if (e instanceof ZodError) {
-				consola.error(`Schema validation failed: ${schemaName}.json`);
-				for (const issue of e.issues) consola.error(`  - ${issue.path.join(".")}: ${issue.message}`);
+		if (args.dir) {
+			if (!args.schema) {
+				failCommand("Schema name (-s) is required in batch mode");
+				return;
+			}
+			const result = await runBatchExtraction(aiexDir, config, aiConfig, args.schema, args.dir, args.glob, modelOverride);
+			if (!result.ok) {
+				failCommand(result.error);
+				return;
 			}
-			fail$1();
+			if (result.failCount > 0) process.exitCode = 1;
+			if (result.failCount > 0) outro(`Completed with failures (${result.failCount} failed)`);
+			else outro("Done!");
 			return;
 		}
-		const s = spinner();
-		s.start(filePath ? "Extracting data from image..." : "Extracting data...");
-		const result = await extractStructuredData({
-			config: aiConfig,
-			schema,
-			text,
-			aiexDir,
-			file: filePath,
-			modelOverride,
-			onRetry(info) {
-				s.message(`API responded with ${info.statusCode}, retrying in ${info.delayMs / 1e3}s (${info.attempt}/${info.maxRetries})...`);
+		if (!args.schema) {
+			failCommand("Please provide a schema name (-s) to extract from");
+			return;
+		}
+		if (!args.text && !args.file) {
+			failCommand("Please provide text (-t) or a file (-f) to extract from");
+			return;
+		}
+		if (args.text && args.file) {
+			failCommand("-t and -f cannot be used together");
+			return;
+		}
+		let text$1 = "";
+		let filePath;
+		if (args.file) try {
+			const input = await readExtractFileInput(args.file, aiConfig);
+			text$1 = input.text;
+			filePath = input.filePath;
+		} catch (e) {
+			failCommand(`Cannot read file: ${args.file} — ${e instanceof Error ? e.message : String(e)}`);
+			return;
+		}
+		else if (args.text) text$1 = args.text;
+		if (!(await extractSingle(aiexDir, config, aiConfig, args.schema, text$1, filePath, modelOverride)).success) {
+			failCommand();
+			return;
+		}
+		outro("Done!");
+	}
+});
+async function runInteractive(aiexDir, config, aiConfig, modelOverride) {
+	const schemas = await listSchemas(aiexDir);
+	if (schemas.length === 0) {
+		failCommand(`No schema files found in ${pc.cyan(".aiex/schema/")}. Run ${pc.cyan("aiex web")} to create and configure schemas first.`);
+		return false;
+	}
+	const schemaName = await select({
+		message: "Select a schema to extract data for:",
+		options: schemas.map((s) => ({
+			label: s,
+			value: s
+		}))
+	});
+	if (isCancel(schemaName)) {
+		cancel("Cancelled");
+		return false;
+	}
+	const inputSource = await select({
+		message: "Choose input source:",
+		options: [
+			{
+				label: "Text content",
+				value: "text",
+				hint: "Paste or type text directly"
+			},
+			{
+				label: "Single file",
+				value: "file",
+				hint: "Extract from a file (txt, pdf, image)"
+			},
+			{
+				label: "Batch directory",
+				value: "dir",
+				hint: "Extract all supported files in a directory"
+			}
+		]
+	});
+	if (isCancel(inputSource)) {
+		cancel("Cancelled");
+		return false;
+	}
+	if (inputSource === "text") {
+		const textContent = await text({
+			message: "Enter text content to extract:",
+			validate(value) {
+				if (!value || value.trim().length === 0) return "Please enter some text";
 			}
 		});
-		if (!result.success) {
-			s.stop("Extraction failed");
-			fail$1(result.error || "Unknown error");
-			return;
+		if (isCancel(textContent)) {
+			cancel("Cancelled");
+			return false;
 		}
-		s.stop("Extraction complete");
-		if (result.outputPath) consola.success(`Result saved: ${pc.cyan(result.outputPath)}`);
-		if (result.tokensUsed) consola.info(pc.gray(`Token usage: prompt=${result.tokensUsed.prompt}, completion=${result.tokensUsed.completion}, total=${result.tokensUsed.total}`));
-		if (args.db && result.data) {
-			const s2 = spinner();
-			s2.start("Inserting into database...");
-			const dbError = await ensureDatabaseReady(config.databasePath, schema);
-			if (dbError) {
-				s2.stop("Database not ready");
-				fail$1(dbError);
-				return;
+		return (await extractSingle(aiexDir, config, aiConfig, schemaName, textContent, void 0, modelOverride)).success;
+	} else if (inputSource === "file") {
+		const filePathStr = await text({
+			message: "Enter file path:",
+			validate(value) {
+				if (!value || value.trim().length === 0) return "Please enter a file path";
 			}
-			try {
-				const db = new Database(config.databasePath);
-				try {
-					const insertResult = insertExtractedData(db, schema, result.data);
-					if (insertResult.success) s2.stop(`Inserted into ${insertResult.tablesInserted.length} table(s)`);
-					else {
-						s2.stop("Database insert failed");
-						fail$1(insertResult.error || "Unknown error");
-						return;
-					}
-				} finally {
-					db.close();
-				}
-			} catch (e) {
-				s2.stop("Database insert failed");
-				fail$1(e instanceof Error ? e.message : String(e));
-				return;
+		});
+		if (isCancel(filePathStr)) {
+			cancel("Cancelled");
+			return false;
+		}
+		const fp = filePathStr;
+		try {
+			const input = await readExtractFileInput(fp, aiConfig);
+			return (await extractSingle(aiexDir, config, aiConfig, schemaName, input.text, input.filePath, modelOverride)).success;
+		} catch (e) {
+			consola.error(`Cannot read file: ${fp} — ${e instanceof Error ? e.message : String(e)}`);
+			return false;
+		}
+	} else if (inputSource === "dir") {
+		const dirPath = await text({
+			message: "Enter directory path:",
+			validate(value) {
+				if (!value || value.trim().length === 0) return "Please enter a directory path";
 			}
+		});
+		if (isCancel(dirPath)) {
+			cancel("Cancelled");
+			return false;
 		}
-		outro("Done!");
+		const result = await runBatchExtraction(aiexDir, config, aiConfig, schemaName, dirPath, void 0, modelOverride);
+		if (!result.ok) failCommand(result.error);
+		return result.ok && result.failCount === 0;
 	}
-});
-
-//#endregion
-//#region schemas/table-schema.json
-var $id = "https://raw.githubusercontent.com/OSpoon/aiex-cli/main/app/cli/schemas/table-schema.json";
+	return false;
+}
+function cancel(msg) {
+	consola.info(msg);
+	outro("Cancelled");
+	process.exitCode = 0;
+}
 
 //#endregion
-//#region src/commands/schema.ts
-const execFileAsync$1 = promisify(execFile);
-function fail(message) {
-	if (message) consola.error(message);
-	outro("Failed!");
-	process.exitCode = 1;
-}
-async function writeJsonIfAbsent(filePath, data) {
+//#region src/core/schema-runner.ts
+const execFileAsync = promisify(execFile);
+async function listSchemaFiles(schemaDir) {
 	try {
-		await fs.writeFile(filePath, `${JSON.stringify(data, null, 2)}\n`, { flag: "wx" });
-		return "created";
-	} catch (error) {
-		if (error.code === "EEXIST") return "skipped";
-		throw error;
+		return (await fs.readdir(schemaDir)).filter((f) => f.endsWith(".json")).map((f) => path.join(schemaDir, f)).sort();
+	} catch {
+		return [];
 	}
 }
-async function generateFromFiles(schemaFiles, config) {
+async function generateSchemaFromFiles(schemaFiles, config) {
 	const result = parseAllSchemas(await Promise.all(schemaFiles.map(async (filePath) => {
 		return {
 			filePath,
 			content: await fs.readFile(filePath, "utf-8")
 		};
 	})));
-	if (!result.success) {
-		consola.error(result.error);
-		return false;
-	}
-	for (const warning of result.data.warnings) consola.warn(warning);
+	if (!result.success) return {
+		success: false,
+		error: result.error,
+		warnings: [],
+		schemaCount: schemaFiles.length,
+		tables: 0,
+		relations: 0
+	};
+	const { tables, relations, reverseRelations, warnings, drizzleCode } = result.data;
 	await fs.mkdir(path.dirname(config.drizzleSchemaPath), { recursive: true });
-	await fs.writeFile(config.drizzleSchemaPath, result.data.drizzleCode);
-	consola.success(`Generated ${pc.cyan(".aiex/drizzle/schema.ts")} from ${schemaFiles.length} schema file(s)`);
-	return true;
+	await fs.writeFile(config.drizzleSchemaPath, drizzleCode);
+	return {
+		success: true,
+		warnings,
+		schemaCount: schemaFiles.length,
+		tables: tables.length,
+		relations: relations.length + reverseRelations.length
+	};
 }
-async function migrate(config, migrationName) {
+function parseMigrationOutput(stdout, stderr) {
+	try {
+		const jsonLine = stdout.trim().split("\n").find((l) => l.startsWith("{") && l.endsWith("}"));
+		if (!jsonLine) return {
+			success: false,
+			error: "Migration helper did not return valid output"
+		};
+		const result = JSON.parse(jsonLine);
+		if (!result.success) return {
+			success: false,
+			error: result.error || "Migration failed"
+		};
+		return result;
+	} catch {
+		return {
+			success: false,
+			error: stderr || stdout || "Migration helper failed"
+		};
+	}
+}
+async function runSchemaMigration(config, migrationName) {
 	const helperPath = resolveHelperPath();
 	const helperArgs = [
 		resolveTsxPath(),
@@ -13560,40 +14070,62 @@ async function migrate(config, migrationName) {
 	];
 	if (migrationName) helperArgs.push(migrationName);
 	try {
-		const { stdout } = await execFileAsync$1(process.execPath, helperArgs, { cwd: process.cwd() });
-		const result = JSON.parse(stdout.trim());
-		if (!result.success) {
-			consola.error("Failed to generate migration");
-			consola.error(result.error);
-			return false;
-		}
-		if (result.changes === 0) {
-			consola.info(pc.gray("No changes detected"));
-			return true;
-		}
-		consola.success(pc.green("Migration files generated"));
-		consola.success(pc.green("Database migrated"));
-		return true;
+		const { stdout, stderr } = await execFileAsync(process.execPath, helperArgs, { cwd: process.cwd() });
+		return parseMigrationOutput(stdout, stderr);
 	} catch (error) {
-		consola.error("Failed to generate migration");
 		const execError = error;
-		if (execError.stderr) consola.error(execError.stderr);
-		else consola.error(execError.message || String(error));
-		return false;
+		return {
+			success: false,
+			error: execError.stderr || execError.stdout || execError.message || String(error)
+		};
 	}
 }
+async function runSchemaSync(config, options = {}) {
+	const schemaFiles = await listSchemaFiles(config.schemaPath);
+	if (schemaFiles.length === 0) return {
+		success: false,
+		error: "No schema files found",
+		warnings: [],
+		schemaCount: 0,
+		tables: 0,
+		relations: 0
+	};
+	const generated = await generateSchemaFromFiles(schemaFiles, config);
+	if (!generated.success) return {
+		success: false,
+		error: generated.error,
+		warnings: generated.warnings,
+		schemaCount: generated.schemaCount,
+		tables: generated.tables,
+		relations: generated.relations
+	};
+	if (options.generateOnly) return {
+		success: true,
+		warnings: generated.warnings,
+		schemaCount: generated.schemaCount,
+		tables: generated.tables,
+		relations: generated.relations
+	};
+	const migration = await runSchemaMigration(config, options.migrationName);
+	return {
+		success: migration.success,
+		error: migration.error,
+		warnings: generated.warnings,
+		schemaCount: generated.schemaCount,
+		tables: generated.tables,
+		relations: generated.relations,
+		migration
+	};
+}
+
+//#endregion
+//#region src/commands/schema.ts
 const schemaCommand = defineCommand({
 	meta: {
 		name: "schema",
 		description: "Sync JSON Schema to SQLite database"
 	},
 	args: {
-		init: {
-			type: "boolean",
-			alias: "i",
-			description: "Only initialize .aiex/ directory with example schema",
-			default: false
-		},
 		generate: {
 			type: "boolean",
 			alias: "g",
@@ -13608,226 +14140,21 @@ const schemaCommand = defineCommand({
 	async run({ args }) {
 		intro(pc.inverse(" aiex schema "));
 		const config = createMigrationConfig(process.cwd());
-		if (args.init) {
-			await fs.mkdir(config.schemaPath, { recursive: true });
-			await fs.mkdir(path.dirname(config.drizzleSchemaPath), { recursive: true });
-			await fs.mkdir(config.migrationsPath, { recursive: true });
-			const userSchema = {
-				$schema: $id,
-				title: "User",
-				type: "object",
-				table: {
-					name: "users",
-					timestamps: true,
-					softDelete: true
-				},
-				properties: {
-					id: {
-						type: "integer",
-						primary: true,
-						autoIncrement: true
-					},
-					email: {
-						type: "string",
-						format: "email",
-						unique: true
-					},
-					username: {
-						type: "string",
-						minLength: 3,
-						maxLength: 50,
-						unique: true
-					},
-					displayName: {
-						type: "string",
-						maxLength: 100
-					},
-					bio: {
-						type: "string",
-						maxLength: 500
-					},
-					avatarUrl: {
-						type: "string",
-						format: "uri"
-					},
-					role: {
-						type: "string",
-						default: "member"
-					},
-					isActive: {
-						type: "boolean",
-						default: true
-					},
-					lastLoginAt: {
-						type: "string",
-						format: "date-time"
-					},
-					profile: {
-						type: "object",
-						drizzle: { mode: "json" },
-						properties: {
-							website: { type: "string" },
-							location: { type: "string" },
-							socialLinks: {
-								type: "array",
-								items: {
-									type: "object",
-									properties: {
-										platform: { type: "string" },
-										url: { type: "string" }
-									}
-								}
-							}
-						}
-					},
-					preferences: {
-						type: "object",
-						nested: {
-							enabled: true,
-							relation: "has-one"
-						},
-						properties: {
-							theme: {
-								type: "string",
-								default: "light"
-							},
-							language: {
-								type: "string",
-								default: "en"
-							},
-							emailNotifications: {
-								type: "boolean",
-								default: true
-							},
-							pushNotifications: {
-								type: "boolean",
-								default: false
-							}
-						}
-					}
-				},
-				required: ["email", "username"]
-			};
-			const postSchema = {
-				$schema: $id,
-				title: "Post",
-				type: "object",
-				table: {
-					name: "posts",
-					timestamps: true,
-					softDelete: true
-				},
-				properties: {
-					id: {
-						type: "integer",
-						primary: true,
-						autoIncrement: true
-					},
-					title: {
-						type: "string",
-						minLength: 5,
-						maxLength: 200
-					},
-					slug: {
-						type: "string",
-						maxLength: 250,
-						unique: true
-					},
-					content: { type: "string" },
-					excerpt: {
-						type: "string",
-						maxLength: 300
-					},
-					authorId: { type: "integer" },
-					status: {
-						type: "string",
-						default: "draft"
-					},
-					viewCount: {
-						type: "integer",
-						default: 0,
-						minimum: 0
-					},
-					likeCount: {
-						type: "integer",
-						default: 0,
-						minimum: 0
-					},
-					publishedAt: {
-						type: "string",
-						format: "date-time"
-					},
-					tags: {
-						type: "array",
-						items: { type: "string" }
-					},
-					metadata: {
-						type: "object",
-						drizzle: { mode: "json" },
-						properties: {
-							featuredImage: { type: "string" },
-							readingTime: { type: "integer" },
-							seoTitle: { type: "string" },
-							seoDescription: { type: "string" }
-						}
-					},
-					comments: {
-						type: "array",
-						items: {
-							type: "object",
-							nested: {
-								enabled: true,
-								relation: "has-many"
-							},
-							properties: {
-								content: {
-									type: "string",
-									minLength: 1,
-									maxLength: 1e3
-								},
-								authorId: { type: "integer" },
-								status: {
-									type: "string",
-									default: "pending"
-								},
-								parentId: { type: "integer" }
-							}
-						}
-					}
-				},
-				required: [
-					"title",
-					"slug",
-					"authorId"
-				]
-			};
-			const userStatus = await writeJsonIfAbsent(path.join(config.schemaPath, "user.json"), userSchema);
-			const postStatus = await writeJsonIfAbsent(path.join(config.schemaPath, "post.json"), postSchema);
-			consola.success(`Initialized ${pc.cyan(".aiex/")} with example schemas`);
-			if (userStatus === "skipped") consola.warn(`${pc.cyan(".aiex/schema/user.json")} already exists, skipped`);
-			if (postStatus === "skipped") consola.warn(`${pc.cyan(".aiex/schema/post.json")} already exists, skipped`);
-			consola.info("Example includes: User (with preferences has-one), Post (with comments has-many)");
-			outro("Run: aiex schema");
-			return;
-		}
-		let schemaFiles;
-		try {
-			schemaFiles = await fs.readdir(config.schemaPath);
-			schemaFiles = schemaFiles.filter((f) => f.endsWith(".json")).map((f) => path.join(config.schemaPath, f));
-		} catch {
-			schemaFiles = [];
-		}
+		const schemaFiles = await listSchemaFiles(config.schemaPath);
 		if (schemaFiles.length === 0) {
-			consola.info("Use --init to initialize with an example schema");
-			fail(`No schema files found in ${pc.cyan(".aiex/schema/")}`);
+			consola.info(`Run ${pc.cyan("aiex web")} to create and configure schemas in the Web UI`);
+			failCommand(`No schema files found in ${pc.cyan(".aiex/schema/")}`);
 			return;
 		}
 		const s1 = spinner();
 		s1.start("Generating Drizzle schema...");
-		const genOk = await generateFromFiles(schemaFiles, config);
-		s1.stop(genOk ? "Schema generated" : "Generation failed");
-		if (!genOk) {
-			fail();
+		const generated = await generateSchemaFromFiles(schemaFiles, config);
+		for (const warning of generated.warnings) consola.warn(warning);
+		if (generated.success) consola.success(`Generated ${pc.cyan(".aiex/drizzle/schema.ts")} from ${generated.schemaCount} schema file(s)`);
+		else if (generated.error) consola.error(generated.error);
+		s1.stop(generated.success ? "Schema generated" : "Generation failed");
+		if (!generated.success) {
+			failCommand();
 			return;
 		}
 		if (args.generate) {
@@ -13836,10 +14163,18 @@ const schemaCommand = defineCommand({
 		}
 		const s2 = spinner();
 		s2.start("Running migrations...");
-		const migOk = await migrate(config, args.name);
-		s2.stop(migOk ? "Migrations applied" : "Migration failed");
-		if (!migOk) {
-			fail();
+		const migration = await runSchemaMigration(config, args.name);
+		if (!migration.success) {
+			consola.error("Failed to generate migration");
+			consola.error(migration.error || "Migration failed");
+		} else if (migration.changes === 0) consola.info(pc.gray("No changes detected"));
+		else {
+			consola.success(pc.green("Migration files generated"));
+			consola.success(pc.green("Database migrated"));
+		}
+		s2.stop(migration.success ? "Migrations applied" : "Migration failed");
+		if (!migration.success) {
+			failCommand();
 			return;
 		}
 		outro("Done!");
@@ -13863,13 +14198,7 @@ function aiRoutes(config) {
 				}
 			});
 		}
-		return c.json({
-			...aiConfig,
-			provider: {
-				...aiConfig.provider,
-				apiKey: maskApiKey(aiConfig.provider.apiKey)
-			}
-		});
+		return c.json(aiConfig);
 	});
 	app.post("/ai/registry-lookup", async (c) => {
 		try {
@@ -13897,11 +14226,6 @@ function aiRoutes(config) {
 				success: false,
 				error: "At least one model must be configured"
 			}, 400);
-			if (body.provider?.apiKey?.startsWith("sk-***")) {
-				const existing = await readAIConfig(aiexDir);
-				if (existing) body.provider.apiKey = existing.provider.apiKey;
-				else body.provider.apiKey = "";
-			}
 			await writeAIConfig(aiexDir, AIConfigSchema.parse(body));
 			return c.json({ success: true });
 		} catch (error) {
@@ -13917,10 +14241,25 @@ function aiRoutes(config) {
 //#endregion
 //#region src/server/routes/data.ts
 const FILE_REGEX = /\.json$/;
-const EXTRACTION_FILE_RE = /^[\w.-]+\.json$/;
-const TABLE_NAME_RE$1 = /^[a-z][a-z0-9_]*$/;
 const TIMESTAMP_CLEANUP = /(\d{2})-(\d{2})-(\d{2})/;
 const TIMESTAMP_TZ = /(\d{3})Z/;
+const tableParamSchema = z.object({ name: z.string().regex(/^[a-z][a-z0-9_]*$/) });
+const extractionFileParamSchema = z.object({ name: z.string().regex(/^[\w.-]+\.json$/).refine((name$1) => name$1 === path.basename(name$1) && !name$1.includes("..")) });
+const tableQuerySchema = z.object({
+	page: z.coerce.number().int().min(1).catch(1),
+	pageSize: z.coerce.number().int().min(1).max(500).catch(50),
+	search: z.string().catch(""),
+	sortField: z.string().optional(),
+	sortOrder: z.preprocess((value) => typeof value === "string" ? value.toLowerCase() : value, z.enum(["asc", "desc"]).catch("asc"))
+});
+function invalidParamResponse$1(message) {
+	return (result, c) => {
+		if (!result.success) return c.json({ error: message }, 400);
+	};
+}
+function createReadonlyQueryDb(databasePath) {
+	return new Kysely({ dialect: new SqliteDialect({ database: new Database(databasePath, { readonly: true }) }) });
+}
 function dataRoutes(config) {
 	const app = new Hono();
 	const aiexDir = path.dirname(config.schemaPath);
@@ -13968,15 +14307,19 @@ function dataRoutes(config) {
 			let db = null;
 			let dbTables = [];
 			try {
-				db = new Database(config.databasePath, { readonly: true });
-				dbTables = db.prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' AND name NOT LIKE '_%' ORDER BY name`).all().map((r) => r.name);
+				db = createReadonlyQueryDb(config.databasePath);
+				dbTables = (await sql`
+          select name
+          from sqlite_master
+          where type = 'table' and name not like 'sqlite_%' and name not like '_%'
+          order by name
+        `.execute(db)).rows.map((row) => row.name);
 			} catch {} finally {
-				db?.close();
+				await db?.destroy();
 			}
 			const tables = [];
 			for (const file of schemaFiles) try {
-				const content = await fs.readFile(path.join(schemaDir, file), "utf-8");
-				const schema = JSON.parse(content);
+				const schema = await readFile(path.join(schemaDir, file));
 				const tableName = schema.table?.name;
 				if (!tableName) continue;
 				tables.push({
@@ -13992,46 +14335,64 @@ function dataRoutes(config) {
 			return c.json({ error: error instanceof Error ? error.message : String(error) }, 500);
 		}
 	});
-	app.get("/data/tables/:name", async (c) => {
-		const tableName = c.req.param("name");
-		if (!TABLE_NAME_RE$1.test(tableName)) return c.json({ error: "Invalid table name" }, 400);
-		const sortField = c.req.query("sortField");
-		const sortOrder = c.req.query("sortOrder") || "asc";
+	app.get("/data/tables/:name", zValidator("param", tableParamSchema, invalidParamResponse$1("Invalid table name")), zValidator("query", tableQuerySchema), async (c) => {
+		const { name: tableName } = c.req.valid("param");
+		const { page, pageSize, search, sortField, sortOrder } = c.req.valid("query");
 		let db;
 		try {
-			db = new Database(config.databasePath, { readonly: true });
+			db = createReadonlyQueryDb(config.databasePath);
 		} catch {
 			return c.json({ error: "Database not found. Run `aiex schema` first." }, 400);
 		}
 		try {
-			if (!db.prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name=?`).get(tableName)) {
-				db.close();
-				return c.json({ error: `Table "${tableName}" not found in database` }, 404);
-			}
-			const columns = db.prepare(`PRAGMA table_info(\`${tableName}\`)`).all().map((col) => ({
+			if ((await sql`
+          select name
+          from sqlite_master
+          where type = 'table' and name = ${tableName}
+        `.execute(db)).rows.length === 0) return c.json({ error: `Table "${tableName}" not found in database` }, 404);
+			const columns = (await sql`
+          pragma table_info(${sql.table(tableName)})
+        `.execute(db)).rows.map((col) => ({
 				name: col.name,
 				type: col.type,
 				notNull: !!col.notnull,
 				pk: !!col.pk
 			}));
-			let orderClause = "";
-			if (sortField && columns.some((c$1) => c$1.name === sortField)) orderClause = ` ORDER BY \`${sortField}\` ${sortOrder.toLowerCase() === "desc" ? "DESC" : "ASC"}`;
-			const total = db.prepare(`SELECT COUNT(*) as count FROM \`${tableName}\``).get().count;
-			const rows = db.prepare(`SELECT * FROM \`${tableName}\`${orderClause} LIMIT 200`).all();
+			const searchConditions = columns.map((col) => sql`${sql.ref(col.name)} like ${`%${search}%`}`);
+			const searchCondition = search ? sql`where ${sql.join(searchConditions, sql` or `)}` : sql``;
+			const sortColumn = columns.find((col) => col.name === sortField);
+			const orderBy = sortColumn ? sql`order by ${sql.ref(sortColumn.name)} ${sql.raw(sortOrder === "desc" ? "desc" : "asc")}` : sql``;
+			const total = (await sql`
+          select count(*) as count
+          from ${sql.table(tableName)}
+          ${searchCondition}
+        `.execute(db)).rows[0]?.count ?? 0;
+			const offset = (page - 1) * pageSize;
+			const totalPages = Math.max(1, Math.ceil(total / pageSize));
+			const result = await sql`
+          select *
+          from ${sql.table(tableName)}
+          ${searchCondition}
+          ${orderBy}
+          limit ${pageSize}
+          offset ${offset}
+        `.execute(db);
 			return c.json({
 				columns,
-				rows,
-				total
+				rows: result.rows,
+				total,
+				page,
+				pageSize,
+				totalPages
 			});
 		} catch (error) {
 			return c.json({ error: error instanceof Error ? error.message : String(error) }, 500);
 		} finally {
-			db.close();
+			await db.destroy();
 		}
 	});
-	app.get("/data/:name", async (c) => {
-		const name$1 = c.req.param("name");
-		if (name$1 !== path.basename(name$1) || !EXTRACTION_FILE_RE.test(name$1) || name$1.includes("..")) return c.json({ error: "Invalid extraction file name" }, 400);
+	app.get("/data/:name", zValidator("param", extractionFileParamSchema, invalidParamResponse$1("Invalid extraction file name")), async (c) => {
+		const { name: name$1 } = c.req.valid("param");
 		const filePath = path.join(extractedDir, name$1);
 		try {
 			const content = await fs.readFile(filePath, "utf-8");
@@ -14049,12 +14410,13 @@ function dataRoutes(config) {
 
 //#endregion
 //#region src/server/routes/schema.ts
-const execFileAsync = promisify(execFile);
-const SCHEMA_FILE_RE = /^[\w.-]+\.json$/;
-const TABLE_NAME_RE = /^[a-z][a-z0-9_]*$/;
-function resolveSchemaFile(schemaDir, name$1) {
-	if (name$1 !== path.basename(name$1) || !SCHEMA_FILE_RE.test(name$1) || name$1.includes("..")) return null;
-	return path.join(schemaDir, name$1);
+const schemaFileNameSchema = z.string().regex(/^[\w.-]+\.json$/).refine((name$1) => name$1 === path.basename(name$1) && !name$1.includes(".."));
+const schemaFileParamSchema = z.object({ name: schemaFileNameSchema });
+const tableNameParamSchema = z.object({ name: z.string().regex(/^[a-z][a-z0-9_]*$/) });
+function invalidParamResponse(message) {
+	return (result, c) => {
+		if (!result.success) return c.json({ error: message }, 400);
+	};
 }
 function schemaRoutes(config) {
 	const app = new Hono();
@@ -14067,23 +14429,25 @@ function schemaRoutes(config) {
 		const jsonFiles = (await fs.readdir(schemaDir)).filter((f) => f.endsWith(".json"));
 		return c.json(jsonFiles);
 	});
-	app.get("/schema/:name", async (c) => {
-		const filePath = resolveSchemaFile(schemaDir, c.req.param("name"));
-		if (!filePath) return c.json({ error: "Invalid schema file name" }, 400);
+	app.get("/schema/:name", zValidator("param", schemaFileParamSchema, invalidParamResponse("Invalid schema file name")), async (c) => {
+		const { name: name$1 } = c.req.valid("param");
+		const filePath = path.join(schemaDir, name$1);
 		try {
-			const content = await fs.readFile(filePath, "utf-8");
-			return c.json(JSON.parse(content));
+			return c.json(await readFile(filePath));
 		} catch {
 			return c.json({ error: "Schema not found" }, 404);
 		}
 	});
-	app.post("/schema/:name", async (c) => {
-		const filePath = resolveSchemaFile(schemaDir, c.req.param("name"));
-		if (!filePath) return c.json({ error: "Invalid schema file name" }, 400);
+	app.post("/schema/:name", zValidator("param", schemaFileParamSchema, invalidParamResponse("Invalid schema file name")), async (c) => {
+		const { name: name$1 } = c.req.valid("param");
+		const filePath = path.join(schemaDir, name$1);
 		try {
 			const body = await c.req.json();
 			await ensureDir();
-			await fs.writeFile(filePath, `${JSON.stringify(body, null, 2)}\n`);
+			await writeFile(filePath, body, {
+				spaces: 2,
+				EOL: "\n"
+			});
 			const aiexDir = path.dirname(schemaDir);
 			try {
 				await savePromptSnapshot(JsonSchemaDefinitionSchema.parse(body), aiexDir);
@@ -14093,12 +14457,8 @@ function schemaRoutes(config) {
 			return c.json({ error: "Failed to save schema" }, 500);
 		}
 	});
-	app.get("/prompt-snapshot/:name", async (c) => {
-		const name$1 = c.req.param("name");
-		if (!TABLE_NAME_RE.test(name$1)) return c.json({
-			success: false,
-			error: "Invalid table name"
-		}, 400);
+	app.get("/prompt-snapshot/:name", zValidator("param", tableNameParamSchema, invalidParamResponse("Invalid table name")), async (c) => {
+		const { name: name$1 } = c.req.valid("param");
 		const aiexDir = path.dirname(schemaDir);
 		const snapshotPath = path.join(aiexDir, "extracted", `${name$1}.prompt.md`);
 		try {
@@ -14114,14 +14474,13 @@ function schemaRoutes(config) {
 			}, 404);
 		}
 	});
-	app.delete("/schema/:name", async (c) => {
-		const filePath = resolveSchemaFile(schemaDir, c.req.param("name"));
-		if (!filePath) return c.json({ error: "Invalid schema file name" }, 400);
+	app.delete("/schema/:name", zValidator("param", schemaFileParamSchema, invalidParamResponse("Invalid schema file name")), async (c) => {
+		const { name: name$1 } = c.req.valid("param");
+		const filePath = path.join(schemaDir, name$1);
 		try {
 			const aiexDir = path.dirname(schemaDir);
 			try {
-				const content = await fs.readFile(filePath, "utf-8");
-				const parsed = JsonSchemaDefinitionSchema.safeParse(JSON.parse(content));
+				const parsed = JsonSchemaDefinitionSchema.safeParse(await readFile(filePath));
 				if (parsed.success) {
 					const tableName = parsed.data.table.name;
 					const snapshotPath = path.join(aiexDir, "extracted", `${tableName}.prompt.md`);
@@ -14137,59 +14496,21 @@ function schemaRoutes(config) {
 	app.post("/migrate", async (c) => {
 		try {
 			await ensureDir();
-			await fs.mkdir(path.dirname(config.drizzleSchemaPath), { recursive: true });
-			const jsonFiles = (await fs.readdir(schemaDir)).filter((f) => f.endsWith(".json"));
-			if (jsonFiles.length === 0) return c.json({
-				success: false,
-				error: "No schema files found"
-			}, 400);
-			const parsedResult = parseAllSchemas(await Promise.all(jsonFiles.map(async (fileName) => {
-				const filePath = path.join(schemaDir, fileName);
-				return {
-					filePath,
-					content: await fs.readFile(filePath, "utf-8")
-				};
-			})));
-			if (!parsedResult.success) return c.json({
-				success: false,
-				error: parsedResult.error
-			}, 400);
-			const { tables, relations, reverseRelations, warnings, drizzleCode } = parsedResult.data;
-			await fs.writeFile(config.drizzleSchemaPath, drizzleCode);
-			const helperPath = resolveHelperPath();
-			const tsxPath = resolveTsxPath();
-			const { stdout, stderr } = await execFileAsync(process.execPath, [
-				tsxPath,
-				helperPath,
-				config.drizzleSchemaPath,
-				config.migrationsPath,
-				config.databasePath
-			], { cwd: process.cwd() });
-			let migrationResult;
-			try {
-				const jsonLine = stdout.trim().split("\n").find((l) => l.startsWith("{") && l.endsWith("}"));
-				if (!jsonLine) return c.json({
-					success: false,
-					error: "Migration helper did not return valid output"
-				}, 500);
-				migrationResult = JSON.parse(jsonLine);
-			} catch {
+			const result = await runSchemaSync(config);
+			if (!result.success) {
+				const status = result.schemaCount === 0 ? 400 : 500;
 				return c.json({
 					success: false,
-					error: stderr || stdout || "Migration helper failed"
-				}, 500);
+					error: result.error || "Migration failed"
+				}, status);
 			}
-			if (!migrationResult.success) return c.json({
-				success: false,
-				error: migrationResult.error || "Migration failed"
-			}, 500);
 			return c.json({
 				success: true,
-				changes: migrationResult.changes ?? 0,
-				tag: migrationResult.tag,
-				tables: tables.length,
-				relations: relations.length + reverseRelations.length,
-				warnings
+				changes: result.migration?.changes ?? 0,
+				tag: result.migration?.tag,
+				tables: result.tables,
+				relations: result.relations,
+				warnings: result.warnings
 			});
 		} catch (error) {
 			return c.json({
@@ -14237,9 +14558,36 @@ function createApp(config, staticDir) {
 	return app;
 }
 
+//#endregion
+//#region src/core/web-runner.ts
+function resolveWebStaticDir() {
+	return path.join(resolvePackageRoot(), "dist/web");
+}
+async function openBrowser(url) {
+	await open(url);
+}
+async function startWebServer(input) {
+	const { config, port } = input;
+	const staticDir = input.staticDir ?? resolveWebStaticDir();
+	const url = `http://localhost:${port}`;
+	serve({
+		fetch: createApp(config, staticDir).fetch,
+		port
+	}, () => {
+		input.onStarted?.({
+			url,
+			schemaPath: config.schemaPath
+		});
+		if (input.open === false) return;
+		openBrowser(url).catch(() => {
+			input.onOpenFailed?.(url);
+		});
+	});
+	await new Promise(() => {});
+}
+
 //#endregion
 //#region src/commands/web.ts
-const execAsync = promisify(exec);
 const webCommand = defineCommand({
 	meta: {
 		name: "web",
@@ -14256,23 +14604,20 @@ const webCommand = defineCommand({
 		const cwd = process.cwd();
 		const port = Number(args.port) || 13e3;
 		const config = createMigrationConfig(cwd);
-		const packageRoot = resolvePackageRoot();
-		const staticDir = path.join(packageRoot, "dist/web");
 		const s = spinner();
 		s.start("Starting web server...");
-		serve({
-			fetch: createApp(config, staticDir).fetch,
-			port
-		}, () => {
-			s.stop(`Server running at ${pc.cyan(`http://localhost:${port}`)}`);
-			consola.info(`Schema directory: ${pc.dim(config.schemaPath)}`);
-			consola.info("Press Ctrl+C to stop");
-			const url = `http://localhost:${port}`;
-			execAsync(`${process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open"} ${url}`).catch(() => {
+		await startWebServer({
+			config,
+			port,
+			onStarted(info) {
+				s.stop(`Server running at ${pc.cyan(info.url)}`);
+				consola.info(`Schema directory: ${pc.dim(info.schemaPath)}`);
+				consola.info("Press Ctrl+C to stop");
+			},
+			onOpenFailed(url) {
 				consola.warn(`Could not open browser. Visit ${url} manually.`);
-			});
+			}
 		});
-		await new Promise(() => {});
 	}
 });
 
@@ -14300,7 +14645,7 @@ process.on("unhandledRejection", (reason) => {
 	process.exit(1);
 });
 if (process.argv[2] === "_complete") {
-	const { getCompletions } = await import("./completions-ygS1okck.mjs");
+	const { getCompletions } = await import("./completions-C3rmTwXZ.mjs");
 	const suggestions = getCompletions(subCommands, process.argv.slice(3));
 	for (const s of suggestions) process.stdout.write(`${s}\n`);
 	process.exit(0);