@kubb/cli 5.11.4 → 5.11.6

package/dist/index.js

@@ -1,7 +1,11 @@
 import { t as __name } from "./rolldown-runtime-CRm0XQPb.js";
-import { c as getErrorMessage, r as version, t as isDisabled } from "./Telemetry-CwaVQsvD.js";
-import { C as initDefaults, S as KUBB_PACKAGE_NAME, a as logInfo, d as logWarn, i as logError, l as logStep, o as logIntro, r as logBlock, s as logOutro, t as createSpinner, v as findConfigFile, x as KUBB_CONFIG_FILENAME } from "./output-PhkPtNP7.js";
-import { a as isOutdated, i as installSpec, n as fetchRegistryIndex, o as registryUrl, r as incompatibility, s as toRegistryId, t as fetchRegistryDetail } from "./registry-DYUhC7rH.js";
+import { t as getErrorMessage } from "./errors-DmC83ALX.js";
+import { a as getElapsedMs, i as formatMs, r as version, t as isDisabled } from "./Telemetry-CfJAUDnh.js";
+import { d as withSpinner, g as exists, n as diffFiles, o as readOutputFiles, u as createSpinner, v as read, y as write } from "./utils-CnjEJIdZ.js";
+import { _ as isRichOutput, a as logOutro, c as logBlock, d as logStep, f as logWarn, i as logIntro, l as logError, r as isInteractiveRun, t as pluralize } from "./text-CMP4M19Z.js";
+import { a as installSpec, c as toRegistryId, f as wantsMascot, i as incompatibility, l as toShortId, n as closestIds, o as isOutdated, r as fetchRegistryIndex, s as registryUrl, t as bumpOf, u as getBanner } from "./registry-CgQYxUju.js";
+import { a as initDefaults, i as KUBB_PACKAGE_NAME, n as findConfigFile, r as KUBB_CONFIG_FILENAME, t as getConfigs } from "./config-Bh00Hwpw.js";
+import { t as logCommandSummary } from "./summary-DkSLti6f.js";
 import { styleText } from "node:util";
 import dryrun, { pluginId as dryRunId } from "@gunshi/plugin-dryrun";
 import { cli, define, defineWithTypes } from "gunshi";
@@ -9,8 +13,8 @@ import process$1 from "node:process";
 import { x } from "tinyexec";
 import path from "node:path";
 import fs from "node:fs";
-import { Diagnostics, readInstalledPackages } from "@kubb/core";
 import * as clack from "@clack/prompts";
