@ucdjs/cli 0.3.0 → 0.3.1-beta.1

package/bin/ucd.js

@@ -1,3 +1,3 @@
 #!/usr/bin/env node
 
-import("../dist/cli.js");
+import("../dist/cli.mjs");

package/dist/_shared-CgcKJJFf.mjs

@@ -0,0 +1,113 @@
+import { a as StoreConfigurationError, i as RemoteNotSupportedError, n as CLIError, o as StoreDirIsRequiredError, r as CLIStoreError } from "./cli.mjs";
+import { createUCDClient } from "@ucdjs/client";
+import { UCDJS_API_BASE_URL } from "@ucdjs/env";
+import { isCancel, multiselect } from "@clack/prompts";
+import { UCDStoreBaseError, createHTTPUCDStore, createNodeUCDStore, validateVersions } from "@ucdjs/ucd-store";
+import { UNICODE_VERSION_METADATA } from "@unicode-utils/core";
+
+//#region src/cmd/store/_shared.ts
+/**
+* Shared flags for all store commands (filtering, API config)
+*/
+const SHARED_FLAGS = [
+	["--include", "Patterns to include files in the store."],
+	["--exclude", "Patterns to exclude files from the store."],
+	["--base-url", "Base URL for the UCD API."],
+	["--force", "Force operation (command-specific behavior)."]
+];
+/**
+* Flags specific to local store commands (init, sync, mirror)
+*/
+const LOCAL_STORE_FLAGS = [["--store-dir", "Directory where the UCD files are stored. (required)"]];
+/**
+* Flags for commands that work with both local and remote stores
+*/
+const REMOTE_CAPABLE_FLAGS = [["--store-dir", "Directory where the UCD files are stored."], ["--remote", "Use a Remote UCD Store (read-only)."]];
+/**
+* Asserts that storeDir is provided. Used for local-only commands (init, sync, mirror).
+*/
+function assertLocalStore(flags) {
+	if (flags.remote) throw new RemoteNotSupportedError();
+	if (!flags.storeDir) throw new StoreDirIsRequiredError();
+}
+function assertRemoteOrStoreDir(flags) {
+	if (!flags.remote && !flags.storeDir) throw new StoreConfigurationError("Either --remote or --store-dir must be specified.");
+}
+/**
+* Validates that the provided versions exist in the API.
+* Throws a CLIError if any versions are invalid.
+*
+* @param versions - Versions to validate
+* @param baseUrl - Base URL for the UCD API
+* @throws {CLIError} If any versions are invalid
+*/
+async function validateVersionsOrThrow(versions, baseUrl) {
+	if (!versions || versions.length === 0) return;
+	const client = await createUCDClient(baseUrl || UCDJS_API_BASE_URL);
+	try {
+		const result = await validateVersions({
+			client,
+			versions
+		});
+		if (!result.valid) throw new CLIError(`Invalid Unicode version(s): ${result.invalidVersions.join(", ")}`, {
+			title: "Version Validation Error",
+			details: [`Available versions: ${result.availableVersions.join(", ")}`]
+		});
+	} catch (err) {
+		if (err instanceof CLIError) throw err;
+		if (err instanceof Error) throw new CLIStoreError(err);
+		throw err;
+	}
+}
+/**
+* Creates a UCD store instance based on the provided CLI flags.
+* Validates versions before creating the store.
+*
+* @param {CLIStoreCmdSharedFlags} flags - Configuration flags for creating the store
+* @returns {Promise<UCDStore>} A promise that resolves to a UCDStore instance
+* @throws {CLIStoreError} When store creation fails
+* @throws {StoreDirIsRequiredError} When store directory is not specified for local stores
+* @throws {CLIError} When version validation fails
+*/
+async function createStoreFromFlags(flags) {
+	const { storeDir, remote, baseUrl, include, exclude, force, requireExistingStore, versionStrategy } = flags;
+	if (flags.versions && flags.versions.length > 0) await validateVersionsOrThrow(flags.versions, baseUrl);
+	const options = {
+		baseUrl,
+		globalFilters: {
+			include,
+			exclude
+		},
+		versionStrategy: force ? "overwrite" : versionStrategy || "strict",
+		requireExistingStore
+	};
+	try {
+		if (remote) return await createHTTPUCDStore(options);
+		if (!storeDir) throw new StoreDirIsRequiredError();
+		return await createNodeUCDStore({
+			...options,
+			basePath: storeDir,
+			versions: flags.versions || []
+		});
+	} catch (err) {
+		if (err instanceof UCDStoreBaseError) throw new CLIStoreError(err);
+		throw err;
+	}
+}
+async function runVersionPrompt({ input, output } = {}) {
+	const selectedVersions = await multiselect({
+		options: UNICODE_VERSION_METADATA.map(({ version }) => ({
+			value: version,
+			label: version
+		})),
+		message: "Select Unicode versions to initialize the store with:",
+		required: true,
+		input,
+		output
+	});
+	if (isCancel(selectedVersions)) return [];
+	return selectedVersions;
+}
+
+//#endregion
+export { assertRemoteOrStoreDir as a, assertLocalStore as i, REMOTE_CAPABLE_FLAGS as n, createStoreFromFlags as o, SHARED_FLAGS as r, runVersionPrompt as s, LOCAL_STORE_FLAGS as t };

