@rune-cli/rune 0.0.9 → 0.0.11

package/dist/cli.mjs

@@ -1,101 +1,247 @@
 #!/usr/bin/env node
-import "./dist-DuisScgY.mjs";
-import { n as isHelpFlag, r as isVersionFlag, t as runManifestCommand } from "./run-manifest-command-BphalAwU.mjs";
+import "./dist-Bpf2xVvb.mjs";
+import { n as isHelpFlag, r as isVersionFlag, t as runManifestCommand } from "./run-manifest-command-DepwxrFI.mjs";
 import { fileURLToPath } from "node:url";
 import { build } from "esbuild";
 import { cp, mkdir, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
 import path from "node:path";
 import ts from "typescript";
 //#region package.json
-var version = "0.0.9";
+var version = "0.0.11";
 //#endregion
-//#region src/manifest/generate-manifest.ts
-const COMMAND_ENTRY_FILE = "index.ts";
-function comparePathSegments(left, right) {
-	const length = Math.min(left.length, right.length);
-	for (let index = 0; index < length; index += 1) {
-		const comparison = left[index].localeCompare(right[index]);
-		if (comparison !== 0) return comparison;
-	}
-	return left.length - right.length;
-}
+//#region src/manifest/generate/extract-description.ts
 function getPropertyNameText(name) {
 	if (ts.isIdentifier(name) || ts.isStringLiteral(name)) return name.text;
 }
-function getStaticDescriptionValue(expression) {
+function getStaticStringValue(expression) {
 	if (ts.isStringLiteral(expression) || ts.isNoSubstitutionTemplateLiteral(expression)) return expression.text;
 }
+function getStaticStringArrayValue(expression) {
+	if (!ts.isArrayLiteralExpression(expression)) return;
+	const values = [];
+	for (const element of expression.elements) {
+		const value = getStaticStringValue(element);
+		if (value === void 0) return;
+		values.push(value);
+	}
+	return values;
+}
+function resolveExpression(expression, sourceFile) {
+	if (ts.isIdentifier(expression)) return findVariableInitializer(sourceFile, expression.text) ?? expression;
+	return expression;
+}
 function isDefineCommandExpression(expression) {
-	if (ts.isIdentifier(expression)) return expression.text === "defineCommand";
-	if (ts.isPropertyAccessExpression(expression)) return expression.name.text === "defineCommand";
-	return false;
+	return isNamedCallExpression(expression, "defineCommand");
 }
-function extractDescriptionFromCommandDefinition(expression, knownDescriptions) {
-	if (ts.isIdentifier(expression)) return knownDescriptions.get(expression.text);
-	if (!ts.isCallExpression(expression) || !isDefineCommandExpression(expression.expression)) return;
+function isDefineGroupExpression(expression) {
+	return isNamedCallExpression(expression, "defineGroup");
+}
+function isDefineCallExpression(expression) {
+	return ts.isCallExpression(expression) && (isDefineCommandExpression(expression.expression) || isDefineGroupExpression(expression.expression));
+}
+function extractMetadataFromCommandDefinition(expression, sourceFile, knownMetadata) {
+	if (ts.isIdentifier(expression)) return knownMetadata.get(expression.text);
+	if (!ts.isCallExpression(expression) || !isDefineCallExpression(expression)) return;
 	const [definition] = expression.arguments;
 	if (!definition || !ts.isObjectLiteralExpression(definition)) return;
+	let description;
+	let aliases = [];
 	for (const property of definition.properties) {
+		if (ts.isShorthandPropertyAssignment(property)) {
+			const propertyName = property.name.text;
+			const resolved = resolveExpression(property.name, sourceFile);
+			if (propertyName === "description") description = getStaticStringValue(resolved);
+			else if (propertyName === "aliases") {
+				const extracted = getStaticStringArrayValue(resolved);
+				if (extracted === void 0) throw new Error("Could not statically analyze aliases. Aliases must be an inline array of string literals (e.g. aliases: [\"d\"]).");
+				aliases = extracted;
+			}
+			continue;
+		}
 		if (!ts.isPropertyAssignment(property)) continue;
-		if (getPropertyNameText(property.name) !== "description") continue;
-		return getStaticDescriptionValue(property.initializer);
+		const propertyName = getPropertyNameText(property.name);
+		const resolved = resolveExpression(property.initializer, sourceFile);
+		if (propertyName === "description") description = getStaticStringValue(resolved);
+		else if (propertyName === "aliases") {
+			const extracted = getStaticStringArrayValue(resolved);
+			if (extracted === void 0) throw new Error("Could not statically analyze aliases. Aliases must be an inline array of string literals (e.g. aliases: [\"d\"]).");
+			aliases = extracted;
+		}
 	}
+	return {
+		description,
+		aliases
+	};
+}
+function findVariableInitializer(sourceFile, name) {
+	for (const statement of sourceFile.statements) {
+		if (!ts.isVariableStatement(statement)) continue;
+		for (const declaration of statement.declarationList.declarations) if (ts.isIdentifier(declaration.name) && declaration.name.text === name && declaration.initializer) return declaration.initializer;
+	}
+}
+function isNamedCallExpression(expression, name) {
+	if (ts.isIdentifier(expression)) return expression.text === name;
+	if (ts.isPropertyAccessExpression(expression)) return expression.name.text === name;
+	return false;
 }
-async function extractDescriptionFromSourceFile(sourceFilePath) {
+async function extractMetadataFromSourceFile(sourceFilePath) {
 	const sourceText = await readFile(sourceFilePath, "utf8");
 	const sourceFile = ts.createSourceFile(sourceFilePath, sourceText, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
-	const knownDescriptions = /* @__PURE__ */ new Map();
+	const knownMetadata = /* @__PURE__ */ new Map();
 	for (const statement of sourceFile.statements) {
 		if (ts.isVariableStatement(statement)) {
 			for (const declaration of statement.declarationList.declarations) {
 				if (!ts.isIdentifier(declaration.name) || !declaration.initializer) continue;
-				knownDescriptions.set(declaration.name.text, extractDescriptionFromCommandDefinition(declaration.initializer, knownDescriptions));
+				knownMetadata.set(declaration.name.text, extractMetadataFromCommandDefinition(declaration.initializer, sourceFile, knownMetadata));
 			}
 			continue;
 		}
-		if (ts.isExportAssignment(statement)) return extractDescriptionFromCommandDefinition(statement.expression, knownDescriptions);
+		if (ts.isExportAssignment(statement)) return extractMetadataFromCommandDefinition(statement.expression, sourceFile, knownMetadata);
 	}
 }
-async function walkCommandsDirectory(absoluteDirectoryPath, pathSegments, extractDescription) {
+//#endregion
+//#region src/manifest/generate/validate-group-meta.ts
+async function validateGroupMetaFile(sourceFilePath) {
+	const sourceText = await readFile(sourceFilePath, "utf8");
+	const sourceFile = ts.createSourceFile(sourceFilePath, sourceText, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+	for (const statement of sourceFile.statements) {
+		if (ts.isVariableStatement(statement) || ts.isImportDeclaration(statement)) continue;
+		if (ts.isExportAssignment(statement)) {
+			const expression = ts.isIdentifier(statement.expression) ? findVariableInitializer(sourceFile, statement.expression.text) : statement.expression;
+			if (expression && ts.isCallExpression(expression) && isDefineGroupExpression(expression.expression)) return;
+			throw new Error(`${sourceFilePath}: _group.ts must use "export default defineGroup(...)". Found a default export that is not a defineGroup() call.`);
+		}
+	}
+	throw new Error(`${sourceFilePath}: _group.ts must have a default export using defineGroup().`);
+}
+//#endregion
+//#region src/manifest/generate/walk-commands-directory.ts
+const COMMAND_ENTRY_FILE = "index.ts";
+const GROUP_META_FILE = "_group.ts";
+const BARE_COMMAND_EXTENSION = ".ts";
+const DECLARATION_FILE_SUFFIXES = [
+	".d.ts",
+	".d.mts",
+	".d.cts"
+];
+function comparePathSegments(left, right) {
+	const length = Math.min(left.length, right.length);
+	for (let index = 0; index < length; index += 1) {
+		const comparison = left[index].localeCompare(right[index]);
+		if (comparison !== 0) return comparison;
+	}
+	return left.length - right.length;
+}
+function validateSiblingAliases(siblings) {
+	const seen = /* @__PURE__ */ new Map();
+	for (const sibling of siblings) {
+		const existing = seen.get(sibling.name);
+		if (existing !== void 0) throw new Error(`Command name conflict: "${sibling.name}" is already used by "${existing}".`);
+		seen.set(sibling.name, sibling.name);
+		for (const alias of sibling.aliases) {
+			if (alias === sibling.name) throw new Error(`Command alias "${alias}" for "${sibling.name}" is the same as its canonical name.`);
+			const conflicting = seen.get(alias);
+			if (conflicting !== void 0) throw new Error(`Command alias conflict: alias "${alias}" for "${sibling.name}" conflicts with "${conflicting}".`);
+			seen.set(alias, sibling.name);
+		}
+	}
+}
+async function walkCommandsDirectory(absoluteDirectoryPath, pathSegments, extractMetadata) {
 	const entries = await readdir(absoluteDirectoryPath, { withFileTypes: true });
 	const childDirectoryNames = entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort((left, right) => left.localeCompare(right));
 	const childResults = await Promise.all(childDirectoryNames.map(async (directoryName) => {
 		return {
 			directoryName,
-			result: await walkCommandsDirectory(path.join(absoluteDirectoryPath, directoryName), [...pathSegments, directoryName], extractDescription)
+			result: await walkCommandsDirectory(path.join(absoluteDirectoryPath, directoryName), [...pathSegments, directoryName], extractMetadata)
 		};
 	}));
-	const childNodes = childResults.flatMap(({ result }) => result.nodes);
-	const childNames = childResults.filter(({ result }) => result.hasNode).map(({ directoryName }) => directoryName);
+	const bareCommandFiles = entries.filter((entry) => entry.isFile() && entry.name.endsWith(BARE_COMMAND_EXTENSION) && entry.name !== COMMAND_ENTRY_FILE && entry.name !== GROUP_META_FILE && !DECLARATION_FILE_SUFFIXES.some((suffix) => entry.name.endsWith(suffix))).map((entry) => entry.name).sort((left, right) => left.localeCompare(right));
+	const childDirectoriesWithNodes = new Set(childResults.filter(({ result }) => result.hasNode).map(({ directoryName }) => directoryName));
+	const bareCommandNodes = await Promise.all(bareCommandFiles.map(async (fileName) => {
+		const commandName = fileName.slice(0, -3);
+		if (childDirectoriesWithNodes.has(commandName)) throw new Error(`Conflicting command definitions: both "${commandName}${BARE_COMMAND_EXTENSION}" and "${commandName}/" exist. A bare command file cannot coexist with a command directory.`);
+		const sourceFilePath = path.join(absoluteDirectoryPath, fileName);
+		const metadata = await extractMetadata(sourceFilePath);
+		return {
+			pathSegments: [...pathSegments, commandName],
+			kind: "command",
+			sourceFilePath,
+			childNames: [],
+			aliases: metadata?.aliases ?? [],
+			description: metadata?.description
+		};
+	}));
+	const descendantNodes = childResults.flatMap(({ result }) => result.nodes);
+	const childNames = [...childResults.filter(({ result }) => result.hasNode).map(({ directoryName }) => directoryName), ...bareCommandFiles.map((fileName) => fileName.slice(0, -3))].sort((left, right) => left.localeCompare(right));
 	const hasCommandEntry = entries.some((entry) => entry.isFile() && entry.name === COMMAND_ENTRY_FILE);
-	if (!hasCommandEntry && childNames.length === 0) return {
-		nodes: childNodes,
+	const hasGroupMeta = entries.some((entry) => entry.isFile() && entry.name === GROUP_META_FILE);
+	if (hasGroupMeta && hasCommandEntry) throw new Error(`Conflicting definitions: both "${GROUP_META_FILE}" and "${COMMAND_ENTRY_FILE}" exist in the same directory. A directory is either a group (_group.ts) or an executable command (index.ts), not both.`);
+	if (hasGroupMeta && childNames.length === 0) throw new Error(`${path.join(absoluteDirectoryPath, GROUP_META_FILE)}: _group.ts exists but the directory has no subcommands.`);
+	if (!hasCommandEntry && !hasGroupMeta && childNames.length === 0) return {
+		nodes: [...descendantNodes, ...bareCommandNodes],
 		hasNode: false
 	};
 	let node;
 	if (hasCommandEntry) {
 		const sourceFilePath = path.join(absoluteDirectoryPath, COMMAND_ENTRY_FILE);
+		const metadata = await extractMetadata(sourceFilePath);
+		const aliases = metadata?.aliases ?? [];
+		if (aliases.length > 0 && pathSegments.length === 0) throw new Error("Aliases on the root command are not supported. The root command has no parent to resolve aliases against.");
 		node = {
 			pathSegments,
 			kind: "command",
 			sourceFilePath,
 			childNames,
-			description: await extractDescription(sourceFilePath)
+			aliases,
+			description: metadata?.description
 		};
-	} else node = {
-		pathSegments,
-		kind: "group",
-		childNames
-	};
+	} else {
+		const groupMetaPath = path.join(absoluteDirectoryPath, GROUP_META_FILE);
+		if (hasGroupMeta) await validateGroupMetaFile(groupMetaPath);
+		const metadata = hasGroupMeta ? await extractMetadata(groupMetaPath) : void 0;
+		if (hasGroupMeta && !metadata?.description) throw new Error(`${groupMetaPath}: _group.ts must export a defineGroup() call with a non-empty "description" string.`);
+		const aliases = metadata?.aliases ?? [];
+		if (aliases.length > 0 && pathSegments.length === 0) throw new Error("Aliases on the root group are not supported. The root group has no parent to resolve aliases against.");
+		node = {
+			pathSegments,
+			kind: "group",
+			childNames,
+			aliases,
+			...metadata?.description !== void 0 ? { description: metadata.description } : {}
+		};
+	}
+	const siblingEntries = [];
+	for (const childResult of childResults) {
+		if (!childResult.result.hasNode) continue;
+		const childNode = childResult.result.nodes.find((n) => n.pathSegments.length === pathSegments.length + 1 && n.pathSegments[pathSegments.length] === childResult.directoryName);
+		siblingEntries.push({
+			name: childResult.directoryName,
+			aliases: childNode?.aliases ?? []
+		});
+	}
+	for (const bareNode of bareCommandNodes) {
+		const name = bareNode.pathSegments[bareNode.pathSegments.length - 1];
+		siblingEntries.push({
+			name,
+			aliases: bareNode.aliases
+		});
+	}
+	validateSiblingAliases(siblingEntries);
 	return {
-		nodes: [node, ...childNodes],
+		nodes: [
+			node,
+			...descendantNodes,
+			...bareCommandNodes
+		],
 		hasNode: true
 	};
 }
+//#endregion
+//#region src/manifest/generate/generate-manifest.ts
 async function generateCommandManifest(options) {
-	const extractDescription = options.extractDescription ?? extractDescriptionFromSourceFile;
-	const walkResult = await walkCommandsDirectory(options.commandsDirectory, [], extractDescription);
-	if (walkResult.nodes.length === 0) throw new Error("No commands found in src/commands/. Create a command file like src/commands/hello/index.ts");
+	const extractMetadata = options.extractMetadata ?? extractMetadataFromSourceFile;
+	const walkResult = await walkCommandsDirectory(options.commandsDirectory, [], extractMetadata);
+	if (walkResult.nodes.length === 0) throw new Error("No commands found in src/commands/. Create a command file like src/commands/hello.ts or src/commands/hello/index.ts");
 	return { nodes: [...walkResult.nodes].sort((left, right) => comparePathSegments(left.pathSegments, right.pathSegments)) };
 }
 function serializeCommandManifest(manifest) {
@@ -119,19 +265,20 @@ function resolveCommandsDirectory(projectRoot) {
 function resolveDistDirectory(projectRoot) {
 	return path.join(projectRoot, DIST_DIRECTORY_NAME);
 }
+function resolveCliNameFromPackageJson(packageJson) {
+	if (packageJson.bin && typeof packageJson.bin === "object") {
+		const binNames = Object.keys(packageJson.bin).sort((left, right) => left.localeCompare(right));
+		if (binNames.length > 0) return binNames[0];
+	}
+	if (packageJson.name && packageJson.name.length > 0) return packageJson.name.split("/").at(-1) ?? packageJson.name;
+}
 async function readProjectCliInfo(projectRoot) {
 	const packageJsonPath = path.join(projectRoot, "package.json");
 	try {
 		const packageJsonContents = await readFile(packageJsonPath, "utf8");
 		const packageJson = JSON.parse(packageJsonContents);
-		let name;
-		if (packageJson.bin && typeof packageJson.bin === "object") {
-			const binNames = Object.keys(packageJson.bin).sort((left, right) => left.localeCompare(right));
-			if (binNames.length > 0) name = binNames[0];
-		}
-		if (!name && packageJson.name && packageJson.name.length > 0) name = packageJson.name.split("/").at(-1) ?? packageJson.name;
 		return {
-			name: name ?? path.basename(projectRoot),
+			name: resolveCliNameFromPackageJson(packageJson) ?? path.basename(projectRoot),
 			version: packageJson.version
 		};
 	} catch (error) {
@@ -478,6 +625,19 @@ function tryParseProjectOption(argv, index) {
 function getRuneVersion() {
 	return version;
 }
+function renderRuneCliHelp() {
+	return `\
+Usage: rune <command>
+
+Commands:
+  build  Build a Rune project into a distributable CLI
+  dev    Run a Rune project in development mode
+
+Options:
+  -h, --help     Show this help message
+  -V, --version  Show the version number
+`;
+}
 function parseDevArgs(argv) {
 	const commandArgs = [];
 	let projectPath;
@@ -546,18 +706,22 @@ function parseBuildArgs(argv) {
 		projectPath
 	};
 }
-function renderRuneCliHelp() {
-	return `\
-Usage: rune <command>
-
-Commands:
-  build  Build a Rune project into a distributable CLI
-  dev    Run a Rune project in development mode
-
-Options:
-  -h, --help     Show this help message
-  -V, --version  Show the version number
-`;
+async function runDevSubcommand(options, restArgs) {
+	const parsedDevArgs = parseDevArgs(restArgs);
+	if (!parsedDevArgs.ok) return writeEarlyExit(parsedDevArgs);
+	return runDevCommand({
+		rawArgs: parsedDevArgs.commandArgs,
+		projectPath: parsedDevArgs.projectPath,
+		cwd: options.cwd
+	});
+}
+async function runBuildSubcommand(options, restArgs) {
+	const parsedBuildArgs = parseBuildArgs(restArgs);
+	if (!parsedBuildArgs.ok) return writeEarlyExit(parsedBuildArgs);
+	return runBuildCommand({
+		projectPath: parsedBuildArgs.projectPath,
+		cwd: options.cwd
+	});
 }
 async function runRuneCli(options) {
 	const [subcommand, ...restArgs] = options.argv;
@@ -569,23 +733,8 @@ async function runRuneCli(options) {
 		await writeStdout(`rune v${getRuneVersion()}\n`);
 		return 0;
 	}
-	if (subcommand === "dev") {
-		const parsedDevArgs = parseDevArgs(restArgs);
-		if (!parsedDevArgs.ok) return writeEarlyExit(parsedDevArgs);
-		return runDevCommand({
-			rawArgs: parsedDevArgs.commandArgs,
-			projectPath: parsedDevArgs.projectPath,
-			cwd: options.cwd
-		});
-	}
-	if (subcommand === "build") {
-		const parsedBuildArgs = parseBuildArgs(restArgs);
-		if (!parsedBuildArgs.ok) return writeEarlyExit(parsedBuildArgs);
-		return runBuildCommand({
-			projectPath: parsedBuildArgs.projectPath,
-			cwd: options.cwd
-		});
-	}
+	if (subcommand === "dev") return runDevSubcommand(options, restArgs);
+	if (subcommand === "build") return runBuildSubcommand(options, restArgs);
 	await writeStderrLine(`Unknown command: ${subcommand}. Available commands: build, dev`);
 	return 1;
 }

package/dist/{dist-DuisScgY.mjs → dist-Bpf2xVvb.mjs}

@@ -1,11 +1,12 @@
-import { format, parseArgs } from "node:util";
+import { parseArgs } from "node:util";
 //#region ../core/dist/index.mjs
 function isSchemaField(field) {
 	return "schema" in field && field.schema !== void 0;
 }
 const DEFINED_COMMAND_BRAND = Symbol.for("@rune-cli/defined-command");
 const OPTION_NAME_RE = /^[A-Za-z][A-Za-z0-9]*(?:-[A-Za-z0-9]+)*$/;
-const ALIAS_RE = /^[a-zA-Z]$/;
+const OPTION_SHORT_RE = /^[a-zA-Z]$/;
+const COMMAND_ALIAS_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 function validateFieldShape(fields, kind) {
 	for (const field of fields) {
 		const raw = field;
@@ -23,13 +24,21 @@ function validateUniqueFieldNames(fields, kind) {
 function validateOptionNames(options) {
 	for (const field of options) if (!OPTION_NAME_RE.test(field.name)) throw new Error(`Invalid option name "${field.name}". Option names must start with a letter and contain only letters, numbers, and internal hyphens.`);
 }
-function validateOptionAliases(options) {
+function validateOptionShortNames(options) {
 	const seen = /* @__PURE__ */ new Set();
 	for (const field of options) {
-		if (field.alias === void 0) continue;
-		if (!ALIAS_RE.test(field.alias)) throw new Error(`Invalid alias "${field.alias}" for option "${field.name}". Alias must be a single letter.`);
-		if (seen.has(field.alias)) throw new Error(`Duplicate alias "${field.alias}" for option "${field.name}".`);
-		seen.add(field.alias);
+		if (field.short === void 0) continue;
+		if (!OPTION_SHORT_RE.test(field.short)) throw new Error(`Invalid short name "${field.short}" for option "${field.name}". Short name must be a single letter.`);
+		if (seen.has(field.short)) throw new Error(`Duplicate short name "${field.short}" for option "${field.name}".`);
+		seen.add(field.short);
+	}
+}
+function validateCommandAliases(aliases) {
+	const seen = /* @__PURE__ */ new Set();
+	for (const alias of aliases) {
+		if (!COMMAND_ALIAS_RE.test(alias)) throw new Error(`Invalid command alias "${alias}". Aliases must be lowercase kebab-case (letters, digits, and internal hyphens).`);
+		if (seen.has(alias)) throw new Error(`Duplicate command alias "${alias}".`);
+		seen.add(alias);
 	}
 }
 function isOptionalArg(field) {
@@ -59,7 +68,7 @@ function validateArgOrdering(args) {
 *     { name: "name", type: "string", required: true },
 *   ],
 *   options: [
-*     { name: "loud", type: "boolean", alias: "l" },
+*     { name: "loud", type: "boolean", short: "l" },
 *   ],
 *   run(ctx) {
 *     const greeting = `Hello, ${ctx.args.name}!`;
@@ -98,6 +107,7 @@ function validateArgOrdering(args) {
 */
 function defineCommand(input) {
 	if (typeof input.run !== "function") throw new Error("defineCommand() requires a \"run\" function.");
+	if (input.aliases) validateCommandAliases(input.aliases);
 	if (input.args) {
 		validateFieldShape(input.args, "argument");
 		validateUniqueFieldNames(input.args, "argument");
@@ -107,10 +117,11 @@ function defineCommand(input) {
 		validateFieldShape(input.options, "option");
 		validateUniqueFieldNames(input.options, "option");
 		validateOptionNames(input.options);
-		validateOptionAliases(input.options);
+		validateOptionShortNames(input.options);
 	}
 	const command = {
 		description: input.description,
+		aliases: input.aliases ?? [],
 		args: input.args ?? [],
 		options: input.options ?? [],
 		run: input.run
@@ -124,17 +135,49 @@ function defineCommand(input) {
 function isDefinedCommand(value) {
 	return typeof value === "object" && value !== null && value[DEFINED_COMMAND_BRAND] === true;
 }
+const DEFINED_GROUP_BRAND = Symbol.for("@rune-cli/defined-group");
+/**
+* Defines metadata for a command group (a directory that only groups
+* subcommands without being executable itself).
+*
+* Place the default export of this function in a `_group.ts` file inside a
+* command directory.
+*
+* @example
+* ```ts
+* // src/commands/project/_group.ts
+* export default defineGroup({
+*   description: "Manage projects",
+* });
+* ```
+*/
+function defineGroup(input) {
+	if (typeof input.description !== "string" || input.description.length === 0) throw new Error("defineGroup() requires a non-empty \"description\" string.");
+	if (input.aliases) validateCommandAliases(input.aliases);
+	const group = {
+		description: input.description,
+		aliases: input.aliases ?? []
+	};
+	Object.defineProperty(group, DEFINED_GROUP_BRAND, {
+		value: true,
+		enumerable: false
+	});
+	return group;
+}
 function formatExecutionError(error) {
 	if (error instanceof Error) return error.message === "" ? "" : error.message || error.name || "Unknown error";
 	if (typeof error === "string") return error;
 	return "Unknown error";
 }
+function createExecutionOptions(command, input) {
+	const options = { ...input.options };
+	for (const field of command.options) if (options[field.name] === void 0 && !isSchemaField(field) && field.type === "boolean") options[field.name] = false;
+	return options;
+}
 async function executeCommand(command, input = {}) {
 	try {
-		const options = { ...input.options };
-		for (const field of command.options) if (options[field.name] === void 0 && !isSchemaField(field) && field.type === "boolean") options[field.name] = false;
 		await command.run({
-			options,
+			options: createExecutionOptions(command, input),
 			args: input.args ?? {},
 			cwd: input.cwd ?? process.cwd(),
 			rawArgs: input.rawArgs ?? []
@@ -148,62 +191,6 @@ async function executeCommand(command, input = {}) {
 		} : { exitCode: 1 };
 	}
 }
-async function captureProcessOutput(action) {
-	const stdoutChunks = [];
-	const stderrChunks = [];
-	const originalStdoutWrite = process.stdout.write.bind(process.stdout);
-	const originalStderrWrite = process.stderr.write.bind(process.stderr);
-	const originalConsoleMethods = {
-		log: console.log,
-		info: console.info,
-		debug: console.debug,
-		warn: console.warn,
-		error: console.error
-	};
-	const captureChunk = (chunks, chunk, encoding) => {
-		if (typeof chunk === "string") {
-			chunks.push(chunk);
-			return;
-		}
-		chunks.push(Buffer.from(chunk).toString(encoding));
-	};
-	const captureConsole = (chunks, args) => {
-		chunks.push(`${format(...args)}\n`);
-	};
-	const createWriteCapture = (chunks) => ((chunk, encoding, cb) => {
-		captureChunk(chunks, chunk, typeof encoding === "string" ? encoding : void 0);
-		if (typeof encoding === "function") encoding(null);
-		else cb?.(null);
-		return true;
-	});
-	process.stdout.write = createWriteCapture(stdoutChunks);
-	process.stderr.write = createWriteCapture(stderrChunks);
-	for (const method of [
-		"log",
-		"info",
-		"debug"
-	]) console[method] = (...args) => captureConsole(stdoutChunks, args);
-	for (const method of ["warn", "error"]) console[method] = (...args) => captureConsole(stderrChunks, args);
-	try {
-		return {
-			ok: true,
-			value: await action(),
-			stdout: stdoutChunks.join(""),
-			stderr: stderrChunks.join("")
-		};
-	} catch (error) {
-		return {
-			ok: false,
-			error,
-			stdout: stdoutChunks.join(""),
-			stderr: stderrChunks.join("")
-		};
-	} finally {
-		process.stdout.write = originalStdoutWrite;
-		process.stderr.write = originalStderrWrite;
-		Object.assign(console, originalConsoleMethods);
-	}
-}
 function formatTypeHint(field) {
 	return isSchemaField(field) ? "" : ` <${field.type}>`;
 }
@@ -377,9 +364,9 @@ function getOptionParseType(field) {
 }
 function buildParseArgsOptions(options) {
 	const config = {};
-	for (const field of options) config[field.name] = field.alias ? {
+	for (const field of options) config[field.name] = field.short ? {
 		type: getOptionParseType(field),
-		short: field.alias
+		short: field.short
 	} : { type: getOptionParseType(field) };
 	return config;
 }
@@ -395,7 +382,7 @@ function detectDuplicateOption(options, tokens) {
 		}
 	}
 }
-async function parseCommand(command, rawArgs) {
+async function parseCommandArgs(command, rawArgs) {
 	let parsed;
 	try {
 		parsed = parseArgs({
@@ -442,4 +429,4 @@ async function parseCommand(command, rawArgs) {
 	};
 }
 //#endregion
-export { isSchemaField as a, isDefinedCommand as i, defineCommand as n, parseCommand as o, executeCommand as r, captureProcessOutput as t };
+export { isSchemaField as a, isDefinedCommand as i, defineGroup as n, parseCommandArgs as o, executeCommand as r, defineCommand as t };