@kubb/cli 5.3.7 → 5.3.9

package/dist/{utils-CMU1rLfY.cjs → utils-BP0xq5AK.cjs}

@@ -1,8 +1,8 @@
 const require_rolldown_runtime = require("./rolldown-runtime-qbf5tadS.cjs");
 const require_errors = require("./errors-C-wEou02.cjs");
 const require_agent = require("./agent-BPqs9VRj.cjs");
-const require_Telemetry = require("./Telemetry-CvHQevSK.cjs");
-const require_output = require("./output-kmklyYIv.cjs");
+const require_Telemetry = require("./Telemetry-B3kc9gFh.cjs");
+const require_output = require("./output-DBBTlqPw.cjs");
 let node_util = require("node:util");
 let node_crypto = require("node:crypto");
 let node_process = require("node:process");
@@ -123,608 +123,444 @@ function tokenize(command) {
 	return (command.match(/[^\s"']+|"([^"]*)"|'([^']*)'/g) ?? []).map((token) => token.replace(/^["']|["']$/g, ""));
 }
 //#endregion
-//#region ../../internals/utils/src/time.ts
+//#region src/loggers/createLogger.ts
 /**
-* Calculates elapsed time in milliseconds from a high-resolution `process.hrtime` start time.
-* Rounds to 2 decimal places for sub-millisecond precision without noise.
-*
-* @example
-* ```ts
-* const start = process.hrtime()
-* doWork()
-* getElapsedMs(start) // 42.35
-* ```
-*/
-function getElapsedMs(hrStart) {
-	const [seconds, nanoseconds] = process.hrtime(hrStart);
-	const ms = seconds * 1e3 + nanoseconds / 1e6;
-	return Math.round(ms * 100) / 100;
-}
-/**
-* Converts a millisecond duration into a human-readable string (`ms`, `s`, or `m s`).
-*
-* @example
-* ```ts
-* formatMs(250)   // '250ms'
-* formatMs(1500)  // '1.50s'
-* formatMs(90000) // '1m 30.0s'
-* ```
-*/
-function formatMs(ms) {
-	if (ms >= 6e4) return `${Math.floor(ms / 6e4)}m ${(ms % 6e4 / 1e3).toFixed(1)}s`;
-	if (ms >= 1e3) return `${(ms / 1e3).toFixed(2)}s`;
-	return `${Math.round(ms)}ms`;
-}
-//#endregion
-//#region src/loggers/banner.ts
-/**
-* Parses a CSS hex color string (`#RGB`) into its RGB channels.
-* Falls back to `255` for any channel that cannot be parsed.
-*/
-function parseHex(color) {
-	const int = Number.parseInt(color.replace("#", ""), 16);
-	return Number.isNaN(int) ? {
-		r: 255,
-		g: 255,
-		b: 255
-	} : {
-		r: int >> 16 & 255,
-		g: int >> 8 & 255,
-		b: int & 255
-	};
-}
-/**
-* Returns a function that wraps a string in a 24-bit ANSI true-color escape sequence
-* for the given hex color.
-*/
-function hex(color) {
-	const { r, g, b } = parseHex(color);
-	return (text) => `\x1b[38;2;${r};${g};${b}m${text}\x1b[0m`;
-}
-function gradient(colorStops, text) {
-	const chars = text.split("");
-	return chars.map((char, i) => {
-		const t = chars.length <= 1 ? 0 : i / (chars.length - 1);
-		const seg = Math.min(Math.floor(t * (colorStops.length - 1)), colorStops.length - 2);
-		const lt = t * (colorStops.length - 1) - seg;
-		const from = parseHex(colorStops[seg]);
-		const to = parseHex(colorStops[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("");
-}
-/**
-* ANSI color functions for each part of the Kubb mascot illustration.
+* The three output phases, in the order the generate runner runs them.
 */
-const palette = {
-	/**
-	* Top cap of the skittle.
-	*/
-	lid: hex("#F55A17"),
-	/**
-	* Upper wood body.
-	*/
-	woodTop: hex("#F5A217"),
-	/**
-	* Middle wood body.
-	*/
-	woodMid: hex("#F58517"),
-	/**
-	* Base wood body.
-	*/
-	woodBase: hex("#B45309"),
-	/**
-	* Eye whites.
-	*/
-	eye: hex("#FFFFFF"),
-	/**
-	* Highlight accent.
-	*/
-	highlight: hex("#adadc6"),
-	/**
-	* Cheek blush.
-	*/
-	blush: hex("#FDA4AF")
+const PHASES = {
+	format: {
+		running: "Formatting",
+		success: "Formatted",
+		failure: "Formatting failed"
+	},
+	lint: {
+		running: "Linting",
+		success: "Linted",
+		failure: "Linting failed"
+	},
+	hooks: {
+		running: "Running post-generate hooks",
+		success: "Post-generate hooks completed",
+		failure: "Post-generate hooks failed",
+		showHookResults: true
+	}
 };
 /**
-* Generates the Kubb mascot welcome banner as an ANSI-colored string.
-*
-* @example
-* ```ts
-* console.log(getIntro({ title: 'kubb.config.ts', description: 'generating…', version: '5.0.0', areEyesOpen: true }))
-* ```
+* Drops the blank lines a subprocess leaves at either end of its output, so its block does not open
+* or close on an empty row.
 */
-function getIntro({ title, description, version, areEyesOpen }) {
-	const kubbVersion = gradient([
-		"#F58517",
-		"#F5A217",
-		"#F55A17"
-	], `KUBB v${version}`);
-	const eyeTop = areEyesOpen ? palette.eye("█▀█") : palette.eye("───");
-	const eyeBottom = areEyesOpen ? palette.eye("▀▀▀") : palette.eye("───");
-	return `
-   ${palette.lid("▄▄▄▄▄▄▄▄▄▄▄▄▄")}
-  ${palette.woodTop("█  ")}${palette.highlight("▄▄")}${palette.woodTop("     ")}${palette.highlight("▄▄")}${palette.woodTop("  █")}  ${kubbVersion}
-  ${palette.woodMid("█ ")}${eyeTop}${palette.woodMid("     ")}${eyeTop}${palette.woodMid(" █")}  ${(0, node_util.styleText)("gray", title)}
-  ${palette.woodMid("█ ")}${eyeBottom}${palette.woodMid("  ")}${palette.blush("◡")}${palette.woodMid("  ")}${eyeBottom}${palette.woodMid(" █")}  ${(0, node_util.styleText)("yellow", "➜")} ${(0, node_util.styleText)("white", description)}
-   ${palette.woodBase("▀▀▀▀▀▀▀▀▀▀▀▀▀")}
-`;
+function trimBlankEdges(lines) {
+	const start = lines.findIndex((line) => line.trim());
+	if (start === -1) return [];
+	return lines.slice(start, lines.findLastIndex((line) => line.trim()) + 1);
 }
 /**
-* Formats a millisecond duration with a threshold-based ANSI color.
-* `≤ 500 ms` → green · `≤ 1 000 ms` → yellow · `> 1 000 ms` → red.
+* Wires a {@link LoggerWriter} onto the run's hooks. This owns what a run says and in what order:
+* one group per config, a step over the plugin work, a progress bar for the writes, one step per
+* output phase, then the summary and the group's closing result. The writer only decides how each
+* line looks, so every logger reports the same run the same way.
 *
 * @example
 * ```ts
-* formatMsWithColor(200)  // '\x1b[32m200ms\x1b[39m'
-* formatMsWithColor(800)  // '\x1b[33m800ms\x1b[39m'
-* formatMsWithColor(1500) // '\x1b[31m1.50s\x1b[39m'
+* export const plainLogger = { name: 'plain', install: (context, options) => createLogger(writer)(context, options) }
 * ```
 */
-function formatMsWithColor(ms) {
-	const formatted = formatMs(ms);
-	if (ms <= 500) return (0, node_util.styleText)("green", formatted);
-	if (ms <= 1e3) return (0, node_util.styleText)("yellow", formatted);
-	return (0, node_util.styleText)("red", formatted);
-}
-//#endregion
-//#region src/loggers/clackLogger.ts
-/**
-* TTY logger for local development, with spinners and progress bars.
-*/
-const clackLogger = {
-	name: "clack",
-	install(context, options) {
+function createLogger(writer) {
+	return function install(context, options) {
 		const logLevel = options?.logLevel ?? _kubb_core.logLevel.info;
+		const silent = logLevel <= _kubb_core.logLevel.silent;
 		const state = {
 			...createProgressCounters(),
-			spinner: _clack_prompts.spinner(),
-			isSpinning: false,
-			runningPlugins: /* @__PURE__ */ new Set(),
-			activeProgress: /* @__PURE__ */ new Map(),
-			activeHookLogs: /* @__PURE__ */ new Map()
+			spinner: null,
+			progress: null,
+			hooks: /* @__PURE__ */ new Map(),
+			/**
+			* Plugin results held back while the generation step owns the line.
+			*/
+			pluginLines: [],
+			phase: null,
+			groupOpen: false
 		};
-		function stopActiveProgress() {
-			for (const [, active] of state.activeProgress) {
-				if (active.interval) clearInterval(active.interval);
-				active.progressBar?.stop();
+		function text(message) {
+			return formatMessage(message, logLevel);
+		}
+		function startSpinner(message) {
+			if (silent) return;
+			state.spinner = writer.spinner();
+			state.spinner.start(text(message));
+		}
+		function stopSpinner(message, status = "success") {
+			const spinner = state.spinner;
+			if (!spinner) return;
+			state.spinner = null;
+			if (message === void 0) {
+				spinner.clear();
+				return;
+			}
+			if (status === "failed") {
+				spinner.error(text(message));
+				return;
 			}
-			state.activeProgress.clear();
+			spinner.stop(text(message));
 		}
-		function reset() {
-			stopActiveProgress();
-			resetProgressCounters(state);
-			state.spinner = _clack_prompts.spinner();
-			state.isSpinning = false;
-			state.runningPlugins.clear();
-			state.activeHookLogs.clear();
+		function stopProgress(message) {
+			const progress = state.progress;
+			if (!progress) return;
+			state.progress = null;
+			progress.stop(message === void 0 ? "" : text(message));
 		}
-		function pluginProgressText() {
-			const running = [...state.runningPlugins].map((name) => (0, node_util.styleText)("bold", name));
-			return getMessage(running.length > 0 ? `Generating ${running.join(", ")}` : "Generating plugins");
+		function startPhase({ running, success, failure, showHookResults = false }) {
+			state.phase = {
+				successLabel: success,
+				failureLabel: failure,
+				showHookResults,
+				failed: false,
+				hrStart: node_process.default.hrtime(),
+				lines: [],
+				output: []
+			};
+			startSpinner(running);
 		}
-		function showProgressStep() {
-			if (logLevel <= _kubb_core.logLevel.silent) return;
-			const line = buildProgressLine(state);
-			if (line) _clack_prompts.log.step(getMessage(line));
+		function endPhase() {
+			const phase = state.phase;
+			state.phase = null;
+			if (!phase || silent) return;
+			const duration = require_output.formatMsWithColor(require_output.getElapsedMs(phase.hrStart));
+			stopSpinner(phase.failed ? `${phase.failureLabel} after ${duration}` : `${phase.successLabel} in ${duration}`, phase.failed ? "failed" : "success");
+			if (phase.lines.length) writer.block(phase.lines);
+			writeOutput(phase.output);
 		}
-		function getMessage(message) {
-			return formatMessage(message, logLevel);
+		function writeOutput(lines) {
+			const output = trimBlankEdges(lines);
+			if (output.length) writer.raw(output);
 		}
-		function onStep(hook, message) {
-			context.hook(hook, () => {
-				if (logLevel <= _kubb_core.logLevel.silent) return;
-				_clack_prompts.log.step(getMessage(message));
-			});
+		function closeGroup(status) {
+			if (!state.groupOpen) return;
+			state.groupOpen = false;
+			stopSpinner();
+			stopProgress();
+			writer.groupEnd(status === "failed" ? (0, node_util.styleText)("red", "✗ Generation failed") : (0, node_util.styleText)("green", "✓ Generation succeeded"));
 		}
-		function stopSpinner(text) {
-			if (!state.isSpinning) return;
-			state.spinner.stop(text);
-			state.isSpinning = false;
+		function reset() {
+			stopSpinner();
+			stopProgress();
+			resetProgressCounters(state);
+			state.hooks.clear();
+			state.pluginLines = [];
+			state.phase = null;
+			state.groupOpen = false;
 		}
-		context.hook("kubb:info", ({ message, info = "" }) => {
-			if (logLevel <= _kubb_core.logLevel.silent) return;
-			const text = getMessage([
+		context.hook("kubb:info", ({ message, info }) => {
+			if (silent) return;
+			const line = text([
 				(0, node_util.styleText)("blue", "ℹ"),
 				message,
 				info ? (0, node_util.styleText)("dim", info) : void 0
 			].filter(Boolean).join(" "));
-			if (state.isSpinning) {
-				state.spinner.message(text);
+			if (state.phase) {
+				state.phase.lines.push(line);
+				return;
+			}
+			if (state.spinner) {
+				state.spinner.message(line);
 				return;
 			}
-			_clack_prompts.log.info(text);
+			writer.info(line);
 		});
-		context.hook("kubb:success", ({ message, info = "" }) => {
-			if (logLevel <= _kubb_core.logLevel.silent) return;
-			const text = getMessage([
-				(0, node_util.styleText)("blue", "✓"),
+		context.hook("kubb:success", ({ message, info }) => {
+			if (silent) return;
+			const line = text([
+				(0, node_util.styleText)("green", "✓"),
 				message,
-				logLevel >= _kubb_core.logLevel.info ? (0, node_util.styleText)("dim", info) : void 0
+				logLevel >= _kubb_core.logLevel.info && info ? (0, node_util.styleText)("dim", info) : void 0
 			].filter(Boolean).join(" "));
-			if (state.isSpinning) {
-				stopSpinner(text);
+			if (state.spinner) {
+				state.spinner.message(line);
 				return;
 			}
-			_clack_prompts.log.success(text);
+			writer.success(line);
 		});
 		context.hook("kubb:warn", ({ message, info }) => {
 			if (logLevel < _kubb_core.logLevel.warn) return;
-			const text = getMessage([
+			writer.warn(text([
 				(0, node_util.styleText)("yellow", "⚠"),
 				message,
 				logLevel >= _kubb_core.logLevel.info && info ? (0, node_util.styleText)("dim", info) : void 0
-			].filter(Boolean).join(" "));
-			_clack_prompts.log.warn(text);
+			].filter(Boolean).join(" ")));
 		});
 		context.hook("kubb:error", ({ error }) => {
-			const text = [(0, node_util.styleText)("red", "✗"), error.message].join(" ");
-			if (state.isSpinning) {
-				stopSpinner(getMessage(text));
-				return;
-			}
-			_clack_prompts.log.error(getMessage(text));
+			if (state.phase) state.phase.failed = true;
+			const line = [(0, node_util.styleText)("red", "✗"), error.message].join(" ");
+			if (state.spinner) stopSpinner(line, "failed");
+			else writer.error(text(line));
 			const frames = logLevel >= _kubb_core.logLevel.verbose ? formatErrorFrames(error) : null;
-			if (frames) {
-				for (const frame of frames.frames) _clack_prompts.log.message(getMessage((0, node_util.styleText)("dim", frame)));
-				if (frames.cause) {
-					_clack_prompts.log.message((0, node_util.styleText)("dim", frames.cause.header));
-					for (const frame of frames.cause.frames) _clack_prompts.log.message(getMessage(`    ${(0, node_util.styleText)("dim", frame)}`));
-				}
-			}
+			if (!frames) return;
+			writer.block(frames.frames.map((frame) => text((0, node_util.styleText)("dim", frame))));
+			if (frames.cause) writer.block([(0, node_util.styleText)("dim", frames.cause.header), ...frames.cause.frames.map((frame) => text(`    ${(0, node_util.styleText)("dim", frame)}`))]);
 		});
 		context.hook("kubb:diagnostic", ({ diagnostic }) => {
-			if (logLevel <= _kubb_core.logLevel.silent && diagnostic.severity !== "error") return;
+			if (silent && diagnostic.severity !== "error") return;
 			stopSpinner();
-			stopActiveProgress();
+			stopProgress();
 			if (_kubb_core.Diagnostics.isUpdate(diagnostic)) {
-				_clack_prompts.box(`\`v${diagnostic.currentVersion}\` → \`v${diagnostic.latestVersion}\`
-Run \`npm install -g @kubb/cli\` to update`, "Update available for `Kubb`", {
-					width: "auto",
-					formatBorder: (s) => (0, node_util.styleText)("yellow", s),
-					rounded: true,
-					withGuide: false,
-					contentAlign: "center",
-					titleAlign: "center"
-				});
+				writer.update([`\`v${diagnostic.currentVersion}\` → \`v${diagnostic.latestVersion}\``, "Run `npm install -g @kubb/cli` to update"], "Update available for `Kubb`");
 				return;
 			}
 			const { headline, details } = _kubb_core.Diagnostics.format(diagnostic);
-			_clack_prompts.log.message([headline, ...details], {
-				symbol: "",
-				secondarySymbol: ""
-			});
+			writer.diagnostic([headline, ...details]);
 		});
 		context.hook("studio:connecting", ({ url }) => {
-			if (logLevel <= _kubb_core.logLevel.silent) return;
-			state.spinner = _clack_prompts.spinner();
-			state.spinner.start(getMessage(`Connecting to ${(0, node_util.styleText)("cyan", url)}`));
-			state.isSpinning = true;
+			startSpinner(`Connecting to ${(0, node_util.styleText)("cyan", url)}`);
 		});
 		context.hook("studio:connected", ({ url, versions }) => {
-			if (logLevel <= _kubb_core.logLevel.silent) return;
-			const text = getMessage(`Connected to ${(0, node_util.styleText)("cyan", url)} ${(0, node_util.styleText)("dim", `(${formatVersions(versions)})`)}`);
-			if (state.isSpinning) {
-				stopSpinner(text);
+			if (silent) return;
+			const line = `Connected to ${(0, node_util.styleText)("cyan", url)} ${(0, node_util.styleText)("dim", `(${formatVersions(versions)})`)}`;
+			if (state.spinner) {
+				stopSpinner(line);
 				return;
 			}
-			_clack_prompts.log.success(text);
+			writer.success(text(`✓ ${line}`));
 		});
 		context.hook("studio:ready", () => {
-			if (logLevel <= _kubb_core.logLevel.silent) return;
-			_clack_prompts.log.success(getMessage("Ready to receive jobs"));
+			if (silent) return;
+			startSpinner("✓ Ready to receive jobs");
 		});
 		context.hook("studio:disconnected", ({ reason }) => {
 			if (logLevel < _kubb_core.logLevel.warn) return;
 			stopSpinner();
-			_clack_prompts.log.warn(getMessage(`Kubb Studio ended the session (${reason})`));
+			writer.warn(text(`⚠ Kubb Studio ended the session (${reason})`));
 		});
 		context.hook("studio:command:start", ({ command }) => {
-			if (logLevel <= _kubb_core.logLevel.silent) return;
-			_clack_prompts.log.info(getMessage(`Kubb Studio asked to ${(0, node_util.styleText)("bold", command)}`));
+			if (silent) return;
+			stopSpinner();
+			writer.info(text(`Kubb Studio asked to ${(0, node_util.styleText)("bold", command)}`));
 		});
 		context.hook("studio:command:end", ({ command, info }) => {
-			if (logLevel <= _kubb_core.logLevel.silent) return;
-			_clack_prompts.log.success(getMessage(`Finished ${command}${info ? ` ${(0, node_util.styleText)("dim", `(${info})`)}` : ""}`));
+			if (silent) return;
+			writer.success(text(`✓ Finished ${command}${info ? ` ${(0, node_util.styleText)("dim", `(${info})`)}` : ""}`));
+			startSpinner("✓ Ready to receive jobs");
 		});
 		context.hook("studio:warn", ({ message }) => {
 			if (logLevel < _kubb_core.logLevel.warn) return;
-			_clack_prompts.log.warn(getMessage(message));
+			writer.warn(text(`⚠ ${message}`));
 		});
 		context.hook("studio:error", ({ error }) => {
-			const text = getMessage([(0, node_util.styleText)("red", "✗"), error.message].join(" "));
-			if (state.isSpinning) {
-				stopSpinner(text);
+			const line = `✗ ${error.message}`;
+			if (state.spinner) {
+				stopSpinner(line, "failed");
 				return;
 			}
-			_clack_prompts.log.error(text);
+			writer.error(text(line));
 		});
-		context.hook("kubb:lifecycle:start", async ({ version }) => {
-			console.log(`\n${getIntro({
-				title: "The meta framework for code generation",
-				description: "Ready to start",
-				version,
-				areEyesOpen: true
-			})}\n`);
+		context.hook("kubb:lifecycle:start", () => {
 			reset();
 		});
 		context.hook("kubb:generation:start", ({ config }) => {
+			closeGroup("failed");
 			reset();
 			state.totalPlugins = config.plugins?.length ?? 0;
-			if (logLevel <= _kubb_core.logLevel.silent) return;
-			const text = getMessage([
-				"Generation started",
-				config.name ? `for ${(0, node_util.styleText)("dim", config.name)}` : void 0,
-				getInputPath(config)
-			].filter(Boolean).join(" "));
-			_clack_prompts.intro(text);
+			if (silent) return;
+			const inputPath = getInputPath(config);
+			writer.group(text([(0, node_util.styleText)("bold", config.name ?? "kubb"), inputPath ? (0, node_util.styleText)("dim", inputPath) : void 0].filter(Boolean).join(" ")));
+			state.groupOpen = true;
+			startSpinner("Generating");
 		});
 		context.hook("kubb:plugin:start", ({ plugin }) => {
-			if (logLevel <= _kubb_core.logLevel.silent) return;
-			stopSpinner();
-			state.runningPlugins.add(plugin.name);
-			const active = state.activeProgress.get("plugins");
-			if (active) {
-				active.progressBar.advance(0, pluginProgressText());
-				return;
-			}
-			const progressBar = _clack_prompts.progress({
-				style: "block",
-				max: Math.max(state.totalPlugins, 1),
-				size: 30
-			});
-			progressBar.start(pluginProgressText());
-			progressBar.advance(state.completedPlugins + state.failedPlugins, pluginProgressText());
-			state.activeProgress.set("plugins", { progressBar });
+			if (silent) return;
+			state.spinner?.message(text(`Generating ${(0, node_util.styleText)("dim", plugin.name)}`));
 		});
-		context.hook("kubb:plugin:end", ({ plugin, success }) => {
-			stopSpinner();
-			const active = state.activeProgress.get("plugins");
-			if (!active || logLevel <= _kubb_core.logLevel.silent) return;
-			state.runningPlugins.delete(plugin.name);
+		context.hook("kubb:plugin:end", ({ plugin, duration, success }) => {
+			if (silent) return;
 			recordPluginResult(state, success);
-			active.progressBar.advance(1, pluginProgressText());
-			if (state.runningPlugins.size === 0) {
-				active.progressBar.stop(getMessage("Plugins generated"));
-				state.activeProgress.delete("plugins");
-				showProgressStep();
+			state.pluginLines.push(text(`${plugin.name} ${success ? "completed" : "failed"} in ${require_output.formatMsWithColor(duration)}`));
+		});
+		context.hook("kubb:plugins:end", () => {
+			if (silent) return;
+			const failed = state.failedPlugins > 0;
+			stopSpinner(buildProgressLine(state) ?? "No plugins ran", failed ? "failed" : "success");
+			if (state.pluginLines.length) {
+				writer.block(state.pluginLines);
+				state.pluginLines = [];
 			}
 		});
 		context.hook("kubb:files:processing:start", ({ files }) => {
-			if (logLevel <= _kubb_core.logLevel.silent) return;
+			if (silent) return;
 			stopSpinner();
 			state.totalFiles = files.length;
 			state.processedFiles = 0;
-			const text = `Writing ${files.length} files`;
-			const progressBar = _clack_prompts.progress({
-				style: "block",
-				max: files.length,
-				size: 30
-			});
-			context.callHook("kubb:info", { message: text });
-			progressBar.start(getMessage(text));
-			state.activeProgress.set("files", { progressBar });
+			state.progress = writer.progress(files.length);
+			state.progress.start(text(`Writing ${pluralize(files.length, "file")}`));
 		});
 		context.hook("kubb:files:processing:update", ({ files }) => {
-			if (logLevel <= _kubb_core.logLevel.silent) return;
-			stopSpinner();
-			const active = state.activeProgress.get("files");
+			if (silent) return;
 			for (const { file, config } of files) {
 				state.processedFiles++;
-				if (active) active.progressBar.advance(void 0, `Writing ${(0, node_path.relative)(config.root, file.path)}`);
+				state.progress?.advance(`Writing ${(0, node_path.relative)(config.root, file.path)}`);
 			}
 		});
 		context.hook("kubb:files:processing:end", () => {
-			if (logLevel <= _kubb_core.logLevel.silent) return;
-			stopSpinner();
-			const text = getMessage("Files written successfully");
-			const active = state.activeProgress.get("files");
-			if (!active) return;
-			active.progressBar.stop(text);
-			state.activeProgress.delete("files");
-			showProgressStep();
-		});
-		context.hook("kubb:generation:end", ({ config }) => {
-			stopSpinner();
-			const text = getMessage(config.name ? `Generation completed for ${(0, node_util.styleText)("dim", config.name)}` : "Generation completed");
-			_clack_prompts.outro(text);
+			if (silent) return;
+			stopProgress(`Wrote ${pluralize(state.processedFiles, "file")}`);
 		});
-		onStep("kubb:format:start", "Formatting");
-		onStep("kubb:lint:start", "Linting");
-		onStep("kubb:hooks:start", "Running hooks");
-		context.hook("kubb:hook:start", ({ id, command, name, args }) => {
-			if (logLevel <= _kubb_core.logLevel.silent || !id) return;
-			stopSpinner();
-			const commandWithArgs = formatCommandWithArgs(command, args);
-			const title = getMessage(`Running ${(0, node_util.styleText)("dim", name ?? commandWithArgs)}`);
-			const taskLog = _clack_prompts.taskLog({ title });
-			state.activeHookLogs.set(id, {
-				taskLog,
-				hrStart: node_process.default.hrtime()
+		context.hook("kubb:format:start", () => startPhase(PHASES.format));
+		context.hook("kubb:format:end", endPhase);
+		context.hook("kubb:lint:start", () => startPhase(PHASES.lint));
+		context.hook("kubb:lint:end", endPhase);
+		context.hook("kubb:hooks:start", () => startPhase(PHASES.hooks));
+		context.hook("kubb:hooks:end", endPhase);
+		context.hook("kubb:hook:start", ({ id }) => {
+			if (silent || !id) return;
+			state.hooks.set(id, {
+				hrStart: node_process.default.hrtime(),
+				lines: []
 			});
 		});
-		if (logLevel > _kubb_core.logLevel.silent) context.hook("kubb:hook:line", ({ id, line }) => {
-			state.activeHookLogs.get(id)?.taskLog.message((0, node_util.styleText)("dim", line));
+		if (!silent) context.hook("kubb:hook:line", ({ id, line }) => {
+			const active = state.hooks.get(id);
+			if (!active) return;
+			if (state.phase) {
+				active.lines.push(line);
+				return;
+			}
+			writer.raw([line]);
 		});
 		context.hook("kubb:hook:end", ({ id, command, name, args, success, error, stdout, stderr }) => {
 			if (!id) return;
-			if (logLevel <= _kubb_core.logLevel.silent) {
+			if (!success && state.phase) state.phase.failed = true;
+			if (silent) {
 				if (!success) {
 					if (stdout) console.log(stdout);
 					if (stderr) console.error(stderr);
 				}
 				return;
 			}
-			const active = state.activeHookLogs.get(id);
+			const active = state.hooks.get(id);
 			if (!active) return;
-			state.activeHookLogs.delete(id);
-			const commandWithArgs = formatCommandWithArgs(command, args);
-			const duration = formatMsWithColor(getElapsedMs(active.hrStart));
-			if (success) active.taskLog.success(getMessage(`${(0, node_util.styleText)("dim", name ?? commandWithArgs)} completed in ${duration}`));
-			else {
-				const reason = error?.message ? ` (${error.message})` : "";
-				active.taskLog.error(getMessage(`${(0, node_util.styleText)("dim", name ?? commandWithArgs)} failed${reason}`), { showLog: true });
+			state.hooks.delete(id);
+			const label = (0, node_util.styleText)("dim", name ?? formatCommandWithArgs(command, args));
+			const reason = error?.message ? ` (${error.message})` : "";
+			const result = success ? `${(0, node_util.styleText)("green", "✓")} ${label} in ${require_output.formatMsWithColor(require_output.getElapsedMs(active.hrStart))}` : `${(0, node_util.styleText)("red", "✗")} ${label} failed${reason}`;
+			const phase = state.phase;
+			if (phase) {
+				if (phase.showHookResults || !success) phase.lines.push(result);
+				phase.output.push(...active.lines);
+				return;
 			}
+			stopSpinner();
+			writer.step(text(result));
+			writeOutput(active.lines);
+		});
+		context.hook("kubb:generation:end", () => {
+			stopSpinner();
+			stopProgress();
 		});
 		context.hook("kubb:lifecycle:end", () => {
+			closeGroup("failed");
 			reset();
 		});
-	}
+		return { renderSummary(lines, { status }) {
+			if (silent || !state.groupOpen) return;
+			closeGroup(status);
+			writer.diagnostic([...lines]);
+		} };
+	};
+}
+/**
+* TTY logger for local development, with animated steps and progress bars.
+*/
+const clackLogger = {
+	name: "clack",
+	install: createLogger({
+		group: (title) => _clack_prompts.intro(title),
+		groupEnd: (text) => _clack_prompts.outro(text),
+		step: (text) => _clack_prompts.log.step(text, { spacing: 0 }),
+		info: (text) => _clack_prompts.log.info(text),
+		success: (text) => _clack_prompts.log.success(text),
+		warn: (text) => _clack_prompts.log.warn(text),
+		error: (text) => _clack_prompts.log.error(text),
+		block: (lines) => _clack_prompts.log.message(lines, { spacing: 0 }),
+		raw: (lines) => console.log((0, node_util.styleText)("dim", lines.join("\n"))),
+		diagnostic: (lines) => _clack_prompts.log.message(lines, {
+			symbol: "",
+			secondarySymbol: ""
+		}),
+		update: (lines, title) => _clack_prompts.box(lines.join("\n"), title, {
+			width: "auto",
+			formatBorder: (border) => (0, node_util.styleText)("yellow", border),
+			rounded: true,
+			withGuide: false,
+			contentAlign: "center",
+			titleAlign: "center"
+		}),
+		spinner() {
+			const spinner = _clack_prompts.spinner();
+			return {
+				start: (text) => spinner.start(text),
+				message: (text) => spinner.message(text),
+				clear: () => spinner.clear(),
+				stop: (text) => spinner.stop(text),
+				error: (text) => spinner.error(text)
+			};
+		},
+		progress(max) {
+			const bar = _clack_prompts.progress({
+				style: "block",
+				max,
+				size: 30
+			});
+			return {
+				start: (text) => bar.start(text),
+				advance: (text) => bar.advance(1, text),
+				stop: (text) => bar.stop(text)
+			};
+		}
+	})
 };
 //#endregion
 //#region src/loggers/plainLogger.ts
 /**
-* Plain console adapter for non-TTY environments, built on `console.log`.
+* Prefixes that stand in for the symbols clack draws, so plain output reads the same way.
+*/
+const SYMBOLS = {
+	info: "ℹ",
+	warn: "⚠",
+	error: "✗",
+	step: "◇"
+};
+function write(line) {
+	console.log(line);
+}
+/**
+* Console adapter for non-TTY environments, and for an AI coding agent reading the output. Reports
+* the same run in the same order as `clackLogger`, without the animation.
 */
 const plainLogger = {
 	name: "plain",
-	install(context, options) {
-		const logLevel = options?.logLevel ?? _kubb_core.logLevel.info;
-		const hookTimer = createHookTimer();
-		function getMessage(message) {
-			return formatMessage(message, logLevel);
-		}
-		function onStep(hook, message) {
-			context.hook(hook, () => {
-				if (logLevel <= _kubb_core.logLevel.silent) return;
-				console.log(getMessage(message));
-			});
-		}
-		context.hook("kubb:info", ({ message, info }) => {
-			if (logLevel <= _kubb_core.logLevel.silent) return;
-			const text = getMessage([
-				"ℹ",
-				message,
-				info
-			].join(" "));
-			console.log(text);
-		});
-		context.hook("kubb:success", ({ message, info = "" }) => {
-			if (logLevel <= _kubb_core.logLevel.silent) return;
-			const text = getMessage([
-				"✓",
-				message,
-				logLevel >= _kubb_core.logLevel.info ? info : void 0
-			].filter(Boolean).join(" "));
-			console.log(text);
-		});
-		context.hook("kubb:warn", ({ message, info }) => {
-			if (logLevel < _kubb_core.logLevel.warn) return;
-			const text = getMessage([
-				"⚠",
-				message,
-				logLevel >= _kubb_core.logLevel.info ? info : void 0
-			].filter(Boolean).join(" "));
-			console.log(text);
-		});
-		context.hook("kubb:error", ({ error }) => {
-			const text = getMessage(["✗", error.message].join(" "));
-			console.log(text);
-			const frames = logLevel >= _kubb_core.logLevel.verbose ? formatErrorFrames(error) : null;
-			if (frames) {
-				for (const frame of frames.frames) console.log(getMessage(frame));
-				if (frames.cause) {
-					console.log(frames.cause.header);
-					for (const frame of frames.cause.frames) console.log(getMessage(`    ${frame}`));
-				}
-			}
-		});
-		context.hook("kubb:diagnostic", ({ diagnostic }) => {
-			if (logLevel <= _kubb_core.logLevel.silent && diagnostic.severity !== "error") return;
-			console.log(getMessage(_kubb_core.Diagnostics.formatLines(diagnostic).join("\n")));
-		});
-		context.hook("studio:connecting", ({ url }) => {
-			if (logLevel <= _kubb_core.logLevel.silent) return;
-			console.log(getMessage(`Connecting to ${url}`));
-		});
-		context.hook("studio:connected", ({ url, versions }) => {
-			if (logLevel <= _kubb_core.logLevel.silent) return;
-			console.log(getMessage(`✓ Connected to ${url} (${formatVersions(versions)})`));
-		});
-		context.hook("studio:ready", () => {
-			if (logLevel <= _kubb_core.logLevel.silent) return;
-			console.log(getMessage("✓ Ready to receive jobs"));
-		});
-		context.hook("studio:disconnected", ({ reason }) => {
-			if (logLevel < _kubb_core.logLevel.warn) return;
-			console.log(getMessage(`⚠ Kubb Studio ended the session (${reason})`));
-		});
-		context.hook("studio:command:start", ({ command }) => {
-			if (logLevel <= _kubb_core.logLevel.silent) return;
-			console.log(getMessage(`Kubb Studio asked to ${command}`));
-		});
-		context.hook("studio:command:end", ({ command, info }) => {
-			if (logLevel <= _kubb_core.logLevel.silent) return;
-			console.log(getMessage(`✓ Finished ${command}${info ? ` (${info})` : ""}`));
-		});
-		context.hook("studio:warn", ({ message }) => {
-			if (logLevel < _kubb_core.logLevel.warn) return;
-			console.log(getMessage(`⚠ ${message}`));
-		});
-		context.hook("studio:error", ({ error }) => {
-			console.log(getMessage(`✗ ${error.message}`));
-		});
-		context.hook("kubb:lifecycle:start", ({ version }) => {
-			console.log(`Kubb CLI v${version}`);
-		});
-		context.hook("kubb:generation:start", ({ config }) => {
-			const text = getMessage(["Generation started", getInputPath(config)].filter(Boolean).join(" "));
-			console.log(text);
-		});
-		context.hook("kubb:plugin:start", ({ plugin }) => {
-			if (logLevel <= _kubb_core.logLevel.silent) return;
-			const text = getMessage(`Generating ${plugin.name}`);
-			console.log(text);
-		});
-		context.hook("kubb:plugin:end", ({ plugin, duration, success }) => {
-			if (logLevel <= _kubb_core.logLevel.silent) return;
-			const durationStr = formatMs(duration);
-			const text = getMessage(success ? `${plugin.name} completed in ${durationStr}` : `${plugin.name} failed in ${durationStr}`);
-			console.log(text);
-		});
-		context.hook("kubb:files:processing:start", ({ files }) => {
-			if (logLevel <= _kubb_core.logLevel.silent) return;
-			const text = getMessage(`Writing ${files.length} files`);
-			console.log(text);
-		});
-		context.hook("kubb:files:processing:update", ({ files }) => {
-			if (logLevel <= _kubb_core.logLevel.silent) return;
-			for (const { file, config } of files) console.log(getMessage(`Writing ${(0, node_path.relative)(config.root, file.path)}`));
-		});
-		context.hook("kubb:files:processing:end", () => {
-			if (logLevel <= _kubb_core.logLevel.silent) return;
-			const text = getMessage("Files written successfully");
-			console.log(text);
-		});
-		context.hook("kubb:generation:end", ({ config }) => {
-			const text = getMessage(config.name ? `Generation completed for ${config.name}` : "Generation completed");
-			console.log(text);
-		});
-		onStep("kubb:format:start", "Format started");
-		onStep("kubb:format:end", "Format completed");
-		onStep("kubb:lint:start", "Lint started");
-		onStep("kubb:lint:end", "Lint completed");
-		onStep("kubb:hooks:start", "Hooks started");
-		onStep("kubb:hooks:end", "Hooks completed");
-		context.hook("kubb:hook:start", ({ id, command, name, args }) => {
-			if (logLevel <= _kubb_core.logLevel.silent) return;
-			if (id) hookTimer.start(id);
-			const commandWithArgs = formatCommandWithArgs(command, args);
-			console.log(getMessage(`Hook ${name ?? commandWithArgs} started`));
-		});
-		context.hook("kubb:hook:end", ({ id, command, name, args, success, error, stdout, stderr }) => {
-			if (logLevel <= _kubb_core.logLevel.silent) return;
-			const ms = id ? hookTimer.end(id) : void 0;
-			const durationStr = ms !== void 0 ? ` in ${formatMs(ms)}` : "";
-			const commandWithArgs = formatCommandWithArgs(command, args);
-			if (success) console.log(getMessage(`✓ Hook ${name ?? commandWithArgs} completed${durationStr}`));
-			else {
-				if (stdout) console.log(stdout);
-				if (stderr) console.error(stderr);
-				const reason = error?.message ? ` (${error.message})` : "";
-				console.log(getMessage(`✗ Hook ${name ?? commandWithArgs} failed${durationStr}${reason}`));
-			}
-		});
-	}
+	install: createLogger({
+		group: write,
+		groupEnd: write,
+		step: (text) => write(`${SYMBOLS.step} ${text}`),
+		info: write,
+		success: write,
+		warn: write,
+		error: write,
+		block: (lines) => write(lines.join("\n")),
+		raw: (lines) => write(lines.join("\n")),
+		diagnostic: (lines) => write(lines.join("\n")),
+		update: (lines, title) => write([title, ...lines].join("\n")),
+		spinner: () => ({
+			start: write,
+			message: write,
+			clear: () => {},
+			stop: (text) => text && write(text),
+			error: (text) => write(`${SYMBOLS.error} ${text}`)
+		}),
+		progress: () => ({
+			start: write,
+			advance: write,
+			stop: (text) => text && write(text)
+		})
+	})
 };
 //#endregion
 //#region src/loggers/utils.ts
@@ -738,6 +574,15 @@ function getInputPath(config) {
 	return typeof input?.path === "string" ? input.path : void 0;
 }
 /**
+* Counts a noun, so a message never reads `1 files`.
+*
+* @example
+* `pluralize(1, 'config')` returns `'1 config'`
+*/
+function pluralize(count, noun) {
+	return `${count} ${count === 1 ? noun : `${noun}s`}`;
+}
+/**
 * Optionally prefix a message with a [HH:MM:SS] timestamp when logLevel >= verbose.
 * Shared across all logger adapters to avoid duplication.
 */
@@ -792,7 +637,7 @@ function formatErrorFrames(error) {
 */
 function buildProgressLine(state) {
 	const parts = [];
-	const duration = formatMs(getElapsedMs(state.hrStart));
+	const duration = require_output.formatMs(require_output.getElapsedMs(state.hrStart));
 	if (state.totalPlugins > 0) {
 		const pluginStr = state.failedPlugins > 0 ? `Plugins ${(0, node_util.styleText)("green", state.completedPlugins.toString())}/${state.totalPlugins} ${(0, node_util.styleText)("red", `(${state.failedPlugins} failed)`)}` : `Plugins ${(0, node_util.styleText)("green", state.completedPlugins.toString())}/${state.totalPlugins}`;
 		parts.push(pluginStr);
@@ -834,23 +679,6 @@ function recordPluginResult(state, success) {
 	else state.failedPlugins++;
 }
 /**
-* Creates a {@link HookTimer} backed by a private `id → hrtime` map.
-*/
-function createHookTimer() {
-	const starts = /* @__PURE__ */ new Map();
-	return {
-		start(id) {
-			starts.set(id, node_process.default.hrtime());
-		},
-		end(id) {
-			const hrStart = starts.get(id);
-			if (!hrStart) return;
-			starts.delete(id);
-			return getElapsedMs(hrStart);
-		}
-	};
-}
-/**
 * Join a command and its optional args into a single display string.
 *
 * @example With args
@@ -897,19 +725,22 @@ function installReporter(context, reporter, ctx) {
 * `stdout`/`stderr` on `kubb:hook:end`, so nothing is returned here.
 *
 * Loggers and reporters are independent, except for `cli`: it both installs the live logger view
-* here and registers as a reporter that prints the per-config summary. The `json` reporter owns
-* stdout, so the whole `cli` reporter (live logger and summary) is skipped whenever `json` is
-* among the reporters, even if `cli` is also listed.
+* here and registers a reporter that renders the per-config summary through that logger, so the
+* summary lands inside the group the logger opened. The `json` reporter owns stdout, so the whole
+* `cli` reporter (live logger and summary) is skipped whenever `json` is among the reporters, even
+* if `cli` is also listed.
 */
 async function setupReporters(context, { logLevel, reporters }) {
 	const hasJson = reporters.some((reporter) => reporter.name === "json");
 	const ctx = { logLevel };
 	for (const reporter of reporters) {
-		if (reporter.name === "cli") {
-			if (hasJson) continue;
-			await (require_output.canUseTTY() && !require_agent.getAgentName() ? clackLogger : plainLogger).install(context, { logLevel });
+		if (reporter.name !== "cli") {
+			installReporter(context, reporter, ctx);
+			continue;
 		}
-		installReporter(context, reporter, ctx);
+		if (hasJson) continue;
+		const handle = await (require_output.canUseTTY() && !require_agent.getAgentName() ? clackLogger : plainLogger).install(context, { logLevel });
+		installReporter(context, (0, _kubb_core.createCliReporter)({ render: handle?.renderSummary }), ctx);
 	}
 }
 /**
@@ -1309,6 +1140,12 @@ Object.defineProperty(exports, "linters", {
 		return linters;
 	}
 });
+Object.defineProperty(exports, "pluralize", {
+	enumerable: true,
+	get: function() {
+		return pluralize;
+	}
+});
 Object.defineProperty(exports, "runHook", {
 	enumerable: true,
 	get: function() {
@@ -1346,4 +1183,4 @@ Object.defineProperty(exports, "startWatcher", {
 	}
 });
 
-//# sourceMappingURL=utils-CMU1rLfY.cjs.map
+//# sourceMappingURL=utils-BP0xq5AK.cjs.map