package/dist/analyze-D8AeAGDR.mjs

@@ -0,0 +1,75 @@
+import { _ as output, p as green, t as printHelp, v as red } from "./cli.mjs";
+import { a as assertRemoteOrStoreDir, n as REMOTE_CAPABLE_FLAGS, o as createStoreFromFlags, r as SHARED_FLAGS } from "./_shared-CgcKJJFf.mjs";
+
+//#region src/cmd/store/analyze.ts
+async function runAnalyzeStore({ flags, versions }) {
+	if (flags?.help || flags?.h) {
+		printHelp({
+			headline: "Analyze UCD Store",
+			commandName: "ucd store analyze",
+			usage: "[...versions] [...flags]",
+			tables: { Flags: [
+				...REMOTE_CAPABLE_FLAGS,
+				...SHARED_FLAGS,
+				["--check-orphaned", "Check for orphaned files in the store."],
+				["--json", "Output analyze information in JSON format."],
+				["--help (-h)", "See all available flags."]
+			] }
+		});
+		return;
+	}
+	if (!versions || versions.length === 0) output.log("No specific versions provided. Analyzing all versions in the store.");
+	assertRemoteOrStoreDir(flags);
+	const { storeDir, json, remote, baseUrl, include: patterns, exclude: excludePatterns } = flags;
+	const [analyzeData, analyzeError] = await (await createStoreFromFlags({
+		baseUrl,
+		storeDir,
+		remote,
+		include: patterns,
+		exclude: excludePatterns,
+		requireExistingStore: true
+	})).analyze({
+		versions: versions.length > 0 ? versions : void 0,
+		filters: {
+			include: patterns,
+			exclude: excludePatterns
+		}
+	});
+	if (analyzeError != null) {
+		output.error(red(`\n❌ Error analyzing store:`));
+		output.error(`  ${analyzeError.message}`);
+		return;
+	}
+	if (!analyzeData) {
+		output.error(red(`\n❌ Error: Analyze operation returned no result.`));
+		return;
+	}
+	if (json) {
+		const analyzeDataObj = {
+			...analyzeData,
+			versions: Object.fromEntries(Array.from(analyzeData.versions.entries()).map(([version, report]) => [version, {
+				...report,
+				files: {
+					...report.files,
+					missing: report.files.missing ?? [],
+					orphaned: report.files.orphaned ?? [],
+					present: report.files.present ?? []
+				}
+			}]))
+		};
+		output.json(analyzeDataObj);
+		return;
+	}
+	for (const [version, report] of analyzeData.versions.entries()) {
+		output.log(`Version: ${version}`);
+		if (report.isComplete) output.log(`  Status: ${green("complete")}`);
+		else output.warning(`  Status: ${red("incomplete")}`);
+		output.log(`  Files: ${report.counts.success}`);
+		if (report.files.missing && report.files.missing.length > 0) output.warning(`  Missing files: ${report.files.missing.length}`);
+		if (report.files.orphaned && report.files.orphaned.length > 0) output.warning(`  Orphaned files: ${report.files.orphaned.length}`);
+		if (report.counts.total) output.log(`  Total files expected: ${report.counts.total}`);
+	}
+}
+
+//#endregion
+export { runAnalyzeStore };

