@h3ravel/console 11.1.0 → 11.2.0

package/dist/index.js

@@ -1,146 +1,152 @@
-import { TableGuesser, Utils } from "./Utils-DAJvoXlr.js";
-import { dirname, join, resolve } from "path";
-import preferredPM from "preferred-pm";
-import { execa } from "execa";
+import { TableGuesser, Utils, sync_default } from "./Utils-Dvclc4Pc.js";
+import { access } from "fs/promises";
+import path, { dirname, join, resolve } from "path";
+import { Application, ConsoleCommand, ConsoleKernel, ServiceProvider } from "@h3ravel/core";
+import { Logger } from "@h3ravel/shared";
 import { glob, mkdir, readFile, writeFile } from "node:fs/promises";
-import chalk from "chalk";
+import { beforeLast } from "@h3ravel/support";
 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/database";
 import "@h3ravel/cache";
 import "@h3ravel/queue";
 import "@h3ravel/mail";
 import "@h3ravel/config";
-import { Logger } from "@h3ravel/shared";
-import { program } from "commander";
+import { Option, program } from "commander";
 import { fork } from "child_process";
+import { build } from "tsdown";
 
 //#region src/Commands/Command.ts
-var Command = class {
-	constructor(app, kernel) {
-		this.app = app;
-		this.kernel = kernel;
-	}
+var Command = class extends ConsoleCommand {};
+
+//#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/ListCommand.ts
+var ListCommand = class extends Command {
 	/**
 	* The name and signature of the console command.
 	*
 	* @var string
 	*/
-	signature;
-	/**
-	* A dictionary of signatures or what not.
-	*
-	* @var object
-	*/
-	dictionary = {};
+	signature = "list";
 	/**
 	* 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;
+	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("");
+		});
+		const grouped = this.program.commands.map((e) => {
+			return Logger.describe(Logger.log("  " + e.name(), "green", false), e.description(), 25, false).join("");
+		}).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;
+		}, {});
+		const list = Object.entries(grouped).map(([group, cmds]) => {
+			const label = group === "__root__" ? "" : group;
+			return [Logger.log(label, "yellow", false), cmds.join("\n")].join("\n");
+		});
+		/** Ootput the app version */
+		Logger.log([["H3ravel Framework", "white"], [this.kernel.modulePackage.version, "green"]], " ");
+		console.log("");
+		console.log(altLogo);
+		console.log("");
+		Logger.log("Usage:", "yellow");
+		Logger.log("  command [options] [arguments]", "white");
+		console.log("");
+		/** Ootput the options */
+		Logger.log("Options:", "yellow");
+		console.log(options.join("\n").trim());
+		console.log("");
+		/** Ootput the commands */
+		Logger.log("Available Commands:", "yellow");
+		console.log(list.join("\n\n").trim());
 	}
 };
 
 //#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}
