@kubb/cli 5.3.8 → 5.3.10

package/dist/{utils-s6yetN6W.js → utils-LvEYQf9I.js}

@@ -1,14 +1,14 @@
 import "./rolldown-runtime-C0LytTxp.js";
 import { t as toError } from "./errors-C8yNfV7w.js";
 import { t as getAgentName } from "./agent-3JmkMghp.js";
-import { c as URL_WATCHER_TIMEOUT_MS, l as WATCHER_IGNORED_PATHS, s as URL_WATCHER_INTERVAL_MS } from "./Telemetry-CJcQkQOT.js";
-import { l as canUseTTY } from "./output-DH2Uoy4x.js";
+import { c as URL_WATCHER_TIMEOUT_MS, l as WATCHER_IGNORED_PATHS, s as URL_WATCHER_INTERVAL_MS } from "./Telemetry-Dw5s6abr.js";
+import { f as formatMsWithColor, h as getElapsedMs, m as formatMs, p as canUseTTY } from "./output-C_Gk4p-8.js";
 import { styleText } from "node:util";
 import { randomUUID } from "node:crypto";
-import process$1 from "node:process";
+import process from "node:process";
 import { spawn } from "node:child_process";
 import { basename, dirname, relative, resolve } from "node:path";
-import { Diagnostics, logLevel } from "@kubb/core";
+import { Diagnostics, createCliReporter, logLevel } from "@kubb/core";
 import * as clack from "@clack/prompts";
 import { createJiti } from "jiti";
 import { NonZeroExitError, x } from "tinyexec";
@@ -121,608 +121,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(" █")}  ${styleText("gray", title)}
-  ${palette.woodMid("█ ")}${eyeBottom}${palette.woodMid("  ")}${palette.blush("◡")}${palette.woodMid("  ")}${eyeBottom}${palette.woodMid(" █")}  ${styleText("yellow", "➜")} ${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 styleText("green", formatted);
-	if (ms <= 1e3) return styleText("yellow", formatted);
-	return 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) {
-		const logLevel$3 = options?.logLevel ?? logLevel.info;
+function createLogger(writer) {
+	return function install(context, options) {
+		const logLevel$2 = options?.logLevel ?? logLevel.info;
+		const silent = logLevel$2 <= logLevel.silent;
 		const state = {
 			...createProgressCounters(),
-			spinner: clack.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$2);
+		}
+		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;
 			}
-			state.activeProgress.clear();
+			if (status === "failed") {
+				spinner.error(text(message));
+				return;
+			}
+			spinner.stop(text(message));
 		}
-		function reset() {
-			stopActiveProgress();
-			resetProgressCounters(state);
-			state.spinner = clack.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) => 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: process.hrtime(),
+				lines: [],
+				output: []
+			};
+			startSpinner(running);
 		}
