padrone 1.4.0 → 1.6.0

package/dist/help-B5Kk83of.mjs

@@ -0,0 +1,849 @@
+import { o as findCommandByName } from "./commands-B_gufyR9.mjs";
+import { a as getJsonSchema, c as parsePositionalConfig, i as extractSchemaMetadata, u as camelToKebab } from "./args-Cnq0nwSM.mjs";
+//#region src/util/utils.ts
+function getRootCommand(cmd) {
+	let current = cmd;
+	while (current.parent) current = current.parent;
+	return current;
+}
+async function readVersionFromPackageJson() {
+	try {
+		const fs = await import("node:fs");
+		const path = await import("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";
+}
+/**
+* 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
+*
+* Returns synchronously when an explicit version or env var is available.
+* Falls back to async package.json discovery otherwise.
+*/
+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") return readVersionFromPackageJson();
+	return "0.0.0";
+}
+//#endregion
+//#region src/output/colorizer.ts
+const ansiCodes = {
+	reset: "\x1B[0m",
+	bold: "\x1B[1m",
+	dim: "\x1B[2m",
+	italic: "\x1B[3m",
+	underline: "\x1B[4m",
+	strikethrough: "\x1B[9m",
+	red: "\x1B[31m",
+	green: "\x1B[32m",
+	yellow: "\x1B[33m",
+	blue: "\x1B[34m",
+	magenta: "\x1B[35m",
+	cyan: "\x1B[36m",
+	white: "\x1B[37m",
+	gray: "\x1B[90m"
+};
+const defaultTheme = {
+	command: ["cyan", "bold"],
+	arg: ["green"],
+	type: ["yellow"],
+	description: ["dim"],
+	label: ["bold"],
+	meta: ["gray"],
+	example: ["underline"],
+	exampleValue: ["italic"],
+	deprecated: ["strikethrough", "gray"]
+};
+const colorThemes = {
+	default: defaultTheme,
+	ocean: {
+		command: ["blue", "bold"],
+		arg: ["cyan"],
+		type: ["green"],
+		description: ["dim"],
+		label: ["bold"],
+		meta: ["gray"],
+		example: ["underline", "cyan"],
+		exampleValue: ["italic"],
+		deprecated: ["strikethrough", "gray"]
+	},
+	warm: {
+		command: ["yellow", "bold"],
+		arg: ["red"],
+		type: ["magenta"],
+		description: ["dim"],
+		label: ["bold"],
+		meta: ["gray"],
+		example: ["underline", "yellow"],
+		exampleValue: ["italic"],
+		deprecated: ["strikethrough", "gray"]
+	},
+	monochrome: {
+		command: ["bold"],
+		arg: ["underline"],
+		type: ["dim"],
+		description: ["dim"],
+		label: ["bold"],
+		meta: ["dim"],
+		example: ["underline"],
+		exampleValue: ["italic"],
+		deprecated: ["strikethrough", "dim"]
+	}
+};
+function makeStyleFn(styles) {
+	const prefix = styles.map((s) => ansiCodes[s]).join("");
+	return (text) => `${prefix}${text}${ansiCodes.reset}`;
+}
+function resolveConfig(config) {
+	if (!config) return defaultTheme;
+	if (typeof config === "string") return colorThemes[config] ?? defaultTheme;
+	return {
+		...defaultTheme,
+		...config
+	};
+}
+function createColorizer(config) {
+	const resolved = resolveConfig(config);
+	return {
+		command: makeStyleFn(resolved.command),
+		arg: makeStyleFn(resolved.arg),
+		type: makeStyleFn(resolved.type),
+		description: makeStyleFn(resolved.description),
+		label: makeStyleFn(resolved.label),
+		meta: makeStyleFn(resolved.meta),
+		example: makeStyleFn(resolved.example),
+		exampleValue: makeStyleFn(resolved.exampleValue),
+		deprecated: makeStyleFn(resolved.deprecated)
+	};
+}
+//#endregion
+//#region src/output/formatter.ts
+const DEFAULT_TERMINAL_WIDTH = 80;
+function wrapText(text, maxWidth) {
+	if (maxWidth <= 0 || text.length <= maxWidth) return [text];
+	const words = text.split(" ");
+	const lines = [];
+	let current = "";
+	for (const word of words) if (current && current.length + 1 + word.length > maxWidth) {
+		lines.push(current);
+		current = word;
+	} else current = current ? `${current} ${word}` : word;
+	if (current) lines.push(current);
+	return lines.length > 0 ? lines : [text];
+}
+function createTextStyler() {
+	return {
+		command: (text) => text,
+		arg: (text) => text,
+		type: (text) => text,
+		description: (text) => text,
+		label: (text) => text,
+		section: (text) => text,
+		meta: (text) => text,
+		example: (text) => text,
+		exampleValue: (text) => text,
+		deprecated: (text) => text
+	};
+}
+function createAnsiStyler(theme) {
+	const colorizer = createColorizer(theme);
+	return {
+		command: colorizer.command,
+		arg: colorizer.arg,
+		type: colorizer.type,
+		description: colorizer.description,
+		label: colorizer.label,
+		section: colorizer.label,
+		meta: colorizer.meta,
+		example: colorizer.example,
+		exampleValue: colorizer.exampleValue,
+		deprecated: colorizer.deprecated
+	};
+}
+function createConsoleStyler(theme) {
+	return createAnsiStyler(theme);
+}
+function createMarkdownStyler() {
+	return {
+		command: (text) => `**${text}**`,
+		arg: (text) => `\`${text}\``,
+		type: (text) => `\`${text}\``,
+		description: (text) => text,
+		label: (text) => `**${text}**`,
+		section: (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) => `<strong>${escapeHtml(text)}</strong>`,
+		section: (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(" ")
+	};
+}
+function createMarkdownLayout() {
+	return {
+		newline: "\n\n",
+		indent: (level) => {
+			if (level === 0) return "";
+			if (level === 1) return "  ";
+			return "    ";
+		},
+		join: (parts) => parts.filter(Boolean).join(" ")
+	};
+}
+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>`
+	};
+}
+/**
+* Creates a formatter that uses the given styler and layout configuration.
+*/
+function createGenericFormatter(styler, layout, showAllBuiltins, terminalWidth) {
+	const { newline, indent, join, wrapDocument } = 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 [`${styler.label("Usage:")} ${join(usageParts)}`];
+	}
+	function formatSubcommandsSection(info) {
+		const lines = [];
+		const subcommands = info.subcommands;
+		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;
+		}));
+		const grouped = Object.groupBy(subcommands, (c) => c.group ?? "");
+		const renderSubcommands = (cmds) => {
+			for (const subCmd of cmds) {
+				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(""));
+			}
+		};
+		for (const [key, items] of Object.entries(grouped)) {
+			if (lines.length > 0) lines.push("");
+			lines.push(styler.section(key ? `${key}:` : "Commands:"));
+			renderSubcommands(items);
+		}
+		if (!info.builtins?.length) {
+			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.section("Arguments:"));
+		const maxNameLength = Math.min(32, Math.max(...args.map((a) => a.name.length)));
+		const descCol = 2 + maxNameLength + 2;
+		const posAvailWidth = terminalWidth ? terminalWidth - descCol : void 0;
+		const descColPad = " ".repeat(descCol);
+		for (const arg of args) {
+			const padding = " ".repeat(Math.max(2, maxNameLength - arg.name.length + 2));
+			const prefix = indent(1) + styler.arg(arg.name) + padding;
+			const descPlain = arg.description ?? "";
+			const styledDesc = descPlain ? styler.description(descPlain) : "";
+			const metaParts = [];
+			const styledMetaParts = [];
+			if (info.usage.stdinField === arg.name) {
+				metaParts.push("(stdin)");
+				styledMetaParts.push(styler.meta("(stdin)"));
+			}
+			if (arg.enum) {
+				const text = `(choices: ${arg.enum.join(", ")})`;
+				metaParts.push(text);
+				styledMetaParts.push(styler.meta(text));
+			}
+			if (arg.default !== void 0) {
+				const text = `(default: ${String(arg.default)})`;
+				metaParts.push(text);
+				styledMetaParts.push(styler.meta(text));
+			}
+			const metaStyled = join(styledMetaParts);
+			if (posAvailWidth && posAvailWidth > 0) if ([descPlain, metaParts.join(" ")].filter(Boolean).join(" ").length <= posAvailWidth) lines.push(prefix + [styledDesc, metaStyled].filter(Boolean).join(" "));
+			else if (!descPlain || descPlain.length <= posAvailWidth) {
+				lines.push(prefix + styledDesc);
+				if (metaStyled) lines.push(descColPad + metaStyled);
+			} else {
+				const wrapped = wrapText(descPlain, posAvailWidth);
+				lines.push(prefix + styler.description(wrapped[0]));
+				for (const wline of wrapped.slice(1)) lines.push(descColPad + styler.description(wline));
+				if (metaStyled) lines.push(descColPad + metaStyled);
+			}
+			else lines.push(prefix + join([styledDesc, metaStyled]));
+		}
+		return lines;
+	}
+	function formatArgumentsSection(info) {
+		const lines = [];
+		const argList = info.arguments || [];
+		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);
+			return {
+				flagsPlain: arg.flags?.length ? arg.flags.map((f) => `-${f}`).join(", ") : "",
+				namesPlain: [`--${primaryName}`, ...remainingAliases?.map((a) => `--${a}`) || []].join(", "),
+				typePlain: arg.type && arg.type !== "boolean" ? arg.optional ? `[${arg.type}]` : `<${arg.type}>` : "",
+				isDeprecated: !!arg.deprecated,
+				arg
+			};
+		});
+		const maxFlagsWidth = Math.min(12, Math.max(0, ...argColumns.map((c) => c.flagsPlain.length)));
+		const maxNamesWidth = Math.min(32, Math.max(0, ...argColumns.map((c) => c.namesPlain.length)));
+		const maxTypeWidth = Math.min(16, Math.max(0, ...argColumns.map((c) => c.typePlain.length)));
+		const hasAnyFlags = maxFlagsWidth > 0;
+		const descCol = 2 + (hasAnyFlags ? maxFlagsWidth + 2 : 0) + maxNamesWidth + 2 + (maxTypeWidth > 0 ? maxTypeWidth + 2 : 0);
+		const argAvailWidth = terminalWidth ? terminalWidth - descCol : void 0;
+		const descColPad = " ".repeat(descCol);
+		const grouped = Object.groupBy(argColumns, (c) => c.arg.group ?? "");
+		const renderArgColumns = (columns) => {
+			for (const { flagsPlain, namesPlain, typePlain, isDeprecated, arg } of columns) {
+				const parts = [];
+				if (hasAnyFlags) {
+					const styledFlags = isDeprecated ? flagsPlain ? styler.deprecated(flagsPlain) : "" : flagsPlain ? styler.arg(flagsPlain) : "";
+					const flagsPadding = " ".repeat(Math.max(0, maxFlagsWidth - flagsPlain.length));
+					const separator = flagsPlain ? ", " : "  ";
+					parts.push(styledFlags + flagsPadding + separator);
+				}
+				const styledNames = isDeprecated ? styler.deprecated(namesPlain) : styler.arg(namesPlain);
+				const namesPadding = " ".repeat(Math.max(2, maxNamesWidth - namesPlain.length + 2));
+				parts.push(styledNames + namesPadding);
+				if (maxTypeWidth > 0) {
+					const styledType = typePlain ? styler.type(typePlain) : "";
+					const typePadding = " ".repeat(Math.max(2, maxTypeWidth - typePlain.length + 2));
+					parts.push(styledType + typePadding);
+				}
+				const prefix = indent(1) + parts.join("");
+				const contPad = argAvailWidth ? descColPad : indent(3);
+				const inlineMeta = [];
+				const styledInlineMeta = [];
+				if (isDeprecated && typeof arg.deprecated !== "string") {
+					inlineMeta.push("(deprecated)");
+					styledInlineMeta.push(styler.meta("(deprecated)"));
+				}
+				if (hasDefault(arg.default)) {
+					const text = `(default: ${String(arg.default)})`;
+					inlineMeta.push(text);
+					styledInlineMeta.push(styler.meta(text));
+				}
+				if (arg.enum) {
+					const text = `(choices: ${arg.enum.join(", ")})`;
+					inlineMeta.push(text);
+					styledInlineMeta.push(styler.meta(text));
+				}
+				const descPlain = arg.description ?? "";
+				const styledDesc = descPlain ? isDeprecated ? styler.deprecated(descPlain) : styler.description(descPlain) : "";
+				const metaStyled = join(styledInlineMeta);
+				if (argAvailWidth && argAvailWidth > 0) if ([descPlain, inlineMeta.join(" ")].filter(Boolean).join(" ").length <= argAvailWidth) lines.push(prefix + [styledDesc, metaStyled].filter(Boolean).join(" "));
+				else if (!descPlain || descPlain.length <= argAvailWidth) {
+					lines.push(prefix + styledDesc);
+					if (metaStyled) lines.push(descColPad + metaStyled);
+				} else {
+					const wrapped = wrapText(descPlain, argAvailWidth);
+					const styleFn = isDeprecated ? styler.deprecated : styler.description;
+					lines.push(prefix + styleFn(wrapped[0]));
+					for (const wline of wrapped.slice(1)) lines.push(descColPad + styleFn(wline));
+					if (metaStyled) lines.push(descColPad + metaStyled);
+				}
+				else {
+					const descParts = [];
+					if (styledDesc) descParts.push(styledDesc);
+					lines.push(prefix + join(descParts));
+					if (styledInlineMeta.length > 0) lines.push(indent(3) + metaStyled);
+				}
+				const line3Parts = [];
+				if (isDeprecated && typeof arg.deprecated === "string") line3Parts.push(styler.meta(`(deprecated: ${arg.deprecated})`));
+				if (arg.examples && arg.examples.length > 0) {
+					const exampleValues = arg.examples.map((example) => typeof example === "string" ? example : JSON.stringify(example)).join(", ");
+					line3Parts.push(styler.example("Example:"), styler.exampleValue(exampleValues));
+				}
+				if (line3Parts.length > 0) lines.push(contPad + join(line3Parts));
+				const line4Parts = [];
+				if (info.usage.stdinField === arg.name) line4Parts.push(styler.meta("(stdin)"));
+				if (arg.env) {
+					const envVars = typeof arg.env === "string" ? [arg.env] : arg.env;
+					line4Parts.push(styler.example("Env:"), styler.exampleValue(envVars.join(", ")));
+				}
+				if (arg.configKey) line4Parts.push(styler.example("Config:"), styler.exampleValue(arg.configKey));
+				if (line4Parts.length > 0) lines.push(contPad + join(line4Parts));
+			}
+		};
+		for (const [key, items] of Object.entries(grouped)) {
+			if (lines.length > 0) lines.push("");
+			lines.push(styler.section(key ? `${key}:` : "Options:"));
+			renderArgColumns(items);
+		}
+		return lines;
+	}
+	function formatBuiltinsSection(info) {
+		const lines = [];
+		const builtins = info.builtins;
+		if (!showAllBuiltins) {
+			lines.push(`${styler.label("Global:")} ${styler.meta([
+				"help [command]",
+				"version",
+				"[command] --repl"
+			].join(", "))}`);
+			const hint = info.usage.hasSubcommands ? `Run "${info.name} [command] --help" for more information. Use "--all" for all global commands.` : `Use "${info.name} help --all" for more information on global commands.`;
+			lines.push(styler.meta(hint));
+			return lines;
+		}
+		lines.push(styler.section("Global:"));
+		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.examples && info.examples.length > 0) {
+			lines.push(styler.section("Examples:"));
+			for (const ex of info.examples) lines.push(indent(1) + styler.meta("$ ") + styler.exampleValue(ex));
+			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.section("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(env, isTTY) {
+	if (env?.NO_COLOR) return false;
+	if (env?.CI) return false;
+	if (typeof isTTY === "boolean") return 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", theme, all, width, terminal, env) {
+	if (detail === "minimal") return createMinimalFormatter();
+	if (format === "json") return createJsonFormatter();
+	const tw = format === "markdown" || format === "html" ? void 0 : width ?? terminal?.columns ?? DEFAULT_TERMINAL_WIDTH;
+	if (format === "ansi" || format === "auto" && shouldUseAnsi(env, terminal?.isTTY)) return createGenericFormatter(createAnsiStyler(theme), createTextLayout(), all, tw);
+	if (format === "console") return createGenericFormatter(createConsoleStyler(theme), createTextLayout(), all, tw);
+	if (format === "markdown") return createGenericFormatter(createMarkdownStyler(), createMarkdownLayout(), all);
+	if (format === "html") return createGenericFormatter(createHtmlStyler(), createHtmlLayout(), all);
+	return createGenericFormatter(createTextStyler(), createTextLayout(), all, tw);
+}
+//#endregion
+//#region src/output/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 = getJsonSchema(schema);
+		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,
+					enum: prop.enum ?? prop.items?.enum
+				});
+			}
+		}
+	} 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 = getJsonSchema(schema);
+		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,
+					group: optMeta?.group
+				});
+			}
+		}
+	} 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", all) {
+	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,
+		examples: cmd.examples,
+		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
+		}
+	};
+	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,
+					group: c.group
+				}, {
+					name: displayName,
+					title: c.title,
+					description: c.description,
+					deprecated: c.deprecated,
+					hidden: c.hidden,
+					hasSubcommands: true,
+					group: c.group
+				}];
+			}
+			return [{
+				name: displayName,
+				title: c.title,
+				description: c.description,
+				aliases: displayAliases?.length ? displayAliases : void 0,
+				deprecated: c.deprecated,
+				hidden: c.hidden,
+				hasSubcommands,
+				group: c.group
+			}];
+		})];
+		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 || all) {
+		const builtins = [];
+		if (!findCommandByName("help", rootCmd.commands)) builtins.push({
+			name: "help [command], -h, --help",
+			description: "Show help for a command",
+			sub: [
+				{
+					name: "--all",
+					description: "Show all global commands and flags"
+				},
+				{
+					name: "--detail <level>",
+					description: "Detail level (minimal, standard, full)"
+				},
+				{
+					name: "--format <format>",
+					description: "Output format (text, ansi, json, markdown, html)"
+				}
+			]
+		});
+		if (!findCommandByName("version", rootCmd.commands)) builtins.push({
+			name: "version, -v, --version",
+			description: "Show version information"
+		});
+		if (!findCommandByName("completion", rootCmd.commands)) builtins.push({
+			name: "completion [shell]",
+			description: "Generate shell completions (bash, zsh, fish, powershell)"
+		});
+		if (!findCommandByName("man", rootCmd.commands)) builtins.push({
+			name: "man",
+			description: "Show or install man pages (--setup to install, --remove to uninstall) (experimental)"
+		});
+		builtins.push({
+			name: "[command] --repl",
+			description: "Start interactive REPL scoped to a command"
+		});
+		if (!findCommandByName("mcp", rootCmd.commands)) builtins.push({
+			name: "mcp [http|stdio]",
+			description: "Start a Model Context Protocol server to expose commands as AI tools (experimental)",
+			sub: [{
+				name: "--port <port>",
+				description: "HTTP port (default: 3000)"
+			}, {
+				name: "--host <host>",
+				description: "HTTP host (default: 127.0.0.1)"
+			}]
+		});
+		builtins.push({
+			name: "--color [theme], --no-color",
+			description: "Set color theme (default, ocean, warm, monochrome) or disable colors"
+		});
+		if (builtins.length > 0) helpInfo.builtins = builtins;
+	}
+	return helpInfo;
+}
+function generateHelp(rootCommand, commandObj = rootCommand, prefs) {
+	const helpInfo = getHelpInfo(commandObj, prefs?.detail, prefs?.all);
+	return createFormatter(prefs?.format ?? "auto", prefs?.detail, prefs?.theme, prefs?.all, prefs?.width, prefs?.terminal, prefs?.env).format(helpInfo);
+}
+//#endregion
+export { getVersion as a, getRootCommand as i, getHelpInfo as n, colorThemes as r, generateHelp as t };
+
+//# sourceMappingURL=help-B5Kk83of.mjs.map