commandkit 0.1.11-dev.20250307192025 → 0.1.11-dev.20250308073818

package/dist/index.d.ts

@@ -1086,6 +1086,10 @@ interface ParsedSubCommand {
      * The group name of the subcommand. This is used to group subcommands together in the Discord UI.
      */
     group: string | null;
+    /**
+     * The category of this subcommand. This will be the parent directory segment that matches /(category)/ in the path.
+     */
+    category: string | null;
     /**
      * The absolute path to the subcommand file.
      */
@@ -1136,9 +1140,15 @@ declare class CommandsRouter {
     toJSON(): CommandTree;
     scan(): Promise<CommandTree>;
     private scanDeep;
+    /**
+     * Gets path segments between two paths, excluding the start and end paths
+     * Used to check if all directories between a path and the entrypoint are category directories
+     */
+    private getPathSegmentsBetween;
     private processMiddleware;
     private processSubcommand;
     private processCommand;
+    private extractDirOmitCategory;
     /**
      * Gets the appropriate file name, handling index files specially
      * For index files, it returns the parent directory name (excluding category markers)

package/dist/index.js

@@ -3772,7 +3772,7 @@ 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_promises3, path2, _CommandsRouter, CommandsRouter;
 var init_CommandsRouter = __esm({
   "src/app/router/CommandsRouter.ts"() {
     "use strict";
@@ -3780,7 +3780,7 @@ var init_CommandsRouter = __esm({
     import_discord11 = require("discord.js");
     import_node_fs3 = require("fs");
     import_promises3 = require("fs/promises");
-    import_posix = __toESM(require("path/posix"));
+    path2 = __toESM(require("path"));
     _CommandsRouter = class _CommandsRouter {
       constructor(options) {
         this.options = options;
@@ -3879,32 +3879,38 @@ var init_CommandsRouter = __esm({
         await this.scanDeep(root);
         return this.toJSON();
       }
-      async scanDeep(entry, currentDepth = 2) {
-        const normalizedPath = import_posix.default.normalize(entry);
+      async scanDeep(entry, currentDepth = 3) {
+        const normalizedPath = path2.normalize(entry);
         const content = await (0, import_promises3.readdir)(normalizedPath, { withFileTypes: true });
+        const isRootOrDirectSubdir = normalizedPath === this.entrypoint || path2.dirname(normalizedPath) === this.entrypoint || // Check if parent directories between this and entrypoint are all category directories
+        this.getPathSegmentsBetween(normalizedPath, this.entrypoint).every(
+          (segment) => this.isCategoryDirectory(segment)
+        );
+        const effectiveDepth = isRootOrDirectSubdir ? 3 : currentDepth;
         for (const item of content) {
-          const itemPath = import_posix.default.join(normalizedPath, item.name);
+          const itemPath = path2.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;
+            if (isCategoryDir || effectiveDepth >= 0) {
+              const nextDepth = isCategoryDir ? effectiveDepth : effectiveDepth - 1;
               await this.scanDeep(itemPath, nextDepth);
             }
           } 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;
+            const isIndexFile = fileName === "index";
             if (this.isMiddleware(itemPath)) {
               this.processMiddleware(itemPath, category);
-            } else if (isInnerSubCommand || isSubCommandGroup) {
+            } else if (effectiveDepth <= 1) {
               this.processSubcommand(
                 itemPath,
-                import_posix.default.basename(normalizedPath),
-                isSubCommandGroup,
-                isIndexFile
+                path2.basename(normalizedPath),
+                effectiveDepth === 0,
+                // isSubCommandGroup when depth is 0
+                isIndexFile,
+                effectiveDepth,
+                category
               );
             } else {
               this.processCommand(
@@ -3916,6 +3922,17 @@ var init_CommandsRouter = __esm({
           }
         }
       }
+      /**
+       * Gets path segments between two paths, excluding the start and end paths
+       * Used to check if all directories between a path and the entrypoint are category directories
+       */
+      getPathSegmentsBetween(path1, path22) {
+        const normalizedPath1 = path2.normalize(path1);
+        const normalizedPath2 = path2.normalize(path22);
+        if (normalizedPath1 === normalizedPath2) return [];
+        const relativePath = path2.relative(normalizedPath2, normalizedPath1);
+        return relativePath.split(path2.sep).filter((segment) => segment !== "." && segment !== "..");
+      }
       processMiddleware(filePath, category) {
         const middleware = {
           id: crypto.randomUUID(),
@@ -3927,19 +3944,41 @@ var init_CommandsRouter = __esm({
         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);
+      processSubcommand(filePath, parentDirName, isGrouped, isIndexFile = false, depth, category) {
+        if (isIndexFile) {
+          const cleanParentDirName = this.extractDirOmitCategory(parentDirName);
+          const parentCommand = this.commands.find((cmd) => {
+            return cmd.name === cleanParentDirName;
+          });
+          if (!parentCommand) {
+            const command = {
+              id: crypto.randomUUID(),
+              name: cleanParentDirName,
+              category,
+              middlewares: [],
+              path: filePath,
+              relativePath: this.getRelativePath(filePath),
+              subcommands: []
+            };
+            this.commands.set(command.id, command);
+          }
+        } else {
+          const subcommand = {
+            id: crypto.randomUUID(),
+            name: this.extractName(filePath),
+            // For subcommands, the group is the directory name (excluding category markers)
+            group: isGrouped ? this.extractDirOmitCategory(parentDirName) : null,
+            middlewares: [],
+            path: filePath,
+            category,
+            relativePath: this.getRelativePath(filePath)
+          };
+          this.subcommands.set(subcommand.id, subcommand);
+          this.applySubcommandToCommands(subcommand);
+        }
       }
       processCommand(filePath, category, parentPath = null) {
+        console.log({ filePath, category, parentPath });
         const command = {
           id: crypto.randomUUID(),
           name: parentPath ? this.getDirectoryName(parentPath) : this.extractName(filePath),
@@ -3951,13 +3990,24 @@ var init_CommandsRouter = __esm({
         };
         this.commands.set(command.id, command);
       }
+      extractDirOmitCategory(dirPath) {
+        const segments = path2.normalize(dirPath).split(path2.sep).reverse();
+        let name = "";
+        while (segments.length > 0) {
+          const segment = segments.pop();
+          if (this.isCategoryDirectory(segment)) continue;
+          name = segment;
+          break;
+        }
+        return name;
+      }
       /**
        * 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) {
+        if (fileName === "index" && path2.dirname(filePath) !== this.entrypoint) {
           return this.getDirectoryName(filePath);
         }
         return fileName;
@@ -3966,7 +4016,7 @@ var init_CommandsRouter = __esm({
        * Extract the clean directory name, removing any category markers
        */
       getDirectoryName(filePath) {
-        const dirName = import_posix.default.basename(import_posix.default.dirname(filePath));
+        const dirName = path2.basename(path2.dirname(filePath));
         return dirName.replace(/^\((\w+)\)$/, "$1");
       }
       // Helper method to identify category directories
@@ -3975,7 +4025,7 @@ var init_CommandsRouter = __esm({
       }
       applyMiddlewareToCommands(middleware) {
         for (const command of this.commands.values()) {
-          const middlewareFileName = import_posix.default.basename(middleware.path);
+          const middlewareFileName = path2.basename(middleware.path);
           const match = middlewareFileName.startsWith(command.name) || middlewareFileName === "middleware";
           if (!match) continue;
           if (command.middlewares.includes(middleware.id)) continue;
@@ -3984,31 +4034,41 @@ var init_CommandsRouter = __esm({
       }
       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);
+          const subcommandPathParts = path2.normalize(subcommand.path).split(path2.sep);
+          const commandName = command.name;
+          const relevantDirectories = subcommandPathParts.map((part) => path2.basename(part)).filter((part) => !this.isCategoryDirectory(part));
+          if (relevantDirectories.includes(commandName)) {
+            if (!command.subcommands.includes(subcommand.id)) {
+              command.subcommands.push(subcommand.id);
+            }
+          }
         }
       }
       extractCategory(entry) {
-        return entry.split(import_posix.default.sep).map((segment) => {
+        return path2.normalize(entry).split(path2.sep).map((segment) => {
           const match = segment.match(/^\((\w+)\)$/);
           return match ? match[1] : null;
-        }).filter(Boolean).join(":");
+        }).filter(Boolean).join(":") || null;
       }
       getRelativePath(entry) {
-        return import_posix.default.relative(this.entrypoint, entry);
+        return path2.relative(this.entrypoint, entry);
       }
       isMiddleware(entry) {
-        return !this.shouldIgnore(entry) && ["middleware", ".middleware."].some((ext) => entry.includes(ext));
+        const fileName = path2.basename(entry);
+        return fileName === "middleware.js" || fileName === "middleware.ts" || fileName === "middleware.mjs" || fileName === "middleware.cjs" || fileName === "middleware.jsx" || fileName === "middleware.tsx" || /\.middleware\.(c|m)?(j|t)sx?$/.test(fileName);
       }
       shouldIgnore(entry, dir = false) {
-        const fileName = import_posix.default.basename(entry);
+        const fileName = path2.basename(entry);
         if (fileName.startsWith("_")) return true;
-        if (!dir) return !/.(c|m)?(j|t)sx?$/.test(fileName);
+        if (!dir) {
+          const ext = path2.extname(fileName).toLowerCase();
+          return ![".js", ".ts", ".jsx", ".tsx", ".mjs", ".cjs"].includes(ext);
+        }
         return false;
       }
       extractName(entry) {
-        return import_posix.default.basename(entry).replace(/\.(c|m)?(j|t)sx?$/, "");
+        const fileName = path2.basename(entry);
+        return path2.parse(fileName).name;
       }
     };
     __name(_CommandsRouter, "CommandsRouter");
@@ -4529,7 +4589,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_path7, import_node_fs8, _started, _CommandKit_instances, init_fn, initCommands_fn, initEvents_fn, _CommandKit, CommandKit;
 var init_CommandKit = __esm({
   "src/CommandKit.ts"() {
     "use strict";
@@ -4551,6 +4611,7 @@ var init_CommandKit = __esm({
     init_loader();
     init_constants();
     init_dev_hooks();
+    import_node_fs8 = require("fs");
     init_CommandKitEventsChannel();
     init_plugins();
     init_types_package();
@@ -4800,10 +4861,14 @@ 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);
+          Logger.info(visual);
+          (0, import_node_fs8.writeFileSync)(
+            "./.commandkit/commands.json",
+            JSON.stringify(result, null, 2)
+          );
         }
       }
       await this.commandHandler.loadCommands();
@@ -4833,7 +4898,7 @@ var init_version = __esm({
     "use strict";
     init_cjs_shims();
     version = /* @__MACRO__ $version */
-    "0.1.11-dev.20250307192025";
+    "0.1.11-dev.20250308073818";
   }
 });
 
@@ -4875,7 +4940,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_path8.join)(cwd, fileName))) {
     panic(`Could not locate the entrypoint file: ${fileName}`);
   }
   const stdio = getStdio(isDev);
@@ -4897,7 +4962,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_fs8;
+var import_node_child_process, import_node_path8, import_node_fs9;
 var init_app_process = __esm({
   "src/cli/app-process.ts"() {
     "use strict";
@@ -4905,7 +4970,7 @@ var init_app_process = __esm({
     import_node_child_process = require("child_process");
     init_env();
     import_node_path8 = require("path");
-    import_node_fs8 = require("fs");
+    import_node_fs9 = require("fs");
     init_common();
     __name(getStdio, "getStdio");
     __name(createAppProcess, "createAppProcess");
@@ -5147,7 +5212,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 +5231,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 +5242,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");