aiex-cli 0.0.0

package/dist/doctor-Wic10PLt.mjs

@@ -0,0 +1,711 @@
+import path from "node:path";
+import process from "node:process";
+import { z } from "zod";
+import fs from "node:fs/promises";
+import os from "node:os";
+import Conf from "conf";
+
+//#region src/core/doctor.ts
+function buildDoctorDiagnostics(input) {
+	return {
+		cli: {
+			name: input.pkg.name,
+			version: input.pkg.version,
+			executable: input.executable
+		},
+		runtime: {
+			node: input.node,
+			platform: input.platform,
+			arch: input.arch,
+			shell: input.shell,
+			packageManager: input.packageManager
+		},
+		system: {
+			os: `${input.osType} ${input.osRelease}`,
+			cwd: input.cwd
+		},
+		config: {
+			path: input.configPath,
+			keys: [...input.configStoreKeys].sort()
+		},
+		project: { ...input.project }
+	};
+}
+function formatDoctorDiagnosticsJson(d) {
+	return `${JSON.stringify(d, null, 2)}\n`;
+}
+function doctorDiagnosticsTableRows(d) {
+	const rows = [
+		["node", d.runtime.node],
+		["platform", d.runtime.platform],
+		["arch", d.runtime.arch],
+		["shell", d.runtime.shell],
+		["packageManager", d.runtime.packageManager],
+		["os", d.system.os],
+		["cwd", d.system.cwd],
+		["config", d.config.path],
+		["configKeys", d.config.keys.join(", ")]
+	];
+	const p = d.project;
+	rows.push(["aiexDir", p.aiexDir]);
+	rows.push(["dirExists", String(p.dirExists)]);
+	rows.push(["schemaFiles", `${p.schemaCount} (${p.schemaFiles.join(", ") || "none"})`]);
+	rows.push(["aiConfig", String(p.aiConfig)]);
+	rows.push(["aiApiKeySet", String(p.aiApiKeySet)]);
+	rows.push(["aiModels", p.aiModelCount ? p.aiModels.join(", ") : "none"]);
+	rows.push(["aiProvider", p.aiProvider ?? "none"]);
+	rows.push(["aiConnectionOk", p.aiConnectionOk === null ? "not tested" : String(p.aiConnectionOk)]);
+	rows.push(["hasDatabase", String(p.hasDatabase)]);
+	rows.push(["migrations", String(p.migrationCount)]);
+	for (const err of p.errors) rows.push(["error", err]);
+	return rows;
+}
+
+//#endregion
+//#region src/core/schema-sqlite/generator.ts
+function generateColumnDefinition(column) {
+	if (column.isPrimary && column.isAutoIncrement) return `  ${column.name}: integer().primaryKey({ autoIncrement: true })`;
+	let def = `  ${column.name}: ${column.drizzleType}`;
+	if (column.isPrimary) def += ".primaryKey()";
+	if (!column.isNullable && !column.isPrimary) def += ".notNull()";
+	if (column.isUnique && !column.isPrimary) def += ".unique()";
+	if (column.defaultValue !== void 0) def += `.default(${column.defaultValue})`;
+	if (column.isForeignKey && column.foreignKeyRef) def += `.references(() => ${column.foreignKeyRef.table}.${column.foreignKeyRef.column})`;
+	return def;
+}
+function generateTableDefinition(table) {
+	const columns = table.columns.map(generateColumnDefinition);
+	return `export const ${table.name} = sqliteTable('${table.name}', {\n${columns.join(",\n")}\n})`;
+}
+function generateRelationDefinitions(relations, reverseRelations) {
+	if (relations.length === 0 && reverseRelations.length === 0) return "";
+	const definitions = [];
+	const childByTable = /* @__PURE__ */ new Map();
+	for (const rel of relations) {
+		const list = childByTable.get(rel.fromTable) ?? [];
+		list.push(rel);
+		childByTable.set(rel.fromTable, list);
+	}
+	const parentByTable = /* @__PURE__ */ new Map();
+	for (const rel of reverseRelations) {
+		const list = parentByTable.get(rel.fromTable) ?? [];
+		list.push(rel);
+		parentByTable.set(rel.fromTable, list);
+	}
+	const allTableNames = new Set([...childByTable.keys(), ...parentByTable.keys()]);
+	for (const tableName of allTableNames) {
+		const childRels = childByTable.get(tableName) ?? [];
+		const parentRels = parentByTable.get(tableName) ?? [];
+		const needsOne = childRels.length > 0 || parentRels.some((r) => r.type === "has-one");
+		const needsMany = parentRels.some((r) => r.type === "has-many");
+		const imports = [];
+		if (needsOne) imports.push("one");
+		if (needsMany) imports.push("many");
+		const importStr = imports.join(", ");
+		const relDefs = [];
+		for (const rel of childRels) relDefs.push(`    ${rel.name}: one(${rel.toTable}, {\n      fields: [${rel.fromColumn}],\n      references: [id],\n    })`);
+		for (const rel of parentRels) if (rel.type === "has-many") relDefs.push(`    ${rel.name}: many(${rel.toTable})`);
+		else relDefs.push(`    ${rel.name}: one(${rel.toTable})`);
+		definitions.push(`export const ${tableName}Relations = relations(${tableName}, ({ ${importStr} }) => ({\n${relDefs.join(",\n")}\n}))`);
+	}
+	return definitions.join("\n\n");
+}
+function generateDrizzleSchema(result) {
+	const imports = `import { sqliteTable, text, integer, real } from 'drizzle-orm/sqlite-core'\nimport { relations } from 'drizzle-orm'`;
+	const tableDefs = result.tables.map(generateTableDefinition).join("\n\n");
+	const relationDefs = generateRelationDefinitions(result.relations, result.reverseRelations);
+	const parts = [
+		imports,
+		"",
+		tableDefs
+	];
+	if (relationDefs) parts.push("", relationDefs);
+	parts.push("");
+	return parts.join("\n");
+}
+
+//#endregion
+//#region src/core/schema-sqlite/parser.ts
+function toSnakeCase(str) {
+	return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+}
+function mapPropertyToColumn(name$1, property, isRequired) {
+	const snakeName = toSnakeCase(name$1);
+	let drizzleType;
+	const isPrimary = property.primary ?? false;
+	const isAutoIncrement = property.autoIncrement ?? false;
+	switch (property.type) {
+		case "string": {
+			const format = property.format;
+			if (format === "date-time" || property.drizzle?.mode === "timestamp") drizzleType = `integer({ mode: 'timestamp' })`;
+			else if (format === "json" || property.drizzle?.mode === "json") drizzleType = `text({ mode: 'json' })`;
+			else drizzleType = "text()";
+			break;
+		}
+		case "integer": {
+			const mode = property.drizzle?.mode;
+			if (mode === "boolean") drizzleType = `integer({ mode: 'boolean' })`;
+			else if (mode === "timestamp" || mode === "timestamp_ms") drizzleType = `integer({ mode: '${mode}' })`;
+			else if (mode === "bigint") drizzleType = `integer({ mode: 'bigint' })`;
+			else drizzleType = "integer()";
+			break;
+		}
+		case "number":
+			drizzleType = "real()";
+			break;
+		case "boolean":
+			drizzleType = `integer({ mode: 'boolean' })`;
+			break;
+		case "object":
+		case "array":
+			drizzleType = `text({ mode: 'json' })`;
+			break;
+		case "null":
+			drizzleType = "text()";
+			break;
+		default: drizzleType = "text()";
+	}
+	return {
+		name: snakeName,
+		drizzleType,
+		isPrimary,
+		isAutoIncrement,
+		isNullable: !isRequired && !isPrimary,
+		isUnique: property.unique ?? false,
+		defaultValue: property.default !== void 0 ? JSON.stringify(property.default) : void 0,
+		isForeignKey: property.foreignKey !== void 0,
+		foreignKeyRef: property.foreignKey ?? void 0
+	};
+}
+function parseObjectToTable(schema, _warnings) {
+	const tableName = schema.table.name;
+	const columns = [];
+	const requiredFields = new Set(schema.required ?? []);
+	const autoColumns = /* @__PURE__ */ new Set();
+	if (schema.table.timestamps) {
+		autoColumns.add("created_at");
+		autoColumns.add("updated_at");
+	}
+	if (schema.table.softDelete) autoColumns.add("deleted_at");
+	for (const [propName, prop] of Object.entries(schema.properties)) {
+		if (prop.nested?.enabled && (prop.type === "object" || prop.type === "array")) continue;
+		if (prop.type === "array" && prop.items?.nested?.enabled) continue;
+		const snakeName = toSnakeCase(propName);
+		if (autoColumns.has(snakeName)) continue;
+		const column = mapPropertyToColumn(propName, prop, requiredFields.has(propName));
+		columns.push(column);
+	}
+	if (schema.table.timestamps) {
+		columns.push({
+			name: "created_at",
+			drizzleType: `integer({ mode: 'timestamp' })`,
+			isPrimary: false,
+			isAutoIncrement: false,
+			isNullable: false,
+			isUnique: false,
+			defaultValue: void 0
+		});
+		columns.push({
+			name: "updated_at",
+			drizzleType: `integer({ mode: 'timestamp' })`,
+			isPrimary: false,
+			isAutoIncrement: false,
+			isNullable: false,
+			isUnique: false,
+			defaultValue: void 0
+		});
+	}
+	if (schema.table.softDelete) columns.push({
+		name: "deleted_at",
+		drizzleType: `integer({ mode: 'timestamp' })`,
+		isPrimary: false,
+		isAutoIncrement: false,
+		isNullable: true,
+		isUnique: false,
+		defaultValue: void 0
+	});
+	return {
+		name: tableName,
+		columns
+	};
+}
+function parseNestedObject(propName, property, parentTableName, warnings) {
+	const nestedTableName = `${parentTableName}_${toSnakeCase(propName)}`;
+	const columns = [];
+	const relationType = property.nested?.relation === "has-many" ? "has-many" : "has-one";
+	columns.push({
+		name: "id",
+		drizzleType: "integer()",
+		isPrimary: true,
+		isAutoIncrement: true,
+		isNullable: false,
+		isUnique: false,
+		defaultValue: void 0
+	});
+	columns.push({
+		name: `${parentTableName}_id`,
+		drizzleType: "integer()",
+		isPrimary: false,
+		isAutoIncrement: false,
+		isNullable: false,
+		isUnique: false,
+		defaultValue: void 0,
+		isForeignKey: true,
+		foreignKeyRef: {
+			table: parentTableName,
+			column: "id"
+		}
+	});
+	if (property.type === "object" && property.properties) for (const [childName, childProp] of Object.entries(property.properties)) {
+		if (childProp.nested?.enabled) {
+			warnings.push(`Nested property "${childName}" inside "${nestedTableName}" is skipped — only one level of nesting is supported. Remove nested.enabled or use drizzle.mode: 'json' instead.`);
+			continue;
+		}
+		const column = mapPropertyToColumn(childName, childProp, false);
+		columns.push(column);
+	}
+	const relation = {
+		fromTable: nestedTableName,
+		fromColumn: `${parentTableName}_id`,
+		toTable: parentTableName,
+		toColumn: "id",
+		name: parentTableName
+	};
+	const reverseRelation = {
+		type: relationType,
+		fromTable: parentTableName,
+		toTable: nestedTableName,
+		name: toSnakeCase(propName)
+	};
+	return {
+		table: {
+			name: nestedTableName,
+			columns
+		},
+		relation,
+		reverseRelation
+	};
+}
+function parseJsonSchema(schema) {
+	const tables = [];
+	const relations = [];
+	const reverseRelations = [];
+	const warnings = [];
+	const mainTable = parseObjectToTable(schema, warnings);
+	tables.push(mainTable);
+	for (const [propName, prop] of Object.entries(schema.properties)) if (prop.type === "object" && prop.nested?.enabled) {
+		const nested = parseNestedObject(propName, prop, mainTable.name, warnings);
+		tables.push(nested.table);
+		relations.push(nested.relation);
+		reverseRelations.push(nested.reverseRelation);
+	} else if (prop.type === "array" && prop.items?.nested?.enabled && prop.items?.type === "object" && prop.items.properties) {
+		const nested = parseNestedObject(propName, prop.items, mainTable.name, warnings);
+		tables.push(nested.table);
+		relations.push(nested.relation);
+		reverseRelations.push(nested.reverseRelation);
+	}
+	return {
+		tables,
+		relations,
+		reverseRelations,
+		warnings
+	};
+}
+
+//#endregion
+//#region src/core/schema-sqlite/schemas.ts
+const DrizzleModeSchema = z.enum([
+	"json",
+	"timestamp",
+	"timestamp_ms",
+	"boolean",
+	"bigint"
+]);
+const DrizzleExtensionSchema = z.object({
+	mode: DrizzleModeSchema.optional(),
+	customType: z.string().optional()
+}).optional();
+const NestedConfigSchema = z.object({
+	enabled: z.literal(true),
+	relation: z.enum(["has-one", "has-many"])
+});
+const ForeignKeyRefSchema = z.object({
+	table: z.string().min(1),
+	column: z.string().min(1)
+});
+const JsonSchemaPropertySchema = z.lazy(() => z.object({
+	type: z.enum([
+		"string",
+		"integer",
+		"number",
+		"boolean",
+		"object",
+		"array",
+		"null"
+	]),
+	format: z.string().optional(),
+	primary: z.boolean().optional(),
+	autoIncrement: z.boolean().optional(),
+	unique: z.boolean().optional(),
+	default: z.unknown().optional(),
+	maxLength: z.number().int().positive().optional(),
+	minLength: z.number().int().nonnegative().optional(),
+	minimum: z.number().optional(),
+	maximum: z.number().optional(),
+	drizzle: DrizzleExtensionSchema,
+	nested: NestedConfigSchema.optional(),
+	foreignKey: ForeignKeyRefSchema.optional(),
+	properties: z.record(z.string(), JsonSchemaPropertySchema).optional(),
+	items: JsonSchemaPropertySchema.optional(),
+	required: z.array(z.string()).optional()
+}));
+const TableConfigSchema = z.object({
+	name: z.string().min(1).regex(/^[a-z][a-z0-9_]*$/, "Table name must be snake_case (lowercase letters, digits, underscores)"),
+	timestamps: z.boolean().optional(),
+	softDelete: z.boolean().optional()
+});
+const JsonSchemaDefinitionSchema = z.object({
+	$schema: z.string().optional(),
+	title: z.string().min(1),
+	description: z.string().optional(),
+	type: z.literal("object"),
+	table: TableConfigSchema,
+	properties: z.record(z.string(), JsonSchemaPropertySchema),
+	required: z.array(z.string()).optional()
+}).refine((schema) => Object.keys(schema.properties).length >= 1, {
+	message: "At least one property is required",
+	path: ["properties"]
+}).refine((schema) => !schema.required || schema.required.every((r) => r in schema.properties), {
+	message: "All required fields must be defined in properties",
+	path: ["required"]
+}).refine((schema) => {
+	return !Object.values(schema.properties).some((p) => p.primary) || Object.values(schema.properties).filter((p) => p.primary).length === 1;
+}, {
+	message: "Only one primary key is allowed per table",
+	path: ["properties"]
+});
+
+//#endregion
+//#region src/core/schema-sqlite/migrator.ts
+function createMigrationConfig(cwd) {
+	return {
+		schemaPath: `${cwd}/.aiex/schema`,
+		drizzleSchemaPath: `${cwd}/.aiex/drizzle/schema.ts`,
+		migrationsPath: `${cwd}/.aiex/migrations`,
+		databasePath: `${cwd}/.aiex/database.db`,
+		drizzleConfigPath: `${cwd}/.aiex/drizzle.config.ts`
+	};
+}
+function generateDrizzleConfig() {
+	return `export default {
+  dialect: 'sqlite',
+  schema: './.aiex/drizzle/schema.ts',
+  out: './.aiex/migrations',
+  dbCredentials: {
+    url: './.aiex/database.db',
+  },
+}
+`;
+}
+
+//#endregion
+//#region package.json
+var name = "aiex-cli";
+var version = "0.0.0";
+var description = "JSON Schema → SQLite with AI-powered data extraction";
+var package_default = {
+	name,
+	type: "module",
+	version,
+	description,
+	author: "OSpoon <zxin088@gmail.com>",
+	license: "MIT",
+	homepage: "https://github.com/OSpoon/aiex-cli#readme",
+	repository: {
+		"type": "git",
+		"url": "git+https://github.com/OSpoon/aiex-cli.git"
+	},
+	bugs: "https://github.com/OSpoon/aiex-cli/issues",
+	keywords: [
+		"json-schema",
+		"sqlite",
+		"drizzle",
+		"orm",
+		"ai-extraction",
+		"cli",
+		"database-migration",
+		"schema-editor",
+		"code-generation",
+		"structured-output"
+	],
+	sideEffects: false,
+	exports: {
+		".": "./dist/index.mjs",
+		"./cli": "./dist/cli.mjs",
+		"./core/schema-sqlite/migrate-helper": "./dist/core/schema-sqlite/migrate-helper.mjs",
+		"./package.json": "./package.json"
+	},
+	main: "./dist/index.mjs",
+	module: "./dist/index.mjs",
+	types: "./dist/index.d.mts",
+	bin: { "aiex": "./bin/cli.mjs" },
+	files: [
+		"bin",
+		"dist",
+		"src/core/schema-sqlite/migrate-helper.ts"
+	],
+	scripts: {
+		"build": "tsdown && pnpm --filter aiex-web build",
+		"dev": "tsdown --watch",
+		"start": "tsx src/index.ts",
+		"test": "vitest",
+		"typecheck": "tsc",
+		"lint": "eslint .",
+		"prepublishOnly": "cp ../../README.md . && pnpm run build",
+		"postpublish": "rm -f README.md"
+	},
+	dependencies: {
+		"@ai-sdk/openai-compatible": "catalog:",
+		"@clack/prompts": "catalog:",
+		"@hono/node-server": "catalog:",
+		"ai": "catalog:",
+		"better-sqlite3": "catalog:",
+		"citty": "catalog:",
+		"cli-table3": "catalog:",
+		"conf": "catalog:",
+		"consola": "catalog:",
+		"date-fns": "catalog:",
+		"drizzle-kit": "catalog:cli",
+		"drizzle-orm": "catalog:",
+		"es-toolkit": "catalog:",
+		"esbuild": "catalog:",
+		"hono": "catalog:",
+		"picocolors": "catalog:",
+		"tsx": "catalog:cli",
+		"update-notifier": "catalog:",
+		"zod": "catalog:"
+	},
+	devDependencies: {
+		"@antfu/eslint-config": "catalog:cli",
+		"@antfu/ni": "catalog:cli",
+		"@types/better-sqlite3": "catalog:types",
+		"@types/node": "catalog:types",
+		"@types/update-notifier": "catalog:",
+		"eslint": "catalog:cli",
+		"publint": "catalog:cli",
+		"tsdown": "catalog:cli",
+		"tsnapi": "catalog:testing",
+		"typescript": "catalog:cli",
+		"vitest": "catalog:testing"
+	}
+};
+
+//#endregion
+//#region src/config.ts
+function createConfig() {
+	return new Conf({
+		cwd: process.env.CLI_CONFIG_DIR,
+		projectName: process.env.CLI_CONFIG_PROJECT_NAME || name
+	});
+}
+function seedConfig(config = createConfig()) {
+	if (!config.has("name")) config.set("name", name);
+	if (!config.has("version")) config.set("version", version);
+}
+
+//#endregion
+//#region src/core/ai-extraction/schemas.ts
+const ModelCapabilitiesSchema = z.object({
+	vision: z.boolean(),
+	structuredOutput: z.boolean()
+});
+const AIModelConfigSchema = z.object({
+	name: z.string().min(1),
+	capabilities: ModelCapabilitiesSchema
+});
+const AIProviderConfigSchema = z.object({
+	baseURL: z.string().min(1),
+	apiKey: z.string(),
+	models: z.array(AIModelConfigSchema).min(1)
+});
+const PromptConfigSchema = z.object({
+	systemTemplate: z.string().min(1),
+	userTemplate: z.string().min(1)
+});
+const ExtractionConfigSchema = z.object({ outputDir: z.string().min(1) });
+const AIConfigSchema = z.object({
+	provider: AIProviderConfigSchema,
+	prompt: PromptConfigSchema,
+	extraction: ExtractionConfigSchema
+});
+
+//#endregion
+//#region src/core/ai-extraction/types.ts
+const PLACEHOLDER_SCHEMA = "{schema}";
+const PLACEHOLDER_TEXT = "{text}";
+const DEFAULT_MODELS = [{
+	name: "qwen-plus",
+	capabilities: {
+		vision: false,
+		structuredOutput: true
+	}
+}, {
+	name: "qwen-vl-plus",
+	capabilities: {
+		vision: true,
+		structuredOutput: true
+	}
+}];
+const DEFAULT_PROVIDER_CONFIG = {
+	baseURL: "https://dashscope.aliyuncs.com/compatible-mode/v1",
+	apiKey: "",
+	models: [...DEFAULT_MODELS]
+};
+const DEFAULT_PROMPT_CONFIG = {
+	systemTemplate: `You are a professional data extraction assistant. Your task is to extract structured data from text based on the data structure definition provided below.
+
+{schema}
+
+Extraction requirements:
+1. Extract strictly according to the field names and types defined in the structure
+2. If the text lacks information for a field, set that field to null
+3. Do not add fields that do not exist in the structure definition
+4. Maintain data accuracy and completeness`,
+	userTemplate: `Please extract data from the following text:
+{text}`
+};
+const DEFAULT_EXTRACTION_CONFIG = { outputDir: ".aiex/extracted" };
+const DEFAULT_AI_CONFIG = {
+	provider: DEFAULT_PROVIDER_CONFIG,
+	prompt: DEFAULT_PROMPT_CONFIG,
+	extraction: DEFAULT_EXTRACTION_CONFIG
+};
+
+//#endregion
+//#region src/core/ai-extraction/config.ts
+const CONFIG_FILE_NAME = "ai-config.json";
+const GITIGNORE_FILE = ".gitignore";
+async function readAIConfig(aiexDir) {
+	const configPath = path.join(aiexDir, CONFIG_FILE_NAME);
+	try {
+		const content = await fs.readFile(configPath, "utf-8");
+		const parsed = JSON.parse(content);
+		return AIConfigSchema.parse(parsed);
+	} catch {
+		return null;
+	}
+}
+async function writeAIConfig(aiexDir, config) {
+	const configPath = path.join(aiexDir, CONFIG_FILE_NAME);
+	await fs.mkdir(aiexDir, { recursive: true });
+	await fs.writeFile(configPath, `${JSON.stringify(config, null, 2)}\n`);
+	await addToGitignore(aiexDir, CONFIG_FILE_NAME);
+}
+function getDefaultAIConfig() {
+	return { ...DEFAULT_AI_CONFIG };
+}
+function maskApiKey(apiKey) {
+	if (apiKey.length <= 4) return "****";
+	return `sk-***${apiKey.slice(-4)}`;
+}
+async function addToGitignore(aiexDir, fileName) {
+	const projectRoot = path.dirname(aiexDir);
+	const gitignorePath = path.join(projectRoot, GITIGNORE_FILE);
+	try {
+		const content = await fs.readFile(gitignorePath, "utf-8");
+		if (content.split("\n").some((line) => line.trim() === fileName || line.includes(".aiex/"))) return;
+		const newContent = content.endsWith("\n") ? `${content}${fileName}\n` : `${content}\n${fileName}\n`;
+		await fs.writeFile(gitignorePath, newContent);
+	} catch {
+		await fs.writeFile(gitignorePath, `${fileName}\n`);
+	}
+}
+
+//#endregion
+//#region src/doctor.ts
+const V1_SUFFIX_RE = /\/v1\/?$/;
+async function checkConnection(baseURL) {
+	try {
+		const base = baseURL.replace(V1_SUFFIX_RE, "");
+		return (await fetch(`${base}/v1/models`, { signal: AbortSignal.timeout(5e3) })).ok;
+	} catch {
+		return false;
+	}
+}
+async function collectDoctorDiagnostics(options = {}) {
+	const config = options.config ?? createConfig();
+	const cwd = process.cwd();
+	const errors = [];
+	const migConfig = createMigrationConfig(cwd);
+	const aiexDir = path.dirname(migConfig.schemaPath);
+	const dirExists = await fs.stat(aiexDir).then((s) => s.isDirectory()).catch(() => false);
+	let schemaFiles = [];
+	if (dirExists) try {
+		const schemaDir = migConfig.schemaPath;
+		schemaFiles = (await fs.readdir(schemaDir).catch(() => [])).filter((f) => f.endsWith(".json")).sort();
+	} catch {
+		errors.push("Could not read schema directory");
+	}
+	let aiConfig = false;
+	let aiApiKeySet = false;
+	let aiModelCount = 0;
+	let aiModels = [];
+	let aiProvider = null;
+	let aiConnectionOk = null;
+	if (dirExists) {
+		const cfg = await readAIConfig(aiexDir);
+		if (cfg) {
+			aiConfig = true;
+			aiApiKeySet = Boolean(cfg.provider.apiKey);
+			aiModelCount = cfg.provider.models?.length ?? 0;
+			aiModels = cfg.provider.models?.map((m) => m.name) ?? [];
+			aiProvider = cfg.provider.baseURL;
+			aiConnectionOk = await checkConnection(cfg.provider.baseURL);
+		}
+	}
+	let dbExists = false;
+	if (dirExists) try {
+		dbExists = (await fs.stat(migConfig.databasePath)).isFile();
+	} catch {
+		dbExists = false;
+	}
+	let migrationCount = 0;
+	if (dirExists) try {
+		migrationCount = (await fs.readdir(migConfig.migrationsPath).catch(() => [])).filter((f) => f.endsWith(".sql")).length;
+	} catch {}
+	return buildDoctorDiagnostics({
+		pkg: {
+			name,
+			version
+		},
+		executable: process.argv[1] ?? "unknown",
+		node: process.version,
+		platform: process.platform,
+		arch: process.arch,
+		shell: process.env.SHELL ?? process.env.ComSpec ?? "unknown",
+		packageManager: process.env.npm_config_user_agent?.split(" ")[0] || "unknown",
+		osType: os.type(),
+		osRelease: os.release(),
+		cwd,
+		configPath: config.path,
+		configStoreKeys: Object.keys(config.store),
+		project: {
+			aiexDir,
+			dirExists,
+			schemaCount: schemaFiles.length,
+			schemaFiles,
+			aiConfig,
+			aiApiKeySet,
+			aiModelCount,
+			aiModels,
+			aiProvider,
+			aiConnectionOk,
+			hasDatabase: dbExists,
+			migrationCount,
+			errors
+		}
+	});
+}
+
+//#endregion
+export { formatDoctorDiagnosticsJson as C, doctorDiagnosticsTableRows as S, generateDrizzleConfig as _, writeAIConfig as a, generateDrizzleSchema as b, PLACEHOLDER_TEXT as c, seedConfig as d, description as f, createMigrationConfig as g, version as h, readAIConfig as i, AIConfigSchema as l, package_default as m, getDefaultAIConfig as n, DEFAULT_PROMPT_CONFIG as o, name as p, maskApiKey as r, PLACEHOLDER_SCHEMA as s, collectDoctorDiagnostics as t, createConfig as u, JsonSchemaDefinitionSchema as v, buildDoctorDiagnostics as x, parseJsonSchema as y };