@kubb/cli 4.32.3 → 4.33.0

package/dist/{generate-zZuxBP8z.js → generate-HP5ySfjV.js}

@@ -1,16 +1,16 @@
 import "./chunk--u3MIqq1.js";
-import { t as version } from "./package--eaEMq2R.js";
-import { r as sendTelemetry, t as buildTelemetryEvent } from "./telemetry-DYWvlxqs.js";
+import { t as version } from "./package-681jTtCk.js";
+import { c as randomColors, i as WATCHER_IGNORED_PATHS, r as SUMMARY_SEPARATOR, t as KUBB_NPM_PACKAGE_URL } from "./constants-CEKRremI.js";
+import { a as isGitHubActions, i as canUseTTY, r as sendTelemetry, t as buildTelemetryEvent } from "./telemetry-C4gOKX2x.js";
+import { n as toCause, r as toError } from "./errors-bSLTEh4e.js";
 import { styleText } from "node:util";
-import { defineCommand, showUsage } from "citty";
 import { createHash } from "node:crypto";
-import * as process$2 from "node:process";
 import process$1 from "node:process";
 import { AsyncEventEmitter, detectFormatter, detectLinter, executeIfOnline, formatHrtime, formatMs, formatters, getConfigs, linters, tokenize } from "@kubb/core/utils";
 import path, { relative, resolve } from "node:path";
 import * as clack from "@clack/prompts";
 import { LogLevel, PromiseManager, defineLogger, isInputPath, safeBuild, setup } from "@kubb/core";
-import { x } from "tinyexec";
+import { NonZeroExitError, x } from "tinyexec";
 import { Writable } from "node:stream";
 import { write } from "@kubb/core/fs";
 import { cosmiconfig } from "cosmiconfig";
@@ -34,28 +34,26 @@ function formatMsWithColor(ms) {
 * ANSI True Color (24-bit) utilities for terminal output
 * Supports hex color codes without external dependencies like chalk
 */
+/** Parse a hex color string into RGB components, defaulting to 255 on invalid input. */
+function parseHex(color) {
+	const c = color.replace("#", "");
+	const r = Number.parseInt(c.slice(0, 2), 16);
+	const g = Number.parseInt(c.slice(2, 4), 16);
+	const b = Number.parseInt(c.slice(4, 6), 16);
+	return {
+		r: Number.isNaN(r) ? 255 : r,
+		g: Number.isNaN(g) ? 255 : g,
+		b: Number.isNaN(b) ? 255 : b
+	};
+}
 /**
 * Convert hex color to ANSI 24-bit true color escape sequence
 * @param color - Hex color code (with or without #), e.g., '#FF5500' or 'FF5500'
 * @returns Function that wraps text with the color
 */
 function hex(color) {
-	const cleanHex = color.replace("#", "");
-	const r = Number.parseInt(cleanHex.slice(0, 2), 16);
-	const g = Number.parseInt(cleanHex.slice(2, 4), 16);
-	const b = Number.parseInt(cleanHex.slice(4, 6), 16);
-	const safeR = Number.isNaN(r) ? 255 : r;
-	const safeG = Number.isNaN(g) ? 255 : g;
-	const safeB = Number.isNaN(b) ? 255 : b;
-	return (text) => `\x1b[38;2;${safeR};${safeG};${safeB}m${text}\x1b[0m`;
-}
-function hexToRgb(color) {
-	const c = color.replace("#", "");
-	return {
-		r: Number.parseInt(c.slice(0, 2), 16),
-		g: Number.parseInt(c.slice(2, 4), 16),
-		b: Number.parseInt(c.slice(4, 6), 16)
-	};
+	const { r, g, b } = parseHex(color);
+	return (text) => `\x1b[38;2;${r};${g};${b}m${text}\x1b[0m`;
 }
 function gradient(colors) {
 	return (text) => {
@@ -64,8 +62,8 @@ function gradient(colors) {
 			const t = chars.length <= 1 ? 0 : i / (chars.length - 1);
 			const seg = Math.min(Math.floor(t * (colors.length - 1)), colors.length - 2);
 			const lt = t * (colors.length - 1) - seg;
-			const from = hexToRgb(colors[seg]);
-			const to = hexToRgb(colors[seg + 1]);
+			const from = parseHex(colors[seg]);
+			const to = parseHex(colors[seg + 1]);
 			return `\x1b[38;2;${Math.round(from.r + (to.r - from.r) * lt)};${Math.round(from.g + (to.g - from.g) * lt)};${Math.round(from.b + (to.b - from.b) * lt)}m${char}\x1b[0m`;
 		}).join("");
 	};
@@ -102,35 +100,19 @@ function getIntro({ title, description, version, areEyesOpen }) {
 }
 //#endregion
 //#region src/utils/randomColor.ts
-function randomColor(text) {
-	if (!text) return "white";
-	const defaultColors = [
-		"black",
-		"red",
-		"green",
-		"yellow",
-		"blue",
-		"red",
-		"green",
-		"magenta",
-		"cyan",
-		"gray"
-	];
-	return defaultColors[createHash("sha256").update(text).digest().readUInt32BE(0) % defaultColors.length] ?? "white";
-}
 function randomCliColor(text) {
 	if (!text) return "";
-	return styleText(randomColor(text), text);
+	return styleText(randomColors[createHash("sha256").update(text).digest().readUInt32BE(0) % randomColors.length] ?? "white", text);
 }
 //#endregion
 //#region src/utils/getSummary.ts
 function getSummary({ failedPlugins, filesCreated, status, hrStart, config, pluginTimings }) {
 	const duration = formatHrtime(hrStart);
-	const pluginsCount = config.plugins?.length || 0;
+	const pluginsCount = config.plugins?.length ?? 0;
 	const successCount = pluginsCount - failedPlugins.size;
 	const meta = {
 		plugins: status === "success" ? `${styleText("green", `${successCount} successful`)}, ${pluginsCount} total` : `${styleText("green", `${successCount} successful`)}, ${styleText("red", `${failedPlugins.size} failed`)}, ${pluginsCount} total`,
-		pluginsFailed: status === "failed" ? [...failedPlugins]?.map(({ plugin }) => randomCliColor(plugin.name))?.join(", ") : void 0,
+		pluginsFailed: status === "failed" ? [...failedPlugins].map(({ plugin }) => randomCliColor(plugin.name)).join(", ") : void 0,
 		filesCreated,
 		time: styleText("green", duration),
 		output: path.isAbsolute(config.root) ? path.resolve(config.root, config.output.path) : config.root
@@ -148,23 +130,76 @@ function getSummary({ failedPlugins, filesCreated, status, hrStart, config, plug
 	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 = styleText("dim", "█".repeat(barLength));
-				summaryLines.push(`${styleText("dim", "•")} ${name.padEnd(maxLength + 1)}${bar} ${timeStr}`);
-			});
-		}
+		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 / 100), 10);
+			const bar = styleText("dim", "█".repeat(barLength));
+			summaryLines.push(`${styleText("dim", "•")} ${name.padEnd(maxLength + 1)}${bar} ${timeStr}`);
+		});
 	}
 	summaryLines.push(`${labels.output.padEnd(maxLength + 2)} ${meta.output}`);
 	return summaryLines;
 }
 //#endregion
