@ls-stack/cli 0.1.0

package/dist/main.mjs

@@ -0,0 +1,723 @@
+import { checkbox, confirm, input, number, search, select } from "@inquirer/prompts";
+import * as readline from "readline";
+import { styleText } from "node:util";
+
+//#region src/cliInput.ts
+function isUserCancellation(e) {
+	return e instanceof Error && (e.name === "ExitPromptError" || e.name === "AbortError" || e.name === "AbortPromptError");
+}
+function handlePromptError(e) {
+	if (isUserCancellation(e)) process.exit(0);
+	console.error(e);
+	process.exit(1);
+}
+function createEscapeAbortController() {
+	const controller = new AbortController();
+	readline.emitKeypressEvents(process.stdin);
+	if (process.stdin.isTTY) process.stdin.setRawMode(true);
+	function onKeypress(_, key) {
+		if (key.name === "escape") controller.abort();
+	}
+	process.stdin.on("keypress", onKeypress);
+	function cleanup() {
+		process.stdin.removeListener("keypress", onKeypress);
+	}
+	return {
+		signal: controller.signal,
+		cleanup
+	};
+}
+async function withEscapeSupport(promptFn) {
+	const { signal, cleanup } = createEscapeAbortController();
+	try {
+		return await promptFn(signal);
+	} finally {
+		cleanup();
+	}
+}
+/**
+* Interactive CLI input utilities with ESC-to-cancel support.
+*
+* All prompts exit the process with code 0 when the user presses ESC or Ctrl+C.
+*
+* @example
+* ```ts
+* import { cliInput } from '@ls-stack/cli';
+*
+* const name = await cliInput.text('Enter your name');
+* const confirm = await cliInput.confirm('Proceed?', { initial: true });
+* ```
+*/
+const cliInput = {
+	select: async (title, { options }) => {
+		try {
+			return await withEscapeSupport((signal) => select({
+				message: title,
+				choices: options.map((option) => ({
+					value: option.value,
+					name: option.label ?? option.value,
+					description: option.hint
+				}))
+			}, { signal }));
+		} catch (e) {
+			handlePromptError(e);
+		}
+	},
+	textWithAutocomplete: async (title, { options, validate }) => {
+		try {
+			const choices = options.map((option) => ({
+				value: option.value,
+				name: option.label ?? option.value,
+				description: option.hint
+			}));
+			return await withEscapeSupport((signal) => search({
+				message: title,
+				source: (term) => {
+					if (!term) return choices;
+					const lowerTerm = term.toLowerCase();
+					return choices.filter((c) => c.name.toLowerCase().includes(lowerTerm) || c.value.toLowerCase().includes(lowerTerm) || c.description?.toLowerCase().includes(lowerTerm));
+				},
+				validate
+			}, { signal }));
+		} catch (e) {
+			handlePromptError(e);
+		}
+	},
+	text: async (title, { initial, validate } = {}) => {
+		try {
+			return await withEscapeSupport((signal) => input({
+				message: title,
+				default: initial,
+				required: true,
+				validate
+			}, { signal }));
+		} catch (e) {
+			handlePromptError(e);
+		}
+	},
+	confirm: async (title, { initial } = {}) => {
+		try {
+			return await withEscapeSupport((signal) => confirm({
+				message: title,
+				default: initial
+			}, { signal }));
+		} catch (e) {
+			handlePromptError(e);
+		}
+	},
+	multipleSelect: async (title, { options }) => {
+		try {
+			return await withEscapeSupport((signal) => checkbox({
+				message: title,
+				required: true,
+				choices: options.map((option) => ({
+					value: option.value,
+					name: option.label ?? option.value,
+					description: option.hint
+				}))
+			}, { signal }));
+		} catch (e) {
+			handlePromptError(e);
+		}
+	},
+	number: async (title, { initial } = {}) => {
+		try {
+			return await withEscapeSupport((signal) => number({
+				message: title,
+				default: initial,
+				required: true
+			}, { signal }));
+		} catch (e) {
+			if (isUserCancellation(e)) process.exit(0);
+			console.error(e);
+			return null;
+		}
+	}
+};
+
+//#endregion
+//#region node_modules/.pnpm/@ls-stack+utils@3.68.0/node_modules/@ls-stack/utils/dist/assertions-CsE3pD8P.mjs
+/**
+* Ensures exhaustive type checking in switch statements or conditional logic.
+*
+* This function should be used in the default case of switch statements or the
+* final else branch of conditional logic to ensure all possible cases are
+* handled. It helps catch missing cases at compile time when new union members
+* are added.
+*
+* @example
+*   ```typescript
+*   type Status = 'pending' | 'success' | 'error';
+*
+*   function handleStatus(status: Status) {
+*     switch (status) {
+*       case 'pending':
+*         return 'Loading...';
+*       case 'success':
+*         return 'Done!';
+*       case 'error':
+*         return 'Failed!';
+*       default:
+*         throw exhaustiveCheck(status); // TypeScript error if Status gains new members
+*     }
+*   }
+*
+*   // In conditional logic
+*   function processValue(value: string | number) {
+*     if (typeof value === 'string') {
+*       return value.toUpperCase();
+*     } else if (typeof value === 'number') {
+*       return value.toString();
+*     } else {
+*       throw exhaustiveCheck(value); // Ensures all cases are covered
+*     }
+*   }
+*   ```;
+*
+* @template Except - The type that should never be reached
+* @param narrowedType - The value that should never exist at runtime
+* @returns An Error object (this function should never actually execute)
+*/
+function exhaustiveCheck(narrowedType) {
+	return /* @__PURE__ */ new Error("This should never happen");
+}
+
+//#endregion
+//#region node_modules/.pnpm/@ls-stack+utils@3.68.0/node_modules/@ls-stack/utils/dist/arrayUtils.mjs
+/**
+* Sort an array based on a value
+*
+* Sort by `ascending` order by default
+*
+* Use `Infinity` as as wildcard to absolute max and min values
+*
+* @example
+*   const items = [1, 3, 2, 4];
+*
+*   const sortedItems = sortBy(items, (item) => item);
+*   // [1, 2, 3, 4]
+*
+*   const items2 = [
+*     { a: 1, b: 2 },
+*     { a: 2, b: 1 },
+*     { a: 1, b: 1 },
+*   ];
+*
+*   // return a array to sort by multiple values
+*   const sortedItems = sortBy(items, (item) => [item.a, item.b]);
+*
+* @param arr
+* @param sortByValue
+* @param props
+*/
+function sortBy(arr, sortByValue, props = "asc") {
+	const order = Array.isArray(props) || typeof props === "string" ? props : props.order ?? "asc";
+	return [...arr].sort((a, b) => {
+		const _aPriority = sortByValue(a);
+		const _bPriority = sortByValue(b);
+		const aPriority = Array.isArray(_aPriority) ? _aPriority : [_aPriority];
+		const bPriority = Array.isArray(_bPriority) ? _bPriority : [_bPriority];
+		for (let i = 0; i < aPriority.length; i++) {
+			const levelOrder = typeof order === "string" ? order : order[i] ?? "asc";
+			const aP = aPriority[i] ?? 0;
+			const bP = bPriority[i] ?? 0;
+			if (aP === bP) continue;
+			if (bP === Infinity || aP === -Infinity || aP < bP) return levelOrder === "asc" ? -1 : 1;
+			if (aP === Infinity || bP === -Infinity || aP > bP) return levelOrder === "asc" ? 1 : -1;
+		}
+		return 0;
+	});
+}
+/**
+* Get the correct 0 based value for sync with other array in ascending order
+*
+* @example
+*   ```ts
+*   const items = [1, 2, 3];
+*
+*   const index = sortBy(
+*     items,
+*     (item) => getAscIndexOrder(
+*       followOrder.findIndex((order) => order === item)
+*     )
+*   );
+*   ```;
+*
+* @param index
+*/
+function getAscIndexOrder(index) {
+	return index === -1 ? Infinity : index ?? Infinity;
+}
+
+//#endregion
+//#region node_modules/.pnpm/@ls-stack+utils@3.68.0/node_modules/@ls-stack/utils/dist/dedent.mjs
+/**
+* Remove common leading indentation from multi-line strings while preserving
+* relative indentation. Can be used as a tagged template literal or called with
+* a plain string.
+*
+* By default, it will dedent interpolated multi-line strings to match the
+* surrounding context. And it will not show falsy values.
+*
+* @example
+*   ```typescript
+*   const text = dedent`;
+*   function hello() {
+*     console.log('world');
+*   }
+*   `;
+*   // Result:
+*   "function hello() {
+*     console.log('world');
+*   }"
+*   ```;
+*/
+const dedent = createDedent({ identInterpolations: true });
+function createDedent(options) {
+	d.withOptions = (newOptions) => createDedent({
+		...options,
+		...newOptions
+	});
+	return d;
+	function d(strings, ...values) {
+		const raw = typeof strings === "string" ? [strings] : strings.raw;
+		const { escapeSpecialCharacters = Array.isArray(strings), trimWhitespace = true, identInterpolations = true, showNullishOrFalseValues = false } = options;
+		let result = "";
+		for (let i = 0; i < raw.length; i++) {
+			let next = raw[i];
+			if (escapeSpecialCharacters) next = next.replace(/\\\n[ \t]*/g, "").replace(/\\`/g, "`").replace(/\\\$/g, "$").replace(/\\\{/g, "{");
+			result += next;
+			if (i < values.length) {
+				let val = values[i];
+				if (!showNullishOrFalseValues && (val === false || val === null || val === void 0)) continue;
+				val = String(val);
+				if (identInterpolations && val.includes("\n")) {
+					let withIdent = val;
+					const currentIndent = getCurrentIndent(result);
+					if (currentIndent && withIdent) withIdent = withIdent.split("\n").map((line, index) => {
+						return index === 0 || line === "" ? line : currentIndent + line;
+					}).join("\n");
+					result += withIdent;
+				} else result += val;
+			}
+		}
+		const lines = result.split("\n");
+		let mindent = null;
+		for (const l of lines) {
+			const m = l.match(/^(\s+)\S+/);
+			if (m) {
+				const indent = m[1].length;
+				if (!mindent) mindent = indent;
+				else mindent = Math.min(mindent, indent);
+			}
+		}
+		if (mindent !== null) {
+			const m = mindent;
+			result = lines.map((l) => l[0] === " " || l[0] === "	" ? l.slice(m) : l).join("\n");
+		}
+		if (trimWhitespace) result = result.trim();
+		if (escapeSpecialCharacters) result = result.replace(/\\n/g, "\n");
+		return result;
+	}
+}
+function getCurrentIndent(str) {
+	const lines = str.split("\n");
+	const lastLine = lines[lines.length - 1];
+	if (!lastLine) return "";
+	const match = lastLine.match(/^(\s*)/);
+	return match ? match[1] : "";
+}
+
+//#endregion
+//#region node_modules/.pnpm/@ls-stack+utils@3.68.0/node_modules/@ls-stack/utils/dist/stringUtils-DEEj_Z1p.mjs
+function removeANSIColors(str) {
+	return str.replace(/\u001b\[\d+m/g, "");
+}
+
+//#endregion
+//#region node_modules/.pnpm/@ls-stack+utils@3.68.0/node_modules/@ls-stack/utils/dist/typingFnUtils-BLxmDUp5.mjs
+/**
+* A wrapper to Object.entries with a better typing inference
+*
+* @param obj
+*/
+function typedObjectEntries(obj) {
+	return Object.entries(obj);
+}
+/**
+* Type helper to narrow a string to a key of an object.
+*
+* @param key
+* @param obj
+*/
+function isObjKey(key, obj) {
+	return typeof key === "string" && key in obj;
+}
+
+//#endregion
+//#region src/createCli.ts
+const [, , cmdFromTerminal, ...cmdArgs] = process.argv;
+/**
+* Creates a type-safe command definition for use with `createCLI`.
+*
+* The `run` function receives fully typed arguments based on the `args` definition.
+* Positional arguments are parsed in declaration order.
+*
+* @template Args - Record of argument definitions
+* @param options - Command configuration
+* @param options.description - Command description shown in help
+* @param options.short - Optional single-character alias (cannot be 'i' or 'h')
+* @param options.args - Typed argument definitions
+* @param options.run - Handler function receiving parsed arguments
+* @param options.examples - Optional usage examples for help text
+* @returns Command definition object
+*
+* @example
+* ```ts
+* const deploy = createCmd({
+*   short: 'd',
+*   description: 'Deploy the application',
+*   args: {
+*     env: {
+*       type: 'positional-string',
+*       name: 'env',
+*       description: 'Target environment',
+*     },
+*     port: {
+*       type: 'value-number-flag',
+*       name: 'port',
+*       description: 'Port number',
+*       default: 3000,
+*     },
+*     verbose: {
+*       type: 'flag',
+*       name: 'verbose',
+*       description: 'Enable verbose logging',
+*     },
+*   },
+*   examples: [
+*     { args: ['production'], description: 'Deploy to production' },
+*     { args: ['staging', '--port', '8080'], description: 'Deploy to staging on port 8080' },
+*   ],
+*   run: async ({ env, port, verbose }) => {
+*     // env: string, port: number, verbose: boolean
+*     console.log(`Deploying to ${env} on port ${port}`);
+*   },
+* });
+* ```
+*/
+function createCmd({ short, description, run, args, examples }) {
+	return {
+		short,
+		description,
+		run,
+		args,
+		examples
+	};
+}
+/**
+* Creates and runs a CLI application with the given commands.
+*
+* Automatically handles argument parsing, help generation, and interactive mode.
+*
+* **Built-in commands:**
+* - `h` or `--help` - Shows help with all commands
+* - `i` - Interactive mode (select command from list)
+* - `<command> -h` - Shows help for a specific command
+*
+* @template C - String literal union of command names
+* @param options - CLI configuration
+* @param options.name - CLI display name shown in header
+* @param options.baseCmd - Command prefix for help text (e.g., 'my-cli')
+* @param options.sort - Optional array to customize command display order
+* @param cmds - Record of command definitions created with `createCmd`
+*
+* @example
+* ```ts
+* await createCLI(
+*   { name: 'My CLI', baseCmd: 'my-cli' },
+*   {
+*     hello: createCmd({
+*       short: 'hi',
+*       description: 'Say hello',
+*       run: async () => console.log('Hello!'),
+*     }),
+*     deploy: createCmd({
+*       short: 'd',
+*       description: 'Deploy the app',
+*       args: {
+*         env: { type: 'positional-string', name: 'env', description: 'Environment' },
+*       },
+*       run: async ({ env }) => console.log(`Deploying to ${env}`),
+*     }),
+*   },
+* );
+* ```
+*
+* @example
+* ```bash
+* # Usage examples:
+* my-cli              # Show interactive menu
+* my-cli h            # Show help
+* my-cli i            # Interactive mode
+* my-cli hello        # Run hello command
+* my-cli hi           # Run hello via short alias
+* my-cli deploy prod  # Run deploy with argument
+* my-cli deploy -h    # Show deploy command help
+* ```
+*/
+async function createCLI({ name, sort, baseCmd }, cmds) {
+	function getCmdId(cmd) {
+		if (isObjKey(cmd, cmds)) return cmd;
+		console.error(styleText(["red", "bold"], `Command '${cmd}' not found`));
+		process.exit(1);
+	}
+	process.stdout.write("\x1Bc");
+	console.info(styleText(["blue", "bold"], name));
+	const addedShortCmds = /* @__PURE__ */ new Set();
+	const reservedShortCmds = ["i", "h"];
+	let runCmdId = cmdFromTerminal;
+	for (const [, cmd] of typedObjectEntries(cmds)) if (cmd.short) {
+		if (reservedShortCmds.includes(cmd.short)) {
+			console.error(styleText(["red", "bold"], `Short cmd "${cmd.short}" is reserved for built-in commands`));
+			process.exit(1);
+		}
+		if (addedShortCmds.has(cmd.short)) {
+			console.error(styleText(["red", "bold"], `Short cmd "${cmd.short}" is duplicated`));
+			process.exit(1);
+		}
+		addedShortCmds.add(cmd.short);
+	}
+	function printHelp() {
+		const pipeChar = styleText(["dim"], " or ");
+		const fmtCmd = (c) => styleText(["blue", "bold"], c);
+		const beforeDescription = styleText(["dim"], "->");
+		const largestCmdTextLength = Math.max(...typedObjectEntries(cmds).map(([cmd, { short }]) => `${cmd}${short ? ` or ${short}` : ""}`.length));
+		console.info(dedent`
+      ${styleText(["blue", "bold"], "Docs:")}
+
+      ${styleText(["bold", "underline"], "Usage:")} ${baseCmd} <command> [command-args...]
+
+      ${styleText(["bold", "underline"], "Commands:")}
+
+      ${typedObjectEntries(cmds).map(([cmd, { description, short, args }]) => {
+			const cmdText = `${fmtCmd(cmd)}${short ? `${pipeChar}${fmtCmd(short)}` : ""}`;
+			const unformattedCmdText = removeANSIColors(cmdText);
+			let result = `${cmdText}${" ".repeat(largestCmdTextLength - unformattedCmdText.length + 1)}${beforeDescription} ${description}`;
+			if (args && Object.keys(args).length > 0) {
+				const briefArgs = typedObjectEntries(args).sort(([, a], [, b]) => {
+					if (a.type.startsWith("positional") && !b.type.startsWith("positional")) return -1;
+					if (!a.type.startsWith("positional") && b.type.startsWith("positional")) return 1;
+					return 0;
+				}).map(([, arg]) => {
+					switch (arg.type) {
+						case "positional-string":
+						case "positional-number": return `[${arg.name}]`;
+						case "flag": return `[--${arg.name}]`;
+						case "value-string-flag":
+						case "value-number-flag": return `[--${arg.name}]`;
+						default: throw exhaustiveCheck(arg);
+					}
+				}).join(" ");
+				result += `\n${styleText(["dim"], ` └─ args: ${briefArgs}`)}`;
+			}
+			return result;
+		}).join("\n")}
+
+      ${styleText(["dim"], `Use ${baseCmd} <cmd> -h for more details about a command`)}
+
+      ${fmtCmd("i")} ${beforeDescription} Starts in interactive mode
+      ${fmtCmd("h")} ${beforeDescription} Prints this help message
+    `);
+		console.info(styleText(["dim"], "Use a command to get started!"));
+	}
+	function printCmdHelp(cmdId) {
+		const cmd = cmds[getCmdId(cmdId)];
+		function formatArg(arg) {
+			switch (arg.type) {
+				case "positional-string":
+				case "positional-number": return `[${arg.name}]`;
+				case "flag": return `[--${arg.name}]`;
+				case "value-string-flag": return `[--${arg.name} <value>]`;
+				case "value-number-flag": return `[--${arg.name} <number>]`;
+				default: throw exhaustiveCheck(arg);
+			}
+		}
+		function getArgsUsage(args) {
+			if (!args) return "";
+			const sortedArgs = typedObjectEntries(args).sort(([, a], [, b]) => {
+				if (a.type.startsWith("positional") && !b.type.startsWith("positional")) return -1;
+				if (!a.type.startsWith("positional") && b.type.startsWith("positional")) return 1;
+				return 0;
+			});
+			const colors = [
+				"cyan",
+				"yellow",
+				"magenta",
+				"blue",
+				"green",
+				"red"
+			];
+			return sortedArgs.map(([, arg], index) => {
+				const color = colors[index % colors.length];
+				if (!color) return formatArg(arg);
+				return styleText([color], formatArg(arg)) || formatArg(arg);
+			}).join(" ");
+		}
+		const cmdTitle = cmd.short ? `${cmdId} (${cmd.short})` : cmdId;
+		let helpText = `${styleText(["blue", "bold"], `${cmdTitle}:`) || `${cmdTitle}:`} ${cmd.description}\n\n${styleText(["bold", "underline"], "Usage:") || "Usage:"} ${styleText(["dim"], baseCmd) || baseCmd} ${styleText(["bold"], cmdId) || cmdId}`;
+		if (cmd.args) {
+			const argsUsage = getArgsUsage(cmd.args);
+			if (argsUsage) helpText += ` ${argsUsage}`;
+		}
+		if (cmd.short) helpText += `\n       ${styleText(["dim"], baseCmd) || baseCmd} ${styleText(["bold"], cmd.short) || cmd.short} ...`;
+		if (cmd.args) {
+			const argEntries = typedObjectEntries(cmd.args);
+			if (argEntries.length > 0) {
+				helpText += `\n\n${styleText(["bold", "underline"], "Arguments:") || "Arguments:"}`;
+				const colors = [
+					"cyan",
+					"yellow",
+					"magenta",
+					"blue",
+					"green",
+					"red"
+				];
+				for (const [index, [, arg]] of argEntries.entries()) {
+					const color = colors[index % colors.length];
+					if (!color) continue;
+					const argDisplayName = arg.type === "flag" ? `--${arg.name}` : arg.type === "value-string-flag" ? `--${arg.name}` : arg.type === "value-number-flag" ? `--${arg.name}` : arg.name;
+					const argName = styleText([color], argDisplayName) || argDisplayName;
+					helpText += `\n  ${argName} - ${arg.description}`;
+				}
+			}
+		}
+		if (cmd.examples) {
+			helpText += `\n\n${styleText(["bold", "underline"], "Examples:") || "Examples:"}`;
+			for (const { args: exampleArgs, description: exampleDesc } of cmd.examples) helpText += `\n  ${baseCmd} ${cmdId} ${exampleArgs.join(" ")} ${styleText(["dim"], `# ${exampleDesc}`) || `# ${exampleDesc}`}`;
+		}
+		console.info(helpText);
+		console.info(styleText(["dim"], "Use a command to get started!"));
+	}
+	if (!cmdFromTerminal) if (await cliInput.select("Choose an action", { options: [{
+		value: "run-cmd",
+		label: "Start interactive mode",
+		hint: `Select a command to run from a list | ${baseCmd} i`
+	}, {
+		value: "print-help",
+		label: "Print help",
+		hint: `${baseCmd} h`
+	}] }) === "print-help") {
+		printHelp();
+		process.exit(0);
+	} else runCmdId = "i";
+	if (runCmdId === "-h" || runCmdId === "--help" || runCmdId === "help" || runCmdId === "h") {
+		printHelp();
+		process.exit(0);
+	}
+	function parseArgs(rawArgs, commandArgs) {
+		if (!commandArgs) return {};
+		const parsed = {};
+		const argEntries = typedObjectEntries(commandArgs);
+		for (const [key, argDef] of argEntries) if (argDef.type === "flag") parsed[key] = false;
+		else if ("default" in argDef && argDef.default !== void 0) parsed[key] = argDef.default;
+		const positionalArgs = argEntries.filter(([, argDef]) => argDef.type.startsWith("positional"));
+		let positionalIndex = 0;
+		let i = 0;
+		while (i < rawArgs.length) {
+			const currentArg = rawArgs[i];
+			if (currentArg?.startsWith("--")) {
+				const flagName = currentArg.slice(2);
+				const flagEntry = argEntries.find(([, argDef]) => argDef.name === flagName);
+				if (flagEntry) {
+					const [key, argDef] = flagEntry;
+					if (argDef.type === "flag") {
+						parsed[key] = true;
+						i++;
+					} else if (argDef.type === "value-string-flag" || argDef.type === "value-number-flag") {
+						const value = rawArgs[i + 1];
+						if (value && !value.startsWith("--")) {
+							if (argDef.type === "value-number-flag") {
+								const numValue = Number(value);
+								if (isNaN(numValue)) {
+									console.error(styleText(["red", "bold"], `Error: Invalid number "${value}" for --${argDef.name}`));
+									process.exit(1);
+								}
+								parsed[key] = numValue;
+							} else parsed[key] = value;
+							i += 2;
+						} else {
+							console.error(styleText(["red", "bold"], `Error: Missing value for --${argDef.name}`));
+							process.exit(1);
+						}
+					} else i++;
+				} else {
+					console.error(styleText(["red", "bold"], `Error: Unknown flag --${flagName}`));
+					process.exit(1);
+				}
+			} else {
+				if (positionalIndex < positionalArgs.length) {
+					const positionalEntry = positionalArgs[positionalIndex];
+					if (positionalEntry) {
+						const [key, argDef] = positionalEntry;
+						if (argDef.type === "positional-number") {
+							const numValue = Number(currentArg);
+							if (isNaN(numValue)) {
+								console.error(styleText(["red", "bold"], `Error: Invalid number "${currentArg}" for ${argDef.name}`));
+								process.exit(1);
+							}
+							parsed[key] = numValue;
+						} else parsed[key] = currentArg;
+						positionalIndex++;
+					}
+				}
+				i++;
+			}
+		}
+		for (const [key, argDef] of positionalArgs) if (!("default" in argDef) && parsed[key] === void 0) {
+			console.error(styleText(["red", "bold"], `Error: Missing required argument <${argDef.name}>`));
+			process.exit(1);
+		}
+		return parsed;
+	}
+	async function runCmd(cmd, args) {
+		process.stdout.write("\x1Bc");
+		for (const [cmdId, { short, run: fn, args: commandArgs }] of typedObjectEntries(cmds)) if (cmd === short || cmd === cmdId) {
+			if (args.includes("-h") || args.includes("--help")) {
+				printCmdHelp(cmdId);
+				process.exit(0);
+			}
+			console.info(`Running ${styleText(["blue", "bold"], cmdId)}${short ? styleText(["dim"], `|${short}`) : ""}:\n`);
+			await fn(parseArgs(args, commandArgs));
+			process.exit(0);
+		}
+		console.error(styleText(["red", "bold"], `Command '${cmd}' not found`));
+		printHelp();
+		process.exit(1);
+	}
+	if (runCmdId === "i") {
+		function hasRequiredArgs(args) {
+			if (!args) return false;
+			return typedObjectEntries(args).some(([, arg]) => (arg.type === "positional-string" || arg.type === "positional-number") && !("default" in arg));
+		}
+		let cmdEntries = typedObjectEntries(cmds);
+		if (sort) cmdEntries = sortBy(cmdEntries, ([cmd]) => getAscIndexOrder(sort.indexOf(cmd)));
+		const availableCmds = cmdEntries.filter(([, cmd]) => !hasRequiredArgs(cmd.args));
+		await runCmd(await cliInput.select("Select a command", { options: availableCmds.map(([cmd, { short, description }]) => ({
+			value: cmd,
+			label: short ? `${cmd} ${styleText(["dim"], "|")} ${short}` : cmd,
+			hint: description
+		})) }), []);
+	} else {
+		if (!runCmdId) {
+			console.error(styleText(["red", "bold"], `Command not found, use \`${baseCmd} h\` to list all supported commands`));
+			console.info(styleText(["dim"], "Use a command to get started!"));
+			process.exit(1);
+		}
+		await runCmd(runCmdId, cmdArgs);
+	}
+}
+
+//#endregion
+export { cliInput, createCLI, createCmd };
+//# sourceMappingURL=main.mjs.map