aiex-cli 0.0.1-beta.29 → 0.0.1-beta.30

package/README.md

@@ -21,7 +21,7 @@ npm install -g aiex-cli
 ```
 
 ```bash
-aiex schema --init                      # set up .aiex/schema/ directory
+aiex web                                # configure schemas and AI settings in the browser
 aiex schema                             # generate SQLite from JSON Schema files
 aiex extract -s invoice -f invoice.pdf  # extract data with AI and insert into database
 ```
@@ -41,17 +41,7 @@ aiex extract -s invoice -f invoice.pdf  # extract data with AI and insert into d
 
 ## 🚀 Getting Started
 
-### 1. Initialize
-
-```bash
-aiex schema --init
-```
-
-Creates a `.aiex/` directory with example schemas to get you started.
-
-Add your own JSON Schema files to `.aiex/schema/` (one file per table), then run `aiex schema` to migrate them into the database.
-
-### 2. Visual Editor
+### 1. Configure In Web UI
 
 ```bash
 aiex web
@@ -59,7 +49,7 @@ aiex web
 
 Opens a browser UI where you can visually design and manage your schemas, configure AI settings, preview extraction prompts, and apply changes to the database.
 
-### 3. Generate Database
+### 2. Generate Database
 
 ```bash
 aiex schema
@@ -67,7 +57,7 @@ aiex schema
 
 Converts your JSON Schema files into a SQLite database with full migration support.
 
-### 4. Extract Data
+### 3. Extract Data
 
 ```bash
 aiex extract                              # interactive mode (prompts for schema & input)
@@ -97,7 +87,6 @@ By default, aiex automatically selects a model based on your input type (vision-
 
 | Command | Description |
 | --- | --- |
-| `aiex schema --init` | Scaffold `.aiex/` directory with example schemas |
 | `aiex schema` | Parse JSON Schema files and migrate to SQLite |
 | `aiex schema --generate` | Generate Drizzle schema code only (skip migration) |
 | `aiex web` | Launch visual schema editor in browser |

package/dist/cli.mjs

@@ -1,10 +1,11 @@
-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-j2dG7dG1.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-DhiJrVw5.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 { ZodError } from "zod";
+import { readFile, writeFile } from "jsonfile";
+import { ZodError, z } from "zod";
 import { fileURLToPath } from "node:url";
 import { defineCommand, runMain } from "citty";
 import { consola } from "consola";
@@ -16,19 +17,23 @@ 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 mime from "mime";
 import pRetry from "p-retry";
+import { jsonrepair } from "jsonrepair";
 import fs$1 from "node:fs";
 import Database from "better-sqlite3";
-import picomatch from "picomatch";
+import { glob, globSync } from "tinyglobby";
 import { execa } from "execa";
 import { Buffer } from "node:buffer";
 import { extractText, getMeta } from "unpdf";
 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";
 
 //#region src/core/schema-sqlite/helpers.ts
 const __filename = fileURLToPath(import.meta.url);
@@ -12806,6 +12811,15 @@ async function withRetry(fn, onRetry, maxRetries = 5) {
 
 //#endregion
 //#region src/core/ai-extraction/json-utils.ts
+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;
@@ -12835,11 +12849,11 @@ function safeParseJSON(text$1) {
 	} 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$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}`);
@@ -12974,37 +12988,22 @@ function initLangfuse(config) {
 }
 const SYSTEM_PROMPT_REGEX = /## System Prompt\n([\s\S]*?)(?=## User Prompt|$)/;
 const USER_PROMPT_REGEX = /## User Prompt Template\n([\s\S]*)$/;
-const 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
 	};
 }
@@ -13210,7 +13209,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,
@@ -13395,17 +13397,11 @@ async function pathExists(filePath) {
 	}
 }
 async function collectMarkdownFiles(dir) {
-	const entries = await fs.readdir(dir, { withFileTypes: true });
-	const files = [];
-	for (const entry of entries) {
-		const entryPath = path.join(dir, entry.name);
-		if (entry.isDirectory()) {
-			files.push(...await collectMarkdownFiles(entryPath));
-			continue;
-		}
-		if (entry.isFile() && entry.name.toLowerCase().endsWith(".md")) files.push(entryPath);
-	}
-	return files.sort();
+	return (await glob("**/*.md", {
+		cwd: dir,
+		absolute: true,
+		onlyFiles: true
+	})).sort();
 }
 async function selectMarkdownFile(outputDir, basename) {
 	const files = await collectMarkdownFiles(outputDir);
@@ -13551,6 +13547,7 @@ const SUPPORTED_EXTENSIONS = new Set([
 	"yml"
 ]);
 const JSON_EXT_RE = /\.json$/;
+const SUPPORTED_FILE_PATTERN = `*.{${[...SUPPORTED_EXTENSIONS].join(",")}}`;
 async function ensureDatabaseReady(dbPath, schema) {
 	try {
 		await fs.access(dbPath);
@@ -13571,22 +13568,20 @@ async function ensureDatabaseReady(dbPath, schema) {
 	return null;
 }
 function listSupportedFiles(dir, pattern) {
-	const entries = fs$1.readdirSync(dir, { withFileTypes: true });
-	const files = [];
-	for (const entry of entries) {
-		if (entry.isDirectory()) continue;
-		const ext = path.extname(entry.name).toLowerCase().replace(".", "");
-		if (!SUPPORTED_EXTENSIONS.has(ext)) continue;
-		if (pattern && !picomatch.isMatch(entry.name, pattern)) continue;
-		files.push(path.join(dir, entry.name));
-	}
-	return files.sort();
+	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 content = await fs.readFile(schemaPath, "utf-8");
-		const parsed = JSON.parse(content);
+		const parsed = await readFile(schemaPath);
 		return { schema: JsonSchemaDefinitionSchema.parse(parsed) };
 	} catch (e) {
 		if (e instanceof ZodError) return {
@@ -13882,7 +13877,7 @@ const extractCommand = defineCommand({
 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 schema --init")} first, or add JSON Schema files.`);
