@h3ravel/console 11.0.7 → 11.2.0

package/dist/index.cjs

@@ -1,972 +1,813 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  Command: () => Command,
-  ConsoleServiceProvider: () => ConsoleServiceProvider,
-  Kernel: () => Kernel,
-  MakeCommand: () => MakeCommand,
-  MigrateCommand: () => MigrateCommand,
-  Musket: () => Musket,
-  ServeCommand: () => ServeCommand,
-  Signature: () => Signature,
-  TableGuesser: () => TableGuesser,
-  Utils: () => Utils
-});
-module.exports = __toCommonJS(index_exports);
+const require_Utils = require('./Utils-CpiQZ3n9.cjs');
+let fs_promises = require("fs/promises");
+fs_promises = require_Utils.__toESM(fs_promises);
+let path = require("path");
+path = require_Utils.__toESM(path);
+let __h3ravel_core = require("@h3ravel/core");
+__h3ravel_core = require_Utils.__toESM(__h3ravel_core);
+let __h3ravel_shared = require("@h3ravel/shared");
+__h3ravel_shared = require_Utils.__toESM(__h3ravel_shared);
+let node_fs_promises = require("node:fs/promises");
+node_fs_promises = require_Utils.__toESM(node_fs_promises);
+let __h3ravel_support = require("@h3ravel/support");
+__h3ravel_support = require_Utils.__toESM(__h3ravel_support);
+let dayjs = require("dayjs");
+dayjs = require_Utils.__toESM(dayjs);
+let node_fs = require("node:fs");
+node_fs = require_Utils.__toESM(node_fs);
+let node_path = require("node:path");
+node_path = require_Utils.__toESM(node_path);
+require("@h3ravel/console");
+require("@h3ravel/http");
+require("@h3ravel/router");
+require("@h3ravel/database");
+require("@h3ravel/cache");
+require("@h3ravel/queue");
+require("@h3ravel/mail");
+require("@h3ravel/config");
+let commander = require("commander");
+commander = require_Utils.__toESM(commander);
+let child_process = require("child_process");
+child_process = require_Utils.__toESM(child_process);
+let tsdown = require("tsdown");
+tsdown = require_Utils.__toESM(tsdown);
 
-// src/Commands/Command.ts
-var Command = class {
-  static {
-    __name(this, "Command");
-  }
-  app;
-  kernel;
-  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;
-  }
-};
+//#region src/Commands/Command.ts
+var Command = class extends __h3ravel_core.ConsoleCommand {};
 
-// src/Utils.ts
-var import_promises = require("fs/promises");
-var import_chalk = __toESM(require("chalk"), 1);
+//#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 /  __/ |
+|_| |_|____/|_|  \__,_| \_/ \___|_|
 
