padrone 1.1.0 → 1.3.0

package/dist/help-CgGP7hQU.mjs

@@ -0,0 +1,1229 @@
+import { t as __require } from "./chunk-y_GBKt04.mjs";
+import { a as parsePositionalConfig, i as extractSchemaMetadata, o as parseStdinConfig, t as camelToKebab } from "./args-DFEI7_G_.mjs";
+//#region src/utils.ts
+function getRootCommand(cmd) {
+	let current = cmd;
+	while (current.parent) current = current.parent;
+	return current;
+}
+/**
+* Attempts to get the version from various sources:
+* 1. Explicit version set on the command
+* 2. npm_package_version environment variable (set by npm/yarn/pnpm when running scripts)
+* 3. package.json in current or parent directories
+* @param explicitVersion - Version explicitly set via .version()
+* @returns The version string or '0.0.0' if not found
+*/
+function getVersion(explicitVersion) {
+	if (explicitVersion) return explicitVersion;
+	if (typeof process !== "undefined" && process.env?.npm_package_version) return process.env.npm_package_version;
+	if (typeof process !== "undefined") try {
+		const fs = __require("node:fs");
+		const path = __require("node:path");
+		let dir = process.cwd();
+		for (let i = 0; i < 10; i++) {
+			const pkgPath = path.join(dir, "package.json");
+			if (fs.existsSync(pkgPath)) {
+				const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+				if (pkg.version) return pkg.version;
+			}
+			const parentDir = path.dirname(dir);
+			if (parentDir === dir) break;
+			dir = parentDir;
+		}
+	} catch {}
+	return "0.0.0";
+}
+/**
+* Loads and parses a config file from the given path.
+* Supports JSON, JSONC (JSON with comments), and attempts to parse other formats.
+* @param configPath - Path to the config file
+* @returns Parsed config data or undefined if loading fails
+*/
+function loadConfigFile(configPath) {
+	if (typeof process === "undefined") return void 0;
+	try {
+		const fs = __require("node:fs");
+		const path = __require("node:path");
+		const absolutePath = path.isAbsolute(configPath) ? configPath : path.resolve(process.cwd(), configPath);
+		if (!fs.existsSync(absolutePath)) {
+			console.error(`Config file not found: ${absolutePath}`);
+			return;
+		}
+		const getContent = () => fs.readFileSync(absolutePath, "utf-8");
+		const ext = path.extname(absolutePath).toLowerCase();
+		if (ext === ".yaml" || ext === ".yml") return Bun.YAML.parse(getContent());
+		if (ext === ".toml") return Bun.TOML.parse(getContent());
+		if (ext === ".json") {
+			if (Bun.JSONC) return Bun.JSONC.parse(getContent());
+			try {
+				return JSON.parse(getContent());
+			} catch {
+				return Bun.JSONC.parse(getContent());
+			}
+		}
+		if (ext === ".jsonc") return Bun.JSONC.parse(getContent());
+		if (ext === ".js" || ext === ".cjs" || ext === ".mjs" || ext === ".ts" || ext === ".cts" || ext === ".mts") return __require(absolutePath);
+		try {
+			return JSON.parse(getContent());
+		} catch {
+			console.error(`Unable to parse config file: ${absolutePath}`);
+			return;
+		}
+	} catch (error) {
+		console.error(`Error loading config file: ${error}`);
+		return;
+	}
+}
+/**
+* Searches for a config file from a list of possible file names.
+* Searches in the current working directory.
+* @param configFiles - Array of possible config file names to search for
+* @returns The path to the first found config file, or undefined if none found
+*/
+function findConfigFile(configFiles) {
+	if (typeof process === "undefined" || !configFiles?.length) return void 0;
+	try {
+		const fs = __require("node:fs");
+		const path = __require("node:path");
+		const cwd = process.cwd();
+		for (const configFile of configFiles) {
+			const configPath = path.isAbsolute(configFile) ? configFile : path.resolve(cwd, configFile);
+			if (fs.existsSync(configPath)) return configPath;
+		}
+	} catch {}
+}
+//#endregion
+//#region src/runtime.ts
+/**
+* Default terminal prompt implementation powered by Enquirer.
+* Lazily imported to avoid loading Enquirer when not needed.
+*/
+async function defaultTerminalPrompt(config) {
+	const Enquirer = (await import("enquirer")).default;
+	const question = {
+		type: config.type,
+		name: config.name,
+		message: config.message
+	};
+	if (config.default !== void 0) question.initial = config.default;
+	if (config.choices) question.choices = config.choices.map((c) => ({
+		name: String(c.value),
+		message: c.label
+	}));
+	return (await Enquirer.prompt(question))[config.name];
+}
+/**
+* Creates a persistent Node.js readline session for the REPL.
+* Enables up/down arrow history navigation and tab completion.
+* Used internally by `repl()` when no custom `readLine` is provided.
+*/
+/**
+* Sentinel value returned by the terminal REPL session when Ctrl+C is pressed.
+* Distinguished from empty string (user pressed enter) and null (EOF/Ctrl+D).
+*/
+const REPL_SIGINT = Symbol("REPL_SIGINT");
+function createTerminalReplSession(config) {
+	let history = config.history ? [...config.history] : [];
+	let currentCompleter = config.completer;
+	return {
+		set completer(fn) {
+			currentCompleter = fn;
+		},
+		async question(prompt) {
+			const { createInterface } = await import("node:readline");
+			const opts = {
+				input: process.stdin,
+				output: process.stdout,
+				terminal: true,
+				history: [...history],
+				historySize: Math.max(history.length, 1e3)
+			};
+			if (currentCompleter) opts.completer = currentCompleter;
+			const rl = createInterface(opts);
+			return new Promise((resolve) => {
+				let resolved = false;
+				const settle = (value) => {
+					if (resolved) return;
+					resolved = true;
+					rl.close();
+					resolve(value);
+				};
+				rl.question(prompt, (answer) => {
+					if (Array.isArray(rl.history)) history = [...rl.history];
+					settle(answer);
+				});
+				rl.once("SIGINT", () => {
+					process.stdout.write("\n");
+					settle(REPL_SIGINT);
+				});
+				rl.once("close", () => {
+					process.stdout.write("\n");
+					settle(null);
+				});
+			});
+		},
+		close() {}
+	};
+}
+/**
+* Auto-detect interactive mode when not explicitly set.
+* Returns 'disabled' in CI environments or non-TTY contexts, 'supported' otherwise.
+*/
+function detectInteractiveMode() {
+	if (typeof process === "undefined") return "disabled";
+	if (process.env.CI || process.env.CONTINUOUS_INTEGRATION) return "disabled";
+	if (!process.stdout?.isTTY) return "disabled";
+	return "supported";
+}
+/**
+* Creates the default Node.js/Bun runtime.
+*/
+/**
+* Creates a default stdin reader from `process.stdin`.
+* Only created when a command actually declares a `stdin` meta field.
+*/
+function createDefaultStdin() {
+	return {
+		get isTTY() {
+			if (typeof process === "undefined") return true;
+			return process.stdin?.isTTY === true;
+		},
+		async text() {
+			if (typeof process === "undefined") return "";
+			const chunks = [];
+			for await (const chunk of process.stdin) chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+			return Buffer.concat(chunks).toString("utf-8");
+		},
+		async *lines() {
+			if (typeof process === "undefined") return;
+			const { createInterface } = await import("node:readline");
+			const rl = createInterface({ input: process.stdin });
+			try {
+				for await (const line of rl) yield line;
+			} finally {
+				rl.close();
+			}
+		}
+	};
+}
+function createDefaultRuntime() {
+	return {
+		output: (...args) => console.log(...args),
+		error: (text) => console.error(text),
+		argv: () => typeof process !== "undefined" ? process.argv.slice(2) : [],
+		env: () => typeof process !== "undefined" ? process.env : {},
+		format: "auto",
+		loadConfigFile,
+		findFile: findConfigFile,
+		prompt: defaultTerminalPrompt,
+		interactive: detectInteractiveMode()
+	};
+}
+/**
+* Merges a partial runtime with the default runtime.
+*/
+/**
+* Returns the stdin abstraction: custom runtime stdin > default process.stdin.
+* Returns `undefined` when no custom stdin is provided and process.stdin is not piped.
+*/
+function resolveStdin(partial) {
+	if (partial?.stdin) return partial.stdin;
+	const defaultStdin = createDefaultStdin();
+	if (defaultStdin.isTTY) return void 0;
+	return defaultStdin;
+}
+function resolveRuntime(partial) {
+	const defaults = createDefaultRuntime();
+	if (!partial) return defaults;
+	return {
+		output: partial.output ?? defaults.output,
+		error: partial.error ?? defaults.error,
+		argv: partial.argv ?? defaults.argv,
+		env: partial.env ?? defaults.env,
+		format: partial.format ?? defaults.format,
+		loadConfigFile: partial.loadConfigFile ?? defaults.loadConfigFile,
+		findFile: partial.findFile ?? defaults.findFile,
+		interactive: partial.interactive ?? defaults.interactive,
+		prompt: partial.prompt ?? defaults.prompt,
+		readLine: partial.readLine ?? defaults.readLine,
+		stdin: partial.stdin
+	};
+}
+//#endregion
+//#region src/command-utils.ts
+/**
+* Brands a schema as async, signaling that its `validate()` may return a Promise.
+* When an async-branded schema is passed to `.arguments()`, `.configFile()`, or `.env()`,
+* the command's `parse()` and `cli()` will return Promises.
+*
+* @example
+* ```ts
+* const schema = asyncSchema(z.object({
+*   name: z.string(),
+* }).check(async (data) => {
+*   // async validation logic
+* }));
+*
+* const program = createPadrone('app')
+*   .command('greet', (c) => c.arguments(schema).action((args) => args.name));
+*
+* // parse() now returns Promise<PadroneParseResult>
+* const result = await program.parse('greet --name world');
+* ```
+*/
+function asyncSchema(schema) {
+	return Object.assign(schema, { "~async": true });
+}
+const commandSymbol = Symbol("padrone_command");
+const noop = () => void 0;
+/** Config keys that are merged when overriding a command. */
+const configKeys = [
+	"title",
+	"description",
+	"version",
+	"deprecated",
+	"hidden",
+	"needsApproval",
+	"autoOutput",
+	"updateCheck"
+];
+/**
+* Merges an existing command with an override.
+* - Config fields are shallow-merged (new overrides old).
+* - Action, arguments, meta, config schema, env schema are taken from the override if set.
+* - Subcommands are recursively merged by name.
+*/
+function mergeCommands(existing, override) {
+	const merged = { ...existing };
+	for (const key of configKeys) if (override[key] !== void 0) merged[key] = override[key];
+	if (override.action !== existing.action) merged.action = override.action;
+	if (override.argsSchema !== existing.argsSchema) merged.argsSchema = override.argsSchema;
+	if (override.meta !== existing.meta) merged.meta = override.meta;
+	if (override.configSchema !== existing.configSchema) merged.configSchema = override.configSchema;
+	if (override.envSchema !== existing.envSchema) merged.envSchema = override.envSchema;
+	if (override.configFiles !== existing.configFiles) merged.configFiles = override.configFiles;
+	if (override.isAsync !== existing.isAsync) merged.isAsync = override.isAsync || existing.isAsync;
+	if (override.runtime !== existing.runtime) merged.runtime = override.runtime;
+	if (override.plugins !== existing.plugins) merged.plugins = override.plugins;
+	if (override.aliases !== existing.aliases) merged.aliases = override.aliases;
+	if (override.commands) {
+		const baseCommands = [...existing.commands || []];
+		for (const overrideChild of override.commands) {
+			const existingIndex = baseCommands.findIndex((c) => c.name === overrideChild.name);
+			if (existingIndex >= 0) baseCommands[existingIndex] = mergeCommands(baseCommands[existingIndex], overrideChild);
+			else baseCommands.push(overrideChild);
+		}
+		merged.commands = baseCommands;
+	}
+	return merged;
+}
+/**
+* Maps over a value that may or may not be a Promise.
+* If the value is a Promise, chains with `.then()`. Otherwise, calls the function synchronously.
+* This preserves sync behavior for sync schemas and async behavior for async schemas.
+*/
+function thenMaybe(value, fn) {
+	if (value instanceof Promise) return value.then(fn);
+	return fn(value);
+}
+function isIterator(value) {
+	return typeof value === "object" && value !== null && Symbol.iterator in value && typeof value[Symbol.iterator] === "function";
+}
+function isAsyncIterator(value) {
+	return typeof value === "object" && value !== null && Symbol.asyncIterator in value && typeof value[Symbol.asyncIterator] === "function";
+}
+/**
+* Writes a command's return value to output, handling promises, iterators, and async iterators.
+* Values are passed directly to the output function without stringification —
+* runtimes like Node/Bun already format objects via console.log.
+* Returns void or a Promise depending on whether async consumption is needed.
+*/
+function outputValue(value, output) {
+	if (value == null) return;
+	if (isAsyncIterator(value)) return (async () => {
+		const iter = value[Symbol.asyncIterator]();
+		while (true) {
+			const { done, value: item } = await iter.next();
+			if (done) break;
+			if (item != null) output(item);
+		}
+	})();
+	if (typeof value !== "string" && !Array.isArray(value) && isIterator(value)) {
+		const iter = value[Symbol.iterator]();
+		while (true) {
+			const { done, value: item } = iter.next();
+			if (done) break;
+			if (item != null) output(item);
+		}
+		return;
+	}
+	if (value instanceof Promise) return value.then((resolved) => outputValue(resolved, output));
+	output(value);
+}
+/**
+* Runs a plugin chain for a given phase using the onion/middleware pattern.
+* Plugins are sorted by `order` (ascending, stable), then composed so that
+* the first plugin in sorted order is the outermost wrapper.
+* If no plugins handle this phase, `core` is called directly.
+*/
+function runPluginChain(phase, plugins, ctx, core) {
+	const phasePlugins = plugins.filter((p) => p[phase]);
+	if (phasePlugins.length === 0) return core();
+	phasePlugins.sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+	let next = core;
+	for (let i = phasePlugins.length - 1; i >= 0; i--) {
+		const handler = phasePlugins[i][phase];
+		const prevNext = next;
+		next = () => handler(ctx, prevNext);
+	}
+	return next();
+}
+/**
+* Wraps a pipeline with start → error → shutdown lifecycle hooks.
+* - `start` plugins wrap the pipeline (onion pattern, root plugins only).
+* - On error: `error` plugins run (can transform/suppress the error).
+* - Always: `shutdown` plugins run (success or failure).
+*/
+function wrapWithLifecycle(plugins, command, state, input, pipeline, wrapErrorResult) {
+	const hasStart = plugins.some((p) => p.start);
+	const hasError = plugins.some((p) => p.error);
+	const hasShutdown = plugins.some((p) => p.shutdown);
+	if (!hasStart && !hasError && !hasShutdown) return pipeline();
+	const runShutdown = (error, result) => {
+		if (!hasShutdown) return;
+		return runPluginChain("shutdown", plugins, {
+			command,
+			state,
+			error,
+			result
+		}, () => {});
+	};
+	const runError = (error) => {
+		if (!hasError) {
+			const s = runShutdown(error);
+			if (s instanceof Promise) return s.then(() => {
+				throw error;
+			});
+			throw error;
+		}
+		return thenMaybe(runPluginChain("error", plugins, {
+			command,
+			state,
+			error
+		}, () => ({ error })), (er) => {
+			if (er.error !== void 0) return thenMaybe(runShutdown(er.error), () => {
+				throw er.error;
+			});
+			const wrapped = wrapErrorResult ? wrapErrorResult(er.result) : er.result;
+			return thenMaybe(runShutdown(void 0, wrapped), () => wrapped);
+		});
+	};
+	const handleSuccess = (result) => {
+		const s = runShutdown(void 0, result);
+		if (s instanceof Promise) return s.then(() => result);
+		return result;
+	};
+	const startCtx = {
+		command,
+		state,
+		input
+	};
+	let result;
+	try {
+		result = hasStart ? runPluginChain("start", plugins, startCtx, pipeline) : pipeline();
+	} catch (e) {
+		return runError(e);
+	}
+	if (result instanceof Promise) return result.then(handleSuccess, runError);
+	return handleSuccess(result);
+}
+/**
+* Resolves the runtime for a command by walking up the parent chain.
+* Returns a fully resolved runtime with all defaults filled in.
+*/
+function getCommandRuntime(cmd) {
+	let current = cmd;
+	while (current) {
+		if (current.runtime) return resolveRuntime(current.runtime);
+		current = current.parent;
+	}
+	return resolveRuntime();
+}
+function isAsyncBranded(schema) {
+	return !!schema && typeof schema === "object" && "~async" in schema && schema["~async"] === true;
+}
+function hasInteractiveConfig(meta) {
+	if (!meta || typeof meta !== "object") return false;
+	const m = meta;
+	return m.interactive === true || Array.isArray(m.interactive) || m.optionalInteractive === true || Array.isArray(m.optionalInteractive);
+}
+function warnIfUnexpectedAsync(value, command) {
+	if (typeof process !== "undefined" && process.env?.NODE_ENV === "production") return value;
+	if (value instanceof Promise && !command.isAsync) getCommandRuntime(command).error(`[padrone] Command "${command.path || command.name}" returned a Promise from validation, but was not marked as async. Use \`.async()\` on the builder or \`asyncSchema()\` to brand your schema. Without this, TypeScript will infer a sync return type and the result will be a Promise at runtime.`);
+	return value;
+}
+/**
+* Recursively re-paths a command tree under a new parent path, updating parent references.
+*/
+function repathCommandTree(cmd, newName, parentPath, parent) {
+	const newPath = parentPath ? `${parentPath} ${newName}` : newName;
+	const remounted = {
+		...cmd,
+		name: newName,
+		path: newPath,
+		parent,
+		version: void 0
+	};
+	if (cmd.commands?.length) remounted.commands = cmd.commands.map((child) => repathCommandTree(child, child.name, newPath, remounted));
+	return remounted;
+}
+/**
+* Builds a completer function for the REPL from the command tree.
+* Completes command names, subcommand names, option names (--foo), and aliases (-f).
+* Also includes dot-prefixed built-in REPL commands (.exit, .clear, .scope, .help, .history).
+*/
+function buildReplCompleter(rootCommand, builtins) {
+	return (line) => {
+		const parts = line.trimStart().split(/\s+/);
+		const lastPart = parts[parts.length - 1] ?? "";
+		if (lastPart.startsWith(".")) {
+			const dotCmds = [
+				".exit",
+				".clear",
+				".help",
+				".history"
+			];
+			if (rootCommand.commands?.some((c) => c.commands?.length) || builtins.inScope) dotCmds.push(".scope");
+			const hits = dotCmds.filter((c) => c.startsWith(lastPart));
+			return [hits.length ? hits : dotCmds, lastPart];
+		}
+		if (lastPart.startsWith("-")) {
+			const commandParts = parts.slice(0, -1).filter((p) => !p.startsWith("-"));
+			let targetCommand = rootCommand;
+			for (const part of commandParts) {
+				const sub = targetCommand.commands?.find((c) => c.name === part || c.aliases?.includes(part));
+				if (sub) targetCommand = sub;
+				else break;
+			}
+			const options = [];
+			if (targetCommand.argsSchema) try {
+				const argsMeta = targetCommand.meta?.fields;
+				const { flags, aliases } = extractSchemaMetadata(targetCommand.argsSchema, argsMeta, targetCommand.meta?.autoAlias);
+				const jsonSchema = targetCommand.argsSchema["~standard"].jsonSchema.input({ target: "draft-2020-12" });
+				if (jsonSchema.type === "object" && jsonSchema.properties) {
+					for (const key of Object.keys(jsonSchema.properties)) options.push(`--${key}`);
+					for (const flag of Object.keys(flags)) options.push(`-${flag}`);
+					for (const alias of Object.keys(aliases)) options.push(`--${alias}`);
+				}
+			} catch {}
+			options.push("--help", "-h");
+			const hits = options.filter((o) => o.startsWith(lastPart));
+			return [hits.length ? hits : options, lastPart];
+		}
+		const commandParts = parts.filter((p) => !p.startsWith("-"));
+		let targetCommand = rootCommand;
+		for (let i = 0; i < commandParts.length - 1; i++) {
+			const sub = targetCommand.commands?.find((c) => c.name === commandParts[i] || c.aliases?.includes(commandParts[i]));
+			if (sub) targetCommand = sub;
+			else break;
+		}
+		const candidates = [];
+		if (targetCommand.commands) {
+			for (const cmd of targetCommand.commands) if (!cmd.hidden) {
+				candidates.push(cmd.name);
+				if (cmd.aliases) candidates.push(...cmd.aliases);
+			}
+		}
+		if (targetCommand === rootCommand) {
+			candidates.push(".help", ".exit", ".clear", ".history");
+			if (rootCommand.commands?.some((c) => c.commands?.length) || builtins.inScope) candidates.push(".scope");
+			if (builtins.inScope) candidates.push("..");
+		}
+		const hits = candidates.filter((c) => c.startsWith(lastPart));
+		return [hits.length ? hits : candidates, lastPart];
+	};
+}
+/**
+* Computes the Levenshtein edit distance between two strings.
+*/
+function levenshtein(a, b) {
+	const m = a.length;
+	const n = b.length;
+	const dp = Array.from({ length: n + 1 }, (_, i) => i);
+	for (let i = 1; i <= m; i++) {
+		let prev = dp[0];
+		dp[0] = i;
+		for (let j = 1; j <= n; j++) {
+			const temp = dp[j];
+			dp[j] = a[i - 1] === b[j - 1] ? prev : 1 + Math.min(prev, dp[j], dp[j - 1]);
+			prev = temp;
+		}
+	}
+	return dp[n];
+}
+/**
+* Finds the closest match from a list of candidates using Levenshtein distance.
+* Returns the suggestion string (e.g. 'Did you mean "deploy"?') or empty string if no good match.
+* Threshold: distance must be at most 40% of the longer string's length (min 1, max 3).
+*/
+function suggestSimilar(input, candidates) {
+	if (candidates.length === 0) return "";
+	const lower = input.toLowerCase();
+	let bestDist = Infinity;
+	let bestMatch = "";
+	for (const candidate of candidates) {
+		const dist = levenshtein(lower, candidate.toLowerCase());
+		if (dist < bestDist) {
+			bestDist = dist;
+			bestMatch = candidate;
+		}
+	}
+	const maxLen = Math.max(input.length, bestMatch.length);
+	const threshold = Math.min(3, Math.max(1, Math.ceil(maxLen * .4)));
+	if (bestDist > 0 && bestDist <= threshold) return `Did you mean "${bestMatch}"?`;
+	return "";
+}
+function findCommandByName(name, commands) {
+	if (!commands) return void 0;
+	const foundByName = commands.find((cmd) => cmd.name === name);
+	if (foundByName) return foundByName;
+	const foundByAlias = commands.find((cmd) => cmd.aliases?.includes(name));
+	if (foundByAlias) return foundByAlias;
+	for (const cmd of commands) {
+		if (cmd.commands && name.startsWith(`${cmd.name} `)) {
+			const subCommand = findCommandByName(name.slice(cmd.name.length + 1), cmd.commands);
+			if (subCommand) return subCommand;
+		}
+		if (cmd.commands && cmd.aliases) {
+			for (const alias of cmd.aliases) if (name.startsWith(`${alias} `)) {
+				const subCommand = findCommandByName(name.slice(alias.length + 1), cmd.commands);
+				if (subCommand) return subCommand;
+			}
+		}
+	}
+}
+//#endregion
+//#region src/colorizer.ts
+const colors = {
+	reset: "\x1B[0m",
+	bold: "\x1B[1m",
+	dim: "\x1B[2m",
+	italic: "\x1B[3m",
+	underline: "\x1B[4m",
+	strikethrough: "\x1B[9m",
+	cyan: "\x1B[36m",
+	green: "\x1B[32m",
+	yellow: "\x1B[33m",
+	blue: "\x1B[34m",
+	magenta: "\x1B[35m",
+	gray: "\x1B[90m"
+};
+function createColorizer() {
+	return {
+		command: (text) => `${colors.cyan}${colors.bold}${text}${colors.reset}`,
+		arg: (text) => `${colors.green}${text}${colors.reset}`,
+		type: (text) => `${colors.yellow}${text}${colors.reset}`,
+		description: (text) => `${colors.dim}${text}${colors.reset}`,
+		label: (text) => `${colors.bold}${text}${colors.reset}`,
+		meta: (text) => `${colors.gray}${text}${colors.reset}`,
+		example: (text) => `${colors.underline}${text}${colors.reset}`,
+		exampleValue: (text) => `${colors.italic}${text}${colors.reset}`,
+		deprecated: (text) => `${colors.strikethrough}${colors.gray}${text}${colors.reset}`
+	};
+}
+//#endregion
+//#region src/formatter.ts
+function createTextStyler() {
+	return {
+		command: (text) => text,
+		arg: (text) => text,
+		type: (text) => text,
+		description: (text) => text,
+		label: (text) => text,
+		meta: (text) => text,
+		example: (text) => text,
+		exampleValue: (text) => text,
+		deprecated: (text) => text
+	};
+}
+function createAnsiStyler() {
+	const colorizer = createColorizer();
+	return {
+		command: colorizer.command,
+		arg: colorizer.arg,
+		type: colorizer.type,
+		description: colorizer.description,
+		label: colorizer.label,
+		meta: colorizer.meta,
+		example: colorizer.example,
+		exampleValue: colorizer.exampleValue,
+		deprecated: colorizer.deprecated
+	};
+}
+function createConsoleStyler() {
+	const colors = {
+		reset: "\x1B[0m",
+		bold: "\x1B[1m",
+		dim: "\x1B[2m",
+		italic: "\x1B[3m",
+		underline: "\x1B[4m",
+		strikethrough: "\x1B[9m",
+		cyan: "\x1B[36m",
+		green: "\x1B[32m",
+		yellow: "\x1B[33m",
+		gray: "\x1B[90m"
+	};
+	return {
+		command: (text) => `${colors.cyan}${colors.bold}${text}${colors.reset}`,
+		arg: (text) => `${colors.green}${text}${colors.reset}`,
+		type: (text) => `${colors.yellow}${text}${colors.reset}`,
+		description: (text) => `${colors.dim}${text}${colors.reset}`,
+		label: (text) => `${colors.bold}${text}${colors.reset}`,
+		meta: (text) => `${colors.gray}${text}${colors.reset}`,
+		example: (text) => `${colors.underline}${text}${colors.reset}`,
+		exampleValue: (text) => `${colors.italic}${text}${colors.reset}`,
+		deprecated: (text) => `${colors.strikethrough}${colors.gray}${text}${colors.reset}`
+	};
+}
+function createMarkdownStyler() {
+	return {
+		command: (text) => `**${text}**`,
+		arg: (text) => `\`${text}\``,
+		type: (text) => `\`${text}\``,
+		description: (text) => text,
+		label: (text) => `### ${text}`,
+		meta: (text) => `*${text}*`,
+		example: (text) => `**${text}**`,
+		exampleValue: (text) => `\`${text}\``,
+		deprecated: (text) => `~~${text}~~`
+	};
+}
+function escapeHtml(text) {
+	return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+}
+function createHtmlStyler() {
+	return {
+		command: (text) => `<strong style="color: #00bcd4;">${escapeHtml(text)}</strong>`,
+		arg: (text) => `<code style="color: #4caf50;">${escapeHtml(text)}</code>`,
+		type: (text) => `<code style="color: #ff9800;">${escapeHtml(text)}</code>`,
+		description: (text) => `<span style="color: #666;">${escapeHtml(text)}</span>`,
+		label: (text) => `<h3>${escapeHtml(text)}</h3>`,
+		meta: (text) => `<span style="color: #999;">${escapeHtml(text)}</span>`,
+		example: (text) => `<strong style="text-decoration: underline;">${escapeHtml(text)}</strong>`,
+		exampleValue: (text) => `<em>${escapeHtml(text)}</em>`,
+		deprecated: (text) => `<del style="color: #999;">${escapeHtml(text)}</del>`
+	};
+}
+function createTextLayout() {
+	return {
+		newline: "\n",
+		indent: (level) => "  ".repeat(level),
+		join: (parts) => parts.filter(Boolean).join(" "),
+		usageLabel: "Usage:"
+	};
+}
+function createMarkdownLayout() {
+	return {
+		newline: "\n\n",
+		indent: (level) => {
+			if (level === 0) return "";
+			if (level === 1) return "  ";
+			return "    ";
+		},
+		join: (parts) => parts.filter(Boolean).join(" "),
+		usageLabel: "Usage:"
+	};
+}
+function createHtmlLayout() {
+	return {
+		newline: "<br>",
+		indent: (level) => "&nbsp;&nbsp;".repeat(level),
+		join: (parts) => parts.filter(Boolean).join(" "),
+		wrapDocument: (content) => `<div style="font-family: monospace; line-height: 1.6;">${content}</div>`,
+		usageLabel: "<strong>Usage:</strong>"
+	};
+}
+/**
+* Creates a formatter that uses the given styler and layout configuration.
+*/
+function createGenericFormatter(styler, layout) {
+	const { newline, indent, join, wrapDocument, usageLabel } = layout;
+	function formatUsageSection(info) {
+		const usageParts = [styler.command(info.usage.command), info.usage.hasSubcommands ? styler.meta("[command]") : ""];
+		if (info.positionals && info.positionals.length > 0) for (const arg of info.positionals) {
+			const name = arg.name.startsWith("...") ? `${arg.name}` : arg.name;
+			usageParts.push(styler.meta(arg.optional ? `[${name}]` : `<${name}>`));
+		}
+		if (info.usage.hasArguments) usageParts.push(styler.meta("[options]"));
+		return [`${usageLabel} ${join(usageParts)}`];
+	}
+	function formatSubcommandsSection(info) {
+		const lines = [];
+		const subcommands = info.subcommands;
+		lines.push(styler.label("Commands:"));
+		const subcommandSuffix = (c) => c.hasSubcommands ? " <subcommand>" : "";
+		const formatAliasParts = (c) => {
+			if (!c.aliases?.length) return {
+				plain: "",
+				styled: ""
+			};
+			const realAliases = c.aliases.filter((a) => a !== "[default]");
+			const hasDefault = c.aliases.some((a) => a === "[default]");
+			const parts = [];
+			const styledParts = [];
+			if (realAliases.length) {
+				parts.push(`(${realAliases.join(", ")})`);
+				styledParts.push(`(${realAliases.join(", ")})`);
+			}
+			if (hasDefault) {
+				parts.push("[default]");
+				styledParts.push(styler.meta("[default]"));
+			}
+			return {
+				plain: parts.length ? ` ${parts.join(" ")}` : "",
+				styled: styledParts.length ? ` ${styledParts.join(" ")}` : ""
+			};
+		};
+		const maxNameLength = Math.max(...subcommands.map((c) => {
+			return (c.name + subcommandSuffix(c) + formatAliasParts(c).plain).length;
+		}));
+		for (const subCmd of subcommands) {
+			const aliasParts = formatAliasParts(subCmd);
+			const suffix = subcommandSuffix(subCmd);
+			const commandDisplay = subCmd.name + suffix + aliasParts.plain;
+			const padding = " ".repeat(Math.max(0, maxNameLength - commandDisplay.length + 2));
+			const isDeprecated = !!subCmd.deprecated;
+			const isDefaultEntry = subCmd.name === "[default]";
+			const lineParts = [isDeprecated ? styler.deprecated(commandDisplay) : (isDefaultEntry ? styler.meta(subCmd.name) : styler.command(subCmd.name)) + (suffix ? styler.meta(suffix) : "") + aliasParts.styled, padding];
+			const displayText = subCmd.title ?? subCmd.description;
+			if (displayText) lineParts.push(isDeprecated ? styler.deprecated(displayText) : styler.description(displayText));
+			if (isDeprecated) {
+				const deprecatedMeta = typeof subCmd.deprecated === "string" ? styler.meta(` (deprecated: ${subCmd.deprecated})`) : styler.meta(" (deprecated)");
+				lineParts.push(deprecatedMeta);
+			}
+			lines.push(indent(1) + lineParts.join(""));
+		}
+		lines.push("");
+		lines.push(styler.meta(`Run "${info.name} [command] --help" for more information on a command.`));
+		return lines;
+	}
+	function formatPositionalsSection(info) {
+		const lines = [];
+		const args = info.positionals;
+		lines.push(styler.label("Arguments:"));
+		const maxNameLength = Math.min(32, Math.max(...args.map((a) => a.name.length)));
+		for (const arg of args) {
+			const padding = " ".repeat(Math.max(2, maxNameLength - arg.name.length + 2));
+			const descParts = [];
+			if (arg.description) descParts.push(styler.description(arg.description));
+			if (info.usage.stdinField === arg.name) descParts.push(styler.meta("(stdin)"));
+			if (arg.default !== void 0) descParts.push(styler.meta(`(default: ${String(arg.default)})`));
+			lines.push(indent(1) + styler.arg(arg.name) + padding + join(descParts));
+		}
+		return lines;
+	}
+	function formatArgumentsSection(info) {
+		const lines = [];
+		const argList = info.arguments || [];
+		lines.push(styler.label("Options:"));
+		const hasDefault = (value) => {
+			if (value === void 0) return false;
+			if (value === "") return false;
+			if (Array.isArray(value) && value.length === 0) return false;
+			return true;
+		};
+		const argColumns = argList.map((arg) => {
+			const kebab = camelToKebab(arg.name);
+			const primaryName = kebab && arg.aliases?.includes(kebab) ? kebab : arg.name;
+			const remainingAliases = arg.aliases?.filter((a) => a !== primaryName);
+			const argName = `--${primaryName}`;
+			const shortNames = [arg.flags?.length ? arg.flags.map((f) => `-${f}`).join(", ") : "", remainingAliases?.length ? remainingAliases.map((a) => `--${a}`).join(", ") : ""].filter(Boolean).join(", ");
+			const fullArgName = shortNames ? `${argName}, ${shortNames}` : argName;
+			const isDeprecated = !!arg.deprecated;
+			const formattedArgName = isDeprecated ? styler.deprecated(fullArgName) : styler.arg(fullArgName);
+			const plainParts = [fullArgName];
+			const styledParts = [formattedArgName];
+			if (arg.type && arg.type !== "boolean") {
+				const typePart = arg.optional ? `[${arg.type}]` : `<${arg.type}>`;
+				plainParts.push(typePart);
+				styledParts.push(styler.type(typePart));
+			}
+			if (isDeprecated) {
+				const deprecatedPart = typeof arg.deprecated === "string" ? `(deprecated: ${arg.deprecated})` : "(deprecated)";
+				plainParts.push(deprecatedPart);
+				styledParts.push(styler.meta(deprecatedPart));
+			}
+			return {
+				plain: plainParts.join(" "),
+				styled: join(styledParts),
+				arg
+			};
+		});
+		const maxColumnWidth = Math.min(32, Math.max(...argColumns.map((c) => c.plain.length)));
+		for (const { plain, styled, arg } of argColumns) {
+			const padding = " ".repeat(Math.max(2, maxColumnWidth - plain.length + 2));
+			const descParts = [];
+			if (arg.description) descParts.push(styler.description(arg.description));
+			if (info.usage.stdinField === arg.name) descParts.push(styler.meta("(stdin)"));
+			if (arg.enum) descParts.push(styler.meta(`(choices: ${arg.enum.join(", ")})`));
+			if (hasDefault(arg.default)) descParts.push(styler.meta(`(default: ${String(arg.default)})`));
+			lines.push(indent(1) + styled + padding + join(descParts));
+			if (arg.env) {
+				const envVars = typeof arg.env === "string" ? [arg.env] : arg.env;
+				const envParts = [styler.example("Env:"), styler.exampleValue(envVars.join(", "))];
+				lines.push(indent(3) + join(envParts));
+			}
+			if (arg.configKey) {
+				const configParts = [styler.example("Config:"), styler.exampleValue(arg.configKey)];
+				lines.push(indent(3) + join(configParts));
+			}
+			if (arg.examples && arg.examples.length > 0) {
+				const exampleValues = arg.examples.map((example) => typeof example === "string" ? example : JSON.stringify(example)).join(", ");
+				const exampleParts = [styler.example("Example:"), styler.exampleValue(exampleValues)];
+				lines.push(indent(3) + join(exampleParts));
+			}
+		}
+		return lines;
+	}
+	function formatBuiltinsSection(info) {
+		const lines = [];
+		const builtins = info.builtins;
+		lines.push(styler.label("Built-in:"));
+		const allLengths = [];
+		for (const entry of builtins) {
+			allLengths.push(entry.name.length);
+			if (entry.sub) for (const sub of entry.sub) allLengths.push(sub.name.length + 2);
+		}
+		const maxLen = Math.max(...allLengths);
+		for (const entry of builtins) {
+			const padding = " ".repeat(Math.max(2, maxLen - entry.name.length + 2));
+			const parts = [styler.command(entry.name)];
+			if (entry.description) parts.push(padding + styler.description(entry.description));
+			lines.push(indent(1) + parts.join(""));
+			if (entry.sub) for (const sub of entry.sub) {
+				const subPadding = " ".repeat(Math.max(2, maxLen - sub.name.length));
+				const subParts = [styler.arg(sub.name)];
+				if (sub.description) subParts.push(subPadding + styler.description(sub.description));
+				lines.push(indent(2) + subParts.join(""));
+			}
+		}
+		return lines;
+	}
+	return { format(info) {
+		const lines = [];
+		if (info.deprecated) {
+			const deprecationMessage = typeof info.deprecated === "string" ? `⚠️  This command is deprecated: ${info.deprecated}` : "⚠️  This command is deprecated";
+			lines.push(styler.deprecated(deprecationMessage));
+			lines.push("");
+		}
+		lines.push(...formatUsageSection(info));
+		lines.push("");
+		if (info.title) {
+			lines.push(styler.label(info.title));
+			lines.push("");
+		}
+		if (info.aliases && info.aliases.length > 0) {
+			lines.push(styler.meta(`Aliases: ${info.aliases.join(", ")}`));
+			lines.push("");
+		}
+		if (info.description) {
+			lines.push(styler.description(info.description));
+			lines.push("");
+		}
+		if (info.subcommands && info.subcommands.length > 0) {
+			lines.push(...formatSubcommandsSection(info));
+			lines.push("");
+		}
+		if (info.positionals && info.positionals.length > 0) {
+			lines.push(...formatPositionalsSection(info));
+			lines.push("");
+		}
+		if (info.arguments && info.arguments.length > 0) {
+			lines.push(...formatArgumentsSection(info));
+			lines.push("");
+		}
+		if (info.builtins && info.builtins.length > 0) {
+			lines.push(...formatBuiltinsSection(info));
+			lines.push("");
+		}
+		if (info.arguments?.some((arg) => arg.negatable && arg.default === true)) {
+			lines.push(styler.meta("Boolean options can be negated with --no-<option>."));
+			lines.push("");
+		}
+		if (info.nestedCommands?.length) {
+			lines.push(styler.label("Subcommand Details:"));
+			lines.push("");
+			for (const nestedCmd of info.nestedCommands) {
+				lines.push(styler.meta("─".repeat(60)));
+				lines.push(this.format(nestedCmd));
+			}
+		}
+		const result = lines.join(newline);
+		return wrapDocument ? wrapDocument(result) : result;
+	} };
+}
+function createJsonFormatter() {
+	return { format(info) {
+		return JSON.stringify(info, null, 2);
+	} };
+}
+function shouldUseAnsi() {
+	if (typeof process === "undefined") return false;
+	if (process.env.NO_COLOR) return false;
+	if (process.env.CI) return false;
+	if (process.stdout && typeof process.stdout.isTTY === "boolean") return process.stdout.isTTY;
+	return false;
+}
+/**
+* Creates a minimal formatter that outputs just a single-line usage string.
+*/
+function createMinimalFormatter() {
+	return { format(info) {
+		const parts = [info.usage.command];
+		if (info.usage.hasSubcommands) parts.push("[command]");
+		if (info.positionals && info.positionals.length > 0) for (const arg of info.positionals) {
+			const name = arg.name.startsWith("...") ? `${arg.name}` : arg.name;
+			parts.push(arg.optional ? `[${name}]` : `<${name}>`);
+		}
+		if (info.usage.hasArguments) parts.push("[options]");
+		return parts.join(" ");
+	} };
+}
+function createFormatter(format, detail = "standard") {
+	if (detail === "minimal") return createMinimalFormatter();
+	if (format === "json") return createJsonFormatter();
+	if (format === "ansi" || format === "auto" && shouldUseAnsi()) return createGenericFormatter(createAnsiStyler(), createTextLayout());
+	if (format === "console") return createGenericFormatter(createConsoleStyler(), createTextLayout());
+	if (format === "markdown") return createGenericFormatter(createMarkdownStyler(), createMarkdownLayout());
+	if (format === "html") return createGenericFormatter(createHtmlStyler(), createHtmlLayout());
+	return createGenericFormatter(createTextStyler(), createTextLayout());
+}
+//#endregion
+//#region src/help.ts
+/**
+* Extract positional arguments info from schema based on meta.positional config.
+*/
+function extractPositionalArgsInfo(schema, meta) {
+	const args = [];
+	const positionalNames = /* @__PURE__ */ new Set();
+	if (!schema || !meta?.positional || meta.positional.length === 0) return {
+		args,
+		positionalNames
+	};
+	const positionalConfig = parsePositionalConfig(meta.positional);
+	try {
+		const jsonSchema = schema["~standard"].jsonSchema.input({ target: "draft-2020-12" });
+		if (jsonSchema.type === "object" && jsonSchema.properties) {
+			const properties = jsonSchema.properties;
+			const required = jsonSchema.required || [];
+			for (const { name, variadic } of positionalConfig) {
+				const prop = properties[name];
+				if (!prop) continue;
+				positionalNames.add(name);
+				const optMeta = meta.fields?.[name];
+				args.push({
+					name: variadic ? `...${name}` : name,
+					description: optMeta?.description ?? prop.description,
+					optional: !required.includes(name),
+					default: prop.default,
+					type: variadic ? `array<${prop.items?.type || "string"}>` : prop.type
+				});
+			}
+		}
+	} catch {}
+	return {
+		args,
+		positionalNames
+	};
+}
+function extractArgsInfo(schema, meta, positionalNames) {
+	const result = [];
+	if (!schema) return result;
+	if (!schema["~standard"].vendor.includes("zod")) return result;
+	const argsMeta = meta?.fields;
+	try {
+		const jsonSchema = schema["~standard"].jsonSchema.input({ target: "draft-2020-12" });
+		if (jsonSchema.type === "object" && jsonSchema.properties) {
+			const properties = jsonSchema.properties;
+			const required = jsonSchema.required || [];
+			const propertyNames = new Set(Object.keys(properties));
+			const hasExplicitNegation = (key) => {
+				const camelNegated = `no${key.charAt(0).toUpperCase()}${key.slice(1)}`;
+				if (propertyNames.has(camelNegated)) return true;
+				const kebabNegated = `no-${key}`;
+				if (propertyNames.has(kebabNegated)) return true;
+				return false;
+			};
+			const isNegationOf = (key) => {
+				if (key.startsWith("no") && key.length > 2 && key[2] === key[2]?.toUpperCase()) {
+					const positiveKey = key.charAt(2).toLowerCase() + key.slice(3);
+					if (propertyNames.has(positiveKey)) return true;
+				}
+				if (key.startsWith("no-")) {
+					const positiveKey = key.slice(3);
+					if (propertyNames.has(positiveKey)) return true;
+				}
+				return false;
+			};
+			for (const [key, prop] of Object.entries(properties)) {
+				if (positionalNames?.has(key)) continue;
+				const isOptional = !required.includes(key);
+				const enumValues = prop.enum ?? prop.items?.enum;
+				const optMeta = argsMeta?.[key];
+				const propType = prop.type;
+				const isNegatable = propType === "boolean" && !hasExplicitNegation(key) && !isNegationOf(key);
+				result.push({
+					name: key,
+					description: optMeta?.description ?? prop.description,
+					optional: isOptional,
+					default: prop.default,
+					type: propType === "array" ? `${prop.items?.type || "string"}[]` : propType,
+					enum: enumValues,
+					deprecated: optMeta?.deprecated ?? prop?.deprecated,
+					hidden: optMeta?.hidden ?? prop?.hidden,
+					examples: optMeta?.examples ?? prop?.examples,
+					variadic: propType === "array",
+					negatable: isNegatable
+				});
+			}
+		}
+	} catch {}
+	return result;
+}
+/**
+* Builds a comprehensive HelpInfo structure from a command.
+* This is the single source of truth that all formatters use.
+* @param cmd - The command to build help info for
+* @param detail - The level of detail ('minimal', 'standard', or 'full')
+*/
+function getHelpInfo(cmd, detail = "standard") {
+	const rootCmd = getRootCommand(cmd);
+	const isDefaultCommand = cmd.parent && (!cmd.name || cmd.aliases?.includes(""));
+	const nonEmptyAliases = cmd.aliases?.filter(Boolean);
+	const commandName = cmd.path || cmd.name || nonEmptyAliases?.[0] || (cmd.parent ? "[default]" : "program");
+	const remainingAliases = !cmd.name && nonEmptyAliases?.length ? nonEmptyAliases.slice(1) : nonEmptyAliases ?? [];
+	const displayAliases = isDefaultCommand ? [...remainingAliases, "[default]"] : nonEmptyAliases;
+	const { args: positionalArgs, positionalNames } = cmd.argsSchema ? extractPositionalArgsInfo(cmd.argsSchema, cmd.meta) : {
+		args: [],
+		positionalNames: /* @__PURE__ */ new Set()
+	};
+	const hasPositionals = positionalArgs.length > 0;
+	const helpInfo = {
+		name: commandName,
+		title: cmd.title,
+		description: cmd.description,
+		aliases: displayAliases,
+		deprecated: cmd.deprecated,
+		hidden: cmd.hidden,
+		usage: {
+			command: rootCmd === cmd ? commandName : `${rootCmd.name} ${commandName}`,
+			hasSubcommands: !!(cmd.commands && cmd.commands.length > 0),
+			hasPositionals,
+			hasArguments: false,
+			stdinField: cmd.meta?.stdin ? parseStdinConfig(cmd.meta.stdin).field : void 0
+		}
+	};
+	if (cmd.commands && cmd.commands.length > 0) {
+		const visibleCommands = detail === "full" ? cmd.commands : cmd.commands.filter((c) => !c.hidden);
+		helpInfo.subcommands = [...cmd.action ? [{
+			name: "[default]",
+			title: cmd.title,
+			description: cmd.description
+		}] : [], ...visibleCommands.flatMap((c) => {
+			const isDefault = !c.name || c.aliases?.includes("");
+			const nonEmptyAliases = c.aliases?.filter(Boolean);
+			const displayName = c.name || nonEmptyAliases?.[0] || "[default]";
+			const remainingAliases = !c.name && nonEmptyAliases?.length ? nonEmptyAliases.slice(1) : nonEmptyAliases ?? [];
+			const displayAliases = isDefault && displayName !== "[default]" ? [...remainingAliases, "[default]"] : isDefault ? remainingAliases : nonEmptyAliases;
+			const hasSubcommands = !!(c.commands && c.commands.length > 0);
+			const hasDefaultHandler = c.action || c.commands?.some((sub) => !sub.name || sub.aliases?.includes(""));
+			if (hasSubcommands && hasDefaultHandler) {
+				const defaultSub = !c.action ? c.commands?.find((sub) => !sub.name || sub.aliases?.includes("")) : void 0;
+				const hasDefaultSubInfo = defaultSub && (defaultSub.title || defaultSub.description);
+				return [{
+					name: displayName,
+					title: hasDefaultSubInfo ? defaultSub.title : c.title,
+					description: hasDefaultSubInfo ? defaultSub.description : c.description,
+					aliases: displayAliases?.length ? displayAliases : void 0,
+					deprecated: c.deprecated,
+					hidden: c.hidden
+				}, {
+					name: displayName,
+					title: c.title,
+					description: c.description,
+					deprecated: c.deprecated,
+					hidden: c.hidden,
+					hasSubcommands: true
+				}];
+			}
+			return [{
+				name: displayName,
+				title: c.title,
+				description: c.description,
+				aliases: displayAliases?.length ? displayAliases : void 0,
+				deprecated: c.deprecated,
+				hidden: c.hidden,
+				hasSubcommands
+			}];
+		})];
+		if (detail === "full") helpInfo.nestedCommands = visibleCommands.map((c) => getHelpInfo(c, "full"));
+	}
+	if (hasPositionals) helpInfo.positionals = positionalArgs;
+	if (cmd.argsSchema) {
+		const argsInfo = extractArgsInfo(cmd.argsSchema, cmd.meta, positionalNames);
+		const argMap = Object.fromEntries(argsInfo.map((arg) => [arg.name, arg]));
+		const { flags, aliases } = extractSchemaMetadata(cmd.argsSchema, cmd.meta?.fields, cmd.meta?.autoAlias);
+		for (const [flag, name] of Object.entries(flags)) {
+			const arg = argMap[name];
+			if (!arg) continue;
+			arg.flags = [...arg.flags || [], flag];
+		}
+		for (const [alias, name] of Object.entries(aliases)) {
+			const arg = argMap[name];
+			if (!arg) continue;
+			arg.aliases = [...arg.aliases || [], alias];
+		}
+		const visibleArgs = argsInfo.filter((arg) => !arg.hidden);
+		if (visibleArgs.length > 0) {
+			helpInfo.arguments = visibleArgs;
+			helpInfo.usage.hasArguments = true;
+		}
+	}
+	if (!cmd.parent) {
+		const builtins = [];
+		if (!findCommandByName("help", cmd.commands)) builtins.push({
+			name: "help [command], -h, --help",
+			description: "Show help for a command",
+			sub: [{
+				name: "--detail <level>",
+				description: "Detail level (minimal, standard, full)"
+			}, {
+				name: "--format <format>",
+				description: "Output format (text, ansi, json, markdown, html)"
+			}]
+		});
+		if (!findCommandByName("version", cmd.commands)) builtins.push({
+			name: "version, -v, --version",
+			description: "Show version information"
+		});
+		if (!findCommandByName("completion", cmd.commands)) builtins.push({
+			name: "completion [shell]",
+			description: "Generate shell completions (bash, zsh, fish, powershell)"
+		});
+		builtins.push({
+			name: "[command] --repl",
+			description: "Start interactive REPL scoped to a command"
+		});
+		if (builtins.length > 0) helpInfo.builtins = builtins;
+	}
+	return helpInfo;
+}
+function generateHelp(rootCommand, commandObj = rootCommand, prefs) {
+	const helpInfo = getHelpInfo(commandObj, prefs?.detail);
+	return createFormatter(prefs?.format ?? "auto", prefs?.detail).format(helpInfo);
+}
+//#endregion
+export { getVersion as S, warnIfUnexpectedAsync as _, commandSymbol as a, createTerminalReplSession as b, hasInteractiveConfig as c, noop as d, outputValue as f, thenMaybe as g, suggestSimilar as h, buildReplCompleter as i, isAsyncBranded as l, runPluginChain as m, getHelpInfo as n, findCommandByName as o, repathCommandTree as p, asyncSchema as r, getCommandRuntime as s, generateHelp as t, mergeCommands as u, wrapWithLifecycle as v, resolveStdin as x, REPL_SIGINT as y };
+
+//# sourceMappingURL=help-CgGP7hQU.mjs.map