padrone 1.0.0-beta.2

package/index.mjs

@@ -0,0 +1,1246 @@
+import { createRequire } from "node:module";
+
+//#region rolldown:runtime
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+//#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}`,
+		option: (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,
+		option: (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,
+		option: colorizer.option,
+		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$1 = {
+		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$1.cyan}${colors$1.bold}${text}${colors$1.reset}`,
+		option: (text) => `${colors$1.green}${text}${colors$1.reset}`,
+		type: (text) => `${colors$1.yellow}${text}${colors$1.reset}`,
+		description: (text) => `${colors$1.dim}${text}${colors$1.reset}`,
+		label: (text) => `${colors$1.bold}${text}${colors$1.reset}`,
+		meta: (text) => `${colors$1.gray}${text}${colors$1.reset}`,
+		example: (text) => `${colors$1.underline}${text}${colors$1.reset}`,
+		exampleValue: (text) => `${colors$1.italic}${text}${colors$1.reset}`,
+		deprecated: (text) => `${colors$1.strikethrough}${colors$1.gray}${text}${colors$1.reset}`
+	};
+}
+function createMarkdownStyler() {
+	return {
+		command: (text) => `**${text}**`,
+		option: (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>`,
+		option: (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) {
+		return [`${usageLabel} ${join([
+			styler.command(info.usage.command),
+			info.usage.hasSubcommands ? styler.meta("[command]") : "",
+			info.usage.hasArguments ? styler.meta("[args...]") : "",
+			info.usage.hasOptions ? styler.meta("[options]") : ""
+		])}`];
+	}
+	function formatSubcommandsSection(info) {
+		const lines = [];
+		const subcommands = info.subcommands;
+		lines.push(styler.label("Commands:"));
+		const maxNameLength = Math.max(...subcommands.map((c) => c.name.length));
+		for (const subCmd of subcommands) {
+			const padding = " ".repeat(Math.max(0, maxNameLength - subCmd.name.length + 2));
+			const isDeprecated = !!subCmd.deprecated;
+			const lineParts = [isDeprecated ? styler.deprecated(subCmd.name) : styler.command(subCmd.name), 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 formatArgumentsSection(info) {
+		const lines = [];
+		const args = info.arguments;
+		lines.push(styler.label("Arguments:"));
+		for (const arg of args) {
+			const parts = [styler.option(arg.name)];
+			if (arg.optional) parts.push(styler.meta("(optional)"));
+			if (arg.default !== void 0) parts.push(styler.meta(`(default: ${String(arg.default)})`));
+			lines.push(indent(1) + join(parts));
+			if (arg.description) lines.push(indent(2) + styler.description(arg.description));
+		}
+		return lines;
+	}
+	function formatOptionsSection(info) {
+		const lines = [];
+		const options = info.options;
+		lines.push(styler.label("Options:"));
+		const maxNameLength = Math.max(...options.map((opt) => opt.name.length));
+		for (const opt of options) {
+			const optionName = opt.negatable ? `--[no-]${opt.name}` : `--${opt.name}`;
+			const aliasNames = opt.aliases && opt.aliases.length > 0 ? opt.aliases.map((a) => `-${a}`).join(", ") : "";
+			const fullOptionName = aliasNames ? `${optionName}, ${aliasNames}` : optionName;
+			const padding = " ".repeat(Math.max(0, maxNameLength - opt.name.length + 2));
+			const isDeprecated = !!opt.deprecated;
+			const parts = [isDeprecated ? styler.deprecated(fullOptionName) : styler.option(fullOptionName)];
+			if (opt.type) parts.push(styler.type(`<${opt.type}>`));
+			if (opt.optional && !opt.deprecated) parts.push(styler.meta("(optional)"));
+			if (opt.default !== void 0) parts.push(styler.meta(`(default: ${String(opt.default)})`));
+			if (opt.enum) parts.push(styler.meta(`(choices: ${opt.enum.join(", ")})`));
+			if (opt.variadic) parts.push(styler.meta("(repeatable)"));
+			if (isDeprecated) {
+				const deprecatedMeta = typeof opt.deprecated === "string" ? styler.meta(`(deprecated: ${opt.deprecated})`) : styler.meta("(deprecated)");
+				parts.push(deprecatedMeta);
+			}
+			const description = opt.description ? styler.description(opt.description) : "";
+			lines.push(indent(1) + join(parts) + padding + description);
+			if (opt.env) {
+				const envVars = typeof opt.env === "string" ? [opt.env] : opt.env;
+				const envParts = [styler.example("Env:"), styler.exampleValue(envVars.join(", "))];
+				lines.push(indent(3) + join(envParts));
+			}
+			if (opt.configKey) {
+				const configParts = [styler.example("Config:"), styler.exampleValue(opt.configKey)];
+				lines.push(indent(3) + join(configParts));
+			}
+			if (opt.examples && opt.examples.length > 0) {
+				const exampleValues = opt.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;
+	}
+	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.description) {
+			lines.push(styler.description(info.description));
+			lines.push("");
+		}
+		if (info.subcommands && info.subcommands.length > 0) {
+			lines.push(...formatSubcommandsSection(info));
+			lines.push("");
+		}
+		if (info.arguments && info.arguments.length > 0) {
+			lines.push(...formatArgumentsSection(info));
+			lines.push("");
+		}
+		if (info.options && info.options.length > 0) {
+			lines.push(...formatOptionsSection(info));
+			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.usage.hasArguments) parts.push("[args...]");
+		if (info.usage.hasOptions) 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/options.ts
+/**
+* Parse positional configuration to extract names and variadic info.
+*/
+function parsePositionalConfig(positional) {
+	return positional.map((p) => {
+		const isVariadic = p.startsWith("...");
+		return {
+			name: isVariadic ? p.slice(3) : p,
+			variadic: isVariadic
+		};
+	});
+}
+/**
+* Extract all option metadata from schema and meta in a single pass.
+* This consolidates aliases, env bindings, and config keys extraction.
+*/
+function extractSchemaMetadata(schema, meta) {
+	const aliases = {};
+	const envBindings = {};
+	const configKeys = {};
+	if (meta) for (const [key, value] of Object.entries(meta)) {
+		if (!value) continue;
+		if (value.alias) {
+			const list = typeof value.alias === "string" ? [value.alias] : value.alias;
+			for (const aliasKey of list) if (typeof aliasKey === "string" && aliasKey && aliasKey !== key) aliases[aliasKey] = key;
+		}
+		if (value.env) envBindings[key] = typeof value.env === "string" ? [value.env] : value.env;
+		if (value.configKey) configKeys[key] = value.configKey;
+	}
+	try {
+		const jsonSchema = schema["~standard"].jsonSchema.input({ target: "draft-2020-12" });
+		if (jsonSchema.type === "object" && jsonSchema.properties) for (const [propertyName, propertySchema] of Object.entries(jsonSchema.properties)) {
+			if (!propertySchema) continue;
+			const propAlias = propertySchema.alias;
+			if (propAlias) {
+				const list = typeof propAlias === "string" ? [propAlias] : propAlias;
+				if (Array.isArray(list)) {
+					for (const aliasKey of list) if (typeof aliasKey === "string" && aliasKey && aliasKey !== propertyName && !(aliasKey in aliases)) aliases[aliasKey] = propertyName;
+				}
+			}
+			if (propertySchema.env && !(propertyName in envBindings)) {
+				const envVars = typeof propertySchema.env === "string" ? [propertySchema.env] : propertySchema.env;
+				if (Array.isArray(envVars)) envBindings[propertyName] = envVars;
+			}
+			if (propertySchema.configKey && !(propertyName in configKeys)) configKeys[propertyName] = propertySchema.configKey;
+		}
+	} catch {}
+	return {
+		aliases,
+		envBindings,
+		configKeys
+	};
+}
+function preprocessAliases(data, aliases) {
+	const result = { ...data };
+	for (const [aliasKey, fullOptionName] of Object.entries(aliases)) if (aliasKey in data && aliasKey !== fullOptionName) {
+		const aliasValue = data[aliasKey];
+		if (!(fullOptionName in result)) result[fullOptionName] = aliasValue;
+		delete result[aliasKey];
+	}
+	return result;
+}
+/**
+* Apply environment variable values to options.
+* CLI values take precedence over environment variables.
+*/
+function applyEnvBindings(data, envBindings, env = typeof process !== "undefined" ? process.env : {}) {
+	const result = { ...data };
+	for (const [optionName, envVars] of Object.entries(envBindings)) {
+		if (optionName in result && result[optionName] !== void 0) continue;
+		for (const envVar of envVars) {
+			const envValue = env[envVar];
+			if (envValue !== void 0) {
+				result[optionName] = parseEnvValue(envValue);
+				break;
+			}
+		}
+	}
+	return result;
+}
+/**
+* Parse an environment variable value, attempting to convert to appropriate types.
+*/
+function parseEnvValue(value) {
+	const lowerValue = value.toLowerCase();
+	if (lowerValue === "true" || lowerValue === "1" || lowerValue === "yes") return true;
+	if (lowerValue === "false" || lowerValue === "0" || lowerValue === "no") return false;
+	if (/^-?\d+$/.test(value)) return Number.parseInt(value, 10);
+	if (/^-?\d+\.\d+$/.test(value)) return Number.parseFloat(value);
+	if (value.includes(",")) return value.split(",").map((v) => parseEnvValue(v.trim()));
+	return value;
+}
+/**
+* Get a nested value from an object using dot notation.
+*/
+function getNestedValue(obj, path) {
+	const parts = path.split(".");
+	let current = obj;
+	for (const part of parts) {
+		if (current === null || current === void 0) return void 0;
+		if (typeof current !== "object") return void 0;
+		current = current[part];
+	}
+	return current;
+}
+/**
+* Apply config file values to options.
+* CLI values and env values take precedence over config file values.
+*/
+function applyConfigValues(data, configKeys, configData) {
+	const result = { ...data };
+	for (const [optionName, configKey] of Object.entries(configKeys)) {
+		if (optionName in result && result[optionName] !== void 0) continue;
+		const configValue = getNestedValue(configData, configKey);
+		if (configValue !== void 0) result[optionName] = configValue;
+	}
+	return result;
+}
+/**
+* Combined preprocessing of options with all features.
+* Precedence order (highest to lowest): CLI args > env vars > config file
+*/
+function preprocessOptions(data, ctx) {
+	let result = { ...data };
+	if (ctx.aliases && Object.keys(ctx.aliases).length > 0) result = preprocessAliases(result, ctx.aliases);
+	if (ctx.envBindings && Object.keys(ctx.envBindings).length > 0) result = applyEnvBindings(result, ctx.envBindings, ctx.env);
+	if (ctx.configKeys && ctx.configData) result = applyConfigValues(result, ctx.configKeys, ctx.configData);
+	return result;
+}
+
+//#endregion
+//#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") return JSON.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/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.options?.[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 extractOptionsInfo(schema, meta, positionalNames) {
+	const result = [];
+	if (!schema) return result;
+	if (!schema["~standard"].vendor.includes("zod")) return result;
+	const optionsMeta = meta?.options;
+	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;
+				const optMeta = optionsMeta?.[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,
+					enum: enumValues,
+					deprecated: optMeta?.deprecated ?? prop?.deprecated,
+					hidden: optMeta?.hidden ?? prop?.hidden,
+					examples: optMeta?.examples ?? prop?.examples,
+					env: optMeta?.env ?? prop?.env,
+					variadic: propType === "array",
+					negatable: isNegatable,
+					configKey: optMeta?.configKey ?? prop?.configKey
+				});
+			}
+		}
+	} 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 commandName = cmd.path || cmd.name || "program";
+	const { args: positionalArgs, positionalNames } = cmd.options ? extractPositionalArgsInfo(cmd.options, cmd.meta) : {
+		args: [],
+		positionalNames: /* @__PURE__ */ new Set()
+	};
+	const hasArguments = positionalArgs.length > 0;
+	const helpInfo = {
+		name: commandName,
+		title: cmd.title,
+		description: cmd.description,
+		deprecated: cmd.deprecated,
+		hidden: cmd.hidden,
+		usage: {
+			command: rootCmd === cmd ? commandName : `${rootCmd.name} ${commandName}`,
+			hasSubcommands: !!(cmd.commands && cmd.commands.length > 0),
+			hasArguments,
+			hasOptions: !!cmd.options
+		}
+	};
+	if (cmd.commands && cmd.commands.length > 0) {
+		const visibleCommands = detail === "full" ? cmd.commands : cmd.commands.filter((c) => !c.hidden);
+		helpInfo.subcommands = visibleCommands.map((c) => ({
+			name: c.name,
+			title: c.title,
+			description: c.description,
+			deprecated: c.deprecated,
+			hidden: c.hidden
+		}));
+		if (detail === "full") helpInfo.nestedCommands = visibleCommands.map((c) => getHelpInfo(c, "full"));
+	}
+	if (hasArguments) helpInfo.arguments = positionalArgs;
+	if (cmd.options) {
+		const optionsInfo = extractOptionsInfo(cmd.options, cmd.meta, positionalNames);
+		const optMap = Object.fromEntries(optionsInfo.map((opt) => [opt.name, opt]));
+		const { aliases } = extractSchemaMetadata(cmd.options, cmd.meta?.options);
+		for (const [alias, name] of Object.entries(aliases)) {
+			const opt = optMap[name];
+			if (!opt) continue;
+			opt.aliases = [...opt.aliases || [], alias];
+		}
+		const visibleOptions = optionsInfo.filter((opt) => !opt.hidden);
+		if (visibleOptions.length > 0) helpInfo.options = visibleOptions;
+	}
+	return helpInfo;
+}
+function generateHelp(rootCommand, commandObj = rootCommand, options) {
+	const helpInfo = getHelpInfo(commandObj, options?.detail);
+	return createFormatter(options?.format ?? "auto", options?.detail).format(helpInfo);
+}
+
+//#endregion
+//#region src/parse.ts
+/**
+* Tokenizes input string respecting quoted strings and bracket arrays.
+* Supports single quotes, double quotes, backticks, and square brackets.
+*/
+function tokenizeInput(input) {
+	const tokens = [];
+	let current = "";
+	let inQuote = null;
+	let bracketDepth = 0;
+	let i = 0;
+	while (i < input.length) {
+		const char = input[i];
+		if (inQuote) {
+			if (char === "\\" && i + 1 < input.length) {
+				const nextChar = input[i + 1];
+				if (nextChar === inQuote || nextChar === "\\") {
+					current += nextChar;
+					i += 2;
+					continue;
+				}
+			}
+			if (char === inQuote) inQuote = null;
+			else current += char;
+		} else if (char === "[") {
+			bracketDepth++;
+			current += char;
+		} else if (char === "]") {
+			bracketDepth = Math.max(0, bracketDepth - 1);
+			current += char;
+		} else if (bracketDepth > 0) current += char;
+		else if (char === "\"" || char === "'" || char === "`") inQuote = char;
+		else if (char === " " || char === "	") {
+			if (current) {
+				tokens.push(current);
+				current = "";
+			}
+		} else current += char;
+		i++;
+	}
+	if (current) tokens.push(current);
+	return tokens;
+}
+function parseCliInputToParts(input) {
+	const parts = tokenizeInput(input.trim());
+	const result = [];
+	let pendingValue;
+	let allowTerm = true;
+	for (const part of parts) {
+		if (!part) continue;
+		const wasPending = pendingValue;
+		pendingValue = void 0;
+		if (part.startsWith("--no-") && part.length > 5) {
+			const p = {
+				type: "option",
+				key: part.slice(5),
+				value: void 0,
+				negated: true
+			};
+			result.push(p);
+		} else if (part.startsWith("--")) {
+			const [key = "", value] = splitOptionValue(part.slice(2));
+			const p = {
+				type: "option",
+				key,
+				value
+			};
+			if (typeof value === "undefined") pendingValue = p;
+			result.push(p);
+		} else if (part.startsWith("-") && part.length > 1 && !/^-\d/.test(part)) {
+			const [key = "", value] = splitOptionValue(part.slice(1));
+			const p = {
+				type: "alias",
+				key,
+				value
+			};
+			if (typeof value === "undefined") pendingValue = p;
+			result.push(p);
+		} else if (wasPending) wasPending.value = part;
+		else if (/^[a-zA-Z0-9_-]+$/.test(part) && allowTerm) result.push({
+			type: "term",
+			value: part
+		});
+		else {
+			result.push({
+				type: "arg",
+				value: part
+			});
+			allowTerm = false;
+		}
+	}
+	return result;
+}
+/**
+* Split option key and value, handling quoted values after =.
+*/
+function splitOptionValue(str) {
+	const eqIndex = str.indexOf("=");
+	if (eqIndex === -1) return [str, void 0];
+	const key = str.slice(0, eqIndex);
+	let value = str.slice(eqIndex + 1);
+	if (value.startsWith("\"") && value.endsWith("\"") || value.startsWith("'") && value.endsWith("'") || value.startsWith("`") && value.endsWith("`")) {
+		value = value.slice(1, -1);
+		return [key, value];
+	}
+	if (value.startsWith("[") && value.endsWith("]")) {
+		const inner = value.slice(1, -1);
+		if (inner === "") return [key, []];
+		return [key, parseArrayItems(inner)];
+	}
+	return [key, value];
+}
+/**
+* Parse comma-separated items, respecting quotes within items.
+*/
+function parseArrayItems(input) {
+	const items = [];
+	let current = "";
+	let inQuote = null;
+	let i = 0;
+	while (i < input.length) {
+		const char = input[i];
+		if (inQuote) {
+			if (char === "\\" && i + 1 < input.length && input[i + 1] === inQuote) {
+				current += input[i + 1];
+				i += 2;
+				continue;
+			}
+			if (char === inQuote) inQuote = null;
+			else current += char;
+		} else if (char === "\"" || char === "'" || char === "`") inQuote = char;
+		else if (char === ",") {
+			items.push(current.trim());
+			current = "";
+		} else current += char;
+		i++;
+	}
+	if (current || items.length > 0) items.push(current.trim());
+	return items;
+}
+
+//#endregion
+//#region src/create.ts
+const commandSymbol = Symbol("padrone_command");
+const noop = () => void 0;
+function createPadroneCommandBuilder(existingCommand) {
+	function findCommandByName(name, commands) {
+		if (!commands) return void 0;
+		const foundByName = commands.find((cmd) => cmd.name === name);
+		if (foundByName) return foundByName;
+		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;
+		}
+	}
+	const find = (command) => {
+		return findCommandByName(command, existingCommand.commands);
+	};
+	/**
+	* Parses CLI input to find the command and extract raw options without validation.
+	*/
+	const parseCommand = (input) => {
+		input ??= typeof process !== "undefined" ? process.argv.slice(2).join(" ") : void 0;
+		if (!input) return {
+			command: existingCommand,
+			rawOptions: {},
+			args: []
+		};
+		const parts = parseCliInputToParts(input);
+		const terms = parts.filter((p) => p.type === "term").map((p) => p.value);
+		const args = parts.filter((p) => p.type === "arg").map((p) => p.value);
+		let curCommand = existingCommand;
+		if (terms[0] === existingCommand.name) terms.shift();
+		for (let i = 0; i < terms.length; i++) {
+			const found = findCommandByName(terms[i] || "", curCommand.commands);
+			if (found) curCommand = found;
+			else {
+				args.unshift(...terms.slice(i));
+				break;
+			}
+		}
+		if (!curCommand) return {
+			command: existingCommand,
+			rawOptions: {},
+			args
+		};
+		const optionsMeta = curCommand.meta?.options;
+		const { aliases } = curCommand.options ? extractSchemaMetadata(curCommand.options, optionsMeta) : {
+			aliases: {},
+			envBindings: {},
+			configKeys: {}
+		};
+		const arrayOptions = /* @__PURE__ */ new Set();
+		if (curCommand.options) try {
+			const jsonSchema = curCommand.options["~standard"].jsonSchema.input({ target: "draft-2020-12" });
+			if (jsonSchema.type === "object" && jsonSchema.properties) {
+				for (const [key, prop] of Object.entries(jsonSchema.properties)) if (prop?.type === "array") arrayOptions.add(key);
+			}
+		} catch {}
+		const opts = parts.filter((p) => p.type === "option" || p.type === "alias");
+		const rawOptions = {};
+		for (const opt of opts) {
+			const key = opt.type === "alias" ? aliases[opt.key] || opt.key : opt.key;
+			if (opt.type === "option" && opt.negated) {
+				rawOptions[key] = false;
+				continue;
+			}
+			const value = opt.value ?? true;
+			if (arrayOptions.has(key)) if (key in rawOptions) {
+				const existing = rawOptions[key];
+				if (Array.isArray(existing)) if (Array.isArray(value)) existing.push(...value);
+				else existing.push(value);
+				else if (Array.isArray(value)) rawOptions[key] = [existing, ...value];
+				else rawOptions[key] = [existing, value];
+			} else rawOptions[key] = Array.isArray(value) ? value : [value];
+			else rawOptions[key] = value;
+		}
+		return {
+			command: curCommand,
+			rawOptions,
+			args
+		};
+	};
+	/**
+	* Validates raw options against the command's schema and applies preprocessing.
+	*/
+	const validateOptions = (command, rawOptions, args, parseOptions) => {
+		const optionsMeta = command.meta?.options;
+		const { envBindings, configKeys } = command.options ? extractSchemaMetadata(command.options, optionsMeta) : {
+			aliases: {},
+			envBindings: {},
+			configKeys: {}
+		};
+		const preprocessedOptions = preprocessOptions(rawOptions, {
+			aliases: {},
+			envBindings,
+			configKeys,
+			configData: parseOptions?.configData,
+			env: parseOptions?.env
+		});
+		const positionalConfig = command.meta?.positional ? parsePositionalConfig(command.meta.positional) : [];
+		if (positionalConfig.length > 0) {
+			let argIndex = 0;
+			for (const { name, variadic } of positionalConfig) {
+				if (argIndex >= args.length) break;
+				if (variadic) {
+					const nonVariadicAfter = positionalConfig.slice(positionalConfig.indexOf({
+						name,
+						variadic
+					}) + 1).filter((p) => !p.variadic).length;
+					const variadicEnd = args.length - nonVariadicAfter;
+					preprocessedOptions[name] = args.slice(argIndex, variadicEnd);
+					argIndex = variadicEnd;
+				} else {
+					preprocessedOptions[name] = args[argIndex];
+					argIndex++;
+				}
+			}
+		}
+		const optionsParsed = command.options ? command.options["~standard"].validate(preprocessedOptions) : { value: preprocessedOptions };
+		if (optionsParsed instanceof Promise) throw new Error("Async validation is not supported. Schema validate() must return a synchronous result.");
+		const hasOptions = command.options || Object.keys(preprocessedOptions).length > 0;
+		return {
+			options: optionsParsed.issues ? void 0 : hasOptions ? optionsParsed.value : void 0,
+			optionsResult: optionsParsed
+		};
+	};
+	const parse = (input, parseOptions) => {
+		const { command, rawOptions, args } = parseCommand(input);
+		const { options, optionsResult } = validateOptions(command, rawOptions, args, parseOptions);
+		return {
+			command,
+			options,
+			optionsResult
+		};
+	};
+	const stringify = (command = "", options) => {
+		const commandObj = typeof command === "string" ? findCommandByName(command, existingCommand.commands) : command;
+		if (!commandObj) throw new Error(`Command "${command ?? ""}" not found`);
+		const parts = [];
+		if (commandObj.path) parts.push(commandObj.path);
+		const positionalConfig = commandObj.meta?.positional ? parsePositionalConfig(commandObj.meta.positional) : [];
+		const positionalNames = new Set(positionalConfig.map((p) => p.name));
+		if (options && typeof options === "object") {
+			for (const { name, variadic } of positionalConfig) {
+				const value = options[name];
+				if (value === void 0) continue;
+				if (variadic && Array.isArray(value)) for (const v of value) {
+					const vStr = String(v);
+					if (vStr.includes(" ")) parts.push(`"${vStr}"`);
+					else parts.push(vStr);
+				}
+				else {
+					const argStr = String(value);
+					if (argStr.includes(" ")) parts.push(`"${argStr}"`);
+					else parts.push(argStr);
+				}
+			}
+			for (const [key, value] of Object.entries(options)) {
+				if (value === void 0 || positionalNames.has(key)) continue;
+				if (typeof value === "boolean") if (value) parts.push(`--${key}`);
+				else parts.push(`--no-${key}`);
+				else if (Array.isArray(value)) for (const v of value) {
+					const vStr = String(v);
+					if (vStr.includes(" ")) parts.push(`--${key}="${vStr}"`);
+					else parts.push(`--${key}=${vStr}`);
+				}
+				else if (typeof value === "string") if (value.includes(" ")) parts.push(`--${key}="${value}"`);
+				else parts.push(`--${key}=${value}`);
+				else parts.push(`--${key}=${value}`);
+			}
+		}
+		return parts.join(" ");
+	};
+	/**
+	* Check if help or version flags/commands are present in the input.
+	* Returns the appropriate action to take, or null if normal execution should proceed.
+	*/
+	const checkBuiltinCommands = (input) => {
+		if (!input) return null;
+		const parts = parseCliInputToParts(input);
+		const terms = parts.filter((p) => p.type === "term").map((p) => p.value);
+		const opts = parts.filter((p) => p.type === "option" || p.type === "alias");
+		const hasHelpFlag = opts.some((p) => p.type === "option" && p.key === "help" || p.type === "alias" && p.key === "h");
+		const getDetailLevel = () => {
+			for (const opt of opts) {
+				if (opt.type === "option" && opt.key === "detail" && typeof opt.value === "string") {
+					if (opt.value === "minimal" || opt.value === "standard" || opt.value === "full") return opt.value;
+				}
+				if (opt.type === "alias" && opt.key === "d" && typeof opt.value === "string") {
+					if (opt.value === "minimal" || opt.value === "standard" || opt.value === "full") return opt.value;
+				}
+			}
+		};
+		const detail = getDetailLevel();
+		const getFormat = () => {
+			const validFormats = [
+				"text",
+				"ansi",
+				"console",
+				"markdown",
+				"html",
+				"json",
+				"auto"
+			];
+			for (const opt of opts) {
+				if (opt.type === "option" && opt.key === "format" && typeof opt.value === "string") {
+					if (validFormats.includes(opt.value)) return opt.value;
+				}
+				if (opt.type === "alias" && opt.key === "f" && typeof opt.value === "string") {
+					if (validFormats.includes(opt.value)) return opt.value;
+				}
+			}
+		};
+		const format = getFormat();
+		const hasVersionFlag = opts.some((p) => p.type === "option" && p.key === "version" || p.type === "alias" && (p.key === "v" || p.key === "V"));
+		const normalizedTerms = [...terms];
+		if (normalizedTerms[0] === existingCommand.name) normalizedTerms.shift();
+		const userHelpCommand = findCommandByName("help", existingCommand.commands);
+		const userVersionCommand = findCommandByName("version", existingCommand.commands);
+		if (!userHelpCommand && normalizedTerms[0] === "help") {
+			const commandName = normalizedTerms.slice(1).join(" ");
+			return {
+				type: "help",
+				command: commandName ? findCommandByName(commandName, existingCommand.commands) : void 0,
+				detail,
+				format
+			};
+		}
+		if (!userVersionCommand && normalizedTerms[0] === "version") return { type: "version" };
+		if (hasHelpFlag) {
+			const commandName = normalizedTerms.filter((t) => t !== "help").join(" ");
+			return {
+				type: "help",
+				command: commandName ? findCommandByName(commandName, existingCommand.commands) : void 0,
+				detail,
+				format
+			};
+		}
+		if (hasVersionFlag && normalizedTerms.length === 0) return { type: "version" };
+		return null;
+	};
+	/**
+	* Extract the config file path from --config=<path> or -c <path> flags.
+	*/
+	const extractConfigPath = (input) => {
+		if (!input) return void 0;
+		const opts = parseCliInputToParts(input).filter((p) => p.type === "option" || p.type === "alias");
+		for (const opt of opts) {
+			if (opt.type === "option" && opt.key === "config" && typeof opt.value === "string") return opt.value;
+			if (opt.type === "alias" && opt.key === "c" && typeof opt.value === "string") return opt.value;
+		}
+	};
+	const cli = (input, cliOptions) => {
+		const resolvedInput = input ?? (typeof process !== "undefined" ? process.argv.slice(2).join(" ") : void 0);
+		const builtin = checkBuiltinCommands(resolvedInput);
+		if (builtin) {
+			if (builtin.type === "help") {
+				const helpText = generateHelp(existingCommand, builtin.command ?? existingCommand, {
+					detail: builtin.detail,
+					format: builtin.format
+				});
+				console.log(helpText);
+				return {
+					command: existingCommand,
+					args: void 0,
+					options: void 0,
+					result: helpText
+				};
+			}
+			if (builtin.type === "version") {
+				const version = getVersion(existingCommand.version);
+				console.log(version);
+				return {
+					command: existingCommand,
+					options: void 0,
+					result: version
+				};
+			}
+		}
+		const { command, rawOptions, args } = parseCommand(resolvedInput);
+		const configPath = extractConfigPath(resolvedInput);
+		const resolveConfigFiles = (cmd) => {
+			if (cmd.configFiles !== void 0) return cmd.configFiles;
+			if (cmd.parent) return resolveConfigFiles(cmd.parent);
+		};
+		const effectiveConfigFiles = resolveConfigFiles(command);
+		let configData = cliOptions?.configData;
+		if (configPath) configData = loadConfigFile(configPath);
+		else if (effectiveConfigFiles?.length) {
+			const foundConfigPath = findConfigFile(effectiveConfigFiles);
+			if (foundConfigPath) configData = loadConfigFile(foundConfigPath) ?? configData;
+		}
+		const { options, optionsResult } = validateOptions(command, rawOptions, args, {
+			...cliOptions,
+			configData
+		});
+		return {
+			...run(command, options),
+			optionsResult
+		};
+	};
+	const run = (command, options) => {
+		const commandObj = typeof command === "string" ? findCommandByName(command, existingCommand.commands) : command;
+		if (!commandObj) throw new Error(`Command "${command ?? ""}" not found`);
+		if (!commandObj.handler) throw new Error(`Command "${commandObj.path}" has no handler`);
+		return {
+			command: commandObj,
+			options,
+			result: commandObj.handler(options)
+		};
+	};
+	const tool = () => {
+		return {
+			type: "function",
+			name: existingCommand.name,
+			description: generateHelp(existingCommand, void 0, {
+				format: "text",
+				detail: "full"
+			}),
+			strict: true,
+			inputExamples: [{ input: { command: "<command> [args...] [options...]" } }],
+			inputSchema: {
+				[Symbol.for("vercel.ai.schema")]: true,
+				jsonSchema: {
+					type: "object",
+					properties: { command: { type: "string" } },
+					additionalProperties: false
+				},
+				_type: void 0,
+				validate: (value) => {
+					const command = value?.command;
+					if (typeof command === "string") return {
+						success: true,
+						value: { command }
+					};
+					return {
+						success: false,
+						error: /* @__PURE__ */ new Error("Expected an object with command property as string.")
+					};
+				}
+			},
+			title: existingCommand.description,
+			needsApproval: (input) => {
+				const { command, options } = parse(input.command);
+				if (typeof command.needsApproval === "function") return command.needsApproval(options);
+				return !!command.needsApproval;
+			},
+			execute: (input) => {
+				return cli(input.command).result;
+			}
+		};
+	};
+	return {
+		configure(config) {
+			return createPadroneCommandBuilder({
+				...existingCommand,
+				...config
+			});
+		},
+		options(options, meta) {
+			return createPadroneCommandBuilder({
+				...existingCommand,
+				options,
+				meta
+			});
+		},
+		action(handler = noop) {
+			return createPadroneCommandBuilder({
+				...existingCommand,
+				handler
+			});
+		},
+		command: (name, builderFn) => {
+			const initialCommand = {
+				name,
+				path: existingCommand.path ? `${existingCommand.path} ${name}` : name,
+				parent: existingCommand,
+				"~types": {}
+			};
+			const builder = createPadroneCommandBuilder(initialCommand);
+			const commandObj = (builderFn?.(builder))?.[commandSymbol] ?? initialCommand;
+			return createPadroneCommandBuilder({
+				...existingCommand,
+				commands: [...existingCommand.commands || [], commandObj]
+			});
+		},
+		run,
+		find,
+		parse,
+		stringify,
+		cli,
+		tool,
+		api() {
+			function buildApi(command) {
+				const runCommand = ((options) => run(command, options).result);
+				if (!command.commands) return runCommand;
+				for (const cmd of command.commands) runCommand[cmd.name] = buildApi(cmd);
+				return runCommand;
+			}
+			return buildApi(existingCommand);
+		},
+		help(command, options) {
+			const commandObj = !command ? existingCommand : typeof command === "string" ? findCommandByName(command, existingCommand.commands) : command;
+			if (!commandObj) throw new Error(`Command "${command ?? ""}" not found`);
+			return generateHelp(existingCommand, commandObj, options);
+		},
+		"~types": {},
+		[commandSymbol]: existingCommand
+	};
+}
+
+//#endregion
+//#region src/index.ts
+function createPadrone(name) {
+	return createPadroneCommandBuilder({
+		name,
+		path: "",
+		commands: []
+	});
+}
+
+//#endregion
+export { createPadrone };
+//# sourceMappingURL=index.mjs.map