-// ../../node_modules/.pnpm/escalade@3.2.0/node_modules/escalade/sync/index.mjs
-var import_path = require("path");
-var import_fs = require("fs");
-function sync_default(start, callback) {
-  let dir = (0, import_path.resolve)(".", start);
-  let tmp, stats = (0, import_fs.statSync)(dir);
-  if (!stats.isDirectory()) {
-    dir = (0, import_path.dirname)(dir);
-  }
-  while (true) {
-    tmp = callback(dir, (0, import_fs.readdirSync)(dir));
-    if (tmp) return (0, import_path.resolve)(dir, tmp);
-    dir = (0, import_path.dirname)(tmp = dir);
-    if (tmp === dir) break;
-  }
-}
-__name(sync_default, "default");
+`;
 
-// src/Utils.ts
-var import_path2 = __toESM(require("path"), 1);
-var join = import_path2.default.join;
-var Utils = class {
-  static {
-    __name(this, "Utils");
-  }
-  /**
-  * Wraps text with chalk
-  * 
-  * @param txt 
-  * @param color 
-  * @returns 
-  */
-  static textFormat(txt, color) {
-    return String(txt).split(":").map((e, i, a) => i == 0 && a.length > 1 ? color(" " + e + ": ") : e).join("");
-  }
-  /**
-  * Ouput formater object
-  * 
-  * @returns 
-  */
-  static output() {
-    return {
-      success: /* @__PURE__ */ __name((msg, exit = false) => {
-        console.log(import_chalk.default.green("\u2713"), this.textFormat(msg, import_chalk.default.bgGreen), "\n");
-        if (exit) process.exit(0);
-      }, "success"),
-      info: /* @__PURE__ */ __name((msg, exit = false) => {
-        console.log(import_chalk.default.blue("\u2139"), this.textFormat(msg, import_chalk.default.bgBlue), "\n");
-        if (exit) process.exit(0);
-      }, "info"),
-      error: /* @__PURE__ */ __name((msg, exit = true) => {
-        if (msg instanceof Error) {
-          if (msg.message) {
-            console.error(import_chalk.default.red("\u2716"), this.textFormat("ERROR:" + msg.message, import_chalk.default.bgRed));
-          }
-          console.error(import_chalk.default.red(`${msg.detail ? `${msg.detail}
-` : ""}${msg.stack}`), "\n");
-        } else {
-          console.error(import_chalk.default.red("\u2716"), this.textFormat(msg, import_chalk.default.bgRed), "\n");
-        }
-        if (exit) process.exit(1);
-      }, "error"),
-      split: /* @__PURE__ */ __name((name, value, status, exit = false) => {
-        status ??= "info";
-        const color = {
-          success: import_chalk.default.bgGreen,
-          info: import_chalk.default.bgBlue,
-          error: import_chalk.default.bgRed
-        };
-        const regex = /\x1b\[\d+m/g;
-        const width = Math.min(process.stdout.columns, 100);
-        const dots = Math.max(width - name.replace(regex, "").length - value.replace(regex, "").length - 10, 0);
-        console.log(this.textFormat(name, color[status]), import_chalk.default.gray(".".repeat(dots)), value);
-        if (exit) process.exit(0);
-      }, "split"),
-      quiet: /* @__PURE__ */ __name(() => {
-        process.exit(0);
-      }, "quiet")
-    };
-  }
-  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 = import_path2.default.join(cwd ?? process.cwd(), "node_modules", packageName);
-    const resolved = this.findUpConfig(packageJson, "package", [
-      "json"
-    ]);
-    if (!resolved) {
-      return;
-    }
-    return import_path2.default.join(import_path2.default.dirname(resolved), parts.join("/"));
-  }
-  static async getMigrationPaths(cwd, migrator, defaultPath, path3) {
-    if (path3) {
-      return [
-        join(cwd, path3)
-      ];
-    }
-    return [
-      ...migrator.getPaths(),
-      join(cwd, defaultPath)
-    ];
-  }
-  static twoColumnDetail(name, value) {
-    const regex = /\x1b\[\d+m/g;
-    const width = Math.min(process.stdout.columns, 100);
-    const dots = Math.max(width - name.replace(regex, "").length - value.replace(regex, "").length - 10, 0);
-    return console.log(name, import_chalk.default.gray(".".repeat(dots)), value);
-  }
-  /**
-  * Check if file exists
-  * 
-  * @param path 
-  * @returns 
-  */
-  static async fileExists(path3) {
-    try {
-      await (0, import_promises.access)(path3);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  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;
-    });
-  }
+//#endregion
+//#region src/Commands/ListCommand.ts
+var ListCommand = class 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 __h3ravel_shared.Logger.describe(__h3ravel_shared.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 __h3ravel_shared.Logger.describe(__h3ravel_shared.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 [__h3ravel_shared.Logger.log(label, "yellow", false), cmds.join("\n")].join("\n");
+		});
+		/** Ootput the app version */
+		__h3ravel_shared.Logger.log([["H3ravel Framework", "white"], [this.kernel.modulePackage.version, "green"]], " ");
+		console.log("");
+		console.log(altLogo);
+		console.log("");
+		__h3ravel_shared.Logger.log("Usage:", "yellow");
+		__h3ravel_shared.Logger.log("  command [options] [arguments]", "white");
+		console.log("");
+		/** Ootput the options */
+		__h3ravel_shared.Logger.log("Options:", "yellow");
+		console.log(options.join("\n").trim());
+		console.log("");
+		/** Ootput the commands */
+		__h3ravel_shared.Logger.log("Available Commands:", "yellow");
+		console.log(list.join("\n\n").trim());
+	}
 };
-var TableGuesser = class TableGuesser2 {
-  static {
-    __name(this, "TableGuesser");
-  }
-  static CREATE_PATTERNS = [
-    /^create_(\w+)_table$/,
-    /^create_(\w+)$/
-  ];
-  static CHANGE_PATTERNS = [
-    /.+_(to|from|in)_(\w+)_table$/,
-    /.+_(to|from|in)_(\w+)$/
-  ];
-  static guess(migration) {
-    for (const pattern of TableGuesser2.CREATE_PATTERNS) {
-      const matches = migration.match(pattern);
-      if (matches) {
-        return [
-          matches[1],
-          true
-        ];
-      }
-    }
-    for (const pattern of TableGuesser2.CHANGE_PATTERNS) {
-      const matches = migration.match(pattern);
-      if (matches) {
-        return [
-          matches[2],
-          false
-        ];
-      }
-    }
-    return [];
-  }
+
+//#endregion
+//#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.default.join(cwd ?? process.cwd(), "node_modules", packageName);
+		const resolved = this.findUpConfig(packageJson, "package", ["json"]);
+		if (!resolved) return;
+		return path.default.join(path.default.dirname(resolved), parts.join("/"));
+	}
+	/**
+	* Check if file exists
+	* 
+	* @param path 
+	* @returns 
+	*/
+	static async fileExists(path$1$1) {
+		try {
+			await (0, fs_promises.access)(path$1$1);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	static findUpConfig(cwd, name, extensions) {
+		return require_Utils.sync_default(cwd, (_dir, names) => {
+			for (const ext of extensions) {
+				const filename = `${name}.${ext}`;
+				if (names.includes(filename)) return filename;
+			}
+			return false;
+		});
+	}
 };
 
-// src/Commands/MakeCommand.ts
-var import_promises2 = require("fs/promises");
-var import_chalk2 = __toESM(require("chalk"), 1);
-var import_dayjs = __toESM(require("dayjs"), 1);
-var import_node_fs = require("fs");
-var import_node_path = __toESM(require("path"), 1);
+//#endregion
+//#region src/Commands/MakeCommand.ts
 var MakeCommand = class extends Command {
-  static {
-    __name(this, "MakeCommand");
-  }
-  /**
-   * 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}} 
+	/**
+	* The name and signature of the console command.
+	*
+	* @var string
+	*/
+	signature = `#make:
+        {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}
     `;
-  /**
-   * 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 path3 = import_node_path.default.join(app_path("Http/Controllers"), name + ".ts");
-    const dbPath = Utils.findModulePkg("@h3ravel/http", this.kernel.cwd) ?? "";
-    const stubPath = import_node_path.default.join(dbPath, `dist/stubs/controller${type}.stub`);
-    if (!force && (0, import_node_fs.existsSync)(path3)) {
-      this.kernel.output.error(`ERORR: ${name} controller already exists`);
-    }
-    let stub = await (0, import_promises2.readFile)(stubPath, "utf-8");
-    stub = stub.replace(/{{ name }}/g, name);
-    await (0, import_promises2.writeFile)(path3, stub);
-    this.kernel.output.split(`INFO: Controller Created`, import_chalk2.default.gray(import_node_path.default.basename(path3)));
-  }
-  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 = (0, import_dayjs.default)().format("YYYY_MM_DD_HHmmss");
-    const path3 = import_node_path.default.join(database_path("migrations"), `${datePrefix}_${name}.ts`);
-    const dbPath = 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 = import_node_path.default.join(dbPath, this.getMigrationStubName(table, create));
-    let stub = await (0, import_promises2.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(import_node_path.default.dirname(path3));
-    await (0, import_promises2.writeFile)(path3, stub);
-    this.kernel.output.split(`INFO: Migration Created`, import_chalk2.default.gray(import_node_path.default.basename(path3)));
-  }
-  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 path3 = import_node_path.default.join(app_path("Models"), name.toLowerCase() + "." + type);
-    const dbPath = Utils.findModulePkg("@h3ravel/database", this.kernel.cwd) ?? "";
-    const stubPath = import_node_path.default.join(dbPath, `dist/stubs/model-${type}.stub`);
-    let stub = await (0, import_promises2.readFile)(stubPath, "utf-8");
-    stub = stub.replace(/{{ name }}/g, name);
-    await (0, import_promises2.writeFile)(path3, stub);
-    this.kernel.output.split(`INFO: Model Created`, import_chalk2.default.gray(import_node_path.default.basename(path3)));
-  }
-  /**
-   * 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;
-  }
+	/**
+	* The console command description.
+	*
+	* @var string
+	*/
+	description = "Generate component classes";
+	async handle() {
+		const command = this.dictionary.baseCommand ?? this.dictionary.name;
+		const methods = {
+			controller: "makeController",
+			resource: "makeResource",
+			migration: "makeMigration",
+			factory: "makeFactory",
+			seeder: "makeSeeder",
+			model: "makeModel",
+			view: "makeView"
+		};
+		try {
+			await this?.[methods[command]]();
+		} catch (e) {
+			__h3ravel_shared.Logger.error(e);
+		}
+	}
+	/**
+	* 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$5 = node_path.default.join(app_path("Http/Controllers"), name + ".ts");
+		const crtlrPath = Helpers.findModulePkg("@h3ravel/http", this.kernel.cwd) ?? "";
+		const stubPath = node_path.default.join(crtlrPath, `dist/stubs/controller${type}.stub`);
+		/** Check if the controller already exists */
+		if (!force && (0, node_fs.existsSync)(path$5)) __h3ravel_shared.Logger.error(`ERORR: ${name} controller already exists`);
+		let stub = await (0, node_fs_promises.readFile)(stubPath, "utf-8");
+		stub = stub.replace(/{{ name }}/g, name);
+		await (0, node_fs_promises.writeFile)(path$5, stub);
+		__h3ravel_shared.Logger.split("INFO: Controller Created", __h3ravel_shared.Logger.log(node_path.default.basename(path$5), "gray", false));
+	}
+	makeResource() {
+		__h3ravel_shared.Logger.success("Resource support is not yet available");
+	}
+	/**
+	* Generate a new database migration class
+	*/
+	async makeMigration() {
+		const name = this.argument("name");
+		const datePrefix = (0, dayjs.default)().format("YYYY_MM_DD_HHmmss");
+		const path$5 = node_path.default.join(database_path("migrations"), `${datePrefix}_${name}.ts`);
+		const crtlrPath = require_Utils.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 = require_Utils.TableGuesser.guess(name);
+			table = guessed[0];
+			create = !!guessed[1];
+		}
+		const stubPath = node_path.default.join(crtlrPath, this.getMigrationStubName(table, create));
+		let stub = await (0, node_fs_promises.readFile)(stubPath, "utf-8");
+		if (table !== null) stub = stub.replace(/DummyTable|{{\s*table\s*}}/g, table);
+		__h3ravel_shared.Logger.info("INFO: Creating Migration");
+		await this.kernel.ensureDirectoryExists(node_path.default.dirname(path$5));
+		await (0, node_fs_promises.writeFile)(path$5, stub);
+		__h3ravel_shared.Logger.split("INFO: Migration Created", __h3ravel_shared.Logger.log(node_path.default.basename(path$5), "gray", false));
+	}
+	/**
+	* Create a new model factory
+	*/
+	makeFactory() {
+		__h3ravel_shared.Logger.success("Factory support is not yet available");
+	}
+	/**
+	* Create a new seeder class
+	*/
+	makeSeeder() {
+		__h3ravel_shared.Logger.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 force = this.argument("force");
+		const path$5 = node_path.default.join(app_path("Models"), name.toLowerCase(), "." + type);
+		/** Check if the model already exists */
+		if (!force && (0, node_fs.existsSync)(path$5)) __h3ravel_shared.Logger.error(`ERORR: ${name} view already exists`);
+		const crtlrPath = require_Utils.Utils.findModulePkg("@h3ravel/database", this.kernel.cwd) ?? "";
+		const stubPath = node_path.default.join(crtlrPath, `dist/stubs/model-${type}.stub`);
+		let stub = await (0, node_fs_promises.readFile)(stubPath, "utf-8");
+		stub = stub.replace(/{{ name }}/g, name);
+		await (0, node_fs_promises.writeFile)(path$5, stub);
+		__h3ravel_shared.Logger.split("INFO: Model Created", __h3ravel_shared.Logger.log(node_path.default.basename(path$5), "gray", false));
+	}
+	/**
+	* Create a new view.
+	*/
+	async makeView() {
+		const name = this.argument("name");
+		const force = this.option("force");
+		const path$5 = node_path.default.join(base_path("src/resources/views"), name + ".edge");
+		if (name.includes("/")) await (0, node_fs_promises.mkdir)((0, __h3ravel_support.beforeLast)(path$5, "/"), { recursive: true });
+		/** Check if the view already exists */
+		if (!force && (0, node_fs.existsSync)(path$5)) __h3ravel_shared.Logger.error(`ERORR: ${name} view already exists`);
+		await (0, node_fs_promises.writeFile)(path$5, `{{-- src/resources/views/${name}.edge --}}`);
+		__h3ravel_shared.Logger.split("INFO: View Created", __h3ravel_shared.Logger.log(`src/resources/views/${name}.edge`, "gray", false));
+	}
+	/**
+	* 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;
+	}
 };
 
-// src/Commands/MigrateCommand.ts
-var MigrateCommand = class extends Command {
-  static {
-    __name(this, "MigrateCommand");
-  }
-  /**
-   * 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.}
-        {^--s|seed : Seed the database}
-    `;
-  /**
-   * 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;
-    const methods = {
-      migrate: "migrateRun",
-      fresh: "migrateFresh",
-      install: "migrateInstall",
-      refresh: "migrateRefresh",
-      reset: "migrateReset",
-      rollback: "migrateRollback",
-      status: "migrateStatus",
-      publish: "migratePublish"
-    };
-    await this?.[methods[command]]();
-  }
-  /**
-   * Run all pending migrations.
-   */
-  async migrateRun() {
-    this.kernel.output.success(`Running migrations are not yet supported.`);
-  }
-  /**
-   * Drop all tables and re-run all migrations.
-   */
-  async migrateFresh() {
-    this.kernel.output.success(`Drop all tables and re-run all migrations.`);
-  }
-  /**
-   * Create the migration repository.
-   */
-  async migrateInstall() {
-    this.kernel.output.success(`Create the migration repository.`);
-  }
-  /**
-   * Reset and re-run all migrations.
-   */
-  async migrateRefresh() {
-    this.kernel.output.success(`Resetting and re-running migrations is not yet supported.`);
-  }
-  /**
-   * Rollback all database migrations.
-   */
-  async migrateReset() {
-    this.kernel.output.success(`Rolling back all migration is not yet supported.`);
-  }
-  /**
-   * Rollback the last database migration.
-   */
-  async migrateRollback() {
-    this.kernel.output.success(`Rolling back the last migration is not yet supported.`);
-  }
-  /**
-   * Show the status of each migration.
-   */
-  async migrateStatus() {
-    const path3 = app_path();
-    this.kernel.output.success(`Show the status of each migration.`);
-  }
-  /**
-   * Publish any migration files from installed packages.
-   */
-  async migratePublish() {
-    this.kernel.output.success(`Publish any migration files from installed packages.`);
-  }
-};
-
-// src/Commands/ServeCommand.ts
-var import_node_child_process = require("child_process");
-var ServeCommand = class extends Command {
-  static {
-    __name(this, "ServeCommand");
-  }
-  /**
-   * The name and signature of the console command.
-   *
-   * @var string
-   */
-  signature = "serve";
-  /**
-   * The console command description.
-   *
-   * @var string
-   */
-  description = "Start the Developement Server";
-  async handle() {
-    try {
-      await this.serve();
-    } catch (e) {
-      this.kernel.output.error(e);
-    }
-  }
-  async serve() {
-    const child = (0, import_node_child_process.spawn)("tsup-node", {
-      stdio: "inherit",
-      shell: true,
-      env: Object.assign({}, process.env, {
-        NODE_ENV: "development"
-      }),
-      detached: false
-    });
-    const cleanup = /* @__PURE__ */ __name(() => {
-      console.log(111111);
-      if (child.pid) {
-        process.kill(child.pid, "SIGTERM");
-      }
-    }, "cleanup");
-    process.on("SIGINT", () => child.kill("SIGINT"));
-    process.on("SIGTERM", () => child.kill("SIGTERM"));
-    process.on("SIGINT", () => {
-      cleanup();
-      process.exit(0);
-    });
-    process.on("SIGTERM", () => {
-      cleanup();
-      process.exit(0);
-    });
-  }
+//#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
+		};
+	}
 };
 
