commandkit 0.1.11-dev.20250307192025 → 0.1.11-dev.20250308122630

package/dist/index.js

@@ -2831,6 +2831,19 @@ var init_Context = __esm({
       cancel() {
         __privateSet(this, _cancel, true);
       }
+      /**
+       * Sets command runner function to wrap the command execution.
+       * @param fn The function to set.
+       * @example ctx.setCommandRunner(async (execute) => {
+       *  // do something before command execution
+       *  await execute();
+       *  // do something after command execution
+       * })
+       */
+      setCommandRunner(fn) {
+        var _a, _b;
+        (_b = (_a = this.config.customArgs) == null ? void 0 : _a.setCommandRunner) == null ? void 0 : _b.call(_a, fn);
+      }
     };
     _cancel = new WeakMap();
     __name(_MiddlewareContext, "MiddlewareContext");
@@ -3089,11 +3102,13 @@ var init_CommandRegistrar = __esm({
        * Gets the commands data.
        */
       getCommandsData() {
-        const commands = this.commandkit.commandHandler.getCommandsArray();
+        const handler = this.commandkit.commandHandler;
+        const commands = handler.getCommandsArray();
         return commands.flatMap((cmd) => {
+          var _a;
           const json = "toJSON" in cmd.data.command ? cmd.data.command.toJSON() : cmd.data.command;
-          if (cmd.subcommands && cmd.subcommands.length > 0 && (!json.type || json.type === import_discord9.ApplicationCommandType.ChatInput)) {
-            this.processSubcommands(json, cmd.subcommands);
+          if (((_a = cmd.command.subcommands) == null ? void 0 : _a.length) > 0 && (!json.type || json.type === import_discord9.ApplicationCommandType.ChatInput)) {
+            this.processSubcommands(json, cmd.command.subcommands);
           }
           const collections = [json];
           if (cmd.data.userContextMenu && json.type !== import_discord9.ApplicationCommandType.User) {
@@ -3138,12 +3153,12 @@ var init_CommandRegistrar = __esm({
         const directSubcommands = groupedSubcommands.get(null) || [];
         for (const subcommand of directSubcommands) {
           const subcommandData = this.commandkit.commandHandler.getSubcommandData(
-            subcommand.id
+            subcommand.command,
+            subcommand.name
           );
           if (subcommandData) {
             const subcommandOption = {
-              type: 1,
-              // SUB_COMMAND
+              type: import_discord9.ApplicationCommandOptionType.Subcommand,
               name: subcommand.name,
               description: subcommandData.description || "No description provided",
               options: subcommandData.options || [],
@@ -3157,19 +3172,18 @@ var init_CommandRegistrar = __esm({
           if (groupName === null) continue;
           const subcommandGroupOption = {
             type: import_discord9.ApplicationCommandOptionType.SubcommandGroup,
-            // SUB_COMMAND_GROUP
             name: groupName,
             description: `${groupName} commands`,
             options: []
           };
           for (const subcommand of groupSubcommands) {
             const subcommandData = this.commandkit.commandHandler.getSubcommandData(
-              subcommand.id
+              subcommand.command,
+              subcommand.name
             );
             if (subcommandData) {
               (_b = subcommandGroupOption.options) == null ? void 0 : _b.push({
                 type: import_discord9.ApplicationCommandOptionType.Subcommand,
-                // SUB_COMMAND
                 name: subcommand.name,
                 description: subcommandData.description || "No description provided",
                 options: subcommandData.options || [],
@@ -3187,15 +3201,24 @@ var init_CommandRegistrar = __esm({
        * Registers loaded commands.
        */
       async register() {
+        if (!this.commandkit.client.isReady()) {
+          throw new Error("Cannot register commands before the client is ready");
+        }
         const commands = this.getCommandsData();
         const guildCommands = commands.filter((command) => {
           var _a;
-          return (_a = command.guilds) == null ? void 0 : _a.length;
+          return (_a = command.guilds) == null ? void 0 : _a.filter(Boolean).length;
+        }).map((c) => {
+          var _a;
+          return {
+            ...c,
+            guilds: Array.from(new Set((_a = c.guilds) == null ? void 0 : _a.filter(Boolean)))
+          };
         });
         const globalCommands = commands.filter(
           (command) => {
             var _a;
-            return !((_a = command.guilds) == null ? void 0 : _a.length);
+            return !((_a = command.guilds) == null ? void 0 : _a.filter(Boolean).length);
           }
         );
         await this.updateGlobalCommands(globalCommands);
@@ -3311,10 +3334,12 @@ var init_AppCommandHandler = __esm({
         return Array.from(this.loadedCommands.values());
       }
       /**
-       * Get subcommand data by ID for the command registrar
+       * Get subcommand data by command ID and subcommand name
        */
-      getSubcommandData(id) {
-        const subcommand = this.loadedSubCommands.get(id);
+      getSubcommandData(commandId, subcommandName) {
+        const subcommand = Array.from(this.loadedSubCommands.values()).find(
+          (sub) => sub.subcommand.command === commandId && sub.subcommand.name === subcommandName
+        );
         if (!subcommand) return null;
         const commandData = subcommand.data.command;
         return "toJSON" in commandData ? commandData.toJSON() : commandData;
@@ -3385,11 +3410,17 @@ var init_AppCommandHandler = __esm({
           return;
         }
         const executionMode = this.getExecutionMode(source);
+        let runCommand = null;
         const ctx = new MiddlewareContext(this.commandkit, {
           executionMode,
           interaction: !(source instanceof import_discord10.Message) ? source : null,
           message: source instanceof import_discord10.Message ? source : null,
-          forwarded: false
+          forwarded: false,
+          customArgs: {
+            setCommandRunner: /* @__PURE__ */ __name((fn2) => {
+              runCommand = fn2;
+            }, "setCommandRunner")
+          }
         });
         for (const middleware of prepared.middlewares) {
           await middleware.data.beforeExecute(ctx);
@@ -3403,7 +3434,8 @@ var init_AppCommandHandler = __esm({
         }
         if (fn) {
           try {
-            const executeCommand = /* @__PURE__ */ __name(async () => fn(ctx.clone()), "executeCommand");
+            const _executeCommand = /* @__PURE__ */ __name(async () => fn(ctx.clone()), "_executeCommand");
+            const executeCommand = runCommand != null ? runCommand(_executeCommand) : _executeCommand;
             const res = await this.commandkit.plugins.execute(
               async (ctx2, plugin) => {
                 return plugin.executeCommand(ctx2, source, prepared, executeCommand);
@@ -3497,25 +3529,12 @@ var init_AppCommandHandler = __esm({
           }
         }
         const middlewares = [];
-        for (const middlewareId of loadedCommand.command.middlewares) {
+        for (const middlewareId of loadedCommand.command.middlewareIds) {
           const middleware = this.loadedMiddlewares.get(middlewareId);
           if (middleware) {
             middlewares.push(middleware);
           }
         }
-        if (loadedSubCommand) {
-          for (const middlewareId of loadedSubCommand.subcommand.middlewares) {
-            const existingIndex = middlewares.findIndex(
-              (m) => m.middleware.id === middlewareId
-            );
-            if (existingIndex === -1) {
-              const middleware = this.loadedMiddlewares.get(middlewareId);
-              if (middleware) {
-                middlewares.push(middleware);
-              }
-            }
-          }
-        }
         return {
           command: loadedCommand,
           subcommand: loadedSubCommand,
@@ -3536,26 +3555,17 @@ var init_AppCommandHandler = __esm({
         if (!commandsRouter) {
           throw new Error("Commands router has not yet initialized");
         }
-        const { commands, subcommands, middlewares } = commandsRouter.getData();
+        const { commands, middlewares } = commandsRouter.getData();
         for (const [id, middleware] of middlewares) {
           await this.loadMiddleware(id, middleware);
         }
         for (const [id, command] of commands) {
           await this.loadCommand(id, command);
         }
-        for (const [id, subcommand] of subcommands) {
-          await this.loadSubcommand(id, subcommand);
-        }
-        for (const loadedSubCommand of this.loadedSubCommands.values()) {
-          const pathSegments = loadedSubCommand.subcommand.path.split("/");
-          const parentCommandName = pathSegments[pathSegments.length - 3];
-          for (const loadedCommand of this.loadedCommands.values()) {
-            if (loadedCommand.command.name === parentCommandName) {
-              if (!loadedCommand.subcommands) {
-                loadedCommand.subcommands = [];
-              }
-              loadedCommand.subcommands.push(loadedSubCommand.subcommand);
-              break;
+        for (const loadedCommand of this.loadedCommands.values()) {
+          if (loadedCommand.command.subcommands) {
+            for (const subcommand of loadedCommand.command.subcommands) {
+              await this.loadSubcommand(subcommand);
             }
           }
         }
@@ -3579,10 +3589,7 @@ var init_AppCommandHandler = __esm({
           }
           this.loadedMiddlewares.set(id, { middleware, data });
         } catch (error) {
-          Logger.error(
-            `Failed to load middleware ${middleware.name} (${id})`,
-            error
-          );
+          Logger.error(`Failed to load middleware ${id}`, error);
         }
       }
       async loadCommand(id, command) {
@@ -3595,11 +3602,9 @@ var init_AppCommandHandler = __esm({
                   name: command.name,
                   description: `${command.name} commands`,
                   type: 1
-                  // CHAT_INPUT
                 }
               }
             });
-            this.commandNameToId.set(command.name, id);
             return;
           }
           const data = await import(`${toFileURL(command.path)}?t=${Date.now()}`);
@@ -3638,7 +3643,7 @@ var init_AppCommandHandler = __esm({
           Logger.error(`Failed to load command ${command.name} (${id})`, error);
         }
       }
-      async loadSubcommand(id, subcommand) {
+      async loadSubcommand(subcommand) {
         try {
           const data = await import(`${toFileURL(subcommand.path)}?t=${Date.now()}`);
           if (!data.command) {
@@ -3660,44 +3665,33 @@ var init_AppCommandHandler = __esm({
               `Invalid export for subcommand ${subcommand.name}: at least one handler function must be provided`
             );
           }
-          const localizedCommand = await this.applyLocalizations({
-            ...data.command
-          });
-          this.loadedSubCommands.set(id, {
+          const localizedCommand = await this.applyLocalizations(
+            { ...data.command },
+            subcommand
+          );
+          const subcommandId = subcommand.command + "/" + subcommand.name;
+          this.loadedSubCommands.set(subcommandId, {
             subcommand,
             data: {
               ...data,
               command: localizedCommand
             }
           });
-          const parentCommandId = subcommand.id.split("/")[0];
-          if (subcommand.group) {
-            this.subcommandPathToId.set(
-              `${parentCommandId}/${subcommand.group}/${subcommand.name}`,
-              id
-            );
-          } else {
-            this.subcommandPathToId.set(
-              `${parentCommandId}/${subcommand.name}`,
-              id
-            );
-          }
+          this.subcommandPathToId.set(subcommandId, subcommandId);
         } catch (error) {
-          Logger.error(
-            `Failed to load subcommand ${subcommand.name} (${id})`,
-            error
-          );
+          Logger.error(`Failed to load subcommand ${subcommand.name}`, error);
         }
       }
-      async applyLocalizations(command) {
+      async applyLocalizations(command, subcommand) {
         var _a, _b, _c, _d, _e;
         const localization = this.commandkit.config.localizationStrategy;
         const validLocales = Object.values(import_discord10.Locale).filter(
           (v) => typeof v === "string"
         );
+        const localizationKey = subcommand ? command.name.split("/")[0] : command.name;
         for (const locale of validLocales) {
           const translation = await localization.locateTranslation(
-            command.name,
+            localizationKey,
             locale
           );
           if (!(translation == null ? void 0 : translation.command)) continue;
@@ -3717,6 +3711,8 @@ var init_AppCommandHandler = __esm({
               let o;
               while (o = opt.shift()) {
                 (_c = raw.options) == null ? void 0 : _c.forEach((option) => {
+                  var _a2;
+                  if (subcommand && option.name !== subcommand.name) return;
                   if (option.name === o.ref) {
                     if (option.name) {
                       option.name_localizations ??= {};
@@ -3726,6 +3722,22 @@ var init_AppCommandHandler = __esm({
                       option.description_localizations ??= {};
                       option.description_localizations[locale] = o.description;
                     }
+                    const opts = option.options;
+                    if ((opts == null ? void 0 : opts.length) && ((_a2 = o.options) == null ? void 0 : _a2.length)) {
+                      o.options.forEach((subOpt) => {
+                        const targetOption = opts == null ? void 0 : opts.find(
+                          (opt2) => opt2.name === subOpt.name
+                        );
+                        if (targetOption) {
+                          targetOption.name_localizations ??= {};
+                          targetOption.name_localizations[locale] = subOpt.name;
+                          if ("description" in targetOption) {
+                            targetOption.description_localizations ??= {};
+                            targetOption.description_localizations[locale] = subOpt.description;
+                          }
+                        }
+                      });
+                    }
                   }
                 });
               }
@@ -3734,12 +3746,10 @@ var init_AppCommandHandler = __esm({
             if (translation.command.name) {
               command.setNameLocalization(locale, translation.command.name);
             }
-            const raw = command.toJSON();
-            return raw;
           } else {
             command.name_localizations ??= {};
             command.name_localizations[locale] = translation.command.name;
-            if (command.description) {
+            if (!subcommand && command.description) {
               command.description_localizations ??= {};
               command.description_localizations[locale] = translation.command.description;
             }
@@ -3748,15 +3758,31 @@ var init_AppCommandHandler = __esm({
               let o;
               while (o = opt.shift()) {
                 command.options.forEach((option) => {
+                  var _a2;
+                  if (subcommand && option.name !== subcommand.name) return;
                   if (option.name === o.ref) {
-                    if (option.name) {
-                      option.name_localizations ??= {};
-                      option.name_localizations[locale] = o.name;
-                    }
-                    if (option.description) {
+                    option.name_localizations ??= {};
+                    option.name_localizations[locale] = o.name;
+                    if ("description" in option) {
                       option.description_localizations ??= {};
                       option.description_localizations[locale] = o.description;
                     }
+                    const opts = option.options;
+                    if ((opts == null ? void 0 : opts.length) && ((_a2 = o.options) == null ? void 0 : _a2.length)) {
+                      o.options.forEach((subOpt) => {
+                        const targetOption = opts == null ? void 0 : opts.find(
+                          (opt2) => opt2.name === subOpt.name
+                        );
+                        if (targetOption) {
+                          targetOption.name_localizations ??= {};
+                          targetOption.name_localizations[locale] = subOpt.name;
+                          if ("description" in targetOption) {
+                            targetOption.description_localizations ??= {};
+                            targetOption.description_localizations[locale] = subOpt.description;
+                          }
+                        }
+                      });
+                    }
                   }
                 });
               }
@@ -3772,243 +3798,208 @@ var init_AppCommandHandler = __esm({
 });
 
 // src/app/router/CommandsRouter.ts
-var import_discord11, import_node_fs3, import_promises3, import_posix, _CommandsRouter, CommandsRouter;
+var import_discord11, import_node_fs3, import_node_crypto3, import_walk, import_node_path3, _CommandsRouter, CommandsRouter;
 var init_CommandsRouter = __esm({
   "src/app/router/CommandsRouter.ts"() {
     "use strict";
     init_cjs_shims();
     import_discord11 = require("discord.js");
     import_node_fs3 = require("fs");
-    import_promises3 = require("fs/promises");
-    import_posix = __toESM(require("path/posix"));
+    import_node_crypto3 = __toESM(require("crypto"));
+    import_walk = __toESM(require("@root/walk"));
+    import_node_path3 = __toESM(require("path"));
     _CommandsRouter = class _CommandsRouter {
       constructor(options) {
         this.options = options;
       }
       commands = 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;
-      }
-      clear() {
-        this.commands.clear();
-        this.middlewares.clear();
-        this.subcommands.clear();
-      }
-      async reload() {
-        this.clear();
-        return this.scan();
+      fromData(data) {
+        this.commands = new import_discord11.Collection(
+          Object.entries(data.commands).map(([id, command]) => [id, command])
+        );
+        this.middlewares = new import_discord11.Collection(
+          Object.entries(data.middlewares).map(
+            ([id, middleware]) => [
+              id,
+              middleware
+            ]
+          )
+        );
       }
-      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;
+      isValidPath() {
+        return (0, import_node_fs3.existsSync)(this.options.entrypoint);
       }
       getData() {
         return {
           commands: this.commands,
-          middlewares: this.middlewares,
-          subcommands: this.subcommands
+          middlewares: this.middlewares
         };
       }
       toJSON() {
         return {
           commands: Object.fromEntries(this.commands.entries()),
-          middlewares: Object.fromEntries(this.middlewares.entries()),
-          subcommands: Object.fromEntries(this.subcommands.entries())
+          middlewares: Object.fromEntries(this.middlewares.entries())
         };
       }
+      clear() {
+        this.commands.clear();
+        this.middlewares.clear();
+      }
+      reload() {
+        this.clear();
+        return this.scan();
+      }
       async scan() {
-        if (!this.isValidPath()) return this.toJSON();
-        const root = this.entrypoint;
-        await this.scanDeep(root);
+        if (!this.isValidPath()) {
+          throw new Error("Invalid path");
+        }
+        await this.traverse();
+        this.applyBindings();
         return this.toJSON();
       }
-      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);
+      async traverse() {
+        const validFile = /\.(c|m)?(j|t)sx?$/;
+        const middleware = /^(\w+\.)?middleware\.(c|m)?(j|t)sx?$/;
+        const categoryDir = /^\((\w+)\)$/;
+        const isCategory = /* @__PURE__ */ __name((name) => categoryDir.test(name), "isCategory");
+        const isMiddleware = /* @__PURE__ */ __name((name) => middleware.test(name), "isMiddleware");
+        const isCommand = /* @__PURE__ */ __name((name) => validFile.test(name) && !isMiddleware(name), "isCommand");
+        await import_walk.default.walk(
+          this.options.entrypoint,
+          async (error, pathname, dirent) => {
+            if (error) throw error;
+            const name = dirent.name;
+            if (dirent.isDirectory()) {
+              if (isCategory(name) && this.distanceFromRoot(pathname) > 1) {
+                throw new Error(
+                  `Category directories must be at the root. Found "${name}" at "${pathname}"`
+                );
+              }
+              return;
             }
-          } else {
-            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 {
-              this.processCommand(
-                itemPath,
-                category,
-                isIndexFile ? normalizedPath : null
+            if (this.distanceFromRoot(pathname, true) > 1) return;
+            if (isMiddleware(name)) {
+              const middleware2 = {
+                id: import_node_crypto3.default.randomUUID(),
+                path: pathname,
+                relativePath: this.toRelativePath(pathname)
+              };
+              this.middlewares.set(middleware2.id, middleware2);
+              return;
+            }
+            if (!isCommand(name)) return;
+            const command = {
+              id: import_node_crypto3.default.randomUUID(),
+              name: this.parseFileName(name),
+              category: this.parseCategory(pathname),
+              middlewareIds: [],
+              path: pathname,
+              relativePath: this.toRelativePath(pathname),
+              subcommands: []
+            };
+            this.commands.set(command.id, command);
+          }
+        );
+        await import_walk.default.walk(
+          this.options.entrypoint,
+          async (error, pathname, dirent) => {
+            if (error) throw error;
+            const name = dirent.name;
+            if (dirent.isDirectory()) return;
+            if (this.distanceFromRoot(pathname, true) <= 1) return;
+            if (isMiddleware(name)) {
+              const middleware2 = {
+                id: import_node_crypto3.default.randomUUID(),
+                path: pathname,
+                relativePath: this.toRelativePath(pathname)
+              };
+              this.middlewares.set(middleware2.id, middleware2);
+              return;
+            }
+            if (!isCommand(name)) return;
+            let currentDir = import_node_path3.default.dirname(pathname);
+            let parentCommand;
+            while (currentDir !== this.options.entrypoint) {
+              const dirName = import_node_path3.default.basename(currentDir);
+              parentCommand = Array.from(this.commands.values()).find(
+                (cmd) => import_node_path3.default.basename(import_node_path3.default.dirname(cmd.path)) === import_node_path3.default.basename(import_node_path3.default.dirname(currentDir)) && this.parseFileName(cmd.path) === dirName
               );
+              if (parentCommand) break;
+              currentDir = import_node_path3.default.dirname(currentDir);
+            }
+            if (parentCommand) {
+              const subcommand = {
+                name: this.parseFileName(name),
+                group: this.parseGroup(pathname),
+                path: pathname,
+                relativePath: this.toRelativePath(pathname),
+                command: parentCommand.id
+              };
+              parentCommand.subcommands.push(subcommand);
             }
           }
-        }
-      }
-      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);
-      }
-      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,
-          relativePath: this.getRelativePath(filePath)
-        };
-        this.subcommands.set(subcommand.id, subcommand);
-        this.applySubcommandToCommands(subcommand);
-      }
-      processCommand(filePath, category, parentPath = null) {
-        const command = {
-          id: crypto.randomUUID(),
-          name: parentPath ? this.getDirectoryName(parentPath) : this.extractName(filePath),
-          path: filePath,
-          relativePath: this.getRelativePath(filePath),
-          category,
-          middlewares: [],
-          subcommands: []
-        };
-        this.commands.set(command.id, command);
+        );
       }
-      /**
-       * 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);
+      applyBindings() {
+        for (const command of this.commands.values()) {
+          const commandName = command.name;
+          const commandDir = import_node_path3.default.dirname(command.path);
+          for (const middleware of this.middlewares.values()) {
+            const middlewareDir = import_node_path3.default.dirname(middleware.path);
+            const middlewareFileName = import_node_path3.default.basename(middleware.path);
+            const isCommandSpecificMiddleware = middlewareFileName.startsWith(
+              commandName + "."
+            );
+            const isSharedMiddleware = middlewareFileName === "middleware.ts" || middlewareFileName === "middleware.js";
+            if (isCommandSpecificMiddleware && middlewareFileName.startsWith(commandName + ".")) {
+              command.middlewareIds.push(middleware.id);
+              continue;
+            }
+            if (isSharedMiddleware) {
+              const relPath = import_node_path3.default.relative(middlewareDir, commandDir);
+              if (!relPath.startsWith("..") && !import_node_path3.default.isAbsolute(relPath)) {
+                command.middlewareIds.push(middleware.id);
+              }
+            }
+          }
         }
-        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);
+      distanceFromRoot(pathname, isFile = false) {
+        const entrypointParts = this.options.entrypoint.split(import_node_path3.default.sep);
+        const pathParts = (!isFile ? pathname : import_node_path3.default.dirname(pathname)).split(
+          import_node_path3.default.sep
+        );
+        const relativeParts = pathParts.slice(entrypointParts.length);
+        return relativeParts.filter((part) => !part.match(/^\(.*\)$/)).length;
       }
-      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);
+      parseGroup(pathname) {
+        const parts = pathname.split(import_node_path3.default.sep);
+        const parentDirIndex = parts.findIndex(
+          (part) => this.commands.some((cmd) => cmd.name === part)
+        );
+        if (parentDirIndex === -1) return null;
+        const groupName = parts[parts.length - 2];
+        if (!groupName || groupName === parts[parentDirIndex] || groupName.match(/^\(.*\)$/)) {
+          return null;
         }
-      }
-      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 groupName;
+      }
+      parseCategory(pathname) {
+        const parts = pathname.split(import_node_path3.default.sep);
+        const entrypointParts = this.options.entrypoint.split(import_node_path3.default.sep);
+        const relativeIndex = entrypointParts.length;
+        const categoryDir = parts[relativeIndex];
+        if (!categoryDir || !/^\((\w+)\)$/.test(categoryDir)) {
+          return null;
         }
+        return categoryDir.slice(1, -1);
       }
-      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;
+      parseFileName(filename) {
+        return import_node_path3.default.basename(filename, import_node_path3.default.extname(filename));
       }
-      extractName(entry) {
-        return import_posix.default.basename(entry).replace(/\.(c|m)?(j|t)sx?$/, "");
+      toRelativePath(pathname) {
+        return import_node_path3.default.relative(this.options.entrypoint, pathname);
       }
     };
     __name(_CommandsRouter, "CommandsRouter");
@@ -4017,14 +4008,14 @@ var init_CommandsRouter = __esm({
 });
 
 // src/app/router/EventsRouter.ts
-var import_node_fs4, import_promises4, import_node_path3, _EventsRouter, EventsRouter;
+var import_node_fs4, import_promises3, import_node_path4, _EventsRouter, EventsRouter;
 var init_EventsRouter = __esm({
   "src/app/router/EventsRouter.ts"() {
     "use strict";
     init_cjs_shims();
     import_node_fs4 = require("fs");
-    import_promises4 = require("fs/promises");
-    import_node_path3 = require("path");
+    import_promises3 = require("fs/promises");
+    import_node_path4 = require("path");
     _EventsRouter = class _EventsRouter {
       /**
        * Creates a new EventsRouter instance
@@ -4079,10 +4070,10 @@ var init_EventsRouter = __esm({
        * @returns Promise resolving to the events tree
        */
       async scan() {
-        const dirs = await (0, import_promises4.readdir)(this.entrypoint, { withFileTypes: true });
+        const dirs = await (0, import_promises3.readdir)(this.entrypoint, { withFileTypes: true });
         for (const dir of dirs) {
           if (dir.isDirectory()) {
-            const path3 = (0, import_node_path3.join)(this.entrypoint, dir.name);
+            const path3 = (0, import_node_path4.join)(this.entrypoint, dir.name);
             const event = await this.scanEvent(dir.name, path3);
             this.events.set(event.event, event);
           }
@@ -4105,16 +4096,16 @@ var init_EventsRouter = __esm({
        */
       async scanEvent(event, path3, listeners = []) {
         var _a;
-        const files = await (0, import_promises4.readdir)(path3, { withFileTypes: true });
+        const files = await (0, import_promises3.readdir)(path3, { withFileTypes: true });
         for (const file of files) {
           if (/node_modules/.test(file.name)) continue;
           if (file.isDirectory()) {
-            const nextPath = (0, import_node_path3.join)(path3, file.name);
+            const nextPath = (0, import_node_path4.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_path3.join)(file.parentPath, file.name));
+            listeners.push((0, import_node_path4.join)(file.parentPath, file.name));
           }
         }
         const maybeNamespace = path3.replace(this.entrypoint, "").replaceAll("\\", "/").split("/").shift();
@@ -4291,12 +4282,12 @@ 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 location = (0, import_node_path5.join)(process.cwd(), "node_modules", "commandkit-types");
+  const packageJSON = (0, import_node_path5.join)(location, "package.json");
+  const index = (0, import_node_path5.join)(location, "index.js");
+  const types = (0, import_node_path5.join)(location, "index.d.ts");
+  const locale = (0, import_node_path5.join)(location, "locale.d.ts");
+  const command = (0, import_node_path5.join)(location, "command.d.ts");
   const exists = (0, import_node_fs5.existsSync)(packageJSON);
   if (exists) return location;
   const packageJSONContent = {
@@ -4317,22 +4308,22 @@ async function generateTypesPackage() {
       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, "");
+  await (0, import_promises4.mkdir)(location, { recursive: true });
+  await (0, import_promises4.writeFile)(packageJSON, JSON.stringify(packageJSONContent, null, 2));
+  await (0, import_promises4.writeFile)(index, indexContent);
+  await (0, import_promises4.writeFile)(types, typesContent);
+  await (0, import_promises4.writeFile)(locale, "");
+  await (0, import_promises4.writeFile)(command, "");
   return location;
 }
-var import_node_fs5, import_promises5, import_node_path4;
+var import_node_fs5, import_promises4, import_node_path5;
 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");
+    import_promises4 = require("fs/promises");
+    import_node_path5 = require("path");
     __name(generateTypesPackage, "generateTypesPackage");
   }
 });
@@ -4374,7 +4365,7 @@ async function loadConfigFileFromPath(target) {
       fileName: target
     });
     const nodeModulesPath = await generateTypesPackage();
-    const tmpFile = (0, import_node_path5.join)(nodeModulesPath, "compiled-commandkit.config.mjs");
+    const tmpFile = (0, import_node_path6.join)(nodeModulesPath, "compiled-commandkit.config.mjs");
     import_node_fs6.default.writeFileSync(tmpFile, outputText);
     target = tmpFile;
   }
@@ -4389,13 +4380,13 @@ async function ensureExists(loc) {
     throw new Error(`File not found: ${loc}`);
   }
 }
-var import_rimraf, import_node_path5, import_node_fs6, ts;
+var import_rimraf, import_node_path6, 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_path6 = require("path");
     import_node_fs6 = __toESM(require("fs"));
     init_colors();
     init_types_package();
@@ -4409,7 +4400,7 @@ var init_common = __esm({
 
 // src/config/loader.ts
 function findConfigFile(cwd) {
-  const locations = CONFIG_FILE_NAMES.map((name) => (0, import_node_path6.join)(cwd, name));
+  const locations = CONFIG_FILE_NAMES.map((name) => (0, import_node_path7.join)(cwd, name));
   for (const location of locations) {
     if ((0, import_node_fs7.existsSync)(location)) {
       return {
@@ -4428,13 +4419,13 @@ async function loadConfigFile(entrypoint = process.cwd()) {
   loadedConfig = config;
   return config;
 }
-var import_node_fs7, import_node_path6, CONFIG_FILE_NAMES, loadedConfig;
+var import_node_fs7, import_node_path7, CONFIG_FILE_NAMES, loadedConfig;
 var init_loader = __esm({
   "src/config/loader.ts"() {
     "use strict";
     init_cjs_shims();
     import_node_fs7 = require("fs");
-    import_node_path6 = require("path");
+    import_node_path7 = require("path");
     init_common();
     init_config();
     CONFIG_FILE_NAMES = [
@@ -4529,7 +4520,7 @@ var init_CommandKitEventsChannel = __esm({
 });
 
 // src/CommandKit.ts
-var import_node_events2, import_discord12, import_node_path7, _started, _CommandKit_instances, init_fn, initCommands_fn, initEvents_fn, _CommandKit, CommandKit;
+var import_node_events2, import_discord12, import_node_path8, import_node_fs8, _started, _CommandKit_instances, init_fn, initCommands_fn, initEvents_fn, _CommandKit, CommandKit;
 var init_CommandKit = __esm({
   "src/CommandKit.ts"() {
     "use strict";
@@ -4543,7 +4534,7 @@ var init_CommandKit = __esm({
     import_discord12 = require("discord.js");
     init_DefaultLocalizationStrategy();
     init_utilities();
-    import_node_path7 = require("path");
+    import_node_path8 = require("path");
     init_AppCommandHandler();
     init_router();
     init_AppEventsHandler();
@@ -4551,6 +4542,7 @@ var init_CommandKit = __esm({
     init_loader();
     init_constants();
     init_dev_hooks();
+    import_node_fs8 = require("fs");
     init_CommandKitEventsChannel();
     init_plugins();
     init_types_package();
@@ -4626,11 +4618,6 @@ var init_CommandKit = __esm({
         await this.loadPlugins();
         await __privateMethod(this, _CommandKit_instances, init_fn).call(this);
         this.incrementClientListenersCount();
-        if (token !== false && !this.options.client.isReady()) {
-          await this.options.client.login(
-            token ?? process.env.TOKEN ?? process.env.DISCORD_TOKEN
-          );
-        }
         __privateSet(this, _started, true);
         await this.commandHandler.registrar.register();
       }
@@ -4772,11 +4759,11 @@ var init_CommandKit = __esm({
         if (!appDir2) return null;
         switch (to) {
           case "locales":
-            return (0, import_node_path7.join)(appDir2, "locales");
+            return (0, import_node_path8.join)(appDir2, "locales");
           case "commands":
-            return (0, import_node_path7.join)(appDir2, "commands");
+            return (0, import_node_path8.join)(appDir2, "commands");
           case "events":
-            return (0, import_node_path7.join)(appDir2, "events");
+            return (0, import_node_path8.join)(appDir2, "events");
           default:
             return to;
         }
@@ -4800,10 +4787,12 @@ var init_CommandKit = __esm({
     }, "#init");
     initCommands_fn = /* @__PURE__ */ __name(async function() {
       if (this.commandsRouter.isValidPath()) {
-        await this.commandsRouter.scan();
+        const result = await this.commandsRouter.scan();
         if (COMMANDKIT_IS_DEV) {
-          const visual = this.commandsRouter.visualize();
-          console.log(visual);
+          (0, import_node_fs8.writeFileSync)(
+            "./.commandkit/commands.json",
+            JSON.stringify(result, null, 2)
+          );
         }
       }
       await this.commandHandler.loadCommands();
@@ -4833,7 +4822,7 @@ var init_version = __esm({
     "use strict";
     init_cjs_shims();
     version = /* @__MACRO__ $version */
-    "0.1.11-dev.20250307192025";
+    "0.1.11-dev.20250308122630";
   }
 });
 
@@ -4875,7 +4864,7 @@ function getStdio(supportsCommands) {
 }
 function createAppProcess(fileName, cwd, isDev) {
   var _a, _b;
-  if (!(0, import_node_fs8.existsSync)((0, import_node_path8.join)(cwd, fileName))) {
+  if (!(0, import_node_fs9.existsSync)((0, import_node_path9.join)(cwd, fileName))) {
     panic(`Could not locate the entrypoint file: ${fileName}`);
   }
   const stdio = getStdio(isDev);
@@ -4897,15 +4886,15 @@ 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_fs8;
+var import_node_child_process, import_node_path9, import_node_fs9;
 var init_app_process = __esm({
   "src/cli/app-process.ts"() {
     "use strict";
     init_cjs_shims();
     import_node_child_process = require("child_process");
     init_env();
-    import_node_path8 = require("path");
-    import_node_fs8 = require("fs");
+    import_node_path9 = require("path");
+    import_node_fs9 = require("fs");
     init_common();
     __name(getStdio, "getStdio");
     __name(createAppProcess, "createAppProcess");
@@ -4992,9 +4981,9 @@ async function main() {
 await main();
 `;
   const dist = isDev ? ".commandkit" : distDir || "dist";
-  await (0, import_promises6.writeFile)((0, import_node_path9.join)(configPath, dist, "index.js"), code);
+  await (0, import_promises5.writeFile)((0, import_node_path10.join)(configPath, dist, "index.js"), code);
 }
-var import_tsup, import_promises6, import_node_path9, envScript, requireScript, antiCrashScript, wrapInAsyncIIFE;
+var import_tsup, import_promises5, import_node_path10, envScript, requireScript, antiCrashScript, wrapInAsyncIIFE;
 var init_build = __esm({
   "src/cli/build.ts"() {
     "use strict";
@@ -5002,8 +4991,8 @@ var init_build = __esm({
     import_tsup = require("tsup");
     init_plugins();
     init_loader();
-    import_promises6 = require("fs/promises");
-    import_node_path9 = require("path");
+    import_promises5 = require("fs/promises");
+    import_node_path10 = require("path");
     init_env();
     __name(buildApplication, "buildApplication");
     envScript = /* @__PURE__ */ __name((dev) => `// --- Environment Variables Loader ---
@@ -5147,7 +5136,7 @@ async function bootstrapDevelopmentServer(configPath) {
   watcher.on("add", hmrHandler);
   watcher.on("unlink", hmrHandler);
   watcher.on("unlinkDir", (path3) => {
-    const hasChild = (0, import_node_fs9.readdirSync)(path3).length > 0;
+    const hasChild = (0, import_node_fs10.readdirSync)(path3).length > 0;
     if (hasChild) return hmrHandler(path3);
   });
   watcher.on("error", (e) => {
@@ -5166,7 +5155,7 @@ ${colors_default.yellowBright("re")} - Reload all events
 ${colors_default.yellowBright("rl")} - Reload all locales`
   );
 }
-var import_path2, import_chokidar, import_node_fs9, isCommandSource, isEventSource, isLocaleSource;
+var import_path2, import_chokidar, import_node_fs10, isCommandSource, isEventSource, isLocaleSource;
 var init_development = __esm({
   "src/cli/development.ts"() {
     "use strict";
@@ -5177,7 +5166,7 @@ var init_development = __esm({
     init_app_process();
     init_build();
     import_chokidar = require("chokidar");
-    import_node_fs9 = require("fs");
+    import_node_fs10 = require("fs");
     init_utilities();
     init_colors();
     __name(buildAndStart, "buildAndStart");
@@ -5264,7 +5253,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_promises7.mkdir)(cmdPath, { recursive: true });
+  if (!(0, import_fs2.existsSync)(cmdPath)) await (0, import_promises6.mkdir)(cmdPath, { recursive: true });
   if ((0, import_fs2.existsSync)((0, import_path4.join)(cmdPath, "command.ts"))) {
     panic(`Command ${name} already exists.`);
   }
@@ -5284,7 +5273,7 @@ export const message: MessageCommand = async (ctx) => {
   await ctx.message.reply('Hello from ${name}!');
 };
 `.trim();
-  await (0, import_promises7.writeFile)((0, import_path4.join)(cmdPath, "command.ts"), commandFile);
+  await (0, import_promises6.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`
@@ -5293,10 +5282,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_promises7.mkdir)(eventPath, { recursive: true });
+  if (!(0, import_fs2.existsSync)(eventPath)) await (0, import_promises6.mkdir)(eventPath, { recursive: true });
   let filename = "event.ts";
   if ((0, import_fs2.existsSync)((0, import_path4.join)(eventPath, filename))) {
-    const count = (await (0, import_promises7.readdir)(eventPath)).length;
+    const count = (await (0, import_promises6.readdir)(eventPath)).length;
     filename = `${String(count).padStart(2, "0")}_${filename}`;
   }
   const eventFile = `
@@ -5304,7 +5293,7 @@ export default async function on${name[0].toUpperCase() + name.slice(1)}() {
   console.log('${name} event fired!');
 };
 `.trim();
-  await (0, import_promises7.writeFile)((0, import_path4.join)(eventPath, filename), eventFile);
+  await (0, import_promises6.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)}`
@@ -5322,7 +5311,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_promises7.mkdir)(localePath, { recursive: true });
+  if (!(0, import_fs2.existsSync)(localePath)) await (0, import_promises6.mkdir)(localePath, { recursive: true });
   if ((0, import_fs2.existsSync)((0, import_path4.join)(localePath, `${commandName}.json`))) {
     panic(`Locale file for ${commandName} already exists.`);
   }
@@ -5333,7 +5322,7 @@ async function generateLocale(locale, commandName, customPath) {
     },
     translations: {}
   };
-  await (0, import_promises7.writeFile)(
+  await (0, import_promises6.writeFile)(
     (0, import_path4.join)(localePath, `${commandName}.json`),
     JSON.stringify(localeFile, null, 2)
   );
@@ -5345,12 +5334,12 @@ async function generateLocale(locale, commandName, customPath) {
     )
   );
 }
-var import_promises7, import_path4, import_discord13, import_fs2, BASE_PATH, COMMANDS_DIR, EVENTS_DIR, LOCALES_DIR, formatPath;
+var import_promises6, 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_promises7 = require("fs/promises");
+    import_promises6 = require("fs/promises");
     import_path4 = require("path");
     import_discord13 = require("discord.js");
     init_common();