-		function showProgressStep() {
-			if (logLevel$3 <= logLevel.silent) return;
-			const line = buildProgressLine(state);
-			if (line) clack.log.step(getMessage(line));
+		function endPhase() {
+			const phase = state.phase;
+			state.phase = null;
+			if (!phase || silent) return;
+			const duration = formatMsWithColor(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$3);
+		function writeOutput(lines) {
+			const output = trimBlankEdges(lines);
+			if (output.length) writer.raw(output);
 		}
-		function onStep(hook, message) {
-			context.hook(hook, () => {
-				if (logLevel$3 <= logLevel.silent) return;
-				clack.log.step(getMessage(message));
-			});
+		function closeGroup(status) {
+			if (!state.groupOpen) return;
+			state.groupOpen = false;
+			stopSpinner();
+			stopProgress();
+			writer.groupEnd(status === "failed" ? styleText("red", "✗ Generation failed") : 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$3 <= logLevel.silent) return;
-			const text = getMessage([
+		context.hook("kubb:info", ({ message, info }) => {
+			if (silent) return;
+			const line = text([
 				styleText("blue", "ℹ"),
 				message,
 				info ? styleText("dim", info) : void 0
 			].filter(Boolean).join(" "));
-			if (state.isSpinning) {
-				state.spinner.message(text);
+			if (state.phase) {
+				state.phase.lines.push(line);
 				return;
 			}
-			clack.log.info(text);
+			if (state.spinner) {
+				state.spinner.message(line);
+				return;
+			}
+			writer.info(line);
 		});
-		context.hook("kubb:success", ({ message, info = "" }) => {
-			if (logLevel$3 <= logLevel.silent) return;
-			const text = getMessage([
-				styleText("blue", "✓"),
+		context.hook("kubb:success", ({ message, info }) => {
+			if (silent) return;
+			const line = text([
+				styleText("green", "✓"),
 				message,
-				logLevel$3 >= logLevel.info ? styleText("dim", info) : void 0
+				logLevel$2 >= logLevel.info && info ? styleText("dim", info) : void 0
 			].filter(Boolean).join(" "));
-			if (state.isSpinning) {
-				stopSpinner(text);
+			if (state.spinner) {
+				state.spinner.message(line);
 				return;
 			}
-			clack.log.success(text);
+			writer.success(line);
 		});
 		context.hook("kubb:warn", ({ message, info }) => {
-			if (logLevel$3 < logLevel.warn) return;
-			const text = getMessage([
+			if (logLevel$2 < logLevel.warn) return;
+			writer.warn(text([
 				styleText("yellow", "⚠"),
 				message,
-				logLevel$3 >= logLevel.info && info ? styleText("dim", info) : void 0
-			].filter(Boolean).join(" "));
-			clack.log.warn(text);
+				logLevel$2 >= logLevel.info && info ? styleText("dim", info) : void 0
+			].filter(Boolean).join(" ")));
 		});
 		context.hook("kubb:error", ({ error }) => {
-			const text = [styleText("red", "✗"), error.message].join(" ");
-			if (state.isSpinning) {
-				stopSpinner(getMessage(text));
-				return;
-			}
-			clack.log.error(getMessage(text));
-			const frames = logLevel$3 >= logLevel.verbose ? formatErrorFrames(error) : null;
-			if (frames) {
-				for (const frame of frames.frames) clack.log.message(getMessage(styleText("dim", frame)));
-				if (frames.cause) {
-					clack.log.message(styleText("dim", frames.cause.header));
-					for (const frame of frames.cause.frames) clack.log.message(getMessage(`    ${styleText("dim", frame)}`));
-				}
-			}
+			if (state.phase) state.phase.failed = true;
+			const line = [styleText("red", "✗"), error.message].join(" ");
+			if (state.spinner) stopSpinner(line, "failed");
+			else writer.error(text(line));
+			const frames = logLevel$2 >= logLevel.verbose ? formatErrorFrames(error) : null;
+			if (!frames) return;
+			writer.block(frames.frames.map((frame) => text(styleText("dim", frame))));
+			if (frames.cause) writer.block([styleText("dim", frames.cause.header), ...frames.cause.frames.map((frame) => text(`    ${styleText("dim", frame)}`))]);
 		});
 		context.hook("kubb:diagnostic", ({ diagnostic }) => {
-			if (logLevel$3 <= logLevel.silent && diagnostic.severity !== "error") return;
+			if (silent && diagnostic.severity !== "error") return;
 			stopSpinner();
-			stopActiveProgress();
+			stopProgress();
 			if (Diagnostics.isUpdate(diagnostic)) {
-				clack.box(`\`v${diagnostic.currentVersion}\` → \`v${diagnostic.latestVersion}\`
-Run \`npm install -g @kubb/cli\` to update`, "Update available for `Kubb`", {
-					width: "auto",
-					formatBorder: (s) => 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 } = Diagnostics.format(diagnostic);
-			clack.log.message([headline, ...details], {
-				symbol: "",
-				secondarySymbol: ""
-			});
+			writer.diagnostic([headline, ...details]);
 		});
 		context.hook("studio:connecting", ({ url }) => {
-			if (logLevel$3 <= logLevel.silent) return;
-			state.spinner = clack.spinner();
-			state.spinner.start(getMessage(`Connecting to ${styleText("cyan", url)}`));
-			state.isSpinning = true;
+			startSpinner(`Connecting to ${styleText("cyan", url)}`);
 		});
 		context.hook("studio:connected", ({ url, versions }) => {
-			if (logLevel$3 <= logLevel.silent) return;
-			const text = getMessage(`Connected to ${styleText("cyan", url)} ${styleText("dim", `(${formatVersions(versions)})`)}`);
-			if (state.isSpinning) {
-				stopSpinner(text);
+			if (silent) return;
+			const line = `Connected to ${styleText("cyan", url)} ${styleText("dim", `(${formatVersions(versions)})`)}`;
+			if (state.spinner) {
+				stopSpinner(line);
 				return;
 			}
-			clack.log.success(text);
+			writer.success(text(`✓ ${line}`));
 		});
 		context.hook("studio:ready", () => {
-			if (logLevel$3 <= logLevel.silent) return;
-			clack.log.success(getMessage("Ready to receive jobs"));
+			if (silent) return;
+			startSpinner("✓ Ready to receive jobs");
 		});
 		context.hook("studio:disconnected", ({ reason }) => {
-			if (logLevel$3 < logLevel.warn) return;
+			if (logLevel$2 < logLevel.warn) return;
 			stopSpinner();
-			clack.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$3 <= logLevel.silent) return;
-			clack.log.info(getMessage(`Kubb Studio asked to ${styleText("bold", command)}`));
+			if (silent) return;
+			stopSpinner();
+			writer.info(text(`Kubb Studio asked to ${styleText("bold", command)}`));
 		});
 		context.hook("studio:command:end", ({ command, info }) => {
-			if (logLevel$3 <= logLevel.silent) return;
-			clack.log.success(getMessage(`Finished ${command}${info ? ` ${styleText("dim", `(${info})`)}` : ""}`));
+			if (silent) return;
+			writer.success(text(`✓ Finished ${command}${info ? ` ${styleText("dim", `(${info})`)}` : ""}`));
+			startSpinner("✓ Ready to receive jobs");
 		});
 		context.hook("studio:warn", ({ message }) => {
-			if (logLevel$3 < logLevel.warn) return;
-			clack.log.warn(getMessage(message));
+			if (logLevel$2 < logLevel.warn) return;
+			writer.warn(text(`⚠ ${message}`));
 		});
 		context.hook("studio:error", ({ error }) => {
-			const text = getMessage([styleText("red", "✗"), error.message].join(" "));
-			if (state.isSpinning) {
-				stopSpinner(text);
+			const line = `✗ ${error.message}`;
+			if (state.spinner) {
+				stopSpinner(line, "failed");
 				return;
 			}
-			clack.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$3 <= logLevel.silent) return;
-			const text = getMessage([
-				"Generation started",
-				config.name ? `for ${styleText("dim", config.name)}` : void 0,
-				getInputPath(config)
-			].filter(Boolean).join(" "));
-			clack.intro(text);
+			if (silent) return;
+			const inputPath = getInputPath(config);
+			writer.group(text([styleText("bold", config.name ?? "kubb"), inputPath ? styleText("dim", inputPath) : void 0].filter(Boolean).join(" ")));
+			state.groupOpen = true;
+			startSpinner("Generating");
 		});
 		context.hook("kubb:plugin:start", ({ plugin }) => {
-			if (logLevel$3 <= 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.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 ${styleText("dim", plugin.name)}`));
 		});
-		context.hook("kubb:plugin:end", ({ plugin, success }) => {
-			stopSpinner();
-			const active = state.activeProgress.get("plugins");
-			if (!active || logLevel$3 <= 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 ${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$3 <= logLevel.silent) return;
+			if (silent) return;
 			stopSpinner();
 			state.totalFiles = files.length;
 			state.processedFiles = 0;
-			const text = `Writing ${files.length} files`;
-			const progressBar = clack.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$3 <= 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 ${relative(config.root, file.path)}`);
+				state.progress?.advance(`Writing ${relative(config.root, file.path)}`);
 			}
 		});
 		context.hook("kubb:files:processing:end", () => {
-			if (logLevel$3 <= 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();
+			if (silent) return;
+			stopProgress(`Wrote ${pluralize(state.processedFiles, "file")}`);
 		});
-		context.hook("kubb:generation:end", ({ config }) => {
-			stopSpinner();
-			const text = getMessage(config.name ? `Generation completed for ${styleText("dim", config.name)}` : "Generation completed");
-			clack.outro(text);
-		});
-		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$3 <= logLevel.silent || !id) return;
-			stopSpinner();
-			const commandWithArgs = formatCommandWithArgs(command, args);
-			const title = getMessage(`Running ${styleText("dim", name ?? commandWithArgs)}`);
-			const taskLog = clack.taskLog({ title });
-			state.activeHookLogs.set(id, {
-				taskLog,
-				hrStart: process$1.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: process.hrtime(),
+				lines: []
 			});
 		});
-		if (logLevel$3 > logLevel.silent) context.hook("kubb:hook:line", ({ id, line }) => {
-			state.activeHookLogs.get(id)?.taskLog.message(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$3 <= 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(`${styleText("dim", name ?? commandWithArgs)} completed in ${duration}`));
-			else {
-				const reason = error?.message ? ` (${error.message})` : "";
-				active.taskLog.error(getMessage(`${styleText("dim", name ?? commandWithArgs)} failed${reason}`), { showLog: true });
+			state.hooks.delete(id);
+			const label = styleText("dim", name ?? formatCommandWithArgs(command, args));
+			const reason = error?.message ? ` (${error.message})` : "";
+			const result = success ? `${styleText("green", "✓")} ${label} in ${formatMsWithColor(getElapsedMs(active.hrStart))}` : `${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.intro(title),
+		groupEnd: (text) => clack.outro(text),
+		step: (text) => clack.log.step(text, { spacing: 0 }),
+		info: (text) => clack.log.info(text),
+		success: (text) => clack.log.success(text),
+		warn: (text) => clack.log.warn(text),
+		error: (text) => clack.log.error(text),
+		block: (lines) => clack.log.message(lines, { spacing: 0 }),
+		raw: (lines) => console.log(styleText("dim", lines.join("\n"))),
+		diagnostic: (lines) => clack.log.message(lines, {
+			symbol: "",
+			secondarySymbol: ""
+		}),
+		update: (lines, title) => clack.box(lines.join("\n"), title, {
+			width: "auto",
+			formatBorder: (border) => styleText("yellow", border),
+			rounded: true,
+			withGuide: false,
+			contentAlign: "center",
+			titleAlign: "center"
+		}),
+		spinner() {
+			const spinner = clack.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.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$2 = options?.logLevel ?? logLevel.info;
-		const hookTimer = createHookTimer();
-		function getMessage(message) {
-			return formatMessage(message, logLevel$2);
-		}
-		function onStep(hook, message) {
-			context.hook(hook, () => {
-				if (logLevel$2 <= logLevel.silent) return;
-				console.log(getMessage(message));
-			});
-		}
-		context.hook("kubb:info", ({ message, info }) => {
-			if (logLevel$2 <= logLevel.silent) return;
-			const text = getMessage([
-				"ℹ",
-				message,
-				info
-			].join(" "));
-			console.log(text);
-		});
-		context.hook("kubb:success", ({ message, info = "" }) => {
-			if (logLevel$2 <= logLevel.silent) return;
-			const text = getMessage([
-				"✓",
-				message,
-				logLevel$2 >= logLevel.info ? info : void 0
-			].filter(Boolean).join(" "));
-			console.log(text);
-		});
-		context.hook("kubb:warn", ({ message, info }) => {
-			if (logLevel$2 < logLevel.warn) return;
-			const text = getMessage([
-				"⚠",
-				message,
-				logLevel$2 >= 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$2 >= 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$2 <= logLevel.silent && diagnostic.severity !== "error") return;
-			console.log(getMessage(Diagnostics.formatLines(diagnostic).join("\n")));
-		});
-		context.hook("studio:connecting", ({ url }) => {
-			if (logLevel$2 <= logLevel.silent) return;
-			console.log(getMessage(`Connecting to ${url}`));
-		});
-		context.hook("studio:connected", ({ url, versions }) => {
-			if (logLevel$2 <= logLevel.silent) return;
-			console.log(getMessage(`✓ Connected to ${url} (${formatVersions(versions)})`));
-		});
-		context.hook("studio:ready", () => {
-			if (logLevel$2 <= logLevel.silent) return;
-			console.log(getMessage("✓ Ready to receive jobs"));
-		});
-		context.hook("studio:disconnected", ({ reason }) => {
-			if (logLevel$2 < logLevel.warn) return;
-			console.log(getMessage(`⚠ Kubb Studio ended the session (${reason})`));
-		});
-		context.hook("studio:command:start", ({ command }) => {
-			if (logLevel$2 <= logLevel.silent) return;
-			console.log(getMessage(`Kubb Studio asked to ${command}`));
-		});
-		context.hook("studio:command:end", ({ command, info }) => {
-			if (logLevel$2 <= logLevel.silent) return;
-			console.log(getMessage(`✓ Finished ${command}${info ? ` (${info})` : ""}`));
-		});
-		context.hook("studio:warn", ({ message }) => {
-			if (logLevel$2 < 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$2 <= logLevel.silent) return;
-			const text = getMessage(`Generating ${plugin.name}`);
-			console.log(text);
-		});
-		context.hook("kubb:plugin:end", ({ plugin, duration, success }) => {
-			if (logLevel$2 <= 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$2 <= logLevel.silent) return;
-			const text = getMessage(`Writing ${files.length} files`);
-			console.log(text);
-		});
-		context.hook("kubb:files:processing:update", ({ files }) => {
-			if (logLevel$2 <= logLevel.silent) return;
-			for (const { file, config } of files) console.log(getMessage(`Writing ${relative(config.root, file.path)}`));
-		});
-		context.hook("kubb:files:processing:end", () => {
-			if (logLevel$2 <= 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$2 <= 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$2 <= 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
@@ -736,6 +572,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.
 */
@@ -810,7 +655,7 @@ function createProgressCounters() {
 		failedPlugins: 0,
 		totalFiles: 0,
 		processedFiles: 0,
-		hrStart: process$1.hrtime()
+		hrStart: process.hrtime()
 	};
 }
 /**
@@ -822,7 +667,7 @@ function resetProgressCounters(state) {
 	state.failedPlugins = 0;
 	state.totalFiles = 0;
 	state.processedFiles = 0;
-	state.hrStart = process$1.hrtime();
+	state.hrStart = process.hrtime();
 }
 /**
 * Records a finished plugin against the progress counters.
@@ -832,23 +677,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, process$1.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
@@ -870,7 +698,7 @@ function installReporter(context, reporter, ctx) {
 		if (added.length) filesByPlugin.set(plugin.name, /* @__PURE__ */ new Set([...filesByPlugin.get(plugin.name) ?? [], ...added]));
 		pluginFiles.set(config, filesByPlugin);
 	});
-	context.hook("kubb:generation:end", async ({ config, diagnostics = [], filesCreated = 0, status = "success", hrStart = process$1.hrtime() }) => {
+	context.hook("kubb:generation:end", async ({ config, diagnostics = [], filesCreated = 0, status = "success", hrStart = process.hrtime() }) => {
 		const files = pluginFiles?.get(config);
 		const grouped = files && [...files].map(([plugin, paths]) => ({
 			plugin,
@@ -895,20 +723,26 @@ 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 }) {
+	let cliHandle;
 	const hasJson = reporters.some((reporter) => reporter.name === "json");
 	const ctx = { logLevel };
 	for (const reporter of reporters) {
-		if (reporter.name === "cli") {
-			if (hasJson) continue;
-			await (canUseTTY() && !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 (canUseTTY() && !getAgentName() ? clackLogger : plainLogger).install(context, { logLevel });
+		cliHandle = handle;
+		installReporter(context, createCliReporter({ render: handle?.renderSummary }), ctx);
 	}
+	return cliHandle;
 }
 /**
 * Picks the reporters whose `name` matches one of `names`, in the order the names are given.
@@ -992,7 +826,7 @@ async function getConfigs({ configPath, input, watch, logLevel }) {
 	let result;
 	try {
 		result = await loadConfig({
-			cwd: abs ? dirname(abs) : process$1.cwd(),
+			cwd: abs ? dirname(abs) : process.cwd(),
 			sources,
 			merge: false
 		});
@@ -1085,7 +919,7 @@ async function runHook({ id, command, name, args, commandWithArgs, hooks }) {
 	const stream = hooks.listenerCount("kubb:hook:line") > 0;
 	try {
 		const proc = x(command, [...args ?? []], {
-			nodeOptions: { detached: process$1.platform !== "win32" },
+			nodeOptions: { detached: process.platform !== "win32" },
 			throwOnError: true
 		});
 		if (stream) for await (const line of proc) await hooks.callHook("kubb:hook:line", {
@@ -1164,10 +998,10 @@ async function startWatcher(path, cb, log = {
 		ignored: WATCHER_IGNORED_PATHS,
 		ignoreInitial: true
 	});
-	process$1.once("SIGINT", () => {
+	process.once("SIGINT", () => {
 		watcher.close();
 	});
-	process$1.once("SIGTERM", () => {
+	process.once("SIGTERM", () => {
 		watcher.close();
 	});
 	const runBuild = createSerialRunner({
@@ -1226,8 +1060,8 @@ function startUrlWatcher(url, cb, options = {}) {
 		if (timer) clearTimeout(timer);
 		controller?.abort();
 	};
-	process$1.once("SIGINT", stop);
-	process$1.once("SIGTERM", stop);
+	process.once("SIGINT", stop);
+	process.once("SIGTERM", stop);
 	const runBuild = createSerialRunner({
 		run: () => cb([url]),
 		onError: () => log.error(styleText("red", "Watcher failed"))
@@ -1259,6 +1093,6 @@ function startUrlWatcher(url, cb, options = {}) {
 	return stop;
 }
 //#endregion
-export { runPostGenerate as a, selectReporters as c, LINTER_PREFERENCE as d, detectTool as f, runHook as i, setupReporters as l, linters as m, getConfigs as n, startUrlWatcher as o, formatters as p, isNewerVersion as r, startWatcher as s, fetchUrlBody as t, FORMATTER_PREFERENCE as u };
+export { runPostGenerate as a, pluralize as c, FORMATTER_PREFERENCE as d, LINTER_PREFERENCE as f, linters as h, runHook as i, selectReporters as l, formatters as m, getConfigs as n, startUrlWatcher as o, detectTool as p, isNewerVersion as r, startWatcher as s, fetchUrlBody as t, setupReporters as u };
 
-//# sourceMappingURL=utils-s6yetN6W.js.map
+//# sourceMappingURL=utils-LvEYQf9I.js.map