-// src/IO/app.ts
-var import_core2 = require("@h3ravel/core");
-
-// src/IO/providers.ts
-var import_http = require("@h3ravel/http");
-var import_router = require("@h3ravel/router");
-var import_database = require("@h3ravel/database");
-var import_cache = require("@h3ravel/cache");
-var import_queue = require("@h3ravel/queue");
-var import_mail = require("@h3ravel/mail");
-var import_config = require("@h3ravel/config");
-
-// src/Providers/ConsoleServiceProvider.ts
-var import_node_events = require("events");
-
-// src/Signature.ts
-var Signature = class _Signature {
-  static {
-    __name(this, "Signature");
-  }
-  /**
-   * Helper to parse options inside a block of text
-   * 
-   * @param block 
-   * @returns 
-   */
-  static parseOptions(block) {
-    const options = [];
-    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(/[#^]/, "");
-      const colonIndex = content.indexOf(":");
-      if (colonIndex === -1) {
-        options.push({
-          name: content
-        });
-        continue;
-      }
-      const namePart = content.substring(0, colonIndex).trim();
-      let rest = content.substring(colonIndex + 1).trim();
-      let description = rest;
-      let nestedOptions;
-      const pipeIndex = rest.indexOf("|");
-      if (pipeIndex !== -1) {
-        description = rest.substring(0, pipeIndex).trim();
-        const nestedText = rest.substring(pipeIndex + 1).trim();
-        const cleanedNestedText = nestedText.replace(/^\{/, "").trim();
-        nestedOptions = _Signature.parseOptions("{" + cleanedNestedText + "}");
-      } else {
-        description = description.trim();
-      }
-      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);
-      }
-      const isFlag = name.startsWith("--");
-      let flags;
-      let defaultValue;
-      if (isFlag) {
-        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(":");
-    const rest = lines.slice(1).join(" ");
-    const allOptions = _Signature.parseOptions(rest);
-    if (isNamespaceCommand) {
-      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 ../../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 = (0, path.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 = (0, child_process.fork)((0, path.join)(dir$1, entryFileName$1), args, forkOptions);
+			};
+			const dir = outputOptions.dir || (0, path.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`);
+		}
+	};
+}
 
-// src/Musket.ts
-var import_chalk3 = __toESM(require("chalk"), 1);
-var import_commander = require("commander");
-var Musket = class _Musket {
-  static {
-    __name(this, "Musket");
-  }
-  app;
-  kernel;
-  output = Utils.output();
-  commands = [];
-  constructor(app, kernel) {
-    this.app = app;
-    this.kernel = kernel;
-  }
-  async build() {
-    this.loadBaseCommands();
-    await this.loadDiscoveredCommands();
-    return this.initialize();
-  }
-  loadBaseCommands() {
-    const commands = [
-      new ServeCommand(this.app, this.kernel),
-      new MakeCommand(this.app, this.kernel),
-      new MigrateCommand(this.app, this.kernel)
-    ];
-    commands.forEach((e) => this.addCommand(e));
-  }
-  async loadDiscoveredCommands() {
-    const commands = [];
-    commands.forEach((e) => this.addCommand(e));
-  }
-  addCommand(command) {
-    this.commands.push(Signature.parseSignature(command.getSignature(), command));
-  }
-  initialize() {
-    const cliVersion = [
-      "H3ravel Version:",
-      import_chalk3.default.green(this.kernel.consolePackage.version)
-    ].join(" ");
-    const localVersion = [
-      "Musket Version:",
-      import_chalk3.default.green(this.kernel.modulePackage.version || "None")
-    ].join(" ");
-    import_commander.program.name("musket").version(`${cliVersion}
-${localVersion}`);
-    import_commander.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) {
-        const cmd = command.isHidden ? import_commander.program : import_commander.program.command(command.baseCommand).description(command.description ?? "").action(async () => {
-          instance.setInput(cmd.opts(), cmd.args, cmd.registeredArguments, command);
-          await instance.handle();
-        });
-        if ((command.options?.length ?? 0) > 0) {
-          command.options?.filter((v, i2, a) => a.findIndex((t) => t.name === v.name) === i2).forEach((opt) => {
-            this.makeOption(opt, cmd);
-          });
-        }
-        command.subCommands.filter((v, i2, a) => !v.shared && a.findIndex((t) => t.name === v.name) === i2).forEach((sub) => {
-          const cmd2 = import_commander.program.command(`${command.baseCommand}:${sub.name}`).description(sub.description || "").action(async () => {
-            instance.setInput(cmd2.opts(), cmd2.args, cmd2.registeredArguments, sub);
-            await instance.handle();
-          });
-          command.subCommands?.filter((e) => e.shared).forEach((opt) => {
-            this.makeOption(opt, cmd2, false, sub);
-          });
-          command.options?.filter((e) => e.shared).forEach((opt) => {
-            this.makeOption(opt, cmd2, false, sub);
-          });
-          if (sub.nestedOptions) {
-            sub.nestedOptions.filter((v, i2, a) => a.findIndex((t) => t.name === v.name) === i2).forEach((opt) => {
-              this.makeOption(opt, cmd2);
-            });
-          }
-        });
-      } else {
-        const cmd = import_commander.program.command(command.baseCommand).description(command.description ?? "");
-        command?.options?.filter((v, i2, a) => a.findIndex((t) => t.name === v.name) === i2).forEach((opt) => {
-          this.makeOption(opt, cmd, true);
-        });
-        cmd.action(async () => {
-          instance.setInput(cmd.opts(), cmd.args, cmd.registeredArguments, command);
-          await instance.handle();
-        });
-      }
-    }
-    return import_commander.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(", ");
-        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/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;
 
-// src/Kernel.ts
-var import_promises3 = require("fs/promises");
-var import_node_path2 = __toESM(require("path"), 1);
-var Kernel = class _Kernel {
-  static {
-    __name(this, "Kernel");
-  }
-  app;
-  cwd;
-  output = Utils.output();
-  basePath = "";
-  modulePath;
-  consolePath;
-  modulePackage;
-  consolePackage;
-  constructor(app, basePath) {
-    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 (0, import_promises3.mkdir)(dir, {
-      recursive: true
-    });
-  }
-  async loadRequirements() {
-    this.cwd = import_node_path2.default.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(import_node_path2.default.join(this.modulePath, "package.json"));
-    } catch {
-      this.modulePackage = {
-        version: "N/A"
-      };
-    }
-    try {
-      this.consolePackage = await import(import_node_path2.default.join(this.consolePath, "package.json"));
-    } catch {
-      this.consolePackage = {
-        version: "N/A"
-      };
-    }
-    return this;
-  }
+//#endregion
+//#region src/Musket.ts
+/**
+* Musket is H3ravel's CLI tool
+*/
+var Musket = class Musket {
+	commands = [];
+	constructor(app, kernel) {
+		this.app = app;
+		this.kernel = kernel;
+	}
+	async build() {
+		this.loadBaseCommands();
+		await this.loadDiscoveredCommands();
+		return this.initialize();
+	}
+	loadBaseCommands() {
+		[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))];
+		/**
+		* 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 (0, node_fs_promises.glob)(providers_path)) {
+			const name = node_path.default.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() {
+		/** Init the Musket Version */
+		const cliVersion = __h3ravel_shared.Logger.parse([["Musket CLI:", "white"], [this.kernel.consolePackage.version, "green"]], " ", false);
+		/** Init the App Version */
+		const localVersion = __h3ravel_shared.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 */
+		commander.program.name("musket").version(`${cliVersion}\n${localVersion}`).addOption(new commander.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(commander.program.opts(), commander.program.args, commander.program.registeredArguments, {}, commander.program);
+			instance.handle();
+		});
+		/** Create the init Command */
+		commander.program.command("init").description("Initialize H3ravel.").action(async () => {
+			__h3ravel_shared.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;
+			if (command.isNamespaceCommand && command.subCommands) {
+				/**
+				* Initialize the base command
+				*/
+				const cmd = command.isHidden ? commander.program : commander.program.command(command.baseCommand).description(command.description ?? "").addOption(new commander.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, commander.program);
+					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 = commander.program.command(`${command.baseCommand}:${sub.name}`).description(sub.description || "").addOption(new commander.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, commander.program);
+						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 = commander.program.command(command.baseCommand).description(command.description ?? "").addOption(new commander.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, commander.program);
+					await instance.handle();
+				});
+			}
+		}
+		/** Rebuild the app on every command except fire so we wont need TS */
+		commander.program.hook("preAction", async (_, cmd) => {
+			if (cmd.name() !== "fire") await (0, tsdown.build)({
+				...TsdownConfig_default,
+				watch: false,
+				plugins: []
+			});
+		});
+		return commander.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();
+	}
 };
 
-// src/Providers/ConsoleServiceProvider.ts
-var import_core = require("@h3ravel/core");
-var ConsoleServiceProvider = class extends import_core.ServiceProvider {
-  static {
-    __name(this, "ConsoleServiceProvider");
-  }
-  static priority = 992;
-  register() {
-  }
-  boot() {
-    Kernel.init(this.app);
-    new import_node_events.EventEmitter().once("SIGINT", () => process.exit(0));
-    process.on("SIGINT", () => {
-      process.exit(0);
-    });
-    process.on("SIGTERM", () => {
-      process.exit(0);
-    });
-  }
+//#endregion
+//#region src/Kernel.ts
+var Kernel = class Kernel extends __h3ravel_core.ConsoleKernel {
+	constructor(app) {
+		super(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 loadRequirements() {
+		this.cwd = node_path.default.join(process.cwd(), this.basePath);
+		this.modulePath = Helpers.findModulePkg("@h3ravel/core", this.cwd) ?? "";
+		this.consolePath = Helpers.findModulePkg("@h3ravel/console", this.cwd) ?? "";
+		try {
+			this.modulePackage = await import(node_path.default.join(this.modulePath, "package.json"));
+		} catch {
+			this.modulePackage = { version: "N/A" };
+		}
+		try {
+			this.consolePackage = await import(node_path.default.join(this.consolePath, "package.json"));
+		} catch {
+			this.consolePackage = { version: "N/A" };
+		}
+		return this;
+	}
 };
 
-// src/IO/providers.ts
-var providers_default = [
-  import_http.HttpServiceProvider,
-  import_config.ConfigServiceProvider,
-  import_router.RouteServiceProvider,
-  import_router.AssetsServiceProvider,
-  import_database.DatabaseServiceProvider,
-  import_cache.CacheServiceProvider,
-  import_queue.QueueServiceProvider,
-  import_mail.MailServiceProvider,
-  ConsoleServiceProvider
-];
-
-// src/IO/app.ts
-var app_default = class {
-  static {
-    __name(this, "default");
-  }
-  async bootstrap() {
-    const app = new import_core2.Application(process.cwd());
-    app.registerProviders(providers_default);
-    await app.registerConfiguredProviders();
-    await app.boot();
-  }
+//#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 __h3ravel_core.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);
+		});
+	}
 };
 
-// src/run.ts
-var import_esm = require("tsx/esm");
-new app_default().bootstrap();
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  Command,
-  ConsoleServiceProvider,
-  Kernel,
-  MakeCommand,
-  MigrateCommand,
-  Musket,
-  ServeCommand,
-  Signature,
-  TableGuesser,
-  Utils
-});
+//#endregion
+exports.Command = Command;
+exports.ConsoleServiceProvider = ConsoleServiceProvider;
+exports.Kernel = Kernel;
+exports.ListCommand = ListCommand;
+exports.MakeCommand = MakeCommand;
+exports.Musket = Musket;
+exports.Signature = Signature;
+exports.TableGuesser = require_Utils.TableGuesser;
+exports.TsDownConfig = TsDownConfig;
+exports.Utils = require_Utils.Utils;
+exports.altLogo = altLogo;
+exports.logo = logo;
+//# sourceMappingURL=index.cjs.map