-    `;
+//#region ../filesystem/dist/index.js
+var Helpers = class {
+	static findModulePkg(moduleId, cwd) {
+		const parts = moduleId.replace(/\\/g, "/").split("/");
+		let packageName = "";
+		if (parts.length > 0 && parts[0][0] === "@") packageName += parts.shift() + "/";
+		packageName += parts.shift();
+		const packageJson = path.join(cwd ?? process.cwd(), "node_modules", packageName);
+		const resolved = this.findUpConfig(packageJson, "package", ["json"]);
+		if (!resolved) return;
+		return path.join(path.dirname(resolved), parts.join("/"));
+	}
 	/**
-	* The console command description.
-	*
-	* @var string
+	* Check if file exists
+	* 
+	* @param path 
+	* @returns 
 	*/
-	description = "Fire up the developement server";
-	async handle() {
+	static async fileExists(path$1) {
 		try {
-			await this.fire();
-		} catch (e) {
-			this.kernel.output.error(e);
+			await access(path$1);
+			return true;
+		} catch {
+			return false;
 		}
 	}
-	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)
+	static findUpConfig(cwd, name, extensions) {
+		return sync_default(cwd, (_dir, names) => {
+			for (const ext of extensions) {
+				const filename = `${name}.${ext}`;
+				if (names.includes(filename)) return filename;
+			}
+			return false;
 		});
 	}
 };
@@ -154,12 +160,37 @@ var MakeCommand = class extends 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}} 
+        {controller : Create a new controller class. 
+            | {--a|api : Exclude the create and edit methods from the controller} 
+            | {--m|model= : Generate a resource controller for the given model} 
+            | {--r|resource : Generate a resource controller class} 
+            | {--force : Create the controller even if it already exists}
+        }
+        {resource : Create a new resource. 
+            | {--c|collection : Create a resource collection}
+            | {--force : Create the resource even if it already exists}
+        }
+        {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 : Create a new model factory.}
+        {seeder : Create a new seeder class.}
+        {view : Create a new view.
+            | {--force : Create the view even if it already exists}
+        }
+        {model : Create a new Eloquent model class. 
+            | {--api : Indicates if the generated controller should be an API resource controller} 
+            | {--c|controller : Create a new controller for the model} 
+            | {--f|factory : Create a new factory for the model} 
+            | {--m|migration : Create a new migration file for the model} 
+            | {--r|resource : Indicates if the generated controller should be a resource controller} 
+            | {--a|all : Generate a migration, seeder, factory, policy, resource controller, and form request classes for the model} 
+            | {--s|seed : Create a new seeder for the model} 
+            | {--t|type=ts : The file type to generate}
+            | {--force : Create the model even if it already exists}
+        } 
         {^name : The name of the [name] to generate}
     `;
 	/**
@@ -169,39 +200,41 @@ var MakeCommand = class extends Command {
 	*/
 	description = "Generate component classes";
 	async handle() {
-		const command = this.dictionary.baseCommand;
+		const command = this.dictionary.baseCommand ?? this.dictionary.name;
 		const methods = {
 			controller: "makeController",
 			resource: "makeResource",
 			migration: "makeMigration",
 			factory: "makeFactory",
 			seeder: "makeSeeder",
-			model: "makeModel"
+			model: "makeModel",
+			view: "makeView"
 		};
 		try {
 			await this?.[methods[command]]();
 		} catch (e) {
-			this.kernel.output.error(e);
+			Logger.error(e);
 		}
 	}
 	/**
-	* Generate a new controller class.
+	* Create 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 crtlrPath = Helpers.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`);
+		/** Check if the controller already exists */
+		if (!force && existsSync(path$1)) Logger.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)));
+		Logger.split("INFO: Controller Created", Logger.log(nodepath.basename(path$1), "gray", false));
 	}
 	makeResource() {
-		this.kernel.output.success(`Resource support is not yet available`);
+		Logger.success("Resource support is not yet available");
 	}
 	/**
 	* Generate a new database migration class
@@ -225,16 +258,22 @@ var MakeCommand = class extends Command {
 		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");
+		Logger.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)));
+		Logger.split("INFO: Migration Created", Logger.log(nodepath.basename(path$1), "gray", false));
 	}
+	/**
+	* Create a new model factory
+	*/
 	makeFactory() {
-		this.kernel.output.success(`Factory support is not yet available`);
+		Logger.success("Factory support is not yet available");
 	}
+	/**
+	* Create a new seeder class
+	*/
 	makeSeeder() {
-		this.kernel.output.success(`Seeder support is not yet available`);
+		Logger.success("Seeder support is not yet available");
 	}
 	/**
 	* Generate a new Arquebus model class
@@ -242,13 +281,29 @@ var MakeCommand = class extends Command {
 	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 force = this.argument("force");
+		const path$1 = nodepath.join(app_path("Models"), name.toLowerCase(), "." + type);
+		/** Check if the model already exists */
+		if (!force && existsSync(path$1)) Logger.error(`ERORR: ${name} view already exists`);
 		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)));
+		Logger.split("INFO: Model Created", Logger.log(nodepath.basename(path$1), "gray", false));
+	}
+	/**
+	* Create a new view.
+	*/
+	async makeView() {
+		const name = this.argument("name");
+		const force = this.option("force");
+		const path$1 = nodepath.join(base_path("src/resources/views"), name + ".edge");
+		if (name.includes("/")) await mkdir(beforeLast(path$1, "/"), { recursive: true });
+		/** Check if the view already exists */
+		if (!force && existsSync(path$1)) Logger.error(`ERORR: ${name} view already exists`);
+		await writeFile(path$1, `{{-- src/resources/views/${name}.edge --}}`);
+		Logger.split("INFO: View Created", Logger.log(`src/resources/views/${name}.edge`, "gray", false));
 	}
 	/**
 	* Ge the database migration file name
@@ -267,181 +322,6 @@ var MakeCommand = class extends Command {
 	}
 };
 
-//#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 {
@@ -606,13 +486,107 @@ var Signature = class Signature {
 	}
 };
 
+//#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"
+	})] : []
+};
+var TsdownConfig_default = TsDownConfig;
+
 //#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;
@@ -624,11 +598,7 @@ var Musket = class Musket {
 		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));
+		[new MakeCommand(this.app, this.kernel), new ListCommand(this.app, this.kernel)].forEach((e) => this.addCommand(e));
 	}
 	async loadDiscoveredCommands() {
 		const commands = [...this.app.registeredCommands.map((cmd) => new cmd(this.app, this.kernel))];
@@ -650,12 +620,27 @@ var Musket = class Musket {
 		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}`);
+		/** Init the Musket Version */
+		const cliVersion = Logger.parse([["Musket CLI:", "white"], [this.kernel.consolePackage.version, "green"]], " ", false);
+		/** Init the App Version */
+		const localVersion = Logger.parse([["H3ravel Framework:", "white"], [this.kernel.modulePackage.version, "green"]], " ", false);
+		const additional = {
+			quiet: ["-q, --quiet", "Do not output any message"],
+			silent: ["--silent", "Do not output any message"],
+			verbose: ["-v, --verbose <number>", "Increase the verbosity of messages: 1 for normal output, 2 for more verbose output and 3 for debug"],
+			interaction: ["-n, --no-interaction", "Do not ask any interactive question"]
+		};
+		/** Init Commander */
+		program.name("musket").version(`${cliVersion}\n${localVersion}`).addOption(new Option(additional.silent[0], additional.silent[1]).implies({ quiet: true })).option(additional.quiet[0], additional.quiet[1]).option(additional.verbose[0], additional.verbose[1]).option(additional.interaction[0], additional.interaction[1]).description(altLogo).action(async () => {
+			const instance = new ListCommand(this.app, this.kernel);
+			instance.setInput(program.opts(), program.args, program.registeredArguments, {}, program);
+			instance.handle();
+		});
+		/** Create the init Command */
 		program.command("init").description("Initialize H3ravel.").action(async () => {
-			this.output.success(`Initialized: H3ravel has been initialized!`);
+			Logger.success("Initialized: H3ravel has been initialized!");
 		});
