@kubb/cli 4.11.3 → 4.12.1

package/dist/generate-BfIvo80v.js

@@ -0,0 +1,1249 @@
+import { t as version } from "./package-B1rQiz1w.js";
+import { defineCommand, showUsage } from "citty";
+import path, { relative, resolve } from "node:path";
+import * as process$2 from "node:process";
+import process$1 from "node:process";
+import * as clack from "@clack/prompts";
+import { LogLevel, PromiseManager, defineLogger, isInputPath, safeBuild, setup } from "@kubb/core";
+import { AsyncEventEmitter, isPromise } from "@kubb/core/utils";
+import getLatestVersion from "latest-version";
+import pc from "picocolors";
+import { lt } from "semver";
+import { execa } from "execa";
+import gradientString from "gradient-string";
+import seedrandom from "seedrandom";
+import { Writable } from "node:stream";
+import { write } from "@kubb/core/fs";
+import { parseArgsStringToArgv } from "string-argv";
+import { cosmiconfig } from "cosmiconfig";
+import { createJiti } from "jiti";
+
+//#region src/utils/parseHrtimeToSeconds.ts
+function parseHrtimeToSeconds(hrtime) {
+	return (hrtime[0] + hrtime[1] / 1e9).toFixed(3);
+}
+
+//#endregion
+//#region src/utils/randomColour.ts
+function randomColour(text) {
+	if (!text) return "white";
+	const defaultColours = [
+		"black",
+		"red",
+		"green",
+		"yellow",
+		"blue",
+		"red",
+		"green",
+		"magenta",
+		"cyan",
+		"gray"
+	];
+	const random = seedrandom(text);
+	return defaultColours.at(Math.floor(random() * defaultColours.length)) || "white";
+}
+function randomCliColour(text) {
+	if (!text) return "";
+	const fn = pc[randomColour(text)];
+	return fn ? fn(text) : text;
+}
+
+//#endregion
+//#region src/utils/getSummary.ts
+function getSummary({ failedPlugins, filesCreated, status, hrStart, config, pluginTimings }) {
+	const elapsedSeconds = parseHrtimeToSeconds(process.hrtime(hrStart));
+	const pluginsCount = config.plugins?.length || 0;
+	const successCount = pluginsCount - failedPlugins.size;
+	const meta = {
+		plugins: status === "success" ? `${pc.green(`${successCount} successful`)}, ${pluginsCount} total` : `${pc.green(`${successCount} successful`)}, ${pc.red(`${failedPlugins.size} failed`)}, ${pluginsCount} total`,
+		pluginsFailed: status === "failed" ? [...failedPlugins]?.map(({ plugin }) => randomCliColour(plugin.name))?.join(", ") : void 0,
+		filesCreated,
+		time: `${elapsedSeconds}s`,
+		output: path.isAbsolute(config.root) ? path.resolve(config.root, config.output.path) : config.root
+	};
+	const labels = {
+		plugins: "Plugins:",
+		failed: "Failed:",
+		generated: "Generated:",
+		pluginTimings: "Plugin Timings:",
+		output: "Output:"
+	};
+	const maxLength = Math.max(0, ...[...Object.values(labels), ...pluginTimings ? Array.from(pluginTimings.keys()) : []].map((s) => s.length));
+	const summaryLines = [];
+	summaryLines.push(`${labels.plugins.padEnd(maxLength + 2)} ${meta.plugins}`);
+	if (meta.pluginsFailed) summaryLines.push(`${labels.failed.padEnd(maxLength + 2)} ${meta.pluginsFailed}`);
+	summaryLines.push(`${labels.generated.padEnd(maxLength + 2)} ${meta.filesCreated} files in ${meta.time}`);
+	if (pluginTimings && pluginTimings.size > 0) {
+		const TIME_SCALE_DIVISOR = 100;
+		const MAX_BAR_LENGTH = 10;
+		const sortedTimings = Array.from(pluginTimings.entries()).sort((a, b) => b[1] - a[1]);
+		if (sortedTimings.length > 0) {
+			summaryLines.push(`${labels.pluginTimings}`);
+			sortedTimings.forEach(([name, time]) => {
+				const timeStr = time >= 1e3 ? `${(time / 1e3).toFixed(2)}s` : `${Math.round(time)}ms`;
+				const barLength = Math.min(Math.ceil(time / TIME_SCALE_DIVISOR), MAX_BAR_LENGTH);
+				const bar = pc.dim("█".repeat(barLength));
+				summaryLines.push(`${pc.dim("•")} ${name.padEnd(maxLength + 1)}${bar} ${timeStr}`);
+			});
+		}
+	}
+	summaryLines.push(`${labels.output.padEnd(maxLength + 2)} ${meta.output}`);
+	return summaryLines;
+}
+
+//#endregion
+//#region src/utils/Writables.ts
+var ClackWritable = class extends Writable {
+	taskLog;
+	constructor(taskLog, opts) {
+		super(opts);
+		this.taskLog = taskLog;
+	}
+	_write(chunk, _encoding, callback) {
+		this.taskLog.message(`${pc.dim(chunk?.toString())}`);
+		callback();
+	}
+};
+
+//#endregion
+//#region src/loggers/clackLogger.ts
+/**
+* Clack adapter for local TTY environments
+* Provides a beautiful CLI UI with flat structure inspired by Claude's CLI patterns
+*/
+const clackLogger = defineLogger({
+	name: "clack",
+	install(context, options) {
+		const logLevel = options?.logLevel || LogLevel.info;
+		const activeProgress = /* @__PURE__ */ new Map();
+		const spinner = clack.spinner();
+		let isSpinning = false;
+		function getMessage(message) {
+			if (logLevel >= LogLevel.verbose) {
+				const timestamp = (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", {
+					hour12: false,
+					hour: "2-digit",
+					minute: "2-digit",
+					second: "2-digit"
+				});
+				return [pc.dim(`[${timestamp}]`), message].join(" ");
+			}
+			return message;
+		}
+		function startSpinner(text) {
+			spinner.start(text);
+			isSpinning = true;
+		}
+		function stopSpinner(text) {
+			spinner.stop(text);
+			isSpinning = false;
+		}
+		context.on("info", (message, info = "") => {
+			if (logLevel <= LogLevel.silent) return;
+			const text = getMessage([
+				pc.blue("ℹ"),
+				message,
+				pc.dim(info)
+			].join(" "));
+			if (isSpinning) spinner.message(text);
+			else clack.log.info(text);
+		});
+		context.on("success", (message, info = "") => {
+			if (logLevel <= LogLevel.silent) return;
+			const text = getMessage([
+				pc.blue("✓"),
+				message,
+				logLevel >= LogLevel.info ? pc.dim(info) : void 0
+			].filter(Boolean).join(" "));
+			if (isSpinning) stopSpinner(text);
+			else clack.log.success(text);
+		});
+		context.on("warn", (message, info) => {
+			if (logLevel < LogLevel.warn) return;
+			const text = getMessage([
+				pc.yellow("⚠"),
+				message,
+				logLevel >= LogLevel.info ? pc.dim(info) : void 0
+			].filter(Boolean).join(" "));
+			clack.log.warn(text);
+		});
+		context.on("error", (error) => {
+			const caused = error.cause;
+			const text = [pc.red("✗"), error.message].join(" ");
+			if (isSpinning) stopSpinner(getMessage(text));
+			else clack.log.error(getMessage(text));
+			if (logLevel >= LogLevel.debug && error.stack) {
+				const frames = error.stack.split("\n").slice(1, 4);
+				for (const frame of frames) clack.log.message(getMessage(pc.dim(frame.trim())));
+				if (caused?.stack) {
+					clack.log.message(pc.dim(`└─ caused by ${caused.message}`));
+					const frames$1 = caused.stack.split("\n").slice(1, 4);
+					for (const frame of frames$1) clack.log.message(getMessage(`    ${pc.dim(frame.trim())}`));
+				}
+			}
+		});
+		context.on("version:new", (version$1, latestVersion) => {
+			if (logLevel <= LogLevel.silent) return;
+			clack.box(`\`v${version$1}\` → \`v${latestVersion}\`
+Run \`npm install -g @kubb/cli\` to update`, "Update available for `Kubb`", {
+				width: "auto",
+				formatBorder: pc.yellow,
+				rounded: true,
+				withGuide: false,
+				contentAlign: "center",
+				titleAlign: "center"
+			});
+		});
+		context.on("lifecycle:start", (version$1) => {
+			console.log(gradientString([
+				"#F58517",
+				"#F5A217",
+				"#F55A17"
+			])(`Kubb ${version$1} 🧩`));
+		});
+		context.on("config:start", () => {
+			if (logLevel <= LogLevel.silent) return;
+			const text = getMessage("Configuration started");
+			clack.intro(text);
+			startSpinner(getMessage("Configuration loading"));
+		});
+		context.on("config:end", () => {
+			if (logLevel <= LogLevel.silent) return;
+			const text = getMessage("Configuration completed");
+			clack.outro(text);
+		});
+		context.on("generation:start", (config) => {
+			const text = getMessage(["Generation started", config.name ? `for ${pc.dim(config.name)}` : void 0].filter(Boolean).join(" "));
+			clack.intro(text);
+		});
+		context.on("plugin:start", (plugin) => {
+			if (logLevel <= LogLevel.silent) return;
+			stopSpinner();
+			const progressBar = clack.progress({
+				style: "block",
+				max: 100,
+				size: 30
+			});
+			const text = getMessage(`Generating ${pc.bold(plugin.name)}`);
+			progressBar.start(text);
+			const interval = setInterval(() => {
+				progressBar.advance();
+			}, 50);
+			activeProgress.set(plugin.name, {
+				progressBar,
+				interval
+			});
+		});
+		context.on("plugin:end", (plugin, duration) => {
+			stopSpinner();
+			const active = activeProgress.get(plugin.name);
+			if (!active || logLevel === LogLevel.silent) return;
+			clearInterval(active.interval);
+			const durationStr = duration >= 1e3 ? `${(duration / 1e3).toFixed(2)}s` : `${duration}ms`;
+			const text = getMessage(`${pc.bold(plugin.name)} completed in ${pc.green(durationStr)}`);
+			active.progressBar.stop(text);
+			activeProgress.delete(plugin.name);
+		});
+		context.on("files:processing:start", (files) => {
+			if (logLevel <= LogLevel.silent) return;
+			stopSpinner();
+			const text = getMessage(`Writing ${files.length} files`);
+			const progressBar = clack.progress({
+				style: "block",
+				max: files.length,
+				size: 30
+			});
+			context.emit("info", text);
+			progressBar.start(text);
+			activeProgress.set("files", { progressBar });
+		});
+		context.on("file:processing:update", ({ file, config }) => {
+			if (logLevel <= LogLevel.silent) return;
+			stopSpinner();
+			const text = `Writing ${relative(config.root, file.path)}`;
+			const active = activeProgress.get("files");
+			if (!active) return;
+			active.progressBar.advance(void 0, text);
+		});
+		context.on("files:processing:end", () => {
+			if (logLevel <= LogLevel.silent) return;
+			stopSpinner();
+			const text = getMessage("Files written successfully");
+			const active = activeProgress.get("files");
+			if (!active) return;
+			active.progressBar.stop(text);
+			activeProgress.delete("files");
+		});
+		context.on("generation:end", (config) => {
+			const text = getMessage(config.name ? `Generation completed for ${pc.dim(config.name)}` : "Generation completed");
+			clack.outro(text);
+		});
+		context.on("hook:execute", async ({ command: command$1, args }, cb) => {
+			if (logLevel <= LogLevel.silent) {
+				try {
+					const result = await execa(command$1, args, {
+						detached: true,
+						stripFinalNewline: true
+					});
+					await context.emit("debug", {
+						date: /* @__PURE__ */ new Date(),
+						logs: [result.stdout]
+					});
+					cb();
+				} catch (err) {
+					const error = /* @__PURE__ */ new Error("Hook execute failed");
+					error.cause = err;
+					await context.emit("debug", {
+						date: /* @__PURE__ */ new Date(),
+						logs: [err.stdout]
+					});
+					await context.emit("error", error);
+				}
+				return;
+			}
+			const writable = new ClackWritable(clack.taskLog({ title: getMessage(["Executing hook", logLevel >= LogLevel.info ? pc.dim(`${command$1} ${args?.join(" ")}`) : void 0].filter(Boolean).join(" ")) }));
+			try {
+				const result = await execa(command$1, args, {
+					detached: true,
+					stdout: ["pipe", writable],
+					stripFinalNewline: true
+				});
+				await context.emit("debug", {
+					date: /* @__PURE__ */ new Date(),
+					logs: [result.stdout]
+				});
+				cb();
+			} catch (err) {
+				const error = /* @__PURE__ */ new Error("Hook execute failed");
+				error.cause = err;
+				await context.emit("debug", {
+					date: /* @__PURE__ */ new Date(),
+					logs: [err.stdout]
+				});
+				await context.emit("error", error);
+			}
+		});
+		context.on("format:start", () => {
+			if (logLevel <= LogLevel.silent) return;
+			const text = getMessage("Format started");
+			clack.intro(text);
+		});
+		context.on("format:end", () => {
+			if (logLevel <= LogLevel.silent) return;
+			const text = getMessage("Format completed");
+			clack.outro(text);
+		});
+		context.on("lint:start", () => {
+			if (logLevel <= LogLevel.silent) return;
+			const text = getMessage("Lint started");
+			clack.intro(text);
+		});
+		context.on("lint:end", () => {
+			if (logLevel <= LogLevel.silent) return;
+			const text = getMessage("Lint completed");
+			clack.outro(text);
+		});
+		context.on("hook:start", (command$1) => {
+			if (logLevel <= LogLevel.silent) return;
+			const text = getMessage(`Hook ${pc.dim(command$1)} started`);
+			clack.intro(text);
+		});
+		context.on("hook:end", (command$1) => {
+			if (logLevel <= LogLevel.silent) return;
+			const text = getMessage(`Hook ${pc.dim(command$1)} completed`);
+			clack.outro(text);
+		});
+		context.on("generation:summary", (config, { pluginTimings, failedPlugins, filesCreated, status, hrStart }) => {
+			const summary = getSummary({
+				failedPlugins,
+				filesCreated,
+				config,
+				status,
+				hrStart,
+				pluginTimings: logLevel >= LogLevel.verbose ? pluginTimings : void 0
+			});
+			const title = config.name || "";
+			summary.unshift("\n");
+			summary.push("\n");
+			if (status === "success") {
+				clack.box(summary.join("\n"), getMessage(title), {
+					width: "auto",
+					formatBorder: pc.green,
+					rounded: true,
+					withGuide: false,
+					contentAlign: "left",
+					titleAlign: "center"
+				});
+				return;
+			}
+			clack.box(summary.join("\n"), getMessage(title), {
+				width: "auto",
+				formatBorder: pc.red,
+				rounded: true,
+				withGuide: false,
+				contentAlign: "left",
+				titleAlign: "center"
+			});
+		});
+		context.on("lifecycle:end", () => {
+			for (const [_key, active] of activeProgress) {
+				if (active.interval) clearInterval(active.interval);
+				active.progressBar?.stop();
+			}
+			activeProgress.clear();
+		});
+	}
+});
+
+//#endregion
+//#region src/loggers/envDetection.ts
+/**
+* Check if running in GitHub Actions environment
+*/
+function isGitHubActions() {
+	return !!process.env.GITHUB_ACTIONS;
+}
+/**
+* Check if running in any CI environment
+*/
+function isCIEnvironment() {
+	return !!(process.env.CI || process.env.GITHUB_ACTIONS || process.env.GITLAB_CI || process.env.CIRCLECI || process.env.TRAVIS || process.env.JENKINS_URL || process.env.BUILDKITE);
+}
+/**
+* Check if TTY is available for interactive output
+*/
+function canUseTTY() {
+	return !!process.stdout.isTTY && !isCIEnvironment();
+}
+
+//#endregion
+//#region src/loggers/fileSystemLogger.ts
+/**
+* FileSystem logger for debug log persistence
+* Captures debug and verbose events and writes them to files in .kubb directory
+*
+* Note: Logs are written on lifecycle:end or process exit. If the process crashes
+* before these events, some cached logs may be lost.
+*/
+const fileSystemLogger = defineLogger({
+	name: "filesystem",
+	install(context) {
+		const cachedLogs = /* @__PURE__ */ new Set();
+		const startDate = Date.now();
+		async function writeLogs() {
+			if (cachedLogs.size === 0) return;
+			const files = {};
+			for (const log of cachedLogs) {
+				const fileName = resolve(process.cwd(), ".kubb", log.fileName || `kubb-${startDate}.log`);
+				if (!files[fileName]) files[fileName] = [];
+				if (log.logs.length > 0) {
+					const timestamp = log.date.toLocaleString();
+					files[fileName].push(`[${timestamp}]\n${log.logs.join("\n")}`);
+				}
+			}
+			await Promise.all(Object.entries(files).map(async ([fileName, logs]) => {
+				return write(fileName, logs.join("\n\n"));
+			}));
+			cachedLogs.clear();
+		}
+		context.on("debug", (message) => {
+			cachedLogs.add({
+				date: /* @__PURE__ */ new Date(),
+				logs: message.logs,
+				fileName: void 0
+			});
+		});
+		context.on("lifecycle:end", async () => {
+			await writeLogs();
+		});
+		const exitHandler = () => {
+			if (cachedLogs.size > 0) writeLogs().catch(() => {});
+		};
+		process.once("exit", exitHandler);
+		process.once("SIGINT", exitHandler);
+		process.once("SIGTERM", exitHandler);
+	}
+});
+
+//#endregion
+//#region src/loggers/githubActionsLogger.ts
+/**
+* GitHub Actions adapter for CI environments
+* Uses ::group:: and ::endgroup:: annotations for collapsible sections
+*/
+const githubActionsLogger = defineLogger({
+	name: "github-actions",
+	install(context, options) {
+		const logLevel = options?.logLevel || LogLevel.info;
+		let currentConfigs = [];
+		function getMessage(message) {
+			if (logLevel >= LogLevel.verbose) {
+				const timestamp = (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", {
+					hour12: false,
+					hour: "2-digit",
+					minute: "2-digit",
+					second: "2-digit"
+				});
+				return [pc.dim(`[${timestamp}]`), message].join(" ");
+			}
+			return message;
+		}
+		function openGroup(name) {
+			console.log(`::group::${name}`);
+		}
+		function closeGroup(_name) {
+			console.log("::endgroup::");
+		}
+		context.on("info", (message, info = "") => {
+			if (logLevel <= LogLevel.silent) return;
+			const text = getMessage([
+				pc.blue("ℹ"),
+				message,
+				pc.dim(info)
+			].join(" "));
+			console.log(text);
+		});
+		context.on("success", (message, info = "") => {
+			if (logLevel <= LogLevel.silent) return;
+			const text = getMessage([
+				pc.blue("✓"),
+				message,
+				logLevel >= LogLevel.info ? pc.dim(info) : void 0
+			].filter(Boolean).join(" "));
+			console.log(text);
+		});
+		context.on("warn", (message, info = "") => {
+			if (logLevel <= LogLevel.silent) return;
+			const text = getMessage([
+				pc.yellow("⚠"),
+				message,
+				logLevel >= LogLevel.info ? pc.dim(info) : void 0
+			].filter(Boolean).join(" "));
+			console.warn(`::warning::${text}`);
+		});
+		context.on("error", (error) => {
+			if (logLevel <= LogLevel.silent) return;
+			const message = error.message || String(error);
+			console.error(`::error::${message}`);
+		});
+		context.on("lifecycle:start", (version$1) => {
+			console.log(pc.yellow(`Kubb ${version$1} 🧩`));
+		});
+		context.on("config:start", () => {
+			if (logLevel <= LogLevel.silent) return;
+			const text = getMessage("Configuration started");
+			openGroup("Configuration");
+			console.log(text);
+		});
+		context.on("config:end", (configs) => {
+			currentConfigs = configs;
+			if (logLevel <= LogLevel.silent) return;
+			const text = getMessage("Configuration completed");
+			console.log(text);
+			closeGroup("Configuration");
+		});
+		context.on("generation:start", (config) => {
+			const text = config.name ? `Generation for ${pc.bold(config.name)}` : "Generation";
+			if (currentConfigs.length > 1) openGroup(text);
+			if (currentConfigs.length === 1) console.log(getMessage(text));
+		});
+		context.on("plugin:start", (plugin) => {
+			if (logLevel <= LogLevel.silent) return;
+			const text = getMessage(`Generating ${pc.bold(plugin.name)}`);
+			if (currentConfigs.length === 1) openGroup(`Plugin: ${plugin.name}`);
+			console.log(text);
+		});
+		context.on("plugin:end", (plugin, duration) => {
+			if (logLevel <= LogLevel.silent) return;
+			const durationStr = duration >= 1e3 ? `${(duration / 1e3).toFixed(2)}s` : `${duration}ms`;
+			const text = getMessage(`${pc.bold(plugin.name)} completed in ${pc.green(durationStr)}`);
+			console.log(text);
+			if (currentConfigs.length > 1) console.log(" ");
+			if (currentConfigs.length === 1) closeGroup(`Plugin: ${plugin.name}`);
+		});
+		context.on("files:processing:start", (files) => {
+			if (logLevel <= LogLevel.silent) return;
+			if (currentConfigs.length === 1) openGroup("File Generation");
+			const text = getMessage(`Writing ${files.length} files`);
+			console.log(text);
+		});
+		context.on("files:processing:end", () => {
+			if (logLevel <= LogLevel.silent) return;
+			const text = getMessage("Files written successfully");
+			console.log(text);
+			if (currentConfigs.length === 1) closeGroup("File Generation");
+		});
+		context.on("generation:end", (config) => {
+			const text = getMessage(config.name ? `${pc.blue("✓")} Generation completed for ${pc.dim(config.name)}` : `${pc.blue("✓")} Generation completed`);
+			console.log(text);
+		});
+		context.on("hook:execute", async ({ command: command$1, args }, cb) => {
+			try {
+				const result = await execa(command$1, args, {
+					detached: true,
+					stripFinalNewline: true
+				});
+				await context.emit("debug", {
+					date: /* @__PURE__ */ new Date(),
+					logs: [result.stdout]
+				});
+				console.log(result.stdout);
+				cb();
+			} catch (err) {
+				const error = /* @__PURE__ */ new Error("Hook execute failed");
+				error.cause = err;
+				await context.emit("debug", {
+					date: /* @__PURE__ */ new Date(),
+					logs: [err.stdout]
+				});
+				await context.emit("error", error);
+			}
+		});
+		context.on("format:start", () => {
+			if (logLevel <= LogLevel.silent) return;
+			const text = getMessage("Format started");
+			if (currentConfigs.length === 1) openGroup("Formatting");
+			console.log(text);
+		});
+		context.on("format:end", () => {
+			if (logLevel <= LogLevel.silent) return;
+			const text = getMessage("Format completed");
+			console.log(text);
+			if (currentConfigs.length === 1) closeGroup("Formatting");
+		});
+		context.on("lint:start", () => {
+			if (logLevel <= LogLevel.silent) return;
+			const text = getMessage("Lint started");
+			if (currentConfigs.length === 1) openGroup("Linting");
+			console.log(text);
+		});
+		context.on("lint:end", () => {
+			if (logLevel <= LogLevel.silent) return;
+			const text = getMessage("Lint completed");
+			console.log(text);
+			if (currentConfigs.length === 1) closeGroup("Linting");
+		});
+		context.on("hook:start", (command$1) => {
+			if (logLevel <= LogLevel.silent) return;
+			const text = getMessage(`Hook ${pc.dim(command$1)} started`);
+			if (currentConfigs.length === 1) openGroup(`Hook ${command$1}`);
+			console.log(text);
+		});
+		context.on("hook:end", (command$1) => {
+			if (logLevel <= LogLevel.silent) return;
+			const text = getMessage(`Hook ${pc.dim(command$1)} completed`);
+			console.log(text);
+			if (currentConfigs.length === 1) closeGroup(`Hook ${command$1}`);
+		});
+		context.on("generation:summary", (config, { status, failedPlugins }) => {
+			const pluginsCount = config.plugins?.length || 0;
+			const successCount = pluginsCount - failedPlugins.size;
+			if (currentConfigs.length > 1) console.log(" ");
+			console.log(status === "success" ? `Kubb Summary: ${pc.blue("✓")} ${`${successCount} successful`}, ${pluginsCount} total` : `Kubb Summary: ${pc.blue("✓")} ${`${successCount} successful`}, ✗ ${`${failedPlugins.size} failed`}, ${pluginsCount} total`);
+			if (currentConfigs.length > 1) closeGroup(config.name ? `Generation for ${pc.bold(config.name)}` : "Generation");
+		});
+	}
+});
+
+//#endregion
+//#region src/loggers/plainLogger.ts
+/**
+* Plain console adapter for non-TTY environments
+* Simple console.log output with indentation
+*/
+const plainLogger = defineLogger({
+	name: "plain",
+	install(context, options) {
+		const logLevel = options?.logLevel || 3;
+		function getMessage(message) {
+			if (logLevel >= LogLevel.verbose) return [`[${(/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", {
+				hour12: false,
+				hour: "2-digit",
+				minute: "2-digit",
+				second: "2-digit"
+			})}]`, message].join(" ");
+			return message;
+		}
+		context.on("info", (message, info) => {
+			if (logLevel <= LogLevel.silent) return;
+			const text = getMessage([
+				"ℹ",
+				message,
+				info
+			].join(" "));
+			console.log(text);
+		});
+		context.on("success", (message, info = "") => {
+			if (logLevel <= LogLevel.silent) return;
+			const text = getMessage([
+				"✓",
+				message,
+				logLevel >= LogLevel.info ? info : void 0
+			].filter(Boolean).join(" "));
+			console.log(text);
+		});
+		context.on("warn", (message, info) => {
+			if (logLevel < LogLevel.warn) return;
+			const text = getMessage([
+				"⚠",
+				message,
+				logLevel >= LogLevel.info ? info : void 0
+			].filter(Boolean).join(" "));
+			console.log(text);
+		});
+		context.on("error", (error) => {
+			const caused = error.cause;
+			const text = getMessage(["✗", error.message].join(" "));
+			console.log(text);
+			if (logLevel >= LogLevel.debug && error.stack) {
+				const frames = error.stack.split("\n").slice(1, 4);
+				for (const frame of frames) console.log(getMessage(frame.trim()));
+				if (caused?.stack) {
+					console.log(`└─ caused by ${caused.message}`);
+					const frames$1 = caused.stack.split("\n").slice(1, 4);
+					for (const frame of frames$1) console.log(getMessage(`    ${frame.trim()}`));
+				}
+			}
+		});
+		context.on("lifecycle:start", () => {
+			console.log("Kubb CLI 🧩");
+		});
+		context.on("config:start", () => {
+			if (logLevel <= LogLevel.silent) return;
+			const text = getMessage("Configuration started");
+			console.log(text);
+		});
+		context.on("config:end", () => {
+			if (logLevel <= LogLevel.silent) return;
+			const text = getMessage("Configuration completed");
+			console.log(text);
+		});
+		context.on("generation:start", () => {
+			const text = getMessage("Configuration started");
+			console.log(text);
+		});
+		context.on("plugin:start", (plugin) => {
+			if (logLevel <= LogLevel.silent) return;
+			const text = getMessage(`Generating ${plugin.name}`);
+			console.log(text);
+		});
+		context.on("plugin:end", (plugin, duration) => {
+			if (logLevel <= LogLevel.silent) return;
+			const durationStr = duration >= 1e3 ? `${(duration / 1e3).toFixed(2)}s` : `${duration}ms`;
+			const text = getMessage(`${plugin.name} completed in ${durationStr}`);
+			console.log(text);
+		});
+		context.on("files:processing:start", (files) => {
+			if (logLevel <= LogLevel.silent) return;
+			const text = getMessage(`Writing ${files.length} files`);
+			console.log(text);
+		});
+		context.on("file:processing:update", ({ file, config }) => {
+			if (logLevel <= LogLevel.silent) return;
+			const text = getMessage(`Writing ${relative(config.root, file.path)}`);
+			console.log(text);
+		});
+		context.on("files:processing:end", () => {
+			if (logLevel <= LogLevel.silent) return;
+			const text = getMessage("Files written successfully");
+			console.log(text);
+		});
+		context.on("generation:end", (config) => {
+			const text = getMessage(config.name ? `Generation completed for ${config.name}` : "Generation completed");
+			console.log(text);
+		});
+		context.on("hook:execute", async ({ command: command$1, args }, cb) => {
+			try {
+				const result = await execa(command$1, args, {
+					detached: true,
+					stripFinalNewline: true
+				});
+				await context.emit("debug", {
+					date: /* @__PURE__ */ new Date(),
+					logs: [result.stdout]
+				});
+				console.log(result.stdout);
+				cb();
+			} catch (err) {
+				const error = /* @__PURE__ */ new Error("Hook execute failed");
+				error.cause = err;
+				await context.emit("debug", {
+					date: /* @__PURE__ */ new Date(),
+					logs: [err.stdout]
+				});
+				await context.emit("error", error);
+			}
+		});
+		context.on("format:start", () => {
+			if (logLevel <= LogLevel.silent) return;
+			const text = getMessage("Format started");
+			console.log(text);
+		});
+		context.on("format:end", () => {
+			if (logLevel <= LogLevel.silent) return;
+			const text = getMessage("Format completed");
+			console.log(text);
+		});
+		context.on("lint:start", () => {
+			if (logLevel <= LogLevel.silent) return;
+			const text = getMessage("Lint started");
+			console.log(text);
+		});
+		context.on("lint:end", () => {
+			if (logLevel <= LogLevel.silent) return;
+			const text = getMessage("Lint completed");
+			console.log(text);
+		});
+		context.on("hook:start", (command$1) => {
+			if (logLevel <= LogLevel.silent) return;
+			const text = getMessage(`Hook ${command$1} started`);
+			console.log(text);
+		});
+		context.on("hook:end", (command$1) => {
+			if (logLevel <= LogLevel.silent) return;
+			const text = getMessage(`Hook ${command$1} completed`);
+			console.log(text);
+		});
+		context.on("generation:summary", (config, { pluginTimings, status, hrStart, failedPlugins, filesCreated }) => {
+			const summary = getSummary({
+				failedPlugins,
+				filesCreated,
+				config,
+				status,
+				hrStart,
+				pluginTimings: logLevel >= LogLevel.verbose ? pluginTimings : void 0
+			});
+			console.log("---------------------------");
+			console.log(summary.join("\n"));
+			console.log("---------------------------");
+		});
+	}
+});
+
+//#endregion
+//#region src/loggers/utils.ts
+function detectLogger() {
+	if (isGitHubActions()) return "github-actions";
+	if (canUseTTY()) return "clack";
+	return "plain";
+}
+const logMapper = {
+	clack: clackLogger,
+	plain: plainLogger,
+	"github-actions": githubActionsLogger
+};
+async function setupLogger(context, { logLevel }) {
+	const type = detectLogger();
+	const logger = logMapper[type];
+	if (!logger) throw new Error(`Unknown adapter type: ${type}`);
+	const cleanup = await logger.install(context, { logLevel });
+	if (logLevel >= LogLevel.debug) await fileSystemLogger.install(context, { logLevel });
+	return cleanup;
+}
+
+//#endregion
+//#region src/utils/executeHooks.ts
+async function executeHooks({ hooks, events }) {
+	const commands = Array.isArray(hooks.done) ? hooks.done : [hooks.done].filter(Boolean);
+	for (const command$1 of commands) {
+		const [cmd, ...args] = [...parseArgsStringToArgv(command$1)];
+		if (!cmd) continue;
+		await events.emit("hook:start", command$1);
+		await events.emit("hook:execute", {
+			command: cmd,
+			args
+		}, async () => {
+			await events.emit("success", `${pc.dim(command$1)} successfully executed`);
+			await events.emit("hook:end", command$1);
+		});
+	}
+}
+
+//#endregion
+//#region src/runners/generate.ts
+async function generate({ input, config, events, logLevel }) {
+	const { root = process$1.cwd(), ...userConfig } = config;
+	const inputPath = input ?? ("path" in userConfig.input ? userConfig.input.path : void 0);
+	const hrStart = process$1.hrtime();
+	const definedConfig = {
+		root,
+		...userConfig,
+		input: inputPath ? {
+			...userConfig.input,
+			path: inputPath
+		} : userConfig.input,
+		output: {
+			write: true,
+			barrelType: "named",
+			extension: { ".ts": ".ts" },
+			format: "prettier",
+			...userConfig.output
+		}
+	};
+	await events.emit("generation:start", definedConfig);
+	await events.emit("info", config.name ? `Setup generation ${pc.bold(config.name)}` : "Setup generation", inputPath);
+	const { fabric, pluginManager } = await setup({
+		config: definedConfig,
+		events
+	});
+	await events.emit("info", config.name ? `Build generation ${pc.bold(config.name)}` : "Build generation", inputPath);
+	const { files, failedPlugins, pluginTimings, error } = await safeBuild({
+		config: definedConfig,
+		events
+	}, {
+		pluginManager,
+		fabric,
+		events
+	});
+	await events.emit("info", "Load summary");
+	if (failedPlugins.size > 0 || error) {
+		[error, ...Array.from(failedPlugins).filter((it) => it.error).map((it) => it.error)].filter(Boolean).forEach((err) => {
+			events.emit("error", err);
+		});
+		await events.emit("generation:end", definedConfig);
+		await events.emit("generation:summary", definedConfig, {
+			failedPlugins,
+			filesCreated: files.length,
+			status: failedPlugins.size > 0 || error ? "failed" : "success",
+			hrStart,
+			pluginTimings: logLevel >= LogLevel.verbose ? pluginTimings : void 0
+		});
+		process$1.exit(1);
+	}
+	await events.emit("success", "Generation successfully", inputPath);
+	await events.emit("generation:end", definedConfig);
+	if (config.output.format) {
+		await events.emit("format:start");
+		await events.emit("info", [`Formatting with ${pc.dim(config.output.format)}`, logLevel >= LogLevel.info ? `on ${pc.dim(path.resolve(definedConfig.root, definedConfig.output.path))}` : void 0].filter(Boolean).join(" "));
+		if (config.output.format === "prettier") {
+			try {
+				await events.emit("hook:execute", {
+					command: "prettier",
+					args: [
+						"--ignore-unknown",
+						"--write",
+						path.resolve(definedConfig.root, definedConfig.output.path)
+					]
+				}, async () => {
+					await events.emit("success", [
+						`Formatting with ${pc.dim(config.output.format)}`,
+						logLevel >= LogLevel.info ? `on ${pc.dim(path.resolve(definedConfig.root, definedConfig.output.path))}` : void 0,
+						"successfully"
+					].filter(Boolean).join(" "));
+				});
+			} catch (e) {
+				await events.emit("error", e);
+			}
+			await events.emit("success", `Formatted with ${config.output.format}`);
+		}
+		if (config.output.format === "biome") try {
+			await events.emit("hook:execute", {
+				command: "biome",
+				args: [
+					"format",
+					"--write",
+					path.resolve(definedConfig.root, definedConfig.output.path)
+				]
+			}, async () => {
+				await events.emit("success", [
+					`Formatting with ${pc.dim(config.output.format)}`,
+					logLevel >= LogLevel.info ? `on ${pc.dim(path.resolve(definedConfig.root, definedConfig.output.path))}` : void 0,
+					"successfully"
+				].filter(Boolean).join(" "));
+			});
+		} catch (e) {
+			const error$1 = /* @__PURE__ */ new Error("Biome not found");
+			error$1.cause = e;
+			await events.emit("error", error$1);
+		}
+		await events.emit("format:end");
+	}
+	if (config.output.lint) {
+		await events.emit("lint:start");
+		await events.emit("info", [`Linting with ${pc.dim(config.output.lint)}`, logLevel >= LogLevel.info ? `on ${pc.dim(path.resolve(definedConfig.root, definedConfig.output.path))}` : void 0].filter(Boolean).join(" "));
+		if (config.output.lint === "eslint") try {
+			await events.emit("hook:execute", {
+				command: "eslint",
+				args: [path.resolve(definedConfig.root, definedConfig.output.path), "--fix"]
+			}, async () => {
+				await events.emit("success", [
+					`Linted with ${pc.dim(config.output.lint)}`,
+					logLevel >= LogLevel.info ? `on ${pc.dim(path.resolve(definedConfig.root, definedConfig.output.path))}` : void 0,
+					"successfully"
+				].filter(Boolean).join(" "));
+			});
+		} catch (e) {
+			const error$1 = /* @__PURE__ */ new Error("Eslint not found");
+			error$1.cause = e;
+			await events.emit("error", error$1);
+		}
+		if (config.output.lint === "biome") try {
+			await events.emit("hook:execute", {
+				command: "biome",
+				args: [
+					"lint",
+					"--fix",
+					path.resolve(definedConfig.root, definedConfig.output.path)
+				]
+			}, async () => {
+				await events.emit("success", [
+					`Linted with ${pc.dim(config.output.lint)}`,
+					logLevel >= LogLevel.info ? `on ${pc.dim(path.resolve(definedConfig.root, definedConfig.output.path))}` : void 0,
+					"successfully"
+				].filter(Boolean).join(" "));
+			});
+		} catch (e) {
+			const error$1 = /* @__PURE__ */ new Error("Biome not found");
+			error$1.cause = e;
+			await events.emit("error", error$1);
+		}
+		if (config.output.lint === "oxlint") try {
+			await events.emit("hook:execute", {
+				command: "oxlint",
+				args: ["--fix", path.resolve(definedConfig.root, definedConfig.output.path)]
+			}, async () => {
+				await events.emit("success", [
+					`Linted with ${pc.dim(config.output.lint)}`,
+					logLevel >= LogLevel.info ? `on ${pc.dim(path.resolve(definedConfig.root, definedConfig.output.path))}` : void 0,
+					"successfully"
+				].filter(Boolean).join(" "));
+			});
+		} catch (e) {
+			const error$1 = /* @__PURE__ */ new Error("Oxlint not found");
+			error$1.cause = e;
+			await events.emit("error", error$1);
+		}
+		await events.emit("lint:end");
+	}
+	if (config.hooks) {
+		await events.emit("hooks:start");
+		await executeHooks({
+			hooks: config.hooks,
+			events
+		});
+		await events.emit("hooks:end");
+	}
+	await events.emit("generation:summary", definedConfig, {
+		failedPlugins,
+		filesCreated: files.length,
+		status: failedPlugins.size > 0 || error ? "failed" : "success",
+		hrStart,
+		pluginTimings
+	});
+}
+
+//#endregion
+//#region src/utils/getPlugins.ts
+function isJSONPlugins(plugins) {
+	return !!plugins?.some((plugin) => {
+		return Array.isArray(plugin) && typeof plugin?.at(0) === "string";
+	});
+}
+function isObjectPlugins(plugins) {
+	return plugins instanceof Object && !Array.isArray(plugins);
+}
+function getPlugins(plugins) {
+	if (isObjectPlugins(plugins)) throw new Error("Object plugins are not supported anymore, best to use http://kubb.dev/getting-started/configure#json");
+	if (isJSONPlugins(plugins)) throw new Error("JSON plugins are not supported anymore, best to use http://kubb.dev/getting-started/configure#json");
+	return Promise.resolve(plugins);
+}
+
+//#endregion
+//#region src/utils/getConfig.ts
+/**
+* Converting UserConfig to Config without a change in the object beside the JSON convert.
+*/
+async function getConfig(result, args) {
+	const config = result?.config;
+	let kubbUserConfig = Promise.resolve(config);
+	if (typeof config === "function") {
+		const possiblePromise = config(args);
+		if (isPromise(possiblePromise)) kubbUserConfig = possiblePromise;
+		kubbUserConfig = Promise.resolve(possiblePromise);
+	}
+	let JSONConfig = await kubbUserConfig;
+	if (Array.isArray(JSONConfig)) {
+		const results = [];
+		for (const item of JSONConfig) {
+			const plugins = item.plugins ? await getPlugins(item.plugins) : void 0;
+			results.push({
+				...item,
+				plugins
+			});
+		}
+		return results;
+	}
+	JSONConfig = {
+		...JSONConfig,
+		plugins: JSONConfig.plugins ? await getPlugins(JSONConfig.plugins) : void 0
+	};
+	return JSONConfig;
+}
+
+//#endregion
+//#region src/utils/getCosmiConfig.ts
+const tsLoader = async (configFile) => {
+	return await createJiti(import.meta.url, {
+		jsx: {
+			runtime: "automatic",
+			importSource: "@kubb/react-fabric"
+		},
+		sourceMaps: true
+	}).import(configFile, { default: true });
+};
+async function getCosmiConfig(moduleName, config) {
+	let result;
+	const searchPlaces = [
+		"package.json",
+		`.${moduleName}rc`,
+		`.${moduleName}rc.json`,
+		`.${moduleName}rc.yaml`,
+		`.${moduleName}rc.yml`,
+		`.${moduleName}rc.ts`,
+		`.${moduleName}rc.js`,
+		`.${moduleName}rc.mjs`,
+		`.${moduleName}rc.cjs`,
+		`${moduleName}.config.ts`,
+		`${moduleName}.config.js`,
+		`${moduleName}.config.mjs`,
+		`${moduleName}.config.cjs`
+	];
+	const explorer = cosmiconfig(moduleName, {
+		cache: false,
+		searchPlaces: [
+			...searchPlaces.map((searchPlace) => {
+				return `.config/${searchPlace}`;
+			}),
+			...searchPlaces.map((searchPlace) => {
+				return `configs/${searchPlace}`;
+			}),
+			...searchPlaces
+		],
+		loaders: { ".ts": tsLoader }
+	});
+	try {
+		result = config ? await explorer.load(config) : await explorer.search();
+	} catch (e) {
+		throw new Error("Config failed loading", { cause: e });
+	}
+	if (result?.isEmpty || !result || !result.config) throw new Error("Config not defined, create a kubb.config.js or pass through your config with the option --config");
+	return result;
+}
+
+//#endregion
+//#region src/utils/watcher.ts
+async function startWatcher(path$1, cb) {
+	const { watch } = await import("chokidar");
+	watch(path$1, {
+		ignorePermissionErrors: true,
+		ignored: "**/{.git,node_modules}/**"
+	}).on("all", (type, file) => {
+		console.log(pc.yellow(pc.bold(`Change detected: ${type} ${file}`)));
+		try {
+			cb(path$1);
+		} catch (_e) {
+			console.log(pc.red("Watcher failed"));
+		}
+	});
+}
+
+//#endregion
+//#region src/commands/generate.ts
+const command = defineCommand({
+	meta: {
+		name: "generate",
+		description: "[input] Generate files based on a 'kubb.config.ts' file"
+	},
+	args: {
+		config: {
+			type: "string",
+			description: "Path to the Kubb config",
+			alias: "c"
+		},
+		logLevel: {
+			type: "string",
+			description: "Info, silent, verbose or debug",
+			alias: "l",
+			default: "info",
+			valueHint: "silent|info|verbose|debug"
+		},
+		watch: {
+			type: "boolean",
+			description: "Watch mode based on the input file",
+			alias: "w",
+			default: false
+		},
+		debug: {
+			type: "boolean",
+			description: "Override logLevel to debug",
+			alias: "d",
+			default: false
+		},
+		verbose: {
+			type: "boolean",
+			description: "Override logLevel to verbose",
+			alias: "v",
+			default: false
+		},
+		help: {
+			type: "boolean",
+			description: "Show help",
+			alias: "h",
+			default: false
+		}
+	},
+	async run(commandContext) {
+		const { args } = commandContext;
+		const input = args._[0];
+		const events = new AsyncEventEmitter();
+		const promiseManager = new PromiseManager();
+		if (args.help) return showUsage(command);
+		if (args.debug) args.logLevel = "debug";
+		if (args.verbose) args.logLevel = "verbose";
+		const logLevel = LogLevel[args.logLevel] || 3;
+		await setupLogger(events, { logLevel });
+		const latestVersion = await getLatestVersion("@kubb/cli");
+		if (lt(version, latestVersion)) await events.emit("version:new", version, latestVersion);
+		try {
+			await events.emit("lifecycle:start", version);
+			await events.emit("config:start");
+			const result = await getCosmiConfig("kubb", args.config);
+			await events.emit("info", "Config loaded", path.relative(process$2.cwd(), result.filepath));
+			const config = await getConfig(result, args);
+			const configs = Array.isArray(config) ? config : [config];
+			await events.emit("success", "Config loaded successfully", path.relative(process$2.cwd(), result.filepath));
+			await events.emit("config:end", configs);
+			const promises = configs.map((config$1) => {
+				return async () => {
+					if (isInputPath(config$1) && args.watch) {
+						await startWatcher([input || config$1.input.path], async (paths) => {
+							await generate({
+								input,
+								config: config$1,
+								logLevel,
+								events
+							});
+							clack.log.step(pc.yellow(`Watching for changes in ${paths.join(" and ")}`));
+						});
+						return;
+					}
+					await generate({
+						input,
+						config: config$1,
+						logLevel,
+						events
+					});
+				};
+			});
+			await promiseManager.run("seq", promises);
+			await events.emit("lifecycle:end");
+		} catch (e) {
+			await events.emit("error", e);
+		}
+	}
+});
+var generate_default = command;
+
+//#endregion
+export { generate_default as default };
+//# sourceMappingURL=generate-BfIvo80v.js.map