commandkit 0.1.11-dev.20250306152436 → 0.1.11-dev.20250307192025

package/dist/index.js

@@ -1011,81 +1011,6 @@ var init_components = __esm({
   }
 });
 
-// src/app/i18n/DefaultLocalizationStrategy.ts
-var import_promises, import_node_path, _DefaultLocalizationStrategy, DefaultLocalizationStrategy;
-var init_DefaultLocalizationStrategy = __esm({
-  "src/app/i18n/DefaultLocalizationStrategy.ts"() {
-    "use strict";
-    init_cjs_shims();
-    import_promises = require("fs/promises");
-    import_node_path = require("path");
-    _DefaultLocalizationStrategy = class _DefaultLocalizationStrategy {
-      constructor(commandkit) {
-        this.commandkit = commandkit;
-      }
-      translations = /* @__PURE__ */ new Map();
-      async locateTranslation(scope, locale) {
-        const localesPath = this.commandkit.getPath("locales");
-        if (!localesPath) return null;
-        const path3 = (0, import_node_path.join)(localesPath, locale, `${scope}.json`);
-        try {
-          const data = await (0, import_promises.readFile)(path3, "utf-8");
-          return JSON.parse(data);
-        } catch {
-          return null;
-        }
-      }
-      async getTranslationStrict(scope, locale) {
-        const key = `${scope}:${locale}`;
-        if (!this.translations.has(key)) {
-          const translation = await this.locateTranslation(scope, locale);
-          if (!translation) {
-            throw new Error(`Translation not found for ${key}`);
-          }
-          this.translations.set(key, translation);
-          return translation;
-        }
-        return this.translations.get(key);
-      }
-      async getTranslation(scope, locale) {
-        try {
-          return this.getTranslationStrict(scope, locale);
-        } catch (e) {
-          return null;
-        }
-      }
-      async translate(request) {
-        const { scope, key, args, locale } = request;
-        const translation = await this.getTranslation(scope, locale);
-        if (!translation) return `${scope}.${key}`;
-        const value = translation.translations[key];
-        const translated = this.applyTranslation(value, args);
-        return translated || `${scope}.${key}`;
-      }
-      applyTranslation(translation, args) {
-        if (!translation || !args) return translation;
-        return translation.replace(/{([^}]+)}/g, (_, key) => {
-          return String(args[key] ?? `{${key}}`);
-        });
-      }
-    };
-    __name(_DefaultLocalizationStrategy, "DefaultLocalizationStrategy");
-    DefaultLocalizationStrategy = _DefaultLocalizationStrategy;
-  }
-});
-
-// src/utils/constants.ts
-var COMMANDKIT_CACHE_TAG, COMMANDKIT_IS_DEV, COMMANDKIT_IS_TEST;
-var init_constants = __esm({
-  "src/utils/constants.ts"() {
-    "use strict";
-    init_cjs_shims();
-    COMMANDKIT_CACHE_TAG = Symbol("kCommandKitCacheTag");
-    COMMANDKIT_IS_DEV = !!process.env.COMMANDKIT_IS_DEV;
-    COMMANDKIT_IS_TEST = process.env.COMMANDKIT_IS_TEST === "true";
-  }
-});
-
 // src/plugins/PluginCommon.ts
 var _PluginCommon, PluginCommon;
 var init_PluginCommon = __esm({
@@ -1157,11 +1082,83 @@ var init_CompilerPlugin = __esm({
 });
 
 // src/plugins/RuntimePlugin.ts
+function isRuntimePlugin(plugin) {
+  return plugin instanceof RuntimePlugin;
+}
+var _RuntimePlugin, RuntimePlugin;
 var init_RuntimePlugin = __esm({
   "src/plugins/RuntimePlugin.ts"() {
     "use strict";
     init_cjs_shims();
     init_PluginCommon();
+    _RuntimePlugin = class _RuntimePlugin extends PluginCommon {
+      /**
+       * Called before commands are loaded
+       */
+      async onBeforeCommandsLoad(ctx) {
+      }
+      /**
+       * Called after commands are loaded
+       */
+      async onAfterCommandsLoad(ctx) {
+      }
+      /**
+       * Called before events are loaded
+       */
+      async onBeforeEventsLoad(ctx) {
+      }
+      /**
+       * Called after events are loaded
+       */
+      async onAfterEventsLoad(ctx) {
+      }
+      /**
+       * Called before the client logs in
+       */
+      async onBeforeClientLogin(ctx) {
+      }
+      /**
+       * Called after the client logs in
+       */
+      async onAfterClientLogin(ctx) {
+      }
+      /**
+       * Called before interaction is handled
+       * @param interaction The interaction
+       */
+      async onBeforeInteraction(ctx, interaction) {
+      }
+      /**
+       * Called after interaction is handled
+       * @param interaction The interaction that was handled
+       */
+      async onAfterInteraction(ctx, interaction) {
+      }
+      /**
+       * Called before message command is processed
+       * @param message The message
+       */
+      async onBeforeMessageCommand(ctx, message) {
+      }
+      /**
+       * Called before message update command is processed
+       * @param message The message
+       */
+      async onBeforeMessageUpdateCommand(ctx, oldMessage, newMessage) {
+      }
+      /**
+       * Called before command is executed. This method can execute the command itself.
+       * @param source The source that triggered the command
+       * @param command The command
+       * @param execute The function that executes the command
+       */
+      async executeCommand(ctx, source, command, execute) {
+        return false;
+      }
+    };
+    __name(_RuntimePlugin, "RuntimePlugin");
+    RuntimePlugin = _RuntimePlugin;
+    __name(isRuntimePlugin, "isRuntimePlugin");
   }
 });
 
@@ -1386,6 +1383,18 @@ var init_CommandKitPluginRuntime = __esm({
       getPlugin(pluginName) {
         return this.plugins.get(pluginName) ?? null;
       }
+      async softRegisterPlugin(plugin) {
+        const pluginName = plugin.name;
+        if (this.plugins.has(pluginName)) return;
+        try {
+          await plugin.activate(this);
+          this.plugins.set(pluginName, plugin);
+        } catch (e) {
+          throw new Error(
+            `Failed to activate plugin "${pluginName}": ${(e == null ? void 0 : e.stack) || e}`
+          );
+        }
+      }
       async registerPlugin(plugin) {
         const pluginName = plugin.name;
         if (this.plugins.has(pluginName)) {
@@ -1467,12 +1476,12 @@ function fromEsbuildPlugin(plugin) {
   let EsbuildPluginCompat = _EsbuildPluginCompat;
   return EsbuildPluginCompat;
 }
-var import_promises2, pattern, _CompilerPluginRuntime, CompilerPluginRuntime;
+var import_promises, pattern, _CompilerPluginRuntime, CompilerPluginRuntime;
 var init_CompilerPluginRuntime = __esm({
   "src/plugins/runtime/CompilerPluginRuntime.ts"() {
     "use strict";
     init_cjs_shims();
-    import_promises2 = require("fs/promises");
+    import_promises = require("fs/promises");
     init_plugins();
     pattern = /\.(c|m)?(t|j)sx?$/;
     _CompilerPluginRuntime = class _CompilerPluginRuntime {
@@ -1485,7 +1494,7 @@ var init_CompilerPluginRuntime = __esm({
       }
       async onLoad(args) {
         var _a;
-        const source = await (0, import_promises2.readFile)(args.path, "utf8");
+        const source = await (0, import_promises.readFile)(args.path, "utf8");
         let contents = source, loader = args.path.split(".").pop();
         for (const plugin of this.plugins) {
           try {
@@ -1956,6 +1965,134 @@ var init_config = __esm({
   }
 });
 
+// src/app/i18n/DefaultLocalizationStrategy.ts
+var import_promises2, import_node_path, import_node_fs, _DefaultLocalizationStrategy, DefaultLocalizationStrategy;
+var init_DefaultLocalizationStrategy = __esm({
+  "src/app/i18n/DefaultLocalizationStrategy.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_promises2 = require("fs/promises");
+    import_node_path = require("path");
+    init_config();
+    import_node_fs = require("fs");
+    _DefaultLocalizationStrategy = class _DefaultLocalizationStrategy {
+      constructor(commandkit) {
+        this.commandkit = commandkit;
+      }
+      translations = /* @__PURE__ */ new Map();
+      async locateTranslation(scope, locale) {
+        const localesPath = this.commandkit.getPath("locales");
+        if (!localesPath) return null;
+        const path3 = (0, import_node_path.join)(localesPath, locale, `${scope}.json`);
+        try {
+          const data = await (0, import_promises2.readFile)(path3, "utf-8");
+          const localeData = JSON.parse(data);
+          await this.generateLocaleTypes(localeData);
+          return localeData;
+        } catch {
+          return null;
+        }
+      }
+      async generateLocaleTypes(localeData) {
+        const { typedLocales } = getConfig();
+        if (!typedLocales) return;
+        const file = (0, import_node_path.join)(
+          process.cwd(),
+          "node_modules",
+          "commandkit-types",
+          "locale_types.d.ts"
+        );
+        const header = `// auto generated file do not edit
+declare module 'commandkit' {
+  export interface CommandLocalizationTypeData {
+`;
+        const footer = `  }
+}`;
+        const generateType = /* @__PURE__ */ __name((locale) => {
+          return `"${locale.command}": ${JSON.stringify(
+            Object.entries(locale.translations).map(([key, value]) => {
+              const args = value.match(/{([^}]+)}/g);
+              if (!args) return `${JSON.stringify(key)}: null`;
+              return `${JSON.stringify(key)}: ${args.map((arg) => arg.slice(1, -1)).join(" | ")}`;
+            }),
+            null,
+            2
+          )}`;
+        }, "generateType");
+        if (!(0, import_node_fs.existsSync)(file)) {
+          const generated = generateType(localeData);
+          await (0, import_promises2.writeFile)(file, `${header}${generated}${footer}`);
+        } else {
+          const data = await (0, import_promises2.readFile)(file, "utf-8");
+          const lines = data.split("\n");
+          const index = lines.findIndex(
+            (line) => line.includes("CommandLocalizationTypeData")
+          );
+          if (index === -1) {
+            for (const locale of this.translations.values()) {
+              const generated2 = generateType(locale);
+              await (0, import_promises2.writeFile)(file, `${header}${generated2}${footer}`);
+            }
+            return;
+          }
+          const start = index + 2;
+          const end = lines.findIndex((line) => line.includes("}"));
+          const generated = generateType(localeData);
+          lines.splice(start, end - start, generated);
+          await (0, import_promises2.writeFile)(file, lines.join("\n"));
+        }
+      }
+      async getTranslationStrict(scope, locale) {
+        const key = `${scope}:${locale}`;
+        if (!this.translations.has(key)) {
+          const translation = await this.locateTranslation(scope, locale);
+          if (!translation) {
+            throw new Error(`Translation not found for ${key}`);
+          }
+          this.translations.set(key, translation);
+          return translation;
+        }
+        return this.translations.get(key);
+      }
+      async getTranslation(scope, locale) {
+        try {
+          return this.getTranslationStrict(scope, locale);
+        } catch (e) {
+          return null;
+        }
+      }
+      async translate(request) {
+        const { scope, key, args, locale } = request;
+        const translation = await this.getTranslation(scope, locale);
+        if (!translation) return `${scope}.${key}`;
+        const value = translation.translations[key];
+        const translated = this.applyTranslation(value, args);
+        return translated || `${scope}.${key}`;
+      }
+      applyTranslation(translation, args) {
+        if (!translation || !args) return translation;
+        return translation.replace(/{([^}]+)}/g, (_, key) => {
+          return String(args[key] ?? `{${key}}`);
+        });
+      }
+    };
+    __name(_DefaultLocalizationStrategy, "DefaultLocalizationStrategy");
+    DefaultLocalizationStrategy = _DefaultLocalizationStrategy;
+  }
+});
+
+// src/utils/constants.ts
+var COMMANDKIT_CACHE_TAG, COMMANDKIT_IS_DEV, COMMANDKIT_IS_TEST;
+var init_constants = __esm({
+  "src/utils/constants.ts"() {
+    "use strict";
+    init_cjs_shims();
+    COMMANDKIT_CACHE_TAG = Symbol("kCommandKitCacheTag");
+    COMMANDKIT_IS_DEV = !!process.env.COMMANDKIT_IS_DEV;
+    COMMANDKIT_IS_TEST = process.env.COMMANDKIT_IS_TEST === "true";
+  }
+});
+
 // src/utils/utilities.ts
 function findAppDirectory() {
   if (appDir) return appDir;
@@ -1963,10 +2100,10 @@ function findAppDirectory() {
     process.cwd(),
     COMMANDKIT_IS_DEV ? ".commandkit" : getConfig().distDir
   );
-  if (!(0, import_node_fs.existsSync)(root)) root = process.cwd();
+  if (!(0, import_node_fs2.existsSync)(root)) root = process.cwd();
   const dirs = ["app"].map((dir) => (0, import_node_path2.join)(root, dir));
   for (const dir of dirs) {
-    if ((0, import_node_fs.existsSync)(dir)) {
+    if ((0, import_node_fs2.existsSync)(dir)) {
       appDir = dir;
       return dir;
     }
@@ -1994,12 +2131,12 @@ function debounce(fn, ms2) {
     });
   };
 }
-var import_node_fs, import_node_path2, appDir;
+var import_node_fs2, import_node_path2, appDir;
 var init_utilities = __esm({
   "src/utils/utilities.ts"() {
     "use strict";
     init_cjs_shims();
-    import_node_fs = require("fs");
+    import_node_fs2 = require("fs");
     import_node_path2 = require("path");
     init_constants();
     init_config();
@@ -3635,256 +3772,243 @@ var init_AppCommandHandler = __esm({
 });
 
 // src/app/router/CommandsRouter.ts
-var import_discord11, import_node_fs2, import_promises3, import_node_path3, import_node_crypto3, _CommandsRouter, CommandsRouter;
+var import_discord11, import_node_fs3, import_promises3, import_posix, _CommandsRouter, CommandsRouter;
 var init_CommandsRouter = __esm({
   "src/app/router/CommandsRouter.ts"() {
     "use strict";
     init_cjs_shims();
     import_discord11 = require("discord.js");
-    import_node_fs2 = require("fs");
+    import_node_fs3 = require("fs");
     import_promises3 = require("fs/promises");
-    import_node_path3 = __toESM(require("path"));
-    import_node_crypto3 = require("crypto");
+    import_posix = __toESM(require("path/posix"));
     _CommandsRouter = class _CommandsRouter {
       constructor(options) {
         this.options = options;
       }
       commands = new import_discord11.Collection();
-      subcommands = new import_discord11.Collection();
       middlewares = new import_discord11.Collection();
+      subcommands = new import_discord11.Collection();
+      isValidPath() {
+        return (0, import_node_fs3.existsSync)(this.entrypoint);
+      }
       get entrypoint() {
         return this.options.entrypoint;
       }
-      isValidPath() {
-        return (0, import_node_fs2.existsSync)(this.entrypoint);
+      clear() {
+        this.commands.clear();
+        this.middlewares.clear();
+        this.subcommands.clear();
+      }
+      async reload() {
+        this.clear();
+        return this.scan();
+      }
+      visualize() {
+        let output = "";
+        const commands = [...this.commands.values()];
+        commands.forEach((command, index) => {
+          const isLast = index === commands.length - 1;
+          const prefix = isLast ? "\u2514\u2500" : "\u251C\u2500";
+          const childPrefix = isLast ? "  " : "\u2502 ";
+          const categoryPrefix = command.category ? `[${command.category}] ` : "";
+          output += `${prefix} ${categoryPrefix}${command.name}
+`;
+          const subcommands = command.subcommands.map((id) => this.subcommands.get(id)).filter(Boolean);
+          const groupedSubs = /* @__PURE__ */ new Map();
+          subcommands.forEach((sub) => {
+            if (!groupedSubs.has(sub.group)) {
+              groupedSubs.set(sub.group, []);
+            }
+            groupedSubs.get(sub.group).push(sub);
+          });
+          const groups = [...groupedSubs.entries()];
+          groups.forEach(([group, subs], groupIndex) => {
+            const isLastGroup = groupIndex === groups.length - 1;
+            if (group) {
+              const groupPrefix = isLastGroup ? `${childPrefix}\u2514\u2500` : `${childPrefix}\u251C\u2500`;
+              output += `${groupPrefix} Group: ${group}
+`;
+            }
+            const subPrefix = group ? `${childPrefix}${isLastGroup ? "  " : "\u2502 "}` : childPrefix;
+            subs.forEach((subcommand, subIndex) => {
+              const isLastSub = subIndex === subs.length - 1;
+              const subCommandPrefix = isLastSub ? `${subPrefix}\u2514\u2500` : `${subPrefix}\u251C\u2500`;
+              output += `${subCommandPrefix} ${subcommand.name}
+`;
+              const middlewares = subcommand.middlewares.map((id) => this.middlewares.get(id)).filter(Boolean);
+              middlewares.forEach((middleware, mwIndex) => {
+                const isLastMw = mwIndex === middlewares.length - 1;
+                const mwPrefix = isLastMw ? `${subPrefix}${isLastSub ? "  " : "\u2502 "}\u2514\u2500` : `${subPrefix}${isLastSub ? "  " : "\u2502 "}\u251C\u2500`;
+                output += `${mwPrefix} \u2699\uFE0F ${middleware.name}
+`;
+              });
+            });
+          });
+          const commandMiddlewares = command.middlewares.map((id) => this.middlewares.get(id)).filter(Boolean);
+          if (commandMiddlewares.length > 0) {
+            output += `${childPrefix}\u2514\u2500 Middlewares:
+`;
+            commandMiddlewares.forEach((middleware, mwIndex) => {
+              const isLastMw = mwIndex === commandMiddlewares.length - 1;
+              const mwPrefix = isLastMw ? `${childPrefix}  \u2514\u2500` : `${childPrefix}  \u251C\u2500`;
+              output += `${mwPrefix} \u2699\uFE0F ${middleware.name}
+`;
+            });
+          }
+          output += "\n";
+        });
+        return output;
       }
       getData() {
         return {
           commands: this.commands,
-          subcommands: this.subcommands,
-          middlewares: this.middlewares
+          middlewares: this.middlewares,
+          subcommands: this.subcommands
         };
       }
       toJSON() {
         return {
           commands: Object.fromEntries(this.commands.entries()),
-          subcommands: Object.fromEntries(this.subcommands.entries()),
-          middlewares: Object.fromEntries(this.middlewares.entries())
+          middlewares: Object.fromEntries(this.middlewares.entries()),
+          subcommands: Object.fromEntries(this.subcommands.entries())
         };
       }
-      clear() {
-        this.commands.clear();
-        this.subcommands.clear();
-        this.middlewares.clear();
-      }
-      async reload() {
-        this.clear();
-        return this.scan();
-      }
       async scan() {
-        await this.scanDirectory(this.entrypoint);
+        if (!this.isValidPath()) return this.toJSON();
+        const root = this.entrypoint;
+        await this.scanDeep(root);
         return this.toJSON();
       }
-      async scanDirectory(dir, parentPath = "", categories = []) {
-        const entries = await (0, import_promises3.readdir)(dir);
-        const directoryStats = /* @__PURE__ */ new Map();
-        for (const entry of entries) {
-          if (entry.startsWith("_")) continue;
-          const fullPath = import_node_path3.default.join(dir, entry);
-          const stats = await (0, import_promises3.stat)(fullPath);
-          directoryStats.set(entry, stats.isDirectory());
-        }
-        await this.processMiddlewares(dir, entries, parentPath, categories);
-        for (const entry of entries) {
-          if (entry.startsWith("_")) continue;
-          if (entry.includes(".middleware.")) continue;
-          const fullPath = import_node_path3.default.join(dir, entry);
-          const isDirectory = directoryStats.get(entry) || false;
-          if (isDirectory) {
-            const { name, parsedCategories } = this.parseNameAndCategory(entry);
-            const newCategories = [...categories, ...parsedCategories];
-            const isCategoryContainer = /^\([^)]+\)$/.test(entry);
-            if (isCategoryContainer) {
-              await this.scanDirectory(fullPath, parentPath, newCategories);
-            } else {
-              const newParentPath = parentPath ? `${parentPath}/${name}` : name;
-              await this.processCommandDirectory(
-                fullPath,
-                name,
-                newParentPath,
-                newCategories
-              );
+      async scanDeep(entry, currentDepth = 2) {
+        const normalizedPath = import_posix.default.normalize(entry);
+        const content = await (0, import_promises3.readdir)(normalizedPath, { withFileTypes: true });
+        for (const item of content) {
+          const itemPath = import_posix.default.join(normalizedPath, item.name);
+          if (this.shouldIgnore(itemPath, item.isDirectory())) continue;
+          if (item.isDirectory()) {
+            const isCategoryDir = this.isCategoryDirectory(item.name);
+            if (currentDepth > 0 || isCategoryDir) {
+              const nextDepth = isCategoryDir ? currentDepth : currentDepth - 1;
+              await this.scanDeep(itemPath, nextDepth);
             }
           } else {
-            if (!/\.(m|c)?(j|t)sx?$/.test(entry)) {
-              continue;
-            }
-            const extname = import_node_path3.default.extname(entry);
-            const basename = import_node_path3.default.basename(entry, extname);
-            if (basename === "index") {
-              continue;
-            }
-            const { name, parsedCategories } = this.parseNameAndCategory(basename);
-            const newCategories = [...categories, ...parsedCategories];
-            if (parentPath) {
-              await this.processSubCommand(
-                fullPath,
-                name,
-                parentPath,
-                newCategories
+            const isInnerSubCommand = currentDepth === 0;
+            const isSubCommandGroup = currentDepth === 1;
+            const category = this.extractCategory(itemPath);
+            const fileName = this.extractName(itemPath);
+            const isIndexFile = fileName === "index" && normalizedPath !== this.entrypoint;
+            if (this.isMiddleware(itemPath)) {
+              this.processMiddleware(itemPath, category);
+            } else if (isInnerSubCommand || isSubCommandGroup) {
+              this.processSubcommand(
+                itemPath,
+                import_posix.default.basename(normalizedPath),
+                isSubCommandGroup,
+                isIndexFile
               );
             } else {
-              await this.processCommand(fullPath, name, newCategories);
+              this.processCommand(
+                itemPath,
+                category,
+                isIndexFile ? normalizedPath : null
+              );
             }
           }
         }
       }
-      async processMiddlewares(dir, entries, parentPath, categories) {
-        for (const entry of entries) {
-          if (entry.startsWith("_")) continue;
-          if (!entry.includes(".middleware.")) continue;
-          const fullPath = import_node_path3.default.join(dir, entry);
-          const stats = await (0, import_promises3.stat)(fullPath);
-          if (stats.isDirectory()) continue;
-          if (!/\.(m|c)?(j|t)sx?$/.test(entry)) {
-            continue;
-          }
-          const extname = import_node_path3.default.extname(entry);
-          const basename = import_node_path3.default.basename(entry, extname);
-          const middlewareSegments = basename.split(".middleware");
-          const middlewareName = middlewareSegments[0];
-          const { name, parsedCategories } = this.parseNameAndCategory(middlewareName);
-          const newCategories = [...categories, ...parsedCategories];
-          const category = newCategories.length ? newCategories.join(":") : null;
-          const middleware = {
-            name,
-            id: (0, import_node_crypto3.randomUUID)(),
-            // Using randomUUID for unique ID generation
-            path: fullPath,
-            category
-          };
-          this.middlewares.set(middleware.id, middleware);
-        }
+      processMiddleware(filePath, category) {
+        const middleware = {
+          id: crypto.randomUUID(),
+          name: this.getAppropriateFileName(filePath),
+          path: filePath,
+          relativePath: this.getRelativePath(filePath),
+          category
+        };
+        this.middlewares.set(middleware.id, middleware);
+        this.applyMiddlewareToCommands(middleware);
       }
-      async processCommand(filePath, name, categories) {
-        const category = categories.length ? categories.join(":") : null;
-        const id = (0, import_node_crypto3.randomUUID)();
-        const middlewares = this.findAssociatedMiddlewares(name, category);
-        const command = {
-          id,
-          name,
+      processSubcommand(filePath, parentDirName, isGrouped, isIndexFile = false) {
+        const subcommand = {
+          id: crypto.randomUUID(),
+          name: isIndexFile ? this.getDirectoryName(filePath) : this.extractName(filePath),
+          group: isGrouped ? parentDirName : null,
+          middlewares: [],
           path: filePath,
-          category,
-          subcommands: [],
-          middlewares
+          relativePath: this.getRelativePath(filePath)
         };
-        this.commands.set(id, command);
-      }
-      async processCommandDirectory(dirPath, name, parentPath, categories) {
-        const category = categories.length ? categories.join(":") : null;
-        const id = (0, import_node_crypto3.randomUUID)();
-        let indexFile = null;
-        const possibleExtensions = [
-          ".js",
-          ".ts",
-          ".jsx",
-          ".tsx",
-          ".mjs",
-          ".cjs",
-          ".mts",
-          ".cts"
-        ];
-        for (const ext of possibleExtensions) {
-          const testPath = import_node_path3.default.join(dirPath, `index${ext}`);
-          if ((0, import_node_fs2.existsSync)(testPath)) {
-            indexFile = testPath;
-            break;
-          }
-        }
-        const middlewares = this.findAssociatedMiddlewares(name, category);
-        const entries = await (0, import_promises3.readdir)(dirPath);
-        const subcommands = [];
-        for (const entry of entries) {
-          if (entry.startsWith("_") || entry.startsWith("index.")) continue;
-          const fullPath = import_node_path3.default.join(dirPath, entry);
-          const stats = await (0, import_promises3.stat)(fullPath);
-          const isDirectory = stats.isDirectory();
-          if (!isDirectory && !/\.(m|c)?(j|t)sx?$/.test(entry)) {
-            continue;
-          }
-          if (!isDirectory || isDirectory && !entry.includes(".")) {
-            const extname = isDirectory ? "" : import_node_path3.default.extname(entry);
-            const baseName = isDirectory ? entry : import_node_path3.default.basename(entry, extname);
-            if (!baseName.includes(".middleware")) {
-              const { name: subName } = this.parseNameAndCategory(baseName);
-              subcommands.push(subName);
-            }
-          }
-        }
+        this.subcommands.set(subcommand.id, subcommand);
+        this.applySubcommandToCommands(subcommand);
+      }
+      processCommand(filePath, category, parentPath = null) {
         const command = {
-          id,
-          name,
-          path: indexFile,
-          // This can be null if no index file exists
+          id: crypto.randomUUID(),
+          name: parentPath ? this.getDirectoryName(parentPath) : this.extractName(filePath),
+          path: filePath,
+          relativePath: this.getRelativePath(filePath),
           category,
-          subcommands,
-          middlewares
+          middlewares: [],
+          subcommands: []
         };
-        this.commands.set(id, command);
-        await this.scanDirectory(dirPath, id, categories);
+        this.commands.set(command.id, command);
       }
-      async processSubCommand(filePath, name, parentPath, categories) {
-        if (!/\.(m|c)?(j|t)sx?$/.test(filePath)) {
-          return;
+      /**
+       * Gets the appropriate file name, handling index files specially
+       * For index files, it returns the parent directory name (excluding category markers)
+       */
+      getAppropriateFileName(filePath) {
+        const fileName = this.extractName(filePath);
+        if (fileName === "index" && import_posix.default.dirname(filePath) !== this.entrypoint) {
+          return this.getDirectoryName(filePath);
         }
-        const pathSegments = parentPath.split("/");
-        let group = null;
-        if (pathSegments.length > 1) {
-          group = pathSegments[1];
+        return fileName;
+      }
+      /**
+       * Extract the clean directory name, removing any category markers
+       */
+      getDirectoryName(filePath) {
+        const dirName = import_posix.default.basename(import_posix.default.dirname(filePath));
+        return dirName.replace(/^\((\w+)\)$/, "$1");
+      }
+      // Helper method to identify category directories
+      isCategoryDirectory(dirName) {
+        return /^\(\w+\)$/.test(dirName);
+      }
+      applyMiddlewareToCommands(middleware) {
+        for (const command of this.commands.values()) {
+          const middlewareFileName = import_posix.default.basename(middleware.path);
+          const match = middlewareFileName.startsWith(command.name) || middlewareFileName === "middleware";
+          if (!match) continue;
+          if (command.middlewares.includes(middleware.id)) continue;
+          command.middlewares.push(middleware.id);
         }
-        const category = categories.length ? categories.join(":") : null;
-        const id = (0, import_node_crypto3.randomUUID)();
-        const middlewares = this.findAssociatedMiddlewares(name, category);
-        const subcommand = {
-          id,
-          name,
-          path: filePath,
-          category,
-          group,
-          middlewares
-        };
-        this.subcommands.set(id, subcommand);
-      }
-      parseNameAndCategory(name) {
-        const parsedCategories = [];
-        const regex = /\(([^)]+)\)/g;
-        let match;
-        let cleanName = name;
-        while ((match = regex.exec(name)) !== null) {
-          parsedCategories.push(match[1]);
-          cleanName = cleanName.replace(match[0], "");
+      }
+      applySubcommandToCommands(subcommand) {
+        for (const command of this.commands.values()) {
+          if (!subcommand.path.startsWith(command.path)) continue;
+          if (command.subcommands.includes(subcommand.id)) continue;
+          command.subcommands.push(subcommand.id);
         }
-        return {
-          name: cleanName.trim(),
-          parsedCategories
-        };
       }
-      findAssociatedMiddlewares(commandName, category) {
-        const middlewares = [];
-        this.middlewares.forEach((middleware) => {
-          if (middleware.name === "middleware") {
-            middlewares.push(middleware.id);
-            return;
-          }
-          if (middleware.name === commandName) {
-            middlewares.push(middleware.id);
-            return;
-          }
-          if (category && middleware.category === category) {
-            middlewares.push(middleware.id);
-          }
-        });
-        return middlewares;
+      extractCategory(entry) {
+        return entry.split(import_posix.default.sep).map((segment) => {
+          const match = segment.match(/^\((\w+)\)$/);
+          return match ? match[1] : null;
+        }).filter(Boolean).join(":");
+      }
+      getRelativePath(entry) {
+        return import_posix.default.relative(this.entrypoint, entry);
+      }
+      isMiddleware(entry) {
+        return !this.shouldIgnore(entry) && ["middleware", ".middleware."].some((ext) => entry.includes(ext));
+      }
+      shouldIgnore(entry, dir = false) {
+        const fileName = import_posix.default.basename(entry);
+        if (fileName.startsWith("_")) return true;
+        if (!dir) return !/.(c|m)?(j|t)sx?$/.test(fileName);
+        return false;
+      }
+      extractName(entry) {
+        return import_posix.default.basename(entry).replace(/\.(c|m)?(j|t)sx?$/, "");
       }
     };
     __name(_CommandsRouter, "CommandsRouter");
@@ -3893,14 +4017,14 @@ var init_CommandsRouter = __esm({
 });
 
 // src/app/router/EventsRouter.ts
-var import_node_fs3, import_promises4, import_node_path4, _EventsRouter, EventsRouter;
+var import_node_fs4, import_promises4, import_node_path3, _EventsRouter, EventsRouter;
 var init_EventsRouter = __esm({
   "src/app/router/EventsRouter.ts"() {
     "use strict";
     init_cjs_shims();
-    import_node_fs3 = require("fs");
+    import_node_fs4 = require("fs");
     import_promises4 = require("fs/promises");
-    import_node_path4 = require("path");
+    import_node_path3 = require("path");
     _EventsRouter = class _EventsRouter {
       /**
        * Creates a new EventsRouter instance
@@ -3934,7 +4058,7 @@ var init_EventsRouter = __esm({
        * Checks if the entrypoint path is valid
        */
       isValidPath() {
-        return (0, import_node_fs3.existsSync)(this.entrypoint);
+        return (0, import_node_fs4.existsSync)(this.entrypoint);
       }
       /**
        * Clear all parsed events
@@ -3958,7 +4082,7 @@ var init_EventsRouter = __esm({
         const dirs = await (0, import_promises4.readdir)(this.entrypoint, { withFileTypes: true });
         for (const dir of dirs) {
           if (dir.isDirectory()) {
-            const path3 = (0, import_node_path4.join)(this.entrypoint, dir.name);
+            const path3 = (0, import_node_path3.join)(this.entrypoint, dir.name);
             const event = await this.scanEvent(dir.name, path3);
             this.events.set(event.event, event);
           }
@@ -3985,12 +4109,12 @@ var init_EventsRouter = __esm({
         for (const file of files) {
           if (/node_modules/.test(file.name)) continue;
           if (file.isDirectory()) {
-            const nextPath = (0, import_node_path4.join)(path3, file.name);
+            const nextPath = (0, import_node_path3.join)(path3, file.name);
             await this.scanEvent(event, nextPath, listeners);
             continue;
           }
           if (file.isFile() && /\.(m|c)?(j|t)sx?$/.test(file.name)) {
-            listeners.push((0, import_node_path4.join)(file.parentPath, file.name));
+            listeners.push((0, import_node_path3.join)(file.parentPath, file.name));
           }
         }
         const maybeNamespace = path3.replace(this.entrypoint, "").replaceAll("\\", "/").split("/").shift();
@@ -4042,7 +4166,10 @@ var init_AppEventsHandler = __esm({
                 `Event handler for ${event.event}${event.namespace ? ` of namespace ${event.namespace}` : ""} does not have a default export or is not a function`
               );
             }
-            listeners.push(handler.default);
+            listeners.push({
+              handler: handler.default,
+              once: !!handler.once
+            });
           }
           const len = listeners.length;
           if (!len) {
@@ -4070,11 +4197,28 @@ var init_AppEventsHandler = __esm({
       registerAllClientEvents() {
         const client = this.commandkit.client;
         for (const [key, data] of this.loadedEvents.entries()) {
-          const { name, listeners, namespace, mainListener } = data;
-          const main = mainListener || (async (...args) => {
-            for (const listener of listeners) {
+          const { name, listeners, namespace } = data;
+          const onceListeners = listeners.filter((listener) => listener.once);
+          const onListeners = listeners.filter((listener) => !listener.once);
+          const executedOnceListeners = /* @__PURE__ */ new Set();
+          const mainHandler = /* @__PURE__ */ __name(async (...args) => {
+            for (const listener of onListeners) {
+              try {
+                await listener.handler(...args);
+              } catch (e) {
+                Logger.error(
+                  `Error handling event ${name}${namespace ? ` of namespace ${namespace}` : ""}`,
+                  e
+                );
+              }
+            }
+          }, "mainHandler");
+          const onceHandler = /* @__PURE__ */ __name(async (...args) => {
+            for (const listener of onceListeners) {
               try {
-                await listener(...args);
+                if (executedOnceListeners.has(listener.handler)) continue;
+                await listener.handler(...args);
+                executedOnceListeners.add(listener.handler);
               } catch (e) {
                 Logger.error(
                   `Error handling event ${name}${namespace ? ` of namespace ${namespace}` : ""}`,
@@ -4082,16 +4226,35 @@ var init_AppEventsHandler = __esm({
                 );
               }
             }
+            if (executedOnceListeners.size === onceListeners.length && onListeners.length === 0) {
+              this.loadedEvents.delete(key);
+              Logger.info(
+                `\u{1F9F9} Cleaned up completed once-only event ${name}${namespace ? ` of namespace ${namespace}` : ""}`
+              );
+            }
+          }, "onceHandler");
+          this.loadedEvents.set(key, {
+            ...data,
+            mainListener: onListeners.length > 0 ? { handler: mainHandler, once: false } : void 0,
+            executedOnceListeners
           });
-          if (!mainListener) {
-            this.loadedEvents.set(key, {
-              ...data,
-              mainListener: main
-            });
+          if (namespace) {
+            if (onListeners.length > 0) {
+              this.commandkit.events.on(namespace, name, mainHandler);
+            }
+            if (onceListeners.length > 0) {
+              this.commandkit.events.once(namespace, name, onceHandler);
+            }
+          } else {
+            if (onListeners.length > 0) {
+              client.on(name, mainHandler);
+            }
+            if (onceListeners.length > 0) {
+              client.once(name, onceHandler);
+            }
           }
-          client.on(name, main);
           Logger.info(
-            `\u{1F50C} Registered event ${name}${namespace ? ` of namespace ${namespace}` : ""}`
+            `\u{1F50C} Registered event ${name}${namespace ? ` of namespace ${namespace}` : ""} (${onListeners.length} regular, ${onceListeners.length} once-only)`
           );
         }
       }
@@ -4102,9 +4265,17 @@ var init_AppEventsHandler = __esm({
           { name, mainListener, namespace }
         ] of this.loadedEvents.entries()) {
           if (mainListener) {
-            client.off(name, mainListener);
+            if (namespace) {
+              this.commandkit.events.off(namespace, name, mainListener.handler);
+            } else {
+              client.off(name, mainListener.handler);
+            }
           } else {
-            client.removeAllListeners(name);
+            if (namespace) {
+              this.commandkit.events.removeAllListeners(namespace, name);
+            } else {
+              client.removeAllListeners(name);
+            }
           }
           this.loadedEvents.delete(key);
           Logger.info(
@@ -4118,6 +4289,54 @@ var init_AppEventsHandler = __esm({
   }
 });
 
+// src/utils/types-package.ts
+async function generateTypesPackage() {
+  const location = (0, import_node_path4.join)(process.cwd(), "node_modules", "commandkit-types");
+  const packageJSON = (0, import_node_path4.join)(location, "package.json");
+  const index = (0, import_node_path4.join)(location, "index.js");
+  const types = (0, import_node_path4.join)(location, "index.d.ts");
+  const locale = (0, import_node_path4.join)(location, "locale.d.ts");
+  const command = (0, import_node_path4.join)(location, "command.d.ts");
+  const exists = (0, import_node_fs5.existsSync)(packageJSON);
+  if (exists) return location;
+  const packageJSONContent = {
+    name: "commandkit-types",
+    version: "1.0.0",
+    description: "CommandKit types package",
+    type: "commonjs",
+    main: "index.js",
+    types: "index.d.ts"
+  };
+  const indexContent = `module.exports = {};`;
+  const typesContent = `import { CommandLocalizationTypeData } from './locale.d.ts';
+  import { CommandTypeData } from './command.d.ts';
+  
+  declare module 'commandkit' {
+    export interface CommandKitTypeReferences {
+      locale: CommandLocalizationTypeData;
+      command: CommandTypeData;
+    }
+  }`;
+  await (0, import_promises5.mkdir)(location, { recursive: true });
+  await (0, import_promises5.writeFile)(packageJSON, JSON.stringify(packageJSONContent, null, 2));
+  await (0, import_promises5.writeFile)(index, indexContent);
+  await (0, import_promises5.writeFile)(types, typesContent);
+  await (0, import_promises5.writeFile)(locale, "");
+  await (0, import_promises5.writeFile)(command, "");
+  return location;
+}
+var import_node_fs5, import_promises5, import_node_path4;
+var init_types_package = __esm({
+  "src/utils/types-package.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_node_fs5 = require("fs");
+    import_promises5 = require("fs/promises");
+    import_node_path4 = require("path");
+    __name(generateTypesPackage, "generateTypesPackage");
+  }
+});
+
 // src/cli/common.ts
 function write(message) {
   process.stdout.write(message);
@@ -4145,7 +4364,7 @@ async function loadConfigFileFromPath(target) {
   const isTs = await ensureTypeScript(target);
   if (isTs && ts) {
     const { transpileModule } = ts;
-    const src = import_node_fs4.default.readFileSync(target, "utf8");
+    const src = import_node_fs6.default.readFileSync(target, "utf8");
     const { outputText } = transpileModule(src, {
       compilerOptions: {
         module: ts.ModuleKind.ESNext,
@@ -4154,14 +4373,9 @@ async function loadConfigFileFromPath(target) {
       },
       fileName: target
     });
-    const nodeModulesPath = (0, import_node_path5.join)(
-      process.cwd(),
-      "node_modules",
-      ".commandkit_tmp"
-    );
-    import_node_fs4.default.mkdirSync(nodeModulesPath, { recursive: true });
+    const nodeModulesPath = await generateTypesPackage();
     const tmpFile = (0, import_node_path5.join)(nodeModulesPath, "compiled-commandkit.config.mjs");
-    import_node_fs4.default.writeFileSync(tmpFile, outputText);
+    import_node_fs6.default.writeFileSync(tmpFile, outputText);
     target = tmpFile;
   }
   const config = await import(`file://${target}`).then(
@@ -4170,20 +4384,21 @@ async function loadConfigFileFromPath(target) {
   return config;
 }
 async function ensureExists(loc) {
-  const exists = import_node_fs4.default.existsSync(loc);
+  const exists = import_node_fs6.default.existsSync(loc);
   if (!exists) {
     throw new Error(`File not found: ${loc}`);
   }
 }
-var import_rimraf, import_node_path5, import_node_fs4, ts;
+var import_rimraf, import_node_path5, import_node_fs6, ts;
 var init_common = __esm({
   "src/cli/common.ts"() {
     "use strict";
     init_cjs_shims();
     import_rimraf = require("rimraf");
     import_node_path5 = require("path");
-    import_node_fs4 = __toESM(require("fs"));
+    import_node_fs6 = __toESM(require("fs"));
     init_colors();
+    init_types_package();
     __name(write, "write");
     __name(panic, "panic");
     __name(ensureTypeScript, "ensureTypeScript");
@@ -4196,7 +4411,7 @@ var init_common = __esm({
 function findConfigFile(cwd) {
   const locations = CONFIG_FILE_NAMES.map((name) => (0, import_node_path6.join)(cwd, name));
   for (const location of locations) {
-    if ((0, import_node_fs5.existsSync)(location)) {
+    if ((0, import_node_fs7.existsSync)(location)) {
       return {
         path: location,
         isTypeScript: /\.ts$/.test(location)
@@ -4213,12 +4428,12 @@ async function loadConfigFile(entrypoint = process.cwd()) {
   loadedConfig = config;
   return config;
 }
-var import_node_fs5, import_node_path6, CONFIG_FILE_NAMES, loadedConfig;
+var import_node_fs7, import_node_path6, CONFIG_FILE_NAMES, loadedConfig;
 var init_loader = __esm({
   "src/config/loader.ts"() {
     "use strict";
     init_cjs_shims();
-    import_node_fs5 = require("fs");
+    import_node_fs7 = require("fs");
     import_node_path6 = require("path");
     init_common();
     init_config();
@@ -4267,13 +4482,59 @@ var init_dev_hooks = __esm({
   }
 });
 
+// src/events/CommandKitEventsChannel.ts
+var import_node_events, _CommandKitEventsChannel, CommandKitEventsChannel;
+var init_CommandKitEventsChannel = __esm({
+  "src/events/CommandKitEventsChannel.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_node_events = __toESM(require("events"));
+    _CommandKitEventsChannel = class _CommandKitEventsChannel {
+      constructor(commandkit) {
+        this.commandkit = commandkit;
+      }
+      emitter = new import_node_events.default();
+      to(namespace) {
+        return {
+          on: this.on.bind(this, namespace),
+          off: this.off.bind(this, namespace),
+          once: this.once.bind(this, namespace),
+          emit: this.emit.bind(this, namespace),
+          removeAllListeners: this.removeAllListeners.bind(this, namespace)
+        };
+      }
+      on(namespace, event, listener) {
+        this.emitter.on(`${namespace}:${event}`, listener);
+      }
+      off(namespace, event, listener) {
+        this.emitter.off(`${namespace}:${event}`, listener);
+      }
+      once(namespace, event, listener) {
+        this.emitter.once(`${namespace}:${event}`, listener);
+      }
+      emit(namespace, event, ...args) {
+        return this.emitter.emit(`${namespace}:${event}`, ...args);
+      }
+      removeAllListeners(namespace, event) {
+        if (event) {
+          this.emitter.removeAllListeners(`${namespace}:${event}`);
+        } else {
+          this.emitter.removeAllListeners(namespace);
+        }
+      }
+    };
+    __name(_CommandKitEventsChannel, "CommandKitEventsChannel");
+    CommandKitEventsChannel = _CommandKitEventsChannel;
+  }
+});
+
 // src/CommandKit.ts
-var import_node_events, import_discord12, import_node_path7, import_node_fs6, _started, _CommandKit_instances, init_fn, initCommands_fn, initEvents_fn, _CommandKit, CommandKit;
+var import_node_events2, import_discord12, import_node_path7, _started, _CommandKit_instances, init_fn, initCommands_fn, initEvents_fn, _CommandKit, CommandKit;
 var init_CommandKit = __esm({
   "src/CommandKit.ts"() {
     "use strict";
     init_cjs_shims();
-    import_node_events = __toESM(require("events"));
+    import_node_events2 = __toESM(require("events"));
     init_colors();
     init_CacheProvider();
     init_MemoryCache();
@@ -4290,8 +4551,11 @@ var init_CommandKit = __esm({
     init_loader();
     init_constants();
     init_dev_hooks();
-    import_node_fs6 = require("fs");
-    _CommandKit = class _CommandKit extends import_node_events.default {
+    init_CommandKitEventsChannel();
+    init_plugins();
+    init_types_package();
+    init_Logger();
+    _CommandKit = class _CommandKit extends import_node_events2.default {
       /**
        * Create a new command and event handler with CommandKit.
        *
@@ -4332,6 +4596,7 @@ var init_CommandKit = __esm({
         __publicField(this, "commandHandler", new AppCommandHandler(this));
         __publicField(this, "eventHandler", new AppEventsHandler(this));
         __publicField(this, "plugins");
+        __publicField(this, "events", new CommandKitEventsChannel(this));
         options.debugCommands ??= process.env.NODE_ENV !== "production";
         if (options.cacheProvider !== null && (!options.cacheProvider || !(options.cacheProvider instanceof CacheProvider))) {
           options.cacheProvider = new MemoryCache();
@@ -4347,8 +4612,18 @@ var init_CommandKit = __esm({
        * @param token The application token to connect to the discord gateway. If not provided, it will use the `TOKEN` or `DISCORD_TOKEN` environment variable. If set to `false`, it will not login.
        */
       async start(token) {
-        await loadConfigFile();
         if (__privateGet(this, _started)) return;
+        if (COMMANDKIT_IS_DEV) {
+          try {
+            registerDevHooks(this);
+            await generateTypesPackage();
+          } catch (e) {
+            if (process.env.COMMANDKIT_DEBUG_TYPEGEN) {
+              Logger.error(e);
+            }
+          }
+        }
+        await this.loadPlugins();
         await __privateMethod(this, _CommandKit_instances, init_fn).call(this);
         this.incrementClientListenersCount();
         if (token !== false && !this.options.client.isReady()) {
@@ -4357,11 +4632,19 @@ var init_CommandKit = __esm({
           );
         }
         __privateSet(this, _started, true);
-        if (COMMANDKIT_IS_DEV) {
-          registerDevHooks(this);
-        }
         await this.commandHandler.registrar.register();
       }
+      /**
+       * Loads all the plugins.
+       */
+      async loadPlugins() {
+        const config = await loadConfigFile();
+        const plugins = config.plugins.filter((p) => isRuntimePlugin(p));
+        if (!plugins.length) return;
+        for (const plugin of plugins) {
+          await this.plugins.softRegisterPlugin(plugin);
+        }
+      }
       /**
        * Whether or not the commandkit application has started.
        */
@@ -4517,8 +4800,11 @@ var init_CommandKit = __esm({
     }, "#init");
     initCommands_fn = /* @__PURE__ */ __name(async function() {
       if (this.commandsRouter.isValidPath()) {
-        const commands = await this.commandsRouter.scan();
-        await (0, import_node_fs6.writeFileSync)("./commands.json", JSON.stringify(commands, null, 2));
+        await this.commandsRouter.scan();
+        if (COMMANDKIT_IS_DEV) {
+          const visual = this.commandsRouter.visualize();
+          console.log(visual);
+        }
       }
       await this.commandHandler.loadCommands();
     }, "#initCommands");
@@ -4547,7 +4833,7 @@ var init_version = __esm({
     "use strict";
     init_cjs_shims();
     version = /* @__MACRO__ $version */
-    "0.1.11-dev.20250306152436";
+    "0.1.11-dev.20250307192025";
   }
 });
 
@@ -4589,7 +4875,7 @@ function getStdio(supportsCommands) {
 }
 function createAppProcess(fileName, cwd, isDev) {
   var _a, _b;
-  if (!(0, import_node_fs7.existsSync)((0, import_node_path8.join)(cwd, fileName))) {
+  if (!(0, import_node_fs8.existsSync)((0, import_node_path8.join)(cwd, fileName))) {
     panic(`Could not locate the entrypoint file: ${fileName}`);
   }
   const stdio = getStdio(isDev);
@@ -4611,7 +4897,7 @@ function createAppProcess(fileName, cwd, isDev) {
   (_b = ps.stderr) == null ? void 0 : _b.pipe(process.stderr);
   return ps;
 }
-var import_node_child_process, import_node_path8, import_node_fs7;
+var import_node_child_process, import_node_path8, import_node_fs8;
 var init_app_process = __esm({
   "src/cli/app-process.ts"() {
     "use strict";
@@ -4619,7 +4905,7 @@ var init_app_process = __esm({
     import_node_child_process = require("child_process");
     init_env();
     import_node_path8 = require("path");
-    import_node_fs7 = require("fs");
+    import_node_fs8 = require("fs");
     init_common();
     __name(getStdio, "getStdio");
     __name(createAppProcess, "createAppProcess");
@@ -4706,9 +4992,9 @@ async function main() {
 await main();
 `;
   const dist = isDev ? ".commandkit" : distDir || "dist";
-  await (0, import_promises5.writeFile)((0, import_node_path9.join)(configPath, dist, "index.js"), code);
+  await (0, import_promises6.writeFile)((0, import_node_path9.join)(configPath, dist, "index.js"), code);
 }
-var import_tsup, import_promises5, import_node_path9, envScript, requireScript, antiCrashScript, wrapInAsyncIIFE;
+var import_tsup, import_promises6, import_node_path9, envScript, requireScript, antiCrashScript, wrapInAsyncIIFE;
 var init_build = __esm({
   "src/cli/build.ts"() {
     "use strict";
@@ -4716,7 +5002,7 @@ var init_build = __esm({
     import_tsup = require("tsup");
     init_plugins();
     init_loader();
-    import_promises5 = require("fs/promises");
+    import_promises6 = require("fs/promises");
     import_node_path9 = require("path");
     init_env();
     __name(buildApplication, "buildApplication");
@@ -4861,7 +5147,7 @@ async function bootstrapDevelopmentServer(configPath) {
   watcher.on("add", hmrHandler);
   watcher.on("unlink", hmrHandler);
   watcher.on("unlinkDir", (path3) => {
-    const hasChild = (0, import_node_fs8.readdirSync)(path3).length > 0;
+    const hasChild = (0, import_node_fs9.readdirSync)(path3).length > 0;
     if (hasChild) return hmrHandler(path3);
   });
   watcher.on("error", (e) => {
@@ -4880,7 +5166,7 @@ ${colors_default.yellowBright("re")} - Reload all events
 ${colors_default.yellowBright("rl")} - Reload all locales`
   );
 }
-var import_path2, import_chokidar, import_node_fs8, isCommandSource, isEventSource, isLocaleSource;
+var import_path2, import_chokidar, import_node_fs9, isCommandSource, isEventSource, isLocaleSource;
 var init_development = __esm({
   "src/cli/development.ts"() {
     "use strict";
@@ -4891,7 +5177,7 @@ var init_development = __esm({
     init_app_process();
     init_build();
     import_chokidar = require("chokidar");
-    import_node_fs8 = require("fs");
+    import_node_fs9 = require("fs");
     init_utilities();
     init_colors();
     __name(buildAndStart, "buildAndStart");
@@ -4978,7 +5264,7 @@ __export(generators_exports, {
 });
 async function generateCommand(name, customPath) {
   const cmdPath = (0, import_path4.join)(customPath || COMMANDS_DIR, name);
-  if (!(0, import_fs2.existsSync)(cmdPath)) await (0, import_promises6.mkdir)(cmdPath, { recursive: true });
+  if (!(0, import_fs2.existsSync)(cmdPath)) await (0, import_promises7.mkdir)(cmdPath, { recursive: true });
   if ((0, import_fs2.existsSync)((0, import_path4.join)(cmdPath, "command.ts"))) {
     panic(`Command ${name} already exists.`);
   }
@@ -4998,7 +5284,7 @@ export const message: MessageCommand = async (ctx) => {
   await ctx.message.reply('Hello from ${name}!');
 };
 `.trim();
-  await (0, import_promises6.writeFile)((0, import_path4.join)(cmdPath, "command.ts"), commandFile);
+  await (0, import_promises7.writeFile)((0, import_path4.join)(cmdPath, "command.ts"), commandFile);
   console.log(
     colors_default.green(
       `Command ${colors_default.magenta(name)} created at ${colors_default.blue(formatPath(cmdPath))}/command.ts`
@@ -5007,10 +5293,10 @@ export const message: MessageCommand = async (ctx) => {
 }
 async function generateEvent(name, customPath) {
   const eventPath = (0, import_path4.join)(customPath || EVENTS_DIR, name);
-  if (!(0, import_fs2.existsSync)(eventPath)) await (0, import_promises6.mkdir)(eventPath, { recursive: true });
+  if (!(0, import_fs2.existsSync)(eventPath)) await (0, import_promises7.mkdir)(eventPath, { recursive: true });
   let filename = "event.ts";
   if ((0, import_fs2.existsSync)((0, import_path4.join)(eventPath, filename))) {
-    const count = (await (0, import_promises6.readdir)(eventPath)).length;
+    const count = (await (0, import_promises7.readdir)(eventPath)).length;
     filename = `${String(count).padStart(2, "0")}_${filename}`;
   }
   const eventFile = `
@@ -5018,7 +5304,7 @@ export default async function on${name[0].toUpperCase() + name.slice(1)}() {
   console.log('${name} event fired!');
 };
 `.trim();
-  await (0, import_promises6.writeFile)((0, import_path4.join)(eventPath, filename), eventFile);
+  await (0, import_promises7.writeFile)((0, import_path4.join)(eventPath, filename), eventFile);
   console.log(
     colors_default.green(
       `Event ${colors_default.magenta(name)} created at ${colors_default.blue(formatPath(eventPath))}/${colors_default.magenta(filename)}`
@@ -5036,7 +5322,7 @@ async function generateLocale(locale, commandName, customPath) {
     panic("Command name is required.");
   }
   const localePath = (0, import_path4.join)(customPath || LOCALES_DIR, locale);
-  if (!(0, import_fs2.existsSync)(localePath)) await (0, import_promises6.mkdir)(localePath, { recursive: true });
+  if (!(0, import_fs2.existsSync)(localePath)) await (0, import_promises7.mkdir)(localePath, { recursive: true });
   if ((0, import_fs2.existsSync)((0, import_path4.join)(localePath, `${commandName}.json`))) {
     panic(`Locale file for ${commandName} already exists.`);
   }
@@ -5047,7 +5333,7 @@ async function generateLocale(locale, commandName, customPath) {
     },
     translations: {}
   };
-  await (0, import_promises6.writeFile)(
+  await (0, import_promises7.writeFile)(
     (0, import_path4.join)(localePath, `${commandName}.json`),
     JSON.stringify(localeFile, null, 2)
   );
@@ -5059,12 +5345,12 @@ async function generateLocale(locale, commandName, customPath) {
     )
   );
 }
-var import_promises6, import_path4, import_discord13, import_fs2, BASE_PATH, COMMANDS_DIR, EVENTS_DIR, LOCALES_DIR, formatPath;
+var import_promises7, import_path4, import_discord13, import_fs2, BASE_PATH, COMMANDS_DIR, EVENTS_DIR, LOCALES_DIR, formatPath;
 var init_generators = __esm({
   "src/cli/generators.ts"() {
     "use strict";
     init_cjs_shims();
-    import_promises6 = require("fs/promises");
+    import_promises7 = require("fs/promises");
     import_path4 = require("path");
     import_discord13 = require("discord.js");
     init_common();