@h3ravel/musket 0.1.0 → 0.1.1

package/dist/index.js

@@ -0,0 +1,918 @@
+import { FileSystem, Logger } from "@h3ravel/shared";
+import { Argument, Option, program } from "commander";
+import { build } from "tsdown";
+import { glob } from "glob";
+import path from "node:path";
+import { Arr, Str } from "@h3ravel/support";
+import { mkdir } from "node:fs/promises";
+
+//#region src/Core/Command.ts
+var Command = class {
+	constructor(app, kernel) {
+		this.app = app;
+		this.kernel = kernel;
+	}
+	/**
+	* The underlying commander instance.
+	*
+	* @var Command
+	*/
+	program;
+	/**
+	* The name and signature of the console command.
+	*
+	* @var string
+	*/
+	signature;
+	/**
+	* A dictionary of signatures or what not.
+	*
+	* @var object
+	*/
+	dictionary = {};
+	/**
+	* The console command description.
+	*
+	* @var string
+	*/
+	description;
+	/**
+	* The console command input.
+	*
+	* @var object
+	*/
+	input = {
+		options: {},
+		arguments: {}
+	};
+	/**
+	* Execute the console command.
+	*/
+	async handle(..._args) {}
+	setApplication(app) {
+		this.app = app;
+	}
+	setInput(options, args, regArgs, dictionary, program$1) {
+		this.program = program$1;
+		this.dictionary = dictionary;
+		this.input.options = options;
+		this.input.arguments = regArgs.map((e, i) => ({ [e.name()]: args[i] })).reduce((e, x) => Object.assign(e, x), {});
+		this.loadBaseFlags();
+		Logger.configure({
+			verbosity: this.option("verbose"),
+			silent: this.option("silent"),
+			quiet: this.option("quiet")
+		});
+		return this;
+	}
+	setOption(key, value) {
+		this.program.setOptionValue(key, value);
+		return this;
+	}
+	setProgram(program$1) {
+		this.program = program$1;
+		return this;
+	}
+	getSignature() {
+		return this.signature;
+	}
+	getDescription() {
+		return this.description;
+	}
+	option(key, def) {
+		const option = this.input.options[key] ?? def;
+		return option === "null" || option === "undefined" ? void 0 : option;
+	}
+	options(key) {
+		if (key) return this.input.options[key];
+		return this.input.options;
+	}
+	argument(key, def) {
+		return this.input.arguments[key] ?? def;
+	}
+	arguments() {
+		return this.input.arguments;
+	}
+	loadBaseFlags() {
+		let verbose = 0;
+		if (this.program.getOptionValue("verbose") == "v") verbose = 2;
+		else if (this.program.getOptionValue("verbose") == "vv") verbose = 3;
+		else verbose = Number(this.program.getOptionValue("verbose") ?? 0);
+		this.input.options.quiet = this.program.getOptionValue("quiet") ?? false;
+		this.input.options.silent = this.program.getOptionValue("silent") ?? false;
+		this.input.options.verbose = verbose;
+		this.input.options.interaction = this.program.getOptionValue("interaction") ?? false;
+	}
+	/**
+	* Check if the command is quiet
+	* 
+	* @returns 
+	*/
+	isQuiet() {
+		return this.option("quiet");
+	}
+	/**
+	* Check if the command is silent
+	* 
+	* @returns 
+	*/
+	isSilent() {
+		return this.option("silent");
+	}
+	/**
+	* Check if the command is non interactive
+	* 
+	* @returns 
+	*/
+	isNonInteractive() {
+		return this.option("interaction") === false;
+	}
+	/**
+	* Get the verbosity of the command
+	* 
+	* @returns 
+	*/
+	getVerbosity() {
+		return Number(this.option("verbose"));
+	}
+	/**
+	* Log an info message
+	*/
+	info(message) {
+		Logger.info(message);
+		return this;
+	}
+	/**
+	* Log a warning message
+	*/
+	warn(message) {
+		Logger.warn(message);
+		return this;
+	}
+	/**
+	* Log a line message
+	*/
+	line(message) {
+		Logger.log(message, "white");
+		return this;
+	}
+	/**
+	* Log a new line
+	*/
+	newLine(count = 1) {
+		if (Number(this.getVerbosity()) >= 3 || !this.isSilent() && !this.isQuiet()) for (let i = 0; i < count; i++) console.log("");
+		return this;
+	}
+	/**
+	* Log a success message
+	*/
+	success(message) {
+		Logger.success(message);
+		return this;
+	}
+	/**
+	* Log an error message
+	*/
+	error(message) {
+		Logger.error(message, false);
+		return this;
+	}
+	/**
+	* Log an error message and terminate execution of the command
+	* return an exit code of 1
+	* 
+	* This method is not chainable
+	*/
+	fail(message) {
+		this.error(message);
+		process.exit(1);
+	}
+	/**
+	* Log a debug message
+	*/
+	debug(message) {
+		Logger.debug(message);
+		return this;
+	}
+};
+
+//#endregion
+//#region src/Signature.ts
+var Signature = class Signature {
+	/**
+	* Helper to parse options inside a block of text
+	* 
+	* @param block 
+	* @returns 
+	*/
+	static parseOptions(block) {
+		const options = [];
+		/**
+		* Match { ... } blocks at top level 
+		*/
+		const regex = /\{([^{}]+(?:\{[^{}]*\}[^{}]*)*)\}/g;
+		let match;
+		while ((match = regex.exec(block)) !== null) {
+			const shared = "^" === match[1][0] || /:[#^]/.test(match[1]);
+			const isHidden = (["#", "^"].includes(match[1][0]) || /:[#^]/.test(match[1])) && !shared;
+			const content = match[1].trim().replace(/[#^]/, "");
+			/**
+			* Split by first ':' to separate name and description+nested
+			*/
+			const colonIndex = content.indexOf(":");
+			if (colonIndex === -1) {
+				/**
+				* No description, treat whole as name
+				*/
+				options.push({ name: content });
+				continue;
+			}
+			const namePart = content.substring(0, colonIndex).trim();
+			const rest = content.substring(colonIndex + 1).trim();
+			/**
+			* Check for nested options after '|'
+			*/
+			let description$1 = rest;
+			let nestedOptions;
+			const pipeIndex = rest.indexOf("|");
+			if (pipeIndex !== -1) {
+				description$1 = rest.substring(0, pipeIndex).trim();
+				/**
+				* nestedText should start with '{' and end with ')', clean it
+				* Also Remove trailing ')' if present
+				*/
+				const cleanedNestedText = rest.substring(pipeIndex + 1).trim().replace(/^\{/, "").trim();
+				/**
+				* Parse nested options recursively
+				*/
+				nestedOptions = Signature.parseOptions("{" + cleanedNestedText + "}");
+			} else
+ /**
+			* Trim the string
+			*/
+			description$1 = description$1.trim();
+			let name$1 = namePart;
+			let flags;
+			let choices = [];
+			let required = /[^a-zA-Z0-9_|-]/.test(name$1);
+			let multiple = false;
+			let placeholder;
+			let defaultValue;
+			/**
+			* Parse the command name
+			*/
+			if (name$1.includes("=")) {
+				const [rawName, rawDefault] = name$1.split("=");
+				name$1 = rawName.trim();
+				const hold = rawName.trim().split("|");
+				const holder = (hold.at(1) ?? hold.at(0)).replace("--", "");
+				defaultValue = rawDefault.trim();
+				placeholder = defaultValue ? `[${holder}]` : `<${holder}>`;
+				required = false;
+			}
+			/**
+			* Parse name modifiers (?, *, ?*)
+			*/
+			if (name$1.endsWith("?*")) {
+				required = false;
+				multiple = true;
+				name$1 = name$1.slice(0, -2);
+			} else if (name$1.endsWith("*")) {
+				multiple = true;
+				name$1 = name$1.slice(0, -1);
+			} else if (name$1.endsWith("?")) {
+				required = false;
+				name$1 = name$1.slice(0, -1);
+				placeholder = `[${name$1.split("--").at(1)?.split("|").at(1) ?? name$1}]`;
+			}
+			/**
+			* Check if it's a flag option (starts with --)
+			*/
+			const isFlag = name$1.startsWith("--");
+			if (isFlag) {
+				/**
+				* Parse flags and default values
+				*/
+				const flagParts = name$1.split("|").map((s) => s.trim());
+				flags = [];
+				for (let part of flagParts) {
+					if (part.startsWith("--") && part.slice(2).length === 1) part = "-" + part.slice(2);
+					else if (part.startsWith("-") && !part.startsWith("--") && part.slice(1).length > 1) part = "--" + part.slice(1);
+					else if (!part.startsWith("-") && part.slice(1).length > 1) part = "--" + part;
+					const eqIndex = part.indexOf("=");
+					if (eqIndex !== -1) {
+						flags.push(part.substring(0, eqIndex));
+						const val = part.substring(eqIndex + 1);
+						if (val === "*") defaultValue = [];
+						else if (val === "true" || val === "false" || !val && !required) defaultValue = val === "true";
+						else if (!isNaN(Number(val))) defaultValue = Number(val);
+						else defaultValue = val;
+					} else flags.push(part);
+				}
+			}
+			const desc = description$1.match(/^([^:]+?)\s*:\s*\[?([\w\s,]+)\]?$/);
+			if (match) {
+				description$1 = desc?.[1].trim() ?? description$1;
+				choices = desc?.[2].split(",").map((s) => s.trim()).filter(Boolean) ?? choices;
+			}
+			options.push({
+				name: isFlag ? flags[flags.length - 1] : name$1,
+				choices,
+				required,
+				multiple,
+				description: description$1,
+				flags,
+				shared,
+				isFlag,
+				isHidden,
+				placeholder,
+				defaultValue,
+				nestedOptions
+			});
+		}
+		return options;
+	}
+	/**
+	* Helper to parse a command's signature
+	* 
+	* @param signature 
+	* @param commandClass 
+	* @returns 
+	*/
+	static parseSignature(signature, commandClass) {
+		const lines = signature.split("\n").map((l) => l.trim()).filter((l) => l.length > 0);
+		const isHidden = ["#", "^"].includes(lines[0][0]) || /:[#^]/.test(lines[0]);
+		const baseCommand = lines[0].split("{")[0].trim().replace(/[^\w:-]/g, "");
+		const description$1 = commandClass.getDescription();
+		const isNamespaceCommand = baseCommand.endsWith(":");
+		/**
+		* Join the rest lines to a single string for parsing
+		*/
+		const rest = lines.slice(1).join(" ");
+		/**
+		* Parse all top-level options/subcommands
+		*/
+		const allOptions = Signature.parseOptions(rest);
+		if (isNamespaceCommand)
+ /**
+		* Separate subcommands (those without flags) and base options (flags)
+		* Here we assume subcommands are those without flags (isFlag false)
+		* and base options are flags or options after subcommands
+		
+		* For simplicity, treat all top-level options as subcommands
+		* and assume base command options come after subcommands in signature (not shown in example)
+		*/
+		return {
+			baseCommand: baseCommand.slice(0, -1),
+			isNamespaceCommand,
+			subCommands: allOptions.filter((e) => !e.flags && !e.isHidden),
+			description: description$1,
+			commandClass,
+			options: allOptions.filter((e) => !!e.flags),
+			isHidden
+		};
+		else return {
+			baseCommand,
+			isNamespaceCommand,
+			options: allOptions,
+			description: description$1,
+			commandClass,
+			isHidden
+		};
+	}
+};
+
+//#endregion
+//#region src/logo.ts
+const logo = String.raw`
+               111                                                                                     
+            111111111                                                                                  
+        1111111111 111111                                                                              
+     111111    111    111111                                                                           
+  111111       111       111111                                                                        
+11111          111          11111                                                                      
+1111111        111        1111111                                                                      
+111  11111     111     111111 111     1111    1111  11111111                                       1111
+111     11111 1111  111111    111     1111    1111 1111  11111                                     1111
+111        11111 11111        111     1111    1111       111111111111 111111111111   1111 1111111  1111
+111           111111     1111 111     111111111111    111111  11111  1111  111 1111 11111111  1111 1111
+111            111   11111111 111     1101    1101       111111111    11111111 1111 1111111111111111101
+111     1111111111111111 1111 111     1111    1111 111    11111011   1111  111  1111111 1101       1111
+111  11111   1110111111111111 111     1111    1111 1111111101 1111   111111111  1111011  111111111 1111
+1111111        111110111110   111     1111    1111   111111   1111    11011101   10111     11111   1111
+11011          111111 11    11111                                                                      
+  111111       11101     111111                                                                        
+     111111    111    111111                                                                           
+        111111 111 111111                                                                              
+            111111111                                                                                  
+               110                                                                                     
+`;
+const altLogo = String.raw`
+ _   _ _____                     _ 
+| | | |___ / _ __ __ ___   _____| |
+| |_| | |_ \| '__/ _  \ \ / / _ \ |
+|  _  |___) | | | (_| |\ V /  __/ |
+|_| |_|____/|_|  \__,_| \_/ \___|_|
+
+`;
+
+//#endregion
+//#region src/Commands/HelpCommand.ts
+var HelpCommand = class extends Command {
+	/**
+	* The name and signature of the console command.
+	*
+	* @var string
+	*/
+	signature = `help
+        {command_name=help : The command name}
+        {--format=txt : The output format}
+    `;
+	/**
+	* The console command description.
+	*
+	* @var string
+	*/
+	description = "Display help for a command";
+	async handle() {
+		const cmd = this.argument("command_name");
+		if (!cmd) {
+			this.program.outputHelp();
+			return;
+		}
+		const target = this.program.commands.find((c) => c.name() === cmd);
+		if (!target) {
+			this.error(`ERROR: Unknown command: ${Logger.log(cmd, ["italic", "grey"], false)}.`);
+			process.exit(1);
+		}
+		target.outputHelp();
+	}
+};
+
+//#endregion
+//#region src/Commands/ListCommand.ts
+var ListCommand = class ListCommand extends Command {
+	/**
+	* The name and signature of the console command.
+	*
+	* @var string
+	*/
+	signature = "list";
+	/**
+	* The console command description.
+	*
+	* @var string
+	*/
+	description = "List all available commands";
+	async handle() {
+		const options = [{
+			short: "-h",
+			long: "--help",
+			description: "Display help for the given command. When no command is given display help for the list command"
+		}].concat(this.program.options).map((e) => {
+			return Logger.describe(Logger.log("  " + [e.short, e.long].filter((e$1) => !!e$1).join(", "), "green", false), e.description, 25, false).join("");
+		});
+		/** Get the program commands */
+		const commands = this.program.commands.map((e) => {
+			return Logger.describe(Logger.log("  " + e.name(), "green", false), e.description(), 25, false).join("");
+		});
+		const list = ListCommand.groupItems(commands);
+		/** Output the modules version */
+		const version$1 = this.kernel.modules.map((e) => {
+			return Logger.log([[Str.of(e.name).after("/").apa().toString(), "white"], [e.version, "green"]], " ", false);
+		}).join(" | ");
+		this.newLine();
+		console.log(version$1);
+		this.newLine();
+		console.log(altLogo);
+		this.newLine();
+		Logger.log("Usage:", "yellow");
+		Logger.log("  command [options] [arguments]", "white");
+		this.newLine();
+		/** Output the options */
+		Logger.log("Options:", "yellow");
+		console.log(options.join("\n").trim());
+		this.newLine();
+		/** Ootput the commands */
+		Logger.log("Available Commands:", "yellow");
+		console.log(list.join("\n\n").trim());
+		this.newLine();
+	}
+	/**
+	* Group Commands based on thier names
+	* 
+	* @param commands 
+	* @returns 
+	*/
+	static groupItems(commands, fmtd = false) {
+		const grouped = commands.reduce((acc, cmd) => {
+			/** strip colors before checking prefix */
+			const clean = cmd.replace(/\x1b\[\d+m/g, "");
+			const prefix = clean.includes(":") ? clean.split(":")[0].trim() : "__root__";
+			acc[prefix] ??= [];
+			/** keep original with colors */
+			acc[prefix].push(cmd);
+			return acc;
+		}, {});
+		return Object.entries(grouped).map(([group, cmds]) => {
+			const label = group === "__root__" ? "" : group;
+			let out = [Logger.log(label, "yellow", false), cmds.join("\n")].join("\n");
+			if (fmtd) out += "\n";
+			return out;
+		});
+	}
+};
+
+//#endregion
+//#region src/Musket.ts
+var Musket = class Musket {
+	/**
+	* The name of the CLI app we're building
+	* 
+	* @default musket
+	*/
+	cliName = "musket";
+	config = {};
+	commands = [];
+	constructor(app, kernel, baseCommands = [], resolver, tsDownConfig = {}) {
+		this.app = app;
+		this.kernel = kernel;
+		this.baseCommands = baseCommands;
+		this.resolver = resolver;
+		this.tsDownConfig = tsDownConfig;
+	}
+	async build() {
+		this.loadBaseCommands();
+		await this.loadDiscoveredCommands();
+		return await this.initialize();
+	}
+	loadBaseCommands() {
+		this.baseCommands.concat([new HelpCommand(this.app, this.kernel), new ListCommand(this.app, this.kernel)]).forEach((e) => this.addCommand(e));
+	}
+	/**
+	* Provide the configuration to initialize the CLI with
+	* 
+	* @param config 
+	* @returns 
+	*/
+	configure(config) {
+		this.config = config;
+		return this;
+	}
+	/**
+	* Set the paths where the cli can search and auto discover commands
+	* 
+	* @param paths
+	* 
+	* @example instance.discoverCommandsFrom('Console/Commands/*.js')
+	* @example instance.discoverCommandsFrom(['Console/Commands/*.js', 'App/Commands/*.js'])
+	* 
+	* @returns the current cli intance
+	*/
+	discoverCommandsFrom(paths) {
+		this.config.discoveryPaths = paths;
+		return this;
+	}
+	async loadDiscoveredCommands() {
+		const commands = [...(this.app.registeredCommands ?? []).map((cmd) => new cmd(this.app, this.kernel))];
+		const paths = Arr.wrap(this.config.discoveryPaths);
+		/**
+		* CLI Commands auto registration
+		*/
+		for await (const pth of glob.stream(paths)) {
+			const name$1 = path.basename(pth).replace(".js", "").replace(".ts", "");
+			try {
+				const cmdClass = (await import(pth))[name$1];
+				commands.push(new cmdClass(this.app, this.kernel));
+			} catch {}
+		}
+		commands.forEach((e) => this.addCommand(e));
+	}
+	addCommand(command) {
+		this.commands.push(Signature.parseSignature(command.getSignature(), command));
+	}
+	async initialize() {
+		if (process.argv.includes("--help") || process.argv.includes("-h")) await this.rebuild("help");
+		/** 
+		* Get the provided packages versions
+		*/
+		const moduleVersions = this.kernel.modules.map((e) => {
+			return Logger.parse([[`${Str.of(e.name).after("/").apa().title().replace("cli", "CLI", false)}:`, "white"], [e.version, "green"]], " ", false);
+		}).join("\n");
+		const additional = {
+			quiet: ["-q, --quiet", "Do not output any message except errors and warnings"],
+			silent: ["--silent", "Do not output any message"],
+			verbose: ["-v, --verbose [level]", "Increase the verbosity of messages: 1 for normal output, 2 and v for more verbose output and 3 and vv for debug"],
+			noInteraction: ["-n, --no-interaction", "Do not ask any interactive question"]
+		};
+		/** 
+		* Init Commander
+		*/
+		program.name(this.cliName).version(moduleVersions).description(this.config.logo ?? altLogo).configureHelp({ showGlobalOptions: true }).addOption(new Option(additional.quiet[0], additional.quiet[1])).addOption(new Option(additional.silent[0], additional.silent[1]).implies({ quiet: true })).addOption(new Option(additional.verbose[0], additional.verbose[1]).choices([
+			"1",
+			"2",
+			"3",
+			"v",
+			"vv"
+		]).default("1")).addOption(new Option(additional.noInteraction[0], additional.noInteraction[1])).action(async () => {
+			const instance = new ListCommand(this.app, this.kernel);
+			instance.setInput(program.opts(), program.args, program.registeredArguments, {}, program);
+			await this.handle(instance);
+		});
+		/**
+		* Format the help command display
+		*/
+		program.configureHelp({
+			styleTitle: (str) => Logger.log(str, "yellow", false),
+			styleOptionTerm: (str) => Logger.log(str, "green", false),
+			styleArgumentTerm: (str) => Logger.log(str, "green", false),
+			styleSubcommandTerm: (str) => Logger.log(str, "green", false),
+			formatItemList(heading, items) {
+				if (items.length < 1) return [];
+				if (!heading.includes("Commands:")) return items;
+				const c = (str) => str.replace(/[^A-Za-z0-9-,]/g, "").replace("32m", "");
+				let flags = items.filter((e) => c(e).startsWith("--") || c(e).includes(",--"));
+				if (flags.length > 0) flags = [Logger.log("\n" + heading + "\n", "yellow", false)].concat(flags);
+				const list = items.filter((e) => !c(e).startsWith("--") && !c(e).includes(",--"));
+				if (list.length < 1) return flags;
+				const _heading = c(heading).includes("Arguments") ? heading : "Available Commands:";
+				return flags.concat(Logger.log(`\n${_heading}`, "yellow", false), ListCommand.groupItems(list, true));
+			},
+			showGlobalOptions: true
+		});
+		/** 
+		* Loop through all the available commands
+		*/
+		for (let i = 0; i < this.commands.length; i++) {
+			const command = this.commands[i];
+			const instance = command.commandClass;
+			if (command.isNamespaceCommand && command.subCommands) {
+				/**
+				* Initialize the base command
+				*/
+				const cmd = command.isHidden ? program : program.command(command.baseCommand).description(command.description ?? "").action(async () => {
+					instance.setInput(cmd.opts(), cmd.args, cmd.registeredArguments, command, program);
+					await this.handle(instance);
+				});
+				/**
+				* Add options to the base command if it has any
+				*/
+				if ((command.options?.length ?? 0) > 0) command.options?.filter((v, i$1, a) => a.findIndex((t) => t.name === v.name) === i$1).forEach((opt) => {
+					this.makeOption(opt, cmd);
+				});
+				/**
+				* Initialize the sub commands
+				*/
+				command.subCommands.filter((v, i$1, a) => !v.shared && a.findIndex((t) => t.name === v.name) === i$1).forEach((sub) => {
+					const cmd$1 = program.command(`${command.baseCommand}:${sub.name}`).description(sub.description || "").action(async () => {
+						instance.setInput(cmd$1.opts(), cmd$1.args, cmd$1.registeredArguments, sub, program);
+						await this.handle(instance);
+					});
+					/**
+					* Add the shared arguments here
+					*/
+					command.subCommands?.filter((e) => e.shared).forEach((opt) => {
+						this.makeOption(opt, cmd$1, false, sub);
+					});
+					/**
+					* Add the shared options here
+					*/
+					command.options?.filter((e) => e.shared).forEach((opt) => {
+						this.makeOption(opt, cmd$1, false, sub);
+					});
+					/**
+					* Add options to the sub command if it has any
+					*/
+					if (sub.nestedOptions) sub.nestedOptions.filter((v, i$1, a) => a.findIndex((t) => t.name === v.name) === i$1).forEach((opt) => {
+						this.makeOption(opt, cmd$1);
+					});
+				});
+			} else {
+				/**
+				* Initialize command with options
+				*/
+				const cmd = program.command(command.baseCommand).description(command.description ?? "");
+				command?.options?.filter((v, i$1, a) => a.findIndex((t) => t.name === v.name) === i$1).forEach((opt) => {
+					this.makeOption(opt, cmd, true);
+				});
+				cmd.action(async () => {
+					instance.setInput(cmd.opts(), cmd.args, cmd.registeredArguments, command, program);
+					await this.handle(instance);
+				});
+			}
+		}
+		/** 
+		* Rebuild the app on every command except fire so we wont need TS
+		*/
+		program.hook("preAction", async (_, cmd) => {
+			this.rebuild(cmd.name());
+		});
+		return program;
+	}
+	async rebuild(name$1) {
+		if (name$1 !== "fire" && name$1 !== "build") await build({
+			...this.tsDownConfig,
+			logLevel: "silent",
+			watch: false,
+			plugins: []
+		});
+	}
+	makeOption(opt, cmd, parse, parent) {
+		const description$1 = opt.description?.replace(/\[(\w+)\]/g, (_, k) => parent?.[k] ?? `[${k}]`) ?? "";
+		const type$1 = opt.name.replaceAll("-", "");
+		if (opt.isFlag) if (parse) {
+			let flags = opt.flags?.map((f) => f.length === 1 ? `-${f}` : `--${f.replace(/^-+/, "")}`).join(", ") ?? void 0;
+			if (opt.required && !opt.placeholder) flags += ` <${type$1}>`;
+			else if (opt.placeholder) flags += " " + opt.placeholder;
+			let optn = new Option(flags || "", description$1).default(opt.defaultValue);
+			if (opt.choices && opt.choices.length) optn = optn.choices(opt.choices ?? []);
+			cmd.addOption(optn);
+		} else {
+			let flags = opt.flags?.join(", ") ?? "";
+			if (opt.required && !opt.placeholder) flags += ` <${type$1}>`;
+			else if (opt.placeholder) flags += " " + opt.placeholder;
+			let optn = new Option(flags, description$1).default(opt.defaultValue);
+			if (opt.choices && opt.choices.length) optn = optn.choices(opt.choices ?? []);
+			cmd.addOption(optn);
+		}
+		else {
+			let name$1 = opt.placeholder;
+			if (!name$1) name$1 = opt.required ? `<${opt.name}>` : `[${opt.name}]`;
+			let arg = new Argument(name$1, description$1);
+			if (opt.choices && opt.choices.length) arg = arg.choices(opt.choices ?? []);
+			if (opt.defaultValue) arg.default(opt.defaultValue);
+			cmd.addArgument(arg);
+		}
+	}
+	async handle(cmd) {
+		if (this.resolver) return await this.resolver(cmd, "handle");
+		await cmd.handle(this.app);
+	}
+	static async parse(kernel, config = {}) {
+		const commands = config.baseCommands?.map((e) => new e(kernel.app, kernel));
+		const cli = new Musket(kernel.app, kernel, commands, config.resolver).configure(config);
+		if (config.cliName) cli.cliName = config.cliName;
+		const command = (await cli.build()).exitOverride((e) => {
+			if (e.exitCode <= 0) return;
+			Logger.log("Unknown command or argument.", "white");
+			Logger.log([
+				["Run", "white"],
+				[`\`${config.cliName} --help\``, ["grey", "italic"]],
+				["to see available commands.", "white"]
+			], " ");
+		});
+		if (!config.skipParsing) await command.parseAsync(process.argv).catch((e) => e);
+		if (cli.app) cli.app.musket = cli;
+		return command;
+	}
+};
+
+//#endregion
+//#region package.json
+var name = "@h3ravel/musket";
+var version = "0.1.0";
+var description = "Musket CLI is a framework-agnostic CLI framework designed to allow you build artisan-like CLI apps and for use in the H3ravel framework.";
+var type = "module";
+var exports = {
+	".": {
+		"import": "./dist/index.js",
+		"require": "./dist/index.cjs"
+	},
+	"./Utils": {
+		"import": "./dist/Utils.js",
+		"require": "./dist/Utils.cjs"
+	}
+};
+var typesVersions = { "*": {
+	"Utils": ["dist/Utils.d.ts"],
+	"*": ["dist/index.d.ts"]
+} };
+var files = ["dist"];
+var publishConfig = { "access": "public" };
+var homepage = "https://h3ravel.toneflix.net/guide/deeper/musket";
+var repository = {
+	"type": "git",
+	"url": "git+https://github.com/h3ravel/musket.git"
+};
+var keywords = [
+	"h3ravel",
+	"modern",
+	"web",
+	"H3",
+	"framework",
+	"nodejs",
+	"typescript",
+	"laravel",
+	"artisan",
+	"musket",
+	"commander",
+	"command",
+	"CLI",
+	"build",
+	"console"
+];
+var scripts = {
+	"build": "tsdown --config-loader unconfig",
+	"lint": "eslint . --ext .ts",
+	"barrel": "barrelize >/dev/null",
+	"test": "vitest",
+	"coverage": "vitest --coverage",
+	"cmd": "tsx --experimental-specifier-resolution=node tests/run",
+	"release:patch": "pnpm build && pnpm version patch && git add . && git commit -m \"version: bump console package version\" && pnpm publish --tag latest",
+	"version-patch": "pnpm version patch",
+	"postinstall": "pnpm barrel"
+};
+var peerDependencies = { "@h3ravel/support": "^0.14.1" };
+var devDependencies = {
+	"@types/node": "^24.7.2",
+	"@typescript-eslint/eslint-plugin": "^8.44.0",
+	"@typescript-eslint/parser": "^8.44.0",
+	"@vitest/coverage-v8": "^3.2.4",
+	"barrelize": "^1.6.4",
+	"eslint": "^9.36.0",
+	"husky": "^9.1.7",
+	"tsdown": "^0.15.7",
+	"typescript": "^5.9.2",
+	"vite-tsconfig-paths": "^5.1.4",
+	"vitest": "^3.2.4"
+};
+var dependencies = {
+	"@h3ravel/shared": "^0.22.2",
+	"chalk": "^5.6.2",
+	"commander": "^14.0.1",
+	"dayjs": "^1.11.18",
+	"execa": "^9.6.0",
+	"glob": "^11.0.3",
+	"preferred-pm": "^4.1.1",
+	"radashi": "^12.6.2",
+	"resolve-from": "^5.0.0",
+	"tsx": "^4.20.5"
+};
+var packageManager = "pnpm@10.18.2";
+var engines = { "node": "^20.19.0 || >=22.12.0" };
+var package_default = {
+	name,
+	version,
+	description,
+	type,
+	exports,
+	typesVersions,
+	files,
+	publishConfig,
+	homepage,
+	repository,
+	keywords,
+	scripts,
+	peerDependencies,
+	devDependencies,
+	dependencies,
+	packageManager,
+	engines
+};
+
+//#endregion
+//#region src/Core/Kernel.ts
+var Kernel = class Kernel {
+	cwd;
+	output = typeof Logger;
+	modules = [];
+	basePath = "";
+	packages = [];
+	config = {};
+	constructor(app) {
+		this.app = app;
+	}
+	async ensureDirectoryExists(dir) {
+		await mkdir(dir, { recursive: true });
+	}
+	static async init(app, config = {}) {
+		const instance = new Kernel(app);
+		instance.config = config;
+		instance.packages = config.packages ?? [];
+		return (await instance.loadRequirements()).run();
+	}
+	async run() {
+		return await Musket.parse(this, this.config);
+	}
+	async loadRequirements() {
+		this.cwd = path.join(process.cwd(), this.basePath);
+		try {
+			package_default.name = this.config.cliName ?? package_default.name;
+			this.modules.push(package_default);
+		} catch {}
+		for (let i = 0; i < this.packages.length; i++) try {
+			const name$1 = this.packages[i];
+			const modulePath = FileSystem.findModulePkg(name$1, this.cwd) ?? "";
+			this.modules.push(await import(path.join(modulePath, "package.json")));
+		} catch (e) {
+			this.modules.push({
+				version: "N/A",
+				name: "Unknown"
+			});
+		}
+		return this;
+	}
+};
+
+//#endregion
+export { Command, Kernel, Musket, Signature };