package/dist/cli.mjs

@@ -0,0 +1,403 @@
+import process$1 from "node:process";
+import farver, { bgGreen, black, bold, dim, green } from "farver/fast";
+import yargs from "yargs-parser";
+
+//#region package.json
+var version = "0.3.1-beta.1";
+
+//#endregion
+//#region src/output.ts
+const green$1 = farver.green;
+const red = farver.red;
+const yellow = farver.yellow;
+const cyan = farver.cyan;
+const bold$1 = farver.bold;
+const dim$1 = farver.dim;
+const BUG_REPORT_URL = "https://github.com/ucdjs/ucd/issues";
+const DEFAULT_INDENT = 2;
+const DEFAULT_DIVIDER_LENGTH = 40;
+const DEFAULT_LABEL_WIDTH = 16;
+const DEFAULT_MAX_LIST_ITEMS = 10;
+let jsonMode = false;
+/**
+* Centralized output utility for CLI commands.
+*
+* In JSON mode:
+* - `log` is redirected to stderr so only JSON goes to stdout
+* - `warn` and `error` always go to stderr
+* - `json` always writes to stdout
+* - `success`, `fail`, `warning`, `info` are silent (no output)
+*
+* This ensures that when `--json` is used, stdout contains only valid JSON
+* that can be piped to other tools.
+*/
+const output = {
+	log: (...args) => {
+		if (jsonMode) console.error(...args);
+		else console.log(...args);
+	},
+	warn: (...args) => {
+		console.warn(...args);
+	},
+	error: (...args) => {
+		console.error(...args);
+	},
+	json: (data) => {
+		console.log(`${JSON.stringify(data, null, 2)}\n`);
+	},
+	success: (message) => {
+		if (jsonMode) return;
+		console.log(green$1(`✓ ${message}`));
+	},
+	fail: (message, options) => {
+		if (jsonMode) return;
+		console.error(red(`\n❌ Error: ${message}`));
+		if (options?.details) for (const detail of options.details) console.error(`  ${detail}`);
+		if (options?.bugReport) console.error(`\n  If you believe this is a bug, please report it at ${BUG_REPORT_URL}`);
+	},
+	warning: (message) => {
+		if (jsonMode) return;
+		console.warn(yellow(`⚠ ${message}`));
+	},
+	info: (message) => {
+		if (jsonMode) return;
+		console.log(message);
+	},
+	errorJson: (error) => {
+		if (jsonMode) console.log(JSON.stringify({ error }, null, 2));
+		else {
+			console.error(red(`\n❌ Error: ${error.message}`));
+			if (error.details) console.error(`  Details: ${typeof error.details === "string" ? error.details : JSON.stringify(error.details)}`);
+		}
+	},
+	failWithJson: (error) => {
+		if (jsonMode) console.log(JSON.stringify({ error }, null, 2));
+		else {
+			console.error(red(`\n❌ Error: ${error.message}`));
+			if (error.details) console.error(`  Details: ${typeof error.details === "string" ? error.details : JSON.stringify(error.details)}`);
+		}
+		process.exit(1);
+	}
+};
+/**
+* Enable or disable JSON mode.
+* When enabled, `output.log` is redirected to stderr.
+*
+* @param enabled - Whether to enable JSON mode
+*/
+function setJsonMode(enabled) {
+	jsonMode = enabled;
+}
+/**
+* Create indentation string.
+*
+* @param spaces - Number of spaces (default: 2)
+* @returns Indentation string
+*
+* @example indent() // "  "
+* @example indent(4) // "    "
+*/
+function indent(spaces = DEFAULT_INDENT) {
+	return " ".repeat(spaces);
+}
+/**
+* Print a section header with title and divider.
+* Silent in JSON mode.
+*
+* @param title - The header title
+*
+* @example header("UCD Store Information")
+* // Output:
+* //   UCD Store Information
+* //   ────────────────────────────────────────
+*/
+function header(title) {
+	if (jsonMode) return;
+	const ind = indent();
+	console.log(`\n${ind}${bold$1(title)}`);
+	console.log(`${ind}${dim$1("─".repeat(DEFAULT_DIVIDER_LENGTH))}\n`);
+}
+/**
+* Print a key-value pair with aligned formatting.
+* Silent in JSON mode.
+*
+* @param key - The label/key
+* @param value - The value to display
+* @param options - Formatting options
+*
+* @example keyValue("Store Path", "/path/to/store", { valueColor: green })
+* // Output:   Store Path:      /path/to/store
+*/
+function keyValue(key, value, options = {}) {
+	if (jsonMode) return;
+	const { indent: indentSpaces = DEFAULT_INDENT, labelWidth = DEFAULT_LABEL_WIDTH, valueColor } = options;
+	const label = `${key}:`.padEnd(labelWidth);
+	const displayValue = valueColor ? valueColor(value) : value;
+	console.log(`${indent(indentSpaces)}${bold$1(label)} ${displayValue}`);
+}
+/**
+* Print a list of items with optional truncation.
+* Silent in JSON mode.
+*
+* @param items - Array of items to display
+* @param options - List formatting options
+*
+* @example list(["file1.txt", "file2.txt"], { prefix: "+", itemColor: green })
+* // Output:
+* //   + file1.txt
+* //   + file2.txt
+*
+* @example list(manyFiles, { maxItems: 5 })
+* // Output:
+* //   • file1.txt
+* //   • file2.txt
+* //   ... and 20 more
+*/
+function list(items, options = {}) {
+	if (jsonMode) return;
+	const { prefix = "•", maxItems = DEFAULT_MAX_LIST_ITEMS, indent: indentSpaces = DEFAULT_INDENT, itemColor } = options;
+	const ind = indent(indentSpaces);
+	const displayItems = items.slice(0, maxItems);
+	for (const item of displayItems) {
+		const displayItem = itemColor ? itemColor(typeof item === "string" ? item : item.filePath) : typeof item === "string" ? item : item.filePath;
+		console.log(`${ind}${prefix} ${displayItem}`);
+	}
+	if (items.length > maxItems) console.log(`${ind}${dim$1(`... and ${items.length - maxItems} more`)}`);
+}
+/**
+* Print a blank line.
+* Silent in JSON mode.
+*/
+function blankLine() {
+	if (jsonMode) return;
+	console.log("");
+}
+/**
+* Format a duration in milliseconds to a human-readable string.
+*
+* @param ms - Duration in milliseconds
+* @returns Formatted duration string (e.g., "2.35s", "150ms")
+*
+* @example formatDuration(2350) // "2.35s"
+* @example formatDuration(150) // "150ms"
+*/
+function formatDuration(ms) {
+	if (ms < 1e3) return `${ms}ms`;
+	return `${(ms / 1e3).toFixed(2)}s`;
+}
+/**
+* Format bytes to human-readable size.
+*
+* @param bytes - Size in bytes
+* @returns Formatted size string (e.g., "1.5 MB", "256 KB")
+*/
+function formatBytes(bytes) {
+	if (bytes === 0) return "0 B";
+	const units = [
+		"B",
+		"KB",
+		"MB",
+		"GB",
+		"TB"
+	];
+	const k = 1024;
+	const i = Math.floor(Math.log(bytes) / Math.log(k));
+	return `${Number.parseFloat((bytes / k ** i).toFixed(2))} ${units[i]}`;
+}
+
+//#endregion
+//#region src/errors.ts
+var CLIError = class extends Error {
+	title;
+	details;
+	constructor(message, options) {
+		super(message);
+		this.name = "CLIError";
+		this.title = options?.title ?? "Error";
+		this.details = options?.details ?? [];
+	}
+	toPrettyMessage() {
+		output.fail(this.message, { details: this.details });
+	}
+};
+var StoreDirIsRequiredError = class extends CLIError {
+	constructor() {
+		super("--store-dir is required. Please specify the directory where the UCD files should be stored.", { title: "Store Error" });
+		this.name = "StoreDirIsRequiredError";
+	}
+};
+var RemoteNotSupportedError = class extends CLIError {
+	constructor() {
+		super("The --remote flag is not supported for this command.", { title: "Store Error" });
+		this.name = "RemoteNotSupportedError";
+	}
+};
+var StoreConfigurationError = class extends CLIError {
+	constructor(message) {
+		super(message, { title: "Store Error" });
+		this.name = "StoreConfigurationError";
+	}
+};
+var CLIStoreError = class extends CLIError {
+	constructor(error) {
+		super(error.message, { title: "Store Error" });
+		this.name = "CLIStoreError";
+	}
+};
+
+//#endregion
+//#region src/cli-utils.ts
+const SUPPORTED_COMMANDS = new Set([
+	"codegen",
+	"store",
+	"files",
+	"lockfile"
+]);
+/**
+* Resolves the CLI command based on the provided arguments.
+*
+* If the `version` flag is present, it returns the "version" command.
+* Otherwise, it checks if the first positional argument (`flags._[0]`)
+* is a supported command. If it is, it returns that command.
+* If no supported command is found, it defaults to the "help" command.
+*
+* @param {Arguments} flags - The parsed arguments from the command line.
+* @returns {CLICommand} The resolved CLI command.
+*/
+function resolveCommand(flags) {
+	if (flags.version) return "version";
+	const cmd = flags._[0];
+	if (SUPPORTED_COMMANDS.has(cmd)) return cmd;
+	return "help";
+}
+function printHelp({ commandName, headline, usage, tables, description }) {
+	const isTinyTerminal = (process$1.stdout.columns || 80) < 60;
+	const indent = "  ";
+	const linebreak = () => "";
+	const table = (rows, { padding }) => {
+		let raw = "";
+		for (const [command, help] of rows) if (isTinyTerminal) raw += `${indent}${indent}${bold(command)}\n${indent}${indent}${indent}${dim(help)}\n`;
+		else {
+			const paddedCommand = command.padEnd(padding);
+			raw += `${indent}${indent}${bold(paddedCommand)}  ${dim(help)}\n`;
+		}
+		return raw.slice(0, -1);
+	};
+	const message = [];
+	if (headline) message.push(`\n${indent}${bgGreen(black(` ${commandName} `))} ${green(`v${version ?? "0.0.0"}`)}`, `${indent}${dim(headline)}`);
+	if (usage) message.push(linebreak(), `${indent}${bold("USAGE")}`, `${indent}${indent}${green(commandName)} ${usage}`);
+	if (description) message.push(linebreak(), `${indent}${bold("DESCRIPTION")}`, `${indent}${indent}${description}`);
+	if (tables) {
+		function calculateTablePadding(rows) {
+			const maxLength = rows.reduce((val, [first]) => Math.max(val, first.length), 0);
+			return Math.min(maxLength, 30) + 2;
+		}
+		const tableEntries = Object.entries(tables);
+		for (const [tableTitle, tableRows] of tableEntries) {
+			const padding = calculateTablePadding(tableRows);
+			message.push(linebreak(), `${indent}${bold(tableTitle.toUpperCase())}`, table(tableRows, { padding }));
+		}
+	}
+	message.push(linebreak(), `${indent}${dim(`Run with --help for more information on specific commands.`)}`);
+	console.log(`${message.join("\n")}\n`);
+}
+/**
+* Runs a command based on the provided CLI command and flags.
+*
+* @param {CLICommand} cmd - The CLI command to execute.
+* @param {Arguments} flags - The flags passed to the command.
+* @returns {Promise<void>} A promise that resolves when the command has finished executing.
+* @throws An error if the command is not found.
+*/
+async function runCommand(cmd, flags) {
+	switch (cmd) {
+		case "help":
+			printHelp({
+				commandName: "ucd",
+				headline: "A CLI for working with the Unicode Character Database (UCD).",
+				usage: "[command] [...flags]",
+				tables: {
+					"Commands": [
+						["store", "Manage UCD stores (init, mirror, sync, etc.)."],
+						["codegen", "Generate TypeScript code from UCD data."],
+						["files", "List and get files from the UCD API."],
+						["lockfile", "Inspect and validate UCD store lockfiles."]
+					],
+					"Global Flags": [["--version", "Show the version number and exit."], ["--help", "Show this help message."]]
+				}
+			});
+			break;
+		case "version":
+			console.log(`  ${bgGreen(black(` ucd `))} ${green(`v${version ?? "x.y.z"}`)}`);
+			break;
+		case "codegen": {
+			const { runCodegenRoot } = await import("./root-CfALAyOQ.mjs");
+			await runCodegenRoot(flags._[1]?.toString() ?? "", { flags });
+			break;
+		}
+		case "store": {
+			const { runStoreRoot } = await import("./root-C_Ycy7kI.mjs");
+			await runStoreRoot(flags._[1]?.toString() ?? "", { flags });
+			break;
+		}
+		case "files": {
+			const { runFilesRoot } = await import("./root-DXVHyPa6.mjs");
+			await runFilesRoot(flags._[1]?.toString() ?? "", { flags });
+			break;
+		}
+		case "lockfile": {
+			const { runLockfileRoot } = await import("./root-BnOeYqGP.mjs");
+			await runLockfileRoot(flags._[1]?.toString() ?? "", { flags });
+			break;
+		}
+		default: throw new Error(`Error running ${cmd} -- no command found.`);
+	}
+}
+function parseFlags(args) {
+	return yargs(args, {
+		configuration: { "parse-positional-numbers": false },
+		default: { force: false },
+		boolean: [
+			"force",
+			"help",
+			"h",
+			"dry-run",
+			"json"
+		],
+		string: [
+			"output-dir",
+			"base-url",
+			"output",
+			"store-dir"
+		],
+		array: ["include", "exclude"]
+	});
+}
+async function runCLI(args) {
+	const flags = parseFlags(args);
+	process$1.title = "ucd-cli";
+	setJsonMode(!!flags.json);
+	try {
+		await runCommand(resolveCommand(flags), flags);
+	} catch (err) {
+		if (err instanceof CLIError) {
+			err.toPrettyMessage();
+			if (process$1.env.NODE_ENV !== "test" && !process$1.env.VITEST) process$1.exit(1);
+			return;
+		}
+		let message = "Unknown error";
+		if (err instanceof Error) message = err.message;
+		else if (typeof err === "string") message = err;
+		output.fail(message, { bugReport: true });
+		if (process$1.env.NODE_ENV !== "test" && !process$1.env.VITEST) process$1.exit(1);
+	} finally {
+		setJsonMode(false);
+	}
+}
+
+//#endregion
+//#region src/cli.ts
+runCLI(process$1.argv.slice(2));
+
+//#endregion
+export { output as _, StoreConfigurationError as a, bold$1 as c, formatBytes as d, formatDuration as f, list as g, keyValue as h, RemoteNotSupportedError as i, cyan as l, header as m, CLIError as n, StoreDirIsRequiredError as o, green$1 as p, CLIStoreError as r, blankLine as s, printHelp as t, dim$1 as u, red as v, yellow as y };