+//#region src/utils/runHook.ts
+/**
+* Execute a hook command, emit debug/hook:end events, and forward output to
+* an optional HookOutputSink.  All three logger adapters share this function
+* so the process-spawning logic lives in exactly one place.
+*/
+async function runHook({ id, command, args, commandWithArgs, context, stream = false, sink }) {
+	try {
+		const proc = x(command, [...args ?? []], {
+			nodeOptions: { detached: true },
+			throwOnError: true
+		});
+		if (stream && sink?.onLine) for await (const line of proc) sink.onLine(line);
+		const result = await proc;
+		await context.emit("debug", {
+			date: /* @__PURE__ */ new Date(),
+			logs: [result.stdout.trimEnd()]
+		});
+		await context.emit("hook:end", {
+			command,
+			args,
+			id,
+			success: true,
+			error: null
+		});
+	} catch (err) {
+		if (!(err instanceof NonZeroExitError)) {
+			await context.emit("hook:end", {
+				command,
+				args,
+				id,
+				success: false,
+				error: toError(err)
+			});
+			await context.emit("error", toError(err));
+			return;
+		}
+		const stderr = err.output?.stderr ?? "";
+		const stdout = err.output?.stdout ?? "";
+		await context.emit("debug", {
+			date: /* @__PURE__ */ new Date(),
+			logs: [stdout, stderr].filter(Boolean)
+		});
+		if (stderr) sink?.onStderr?.(stderr);
+		if (stdout) sink?.onStdout?.(stdout);
+		const errorMessage = /* @__PURE__ */ new Error(`Hook execute failed: ${commandWithArgs}`);
+		await context.emit("hook:end", {
+			command,
+			args,
+			id,
+			success: false,
+			error: errorMessage
+		});
+		await context.emit("error", errorMessage);
+	}
+}
+//#endregion
 //#region src/utils/Writables.ts
 var ClackWritable = class extends Writable {
 	taskLog;
@@ -173,7 +208,7 @@ var ClackWritable = class extends Writable {
 		this.taskLog = taskLog;
 	}
 	_write(chunk, _encoding, callback) {
-		this.taskLog.message(`${styleText("dim", chunk?.toString())}`);
+		this.taskLog.message(`${styleText("dim", chunk.toString())}`);
 		callback();
 	}
 };
