padrone 1.5.0 → 1.6.0

package/dist/command-utils-B1D-HqCd.mjs

@@ -1,1117 +0,0 @@
-import { n as __require, t as __exportAll } from "./chunk-CjcI7cDX.mjs";
-import { a as extractSchemaMetadata, t as JSON_SCHEMA_OPTS } from "./args-D5PNDyNu.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();
-			}
-		}
-	};
-}
-const spinnerPresets = {
-	dots: [
-		"⠋",
-		"⠙",
-		"⠹",
-		"⠸",
-		"⠼",
-		"⠴",
-		"⠦",
-		"⠧",
-		"⠇",
-		"⠏"
-	],
-	line: [
-		"-",
-		"\\",
-		"|",
-		"/"
-	],
-	arc: [
-		"◜",
-		"◠",
-		"◝",
-		"◞",
-		"◡",
-		"◟"
-	],
-	bounce: [
-		"⠁",
-		"⠂",
-		"⠄",
-		"⡀",
-		"⢀",
-		"⠠",
-		"⠐",
-		"⠈"
-	]
-};
-function resolveSpinnerConfig(config) {
-	if (config === false) return {
-		frames: [],
-		interval: 80,
-		disabled: true
-	};
-	if (typeof config === "string") return {
-		frames: spinnerPresets[config],
-		interval: 80,
-		disabled: false
-	};
-	if (typeof config === "object") return {
-		frames: config.frames ?? spinnerPresets.dots,
-		interval: config.interval ?? 80,
-		disabled: false
-	};
-	return {
-		frames: spinnerPresets.dots,
-		interval: 80,
-		disabled: false
-	};
-}
-/**
-* Creates a built-in terminal spinner. Returns a no-op indicator in non-TTY/CI environments.
-*/
-function createTerminalSpinner(message, options) {
-	const { frames, interval, disabled: spinnerDisabled } = resolveSpinnerConfig(options?.spinner);
-	const successIcon = options?.successIndicator ?? "✔";
-	const errorIcon = options?.errorIndicator ?? "✖";
-	const formatFinal = (icon, msg) => icon ? `${icon} ${msg}\n` : `${msg}\n`;
-	if (typeof process === "undefined" || !process.stderr?.isTTY) return {
-		update() {},
-		succeed(msg, opts) {
-			if (msg === null) return;
-			const icon = opts?.indicator ?? successIcon;
-			if (msg || message) process?.stderr?.write?.(formatFinal(icon, msg || message));
-		},
-		fail(msg, opts) {
-			if (msg === null) return;
-			const icon = opts?.indicator ?? errorIcon;
-			if (msg || message) process?.stderr?.write?.(formatFinal(icon, msg || message));
-		},
-		stop() {},
-		pause() {},
-		resume() {}
-	};
-	if (spinnerDisabled && !message) return {
-		update() {},
-		succeed() {},
-		fail() {},
-		stop() {},
-		pause() {},
-		resume() {}
-	};
-	let frame = 0;
-	let text = message;
-	let stopped = false;
-	let paused = false;
-	const writeStderr = process.stderr.write.bind(process.stderr);
-	const writeStdout = process.stdout.write.bind(process.stdout);
-	const clearLine = () => writeStderr("\x1B[2K\r");
-	const render = () => {
-		if (paused || stopped) return;
-		if (spinnerDisabled) {
-			if (text) writeStderr(`\x1b[2K\r${text}`);
-		} else {
-			const prefix = frames[frame] ?? "";
-			writeStderr(`\x1b[2K\r${text ? `${prefix} ${text}` : prefix}`);
-		}
-	};
-	const timer = spinnerDisabled ? void 0 : setInterval(() => {
-		frame = (frame + 1) % frames.length;
-		render();
-	}, interval);
-	render();
-	const clear = () => {
-		if (stopped) return;
-		stopped = true;
-		paused = false;
-		if (timer) clearInterval(timer);
-		clearLine();
-	};
-	return {
-		update(msg) {
-			if (stopped) return;
-			text = msg;
-			render();
-		},
-		succeed(msg, opts) {
-			clear();
-			if (msg === null) return;
-			const finalMsg = msg ?? text;
-			const icon = opts?.indicator ?? successIcon;
-			if (finalMsg) writeStderr(formatFinal(icon, finalMsg));
-		},
-		fail(msg, opts) {
-			clear();
-			if (msg === null) return;
-			const finalMsg = msg ?? text;
-			const icon = opts?.indicator ?? errorIcon;
-			if (finalMsg) writeStderr(formatFinal(icon, finalMsg));
-		},
-		stop() {
-			clear();
-		},
-		pause() {
-			if (stopped || paused) return;
-			paused = true;
-			clearLine();
-			writeStdout("\x1B[2K\r");
-		},
-		resume() {
-			if (stopped || !paused) return;
-			paused = false;
-			render();
-		}
-	};
-}
-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(),
-		progress: createTerminalSpinner
-	};
-}
-/**
-* 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;
-}
-/**
-* Like `resolveStdin`, but always returns a stdin source even when it's a TTY.
-* Used for async streams which support interactive (non-piped) input.
-*/
-function resolveStdinAlways(partial) {
-	if (partial?.stdin) return partial.stdin;
-	return createDefaultStdin();
-}
-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,
-		progress: partial.progress ?? defaults.progress,
-		stdin: partial.stdin,
-		theme: partial.theme
-	};
-}
-//#endregion
-//#region src/command-utils.ts
-var command_utils_exports = /* @__PURE__ */ __exportAll({
-	asyncSchema: () => asyncSchema,
-	buildInputSchema: () => buildInputSchema,
-	buildReplCompleter: () => buildReplCompleter,
-	collectEndpoints: () => collectEndpoints,
-	commandSymbol: () => commandSymbol,
-	configKeys: () => configKeys,
-	createLazyIndicator: () => createLazyIndicator,
-	createProgress: () => createProgress,
-	drainValue: () => drainValue,
-	errorResult: () => errorResult,
-	findCommandByName: () => findCommandByName,
-	getCommand: () => getCommand,
-	getCommandRuntime: () => getCommandRuntime,
-	hasInteractiveConfig: () => hasInteractiveConfig,
-	isAsyncBranded: () => isAsyncBranded,
-	isAsyncIterator: () => isAsyncIterator,
-	isIterator: () => isIterator,
-	lazyResolver: () => lazyResolver,
-	makeThenable: () => makeThenable,
-	mergeCommands: () => mergeCommands,
-	noop: () => noop,
-	noopIndicator: () => noopIndicator,
-	outputValue: () => outputValue,
-	repathCommandTree: () => repathCommandTree,
-	resolveAllCommands: () => resolveAllCommands,
-	resolveCommand: () => resolveCommand,
-	resolveProgressMessage: () => resolveProgressMessage,
-	runPluginChain: () => runPluginChain,
-	serializeArgsToFlags: () => serializeArgsToFlags,
-	suggestSimilar: () => suggestSimilar,
-	thenMaybe: () => thenMaybe,
-	warnIfUnexpectedAsync: () => warnIfUnexpectedAsync,
-	withDrain: () => withDrain,
-	withPromiseDrain: () => withPromiseDrain,
-	wrapWithLifecycle: () => wrapWithLifecycle
-});
-const lazyResolver = Symbol("lazyResolver");
-/** Resolves a lazy command in place by calling its stored resolver. No-op if already resolved. */
-function resolveCommand(cmd) {
-	const resolver = cmd[lazyResolver];
-	if (resolver) {
-		delete cmd[lazyResolver];
-		resolver(cmd);
-	}
-	return cmd;
-}
-/** Recursively resolves a command and all its descendants. */
-function resolveAllCommands(cmd) {
-	resolveCommand(cmd);
-	if (cmd.commands) for (const sub of cmd.commands) resolveAllCommands(sub);
-}
-/** Extracts the underlying command from a program/builder and resolves the full command tree. */
-function getCommand(program) {
-	const cmd = commandSymbol in program ? program[commandSymbol] : program;
-	resolveAllCommands(cmd);
-	return cmd;
-}
-/**
-* 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",
-	"mutation",
-	"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) {
-	resolveCommand(existing);
-	resolveCommand(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.progress !== existing.progress) merged.progress = override.progress;
-	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);
-}
-/**
-* Makes a sync result object thenable by adding `.then()`, `.catch()`, and `.finally()` methods.
-* If the value is already a Promise, returns it as-is.
-* This allows users to write `await program.cli()` or `program.cli().then(...)` regardless of sync/async.
-*
-* The `.then()` resolves with a plain copy (without thenable methods) to avoid infinite
-* recursive unwrapping by the Promise resolution algorithm.
-*/
-function makeThenable(value) {
-	if (value instanceof Promise) return value;
-	if (value !== null && typeof value === "object" && !("then" in value)) {
-		const toPlain = () => {
-			const plain = { ...value };
-			delete plain.then;
-			delete plain.catch;
-			delete plain.finally;
-			return plain;
-		};
-		value.then = (onfulfilled, onrejected) => {
-			try {
-				const result = onfulfilled ? onfulfilled(toPlain()) : toPlain();
-				return Promise.resolve(result);
-			} catch (err) {
-				if (onrejected) return Promise.resolve(onrejected(err));
-				return Promise.reject(err);
-			}
-		};
-		value.catch = (onrejected) => value.then(void 0, onrejected);
-		value.finally = (onfinally) => value.then((v) => {
-			onfinally?.();
-			return v;
-		}, (err) => {
-			onfinally?.();
-			throw err;
-		});
-	}
-	return value;
-}
-/**
-* Wraps a Promise to include a `drain()` method at the top level.
-* This allows `await promise.drain()` without first awaiting the promise.
-* Since cli/eval never reject, this just delegates to the resolved result's `drain()`.
-*/
-function withPromiseDrain(promise) {
-	promise.drain = async () => {
-		return (await promise).drain();
-	};
-	return promise;
-}
-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);
-}
-/**
-* Resolves a result value by unwrapping Promises and collecting iterables into arrays.
-* This is the runtime counterpart of the `Drained<T>` type.
-*/
-async function drainValue(value) {
-	if (value instanceof Promise) return drainValue(await value);
-	if (isAsyncIterator(value)) {
-		const items = [];
-		const iter = value[Symbol.asyncIterator]();
-		while (true) {
-			const { done, value: item } = await iter.next();
-			if (done) break;
-			items.push(item);
-		}
-		return items;
-	}
-	if (typeof value !== "string" && !Array.isArray(value) && isIterator(value)) {
-		const items = [];
-		const iter = value[Symbol.iterator]();
-		while (true) {
-			const { done, value: item } = iter.next();
-			if (done) break;
-			items.push(item);
-		}
-		return items;
-	}
-	return value;
-}
-/**
-* Attaches a `drain()` method to a command result object.
-* If the result has an `error` field, `drain()` returns `{ error }`.
-* Otherwise, resolves the result (unwrapping Promises, collecting iterables), catches errors,
-* and returns a discriminated union `{ value } | { error }` that never throws.
-*/
-function withDrain(obj) {
-	obj.drain = async () => {
-		if ("error" in obj && obj.error !== void 0) return { error: obj.error };
-		try {
-			return { value: await drainValue(obj.result) };
-		} catch (err) {
-			return { error: err };
-		}
-	};
-	return obj;
-}
-/**
-* Creates an error command result with a `drain()` that returns the error.
-*/
-function errorResult(error, partial) {
-	return withDrain({
-		error,
-		result: void 0,
-		command: partial?.command,
-		args: partial?.args,
-		argsResult: partial?.argsResult
-	});
-}
-/**
-* Deduplicates plugins by `id`. When multiple plugins share the same `id`,
-* only the last one in the array is kept. Plugins without an `id` are always kept.
-*/
-function deduplicatePlugins(plugins) {
-	if (!plugins.some((p) => p.id)) return plugins;
-	const lastIndex = /* @__PURE__ */ new Map();
-	for (let i = 0; i < plugins.length; i++) {
-		const id = plugins[i].id;
-		if (id) lastIndex.set(id, i);
-	}
-	return plugins.filter((p, i) => !p.id || lastIndex.get(p.id) === i);
-}
-/**
-* 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 = deduplicatePlugins(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);
-	const cleanupProgress = (error, result) => {
-		const indicator = state._progress;
-		if (indicator) {
-			if (!("_progressMsg" in state)) indicator.stop();
-			else if (error !== void 0) {
-				const fallback = error instanceof Error ? error.message : String(error);
-				const { message: errorMsg, indicator: errorIcon } = resolveProgressMessage(state._progressError, error, fallback);
-				indicator.fail(errorMsg, errorIcon !== void 0 ? { indicator: errorIcon } : void 0);
-			} else {
-				const { message: successMsg, indicator: successIcon } = resolveProgressMessage(state._progressSuccess, result);
-				indicator.succeed(successMsg, successIcon !== void 0 ? { indicator: successIcon } : void 0);
-			}
-			state._restoreOutput?.();
-			state._progress = void 0;
-			state._restoreOutput = void 0;
-		}
-	};
-	if (!hasStart && !hasError && !hasShutdown) {
-		let result;
-		try {
-			result = pipeline();
-		} catch (e) {
-			cleanupProgress(e);
-			throw e;
-		}
-		if (result instanceof Promise) return result.then((r) => {
-			cleanupProgress();
-			return r;
-		}, (e) => {
-			cleanupProgress(e);
-			throw e;
-		});
-		cleanupProgress();
-		return result;
-	}
-	const runShutdown = (error, result) => {
-		cleanupProgress(error);
-		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();
-}
-/** No-op progress indicator returned when the runtime doesn't provide a `progress` factory. */
-const noopIndicator = {
-	update() {},
-	succeed() {},
-	fail() {},
-	stop() {},
-	pause() {},
-	resume() {}
-};
-/** Creates a progress indicator from the runtime, or returns a no-op if unavailable. */
-function createProgress(runtime, message, options) {
-	return runtime.progress?.(message, options) ?? noopIndicator;
-}
-/**
-* Creates a lazy progress indicator that defers real indicator creation until first use.
-* This allows `ctx.progress` to work even without `.progress()` config, as long as the
-* runtime provides a progress factory.
-*/
-function createLazyIndicator(runtime, state) {
-	if (!runtime.progress) return noopIndicator;
-	let real;
-	const ensure = (message) => {
-		if (!real) {
-			real = runtime.progress(message ?? "", void 0);
-			state._progress = real;
-		}
-		return real;
-	};
-	return {
-		update(msg) {
-			ensure(msg).update(msg);
-		},
-		succeed(msg) {
-			if (real) real.succeed(msg);
-		},
-		fail(msg) {
-			if (real) real.fail(msg);
-		},
-		stop() {
-			if (real) real.stop();
-		},
-		pause() {
-			if (real) real.pause();
-		},
-		resume() {
-			if (real) real.resume();
-		}
-	};
-}
-/**
-* Resolves a progress message field (static or callback) into the arguments for succeed/fail.
-* Handles string, null, `{ message, indicator }` objects, and callback functions.
-*/
-function resolveProgressMessage(field, value, fallback) {
-	const raw = typeof field === "function" ? field(value) : field;
-	if (raw === void 0) return { message: fallback };
-	if (raw === null || typeof raw === "string") return { message: raw };
-	if (typeof raw === "object" && raw !== null) {
-		const obj = raw;
-		return {
-			message: obj.message,
-			indicator: obj.indicator
-		};
-	}
-	return { message: fallback };
-}
-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) {
-	resolveCommand(cmd);
-	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) {
-	resolveAllCommands(rootCommand);
-	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) {
-				resolveCommand(targetCommand);
-				const sub = targetCommand.commands?.find((c) => c.name === part || c.aliases?.includes(part));
-				if (sub) {
-					resolveCommand(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(JSON_SCHEMA_OPTS);
-				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++) {
-			resolveCommand(targetCommand);
-			const sub = targetCommand.commands?.find((c) => c.name === commandParts[i] || c.aliases?.includes(commandParts[i]));
-			if (sub) {
-				resolveCommand(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 resolveCommand(foundByName);
-	const foundByAlias = commands.find((cmd) => cmd.aliases?.includes(name));
-	if (foundByAlias) return resolveCommand(foundByAlias);
-	for (const cmd of commands) {
-		if (name.startsWith(`${cmd.name} `)) {
-			resolveCommand(cmd);
-			if (cmd.commands) {
-				const subCommand = findCommandByName(name.slice(cmd.name.length + 1), cmd.commands);
-				if (subCommand) return subCommand;
-			}
-		}
-		if (cmd.aliases) {
-			for (const alias of cmd.aliases) if (name.startsWith(`${alias} `)) {
-				resolveCommand(cmd);
-				if (cmd.commands) {
-					const subCommand = findCommandByName(name.slice(alias.length + 1), cmd.commands);
-					if (subCommand) return subCommand;
-				}
-			}
-		}
-	}
-}
-/** Collect all actionable commands recursively. Hidden commands are excluded. */
-function collectEndpoints(commands, prefix) {
-	if (!commands) return [];
-	const endpoints = [];
-	for (const cmd of commands) {
-		resolveCommand(cmd);
-		if (cmd.hidden) continue;
-		const path = cmd.name ? prefix ? `${prefix}.${cmd.name}` : cmd.name : prefix;
-		if (cmd.action || cmd.argsSchema) endpoints.push({
-			name: path,
-			command: cmd
-		});
-		if (cmd.commands?.length) endpoints.push(...collectEndpoints(cmd.commands, path));
-	}
-	return endpoints;
-}
-/** Build the JSON Schema for a command's arguments. */
-function buildInputSchema(cmd) {
-	if (!cmd.argsSchema) return {
-		type: "object",
-		additionalProperties: false
-	};
-	try {
-		return cmd.argsSchema["~standard"].jsonSchema.input(JSON_SCHEMA_OPTS);
-	} catch {
-		return {
-			type: "object",
-			additionalProperties: false
-		};
-	}
-}
-/** Serialize a record of args into CLI flag strings. */
-function serializeArgsToFlags(args) {
-	const parts = [];
-	for (const [key, value] of Object.entries(args)) {
-		if (value === void 0) continue;
-		if (typeof value === "boolean") parts.push(value ? `--${key}` : `--no-${key}`);
-		else if (Array.isArray(value)) for (const v of value) parts.push(`--${key}=${String(v)}`);
-		else {
-			const strVal = String(value);
-			parts.push(strVal.includes(" ") ? `--${key}="${strVal}"` : `--${key}=${strVal}`);
-		}
-	}
-	return parts;
-}
-//#endregion
-export { withDrain as A, resolveCommand as C, suggestSimilar as D, serializeArgsToFlags as E, resolveStdin as F, resolveStdinAlways as I, getRootCommand as L, wrapWithLifecycle as M, REPL_SIGINT as N, thenMaybe as O, createTerminalReplSession as P, getVersion as R, resolveAllCommands as S, runPluginChain as T, mergeCommands as _, commandSymbol as a, outputValue as b, createProgress as c, getCommand as d, getCommandRuntime as f, makeThenable as g, lazyResolver as h, collectEndpoints as i, withPromiseDrain as j, warnIfUnexpectedAsync as k, errorResult as l, isAsyncBranded as m, buildInputSchema as n, command_utils_exports as o, hasInteractiveConfig as p, buildReplCompleter as r, createLazyIndicator as s, asyncSchema as t, findCommandByName as u, noop as v, resolveProgressMessage as w, repathCommandTree as x, noopIndicator as y };
-
-//# sourceMappingURL=command-utils-B1D-HqCd.mjs.map