alepha 0.12.1 → 0.13.1

package/dist/command/index.cjs

@@ -1,693 +0,0 @@
-//#region rolldown:runtime
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") {
-		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-			key = keys[i];
-			if (!__hasOwnProp.call(to, key) && key !== except) {
-				__defProp(to, key, {
-					get: ((k) => from[k]).bind(null, key),
-					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-				});
-			}
-		}
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-
-//#endregion
-let alepha = require("alepha");
-let node_process = require("node:process");
-let node_readline_promises = require("node:readline/promises");
-let alepha_logger = require("alepha/logger");
-let alepha_datetime = require("alepha/datetime");
-let node_child_process = require("node:child_process");
-let node_fs_promises = require("node:fs/promises");
-node_fs_promises = __toESM(node_fs_promises);
-
-//#region src/command/descriptors/$command.ts
-/**
-* Declares a CLI command.
-*
-* This descriptor allows you to define a command, its flags, and its handler
-* within your Alepha application structure.
-*/
-const $command = (options) => (0, alepha.createDescriptor)(CommandDescriptor, options);
-var CommandDescriptor = class extends alepha.Descriptor {
-	flags = this.options.flags ?? alepha.t.object({});
-	aliases = this.options.aliases ?? [];
-	get name() {
-		if (this.options.root) return "";
-		return this.options.name ?? `${this.config.propertyKey}`;
-	}
-};
-$command[alepha.KIND] = CommandDescriptor;
-
-//#endregion
-//#region src/command/helpers/Asker.ts
-var Asker = class {
-	log = (0, alepha_logger.$logger)();
-	ask;
-	alepha = (0, alepha.$inject)(alepha.Alepha);
-	constructor() {
-		this.ask = this.createAskMethod();
-	}
-	createAskMethod() {
-		const askFn = async (question, options = {}) => {
-			return await this.prompt(question, options);
-		};
-		return askFn;
-	}
-	async prompt(question, options) {
-		const rl = this.createPromptInterface();
-		let value;
-		try {
-			do
-				try {
-					const answer = await rl.question(`${question}\n> `);
-					if (options.schema) value = this.alepha.codec.decode(options.schema, answer ? answer.trim() : void 0);
-					else value = String(answer.trim());
-					if (options.validate) options.validate(value);
-				} catch (error) {
-					if (error instanceof alepha.AlephaError) {
-						this.log.error(`${error.message}\n`);
-						value = void 0;
-					} else throw error;
-				}
-			while (value === void 0);
-		} finally {
-			rl.close();
-		}
-		return value;
-	}
-	createPromptInterface() {
-		return (0, node_readline_promises.createInterface)({
-			input: node_process.stdin,
-			output: node_process.stdout
-		});
-	}
-};
-
-//#endregion
-//#region src/command/helpers/PrettyPrint.ts
-var PrettyPrint = class {
-	dateTimeProvider = (0, alepha.$inject)(alepha_datetime.DateTimeProvider);
-	spinnerInterval;
-	frames = [
-		"⠋",
-		"⠙",
-		"⠹",
-		"⠸",
-		"⠼",
-		"⠴",
-		"⠦",
-		"⠧",
-		"⠇",
-		"⠏"
-	];
-	tasks = /* @__PURE__ */ new Map();
-	lastLineCount = 0;
-	header;
-	commandStartTime;
-	colors = {
-		reset: "\x1B[0m",
-		cyan: "\x1B[36m",
-		green: "\x1B[32m",
-		red: "\x1B[31m",
-		dim: "\x1B[2m"
-	};
-	/**
-	* Start a new command session with header
-	*/
-	startCommand(cliName, commandName) {
-		this.header = commandName ? `${cliName} ${commandName}` : cliName;
-		this.commandStartTime = Date.now();
-		this.tasks.clear();
-		this.lastLineCount = 0;
-		process.stdout.write(`┌─ ${this.header}\n`);
-	}
-	/**
-	* End the command session with footer
-	*/
-	endCommand() {
-		if (this.commandStartTime) {
-			const totalDuration = ((Date.now() - this.commandStartTime) / 1e3).toFixed(1);
-			process.stdout.write(`└─ Done in ${totalDuration}s\n`);
-		}
-		this.header = void 0;
-		this.commandStartTime = void 0;
-	}
-	/**
-	* Start an animated spinner with a task name
-	*/
-	startSpinner(id, taskName) {
-		this.tasks.set(id, {
-			taskName,
-			frameIndex: 0,
-			status: "running"
-		});
-		if (!this.spinnerInterval) this.spinnerInterval = this.dateTimeProvider.createInterval(() => this.updateDisplay(), 80, true);
-		this.updateDisplay();
-	}
-	/**
-	* Stop the spinner and show success with a tick
-	*/
-	success(id, taskName, duration) {
-		const task = this.tasks.get(id);
-		if (task) {
-			task.status = "success";
-			if (taskName) task.taskName = taskName;
-			if (duration) task.duration = duration;
-			this.updateDisplay();
-		}
-		this.checkIfAllDone();
-	}
-	/**
-	* Stop the spinner and show error with a cross
-	*/
-	error(id, taskName) {
-		const task = this.tasks.get(id);
-		if (task) {
-			task.status = "error";
-			if (taskName) task.taskName = taskName;
-			this.updateDisplay();
-		}
-		this.checkIfAllDone();
-	}
-	/**
-	* Update the display for all tasks
-	*/
-	updateDisplay() {
-		if (this.lastLineCount > 0) for (let i = 0; i < this.lastLineCount; i++) process.stdout.write("\x1B[1A\x1B[2K");
-		const taskArray = Array.from(this.tasks.values());
-		const prefix = this.header ? "│  " : "";
-		for (const task of taskArray) {
-			let line = prefix;
-			if (task.status === "running") {
-				const frame = this.frames[task.frameIndex];
-				line += `${this.colors.cyan}${frame}${this.colors.reset} ${this.colors.dim}${task.taskName}${this.colors.reset}`;
-				task.frameIndex = (task.frameIndex + 1) % this.frames.length;
-			} else if (task.status === "success") {
-				const durationStr = task.duration ? `  ${this.colors.dim}${task.duration}${this.colors.reset}` : "";
-				line += `${this.colors.green}✓${this.colors.reset} ${task.taskName}${durationStr}`;
-			} else if (task.status === "error") line += `${this.colors.red}✗${this.colors.reset} ${task.taskName}`;
-			process.stdout.write(`${line}\n`);
-		}
-		this.lastLineCount = taskArray.length;
-	}
-	/**
-	* Check if all tasks are done and stop the interval
-	*/
-	checkIfAllDone() {
-		if (!Array.from(this.tasks.values()).some((task) => task.status === "running") && this.spinnerInterval) {
-			this.dateTimeProvider.clearInterval(this.spinnerInterval);
-			this.spinnerInterval = void 0;
-		}
-	}
-	/**
-	* Stop the spinner without showing any symbol
-	*/
-	stopSpinner() {
-		if (this.spinnerInterval) {
-			this.dateTimeProvider.clearInterval(this.spinnerInterval);
-			this.spinnerInterval = void 0;
-		}
-	}
-	/**
-	* Clear all tasks
-	*/
-	clear() {
-		this.tasks.clear();
-		this.stopSpinner();
-		this.lastLineCount = 0;
-	}
-};
-
-//#endregion
-//#region src/command/errors/CommandError.ts
-var CommandError = class extends alepha.AlephaError {
-	name = "CommandError";
-};
-
-//#endregion
-//#region src/command/helpers/Runner.ts
-var Runner = class {
-	log = (0, alepha_logger.$logger)();
-	timers = [];
-	startTime = Date.now();
-	prettyPrint = (0, alepha.$inject)(PrettyPrint);
-	alepha = (0, alepha.$inject)(alepha.Alepha);
-	run;
-	cliName = "";
-	commandName = "";
-	firstTaskStarted = false;
-	constructor() {
-		this.run = this.createRunMethod();
-	}
-	get useDynamicLogger() {
-		if (this.alepha.isCI()) return false;
-		return this.alepha.env.LOG_FORMAT === "raw";
-	}
-	/**
-	* Start a new command session with header (for pretty print mode)
-	*/
-	startCommand(cliName, commandName) {
-		this.cliName = cliName;
-		this.commandName = commandName;
-	}
-	createRunMethod() {
-		const runFn = async (cmd, options) => {
-			if (this.useDynamicLogger && !this.firstTaskStarted) this.prettyPrint.startCommand(this.cliName, this.commandName);
-			this.firstTaskStarted = true;
-			if (Array.isArray(cmd)) return await this.execute(cmd.map((it) => typeof it === "string" ? {
-				name: it,
-				handler: () => this.exec(it)
-			} : it));
-			const name = (typeof options === "object" ? options.alias : void 0) ?? (typeof cmd === "string" ? cmd : cmd.name);
-			const handler = typeof options === "function" ? options : typeof cmd === "string" ? () => this.exec(cmd) : cmd.handler;
-			return await this.execute({
-				name,
-				handler
-			});
-		};
-		runFn.rm = async (files, options = {}) => {
-			if (Array.isArray(files) || files.includes("*")) return runFn({
-				name: options.alias ?? `rm -rf ${Array.isArray(files) ? files.join(" ") : files}`,
-				handler: async () => {
-					for await (const file of (0, node_fs_promises.glob)(files)) {
-						this.log.trace(`Removing ${file}`);
-						await (0, node_fs_promises.rm)(file, {
-							recursive: true,
-							force: true
-						});
-					}
-				}
-			});
-			this.log.trace(`Removing ${files}`);
-			return runFn({
-				name: options.alias ?? `rm -rf ${files}`,
-				handler: () => (0, node_fs_promises.rm)(files, {
-					recursive: true,
-					force: true
-				})
-			});
-		};
-		runFn.cp = async (source, dist, options = {}) => {
-			this.log.trace(`Copying ${source} to ${dist}`);
-			return runFn({
-				name: options.alias ?? `cp -r ${source} ${dist}`,
-				handler: () => (0, node_fs_promises.cp)(source, dist, { recursive: true })
-			}, options);
-		};
-		return runFn;
-	}
-	async exec(cmd) {
-		return await new Promise((resolve, reject) => {
-			(0, node_child_process.exec)(cmd, { env: {
-				...process.env,
-				LOG_FORMAT: "pretty"
-			} }, (err, stdout) => {
-				if (err) {
-					err.stdout = stdout;
-					reject(err);
-				} else resolve(stdout);
-			});
-		});
-	}
-	/**
-	* Executes one or more tasks.
-	*
-	* @param task - A single task or an array of tasks to run in parallel.
-	*/
-	async execute(task) {
-		if (Array.isArray(task)) {
-			await Promise.all(task.map((t$2) => this.executeTask(t$2)));
-			return "";
-		} else return await this.executeTask(task);
-	}
-	/**
-	* Prints a summary of all executed tasks and their durations.
-	*/
-	summary() {
-		if (this.useDynamicLogger && this.firstTaskStarted) {
-			this.prettyPrint.endCommand();
-			return;
-		}
-		if (this.timers.length === 0) return;
-		this.log.info("");
-		const totalTime = ((Date.now() - this.startTime) / 1e3).toFixed(1);
-		this.log.info(`Total time: ${totalTime}s`);
-		this.log.info(``);
-	}
-	async executeTask(task) {
-		const now = Date.now();
-		const taskId = task.name;
-		if (this.useDynamicLogger) this.prettyPrint.startSpinner(taskId, task.name);
-		else this.log.info(`Starting '${task.name}' ...`);
-		let stdout = "";
-		try {
-			stdout = String(await task.handler() ?? "");
-		} catch (error) {
-			if (this.useDynamicLogger) this.prettyPrint.error(taskId, task.name);
-			if (error instanceof Error && "stdout" in error) this.log.info(`\n\n${error.stdout}`);
-			throw new CommandError(`Task '${task.name}' failed`, { cause: error });
-		}
-		if (stdout) this.log.trace(stdout);
-		const duration = ((Date.now() - now) / 1e3).toFixed(1);
-		if (this.useDynamicLogger) this.prettyPrint.success(taskId, task.name, `${duration}s`);
-		else this.log.info(`Finished '${task.name}' after ${duration}s`);
-		this.timers.push({
-			name: task.name,
-			duration: `${duration}s`
-		});
-		return stdout;
-	}
-	renderTable(data) {
-		if (data.length === 0) return;
-		const col1Width = Math.max(...data.map(([col1]) => col1.length), 7);
-		const col2Width = Math.max(...data.map(([, col2]) => col2.length), 8);
-		const divider = `+${"-".repeat(col1Width + 2)}+${"-".repeat(col2Width + 2)}+`;
-		this.log.info(divider);
-		this.log.info(`| ${"Command".padEnd(col1Width)} | ${"Duration".padEnd(col2Width)} |`);
-		this.log.info(divider);
-		for (const [col1, col2] of data) this.log.info(`| ${col1.padEnd(col1Width)} | ${col2.padEnd(col2Width)} |`);
-		this.log.info(divider);
-	}
-};
-
-//#endregion
-//#region src/command/providers/CliProvider.ts
-const envSchema = alepha.t.object({
-	CLI_NAME: alepha.t.text({
-		default: "cli",
-		description: "Name of the CLI application."
-	}),
-	CLI_DESCRIPTION: alepha.t.text({
-		default: "",
-		description: "Description of the CLI application."
-	})
-});
-/**
-* CLI provider configuration atom
-*/
-const cliOptions = (0, alepha.$atom)({
-	name: "alepha.command.cli.options",
-	schema: alepha.t.object({
-		name: alepha.t.optional(alepha.t.string({ description: "Name of the CLI application." })),
-		description: alepha.t.optional(alepha.t.string({ description: "Description of the CLI application." })),
-		argv: alepha.t.optional(alepha.t.array(alepha.t.string(), { description: "Command line arguments to parse." }))
-	}),
-	default: {}
-});
-var CliProvider = class {
-	env = (0, alepha.$env)(envSchema);
-	alepha = (0, alepha.$inject)(alepha.Alepha);
-	log = (0, alepha_logger.$logger)();
-	runner = (0, alepha.$inject)(Runner);
-	asker = (0, alepha.$inject)(Asker);
-	options = (0, alepha.$use)(cliOptions);
-	get name() {
-		return this.options.name || this.env.CLI_NAME;
-	}
-	get description() {
-		return this.options.description || this.env.CLI_DESCRIPTION;
-	}
-	get argv() {
-		return this.options.argv || (typeof process !== "undefined" ? process.argv.slice(2) : []);
-	}
-	globalFlags = { help: {
-		aliases: ["h", "help"],
-		description: "Show this help message",
-		schema: alepha.t.boolean()
-	} };
-	onReady = (0, alepha.$hook)({
-		on: "ready",
-		handler: async () => {
-			const argv = [...this.argv];
-			const commandName = argv.find((arg) => !arg.startsWith("-")) ?? "";
-			let command = this.findCommand(commandName);
-			if (this.parseFlags(argv, Object.entries(this.getAllGlobalFlags()).map(([key, value]) => ({
-				key,
-				...value
-			}))).help) {
-				this.printHelp(command);
-				return;
-			}
-			if (!command) {
-				const rootCommand = this.findCommand("");
-				if (rootCommand?.options.args) command = rootCommand;
-				else {
-					if (commandName !== "") {
-						this.log.error(`Unknown command: '${commandName}'`);
-						this.printHelp();
-					}
-					return;
-				}
-			}
-			const commandFlags = this.parseCommandFlags(argv, command.flags);
-			const commandArgs = this.parseCommandArgs(argv, command.options.args);
-			await this.alepha.context.run(async () => {
-				this.log.debug(`Executing command '${command.name}'...`, {
-					flags: commandFlags,
-					args: commandArgs
-				});
-				const runner = this.runner;
-				runner.startCommand(this.name, command.name);
-				const args = {
-					flags: commandFlags,
-					args: commandArgs,
-					run: runner.run,
-					ask: this.asker.ask,
-					fs: node_fs_promises,
-					glob: node_fs_promises.glob,
-					root: process.cwd()
-				};
-				await command.options.handler(args);
-				if (command.options.summary !== false) runner.summary();
-				this.log.debug(`Command '${command.name}' executed successfully.`);
-			});
-		}
-	});
-	get commands() {
-		return this.alepha.descriptors($command);
-	}
-	findCommand(name) {
-		return this.commands.find((command) => command.name === name || command.aliases.includes(name));
-	}
-	/**
-	* Get all global flags including those from the root command (name === "")
-	*/
-	getAllGlobalFlags() {
-		const rootCommand = this.commands.find((cmd) => cmd.name === "");
-		const allGlobalFlags = { ...this.globalFlags };
-		if (rootCommand) for (const [key, value] of Object.entries(rootCommand.flags.properties)) allGlobalFlags[key] = {
-			aliases: [key, ...value.aliases ?? (value.alias ? [value.alias] : void 0) ?? []],
-			description: value.description,
-			schema: value
-		};
-		return allGlobalFlags;
-	}
-	parseCommandFlags(argv, schema) {
-		const flagDefs = Object.entries(schema.properties).map(([key, value]) => ({
-			key,
-			aliases: [key, ...value.aliases ?? (value.alias ? [value.alias] : void 0) ?? []],
-			description: value.description,
-			schema: value
-		}));
-		const parsed = this.parseFlags(argv, flagDefs);
-		for (const [key, value] of Object.entries(schema.properties)) if (!(key in parsed) && alepha.t.schema.isOptional(value)) {
-			const innerSchema = value;
-			if (innerSchema && "default" in innerSchema) parsed[key] = innerSchema.default;
-		}
-		try {
-			return this.alepha.codec.decode(schema, parsed);
-		} catch (error) {
-			if (error instanceof alepha.TypeBoxError) throw new CommandError(`Invalid flag: ${error.cause.instancePath || "command"} ${error.cause.message}`);
-			throw error;
-		}
-	}
-	parseFlags(argv, flagDefs) {
-		const result = {};
-		for (const arg of argv.filter((a) => a.startsWith("-"))) {
-			const [rawKey, ...valueParts] = arg.replace(/^-{1,2}/, "").split("=");
-			const value = valueParts.join("=");
-			const def = flagDefs.find((d) => d.aliases.includes(rawKey));
-			if (!def) continue;
-			if (alepha.t.schema.isBoolean(def.schema)) result[def.key] = true;
-			else if (value) try {
-				if (alepha.t.schema.isObject(def.schema) || alepha.t.schema.isArray(def.schema)) result[def.key] = JSON.parse(value);
-				else result[def.key] = value;
-			} catch {
-				throw new CommandError(`Invalid JSON value for flag --${rawKey}`);
-			}
-			else throw new CommandError(`Flag --${rawKey} requires a value.`);
-		}
-		return result;
-	}
-	parseCommandArgs(argv, schema) {
-		if (!schema) return;
-		const argsOnly = argv.filter((arg) => !arg.startsWith("-")).slice(1);
-		try {
-			if (alepha.t.schema.isOptional(schema)) {
-				if (argsOnly.length === 0) return;
-				return this.parseArgumentValue(argsOnly[0], schema);
-			} else if (alepha.t.schema.isTuple(schema) && schema.items) {
-				const result = [];
-				const items = schema.items;
-				for (let i = 0; i < items.length; i++) {
-					const itemSchema = items[i];
-					if (i < argsOnly.length) result.push(this.parseArgumentValue(argsOnly[i], itemSchema));
-					else if (alepha.t.schema.isOptional(itemSchema)) result.push(void 0);
-					else throw new CommandError(`Missing required argument at position ${i + 1}`);
-				}
-				return result;
-			} else {
-				if (argsOnly.length === 0) throw new CommandError("Missing required argument");
-				return this.parseArgumentValue(argsOnly[0], schema);
-			}
-		} catch (error) {
-			if (error instanceof alepha.TypeBoxError) throw new CommandError(`Invalid argument: ${error.value.message}`);
-			throw error;
-		}
-	}
-	parseArgumentValue(value, schema) {
-		if (alepha.t.schema.isString(schema)) return value;
-		if (alepha.t.schema.isNumber(schema) || alepha.t.schema.isInteger(schema)) {
-			const num = Number(value);
-			if (Number.isNaN(num)) throw new CommandError(`Expected number, got "${value}"`);
-			if (alepha.t.schema.isInteger(schema) && !Number.isInteger(num)) throw new CommandError(`Expected integer, got "${value}"`);
-			return num;
-		}
-		if (alepha.t.schema.isBoolean(schema)) {
-			const lower = value.toLowerCase();
-			if (lower === "true" || lower === "1") return true;
-			if (lower === "false" || lower === "0") return false;
-			throw new CommandError(`Expected boolean, got "${value}"`);
-		}
-		return value;
-	}
-	generateArgsUsage(schema) {
-		if (!schema) return "";
-		if (alepha.t.schema.isOptional(schema)) {
-			const typeName$1 = this.getTypeName(schema);
-			return ` [${"title" in schema ? schema.title : "arg1"}${typeName$1}]`;
-		}
-		if (alepha.t.schema.isTuple(schema) && schema.items) return ` ${schema.items.map((item, index) => {
-			const argName = `arg${index + 1}`;
-			const typeName$1 = this.getTypeName(item);
-			if (alepha.t.schema.isOptional(item)) return `[${argName}${typeName$1}]`;
-			return `<${argName}${typeName$1}>`;
-		}).join(" ")}`;
-		const typeName = this.getTypeName(schema);
-		return ` <${"title" in schema ? schema.title : "arg1"}${typeName}>`;
-	}
-	getTypeName(schema) {
-		if (!schema) return "";
-		if (alepha.t.schema.isString(schema)) return "";
-		if (alepha.t.schema.isNumber(schema)) return ": number";
-		if (alepha.t.schema.isInteger(schema)) return ": integer";
-		if (alepha.t.schema.isBoolean(schema)) return ": boolean";
-		return "";
-	}
-	printHelp(command) {
-		const cliName = this.name || "cli";
-		this.log.info("");
-		if (command?.name) {
-			const argsUsage = this.generateArgsUsage(command.options.args);
-			const usage = `${cliName} ${command.name}${argsUsage}`.trim();
-			this.log.info(`Usage: \`${usage}\``);
-			if (command.options.description) {
-				this.log.info(``);
-				this.log.info(`\t${command.options.description}`);
-			}
-			this.log.info("");
-			this.log.info("Flags:");
-			const flags = [...Object.entries(command.flags.properties).map(([key, value]) => ({
-				key,
-				schema: value,
-				aliases: value.alias ?? [key],
-				description: value.description
-			})), ...Object.entries(this.getAllGlobalFlags()).map(([key, value]) => ({
-				key,
-				...value
-			}))];
-			const maxFlagLength = this.getMaxFlagLength(flags);
-			for (const { aliases, description } of flags) {
-				const flagStr = (Array.isArray(aliases) ? aliases : [aliases]).map((a) => a.length === 1 ? `-${a}` : `--${a}`).join(", ");
-				this.log.info(`    ${flagStr.padEnd(maxFlagLength)} # ${description ?? ""}`);
-			}
-		} else {
-			this.log.info(this.description || "Available commands:");
-			this.log.info("");
-			this.log.info("Commands:");
-			const maxCmdLength = this.getMaxCmdLength(this.commands);
-			for (const command$1 of this.commands) {
-				if (command$1.name === "") continue;
-				const fullCmdStr = `${[command$1.name, ...command$1.aliases].join(", ")}${this.generateArgsUsage(command$1.options.args)}`;
-				this.log.info(`    ${cliName} ${fullCmdStr.padEnd(maxCmdLength)} # ${command$1.options.description ?? ""}`);
-			}
-			this.log.info("");
-			this.log.info("Flags:");
-			const globalFlags = Object.values(this.getAllGlobalFlags());
-			const maxFlagLength = this.getMaxFlagLength(globalFlags);
-			for (const { aliases, description } of globalFlags) {
-				const flagStr = aliases.map((a) => a.length === 1 ? `-${a}` : `--${a}`).join(", ");
-				this.log.info(`    ${flagStr.padEnd(maxFlagLength)} # ${description ?? ""}`);
-			}
-		}
-		this.log.info("");
-	}
-	getMaxCmdLength(commands) {
-		return Math.max(...commands.map((c) => {
-			return `${[c.name, ...c.aliases].join(", ")}${this.generateArgsUsage(c.options.args)}`.length;
-		}));
-	}
-	getMaxFlagLength(flags) {
-		return Math.max(...flags.map((f) => {
-			return (Array.isArray(f.aliases) ? f.aliases : [f.aliases]).map((a) => a.length === 1 ? `-${a}` : `--${a}`).join(", ").length;
-		}));
-	}
-};
-
-//#endregion
-//#region src/command/index.ts
-/**
-* This module provides a powerful way to build command-line interfaces
-* directly within your Alepha application, using declarative descriptors.
-*
-* It allows you to define commands using the `$command` descriptor.
-*
-* @see {@link $command}
-* @module alepha.command
-*/
-const AlephaCommand = (0, alepha.$module)({
-	name: "alepha.command",
-	descriptors: [$command],
-	services: [
-		CliProvider,
-		Runner,
-		Asker,
-		PrettyPrint
-	]
-});
-
-//#endregion
-exports.$command = $command;
-exports.AlephaCommand = AlephaCommand;
-exports.Asker = Asker;
-exports.CliProvider = CliProvider;
-exports.CommandDescriptor = CommandDescriptor;
-exports.CommandError = CommandError;
-exports.PrettyPrint = PrettyPrint;
-exports.Runner = Runner;
-exports.cliOptions = cliOptions;
-//# sourceMappingURL=index.cjs.map