+		/** Loop through all the available commands */
 		for (let i = 0; i < this.commands.length; i++) {
 			const command = this.commands[i];
 			const instance = command.commandClass;
@@ -663,8 +648,8 @@ var Musket = class Musket {
 				/**
 				* 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);
+				const cmd = command.isHidden ? program : program.command(command.baseCommand).description(command.description ?? "").addOption(new Option(additional.silent[0], additional.silent[1]).implies({ quiet: true })).option(additional.quiet[0], additional.quiet[1]).option(additional.verbose[0], additional.verbose[1]).option(additional.interaction[0], additional.interaction[1]).action(async () => {
+					instance.setInput(cmd.opts(), cmd.args, cmd.registeredArguments, command, program);
 					await instance.handle();
 				});
 				/**
@@ -677,8 +662,8 @@ var Musket = class Musket {
 				* 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);
+					const cmd$1 = program.command(`${command.baseCommand}:${sub.name}`).description(sub.description || "").addOption(new Option(additional.silent[0], additional.silent[1]).implies({ quiet: true })).option(additional.quiet[0], additional.quiet[1]).option(additional.verbose[0], additional.verbose[1]).option(additional.interaction[0], additional.interaction[1]).action(async () => {
+						instance.setInput(cmd$1.opts(), cmd$1.args, cmd$1.registeredArguments, sub, program);
 						await instance.handle();
 					});
 					/**
@@ -704,16 +689,24 @@ var Musket = class Musket {
 				/**
 				* Initialize command with options
 				*/
-				const cmd = program.command(command.baseCommand).description(command.description ?? "");
+				const cmd = program.command(command.baseCommand).description(command.description ?? "").addOption(new Option(additional.silent[0], additional.silent[1]).implies({ quiet: true })).option(additional.quiet[0], additional.quiet[1]).option(additional.verbose[0], additional.verbose[1]).option(additional.interaction[0], additional.interaction[1]);
 				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);
+					instance.setInput(cmd.opts(), cmd.args, cmd.registeredArguments, command, program);
 					await instance.handle();
 				});
 			}
 		}
+		/** Rebuild the app on every command except fire so we wont need TS */
+		program.hook("preAction", async (_, cmd) => {
+			if (cmd.name() !== "fire") await build({
+				...TsdownConfig_default,
+				watch: false,
+				plugins: []
+			});
+		});
 		return program;
 	}
 	makeOption(opt, cmd, parse, parent) {
@@ -732,15 +725,9 @@ var Musket = class Musket {
 
 //#endregion
 //#region src/Kernel.ts
-var Kernel = class Kernel {
-	cwd;
-	output = Logger.log();
-	basePath = "";
-	modulePath;
-	consolePath;
-	modulePackage;
-	consolePackage;
+var Kernel = class Kernel extends ConsoleKernel {
 	constructor(app) {
+		super(app);
 		this.app = app;
 	}
 	static init(app) {
@@ -751,13 +738,10 @@ var Kernel = class Kernel {
 		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) ?? "";
+		this.modulePath = Helpers.findModulePkg("@h3ravel/core", this.cwd) ?? "";
+		this.consolePath = Helpers.findModulePkg("@h3ravel/console", this.cwd) ?? "";
 		try {
 			this.modulePackage = await import(nodepath.join(this.modulePath, "package.json"));
 		} catch {
@@ -802,99 +786,5 @@ var ConsoleServiceProvider = class extends ServiceProvider {
 };
 
 //#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 };
+export { Command, ConsoleServiceProvider, Kernel, ListCommand, MakeCommand, Musket, Signature, TableGuesser, TsDownConfig, Utils, altLogo, logo };
 //# sourceMappingURL=index.js.map