+import { Diagnostics, Hookable, createKubb, readInstalledPackages } from "@kubb/core";
 //#region src/commands/shared.ts
 const configArg = { config: {
 	type: "string",
@@ -108,7 +112,8 @@ function resolveLogLevel({ verbose, silent, logLevel }) {
 }
 const command$13 = defineWithTypes()({
 	name: "generate",
-	description: "Generate TypeScript types, API clients, React Query hooks, Zod schemas, and more from an OpenAPI specification. Reads kubb.config.ts by default. Pass an OpenAPI file path as the first argument to override the input without editing the config.",
+	rendering: { header: null },
+	description: "Generate types, clients, hooks, and schemas from an OpenAPI specification.",
 	examples: [
 		"kubb generate                     # generate from kubb.config.ts",
 		"kubb generate ./openapi.yaml      # generate from this spec instead of the config input",
@@ -156,7 +161,7 @@ const command$13 = defineWithTypes()({
 	async run(ctx) {
 		const { values } = ctx;
 		const logLevel = resolveLogLevel(values);
-		const { run } = await import("./run-SYKj8-Q5.js");
+		const { run } = await import("./run-wkN1irUo.js");
 		await run({
 			input: values.input,
 			configPath: values.config,
@@ -172,7 +177,7 @@ const command$13 = defineWithTypes()({
 /** The runner is imported when the command runs, so listing `kubb --help` never loads `@kubb/mcp`. */
 const command$12 = define({
 	name: "mcp",
-	description: "Start a Model Context Protocol (MCP) server that exposes Kubb code generation as tools for AI assistants. Once running, configure your AI client (Claude, Cursor, Windsurf, etc.) to connect to it — the assistant can then call kubb generate directly without leaving the chat.",
+	description: "Start an MCP server for code generation from an AI assistant.",
 	examples: [
 		"kubb mcp",
 		"# Then add to your MCP client config:",
@@ -180,7 +185,7 @@ const command$12 = define({
 	].join("\n"),
 	rendering: { header: null },
 	async run() {
-		const { run } = await import("./run-B6VxJ_VM.js");
+		const { run } = await import("./run-KuzAqsjg.js");
 		await run();
 	}
 });
@@ -195,7 +200,7 @@ function studioCommand({ action, block, ...definition }) {
 		...definition,
 		toKebab: true,
 		async run({ values }) {
-			const { runStudio } = await import("./run-CwrI0wRy.js");
+			const { runStudio } = await import("./run-DsJJCzQD.js");
 			await runStudio(values, action, { block });
 		}
 	});
@@ -225,7 +230,7 @@ const command$11 = studioCommand({
 	},
 	block: true,
 	async action(options) {
-		const { connect } = await import("./run-CwrI0wRy.js");
+		const { connect } = await import("./run-DsJJCzQD.js");
 		await connect(options);
 	}
 });
@@ -237,7 +242,7 @@ const command$10 = studioCommand({
 	examples: ["kubb studio login", "kubb studio login --url http://localhost:3000"].join("\n"),
 	args: command$11.args,
 	async action(options) {
-		const { login } = await import("./run-CwrI0wRy.js");
+		const { login } = await import("./run-DsJJCzQD.js");
 		await login(options);
 	}
 });
@@ -249,7 +254,7 @@ const command$9 = studioCommand({
 	examples: "kubb studio logout",
 	args: {},
 	async action() {
-		const { stopWorker } = await import("./background-aTbwrgui.js");
+		const { stopWorker } = await import("./background-DS2zOde-.js");
 		const { clearCredentials } = await import("./credentials-C8tjAhTo.js");
 		await stopWorker();
 		await clearCredentials();
@@ -292,7 +297,7 @@ const command$8 = define({
 		...logLevelArg
 	},
 	async run(ctx) {
-		const { runner } = await import("./snapshot-Cilp10vE.js");
+		const { runner } = await import("./snapshot-CdGwHH15.js");
 		await runner(ctx);
 	}
 });
@@ -303,7 +308,7 @@ const command$7 = studioCommand({
 	description: "Keep this project connected to Kubb Studio in the background.",
 	args: command$11.args,
 	async action(options) {
-		const { startWorker } = await import("./background-aTbwrgui.js");
+		const { startWorker } = await import("./background-DS2zOde-.js");
 		await startWorker(options);
 	}
 });
@@ -311,7 +316,7 @@ const stopCommand = define({
 	name: "stop",
 	description: "Stop this project's background connection and keep its pairing.",
 	async run() {
-		const { stopWorker } = await import("./background-aTbwrgui.js");
+		const { stopWorker } = await import("./background-DS2zOde-.js");
 		await stopWorker();
 		console.log("Background connection stopped.");
 	}
@@ -324,32 +329,21 @@ const command$6 = studioCommand({
 	examples: "kubb studio status",
 	args: { url: studioConnectionArgs.url },
 	async action(options) {
-		const { getWorkerLogPath, getWorkerStatus } = await import("./background-aTbwrgui.js");
+		const { getWorkerLogPath, getWorkerStatus } = await import("./background-DS2zOde-.js");
 		const { readCredentials } = await import("./credentials-C8tjAhTo.js");
-		const { formatPermissionRows } = await import("./run-CwrI0wRy.js");
-		const worker = await getWorkerStatus();
-		console.log(`Background connection: ${worker.state}${worker.running ? ` (PID ${worker.pid})` : ""}`);
-		console.log(`Logs: ${getWorkerLogPath()}`);
-		const credentials = await readCredentials();
-		if (!credentials) {
-			console.log("Not paired. Run `kubb studio login`.");
-			return;
-		}
-		console.log(`Paired with ${credentials.studioUrl} as ${styleText("cyan", credentials.agentSlug || credentials.agentId)}`);
-		if (credentials.studioUrl !== options.studioUrl) console.log(styleText("yellow", `Connecting to ${options.studioUrl} needs pairing again.`));
-		const remembered = credentials.projects?.[process$1.cwd()];
-		if (!remembered) {
-			console.log(styleText("dim", "No saved permissions for this project. Run `kubb studio` to connect and choose."));
-			return;
-		}
-		console.log(styleText("dim", "Saved permissions"));
-		for (const row of formatPermissionRows({
-			allowRead: remembered.allowRead === true,
-			allowReadAst: remembered.allowReadAst === true,
-			allowWrite: remembered.allowWrite === true,
-			allowConfigEdit: remembered.allowConfigEdit === true,
-			allowExec: remembered.allowExec === true
-		})) console.log(row);
+		const { formatStatus } = await import("./status-DHPeR3bq.js");
+		const [worker, credentials] = await Promise.all([getWorkerStatus(), readCredentials()]);
+		console.log([
+			"",
+			...formatStatus({
+				studioUrl: options.studioUrl,
+				credentials,
+				worker,
+				project: process$1.cwd(),
+				logPath: getWorkerLogPath()
+			}),
+			""
+		].join("\n"));
 	}
 });
 //#endregion
@@ -394,16 +388,22 @@ function routeStudioFlags(args) {
 /** The runner is imported when the command runs, so listing `kubb --help` never loads `@kubb/adapter-oas`. */
 const command$4 = define({
 	name: "validate",
-	description: "Parse and validate an OpenAPI/Swagger file for structural correctness. Reports schema errors, missing required fields, and malformed references. Use this before running generate to catch spec issues early.",
+	description: "Check a specification with the configured adapter before generating.",
 	examples: ["kubb validate ./openapi.yaml", "kubb validate https://petstore3.swagger.io/api/v3/openapi.json"].join("\n"),
-	args: { input: {
-		type: "positional",
-		description: "Path or URL to the OpenAPI/Swagger file to validate",
-		required: true
-	} },
+	args: {
+		...configArg,
+		input: {
+			type: "positional",
+			description: "Path or URL to the specification to validate",
+			required: true
+		}
+	},
 	async run({ values }) {
-		const { run } = await import("./run-AfjIBtiL.js");
-		await run({ input: values.input });
+		const { run } = await import("./run-D_dD7xHp.js");
+		await run({
+			input: values.input,
+			configPath: values.config
+		});
 	}
 });
 //#endregion
@@ -420,6 +420,8 @@ const DEPRECATED_FLAGS = {
 	dryRun: "dry-run",
 	packageVersion: "package-version"
 };
+/** Flags a single command renamed, rewritten only for that command, since the old name is a common word. */
+const DEPRECATED_COMMAND_FLAGS = { update: { check: "dry-run" } };
 const FLAG_PATTERN = /^--([a-zA-Z][\w-]*)(=.*)?$/;
 /**
 * Rewrites a deprecated camelCase flag to its kebab-case replacement and warns on stderr, so a
@@ -427,10 +429,11 @@ const FLAG_PATTERN = /^--([a-zA-Z][\w-]*)(=.*)?$/;
 * of failing with an unknown-option error.
 */
 function resolveDeprecatedFlags(args) {
+	const commandFlags = DEPRECATED_COMMAND_FLAGS[args[0] ?? ""] ?? {};
 	return args.map((arg) => {
 		const match = FLAG_PATTERN.exec(arg);
 		const name = match?.[1];
-		const replacement = name ? DEPRECATED_FLAGS[name] : void 0;
+		const replacement = name ? DEPRECATED_FLAGS[name] ?? commandFlags[name] : void 0;
 		if (!name || !replacement) return arg;
 		console.error(`${styleText("yellow", "Warning:")} --${name} is deprecated, use --${replacement} instead. --${name} will be removed in a future major version.`);
 		return `--${replacement}${match?.[2] ?? ""}`;
@@ -460,25 +463,29 @@ const packageManagers = {
 		name: "pnpm",
 		lockFiles: ["pnpm-lock.yaml"],
 		initCommand: ["init"],
-		installCommand: ["add", "-D"]
+		installCommand: ["add", "-D"],
+		runCommand: []
 	},
 	yarn: {
 		name: "yarn",
 		lockFiles: ["yarn.lock"],
 		initCommand: ["init", "-y"],
-		installCommand: ["add", "-D"]
+		installCommand: ["add", "-D"],
+		runCommand: []
 	},
 	bun: {
 		name: "bun",
 		lockFiles: ["bun.lock", "bun.lockb"],
 		initCommand: ["init", "-y"],
-		installCommand: ["add", "-d"]
+		installCommand: ["add", "-d"],
+		runCommand: ["run"]
 	},
 	npm: {
 		name: "npm",
 		lockFiles: ["package-lock.json"],
 		initCommand: ["init", "-y"],
-		installCommand: ["install", "--save-dev"]
+		installCommand: ["install", "--save-dev"],
+		runCommand: ["run"]
 	}
 };
 /** Detects the package manager for `cwd`: the `packageManager` field in `package.json`, then a lock file, then `npm`. */
@@ -506,27 +513,191 @@ async function initPackageJson(cwd, packageManager) {
 		throwOnError: true
 	});
 }
+const INSTALL_TIMEOUT_MS = 3e5;
 /**
-* Installs the given packages at `cwd` using the detected package manager.
+* Installs the given packages at `cwd` using the detected package manager. Each output line goes
+* to `onLine`, so the caller can show it while the install runs; a failed install also keeps the
+* end of the output in the error.
 */
-async function installPackages(packages, packageManager, cwd = process$1.cwd()) {
-	await x(packageManager.name, [...packageManager.installCommand, ...packages], {
+async function installPackages(packages, packageManager, cwd = process$1.cwd(), onLine) {
+	const args = [...packageManager.installCommand, ...packages];
+	const result = x(packageManager.name, args, {
 		nodeOptions: {
 			cwd,
-			stdio: "inherit"
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
 		},
-		throwOnError: true
+		timeout: INSTALL_TIMEOUT_MS,
+		throwOnError: false
 	});
+	const lines = [];
+	for await (const line of result) {
+		lines.push(line);
+		onLine?.(line);
+	}
+	if (result.exitCode === 0) return;
+	if (result.exitCode === void 0) throw new Error(`\`${packageManager.name} ${args.join(" ")}\` timed out after ${INSTALL_TIMEOUT_MS / 6e4} minutes`);
+	const output = lines.slice(-20).join("\n");
+	throw new Error(`\`${packageManager.name} ${args.join(" ")}\` failed with exit code ${result.exitCode}${output ? `:\n${output}` : ""}`);
 }
 /**
-* What the installed manifests of the `selected` plugins say is missing from the selection: a
-* `dependencies` entry, or a `client` plugin next to a `consumer`. Empty when nothing is missing.
+* What the selected plugins' `manifests` say is missing from the selection: a `dependencies`
+* entry, or a `client` plugin next to a `consumer`. Empty when nothing is missing.
 * `optionalDependencies` are skipped, since `kubb init` writes the default options.
 */
-function missingPluginDependencies({ selected, manifests }) {
+function missingPluginDependencies(manifests) {
+	const selected = manifests.map((manifest) => manifest.name);
 	const hasClient = manifests.some((manifest) => manifest.role === "client");
 	return manifests.flatMap((manifest) => [...(manifest.dependencies ?? []).filter((name) => !selected.includes(name)).map((name) => `${manifest.name} needs ${name}.`), ...manifest.role === "consumer" && !hasClient ? [`${manifest.name} needs a client plugin, such as plugin-axios or plugin-fetch.`] : []]);
 }
+async function readPackageJson(cwd) {
+	try {
+		return JSON.parse(await read(path.join(cwd, "package.json")));
+	} catch {
+		return {};
+	}
+}
+const SPEC_FILE = /^(openapi|swagger)[\w.-]*\.(ya?ml|json)$/i;
+const SKIPPED_DIRS = /* @__PURE__ */ new Set([
+	"node_modules",
+	"dist",
+	"build",
+	"coverage"
+]);
+/**
+* Finds OpenAPI spec files up to `depth` folders below `cwd`, shallowest first, as `./`-relative
+* paths. Walks one level at a time and stops after `limit` files, so a large repo stays fast.
+*/
+async function findSpecFiles(cwd, { depth = 3, limit = 20 } = {}) {
+	const found = [];
+	let level = [""];
+	for (let current = 0; current <= depth && level.length && found.length < limit; current++) {
+		const listings = await Promise.all(level.map(async (dir) => ({
+			dir,
+			entries: await fs.promises.readdir(path.join(cwd, dir), { withFileTypes: true }).catch(() => [])
+		})));
+		level = [];
+		for (const { dir, entries } of listings) for (const entry of entries.toSorted((a, b) => a.name.localeCompare(b.name))) {
+			if (entry.isFile() && SPEC_FILE.test(entry.name)) found.push(`./${path.posix.join(dir, entry.name)}`);
+			if (entry.isDirectory() && !entry.name.startsWith(".") && !SKIPPED_DIRS.has(entry.name)) level.push(path.posix.join(dir, entry.name));
+		}
+	}
+	return found.slice(0, limit);
+}
+const SPEC_HEAD_BYTES = 262144;
+const METHOD = "(?:get|put|post|delete|options|head|patch|trace)";
+/**
+* Reads the OpenAPI or Swagger version and counts the operations from the first 256 KB of the
+* file, so a large spec is never parsed. The count is left out when the file is longer.
+*/
+async function readSpecInfo(file) {
+	const handle = await fs.promises.open(file);
+	try {
+		const buffer = Buffer.alloc(SPEC_HEAD_BYTES);
+		const { bytesRead } = await handle.read(buffer, 0, SPEC_HEAD_BYTES, 0);
+		const head = buffer.toString("utf-8", 0, bytesRead);
+		const complete = bytesRead < SPEC_HEAD_BYTES;
+		const version = head.match(/^\s*["']?(?:openapi|swagger)["']?\s*:\s*["']?(\d[\d.]*)/m)?.[1];
+		const methods = new RegExp(`^\\s*["']?${METHOD}["']?\\s*:\\s*(?:\\{|$)`, "gm");
+		return {
+			version,
+			operations: complete ? head.match(methods)?.length ?? 0 : void 0
+		};
+	} finally {
+		await handle.close();
+	}
+}
+/** Finds a plugin by registry id, slug, or short name, so `ts`, `plugin-ts`, and `kubb-labs/plugin-ts` all match. */
+function findPlugin({ plugins, id }) {
+	const ids = id.includes("/") ? [id] : [`kubb-labs/${id}`, `kubb-labs/plugin-${id}`];
+	return plugins.find((entry) => ids.includes(entry.id));
+}
+/**
+* Turns the comma-separated `--plugins` value into registry entries.
+*
+* @throws when an id is not in `plugins`.
+*/
+function parsePluginsFlag({ plugins, value }) {
+	const ids = value.split(",").map((id) => id.trim()).filter(Boolean);
+	const unknown = ids.filter((id) => !findPlugin({
+		plugins,
+		id
+	}));
+	if (unknown.length) throw new Diagnostics.Error({
+		code: Diagnostics.code.pluginNotFound,
+		severity: "error",
+		message: `Not in the Kubb registry: ${unknown.join(", ")}. Browse the plugins at https://kubb.dev/extensions.`,
+		help: "Use plugin ids from https://kubb.dev/extensions, such as plugin-ts or ts."
+	});
+	return ids.map((id) => findPlugin({
+		plugins,
+		id
+	}));
+}
+/** Adds `"generate": "kubb generate"` to the `package.json` scripts at `cwd`. Returns `false`, and changes nothing, when a `generate` script exists. */
+async function addGenerateScript(cwd) {
+	const file = path.join(cwd, "package.json");
+	const source = await read(file);
+	const packageJson = JSON.parse(source);
+	if (packageJson.scripts?.generate !== void 0) return false;
+	const indent = source.match(/^[ \t]+/m)?.[0] ?? "  ";
+	const updated = {
+		...packageJson,
+		scripts: {
+			...packageJson.scripts,
+			generate: "kubb generate"
+		}
+	};
+	await write(file, JSON.stringify(updated, null, indent));
+	return true;
+}
+/** Reads the `generate` script from the `package.json` at `cwd`. */
+async function generateScript(cwd) {
+	return (await readPackageJson(cwd)).scripts?.generate;
+}
+//#endregion
+//#region src/runners/installWithSpinner.ts
+/** How many package manager lines stay visible under the install title while it runs. */
+const LOG_LINES = 6;
+/**
+* Installs `packages` and reports how long it took. A rich terminal shows the package manager's
+* last lines under the title while the install runs and clears them when it succeeds; a plain one
+* prints the start and end lines. A failed install keeps the output, reports the failure and rethrows.
+*/
+async function installWithSpinner({ packages, names, packageManager, cwd, install = installPackages }) {
+	const start = process$1.hrtime();
+	const task = createTask(`Installing ${names} with ${packageManager.name}`);
+	try {
+		await install(packages, packageManager, cwd, task.message);
+	} catch (error) {
+		task.error("Install failed");
+		throw error;
+	}
+	task.success(`Installed ${names} with ${packageManager.name} in ${formatMs(getElapsedMs(start))}`);
+}
+function createTask(title) {
+	if (isRichOutput()) {
+		const log = clack.taskLog({
+			title,
+			limit: LOG_LINES
+		});
+		return {
+			message: (line) => log.message(line),
+			error: (text) => log.error(text, { showLog: false }),
+			success: (text) => log.success(text)
+		};
+	}
+	const spinner = createSpinner();
+	spinner.start(title);
+	return {
+		message: () => {},
+		error: (text) => spinner.error(text),
+		success: (text) => spinner.stop(text)
+	};
+}
 //#endregion
 //#region src/runners/add/run.ts
 /** The import and the `defineConfig` property to merge into `kubb.config.ts` by hand. */
@@ -543,55 +714,108 @@ function toSnippet({ artifact, manifest }) {
 		property[manifest.kind]
 	].join("\n");
 }
-/** Adds the plugin call and its import to the config file. Returns why it could not, or `undefined`. */
-async function addToConfig({ detail, configFile }) {
-	const { artifact, manifest } = detail;
+/** The `add-plugin` edits for `details`, and the manifests the edits read their export names from. */
+function toConfigEdits(details) {
+	return {
+		edits: details.map(({ artifact }) => ({
+			operation: "add-plugin",
+			plugin: artifact.package
+		})),
+		extensions: new Map(details.map(({ artifact, manifest }) => [artifact.package, {
+			package: artifact.package,
+			version: artifact.version,
+			manifest
+		}]))
+	};
+}
+/** The lines adding `details` would put in the config `source`, trimmed, or why it could not add them. */
+async function previewConfig({ details, source }) {
 	try {
-		const { writeConfigEdits } = await import("@kubb/studio");
-		const { outcomes } = await writeConfigEdits({
-			filePath: configFile,
-			edits: [{
-				operation: "add-plugin",
-				plugin: artifact.package
-			}],
-			extensions: /* @__PURE__ */ new Map([[artifact.package, {
-				package: artifact.package,
-				version: artifact.version,
-				manifest
-			}]])
+		const { applyConfigEdits } = await import("@kubb/studio");
+		const result = applyConfigEdits({
+			source,
+			...toConfigEdits(details)
 		});
-		return outcomes[0]?.applied ? void 0 : outcomes[0]?.reason ?? "the config file was not changed";
+		const failed = result.outcomes.find((outcome) => !outcome.applied);
+		if (failed) return { reason: failed.reason ?? "the config file was not changed" };
+		const remaining = source.split("\n");
+		return { lines: result.source.split("\n").filter((line) => {
+			const index = remaining.indexOf(line);
+			if (index !== -1) remaining.splice(index, 1);
+			return index === -1;
+		}).map((line) => line.trim()) };
 	} catch (error) {
-		return getErrorMessage(error);
+		return { reason: getErrorMessage(error) };
 	}
 }
-async function selectExtension(registry) {
-	const options = (await fetchRegistryIndex({ registry })).toSorted((a, b) => a.id.localeCompare(b.id)).map((entry) => ({
-		value: entry.id,
-		label: entry.manifest.displayName,
-		hint: `${entry.id} · ${entry.kind} ${entry.artifact.version} · ${entry.manifest.description}`
-	}));
-	if (!options.length) throw new Diagnostics.Error({
+async function selectExtension({ entries, versions, registry }) {
+	if (!entries.length) throw new Diagnostics.Error({
 		code: Diagnostics.code.unknown,
 		severity: "error",
 		message: `The registry at ${registry} lists no extensions.`,
 		help: "Check that `KUBB_REGISTRY` points at a Kubb registry, or unset it to use https://kubb.dev/registry."
 	});
+	const searchText = new Map(entries.map((entry) => [entry.id, `${entry.id} ${entry.manifest.displayName} ${entry.manifest.description}`.toLowerCase()]));
+	const options = entries.toSorted((a, b) => a.id.localeCompare(b.id)).map((entry) => {
+		const installed = versions.has(entry.artifact.package);
+		return {
+			value: entry.id,
+			label: toShortId(entry.id),
+			hint: installed ? "installed" : summarize(entry.manifest.description),
+			disabled: installed
+		};
+	});
 	const id = await clack.autocomplete({
-		message: "Select an extension to add:",
+		message: `Add an extension · ${entries.length} in the registry`,
+		placeholder: "Search",
 		options,
-		filter: (search, option) => `${option.label} ${option.hint}`.toLowerCase().includes(search.toLowerCase())
+		filter: (search, option) => searchText.get(option.value)?.includes(search.toLowerCase()) ?? false
 	});
 	return clack.isCancel(id) ? void 0 : id;
 }
+/** Asks whether to also add the required plugins the config lacks. `--yes` adds them. */
+async function confirmDependencies({ entry, missing, yes }) {
+	if (!missing.length || yes) return true;
+	const names = missing.map((dependency) => dependency.manifest.name).join(", ");
+	const answer = await clack.select({
+		message: `${entry.manifest.name} needs ${names}. Add ${names} as well?`,
+		options: [{
+			value: true,
+			label: `Yes, add ${missing.length === 1 ? "both" : "all"}`,
+			hint: "recommended"
+		}, {
+			value: false,
+			label: `Only ${entry.manifest.name}`,
+			hint: "generate fails until you add it"
+		}],
+		initialValue: true
+	});
+	return clack.isCancel(answer) ? void 0 : answer;
+}
+/** The first sentence of a registry description, cut to one terminal line. */
+function summarize(description, max = 64) {
+	const sentence = description.split(/\.\s/)[0].replace(/\.$/, "");
+	return sentence.length > max ? `${sentence.slice(0, max - 1).trimEnd()}…` : sentence;
+}
 /**
 * Installs an extension from the Kubb registry at its reviewed version and, for a plugin, adds it to
-* `kubb.config.ts`. Without an id, asks which one. Refuses when the running Kubb or Node.js version
-* is outside its compatibility.
+* `kubb.config.ts`, offering to add the plugins it needs as well. Without an id, asks which one.
+* Previews the packages and config lines before asking. Refuses when the running Kubb or Node.js
+* version is outside its compatibility.
 */
 async function run$4({ id: input, configPath, yes, install }) {
 	const cwd = process$1.cwd();
-	logIntro({ title: styleText("bgCyan", styleText("black", " Kubb Add ")) });
+	const hrStart = process$1.hrtime();
+	const summary = (title, status, lines) => logCommandSummary({
+		title,
+		status,
+		hrStart,
+		block: true,
+		lines
+	});
+	const installedPackages = [];
+	const configured = [];
+	logIntro({ title: isInteractiveRun({ yes }) ? void 0 : styleText("bgCyan", styleText("black", " Kubb Add ")) });
 	try {
 		const registry = registryUrl();
 		if (!input && yes) throw new Diagnostics.Error({
@@ -600,16 +824,38 @@ async function run$4({ id: input, configPath, yes, install }) {
 			message: "Pass a registry id, such as plugin-zod, when using --yes.",
 			help: "Run `kubb add plugin-zod --yes`, or drop `--yes` to pick from a list."
 		});
-		const id = input ? toRegistryId(input) : await selectExtension(registry);
+		const inputId = input ? toRegistryId(input) : void 0;
+		const foundConfig = configPath ? path.resolve(configPath) : findConfigFile(cwd);
+		const [entries, installed, configSource] = await withSpinner({
+			message: "Reading the registry",
+			promise: Promise.all([
+				fetchRegistryIndex({ registry }),
+				readInstalledPackages({ root: cwd }),
+				foundConfig ? read(foundConfig).catch(() => void 0) : void 0
+			])
+		});
+		const versions = new Map(installed.map((item) => [item.package, item.version]));
+		const id = inputId ?? await selectExtension({
+			entries,
+			versions,
+			registry
+		});
 		if (!id) {
-			clack.cancel("Operation canceled.");
+			summary("Add canceled", "canceled", ["  No changes made"]);
 			return;
 		}
-		const detail = await fetchRegistryDetail({
-			id,
-			registry
-		});
-		const { artifact, manifest } = detail;
+		const entry = entries.find((candidate) => candidate.id === id);
+		if (!entry) {
+			const suggestions = closestIds({
+				input: id,
+				ids: entries.map((entry) => entry.id)
+			}).map(toShortId);
+			summary(`No extension named ${input ?? id}`, "failed", [...suggestions.map((suggestion) => `  kubb add ${suggestion}`), "  Browse all  kubb.dev/extensions"]);
+			process$1.exitCode = 1;
+			return;
+		}
+		const { artifact, manifest } = entry;
+		const kind = manifest.kind.charAt(0).toUpperCase() + manifest.kind.slice(1);
 		const problem = incompatibility(manifest);
 		if (problem) throw new Diagnostics.Error({
 			code: Diagnostics.code.incompatibleExtension,
@@ -617,53 +863,108 @@ async function run$4({ id: input, configPath, yes, install }) {
 			message: problem,
 			help: "Upgrade Kubb or Node.js to a version the extension supports."
 		});
-		const spec = installSpec(artifact);
-		const configFile = manifest.kind === "plugin" ? configPath ? path.resolve(configPath) : findConfigFile(cwd) : void 0;
+		const configFile = manifest.kind === "plugin" ? foundConfig : void 0;
 		if (manifest.kind === "plugin" && !configFile) throw new Diagnostics.Error({
 			code: Diagnostics.code.unknown,
 			severity: "error",
 			message: "No kubb.config.ts found. Run `kubb init` first, or pass --config.",
 			help: "Run `kubb init` to create a config, or pass its path with `--config`."
 		});
-		logInfo(`${styleText("cyan", manifest.displayName)} (${manifest.kind}): ${manifest.description}`);
-		logBlock([install ? `Install ${styleText("cyan", spec)} as a dev dependency` : `Skip installing ${spec}`, configFile ? `Add ${styleText("cyan", `${manifest.export}()`)} to ${path.relative(cwd, configFile) || configFile}` : `Print the ${manifest.kind} snippet to add`]);
+		const configName = configFile ? path.relative(cwd, configFile) || configFile : void 0;
+		const byName = new Map(entries.map((candidate) => [candidate.manifest.name, candidate]));
+		const inConfig = (name) => {
+			const dependency = byName.get(name);
+			return dependency ? !!configSource?.includes(`${dependency.manifest.export}(`) : installed.some((item) => item.manifest?.name === name);
+		};
+		const dependencies = manifest.dependencies ?? [];
+		const missing = configFile ? dependencies.filter((name) => !inConfig(name)).flatMap((name) => byName.get(name) ?? []) : [];
+		const withDependencies = await confirmDependencies({
+			entry,
+			missing,
+			yes
+		});
+		if (withDependencies === void 0) {
+			summary("Add canceled", "canceled", [`  ${kind}  ${manifest.name}`, "  No changes made"]);
+			return;
+		}
+		const targets = [...withDependencies ? missing : [], entry];
+		const specs = targets.filter((target) => target === entry || !versions.has(target.artifact.package)).map((target) => installSpec(target.artifact));
+		const dependencyStatus = (name) => {
+			if (inConfig(name)) return `${name} ${styleText("green", "✓ installed")}`;
+			return targets.some((target) => target.manifest.name === name) ? `${name} ${styleText("cyan", "+ adding")}` : `${name} ${styleText("yellow", "missing")}`;
+		};
+		const preview = configFile && configSource !== void 0 ? await previewConfig({
+			details: targets,
+			source: configSource
+		}) : void 0;
+		logStep(`${kind} ${styleText("cyan", manifest.name)} v${artifact.version} · ${summarize(manifest.description)}`);
+		logBlock([
+			...dependencies.length ? [`Needs     ${dependencies.map(dependencyStatus).join("  ")}`] : [],
+			install ? `Installs  ${specs.join("  ")}` : "Installs  nothing (--no-install)",
+			...configName ? [`Config    ${configName}`] : [`Config    prints the ${manifest.kind} snippet to add`],
+			...preview && "lines" in preview ? preview.lines.map((line) => styleText("green", `  + ${line}`)) : [],
+			...preview && "reason" in preview ? [styleText("yellow", `  cannot edit it: ${preview.reason}`)] : []
+		]);
 		const confirmed = yes || await clack.confirm({
-			message: "Continue?",
+			message: "Add it?",
 			initialValue: true
 		});
 		if (clack.isCancel(confirmed) || !confirmed) {
-			clack.cancel("Operation canceled.");
+			summary("Add canceled", "canceled", [`  ${kind}  ${manifest.name}`, "  No changes made"]);
 			return;
 		}
+		const packageManager = detectPackageManager(cwd);
+		const packages = () => install ? `${installedPackages.length} installed with ${packageManager.name}` : "installation skipped (--no-install)";
 		if (install) {
-			const packageManager = detectPackageManager(cwd);
-			logStep(`Installing ${spec} with ${packageManager.name}`);
-			await installPackages([spec], packageManager, cwd);
+			const names = targets.filter((target) => specs.includes(installSpec(target.artifact))).map((target) => target.artifact.package);
+			await installWithSpinner({
+				packages: specs,
+				names: names.join(", "),
+				packageManager,
+				cwd
+			});
+			installedPackages.push(...names);
 		}
-		const reason = configFile ? await addToConfig({
-			detail,
-			configFile
-		}) : `add the ${manifest.kind} to your config`;
-		if (!reason) {
-			logOutro(styleText("green", install ? `Added ${spec}` : `Added ${manifest.export}() to the config. Install ${spec} to use it.`));
-			return;
+		const unconfigured = configFile ? [] : [entry];
+		if (configFile) for (const target of targets) try {
+			const { writeConfigEdits } = await import("@kubb/studio");
+			const { outcomes, changed } = await writeConfigEdits({
+				filePath: configFile,
+				...toConfigEdits([target])
+			});
+			if (!outcomes[0]?.applied) throw new Error(outcomes[0]?.reason ?? "the config file was not changed");
+			if (changed) configured.push(target);
+			logStep(`${target.manifest.export}() configured in ${configName}`);
+		} catch (error) {
+			logWarn(`Could not edit ${configName}: ${getErrorMessage(error)}`);
+			unconfigured.push(target);
 		}
-		if (configFile) logWarn(`Could not edit ${configFile}: ${reason}`);
-		logBlock([
+		const manual = unconfigured.length > 0;
+		if (manual) logBlock([
 			"Add the import to your Kubb config and merge the property into its defineConfig call:",
 			"",
-			toSnippet(detail)
+			...unconfigured.map((target) => toSnippet(target))
+		]);
+		const dependenciesMissing = !withDependencies && missing.length > 0;
+		summary(manual ? `${kind} needs configuration` : dependenciesMissing ? "Plugin configured; dependencies missing" : configured.length ? install ? "Plugin ready" : "Plugin configured" : "Plugin already configured", manual || dependenciesMissing ? "warning" : "success", [
+			`  Packages  ${packages()}`,
+			...configured.map((target) => styleText("green", `  + ${target.manifest.export}()`)),
+			"",
+			...!install ? [`Install ${specs.join(" ")} to use it.`] : [],
+			...dependenciesMissing ? [`Missing plugins  ${missing.map((target) => target.manifest.name).join(", ")}`] : [],
+			manual ? "Add the snippet above, then run kubb generate." : "Next     kubb generate",
+			`Options  kubb.dev/extensions/${entry.id}`
 		]);
-		logOutro(styleText("green", install ? `Installed ${spec}. Add it with the snippet above.` : `Install ${spec} and add the snippet above.`));
 	} catch (error) {
 		logError(getErrorMessage(error));
+		summary("Add failed", "failed", installedPackages.length ? [`  Packages  ${installedPackages.join(", ")} installed`] : ["  No changes made"]);
 		process$1.exitCode = 1;
 	}
 }
 __name(run$4, "run");
 const command$3 = define({
 	name: "add",
-	description: "Install a plugin, adapter, or parser from the Kubb registry at its reviewed version. Without an id, pick one from the registry. A plugin is added to kubb.config.ts, an adapter or parser prints the code to add. Reads KUBB_REGISTRY to use another registry.",
+	description: "Find and install plugins, adapters, and parsers from the Kubb registry.",
 	examples: [
 		"kubb add",
 		"kubb add plugin-zod",
@@ -700,154 +1001,300 @@ function cancelAndExit(message = "Operation canceled.") {
 	clack.cancel(message);
 	process$1.exit(0);
 }
+function unwrap(value) {
+	if (clack.isCancel(value)) cancelAndExit();
+	return value;
+}
+/** The full `kubb.config.ts` for `choices`, with each plugin added the way `kubb add` adds it. */
+async function buildConfig({ inputPath, outputPath, plugins }) {
+	const { applyConfigEdits } = await import("@kubb/studio");
+	const { source, outcomes } = applyConfigEdits({
+		source: generateConfigFile({
+			inputPath,
+			outputPath
+		}),
+		edits: plugins.map((entry) => ({
+			operation: "add-plugin",
+			plugin: entry.artifact.package
+		})),
+		extensions: new Map(plugins.map(({ artifact, manifest }) => [artifact.package, {
+			package: artifact.package,
+			version: artifact.version,
+			manifest
+		}]))
+	});
+	const failed = outcomes.find((outcome) => !outcome.applied);
+	if (failed && failed.edit.operation === "add-plugin") throw new Diagnostics.Error({
+		code: Diagnostics.code.unknown,
+		severity: "error",
+		message: `Could not add ${failed.edit.plugin} to ${KUBB_CONFIG_FILENAME}: ${failed.reason}`,
+		help: `Run kubb init without that plugin, then add it with kubb add.`
+	});
+	return source;
+}
+/** Generates from the config at `configPath` without reporters, and returns how many files it wrote. */
+async function firstRun(configPath) {
+	const { configs } = await getConfigs({ configPath });
+	let files = 0;
+	for (const config of configs) {
+		const result = await createKubb(config).generate();
+		if (!result.success) throw new Error(result.diagnostics.flatMap((diagnostic) => diagnostic.severity === "error" ? [diagnostic.message] : []).join("\n"));
+		files += result.files.length;
+	}
+	return files;
+}
+/** The command that runs `kubb generate`: the `generate` script when it runs Kubb, otherwise `npx kubb generate`. */
+function generateCommand({ packageManager, script, watch }) {
+	if (script !== "kubb generate") return `npx kubb generate${watch ? " --watch" : ""}`;
+	const run = [
+		packageManager.name,
+		...packageManager.runCommand,
+		"generate"
+	].join(" ");
+	if (!watch) return run;
+	return packageManager.name === "npm" ? `${run} -- --watch` : `${run} --watch`;
+}
 /**
-* Runs the interactive Kubb scaffolding wizard.
-* Detects the package manager, prompts for input/output paths and plugins, installs packages, and writes `kubb.config.ts`.
-* Pass `yes: true` to skip all prompts and use defaults.
+* Runs the Kubb setup wizard: detects the package manager and specs, asks for the spec, plugins, and
+* output folder, shows the config for review, then installs, writes `kubb.config.ts`, adds a
+* `generate` script, and runs the first generation.
+* Pass `yes: true` to skip all prompts and print one line per step.
 */
 async function run$3({ yes, input: inputFlag, output: outputFlag, plugins: pluginsFlag, dryRun }) {
 	const cwd = process$1.cwd();
-	logIntro({ title: styleText("bgCyan", styleText("black", " Kubb Init ")) });
-	/**
-	* Returns `flag` when provided, the `defaultValue` when `yes` is set,
-	* or calls `prompt()` for interactive input. Exits on cancellation.
-	*/
-	async function resolveOrPrompt(flag, defaultValue, logLabel, prompt) {
-		if (flag !== void 0) {
-			logInfo(`${logLabel}: ${styleText("cyan", String(flag))}`);
-			return flag;
-		}
-		if (yes) {
-			logInfo(`${logLabel}: ${styleText("cyan", String(defaultValue))}`);
-			return defaultValue;
+	/** Runs `task` behind a spinner, or prints one line when it is done in `--yes` mode. */
+	async function step({ start, task, done, failed }) {
+		const spinner = createSpinner();
+		if (!yes) spinner.start(start);
+		try {
+			const result = await task();
+			if (yes) console.log(`${styleText("green", "✓")} ${done(result)}`);
+			else spinner.stop(done(result));
+			return result;
+		} catch (error) {
+			if (!yes) spinner.error(failed);
+			throw error;
 		}
-		const result = await prompt();
-		if (clack.isCancel(result)) cancelAndExit();
-		return result;
 	}
+	if (!yes) logIntro({ title: isInteractiveRun({
+		yes,
+		dryRun: dryRun.enabled
+	}) ? void 0 : "Set up Kubb" });
 	try {
-		const plugins = (await fetchRegistryIndex({ registry: registryUrl() })).filter((entry) => entry.kind === "plugin" && !incompatibility(entry.manifest));
-		const byId = new Map(plugins.map((entry) => [entry.id, entry]));
-		if (!fs.existsSync(path.join(cwd, "package.json"))) {
+		const registry = fetchRegistryIndex({ registry: registryUrl() }).then((entries) => entries.filter((entry) => entry.kind === "plugin" && !incompatibility(entry.manifest)));
+		registry.catch(() => {});
+		if (!yes) import("@kubb/studio").catch(() => {});
+		if (!await exists(path.join(cwd, "package.json"))) {
 			if (!yes) {
-				const shouldInit = await clack.confirm({
+				if (!unwrap(await clack.confirm({
 					message: "No package.json found. Would you like to create one?",
 					initialValue: true
-				});
-				if (clack.isCancel(shouldInit) || !shouldInit) cancelAndExit();
+				}))) cancelAndExit();
 			}
 			const packageManager = detectPackageManager(cwd);
-			const spinner = createSpinner();
-			spinner.start(`Initializing package.json with ${packageManager.name}`);
-			await initPackageJson(cwd, packageManager);
-			spinner.stop(`Created package.json with ${packageManager.name}`);
+			await step({
+				start: `Initializing package.json with ${packageManager.name}`,
+				task: () => initPackageJson(cwd, packageManager),
+				done: () => `Created package.json with ${packageManager.name}`,
+				failed: "Could not create package.json"
+			});
 		}
 		const packageManager = detectPackageManager(cwd);
-		logInfo(`Detected package manager: ${styleText("cyan", packageManager.name)}`);
-		const inputPath = await resolveOrPrompt(inputFlag, initDefaults.inputPath, "Using input path", () => clack.text({
-			message: "Where is your OpenAPI specification located?",
-			placeholder: initDefaults.inputPath,
-			defaultValue: initDefaults.inputPath,
-			validate: (value) => {
-				if (!value) return "Input path is required";
-			}
-		}));
-		const outputPath = await resolveOrPrompt(outputFlag, initDefaults.outputPath, "Using output path", () => clack.text({
-			message: "Where should the generated files be output?",
-			placeholder: initDefaults.outputPath,
-			defaultValue: initDefaults.outputPath,
-			validate: (value) => {
-				if (!value) return "Output path is required";
-			}
-		}));
-		const defaultPlugins = initDefaults.plugins.flatMap((slug) => byId.get(toRegistryId(slug)) ?? []);
-		const pluginLabel = (entries) => styleText("cyan", entries.map((entry) => entry.manifest.displayName).join(", "));
-		const selectedPlugins = await (async () => {
-			if (pluginsFlag) {
-				const ids = pluginsFlag.split(",").map((id) => id.trim()).filter(Boolean);
-				const unknown = ids.filter((id) => !byId.has(toRegistryId(id)));
-				if (unknown.length) throw new Diagnostics.Error({
-					code: Diagnostics.code.pluginNotFound,
-					severity: "error",
-					message: `Not in the Kubb registry: ${unknown.join(", ")}. Browse the plugins at https://kubb.dev/extensions.`,
-					help: "Use plugin ids from https://kubb.dev/extensions, such as plugin-ts."
-				});
-				const entries = ids.map((id) => byId.get(toRegistryId(id)));
-				logInfo(`Using plugins: ${pluginLabel(entries)}`);
-				return entries;
-			}
-			if (yes) {
-				logInfo(`Using plugins: ${pluginLabel(defaultPlugins)}`);
-				return defaultPlugins;
+		const specs = await findSpecFiles(cwd);
+		if (!yes) {
+			logStep(`Package manager  ${packageManager.name}`);
+			if (specs[0]) {
+				const { version: specVersion, operations } = await readSpecInfo(path.join(cwd, specs[0]));
+				const details = [
+					specs[0].slice(2),
+					specVersion ? `${specVersion.startsWith("2") ? "Swagger" : "OpenAPI"} ${specVersion}` : void 0,
+					operations === void 0 ? void 0 : pluralize(operations, "operation"),
+					specs.length > 1 ? `+${specs.length - 1} more` : void 0
+				];
+				logStep(`Found     ${details.filter(Boolean).join(" · ")}`);
 			}
-			const values = await clack.multiselect({
-				message: "Select plugins to use:",
+		}
+		const plugins = pluginsFlag || yes ? await registry : void 0;
+		const defaultPlugins = (entries) => initDefaults.plugins.flatMap((id) => findPlugin({
+			plugins: entries,
+			id
+		}) ?? []);
+		const flagPlugins = pluginsFlag && plugins ? parsePluginsFlag({
+			plugins,
+			value: pluginsFlag
+		}) : void 0;
+		let choices = {
+			inputPath: inputFlag ?? specs[0] ?? initDefaults.inputPath,
+			outputPath: outputFlag ?? initDefaults.outputPath,
+			plugins: flagPlugins ?? (plugins ? defaultPlugins(plugins) : [])
+		};
+		if (yes && !choices.plugins.length) throw new Error("The registry has no default plugin. Pass --plugins to choose one.");
+		async function askInput(current) {
+			const choice = specs.length ? unwrap(await clack.select({
+				message: "Which spec should Kubb read?",
+				options: [
+					...specs.map((spec) => ({
+						value: spec,
+						label: spec,
+						hint: "found in this repo"
+					})),
+					{
+						value: "url",
+						label: "A URL"
+					},
+					{
+						value: "file",
+						label: "Another file"
+					}
+				],
+				initialValue: specs.includes(current) ? current : /^https?:\/\//.test(current) ? "url" : "file"
+			})) : /^https?:\/\//.test(current) ? "url" : "file";
+			if (specs.includes(choice)) return choice;
+			const isUrl = choice === "url";
+			const initial = isUrl === /^https?:\/\//.test(current) && !specs.includes(current) ? current : void 0;
+			return unwrap(await clack.text({
+				message: isUrl ? "Spec URL" : "Spec path",
+				placeholder: isUrl ? "https://example.com/openapi.yaml" : initDefaults.inputPath,
+				initialValue: initial,
+				defaultValue: isUrl ? void 0 : initDefaults.inputPath,
+				validate: (value) => {
+					if (isUrl && !/^https?:\/\//.test(value ?? "")) return "Enter an http(s) URL";
+				}
+			}));
+		}
+		async function askPlugins(previous) {
+			const plugins = await registry;
+			const current = previous.length ? previous : defaultPlugins(plugins);
+			const width = Math.max(...plugins.map((entry) => entry.manifest.displayName.length));
+			const nameWidth = Math.max(...plugins.map((entry) => entry.manifest.name.length));
+			const values = unwrap(await clack.multiselect({
+				message: "What should Kubb generate?",
 				options: plugins.map(({ id, manifest }) => ({
 					value: id,
-					label: manifest.displayName,
-					hint: manifest.category
+					label: `${manifest.displayName.padEnd(width)}  ${styleText("dim", manifest.name.padEnd(nameWidth))}`.trimEnd()
 				})),
-				initialValues: defaultPlugins.map((entry) => entry.id),
+				initialValues: current.map((entry) => entry.id),
 				required: true
-			});
-			if (clack.isCancel(values)) cancelAndExit();
+			}));
 			return plugins.filter((entry) => values.includes(entry.id));
-		})();
-		const missing = missingPluginDependencies({
-			selected: selectedPlugins.map((entry) => entry.manifest.name),
-			manifests: selectedPlugins.map((entry) => entry.manifest)
-		});
+		}
+		const answered = yes || Boolean(inputFlag && outputFlag && pluginsFlag);
+		if (!answered) {
+			let firstPass = true;
+			while (true) {
+				choices = {
+					inputPath: firstPass && inputFlag ? inputFlag : await askInput(choices.inputPath),
+					plugins: firstPass && flagPlugins ? flagPlugins : await askPlugins(choices.plugins),
+					outputPath: firstPass && outputFlag ? outputFlag : unwrap(await clack.text({
+						message: "Output folder",
+						placeholder: choices.outputPath,
+						defaultValue: choices.outputPath
+					}))
+				};
+				firstPass = false;
+				const missing = missingPluginDependencies(choices.plugins.map((entry) => entry.manifest));
+				if (missing.length) {
+					logWarn(`${missing.join("\n")}\nAdd the missing plugins.`);
+					continue;
+				}
+				const config = await buildConfig(choices);
+				const packages = [KUBB_PACKAGE_NAME, ...choices.plugins.map((entry) => entry.artifact.package)];
+				logStep(`Review ${KUBB_CONFIG_FILENAME}`);
+				logBlock([
+					...config.trimEnd().split("\n"),
+					"",
+					`${styleText("dim", "Installs")}  ${packages.join(" ")} with ${packageManager.name}`
+				]);
+				const configExists = await exists(path.join(cwd, KUBB_CONFIG_FILENAME));
+				if (unwrap(await clack.select({
+					message: configExists ? `kubb.config.ts exists. Overwrite it?` : "Create it?",
+					options: [{
+						value: true,
+						label: "Yes"
+					}, {
+						value: false,
+						label: "Change a choice"
+					}]
+				}))) break;
+			}
+		}
+		const missing = missingPluginDependencies(choices.plugins.map((entry) => entry.manifest));
 		if (missing.length) throw new Diagnostics.Error({
 			code: Diagnostics.code.missingDependency,
 			severity: "error",
 			message: `${missing.join("\n")}\nAdd the missing plugins and run kubb init again.`
 		});
-		const packagesToInstall = [`${KUBB_PACKAGE_NAME}@${version}`, ...selectedPlugins.map((entry) => installSpec(entry.artifact))];
-		const spinner = createSpinner();
-		spinner.start(`Installing ${packagesToInstall.length} packages with ${packageManager.name}`);
-		try {
-			await dryRun.run(() => installPackages(packagesToInstall, packageManager, cwd), { message: `install ${packagesToInstall.length} packages with ${packageManager.name}` });
-			spinner.stop(`Installed ${packagesToInstall.length} packages`);
-		} catch (error) {
-			spinner.stop("Installation failed");
-			throw error;
-		}
-		const configSpinner = createSpinner();
-		configSpinner.start(`Creating ${KUBB_CONFIG_FILENAME}`);
-		const configContent = generateConfigFile({
-			inputPath,
-			outputPath
-		});
 		const configPath = path.join(cwd, KUBB_CONFIG_FILENAME);
-		if (fs.existsSync(configPath)) {
-			configSpinner.stop(`${KUBB_CONFIG_FILENAME} already exists`);
-			if (!yes) {
-				const shouldOverwrite = await clack.confirm({
-					message: `${KUBB_CONFIG_FILENAME} already exists. Overwrite?`,
-					initialValue: false
-				});
-				if (clack.isCancel(shouldOverwrite) || !shouldOverwrite) cancelAndExit("Keeping existing configuration. Packages have been installed.");
-			}
-			configSpinner.start(`Overwriting ${KUBB_CONFIG_FILENAME}`);
+		if (answered && !yes && await exists(configPath)) {
+			if (!unwrap(await clack.confirm({
+				message: `kubb.config.ts exists. Overwrite it?`,
+				initialValue: false
+			}))) cancelAndExit("Keeping existing configuration.");
 		}
-		await dryRun.run(() => fs.promises.writeFile(configPath, configContent, "utf-8"), { message: `write ${KUBB_CONFIG_FILENAME}` });
-		for (const entry of selectedPlugins) {
-			const reason = await dryRun.run(() => addToConfig({
-				detail: entry,
-				configFile: configPath
+		const packagesToInstall = [`${KUBB_PACKAGE_NAME}@${version}`, ...choices.plugins.map((entry) => installSpec(entry.artifact))];
+		const packageNames = [KUBB_PACKAGE_NAME, ...choices.plugins.map((entry) => entry.artifact.package)];
+		const dry = { message: `install ${packagesToInstall.length} packages with ${packageManager.name}` };
+		if (yes) await step({
+			start: "",
+			task: async () => void await dryRun.run(() => installPackages(packagesToInstall, packageManager, cwd), dry),
+			done: () => `Installed ${packageNames.join(" ")} with ${packageManager.name}`,
+			failed: "Installation failed"
+		});
+		else await installWithSpinner({
+			packages: packagesToInstall,
+			names: `${packagesToInstall.length} packages`,
+			packageManager,
+			cwd,
+			install: async (packages, packageManager, cwd, onLine) => void await dryRun.run(() => installPackages(packages, packageManager, cwd, onLine), dry)
+		});
+		await step({
+			start: `Writing ${KUBB_CONFIG_FILENAME}`,
+			task: async () => dryRun.run(async () => void await write(configPath, await buildConfig(choices)), { message: `write ${KUBB_CONFIG_FILENAME}` }),
+			done: () => `Wrote ${KUBB_CONFIG_FILENAME}`,
+			failed: `Could not write ${KUBB_CONFIG_FILENAME}`
+		});
+		const scriptAdded = await dryRun.run(() => addGenerateScript(cwd), {
+			message: "add a generate script to package.json",
+			resolve: async () => await generateScript(cwd) === void 0
+		});
+		if (scriptAdded && !yes) logStep("Added \"generate\": \"kubb generate\" to package.json");
+		const script = scriptAdded ? "kubb generate" : await generateScript(cwd);
+		const runStart = process$1.hrtime();
+		try {
+			await dryRun.run(() => step({
+				start: "Running the first generation",
+				task: () => firstRun(configPath),
+				done: (files) => yes ? `Generated ${pluralize(files, "file")} in ${choices.outputPath}` : `First run  ${pluralize(files, "file")} in ${choices.outputPath} · ${formatMs(getElapsedMs(runStart))}`,
+				failed: "First run failed"
 			}), {
-				message: `add ${entry.manifest.export}() to ${KUBB_CONFIG_FILENAME}`,
-				resolve: () => void 0
-			});
-			if (reason) throw new Diagnostics.Error({
-				code: Diagnostics.code.unknown,
-				severity: "error",
-				message: `Could not add ${entry.manifest.export}() to ${KUBB_CONFIG_FILENAME}: ${reason}`,
-				help: `Add ${entry.manifest.export}() to the plugins array in ${KUBB_CONFIG_FILENAME} by hand.`
+				message: "run the first generation",
+				resolve: () => 0
 			});
+		} catch (error) {
+			logError(error instanceof Error ? error.message : String(error));
+			const message = `Kubb is set up, but the first run failed. Fix the error, then run ${generateCommand({
+				packageManager,
+				script,
+				watch: false
+			})}.`;
+			if (yes) console.log(message);
+			else logOutro(styleText("yellow", message));
+			process$1.exitCode = 1;
+			return;
 		}
-		configSpinner.stop(`Created ${KUBB_CONFIG_FILENAME}`);
-		logOutro(styleText("green", "✓ All set!") + "\n\n" + styleText("dim", "Next steps:") + "\n" + styleText("cyan", `  1. Make sure your OpenAPI spec is at: ${inputPath}`) + "\n" + styleText("cyan", "  2. Generate code with: npx kubb generate") + "\n" + styleText("cyan", `  3. Find generated files in: ${outputPath}`) + "\n\n" + styleText("dim", `Using ${packageManager.name} • Kubb v${version}`));
+		if (yes) {
+			console.log(`Kubb is set up. Run ${generateCommand({
+				packageManager,
+				script,
+				watch: false
+			})} after changing the spec.`);
+			return;
+		}
+		logOutro(`${styleText("green", "✓ Kubb is set up")}\n   ${styleText("dim", "Next")}  ${generateCommand({
+			packageManager,
+			script,
+			watch: true
+		})}`);
 	} catch (error) {
 		logError(styleText("red", "An error occurred during initialization"));
 		if (error instanceof Error) logError(error.message);
@@ -857,11 +1304,12 @@ async function run$3({ yes, input: inputFlag, output: outputFlag, plugins: plugi
 __name(run$3, "run");
 const command$2 = defineWithTypes()({
 	name: "init",
-	description: "Scaffold a kubb.config.ts and install plugins for code generation from an OpenAPI spec. Run without flags for interactive setup, or pass --input, --output, and --plugins to skip the prompts.",
+	description: "Set up a config, install plugins, and run the first generation.",
 	examples: [
 		"kubb init",
 		"kubb init --yes",
 		"kubb init --input ./openapi.yaml --output ./src/gen --plugins plugin-ts,plugin-zod",
+		"kubb init --yes --input ./openapi.yaml --plugins ts,zod --output src/api",
 		"kubb init --plugins plugin-ts,plugin-axios,plugin-react-query",
 		"kubb init --yes --dry-run"
 	].join("\n"),
@@ -869,7 +1317,7 @@ const command$2 = defineWithTypes()({
 	args: {
 		yes: {
 			type: "boolean",
-			description: "Skip prompts and use default options",
+			description: "Skip prompts and use the detected spec, the default plugin, and the default output folder",
 			short: "y",
 			default: false
 		},
@@ -887,7 +1335,7 @@ const command$2 = defineWithTypes()({
 		},
 		plugins: {
 			type: "string",
-			description: "Comma-separated Kubb registry ids of the plugins to add, the same ids `kubb add` takes (plugin-ts, plugin-zod, acme/plugin-x)",
+			description: "Comma-separated Kubb registry ids of the plugins to add, the same ids `kubb add` takes (plugin-ts, plugin-zod, acme/plugin-x), or short names (ts, zod)",
 			metavar: "plugin-ts,plugin-zod,..."
 		}
 	},
@@ -900,6 +1348,13 @@ const command$2 = defineWithTypes()({
 	})
 });
 //#endregion
+//#region src/ui/table.ts
+/** Pads each column to its widest cell, one line per row. */
+function formatTable(rows) {
+	const widths = Array.from({ length: Math.max(0, ...rows.map((row) => row.length)) }, (_, index) => Math.max(...rows.map((row) => row[index]?.length ?? 0)));
+	return rows.map((row) => row.map((cell, index) => cell.padEnd(widths[index])).join("  ").trimEnd());
+}
+//#endregion
 //#region src/runners/list/run.ts
 /**
 * The installed packages that ship a `kubb-extension.json` or have a registry entry, with the
@@ -938,23 +1393,20 @@ async function run$2() {
 			logOutro("No installed extensions found.");
 			return;
 		}
-		const header = [
+		const [head, ...body] = formatTable([[
 			"ID",
 			"PACKAGE",
 			"INSTALLED",
 			"REGISTRY",
 			"UPDATE"
-		];
-		const cells = rows.map((row) => [
+		], ...rows.map((row) => [
 			row.id ?? "-",
 			row.package,
 			row.installed ?? "-",
 			row.registry ?? "-",
 			row.update ? "yes" : "no"
-		]);
-		const widths = header.map((title, index) => Math.max(title.length, ...cells.map((cell) => cell[index].length)));
-		const line = (cell) => cell.map((value, index) => value.padEnd(widths[index])).join("  ").trimEnd();
-		logBlock([styleText("dim", line(header)), ...cells.map(line)]);
+		])]);
+		logBlock([styleText("dim", head), ...body]);
 	} catch (error) {
 		logError(getErrorMessage(error));
 		process$1.exitCode = 1;
@@ -963,82 +1415,193 @@ async function run$2() {
 __name(run$2, "run");
 const command$1 = define({
 	name: "list",
-	description: "List the installed Kubb extensions: their registry id, package, installed version, the version the Kubb registry pins, and whether an update exists.",
+	description: "List installed extensions, their versions, and available updates.",
 	examples: "kubb list",
 	run: () => run$2()
 });
 //#endregion
 //#region src/runners/update/run.ts
 /**
-* Moves installed extensions to the version the registry pins. Lists the proposals, asks, then
-* installs them. With `check`, only lists them.
+* Generates every config in this process, the way `kubb generate` does, and returns the output files
+* it changed. Runs after the install, so the config loads the new versions. `undefined` when the
+* config fails to load or a build fails.
+*/
+async function regenerate({ cwd, configPath }) {
+	const spinner = createSpinner();
+	spinner.start("Generating with the new versions");
+	try {
+		const [{ getConfigs }, { generate }] = await Promise.all([import("./config-iVdOcpro.js"), import("./run-wkN1irUo.js")]);
+		const { configs } = await getConfigs({ configPath });
+		const dirs = configs.map((config) => path.resolve(config.root ?? cwd, config.output.path));
+		const before = new Map((await Promise.all(dirs.map(readOutputFiles))).flatMap((files) => [...files]));
+		const hooks = new Hookable();
+		for (const config of configs) if (!await generate({
+			config,
+			hooks
+		})) throw new Error("Generation failed");
+		const after = new Map((await Promise.all(dirs.map(readOutputFiles))).flatMap((files) => [...files]));
+		const diff = diffFiles(before, after);
+		spinner.stop(diff.files.length ? `Generated: ${pluralize(diff.files.length, "file")} changed` : "Generated: no files changed");
+		return {
+			...diff,
+			output: dirs.map((dir) => path.relative(cwd, dir) || ".").join(", ")
+		};
+	} catch (error) {
+		spinner.error(`Generation failed: ${getErrorMessage(error)}`);
+		return;
+	}
+}
+/**
+* Moves installed extensions to the version the registry pins. Shows each version change with its
+* bump, asks which to install with majors left out, installs them, and regenerates to show which
+* files changed. With `dryRun`, only lists the updates and installs nothing.
 */
-async function run$1({ ids, check, yes }) {
+async function run$1({ ids, dryRun, yes }) {
 	const cwd = process$1.cwd();
-	logIntro({ title: styleText("bgCyan", styleText("black", " Kubb Update ")) });
+	const hrStart = process$1.hrtime();
+	const installedPackages = [];
+	const summary = (title, status, lines) => logCommandSummary({
+		title,
+		status,
+		hrStart,
+		block: true,
+		lines
+	});
+	logIntro({ title: isInteractiveRun({
+		yes,
+		dryRun
+	}) ? void 0 : styleText("bgCyan", styleText("black", " Kubb Update ")) });
 	try {
 		const wanted = new Set(ids.map(toRegistryId));
-		const [entries, installed] = await Promise.all([fetchRegistryIndex({ registry: registryUrl() }), readInstalledPackages({ root: cwd })]);
+		const [entries, installed] = await withSpinner({
+			message: "Checking the registry",
+			promise: Promise.all([fetchRegistryIndex({ registry: registryUrl() }), readInstalledPackages({ root: cwd })])
+		});
 		const versions = new Map(installed.map((item) => [item.package, item.version]));
 		const tracked = entries.filter((entry) => versions.has(entry.artifact.package) && (!wanted.size || wanted.has(entry.id)));
 		for (const id of wanted) if (!tracked.some((entry) => entry.id === id)) logWarn(`${id} is not installed, or not in the registry.`);
-		const proposals = tracked.filter((entry) => {
-			if (!isOutdated({
-				installed: versions.get(entry.artifact.package),
-				latest: entry.artifact.version
-			})) return false;
+		const current = ({ artifact }) => versions.get(artifact.package);
+		const isMajor = (entry) => bumpOf({
+			installed: current(entry),
+			latest: entry.artifact.version
+		}) === "major";
+		const outdated = tracked.filter((entry) => isOutdated({
+			installed: current(entry),
+			latest: entry.artifact.version
+		}));
+		const proposals = outdated.filter((entry) => {
 			const problem = incompatibility(entry.manifest);
 			if (problem) logWarn(`Skipped ${entry.id}: ${problem}`);
 			return !problem;
 		});
 		if (!proposals.length) {
-			logOutro(ids.length ? `No updates for ${ids.join(", ")}.` : "Every installed extension is up to date.");
+			const title = outdated.length ? "No compatible updates available" : "Already up to date";
+			summary(tracked.length ? title : "No installed extensions to update", outdated.length ? "warning" : "success", [`  ${tracked.length - outdated.length} of ${tracked.length} up to date`, ...ids.length ? ["", `No updates for ${ids.join(", ")}.`] : []]);
 			return;
 		}
-		const change = ({ kind, artifact }) => `${kind}  ${versions.get(artifact.package) ?? "not installed"} -> ${styleText("green", artifact.version)}`;
-		logBlock(proposals.map((entry) => `${entry.artifact.package}  ${change(entry)}`));
-		if (check) {
-			const plural = proposals.length === 1 ? "" : "s";
-			logOutro(`${proposals.length} update${plural} available. Run \`kubb update\` to install.`);
+		if (tracked.length) {
+			const lines = formatTable([[
+				"Extension",
+				"Current",
+				"Latest",
+				""
+			], ...tracked.map((entry) => {
+				if (!outdated.includes(entry)) return [
+					entry.artifact.package,
+					current(entry) ?? "-",
+					"up to date",
+					""
+				];
+				const bump = bumpOf({
+					installed: current(entry),
+					latest: entry.artifact.version
+				}) ?? "";
+				return [
+					entry.artifact.package,
+					current(entry) ?? "not installed",
+					entry.artifact.version,
+					bump === "major" ? "major · breaking" : bump
+				];
+			})]);
+			logStep(`Checked ${pluralize(tracked.length, "extension")} against the registry`);
+			logBlock([styleText("dim", lines[0]), ...lines.slice(1).map((line, index) => {
+				if (!outdated.includes(tracked[index])) return styleText("dim", line);
+				return line.endsWith("major · breaking") ? styleText("yellow", line) : line;
+			})]);
+		}
+		if (dryRun) {
+			summary("Updates available", "planned", [`Dry run: nothing was installed. Run kubb update to install ${proposals.length === 1 ? "it" : "them"}.`]);
 			return;
 		}
-		let selected = proposals;
-		if (!yes) {
-			const chosen = await clack.multiselect({
-				message: "Select the updates to install:",
-				options: proposals.map((entry) => ({
-					value: entry.id,
-					label: entry.artifact.package,
-					hint: change(entry)
-				})),
-				initialValues: proposals.map((entry) => entry.id),
-				required: true
-			});
-			if (clack.isCancel(chosen)) {
-				clack.cancel("Operation canceled.");
-				return;
-			}
-			selected = proposals.filter((entry) => chosen.includes(entry.id));
+		const defaults = proposals.filter((entry) => !isMajor(entry));
+		const chosen = yes ? defaults.map((entry) => entry.id) : await clack.multiselect({
+			message: "Select the updates to install",
+			options: proposals.map((entry) => ({
+				value: entry.id,
+				label: entry.artifact.package,
+				hint: `${current(entry) ?? "not installed"} → ${entry.artifact.version}`
+			})),
+			initialValues: defaults.map((entry) => entry.id),
+			required: false
+		});
+		if (clack.isCancel(chosen)) {
+			summary("Update canceled", "canceled", ["  No changes made"]);
+			return;
+		}
+		const selected = proposals.filter((entry) => chosen.includes(entry.id));
+		const skipped = proposals.filter((entry) => !selected.includes(entry)).map((entry) => {
+			const kind = entry.manifest.kind.charAt(0).toUpperCase() + entry.manifest.kind.slice(1);
+			return `  ${styleText("dim", "Skipped")}  ${kind} ${entry.artifact.package} ${entry.artifact.version}  ${styleText("dim", `run kubb update ${toShortId(entry.id)} later`)}`;
+		});
+		if (!selected.length) {
+			summary("No updates installed", "canceled", ["  No updates selected.", ...skipped]);
+			return;
 		}
-		const plural = selected.length === 1 ? "" : "s";
 		const packageManager = detectPackageManager(cwd);
-		const specs = selected.map(({ artifact }) => installSpec(artifact));
-		logStep(`Installing ${specs.join(", ")} with ${packageManager.name}`);
-		await installPackages(specs, packageManager, cwd);
-		logInfo(`Updated ${specs.length} extension${plural}`);
-		logOutro(styleText("green", "Done"));
+		const names = selected.map(({ artifact }) => artifact.package).join(", ");
+		await installWithSpinner({
+			packages: selected.map(({ artifact }) => installSpec(artifact)),
+			names,
+			packageManager,
+			cwd
+		});
+		installedPackages.push(...selected.map((entry) => entry.artifact.package));
+		const foundConfig = findConfigFile(cwd);
+		const configPath = foundConfig && !yes && await clack.confirm({
+			message: "Regenerate now? This rewrites the generated files.",
+			initialValue: true
+		}) === true ? foundConfig : void 0;
+		const changed = configPath ? await regenerate({
+			cwd,
+			configPath
+		}) : void 0;
+		const generationFailed = Boolean(configPath && !changed);
+		const fileCounts = {
+			A: 0,
+			M: 0,
+			D: 0
+		};
+		for (const file of changed?.files ?? []) fileCounts[file.status]++;
+		summary(generationFailed ? "Extensions updated; generation failed" : "Update complete", generationFailed ? "warning" : "success", [
+			`  Packages  ${selected.length} installed with ${packageManager.name}${skipped.length ? ` · ${skipped.length} skipped` : ""}`,
+			...skipped,
+			...changed ? [`  Files     ${fileCounts.A} added · ${fileCounts.M} modified · ${fileCounts.D} deleted`] : [],
+			...!configPath ? ["  Regeneration not run"] : [],
+			...generationFailed ? ["", "Fix the generation error, then run kubb generate."] : []
+		]);
 	} catch (error) {
 		logError(getErrorMessage(error));
+		summary("Update failed", "failed", installedPackages.length ? [`  Packages  ${installedPackages.join(", ")} installed`] : ["  No changes made"]);
 		process$1.exitCode = 1;
 	}
 }
 __name(run$1, "run");
-const command = define({
+const command = defineWithTypes()({
 	name: "update",
-	description: "Update installed extensions to the version the Kubb registry pins. Pass ids to update only those, or --check to list the updates without installing.",
+	description: "Update installed extensions, regenerate, and summarize file changes.",
 	examples: [
 		"kubb update",
-		"kubb update --check",
+		"kubb update --dry-run",
 		"kubb update plugin-zod plugin-ts --yes"
 	].join("\n"),
 	args: {
@@ -1047,16 +1610,11 @@ const command = define({
 			description: "Registry ids to update, all installed extensions when omitted",
 			multiple: true
 		},
-		check: {
-			type: "boolean",
-			description: "List the available updates without installing them",
-			default: false
-		},
 		...yesArg
 	},
-	run: ({ values }) => run$1({
+	run: ({ values, extensions }) => run$1({
 		ids: values.ids ?? [],
-		check: values.check,
+		dryRun: extensions[dryRunId].enabled,
 		yes: values.yes
 	})
 });
@@ -1077,7 +1635,7 @@ const QUIET_FLAGS = /* @__PURE__ */ new Set([
 async function run(argv = process.argv.slice(2)) {
 	const args = routeStudioFlags(resolveDeprecatedFlags(argv));
 	const isQuietFlag = args.some((arg) => QUIET_FLAGS.has(arg));
-	const isJsonReporter = args.some((arg, index) => /^--reporter=.*\bjson\b/.test(arg) || arg === "--reporter" && /\bjson\b/.test(args[index + 1] ?? ""));
+	const isJsonOutput = args.includes("--json") || args.some((arg, index) => /^--reporter=.*\bjson\b/.test(arg) || arg === "--reporter" && /\bjson\b/.test(args[index + 1] ?? ""));
 	if (!isDisabled() && !isQuietFlag) console.error(`${styleText("yellow", "Notice:")} Kubb collects anonymous telemetry data to help improve the tool. No personal data or file contents are collected. \nTo disable, set ${styleText("cyan", "KUBB_DISABLE_TELEMETRY=1")}.\n`);
 	await cli(args, command$13, {
 		name: "kubb",
@@ -1094,7 +1652,14 @@ async function run(argv = process.argv.slice(2)) {
 			list: command$1
 		},
 		fallbackToEntry: true,
-		...isJsonReporter ? { renderHeader: null } : {},
+		renderHeader: isJsonOutput ? null : async (ctx) => {
+			if (!wantsMascot({
+				commandPath: ctx.commandPath,
+				values: ctx.values
+			})) return "";
+			ctx.log(getBanner(version, ctx.commandPath.join(" ") || "generate"));
+			return "";
+		},
 		strict: true,
 		plugins: [dryrun({ name: "dry-run" })],
 		onErrorCommand: async (_ctx, error) => {