@@ -186,7 +221,7 @@ var ClackWritable = class extends Writable {
 const clackLogger = defineLogger({
 	name: "clack",
 	install(context, options) {
-		const logLevel = options?.logLevel || LogLevel.info;
+		const logLevel = options?.logLevel ?? LogLevel.info;
 		const state = {
 			totalPlugins: 0,
 			completedPlugins: 0,
@@ -215,26 +250,11 @@ const clackLogger = defineLogger({
 		}
 		function showProgressStep() {
 			if (logLevel <= LogLevel.silent) return;
-			const parts = [];
-			const duration = formatHrtime(state.hrStart);
-			if (state.totalPlugins > 0) {
-				const pluginStr = state.failedPlugins > 0 ? `Plugins ${styleText("green", state.completedPlugins.toString())}/${state.totalPlugins} ${styleText("red", `(${state.failedPlugins} failed)`)}` : `Plugins ${styleText("green", state.completedPlugins.toString())}/${state.totalPlugins}`;
-				parts.push(pluginStr);
-			}
-			if (state.totalFiles > 0) parts.push(`Files ${styleText("green", state.processedFiles.toString())}/${state.totalFiles}`);
-			if (parts.length > 0) {
-				parts.push(`${styleText("green", duration)} elapsed`);
-				clack.log.step(getMessage(parts.join(styleText("dim", " | "))));
-			}
+			const line = buildProgressLine(state);
+			if (line) clack.log.step(getMessage(line));
 		}
 		function getMessage(message) {
-			if (logLevel >= LogLevel.verbose) return [styleText("dim", `[${(/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", {
-				hour12: false,
-				hour: "2-digit",
-				minute: "2-digit",
-				second: "2-digit"
-			})}]`), message].join(" ");
-			return message;
+			return formatMessage(message, logLevel);
 		}
 		function startSpinner(text) {
 			state.spinner.start(text);
@@ -274,7 +294,7 @@ const clackLogger = defineLogger({
 			clack.log.warn(text);
 		});
 		context.on("error", (error) => {
-			const caused = error.cause;
+			const caused = toCause(error);
 			const text = [styleText("red", "✗"), error.message].join(" ");
 			if (state.isSpinning) stopSpinner(getMessage(text));
 			else clack.log.error(getMessage(text));
@@ -321,10 +341,10 @@ Run \`npm install -g @kubb/cli\` to update`, "Update available for `Kubb`", {
 			clack.outro(text);
 		});
 		context.on("generation:start", (config) => {
-			state.totalPlugins = config.plugins?.length || 0;
+			reset();
+			state.totalPlugins = config.plugins?.length ?? 0;
 			const text = getMessage(["Generation started", config.name ? `for ${styleText("dim", config.name)}` : void 0].filter(Boolean).join(" "));
 			clack.intro(text);
-			reset();
 		});
 		context.on("plugin:start", (plugin) => {
 			if (logLevel <= LogLevel.silent) return;
@@ -416,93 +436,43 @@ Run \`npm install -g @kubb/cli\` to update`, "Update available for `Kubb`", {
 			clack.outro(text);
 		});
 		context.on("hook:start", async ({ id, command, args }) => {
-			const commandWithArgs = args?.length ? `${command} ${args.join(" ")}` : command;
+			const commandWithArgs = formatCommandWithArgs(command, args);
 			const text = getMessage(`Hook ${styleText("dim", commandWithArgs)} started`);
 			if (!id) return;
 			if (logLevel <= LogLevel.silent) {
-				try {
-					const result = await x(command, [...args ?? []], {
-						nodeOptions: { detached: true },
-						throwOnError: true
-					});
-					await context.emit("debug", {
-						date: /* @__PURE__ */ new Date(),
-						logs: [result.stdout.trimEnd()]
-					});
-					await context.emit("hook:end", {
-						command,
-						args,
-						id,
-						success: true,
-						error: null
-					});
-				} catch (err) {
-					const error = err;
-					const stderr = error.output?.stderr ?? "";
-					const stdout = error.output?.stdout ?? "";
-					await context.emit("debug", {
-						date: /* @__PURE__ */ new Date(),
-						logs: [stdout, stderr].filter(Boolean)
-					});
-					if (stderr) console.error(stderr);
-					if (stdout) console.log(stdout);
-					const errorMessage = /* @__PURE__ */ new Error(`Hook execute failed: ${commandWithArgs}`);
-					await context.emit("hook:end", {
-						command,
-						args,
-						id,
-						success: false,
-						error: errorMessage
-					});
-					await context.emit("error", errorMessage);
-				}
-				return;
-			}
-			clack.intro(text);
-			const logger = clack.taskLog({ title: getMessage(["Executing hook", logLevel >= LogLevel.info ? styleText("dim", commandWithArgs) : void 0].filter(Boolean).join(" ")) });
-			const writable = new ClackWritable(logger);
-			try {
-				const proc = x(command, [...args ?? []], {
-					nodeOptions: { detached: true },
-					throwOnError: true
-				});
-				for await (const line of proc) writable.write(line);
-				const result = await proc;
-				await context.emit("debug", {
-					date: /* @__PURE__ */ new Date(),
-					logs: [result.stdout.trimEnd()]
-				});
-				await context.emit("hook:end", {
-					command,
-					args,
+				await runHook({
 					id,
-					success: true,
-					error: null
-				});
-			} catch (err) {
-				const error = err;
-				const stderr = error.output?.stderr ?? "";
-				const stdout = error.output?.stdout ?? "";
-				await context.emit("debug", {
-					date: /* @__PURE__ */ new Date(),
-					logs: [stdout, stderr].filter(Boolean)
-				});
-				if (stderr) logger.error(stderr);
-				if (stdout) logger.message(stdout);
-				const errorMessage = /* @__PURE__ */ new Error(`Hook execute failed: ${commandWithArgs}`);
-				await context.emit("hook:end", {
 					command,
 					args,
-					id,
-					success: false,
-					error: errorMessage
+					commandWithArgs,
+					context,
+					sink: {
+						onStderr: (s) => console.error(s),
+						onStdout: (s) => console.log(s)
+					}
 				});
-				await context.emit("error", errorMessage);
+				return;
 			}
+			clack.intro(text);
+			const logger = clack.taskLog({ title: getMessage(["Executing hook", logLevel >= LogLevel.info ? styleText("dim", commandWithArgs) : void 0].filter(Boolean).join(" ")) });
+			const writable = new ClackWritable(logger);
+			await runHook({
+				id,
+				command,
+				args,
+				commandWithArgs,
+				context,
+				stream: true,
+				sink: {
+					onLine: (line) => writable.write(line),
+					onStderr: (s) => logger.error(s),
+					onStdout: (s) => logger.message(s)
+				}
+			});
 		});
 		context.on("hook:end", ({ command, args }) => {
 			if (logLevel <= LogLevel.silent) return;
-			const text = getMessage(`Hook ${styleText("dim", args?.length ? `${command} ${args.join(" ")}` : command)} successfully executed`);
+			const text = getMessage(`Hook ${styleText("dim", formatCommandWithArgs(command, args))} successfully executed`);
 			clack.outro(text);
 		});
 		context.on("generation:summary", (config, { pluginTimings, failedPlugins, filesCreated, status, hrStart }) => {
@@ -517,20 +487,10 @@ Run \`npm install -g @kubb/cli\` to update`, "Update available for `Kubb`", {
 			const title = config.name || "";
 			summary.unshift("\n");
 			summary.push("\n");
-			if (status === "success") {
-				clack.box(summary.join("\n"), getMessage(title), {
-					width: "auto",
-					formatBorder: (s) => styleText("green", s),
-					rounded: true,
-					withGuide: false,
-					contentAlign: "left",
-					titleAlign: "center"
-				});
-				return;
-			}
+			const borderColor = status === "success" ? "green" : "red";
 			clack.box(summary.join("\n"), getMessage(title), {
 				width: "auto",
-				formatBorder: (s) => styleText("red", s),
+				formatBorder: (s) => styleText(borderColor, s),
 				rounded: true,
 				withGuide: false,
 				contentAlign: "left",
@@ -543,26 +503,6 @@ Run \`npm install -g @kubb/cli\` to update`, "Update available for `Kubb`", {
 	}
 });
 //#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
@@ -591,7 +531,7 @@ const fileSystemLogger = defineLogger({
 					name,
 					state.startDate
 				].filter(Boolean).join("-")}.log`;
-				const pathName = resolve(process.cwd(), ".kubb", baseName);
+				const pathName = resolve(process$1.cwd(), ".kubb", baseName);
 				if (!files[pathName]) files[pathName] = [];
 				if (log.logs.length > 0) {
 					const timestamp = log.date.toLocaleString();
@@ -606,75 +546,66 @@ const fileSystemLogger = defineLogger({
 		context.on("info", (message, info) => {
 			state.cachedLogs.add({
 				date: /* @__PURE__ */ new Date(),
-				logs: [`ℹ ${message} ${info}`],
-				fileName: void 0
+				logs: [`ℹ ${message} ${info}`]
 			});
 		});
 		context.on("success", (message, info) => {
 			state.cachedLogs.add({
 				date: /* @__PURE__ */ new Date(),
-				logs: [`✓ ${message} ${info}`],
-				fileName: void 0
+				logs: [`✓ ${message} ${info}`]
 			});
 		});
 		context.on("warn", (message, info) => {
 			state.cachedLogs.add({
 				date: /* @__PURE__ */ new Date(),
-				logs: [`⚠ ${message} ${info}`],
-				fileName: void 0
+				logs: [`⚠ ${message} ${info}`]
 			});
 		});
 		context.on("error", (error) => {
 			state.cachedLogs.add({
 				date: /* @__PURE__ */ new Date(),
-				logs: [`✗ ${error.message}`, error.stack || "unknown stack"],
-				fileName: void 0
+				logs: [`✗ ${error.message}`, error.stack || "unknown stack"]
 			});
 		});
 		context.on("debug", (message) => {
 			state.cachedLogs.add({
 				date: /* @__PURE__ */ new Date(),
-				logs: message.logs,
-				fileName: void 0
+				logs: message.logs
 			});
 		});
 		context.on("plugin:start", (plugin) => {
 			state.cachedLogs.add({
 				date: /* @__PURE__ */ new Date(),
-				logs: [`Generating ${plugin.name}`],
-				fileName: void 0
+				logs: [`Generating ${plugin.name}`]
 			});
 		});
 		context.on("plugin:end", (plugin, { duration, success }) => {
 			const durationStr = formatMs(duration);
 			state.cachedLogs.add({
 				date: /* @__PURE__ */ new Date(),
-				logs: [success ? `${plugin.name} completed in ${durationStr}` : `${plugin.name} failed in ${durationStr}`],
-				fileName: void 0
+				logs: [success ? `${plugin.name} completed in ${durationStr}` : `${plugin.name} failed in ${durationStr}`]
 			});
 		});
 		context.on("files:processing:start", (files) => {
 			state.cachedLogs.add({
 				date: /* @__PURE__ */ new Date(),
-				logs: [`Start ${files.length} writing:`, ...files.map((file) => file.path)],
-				fileName: void 0
+				logs: [`Start ${files.length} writing:`, ...files.map((file) => file.path)]
 			});
 		});
 		context.on("generation:end", async (config) => {
 			const writtenFilePaths = await writeLogs(config.name);
 			if (writtenFilePaths.length > 0) {
-				const files = writtenFilePaths.map((f) => relative(process.cwd(), f));
+				const files = writtenFilePaths.map((f) => relative(process$1.cwd(), f));
 				await context.emit("info", "Debug files written to:", files.join(", "));
 			}
 			reset();
 		});
-		context.on("lifecycle:end", async () => {});
 		const exitHandler = () => {
 			if (state.cachedLogs.size > 0) writeLogs().catch(() => {});
 		};
-		process.once("exit", exitHandler);
-		process.once("SIGINT", exitHandler);
-		process.once("SIGTERM", exitHandler);
+		process$1.once("exit", exitHandler);
+		process$1.once("SIGINT", exitHandler);
+		process$1.once("SIGTERM", exitHandler);
 	}
 });
 //#endregion
@@ -686,7 +617,7 @@ const fileSystemLogger = defineLogger({
 const githubActionsLogger = defineLogger({
 	name: "github-actions",
 	install(context, options) {
-		const logLevel = options?.logLevel || LogLevel.info;
+		const logLevel = options?.logLevel ?? LogLevel.info;
 		const state = {
 			totalPlugins: 0,
 			completedPlugins: 0,
@@ -703,29 +634,15 @@ const githubActionsLogger = defineLogger({
 			state.totalFiles = 0;
 			state.processedFiles = 0;
 			state.hrStart = process.hrtime();
+			state.currentConfigs = [];
 		}
 		function showProgressStep() {
 			if (logLevel <= LogLevel.silent) return;
-			const parts = [];
-			const duration = formatHrtime(state.hrStart);
-			if (state.totalPlugins > 0) {
-				const pluginStr = state.failedPlugins > 0 ? `Plugins ${styleText("green", state.completedPlugins.toString())}/${state.totalPlugins} ${styleText("red", `(${state.failedPlugins} failed)`)}` : `Plugins ${styleText("green", state.completedPlugins.toString())}/${state.totalPlugins}`;
-				parts.push(pluginStr);
-			}
-			if (state.totalFiles > 0) parts.push(`Files ${styleText("green", state.processedFiles.toString())}/${state.totalFiles}`);
-			if (parts.length > 0) {
-				parts.push(`${styleText("green", duration)} elapsed`);
-				console.log(getMessage(parts.join(styleText("dim", " | "))));
-			}
+			const line = buildProgressLine(state);
+			if (line) console.log(getMessage(line));
 		}
 		function getMessage(message) {
-			if (logLevel >= LogLevel.verbose) return [styleText("dim", `[${(/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", {
-				hour12: false,
-				hour: "2-digit",
-				minute: "2-digit",
-				second: "2-digit"
-			})}]`), message].join(" ");
-			return message;
+			return formatMessage(message, logLevel);
 		}
 		function openGroup(name) {
 			console.log(`::group::${name}`);
@@ -761,7 +678,7 @@ const githubActionsLogger = defineLogger({
 			console.warn(`::warning::${text}`);
 		});
 		context.on("error", (error) => {
-			const caused = error.cause;
+			const caused = toCause(error);
 			if (logLevel <= LogLevel.silent) return;
 			const message = error.message || String(error);
 			console.error(`::error::${message}`);
@@ -793,11 +710,11 @@ const githubActionsLogger = defineLogger({
 			closeGroup("Configuration");
 		});
 		context.on("generation:start", (config) => {
-			state.totalPlugins = config.plugins?.length || 0;
+			reset();
+			state.totalPlugins = config.plugins?.length ?? 0;
 			const text = config.name ? `Generation for ${styleText("bold", config.name)}` : "Generation";
 			if (state.currentConfigs.length > 1) openGroup(text);
 			if (state.currentConfigs.length === 1) console.log(getMessage(text));
-			reset();
 		});
 		context.on("plugin:start", (plugin) => {
 			if (logLevel <= LogLevel.silent) return;
@@ -829,15 +746,12 @@ const githubActionsLogger = defineLogger({
 			const text = getMessage("Files written successfully");
 			console.log(text);
 			if (state.currentConfigs.length === 1) closeGroup("File Generation");
+			showProgressStep();
 		});
 		context.on("file:processing:update", () => {
 			if (logLevel <= LogLevel.silent) return;
 			state.processedFiles++;
 		});
-		context.on("files:processing:end", () => {
-			if (logLevel <= LogLevel.silent) return;
-			showProgressStep();
-		});
 		context.on("generation:end", (config) => {
 			const text = getMessage(config.name ? `${styleText("blue", "✓")} Generation completed for ${styleText("dim", config.name)}` : `${styleText("blue", "✓")} Generation completed`);
 			console.log(text);
@@ -867,66 +781,43 @@ const githubActionsLogger = defineLogger({
 			if (state.currentConfigs.length === 1) closeGroup("Linting");
 		});
 		context.on("hook:start", async ({ id, command, args }) => {
-			const commandWithArgs = args?.length ? `${command} ${args.join(" ")}` : command;
+			const commandWithArgs = formatCommandWithArgs(command, args);
 			const text = getMessage(`Hook ${styleText("dim", commandWithArgs)} started`);
 			if (logLevel > LogLevel.silent) {
 				if (state.currentConfigs.length === 1) openGroup(`Hook ${commandWithArgs}`);
 				console.log(text);
 			}
 			if (!id) return;
-			try {
-				const result = await x(command, [...args ?? []], {
-					nodeOptions: { detached: true },
-					throwOnError: true
-				});
-				await context.emit("debug", {
-					date: /* @__PURE__ */ new Date(),
-					logs: [result.stdout.trimEnd()]
-				});
-				if (logLevel > LogLevel.silent) console.log(result.stdout.trimEnd());
-				await context.emit("hook:end", {
-					command,
-					args,
-					id,
-					success: true,
-					error: null
-				});
-			} catch (err) {
-				const error = err;
-				const stderr = error.output?.stderr ?? "";
-				const stdout = error.output?.stdout ?? "";
-				await context.emit("debug", {
-					date: /* @__PURE__ */ new Date(),
-					logs: [stdout, stderr].filter(Boolean)
-				});
-				if (stderr) console.error(`::error::${stderr}`);
-				if (stdout) console.log(stdout);
-				const errorMessage = /* @__PURE__ */ new Error(`Hook execute failed: ${commandWithArgs}`);
-				await context.emit("hook:end", {
-					command,
-					args,
-					id,
-					success: false,
-					error: errorMessage
-				});
-				await context.emit("error", errorMessage);
-			}
+			await runHook({
+				id,
+				command,
+				args,
+				commandWithArgs,
+				context,
+				sink: {
+					onStdout: logLevel > LogLevel.silent ? (s) => console.log(s) : void 0,
+					onStderr: logLevel > LogLevel.silent ? (s) => console.error(`::error::${s}`) : void 0
+				}
+			});
 		});
 		context.on("hook:end", ({ command, args }) => {
 			if (logLevel <= LogLevel.silent) return;
-			const commandWithArgs = args?.length ? `${command} ${args.join(" ")}` : command;
+			const commandWithArgs = formatCommandWithArgs(command, args);
 			const text = getMessage(`Hook ${styleText("dim", commandWithArgs)} completed`);
 			console.log(text);
 			if (state.currentConfigs.length === 1) closeGroup(`Hook ${commandWithArgs}`);
 		});
 		context.on("generation:summary", (config, { status, hrStart, failedPlugins }) => {
-			const pluginsCount = config.plugins?.length || 0;
+			const pluginsCount = config.plugins?.length ?? 0;
 			const successCount = pluginsCount - failedPlugins.size;
 			const duration = formatHrtime(hrStart);
 			if (state.currentConfigs.length > 1) console.log(" ");
 			console.log(status === "success" ? `Kubb Summary: ${styleText("blue", "✓")} ${`${successCount} successful`}, ${pluginsCount} total, ${styleText("green", duration)}` : `Kubb Summary: ${styleText("blue", "✓")} ${`${successCount} successful`}, ✗ ${`${failedPlugins.size} failed`}, ${pluginsCount} total, ${styleText("green", duration)}`);
 			if (state.currentConfigs.length > 1) closeGroup(config.name ? `Generation for ${styleText("bold", config.name)}` : "Generation");
 		});
+		context.on("lifecycle:end", () => {
+			reset();
+		});
 	}
 });
 //#endregion
@@ -938,15 +829,9 @@ const githubActionsLogger = defineLogger({
 const plainLogger = defineLogger({
 	name: "plain",
 	install(context, options) {
-		const logLevel = options?.logLevel || 3;
+		const logLevel = options?.logLevel ?? LogLevel.info;
 		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;
+			return formatMessage(message, logLevel);
 		}
 		context.on("info", (message, info) => {
 			if (logLevel <= LogLevel.silent) return;
@@ -976,7 +861,7 @@ const plainLogger = defineLogger({
 			console.log(text);
 		});
 		context.on("error", (error) => {
-			const caused = error.cause;
+			const caused = toCause(error);
 			const text = getMessage(["✗", error.message].join(" "));
 			console.log(text);
 			if (logLevel >= LogLevel.debug && error.stack) {
@@ -1003,7 +888,7 @@ const plainLogger = defineLogger({
 			console.log(text);
 		});
 		context.on("generation:start", () => {
-			const text = getMessage("Configuration started");
+			const text = getMessage("Generation started");
 			console.log(text);
 		});
 		context.on("plugin:start", (plugin) => {
@@ -1057,51 +942,25 @@ const plainLogger = defineLogger({
 			console.log(text);
 		});
 		context.on("hook:start", async ({ id, command, args }) => {
-			const commandWithArgs = args?.length ? `${command} ${args.join(" ")}` : command;
+			const commandWithArgs = formatCommandWithArgs(command, args);
 			const text = getMessage(`Hook ${commandWithArgs} started`);
 			if (logLevel > LogLevel.silent) console.log(text);
 			if (!id) return;
-			try {
-				const result = await x(command, [...args ?? []], {
-					nodeOptions: { detached: true },
-					throwOnError: true
-				});
-				await context.emit("debug", {
-					date: /* @__PURE__ */ new Date(),
-					logs: [result.stdout.trimEnd()]
-				});
-				if (logLevel > LogLevel.silent) console.log(result.stdout.trimEnd());
-				await context.emit("hook:end", {
-					command,
-					args,
-					id,
-					success: true,
-					error: null
-				});
-			} catch (err) {
-				const error = err;
-				const stderr = error.output?.stderr ?? "";
-				const stdout = error.output?.stdout ?? "";
-				await context.emit("debug", {
-					date: /* @__PURE__ */ new Date(),
-					logs: [stdout, stderr].filter(Boolean)
-				});
-				if (stderr) console.error(stderr);
-				if (stdout) console.log(stdout);
-				const errorMessage = /* @__PURE__ */ new Error(`Hook execute failed: ${commandWithArgs}`);
-				await context.emit("hook:end", {
-					command,
-					args,
-					id,
-					success: false,
-					error: errorMessage
-				});
-				await context.emit("error", errorMessage);
-			}
+			await runHook({
+				id,
+				command,
+				args,
+				commandWithArgs,
+				context,
+				sink: {
+					onStdout: logLevel > LogLevel.silent ? (s) => console.log(s) : void 0,
+					onStderr: logLevel > LogLevel.silent ? (s) => console.error(s) : void 0
+				}
+			});
 		});
 		context.on("hook:end", ({ command, args }) => {
 			if (logLevel <= LogLevel.silent) return;
-			const text = getMessage(`Hook ${args?.length ? `${command} ${args.join(" ")}` : command} completed`);
+			const text = getMessage(`Hook ${formatCommandWithArgs(command, args)} completed`);
 			console.log(text);
 		});
 		context.on("generation:summary", (config, { pluginTimings, status, hrStart, failedPlugins, filesCreated }) => {
@@ -1113,14 +972,50 @@ const plainLogger = defineLogger({
 				hrStart,
 				pluginTimings: logLevel >= LogLevel.verbose ? pluginTimings : void 0
 			});
-			console.log("---------------------------");
+			console.log(SUMMARY_SEPARATOR);
 			console.log(summary.join("\n"));
-			console.log("---------------------------");
+			console.log(SUMMARY_SEPARATOR);
 		});
 	}
 });
 //#endregion
 //#region src/loggers/utils.ts
+/**
+* Optionally prefix a message with a [HH:MM:SS] timestamp when logLevel >= verbose.
+* Shared across all logger adapters to avoid duplication.
+*/
+function formatMessage(message, logLevel) {
+	if (logLevel >= LogLevel.verbose) return `${styleText("dim", `[${(/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", {
+		hour12: false,
+		hour: "2-digit",
+		minute: "2-digit",
+		second: "2-digit"
+	})}]`)} ${message}`;
+	return message;
+}
+/**
+* Build the progress summary line shared by clack and GitHub Actions loggers.
+* Returns null when there is nothing to display.
+*/
+function buildProgressLine(state) {
+	const parts = [];
+	const duration = formatHrtime(state.hrStart);
+	if (state.totalPlugins > 0) {
+		const pluginStr = state.failedPlugins > 0 ? `Plugins ${styleText("green", state.completedPlugins.toString())}/${state.totalPlugins} ${styleText("red", `(${state.failedPlugins} failed)`)}` : `Plugins ${styleText("green", state.completedPlugins.toString())}/${state.totalPlugins}`;
+		parts.push(pluginStr);
+	}
+	if (state.totalFiles > 0) parts.push(`Files ${styleText("green", state.processedFiles.toString())}/${state.totalFiles}`);
+	if (parts.length === 0) return null;
+	parts.push(`${styleText("green", duration)} elapsed`);
+	return parts.join(styleText("dim", " | "));
+}
+/**
+* Join a command and its optional args into a single display string.
+* e.g. ("prettier", ["--write", "."]) → "prettier --write ."
+*/
+function formatCommandWithArgs(command, args) {
+	return args?.length ? `${command} ${args.join(" ")}` : command;
+}
 function detectLogger() {
 	if (isGitHubActions()) return "github-actions";
 	if (canUseTTY()) return "clack";
@@ -1147,19 +1042,140 @@ async function executeHooks({ hooks, events }) {
 		const [cmd, ...args] = tokenize(command);
 		if (!cmd) continue;
 		const hookId = createHash("sha256").update(command).digest("hex");
+		const hookEndPromise = new Promise((resolve, reject) => {
+			const handler = ({ id, success, error }) => {
+				if (id !== hookId) return;
+				events.off("hook:end", handler);
+				if (!success) {
+					reject(error ?? /* @__PURE__ */ new Error(`Hook failed: ${command}`));
+					return;
+				}
+				events.emit("success", `${styleText("dim", command)} successfully executed`).then(resolve).catch(reject);
+			};
+			events.on("hook:end", handler);
+		});
 		await events.emit("hook:start", {
 			id: hookId,
 			command: cmd,
 			args
 		});
-		await events.onOnce("hook:end", async ({ success, error }) => {
-			if (!success) throw error;
-			await events.emit("success", `${styleText("dim", command)} successfully executed`);
-		});
+		await hookEndPromise;
+	}
+}
+//#endregion
+//#region src/utils/getCosmiConfig.ts
+const jiti = createJiti(import.meta.url, {
+	jsx: {
+		runtime: "automatic",
+		importSource: "@kubb/react-fabric"
+	},
+	sourceMaps: true,
+	interopDefault: true
+});
+const tsLoader = async (configFile) => {
+	return await jiti.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 (error) {
+		throw new Error("Config failed loading", { cause: error });
 	}
+	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, cb) {
+	const { watch } = await import("chokidar");
+	watch(path, {
+		ignorePermissionErrors: true,
+		ignored: WATCHER_IGNORED_PATHS
+	}).on("all", async (type, file) => {
+		console.log(styleText("yellow", styleText("bold", `Change detected: ${type} ${file}`)));
+		try {
+			await cb(path);
+		} catch (_e) {
+			console.log(styleText("red", "Watcher failed"));
+		}
+	});
 }
 //#endregion
 //#region src/runners/generate.ts
+async function runToolPass({ toolValue, detect, toolMap, toolLabel, successPrefix, noToolMessage, configName, outputPath, logLevel, events, onStart, onEnd }) {
+	await onStart();
+	let resolvedTool = toolValue;
+	if (resolvedTool === "auto") {
+		const detected = await detect();
+		if (!detected) await events.emit("warn", noToolMessage);
+		else {
+			resolvedTool = detected;
+			await events.emit("info", `Auto-detected ${toolLabel}: ${styleText("dim", resolvedTool)}`);
+		}
+	}
+	if (resolvedTool && resolvedTool !== "auto" && resolvedTool in toolMap) {
+		const toolConfig = toolMap[resolvedTool];
+		try {
+			const hookId = createHash("sha256").update([configName, resolvedTool].filter(Boolean).join("-")).digest("hex");
+			const hookEndPromise = new Promise((resolve, reject) => {
+				const handler = ({ id, success, error }) => {
+					if (id !== hookId) return;
+					events.off("hook:end", handler);
+					if (!success) {
+						reject(error ?? /* @__PURE__ */ new Error(`${toolConfig.errorMessage}`));
+						return;
+					}
+					events.emit("success", [
+						`${successPrefix} with ${styleText("dim", resolvedTool)}`,
+						logLevel >= LogLevel.info ? `on ${styleText("dim", outputPath)}` : void 0,
+						"successfully"
+					].filter(Boolean).join(" ")).then(resolve).catch(reject);
+				};
+				events.on("hook:end", handler);
+			});
+			await events.emit("hook:start", {
+				id: hookId,
+				command: toolConfig.command,
+				args: toolConfig.args(outputPath)
+			});
+			await hookEndPromise;
+		} catch (caughtError) {
+			const err = new Error(toolConfig.errorMessage);
+			err.cause = caughtError;
+			await events.emit("error", err);
+		}
+	}
+	await onEnd();
+}
 async function generate({ input, config: userConfig, events, logLevel }) {
 	const inputPath = input ?? ("path" in userConfig.input ? userConfig.input.path : void 0);
 	const hrStart = process$1.hrtime();
@@ -1196,9 +1212,8 @@ async function generate({ input, config: userConfig, events, logLevel }) {
 	});
 	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);
-		});
+		const allErrors = [error, ...Array.from(failedPlugins).filter((it) => it.error).map((it) => it.error)].filter(Boolean);
+		for (const err of allErrors) await events.emit("error", err);
 		await events.emit("generation:end", config, files, sources);
 		await events.emit("generation:summary", config, {
 			failedPlugins,
@@ -1222,80 +1237,35 @@ async function generate({ input, config: userConfig, events, logLevel }) {
 	}
 	await events.emit("success", "Generation successfully", inputPath);
 	await events.emit("generation:end", config, files, sources);
-	if (config.output.format) {
-		await events.emit("format:start");
-		let formatter = config.output.format;
-		if (formatter === "auto") {
-			const detectedFormatter = await detectFormatter();
-			if (!detectedFormatter) await events.emit("warn", "No formatter found (biome, prettier, or oxfmt). Skipping formatting.");
-			else {
-				formatter = detectedFormatter;
-				await events.emit("info", `Auto-detected formatter: ${styleText("dim", formatter)}`);
-			}
-		}
-		if (formatter && formatter !== "auto" && formatter in formatters) {
-			const formatterConfig = formatters[formatter];
-			const outputPath = path.resolve(config.root, config.output.path);
-			try {
-				const hookId = createHash("sha256").update([config.name, formatter].filter(Boolean).join("-")).digest("hex");
-				await events.emit("hook:start", {
-					id: hookId,
-					command: formatterConfig.command,
-					args: formatterConfig.args(outputPath)
-				});
-				await events.onOnce("hook:end", async ({ success, error }) => {
-					if (!success) throw error;
-					await events.emit("success", [
-						`Formatting with ${styleText("dim", formatter)}`,
-						logLevel >= LogLevel.info ? `on ${styleText("dim", outputPath)}` : void 0,
-						"successfully"
-					].filter(Boolean).join(" "));
-				});
-			} catch (caughtError) {
-				const error = new Error(formatterConfig.errorMessage);
-				error.cause = caughtError;
-				await events.emit("error", error);
-			}
-		}
-		await events.emit("format:end");
-	}
-	if (config.output.lint) {
-		await events.emit("lint:start");
-		let linter = config.output.lint;
-		if (linter === "auto") {
-			const detectedLinter = await detectLinter();
-			if (!detectedLinter) await events.emit("warn", "No linter found (biome, oxlint, or eslint). Skipping linting.");
-			else {
-				linter = detectedLinter;
-				await events.emit("info", `Auto-detected linter: ${styleText("dim", linter)}`);
-			}
-		}
-		if (linter && linter !== "auto" && linter in linters) {
-			const linterConfig = linters[linter];
-			const outputPath = path.resolve(config.root, config.output.path);
-			try {
-				const hookId = createHash("sha256").update([config.name, linter].filter(Boolean).join("-")).digest("hex");
-				await events.emit("hook:start", {
-					id: hookId,
-					command: linterConfig.command,
-					args: linterConfig.args(outputPath)
-				});
-				await events.onOnce("hook:end", async ({ success, error }) => {
-					if (!success) throw error;
-					await events.emit("success", [
-						`Linting with ${styleText("dim", linter)}`,
-						logLevel >= LogLevel.info ? `on ${styleText("dim", outputPath)}` : void 0,
-						"successfully"
-					].filter(Boolean).join(" "));
-				});
-			} catch (caughtError) {
-				const error = new Error(linterConfig.errorMessage);
-				error.cause = caughtError;
-				await events.emit("error", error);
-			}
-		}
-		await events.emit("lint:end");
-	}
+	const outputPath = path.resolve(config.root, config.output.path);
+	if (config.output.format) await runToolPass({
+		toolValue: config.output.format,
+		detect: detectFormatter,
+		toolMap: formatters,
+		toolLabel: "formatter",
+		successPrefix: "Formatting",
+		noToolMessage: "No formatter found (biome, prettier, or oxfmt). Skipping formatting.",
+		configName: config.name,
+		outputPath,
+		logLevel,
+		events,
+		onStart: () => events.emit("format:start"),
+		onEnd: () => events.emit("format:end")
+	});
+	if (config.output.lint) await runToolPass({
+		toolValue: config.output.lint,
+		detect: detectLinter,
+		toolMap: linters,
+		toolLabel: "linter",
+		successPrefix: "Linting",
+		noToolMessage: "No linter found (biome, oxlint, or eslint). Skipping linting.",
+		configName: config.name,
+		outputPath,
+		logLevel,
+		events,
+		onStart: () => events.emit("lint:start"),
+		onEnd: () => events.emit("lint:end")
+	});
 	if (config.hooks) {
 		await events.emit("hooks:start");
 		await executeHooks({
@@ -1304,11 +1274,10 @@ async function generate({ input, config: userConfig, events, logLevel }) {
 		});
 		await events.emit("hooks:end");
 	}
-	const generationStatus = failedPlugins.size > 0 || error ? "failed" : "success";
 	await events.emit("generation:summary", config, {
 		failedPlugins,
 		filesCreated: files.length,
-		status: generationStatus,
+		status: "success",
 		hrStart,
 		pluginTimings
 	});
@@ -1321,183 +1290,59 @@ async function generate({ input, config: userConfig, events, logLevel }) {
 		})),
 		hrStart,
 		filesCreated: files.length,
-		status: generationStatus
+		status: "success"
 	}));
 }
-//#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,
-		interopDefault: 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 (error) {
-		throw new Error("Config failed loading", { cause: error });
-	}
-	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, cb) {
-	const { watch } = await import("chokidar");
-	watch(path, {
-		ignorePermissionErrors: true,
-		ignored: "**/{.git,node_modules}/**"
-	}).on("all", async (type, file) => {
-		console.log(styleText("yellow", styleText("bold", `Change detected: ${type} ${file}`)));
+async function runGenerateCommand({ input, configPath, logLevel: logLevelKey, watch }) {
+	const logLevel = LogLevel[logLevelKey] ?? LogLevel.info;
+	const events = new AsyncEventEmitter();
+	const promiseManager = new PromiseManager();
+	await setupLogger(events, { logLevel });
+	await executeIfOnline(async () => {
 		try {
-			await cb(path);
-		} catch (_e) {
-			console.log(styleText("red", "Watcher failed"));
-		}
+			const latestVersion = (await (await fetch(KUBB_NPM_PACKAGE_URL)).json()).version;
+			if (latestVersion && version < latestVersion) await events.emit("version:new", version, latestVersion);
+		} catch {}
 	});
-}
-//#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
-		},
-		silent: {
-			type: "boolean",
-			description: "Override logLevel to silent",
-			alias: "s",
-			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";
-		if (args.silent) args.logLevel = "silent";
-		const logLevel = LogLevel[args.logLevel] || 3;
-		await setupLogger(events, { logLevel });
-		await executeIfOnline(async () => {
-			try {
-				const latestVersion = (await (await fetch("https://registry.npmjs.org/@kubb/cli/latest")).json()).version;
-				if (latestVersion && version < latestVersion) await events.emit("version:new", version, latestVersion);
-			} catch {}
-		});
-		try {
-			const result = await getCosmiConfig("kubb", args.config);
-			const configs = await getConfigs(result.config, args);
-			await events.emit("config:start");
-			await events.emit("info", "Config loaded", path.relative(process$2.cwd(), result.filepath));
-			await events.emit("success", "Config loaded successfully", path.relative(process$2.cwd(), result.filepath));
-			await events.emit("config:end", configs);
-			await events.emit("lifecycle:start", version);
-			const promises = configs.map((config) => {
-				return async () => {
-					if (isInputPath(config) && args.watch) {
-						await startWatcher([input || config.input.path], async (paths) => {
-							events.removeAll();
-							await generate({
-								input,
-								config,
-								logLevel,
-								events
-							});
-							clack.log.step(styleText("yellow", `Watching for changes in ${paths.join(" and ")}`));
+	try {
+		const result = await getCosmiConfig("kubb", configPath);
+		const configs = await getConfigs(result.config, { input });
+		await events.emit("config:start");
+		await events.emit("info", "Config loaded", path.relative(process$1.cwd(), result.filepath));
+		await events.emit("success", "Config loaded successfully", path.relative(process$1.cwd(), result.filepath));
+		await events.emit("config:end", configs);
+		await events.emit("lifecycle:start", version);
+		const promises = configs.map((config) => {
+			return async () => {
+				if (isInputPath(config) && watch) {
+					await startWatcher([input || config.input.path], async (paths) => {
+						events.removeAll();
+						await generate({
+							input,
+							config,
+							logLevel,
+							events
 						});
-						return;
-					}
-					await generate({
-						input,
-						config,
-						logLevel,
-						events
+						clack.log.step(styleText("yellow", `Watching for changes in ${paths.join(" and ")}`));
 					});
-				};
-			});
-			await promiseManager.run("seq", promises);
-			await events.emit("lifecycle:end");
-		} catch (error) {
-			await events.emit("error", error);
-			process$2.exit(1);
-		}
+					return;
+				}
+				await generate({
+					input,
+					config,
+					logLevel,
+					events
+				});
+			};
+		});
+		await promiseManager.run("seq", promises);
+		await events.emit("lifecycle:end");
+	} catch (error) {
+		await events.emit("error", toError(error));
+		process$1.exit(1);
 	}
-});
+}
 //#endregion
-export { command as default };
+export { runGenerateCommand };
 
-//# sourceMappingURL=generate-zZuxBP8z.js.map
+//# sourceMappingURL=generate-HP5ySfjV.js.map