package/dist/{fields-CbRX6M6H.js → fields-BvLDPLGg.mjs}

@@ -1,4 +1,4 @@
-import { t as printHelp } from "./cli-utils-dAbyq59_.js";
+import { _ as output, n as CLIError, t as printHelp } from "./cli.mjs";
 import process from "node:process";
 import { existsSync } from "node:fs";
 import { mkdir, readdir, stat, writeFile } from "node:fs/promises";
@@ -57,7 +57,7 @@ async function writeBundledFile(version, results, bundleTemplate, outputDir) {
 	if (!bundlePath.endsWith(".ts")) bundlePath += ".ts";
 	await mkdir(path.dirname(bundlePath), { recursive: true });
 	await writeFile(bundlePath, bundledCode, "utf-8");
-	console.log(`Generated bundled fields for Unicode ${version} in ${bundlePath}`);
+	output.success(`Generated bundled fields for Unicode ${version} in ${bundlePath}`);
 }
 async function runFieldCodegen({ inputPath, flags }) {
 	if (flags?.help || flags?.h) {
@@ -75,19 +75,10 @@ async function runFieldCodegen({ inputPath, flags }) {
 		return;
 	}
 	const openaiKey = flags.openaiKey || process.env.OPENAI_API_KEY;
-	if (!openaiKey) {
-		console.error("No OpenAI API key provided. Please provide an OpenAI API key.");
-		return;
-	}
-	if (inputPath == null) {
-		console.error("No input path provided. Please provide an input path.");
-		return;
-	}
+	if (!openaiKey) throw new CLIError("No OpenAI API key provided.", { details: ["Please provide an OpenAI API key via --openai-key flag or OPENAI_API_KEY environment variable."] });
+	if (inputPath == null) throw new CLIError("No input path provided.", { details: ["Please provide an input path as the first argument."] });
 	const resolvedInputPath = path.resolve(inputPath);
-	if (!existsSync(resolvedInputPath)) {
-		console.error(`invalid input path: ${inputPath}. Please provide a valid input path.`);
-		return;
-	}
+	if (!existsSync(resolvedInputPath)) throw new CLIError(`Invalid input path: ${inputPath}`, { details: ["The specified input path does not exist. Please provide a valid input path."] });
 	const shouldBundle = typeof flags.bundle === "string" || flags.bundle === true;
 	const bundleTemplate = typeof flags.bundle === "string" ? flags.bundle : "index.ts";
 	let outputDir = flags.outputDir;
@@ -95,7 +86,7 @@ async function runFieldCodegen({ inputPath, flags }) {
 	else outputDir = path.join(path.dirname(resolvedInputPath), ".codegen");
 	if (outputDir) await mkdir(outputDir, { recursive: true });
 	const filesWithVersion = await scanFiles(inputPath);
-	console.log(`Found ${filesWithVersion.length} files to process.`);
+	output.info(`Found ${filesWithVersion.length} files to process.`);
 	const results = await runSchemagen({
 		files: filesWithVersion,
 		openaiKey
@@ -104,7 +95,7 @@ async function runFieldCodegen({ inputPath, flags }) {
 	if (!shouldBundle) {
 		writePromises.push(...results.map((result) => writeFile(path.join(outputDir, `${result.fileName}.ts`), result.code, "utf-8")));
 		await Promise.all(writePromises);
-		console.log(`Generated fields for ${results.length} files in ${outputDir}`);
+		output.success(`Generated fields for ${results.length} files in ${outputDir}`);
 		return;
 	}
 	const resultsByVersion = /* @__PURE__ */ new Map();