@h3ravel/console 11.0.7 → 11.1.0

package/dist/index.js

@@ -1,45 +1,900 @@
-import "./chunk-NADN2PHB.js";
-import "./chunk-NVPKTRMT.js";
-import "./chunk-UWCTG2LX.js";
-import "./chunk-ADIVRUAJ.js";
-import {
-  ConsoleServiceProvider
-} from "./chunk-6OIH6FS4.js";
-import {
-  Kernel
-} from "./chunk-QCNBVSFO.js";
-import {
-  Musket
-} from "./chunk-KCJKQP37.js";
-import {
-  MigrateCommand
-} from "./chunk-EIOQKTRM.js";
-import {
-  ServeCommand
-} from "./chunk-7EWRZPTX.js";
-import {
-  Signature
-} from "./chunk-3FVPHQCH.js";
-import {
-  MakeCommand
-} from "./chunk-PMV4TMFS.js";
-import {
-  TableGuesser,
-  Utils
-} from "./chunk-POF4JGTX.js";
-import {
-  Command
-} from "./chunk-O45AB4MX.js";
-import "./chunk-SHUYVCID.js";
-export {
-  Command,
-  ConsoleServiceProvider,
-  Kernel,
-  MakeCommand,
-  MigrateCommand,
-  Musket,
-  ServeCommand,
-  Signature,
-  TableGuesser,
-  Utils
+import { TableGuesser, Utils } from "./Utils-DAJvoXlr.js";
+import { dirname, join, resolve } from "path";
+import preferredPM from "preferred-pm";
+import { execa } from "execa";
+import { glob, mkdir, readFile, writeFile } from "node:fs/promises";
+import chalk from "chalk";
+import dayjs from "dayjs";
+import { existsSync } from "node:fs";
+import nodepath from "node:path";
+import { Migrate, MigrationCreator } from "@h3ravel/arquebus/migrations";
+import { arquebusConfig } from "@h3ravel/database";
+import { Application, ServiceProvider } from "@h3ravel/core";
+import "@h3ravel/console";
+import "@h3ravel/http";
+import "@h3ravel/router";
+import "@h3ravel/cache";
+import "@h3ravel/queue";
+import "@h3ravel/mail";
+import "@h3ravel/config";
+import { Logger } from "@h3ravel/shared";
+import { program } from "commander";
+import { fork } from "child_process";
+
+//#region src/Commands/Command.ts
+var Command = class {
+	constructor(app, kernel) {
+		this.app = app;
+		this.kernel = kernel;
+	}
+	/**
+	* 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) {
+		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), {});
+	}
+	getSignature() {
+		return this.signature;
+	}
+	getDescription() {
+		return this.description;
+	}
+	option(key, def) {
+		return this.input.options[key] ?? def;
+	}
+	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;
+	}
 };
+
+//#endregion
+//#region src/Commands/FireCommand.ts
+var FireCommand = class extends Command {
+	/**
+	* The name and signature of the console command.
+	*
+	* @var string
+	*/
+	signature = `fire:
+        {--a|host=localhost : The host address to serve the application on}
+        {--p|port=3000 : The port to serve the application on}
+        {--t|tries=10 : The max number of ports to attempt to serve from}
+        {--d|debug : Show extra debug info, like registered service providers and more}
+    `;
+	/**
+	* The console command description.
+	*
+	* @var string
+	*/
+	description = "Fire up the developement server";
+	async handle() {
+		try {
+			await this.fire();
+		} catch (e) {
+			this.kernel.output.error(e);
+		}
+	}
+	async fire() {
+		const outDir$1 = ".h3ravel/serve";
+		const pm = (await preferredPM(base_path()))?.name ?? "pnpm";
+		const port = this.option("port");
+		const host = this.option("host");
+		const tries = this.option("tries");
+		const ENV_VARS = {
+			EXTENDED_DEBUG: this.option("debug") ? "true" : "false",
+			CLI_BUILD: "false",
+			NODE_ENV: "development",
+			SRC_PATH: outDir$1,
+			HOSTNAME: host,
+			RETRIES: tries,
+			PORT: port
+		};
+		await execa(pm, [
+			"tsdown",
+			"--silent",
+			"--config-loader",
+			"unconfig",
+			"-c",
+			"tsdown.default.config.ts"
+		], {
+			stdout: "inherit",
+			stderr: "inherit",
+			cwd: base_path(),
+			env: Object.assign({}, process.env, ENV_VARS)
+		});
+	}
+};
+
+//#endregion
+//#region src/Commands/MakeCommand.ts
+var MakeCommand = class extends Command {
+	/**
+	* The name and signature of the console command.
+	*
+	* @var string
+	*/
+	signature = `#make:
+        {controller : Generates a new controller class. | {--a|api : Generate an API resource controller} | {--force : Overide existing controller.} }
+        {resource : Generates a new API resource class.}
+        {migration : Generates a new database migration class. | {--l|type=ts : The file type to generate} | {--t|table : The table to migrate}  | {--c|create : The table to be created} }
+        {factory : Generates a new database factory class.}
+        {seeder : Generates a new database seeder class.}
+        {model : Generates a new Arquebus model class. | {--t|type=ts : The file type to generate}} 
+        {^name : The name of the [name] to generate}
+    `;
+	/**
+	* The console command description.
+	*
+	* @var string
+	*/
+	description = "Generate component classes";
+	async handle() {
+		const command = this.dictionary.baseCommand;
+		const methods = {
+			controller: "makeController",
+			resource: "makeResource",
+			migration: "makeMigration",
+			factory: "makeFactory",
+			seeder: "makeSeeder",
+			model: "makeModel"
+		};
+		try {
+			await this?.[methods[command]]();
+		} catch (e) {
+			this.kernel.output.error(e);
+		}
+	}
+	/**
+	* Generate a new controller class.
+	*/
+	async makeController() {
+		const type = this.option("api") ? "-resource" : "";
+		const name = this.argument("name");
+		const force = this.option("force");
+		const path$1 = nodepath.join(app_path("Http/Controllers"), name + ".ts");
+		const crtlrPath = Utils.findModulePkg("@h3ravel/http", this.kernel.cwd) ?? "";
+		const stubPath = nodepath.join(crtlrPath, `dist/stubs/controller${type}.stub`);
+		if (!force && existsSync(path$1)) this.kernel.output.error(`ERORR: ${name} controller already exists`);
+		let stub = await readFile(stubPath, "utf-8");
+		stub = stub.replace(/{{ name }}/g, name);
+		await writeFile(path$1, stub);
+		this.kernel.output.split(`INFO: Controller Created`, chalk.gray(nodepath.basename(path$1)));
+	}
+	makeResource() {
+		this.kernel.output.success(`Resource support is not yet available`);
+	}
+	/**
+	* Generate a new database migration class
+	*/
+	async makeMigration() {
+		const name = this.argument("name");
+		const datePrefix = dayjs().format("YYYY_MM_DD_HHmmss");
+		const path$1 = nodepath.join(database_path("migrations"), `${datePrefix}_${name}.ts`);
+		const crtlrPath = Utils.findModulePkg("@h3ravel/database", this.kernel.cwd) ?? "";
+		let create = this.option("create", false);
+		let table = this.option("table");
+		if (!table && typeof create === "string") {
+			table = create;
+			create = true;
+		}
+		if (!table) {
+			const guessed = TableGuesser.guess(name);
+			table = guessed[0];
+			create = !!guessed[1];
+		}
+		const stubPath = nodepath.join(crtlrPath, this.getMigrationStubName(table, create));
+		let stub = await readFile(stubPath, "utf-8");
+		if (table !== null) stub = stub.replace(/DummyTable|{{\s*table\s*}}/g, table);
+		this.kernel.output.info("INFO: Creating Migration");
+		await this.kernel.ensureDirectoryExists(nodepath.dirname(path$1));
+		await writeFile(path$1, stub);
+		this.kernel.output.split(`INFO: Migration Created`, chalk.gray(nodepath.basename(path$1)));
+	}
+	makeFactory() {
+		this.kernel.output.success(`Factory support is not yet available`);
+	}
+	makeSeeder() {
+		this.kernel.output.success(`Seeder support is not yet available`);
+	}
+	/**
+	* Generate a new Arquebus model class
+	*/
+	async makeModel() {
+		const type = this.option("type", "ts");
+		const name = this.argument("name");
+		const path$1 = nodepath.join(app_path("Models"), name.toLowerCase() + "." + type);
+		const crtlrPath = Utils.findModulePkg("@h3ravel/database", this.kernel.cwd) ?? "";
+		const stubPath = nodepath.join(crtlrPath, `dist/stubs/model-${type}.stub`);
+		let stub = await readFile(stubPath, "utf-8");
+		stub = stub.replace(/{{ name }}/g, name);
+		await writeFile(path$1, stub);
+		this.kernel.output.split(`INFO: Model Created`, chalk.gray(nodepath.basename(path$1)));
+	}
+	/**
+	* Ge the database migration file name
+	* 
+	* @param table 
+	* @param create 
+	* @param type 
+	* @returns 
+	*/
+	getMigrationStubName(table, create = false, type = "ts") {
+		let stub;
+		if (!table) stub = `migration-${type}.stub`;
+		else if (create) stub = `migration.create-${type}.stub`;
+		else stub = `migration.update-${type}.stub`;
+		return "dist/stubs/" + stub;
+	}
+};
+
+//#endregion
+//#region src/Commands/MigrateCommand.ts
+var MigrateCommand = class extends Command {
+	/**
+	* The current database connection
+	*/
+	connection;
+	/** 
+	* The base path for all database operations
+	*/
+	databasePath = database_path();
+	/**
+	* The name and signature of the console command.
+	*
+	* @var string
+	*/
+	signature = `migrate:
+        {fresh : Drop all tables and re-run all migrations.}
+        {install : Create the migration repository.}
+        {refresh : Reset and re-run all migrations.}
+        {reset : Rollback all database migrations.}
+        {rollback : Rollback the last database migration.}
+        {status : Show the status of each migration.}
+        {publish : Publish any migration files from installed packages. | {package : The package to publish migrations from}}
+        {^--s|seed : Seed the database}
+        {^--c|connection=mysql : The database connection to use}
+    `;
+	/**
+	* The console command description.
+	*
+	* @var string
+	*/
+	description = "Run all pending migrations.";
+	/**
+	* Execute the console command.
+	*/
+	async handle() {
+		const command = this.dictionary.name ?? this.dictionary.baseCommand;
+		this.connection = Object.entries(arquebusConfig(config("database"))).find(([client]) => client === config("database.default"))?.at(1);
+		this.connection.migrations = {
+			path: "migrations",
+			table: "migrations"
+		};
+		await this?.[{
+			migrate: "migrateRun",
+			fresh: "migrateFresh",
+			install: "migrateInstall",
+			refresh: "migrateRefresh",
+			reset: "migrateReset",
+			rollback: "migrateRollback",
+			status: "migrateStatus",
+			publish: "migratePublish"
+		}[command]]();
+	}
+	/**
+	* Run all pending migrations.
+	*/
+	async migrateRun() {
+		try {
+			await new Migrate(this.databasePath).run(this.connection, this.options(), true);
+		} catch (e) {
+			this.kernel.output.error("ERROR: " + e);
+		}
+	}
+	/**
+	* Drop all tables and re-run all migrations.
+	*/
+	async migrateFresh() {
+		try {
+			await new Migrate(this.databasePath).fresh(this.connection, this.options(), true);
+		} catch (e) {
+			this.kernel.output.error("ERROR: " + e);
+		}
+	}
+	/**
+	* Create the migration repository.
+	*/
+	async migrateInstall() {
+		try {
+			const migrate = new Migrate(this.databasePath);
+			const { migrator } = await migrate.setupConnection(this.connection);
+			await migrate.prepareDatabase(migrator);
+			this.kernel.output.success(`Migration repository installed.`);
+		} catch (e) {
+			this.kernel.output.error("ERROR: " + e);
+		}
+	}
+	/**
+	* Reset and re-run all migrations.
+	*/
+	async migrateRefresh() {
+		try {
+			await new Migrate(this.databasePath).refresh(this.connection, this.options(), true);
+		} catch (e) {
+			this.kernel.output.error("ERROR: " + e);
+		}
+	}
+	/**
+	* Rollback all database migrations.
+	*/
+	async migrateReset() {
+		try {
+			await new Migrate(this.databasePath).reset(this.connection, this.options(), true);
+		} catch (e) {
+			this.kernel.output.error("ERROR: " + e);
+		}
+	}
+	/**
+	* Rollback the last database migration.
+	*/
+	async migrateRollback() {
+		try {
+			await new Migrate(this.databasePath).rollback(this.connection, this.options(), true);
+		} catch (e) {
+			this.kernel.output.error("ERROR: " + e);
+		}
+	}
+	/**
+	* Show the status of each migration.
+	*/
+	async migrateStatus() {
+		const migrations = await new Migrate(this.databasePath, void 0, (msg, sts) => {
+			const hint = this.kernel.output.parse([[" Did you forget to run", "white"], ["`musket migrate:install`?", "grey"]], " ", false);
+			if (sts) this.kernel.output[sts](msg + hint, sts === "error", true);
+		}).status(this.connection, this.options(), true);
+		try {
+			if (migrations.length > 0) {
+				this.kernel.output.twoColumnLog("Migration name", "Batch / Status");
+				migrations.forEach((migration) => {
+					const status = migration.ran ? `[${migration.batch}] ${chalk.green("Ran")}` : chalk.yellow("Pending");
+					this.kernel.output.twoColumnLog(migration.name, status);
+				});
+			} else this.kernel.output.info("No migrations found");
+		} catch (e) {
+			this.kernel.output.error(["ERROR: " + e, "Did you run musket migrate:install"]);
+		}
+	}
+	/**
+	* Publish any migration files from installed packages.
+	*/
+	async migratePublish() {
+		const name = this.argument("package");
+		try {
+			/** Find the requested package */
+			const packagePath = Utils.findModulePkg(name) ?? null;
+			if (!packagePath) throw new Error("Package not found");
+			/** Get the package,json and instanciate the migration creator */
+			const pkgJson = await import(nodepath.join(packagePath, "package.json"));
+			const creator = new MigrationCreator(nodepath.join(packagePath, pkgJson.migrations ?? "migrations"));
+			const info = this.kernel.output.parse([[" Publishing migrations from", "white"], [`${pkgJson.name}@${pkgJson.version}`, chalk.italic.gray]], " ", false);
+			this.kernel.output.info(`INFO: ${info}`);
+			try {
+				/** Publish any existing migrations */
+				await creator.publish(this.databasePath, (fileName) => {
+					this.kernel.output.twoColumnLog(fileName, chalk.green("PUBLISHED"));
+				});
+			} catch {
+				this.kernel.output.error([`ERROR: ${name} has no publishable migrations.`]);
+			}
+		} catch (e) {
+			const hint = this.kernel.output.parse([[" Did you forget to run", "white"], [`\`${await Utils.installCommand(name)}\``, "grey"]], " ", false);
+			const error = this.kernel.output.parse([
+				["Package `", "white"],
+				[name, "grey"],
+				["` not found", "white"]
+			], "", false);
+			this.kernel.output.error([
+				"ERROR: " + error,
+				hint + "?",
+				String(e)
+			]);
+		}
+	}
+};
+
+//#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();
+			let rest = content.substring(colonIndex + 1).trim();
+			/**
+			* Check for nested options after '|'
+			*/
+			let description = rest;
+			let nestedOptions;
+			const pipeIndex = rest.indexOf("|");
+			if (pipeIndex !== -1) {
+				description = 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 = description.trim();
+			/**
+			* Parse name modifiers (?, *, ?*)
+			*/
+			let name = namePart;
+			let required = /[^a-zA-Z0-9_|-]/.test(name);
+			let multiple = false;
+			if (name.endsWith("?*")) {
+				required = false;
+				multiple = true;
+				name = name.slice(0, -2);
+			} else if (name.endsWith("*")) {
+				multiple = true;
+				name = name.slice(0, -1);
+			} else if (name.endsWith("?")) {
+				required = false;
+				name = name.slice(0, -1);
+			}
+			/**
+			* Check if it's a flag option (starts with --)
+			*/
+			const isFlag = name.startsWith("--");
+			let flags;
+			let defaultValue;
+			if (isFlag) {
+				/**
+				* Parse flags and default values
+				*/
+				const flagParts = name.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);
+				}
+			}
+			options.push({
+				name: isFlag ? flags[flags.length - 1] : name,
+				required,
+				multiple,
+				description,
+				flags,
+				shared,
+				isFlag,
+				isHidden,
+				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].replace(/[^\w=:-]/g, "");
+		const description = 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,
+			commandClass,
+			options: allOptions.filter((e) => !!e.flags),
+			isHidden
+		};
+		else return {
+			baseCommand,
+			isNamespaceCommand,
+			options: allOptions,
+			description,
+			commandClass,
+			isHidden
+		};
+	}
+};
+
+//#endregion
+//#region src/Musket.ts
+/**
+* Musket is H3ravel's CLI tool
+*/
+var Musket = class Musket {
+	output = Logger.log();
+	commands = [];
+	constructor(app, kernel) {
+		this.app = app;
+		this.kernel = kernel;
+	}
+	async build() {
+		this.loadBaseCommands();
+		await this.loadDiscoveredCommands();
+		return this.initialize();
+	}
+	loadBaseCommands() {
+		[
+			new FireCommand(this.app, this.kernel),
+			new MakeCommand(this.app, this.kernel),
+			new MigrateCommand(this.app, this.kernel)
+		].forEach((e) => this.addCommand(e));
+	}
+	async loadDiscoveredCommands() {
+		const commands = [...this.app.registeredCommands.map((cmd) => new cmd(this.app, this.kernel))];
+		/**
+		* Musket Commands auto registration
+		*/
+		const providers_path = app_path("Console/Commands/*.js").replace("/src/", "/.h3ravel/serve/");
+		/** Add the App Commands */
+		for await (const cmd of glob(providers_path)) {
+			const name = nodepath.basename(cmd).replace(".js", "");
+			try {
+				const cmdClass = (await import(cmd))[name];
+				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));
+	}
+	initialize() {
+		const cliVersion = ["H3ravel Version:", chalk.green(this.kernel.consolePackage.version)].join(" ");
+		const localVersion = ["Musket Version:", chalk.green(this.kernel.modulePackage.version || "None")].join(" ");
+		program.name("musket").version(`${cliVersion}\n${localVersion}`);
+		program.command("init").description("Initialize H3ravel.").action(async () => {
+			this.output.success(`Initialized: H3ravel has been initialized!`);
+		});
+		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);
+					await instance.handle();
+				});
+				/**
+				* 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);
+						await instance.handle();
+					});
+					/**
+					* 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);
+					await instance.handle();
+				});
+			}
+		}
+		return program;
+	}
+	makeOption(opt, cmd, parse, parent) {
+		const description = opt.description?.replace(/\[(\w+)\]/g, (_, k) => parent?.[k] ?? `[${k}]`) ?? "";
+		const type = opt.name.replaceAll("-", "");
+		if (opt.isFlag) if (parse) {
+			const flags = opt.flags?.map((f) => f.length === 1 ? `-${f}` : `--${f}`).join(", ").replaceAll("----", "--").replaceAll("---", "-");
+			cmd.option(flags || "", description, String(opt.defaultValue) || void 0);
+		} else cmd.option(opt.flags?.join(", ") + (opt.required ? ` <${type}>` : ""), description, opt.defaultValue);
+		else cmd.argument(opt.required ? `<${opt.name}>` : `[${opt.name}]`, description, opt.defaultValue);
+	}
+	static async parse(kernel) {
+		return (await new Musket(kernel.app, kernel).build()).parseAsync();
+	}
+};
+
+//#endregion
+//#region src/Kernel.ts
+var Kernel = class Kernel {
+	cwd;
+	output = Logger.log();
+	basePath = "";
+	modulePath;
+	consolePath;
+	modulePackage;
+	consolePackage;
+	constructor(app) {
+		this.app = app;
+	}
+	static init(app) {
+		const instance = new Kernel(app);
+		Promise.all([instance.loadRequirements()]).then(([e]) => e.run());
+	}
+	async run() {
+		await Musket.parse(this);
+		process.exit(0);
+	}
+	async ensureDirectoryExists(dir) {
+		await mkdir(dir, { recursive: true });
+	}
+	async loadRequirements() {
+		this.cwd = nodepath.join(process.cwd(), this.basePath);
+		this.modulePath = Utils.findModulePkg("@h3ravel/core", this.cwd) ?? "";
+		this.consolePath = Utils.findModulePkg("@h3ravel/console", this.cwd) ?? "";
+		try {
+			this.modulePackage = await import(nodepath.join(this.modulePath, "package.json"));
+		} catch {
+			this.modulePackage = { version: "N/A" };
+		}
+		try {
+			this.consolePackage = await import(nodepath.join(this.consolePath, "package.json"));
+		} catch {
+			this.consolePackage = { version: "N/A" };
+		}
+		return this;
+	}
+};
+
+//#endregion
+//#region src/Providers/ConsoleServiceProvider.ts
+/**
+* Handles CLI commands and tooling.
+* 
+* Register DatabaseManager and QueryBuilder.
+* Set up ORM models and relationships.
+* Register migration and seeder commands.
+* 
+* Auto-Registered when in CLI mode
+*/
+var ConsoleServiceProvider = class extends ServiceProvider {
+	static priority = 992;
+	/**
+	* Indicate that this service provider only runs in console
+	*/
+	static console = true;
+	register() {}
+	boot() {
+		Kernel.init(this.app);
+		process.on("SIGINT", () => {
+			process.exit(0);
+		});
+		process.on("SIGTERM", () => {
+			process.exit(0);
+		});
+	}
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/@rollup+plugin-run@3.1.0/node_modules/@rollup/plugin-run/dist/es/index.js
+function run(opts = {}) {
+	let input;
+	let proc;
+	const args = opts.args || [];
+	const allowRestarts = opts.allowRestarts || false;
+	const overrideInput = opts.input;
+	const forkOptions = opts.options || opts;
+	delete forkOptions.args;
+	delete forkOptions.allowRestarts;
+	return {
+		name: "run",
+		buildStart(options) {
+			let inputs = overrideInput !== null && overrideInput !== void 0 ? overrideInput : options.input;
+			if (typeof inputs === "string") inputs = [inputs];
+			if (typeof inputs === "object") inputs = Object.values(inputs);
+			if (inputs.length > 1) throw new Error(`@rollup/plugin-run must have a single entry point; consider setting the \`input\` option`);
+			input = resolve(inputs[0]);
+		},
+		generateBundle(_outputOptions, _bundle, isWrite) {
+			if (!isWrite) this.error(`@rollup/plugin-run currently only works with bundles that are written to disk`);
+		},
+		writeBundle(outputOptions, bundle) {
+			const forkBundle = (dir$1, entryFileName$1) => {
+				if (proc) proc.kill();
+				proc = fork(join(dir$1, entryFileName$1), args, forkOptions);
+			};
+			const dir = outputOptions.dir || dirname(outputOptions.file);
+			const entryFileName = Object.keys(bundle).find((fileName) => {
+				const chunk = bundle[fileName];
+				return chunk.isEntry && chunk.facadeModuleId === input;
+			});
+			if (entryFileName) {
+				forkBundle(dir, entryFileName);
+				if (allowRestarts) {
+					process.stdin.resume();
+					process.stdin.setEncoding("utf8");
+					process.stdin.on("data", (data) => {
+						const line = data.toString().trim().toLowerCase();
+						if (line === "rs" || line === "restart" || data.toString().charCodeAt(0) === 11) forkBundle(dir, entryFileName);
+						else if (line === "cls" || line === "clear" || data.toString().charCodeAt(0) === 12) console.clear();
+					});
+				}
+			} else this.error(`@rollup/plugin-run could not find output chunk`);
+		}
+	};
+}
+
+//#endregion
+//#region src/TsdownConfig.ts
+const env = process.env.NODE_ENV || "development";
+const outDir = env === "development" ? ".h3ravel/serve" : "dist";
+const TsDownConfig = {
+	outDir,
+	entry: ["src/**/*.ts"],
+	format: ["esm"],
+	target: "node22",
+	sourcemap: env === "development",
+	clean: true,
+	shims: true,
+	copy: [
+		{
+			from: "public",
+			to: outDir
+		},
+		"src/resources",
+		"src/database"
+	],
+	env: env === "development" ? {
+		NODE_ENV: env,
+		SRC_PATH: outDir
+	} : {},
+	watch: env === "development" && process.env.CLI_BUILD !== "true" ? [
+		".env",
+		".env.*",
+		"src",
+		"../../packages"
+	] : false,
+	dts: false,
+	logLevel: "silent",
+	nodeProtocol: true,
+	skipNodeModulesBundle: true,
+	plugins: env === "development" && process.env.CLI_BUILD !== "true" ? [run({
+		env: Object.assign({}, process.env, {
+			NODE_ENV: env,
+			SRC_PATH: outDir
+		}),
+		execArgv: ["-r", "source-map-support/register"],
+		allowRestarts: false,
+		input: process.cwd() + "/src/server.ts"
+	})] : []
+};
+
+//#endregion
+export { Command, ConsoleServiceProvider, FireCommand, Kernel, MakeCommand, MigrateCommand, Musket, Signature, TableGuesser, TsDownConfig, Utils };
+//# sourceMappingURL=index.js.map