+		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({
@@ -13974,131 +13969,9 @@ function cancel(msg) {
 	process.exitCode = 0;
 }
 
-//#endregion
-//#region schemas/table-schema.json
-var $id = "https://raw.githubusercontent.com/OSpoon/aiex-cli/main/app/cli/schemas/table-schema.json";
-
 //#endregion
 //#region src/core/schema-runner.ts
-const execFileAsync$1 = promisify(execFile);
-const EXAMPLE_SCORE_REPORT_SCHEMA = {
-	$schema: $id,
-	title: "ScoreReport",
-	type: "object",
-	table: {
-		name: "score_report",
-		timestamps: true
-	},
-	properties: {
-		name: {
-			type: "string",
-			description: "姓名"
-		},
-		reportNumber: {
-			type: "string",
-			description: "报告编号"
-		},
-		gender: {
-			type: "string",
-			description: "性别"
-		},
-		printDate: {
-			type: "string",
-			format: "date-time",
-			description: "打印日期"
-		},
-		examYear: {
-			type: "integer",
-			description: "考试年份"
-		},
-		examType: {
-			type: "string",
-			description: "考试类型，如全国统考"
-		},
-		examCategory: {
-			type: "string",
-			description: "考试类别，如普通高考"
-		},
-		province: {
-			type: "string",
-			description: "考试省份"
-		},
-		subjectCategory: {
-			type: "string",
-			description: "科类，如艺术（文）"
-		},
-		chinese: {
-			type: "integer",
-			description: "语文成绩"
-		},
-		chineseFull: {
-			type: "integer",
-			description: "语文满分"
-		},
-		math: {
-			type: "integer",
-			description: "数学成绩"
-		},
-		mathFull: {
-			type: "integer",
-			description: "数学满分"
-		},
-		foreignLang: {
-			type: "integer",
-			description: "外语成绩"
-		},
-		foreignLangFull: {
-			type: "integer",
-			description: "外语满分"
-		},
-		comprehensive: {
-			type: "integer",
-			description: "综合成绩"
-		},
-		comprehensiveFull: {
-			type: "integer",
-			description: "综合满分"
-		},
-		totalScore: {
-			type: "integer",
-			description: "总分"
-		},
-		totalFullScore: {
-			type: "integer",
-			description: "总分满分"
-		},
-		batchLineFirst: {
-			type: "integer",
-			description: "本科第一批录取分数线"
-		},
-		batchLineSecond: {
-			type: "integer",
-			description: "本科第二批录取分数线"
-		}
-	},
-	required: [
-		"name",
-		"examYear",
-		"examType",
-		"province",
-		"totalScore"
-	]
-};
-async function writeJsonIfAbsent(filePath, data) {
-	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;
-	}
-}
-async function initSchemaProject(config) {
-	await fs.mkdir(config.schemaPath, { recursive: true });
-	await fs.mkdir(path.dirname(config.drizzleSchemaPath), { recursive: true });
-	await fs.mkdir(config.migrationsPath, { recursive: true });
-	return { scoreReportStatus: await writeJsonIfAbsent(path.join(config.schemaPath, "score_report.json"), EXAMPLE_SCORE_REPORT_SCHEMA) };
-}
+const execFileAsync = promisify(execFile);
 async function listSchemaFiles(schemaDir) {
 	try {
 		return (await fs.readdir(schemaDir)).filter((f) => f.endsWith(".json")).map((f) => path.join(schemaDir, f)).sort();
@@ -14163,7 +14036,7 @@ async function runSchemaMigration(config, migrationName) {
 	];
 	if (migrationName) helperArgs.push(migrationName);
 	try {
-		const { stdout, stderr } = await execFileAsync$1(process.execPath, helperArgs, { cwd: process.cwd() });
+		const { stdout, stderr } = await execFileAsync(process.execPath, helperArgs, { cwd: process.cwd() });
 		return parseMigrationOutput(stdout, stderr);
 	} catch (error) {
 		const execError = error;
@@ -14219,12 +14092,6 @@ const schemaCommand = defineCommand({
 		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",
@@ -14239,17 +14106,9 @@ const schemaCommand = defineCommand({
 	async run({ args }) {
 		intro(pc.inverse(" aiex schema "));
 		const config = createMigrationConfig(process.cwd());
-		if (args.init) {
-			const initResult = await initSchemaProject(config);
-			consola.success(`Initialized ${pc.cyan(".aiex/")} with example schemas`);
-			if (initResult.scoreReportStatus === "skipped") consola.warn(`${pc.cyan(".aiex/schema/score_report.json")} already exists, skipped`);
-			consola.info("Example includes: ScoreReport (college entrance exam score report)");
-			outro("Run: aiex schema");
-			return;
-		}
 		const schemaFiles = await listSchemaFiles(config.schemaPath);
 		if (schemaFiles.length === 0) {
-			consola.info("Use --init to initialize with an example 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;
 		}
@@ -14348,10 +14207,22 @@ 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 dataRoutes(config) {
 	const app = new Hono();
 	const aiexDir = path.dirname(config.schemaPath);
@@ -14406,8 +14277,7 @@ function dataRoutes(config) {
 			}
 			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({
@@ -14423,14 +14293,9 @@ 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";
-		const page = Math.max(1, Number.parseInt(c.req.query("page") || "1", 10) || 1);
-		const pageSize = Math.min(500, Math.max(1, Number.parseInt(c.req.query("pageSize") || "50", 10) || 50));
-		const search = c.req.query("search") || "";
+	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 });
@@ -14449,7 +14314,7 @@ function dataRoutes(config) {
 				pk: !!col.pk
 			}));
 			let orderClause = "";
-			if (sortField && columns.some((c$1) => c$1.name === sortField)) orderClause = ` ORDER BY \`${sortField}\` ${sortOrder.toLowerCase() === "desc" ? "DESC" : "ASC"}`;
+			if (sortField && columns.some((c$1) => c$1.name === sortField)) orderClause = ` ORDER BY \`${sortField}\` ${sortOrder === "desc" ? "DESC" : "ASC"}`;
 			let whereClause = "";
 			const queryParams = [];
 			if (search) whereClause = ` WHERE ${columns.map((col) => {
@@ -14474,9 +14339,8 @@ function dataRoutes(config) {
 			db.close();
 		}
 	});
-	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");
@@ -14494,11 +14358,13 @@ function dataRoutes(config) {
 
 //#endregion
 //#region src/server/routes/schema.ts
-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();
@@ -14511,23 +14377,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);
@@ -14537,12 +14405,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 {
@@ -14558,14 +14422,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`);
@@ -14645,25 +14508,11 @@ function createApp(config, staticDir) {
 
 //#endregion
 //#region src/core/web-runner.ts
-const execFileAsync = promisify(execFile);
 function resolveWebStaticDir() {
 	return path.join(resolvePackageRoot(), "dist/web");
 }
 async function openBrowser(url) {
-	if (process.platform === "darwin") {
-		await execFileAsync("open", [url]);
-		return;
-	}
-	if (process.platform === "win32") {
-		await execFileAsync("cmd", [
-			"/c",
-			"start",
-			"",
-			url
-		]);
-		return;
-	}
-	await execFileAsync("xdg-open", [url]);
+	await open(url);
 }
 async function startWebServer(input) {
 	const { config, port } = input;
@@ -14744,7 +14593,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);

package/dist/{completions-ygS1okck.mjs → completions-C3rmTwXZ.mjs}

@@ -1,5 +1,6 @@
 import path from "node:path";
 import process from "node:process";
+import { readFileSync } from "jsonfile";
 import fs from "node:fs";
 
 //#region src/core/completions.ts
@@ -27,8 +28,7 @@ function getFileCompletions(pattern) {
 }
 function getJsonModelNames(configPath) {
 	try {
-		const content = fs.readFileSync(configPath, "utf-8");
-		const config = JSON.parse(content);
+		const config = readFileSync(configPath);
 		if (config.provider?.models) return config.provider.models.map((m) => m.name);
 	} catch {}
 	return [];