@decaf-ts/cli 0.3.2 → 0.3.6

package/dist/cli.cjs

@@ -5,25 +5,35 @@
 })(this, (function (exports, commander, fs, path) { 'use strict';
 
     /**
-     * @description The name for decaf cli modules where each library must export
-     * a single {@link CliModule}
+     * @description The filename that identifies Decaf CLI modules
+     * @summary The standard filename for CLI module files where each library must export a single CliModule function
      *
-     * @constant
-     * @memberOf module:CLI.cli
+     * @const CLI_FILE_NAME
+     * @memberOf module:CLI
      */
     const CLI_FILE_NAME = "cli-module";
 
     /**
-     * @description util class to retrieve versions and other information
+     * @description Utility class for CLI operations
+     * @summary A static utility class that provides methods for loading modules, retrieving package information, and initializing CLI commands
+     *
+     * @example
+     * // Initialize a Command object with package information
+     * const command = new Command();
+     * CLIUtils.initialize(command, './path/to/package');
+     *
+     * // Load a CLI module from a file
+     * const module = await CLIUtils.loadFromFile('./path/to/cli-module.js');
      *
      * @class CLIUtils
-     * @static
      */
     class CLIUtils {
         /**
-         * @description Dynamically imports a cjs file into a decaf module
-         * @param {string} path
-         * @static
+         * @description Dynamically imports a module file
+         * @summary Loads a JavaScript file and returns it as a CliModule, handling both ESM and CommonJS formats
+         *
+         * @param {string} path The file path to the module to load
+         * @return {Promise<CliModule>} A promise that resolves to the loaded CliModule
          */
         static async loadFromFile(path) {
             try {
@@ -34,11 +44,12 @@
             }
         }
         /**
-         * @description allows safe dynamic imports
-         * @summary property imports JS files regardless of esm status
+         * @description Normalizes module imports to handle both ESM and CommonJS formats
+         * @summary Properly imports JavaScript files regardless of their module format by handling the ESM wrapper for CommonJS modules
          *
-         * @typeParam T
-         * @param {Promise} importPromise
+         * @template T The type of the imported module
+         * @param {Promise<T>} importPromise The promise returned by the dynamic import
+         * @return {Promise<T>} A promise that resolves to the normalized module
          * @private
          */
         static async normalizeImport(importPromise) {
@@ -46,10 +57,12 @@
             return importPromise.then((m) => (m.default || m));
         }
         /**
-         * @description initializes the Cli object
+         * @description Initializes a Command object with package information
+         * @summary Sets up a Commander Command object with the package name, description, and version from the package.json file
          *
-         * @param {Command} command
-         * @param {string} [basePath] defaults to the current working directory
+         * @param {Command} command The Command object to initialize
+         * @param {string} [basePath] The base path where the package.json file is located, defaults to the current working directory
+         * @return {void}
          */
         static initialize(command, basePath) {
             const name = CLIUtils.packageName(basePath);
@@ -59,9 +72,11 @@
                 .version(CLIUtils.packageVersion(basePath));
         }
         /**
-         * @description retrieves and parses the package.json file
+         * @description Retrieves and parses the package.json file
+         * @summary Reads the package.json file from the specified path and parses it into a JavaScript object
          *
-         * @param {string} basePath
+         * @param {string} basePath The base path where the package.json file is located
+         * @return {Record<string, unknown>} The parsed package.json content as an object
          * @private
          */
         static getPackage(basePath) {
@@ -73,27 +88,42 @@
             }
         }
         /**
-         * @description returns the package version
-         * @param {string} [basePath] defaults to current working dir
+         * @description Returns the version from package.json
+         * @summary Retrieves the version field from the package.json file at the specified path
+         *
+         * @param {string} basePath The base path where the package.json file is located
+         * @return {string} The package version string
          */
         static packageVersion(basePath) {
             return CLIUtils.getPackage(basePath)["version"];
         }
         /**
-         * @description returns the package name
-         * @param {string} [basePath] defaults to current working dir
+         * @description Returns the name from package.json
+         * @summary Retrieves the name field from the package.json file at the specified path and extracts the package name without the scope
+         *
+         * @param {string} basePath The base path where the package.json file is located
+         * @return {string} The package name without the scope (e.g., "cli" from "@decaf-ts/cli")
          */
         static packageName(basePath) {
-            return CLIUtils.getPackage(basePath)["name"].split("/")[1];
+            const name = CLIUtils.getPackage(basePath)["name"].split("/");
+            return name[name.length - 1];
         }
     }
 
     /**
-     * @summary Util class to handle CLI functionality from all Decaf modules
-     * @description CLI handler class
+     * @description Utility class to handle CLI functionality from all Decaf modules
+     * @summary This class provides a wrapper around Commander.js to handle CLI commands from different Decaf modules.
+     * It crawls the filesystem to find CLI modules, loads them, and registers their commands.
      *
-     * @param {string} [basepath] the base path to look for modules in. defaults to `./`
-     * @param {string} [crawlLevels] folders to crawl to find modules from the basePath. defaults to 4
+     * @param {string} [basePath] The base path to look for modules in. Defaults to `./`
+     * @param {number} [crawlLevels] Number of folder levels to crawl to find modules from the basePath. Defaults to 4
+     *
+     * @example
+     * // Create a new CLI wrapper and run it with custom options
+     * const cli = new CliWrapper('./src', 2);
+     * cli.run(process.argv).then(() => {
+     *   console.log('CLI commands executed successfully');
+     * });
      *
      * @class CliWrapper
      */
@@ -102,26 +132,47 @@
             this.basePath = basePath;
             this.crawlLevels = crawlLevels;
             this.modules = {};
+            this.rootPath = path.resolve(__dirname, "..");
         }
         /**
-         * @description Retrieves and initializes the {@link Command} object
+         * @description Retrieves and initializes the Commander Command object
+         * @summary Lazy-loads the Command object, initializing it with the package name, description, and version
+         * @return {Command} The initialized Command object
          * @private
          */
         get command() {
             if (!this._command) {
                 this._command = new commander.Command();
-                CLIUtils.initialize(this._command, this.basePath);
+                CLIUtils.initialize(this._command, this.rootPath);
             }
             return this._command;
         }
         /**
-         * @description loads and registers module from a file
+         * @description Loads and registers a module from a file
+         * @summary Dynamically imports a CLI module from the specified file path, initializes it, and registers it in the modules collection
          *
-         * @param {string} filePath path to look for modules
-         * @param {string} rootPath repo root to find the package.json
-         * @return {string} the module name
+         * @param {string} filePath Path to the module file to load
+         * @param {string} rootPath Repository root path to find the package.json
+         * @return {Promise<string>} A promise that resolves to the module name
          *
          * @private
+         * @mermaid
+         * sequenceDiagram
+         *   participant CliWrapper
+         *   participant CLIUtils
+         *   participant Module
+         *
+         *   CliWrapper->>CLIUtils: loadFromFile(filePath)
+         *   CLIUtils-->>CliWrapper: module
+         *   CliWrapper->>CliWrapper: Get module name
+         *   CliWrapper->>Command: new Command()
+         *   Command-->>CliWrapper: cmd
+         *   CliWrapper->>CLIUtils: initialize(cmd, path.dirname(rootPath))
+         *   CliWrapper->>Module: module()
+         *   Note over CliWrapper,Module: Handle Promise if needed
+         *   Module-->>CliWrapper: Command instance
+         *   CliWrapper->>CliWrapper: Store in modules[name]
+         *   CliWrapper-->>CliWrapper: Return name
          */
         async load(filePath, rootPath) {
             let name;
@@ -129,7 +180,7 @@
                 const module = await CLIUtils.loadFromFile(filePath);
                 name = module.name;
                 const cmd = new commander.Command();
-                CLIUtils.initialize(cmd, path.dirname(rootPath));
+                CLIUtils.initialize(cmd, rootPath);
                 let m = module();
                 if (m instanceof Promise)
                     m = await m;
@@ -141,12 +192,36 @@
             return name;
         }
         /**
-         * @description finds all the cli modules in the basePath via {@link CliWrapper.crawl}
-         * and loads them
+         * @description Finds and loads all CLI modules in the basePath
+         * @summary Uses the crawl method to find all CLI modules in the specified base path,
+         * then loads and registers each module as a subcommand
+         *
+         * @return {Promise<void>} A promise that resolves when all modules are loaded
+         *
          * @private
+         * @mermaid
+         * sequenceDiagram
+         *   participant CliWrapper
+         *   participant Filesystem
+         *   participant Module
+         *
+         *   CliWrapper->>Filesystem: Join basePath with cwd
+         *   CliWrapper->>CliWrapper: crawl(basePath, crawlLevels)
+         *   CliWrapper-->>CliWrapper: modules[]
+         *   loop For each module
+         *     alt Not @decaf-ts/cli
+         *       CliWrapper->>CliWrapper: load(module, cwd)
+         *       CliWrapper-->>CliWrapper: name
+         *       CliWrapper->>CliWrapper: Check if command exists
+         *       alt Command doesn't exist
+         *         CliWrapper->>Command: command(name).addCommand(modules[name])
+         *       end
+         *     end
+         *   end
+         *   CliWrapper->>Console: Log loaded modules
          */
         async boot() {
-            const basePath = path.join(process.cwd(), this.basePath);
+            const basePath = path.resolve(this.rootPath, this.basePath);
             const modules = this.crawl(basePath, this.crawlLevels);
             for (const module of modules) {
                 if (module.includes("@decaf-ts/cli")) {
@@ -154,7 +229,7 @@
                 }
                 let name;
                 try {
-                    name = await this.load(module, process.cwd());
+                    name = await this.load(module, this.rootPath);
                 }
                 catch (e) {
                     console.error(e);
@@ -173,9 +248,13 @@
             .join("\n")}`);
         }
         /**
-         * @description crawls the basePath up for 'levels' folders to find a module,eg a {@link CLI_FILE_NAME} named file
-         * @param {string} basePath the relative base batch to start searching in
-         * @param {number} [levels] the max number of levels to crawl. defaults to 2
+         * @description Recursively searches for CLI module files in the directory structure
+         * @summary Crawls the basePath up to the specified number of folder levels to find files named according to CLI_FILE_NAME
+         *
+         * @param {string} basePath The absolute base path to start searching in
+         * @param {number} [levels=2] The maximum number of directory levels to crawl
+         * @return {string[]} An array of file paths to CLI modules
+         *
          * @private
          */
         crawl(basePath, levels = 2) {
@@ -193,9 +272,24 @@
             }, []);
         }
         /**
-         * @description runs the given command
+         * @description Executes the CLI with the provided arguments
+         * @summary Boots the CLI by loading all modules, then parses and executes the command specified in the arguments
+         *
+         * @param {string[]} [args=process.argv] Command line arguments to parse and execute
+         * @return {Promise<void>} A promise that resolves when the command execution is complete
          *
-         * @param {string[]} [args] args to run. defaults to process.argv
+         * @mermaid
+         * sequenceDiagram
+         *   participant Client
+         *   participant CliWrapper
+         *   participant Command
+         *
+         *   Client->>CliWrapper: run(args)
+         *   CliWrapper->>CliWrapper: boot()
+         *   Note over CliWrapper: Loads all modules
+         *   CliWrapper->>Command: parseAsync(args)
+         *   Command-->>CliWrapper: result
+         *   CliWrapper-->>Client: result
          */
         async run(args = process.argv) {
             await this.boot();
@@ -206,7 +300,8 @@
     /**
      * @description Decaf-ts' CLI module
      * @summary This file will crawl the current working directory for files called {@link CLI_FILE_NAME}
-     * within the @decaf-ts namespace and load then as subcommands
+     * within the @decaf-ts namespace and load them as subcommands. It serves as the main entry point
+     * for the CLI functionality, exporting the CliWrapper class and VERSION constant.
      *
      * @example
      * run module command     - $ npx decaf <module name> <module command> ...<module command options>
@@ -217,29 +312,15 @@
      * @module CLI
      */
     /**
-     * @description Decaf-ts' CLI namespace
-     * @summary This file will crawl the current working directory for files called {@link CLI_FILE_NAME}
-     * within the @decaf-ts namespace and load then as subcommands
-     *
-     * @example
-     * run module command     - $ npx decaf <module name> <module command> ...<module command options>
-     * get module help        - $ npx decaf help <module name>;
-     * list imported modules  - $ npx decaf list;
-     * get cli help           - $ npx decaf help;
-     *
-     * @namespace cli
-     * @memberOf module:CLI
-     */
-    /**
-     * @summary stores the current package version
-     * @description this is how you should document a constant
+     * @description Stores the current package version
+     * @summary A constant that holds the version string of the package, which is replaced during build
      * @const VERSION
      * @memberOf module:CLI
      */
-    const VERSION = "0.3.1";
+    const VERSION = "0.3.6";
 
     exports.CliWrapper = CliWrapper;
     exports.VERSION = VERSION;
 
 }));
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"cli.cjs","sources":["../src/constants.ts","../src/utils.ts","../src/CliWrapper.ts","../src/index.ts"],"sourcesContent":["// eslint-disable-next-line @typescript-eslint/no-unused-vars\nimport { CliModule } from \"./types\";\n\n/**\n * @description The name for decaf cli modules where each library must export\n * a single {@link CliModule}\n *\n * @constant\n * @memberOf module:CLI.cli\n */\nexport const CLI_FILE_NAME = \"cli-module\";\n","import path from \"path\";\nimport fs from \"fs\";\nimport { Command } from \"commander\";\nimport { CliModule } from \"./types\";\n\n/**\n * @description util class to retrieve versions and other information\n *\n * @class CLIUtils\n * @static\n */\nexport class CLIUtils {\n  /**\n   * @description Dynamically imports a cjs file into a decaf module\n   * @param {string} path\n   * @static\n   */\n  static async loadFromFile(path: string): Promise<CliModule> {\n    try {\n      return CLIUtils.normalizeImport(import(path));\n    } catch (e: unknown) {\n      throw new Error(\n        `Failed to load from ${path}: ${e instanceof Error ? e.message : e}`\n      );\n    }\n  }\n\n  /**\n   * @description allows safe dynamic imports\n   * @summary property imports JS files regardless of esm status\n   *\n   * @typeParam T\n   * @param {Promise} importPromise\n   * @private\n   */\n  static async normalizeImport<T>(importPromise: Promise<T>): Promise<T> {\n    // CommonJS's `module.exports` is wrapped as `default` in ESModule.\n    return importPromise.then(\n      (m: unknown) => ((m as { default: T }).default || m) as T\n    );\n  }\n\n  /**\n   * @description initializes the Cli object\n   *\n   * @param {Command} command\n   * @param {string} [basePath] defaults to the current working directory\n   */\n  static initialize(command: Command, basePath: string) {\n    const name = CLIUtils.packageName(basePath);\n    command\n      .name(name)\n      .description(`Runs ${name} related commands`)\n      .version(CLIUtils.packageVersion(basePath));\n  }\n\n  /**\n   * @description retrieves and parses the package.json file\n   *\n   * @param {string} basePath\n   * @private\n   */\n  private static getPackage(basePath: string): Record<string, unknown> {\n    try {\n      return JSON.parse(\n        fs.readFileSync(path.join(basePath, \"package.json\"), \"utf8\")\n      );\n    } catch (e: unknown) {\n      throw new Error(`Unable to read version from ${basePath}: ${e}`);\n    }\n  }\n\n  /**\n   * @description returns the package version\n   * @param {string} [basePath] defaults to current working dir\n   */\n  static packageVersion(basePath: string): string {\n    return CLIUtils.getPackage(basePath)[\"version\"] as string;\n  }\n\n  /**\n   * @description returns the package name\n   * @param {string} [basePath] defaults to current working dir\n   */\n  static packageName(basePath: string): string {\n    return (CLIUtils.getPackage(basePath)[\"name\"] as string).split(\"/\")[1];\n  }\n}\n","import { Command } from \"commander\";\nimport fs from \"fs\";\nimport path from \"path\";\nimport { CLI_FILE_NAME } from \"./constants\";\nimport { CLIUtils } from \"./utils\";\n\n/**\n * @summary Util class to handle CLI functionality from all Decaf modules\n * @description CLI handler class\n *\n * @param {string} [basepath] the base path to look for modules in. defaults to `./`\n * @param {string} [crawlLevels] folders to crawl to find modules from the basePath. defaults to 4\n *\n * @class CliWrapper\n */\nexport class CliWrapper {\n  private _command?: Command;\n  private modules: Record<string, Command> = {};\n\n  constructor(\n    private basePath: string = \"./\",\n    private crawlLevels = 4\n  ) {}\n\n  /**\n   * @description Retrieves and initializes the {@link Command} object\n   * @private\n   */\n  private get command() {\n    if (!this._command) {\n      this._command = new Command();\n      CLIUtils.initialize(this._command, this.basePath);\n    }\n    return this._command;\n  }\n\n  /**\n   * @description loads and registers module from a file\n   *\n   * @param {string} filePath path to look for modules\n   * @param {string} rootPath repo root to find the package.json\n   * @return {string} the module name\n   *\n   * @private\n   */\n  private async load(filePath: string, rootPath: string): Promise<string> {\n    let name;\n    try {\n      const module = await CLIUtils.loadFromFile(filePath);\n      name = module.name;\n      const cmd = new Command();\n      CLIUtils.initialize(cmd, path.dirname(rootPath));\n      let m = module();\n      if (m instanceof Promise) m = await m;\n      this.modules[name] = m;\n    } catch (e: unknown) {\n      throw new Error(\n        `failed to load module ${name || \"unnamed\"} under ${filePath}: ${e instanceof Error ? e.message : e}`\n      );\n    }\n    return name;\n  }\n\n  /**\n   * @description finds all the cli modules in the basePath via {@link CliWrapper.crawl}\n   * and loads them\n   * @private\n   */\n  private async boot() {\n    const basePath = path.join(process.cwd(), this.basePath);\n    const modules = this.crawl(basePath, this.crawlLevels);\n    for (const module of modules) {\n      if (module.includes(\"@decaf-ts/cli\")) {\n        continue;\n      }\n      let name: string;\n      try {\n        name = await this.load(module, process.cwd());\n      } catch (e: unknown) {\n        console.error(e);\n        continue;\n      }\n\n      if (\n        !this.command.commands.find(\n          (c) => (c as unknown as Record<string, string>)[\"_name\"] === name\n        )\n      )\n        try {\n          this.command.command(name).addCommand(this.modules[name]);\n        } catch (e: unknown) {\n          console.error(e);\n        }\n    }\n    console.log(\n      `loaded modules:\\n${Object.keys(this.modules)\n        .map((k) => `- ${k}`)\n        .join(\"\\n\")}`\n    );\n  }\n\n  /**\n   * @description crawls the basePath up for 'levels' folders to find a module,eg a {@link CLI_FILE_NAME} named file\n   * @param {string} basePath the relative base batch to start searching in\n   * @param {number} [levels] the max number of levels to crawl. defaults to 2\n   * @private\n   */\n  private crawl(basePath: string, levels: number = 2) {\n    if (levels <= 0) return [];\n    return fs.readdirSync(basePath).reduce((accum: string[], file) => {\n      file = path.join(basePath, file);\n      if (fs.statSync(file).isDirectory()) {\n        accum.push(...this.crawl(file, levels - 1));\n      } else if (file.match(new RegExp(`${CLI_FILE_NAME}.[cm]?js$`, \"gm\"))) {\n        accum.push(file);\n      }\n      return accum;\n    }, []);\n  }\n\n  /**\n   * @description runs the given command\n   *\n   * @param {string[]} [args] args to run. defaults to process.argv\n   */\n  async run(args: string[] = process.argv) {\n    await this.boot();\n    return this.command.parseAsync(args);\n  }\n}\n","export * from \"./CliWrapper\";\n\n/**\n * @description Decaf-ts' CLI module\n * @summary This file will crawl the current working directory for files called {@link CLI_FILE_NAME}\n * within the @decaf-ts namespace and load then as subcommands\n *\n * @example\n * run module command     - $ npx decaf <module name> <module command> ...<module command options>\n * get module help        - $ npx decaf help <module name>;\n * list imported modules  - $ npx decaf list;\n * get cli help           - $ npx decaf help;\n *\n * @module CLI\n */\n\n/**\n * @description Decaf-ts' CLI namespace\n * @summary This file will crawl the current working directory for files called {@link CLI_FILE_NAME}\n * within the @decaf-ts namespace and load then as subcommands\n *\n * @example\n * run module command     - $ npx decaf <module name> <module command> ...<module command options>\n * get module help        - $ npx decaf help <module name>;\n * list imported modules  - $ npx decaf list;\n * get cli help           - $ npx decaf help;\n *\n * @namespace cli\n * @memberOf module:CLI\n */\n\n/**\n * @summary stores the current package version\n * @description this is how you should document a constant\n * @const VERSION\n * @memberOf module:CLI\n */\nexport const VERSION = \"##VERSION##\";\n"],"names":["Command"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"cli.cjs","sources":["../src/constants.ts","../src/utils.ts","../src/CliWrapper.ts","../src/index.ts"],"sourcesContent":["// eslint-disable-next-line @typescript-eslint/no-unused-vars\nimport { CliModule } from \"./types\";\n\n/**\n * @description The filename that identifies Decaf CLI modules\n * @summary The standard filename for CLI module files where each library must export a single CliModule function\n *\n * @const CLI_FILE_NAME\n * @memberOf module:CLI\n */\nexport const CLI_FILE_NAME = \"cli-module\";\n","import path from \"path\";\nimport fs from \"fs\";\nimport { Command } from \"commander\";\nimport { CliModule } from \"./types\";\n\n/**\n * @description Utility class for CLI operations\n * @summary A static utility class that provides methods for loading modules, retrieving package information, and initializing CLI commands\n * \n * @example\n * // Initialize a Command object with package information\n * const command = new Command();\n * CLIUtils.initialize(command, './path/to/package');\n * \n * // Load a CLI module from a file\n * const module = await CLIUtils.loadFromFile('./path/to/cli-module.js');\n * \n * @class CLIUtils\n */\nexport class CLIUtils {\n  /**\n   * @description Dynamically imports a module file\n   * @summary Loads a JavaScript file and returns it as a CliModule, handling both ESM and CommonJS formats\n   * \n   * @param {string} path The file path to the module to load\n   * @return {Promise<CliModule>} A promise that resolves to the loaded CliModule\n   */\n  static async loadFromFile(path: string): Promise<CliModule> {\n    try {\n      return CLIUtils.normalizeImport(import(path));\n    } catch (e: unknown) {\n      throw new Error(\n        `Failed to load from ${path}: ${e instanceof Error ? e.message : e}`\n      );\n    }\n  }\n\n  /**\n   * @description Normalizes module imports to handle both ESM and CommonJS formats\n   * @summary Properly imports JavaScript files regardless of their module format by handling the ESM wrapper for CommonJS modules\n   *\n   * @template T The type of the imported module\n   * @param {Promise<T>} importPromise The promise returned by the dynamic import\n   * @return {Promise<T>} A promise that resolves to the normalized module\n   * @private\n   */\n  static async normalizeImport<T>(importPromise: Promise<T>): Promise<T> {\n    // CommonJS's `module.exports` is wrapped as `default` in ESModule.\n    return importPromise.then(\n      (m: unknown) => ((m as { default: T }).default || m) as T\n    );\n  }\n\n  /**\n   * @description Initializes a Command object with package information\n   * @summary Sets up a Commander Command object with the package name, description, and version from the package.json file\n   *\n   * @param {Command} command The Command object to initialize\n   * @param {string} [basePath] The base path where the package.json file is located, defaults to the current working directory\n   * @return {void}\n   */\n  static initialize(command: Command, basePath: string) {\n    const name = CLIUtils.packageName(basePath);\n    command\n      .name(name)\n      .description(`Runs ${name} related commands`)\n      .version(CLIUtils.packageVersion(basePath));\n  }\n\n  /**\n   * @description Retrieves and parses the package.json file\n   * @summary Reads the package.json file from the specified path and parses it into a JavaScript object\n   *\n   * @param {string} basePath The base path where the package.json file is located\n   * @return {Record<string, unknown>} The parsed package.json content as an object\n   * @private\n   */\n  private static getPackage(basePath: string): Record<string, unknown> {\n    try {\n      return JSON.parse(\n        fs.readFileSync(path.join(basePath, \"package.json\"), \"utf8\")\n      );\n    } catch (e: unknown) {\n      throw new Error(`Unable to read version from ${basePath}: ${e}`);\n    }\n  }\n\n  /**\n   * @description Returns the version from package.json\n   * @summary Retrieves the version field from the package.json file at the specified path\n   *\n   * @param {string} basePath The base path where the package.json file is located\n   * @return {string} The package version string\n   */\n  static packageVersion(basePath: string): string {\n    return CLIUtils.getPackage(basePath)[\"version\"] as string;\n  }\n\n  /**\n   * @description Returns the name from package.json\n   * @summary Retrieves the name field from the package.json file at the specified path and extracts the package name without the scope\n   *\n   * @param {string} basePath The base path where the package.json file is located\n   * @return {string} The package name without the scope (e.g., \"cli\" from \"@decaf-ts/cli\")\n   */\n  static packageName(basePath: string): string {\n    const name = (CLIUtils.getPackage(basePath)[\"name\"] as string).split(\"/\");\n    return name[name.length - 1];\n  }\n}\n","import { Command } from \"commander\";\nimport fs from \"fs\";\nimport path from \"path\";\nimport { CLI_FILE_NAME } from \"./constants\";\nimport { CLIUtils } from \"./utils\";\n\n/**\n * @description Utility class to handle CLI functionality from all Decaf modules\n * @summary This class provides a wrapper around Commander.js to handle CLI commands from different Decaf modules.\n * It crawls the filesystem to find CLI modules, loads them, and registers their commands.\n * \n * @param {string} [basePath] The base path to look for modules in. Defaults to `./`\n * @param {number} [crawlLevels] Number of folder levels to crawl to find modules from the basePath. Defaults to 4\n * \n * @example\n * // Create a new CLI wrapper and run it with custom options\n * const cli = new CliWrapper('./src', 2);\n * cli.run(process.argv).then(() => {\n *   console.log('CLI commands executed successfully');\n * });\n * \n * @class CliWrapper\n */\nexport class CliWrapper {\n  private _command?: Command;\n  private modules: Record<string, Command> = {};\n  private readonly rootPath: string;\n\n  constructor(\n    private basePath: string = \"./\",\n    private crawlLevels = 4\n  ) {\n    this.rootPath = path.resolve(__dirname, \"..\");\n  }\n\n  /**\n   * @description Retrieves and initializes the Commander Command object\n   * @summary Lazy-loads the Command object, initializing it with the package name, description, and version\n   * @return {Command} The initialized Command object\n   * @private\n   */\n  private get command() {\n    if (!this._command) {\n      this._command = new Command();\n      CLIUtils.initialize(this._command, this.rootPath);\n    }\n    return this._command;\n  }\n\n  /**\n   * @description Loads and registers a module from a file\n   * @summary Dynamically imports a CLI module from the specified file path, initializes it, and registers it in the modules collection\n   *\n   * @param {string} filePath Path to the module file to load\n   * @param {string} rootPath Repository root path to find the package.json\n   * @return {Promise<string>} A promise that resolves to the module name\n   *\n   * @private\n   * @mermaid\n   * sequenceDiagram\n   *   participant CliWrapper\n   *   participant CLIUtils\n   *   participant Module\n   *   \n   *   CliWrapper->>CLIUtils: loadFromFile(filePath)\n   *   CLIUtils-->>CliWrapper: module\n   *   CliWrapper->>CliWrapper: Get module name\n   *   CliWrapper->>Command: new Command()\n   *   Command-->>CliWrapper: cmd\n   *   CliWrapper->>CLIUtils: initialize(cmd, path.dirname(rootPath))\n   *   CliWrapper->>Module: module()\n   *   Note over CliWrapper,Module: Handle Promise if needed\n   *   Module-->>CliWrapper: Command instance\n   *   CliWrapper->>CliWrapper: Store in modules[name]\n   *   CliWrapper-->>CliWrapper: Return name\n   */\n  private async load(filePath: string, rootPath: string): Promise<string> {\n    let name;\n    try {\n      const module = await CLIUtils.loadFromFile(filePath);\n      name = module.name;\n      const cmd = new Command();\n      CLIUtils.initialize(cmd, rootPath);\n      let m = module();\n      if (m instanceof Promise) m = await m;\n      this.modules[name] = m;\n    } catch (e: unknown) {\n      throw new Error(\n        `failed to load module ${name || \"unnamed\"} under ${filePath}: ${e instanceof Error ? e.message : e}`\n      );\n    }\n    return name;\n  }\n\n  /**\n   * @description Finds and loads all CLI modules in the basePath\n   * @summary Uses the crawl method to find all CLI modules in the specified base path, \n   * then loads and registers each module as a subcommand\n   * \n   * @return {Promise<void>} A promise that resolves when all modules are loaded\n   * \n   * @private\n   * @mermaid\n   * sequenceDiagram\n   *   participant CliWrapper\n   *   participant Filesystem\n   *   participant Module\n   *   \n   *   CliWrapper->>Filesystem: Join basePath with cwd\n   *   CliWrapper->>CliWrapper: crawl(basePath, crawlLevels)\n   *   CliWrapper-->>CliWrapper: modules[]\n   *   loop For each module\n   *     alt Not @decaf-ts/cli\n   *       CliWrapper->>CliWrapper: load(module, cwd)\n   *       CliWrapper-->>CliWrapper: name\n   *       CliWrapper->>CliWrapper: Check if command exists\n   *       alt Command doesn't exist\n   *         CliWrapper->>Command: command(name).addCommand(modules[name])\n   *       end\n   *     end\n   *   end\n   *   CliWrapper->>Console: Log loaded modules\n   */\n  private async boot() {\n    const basePath = path.resolve(this.rootPath, this.basePath);\n    const modules = this.crawl(basePath, this.crawlLevels);\n    for (const module of modules) {\n      if (module.includes(\"@decaf-ts/cli\")) {\n        continue;\n      }\n      let name: string;\n      try {\n        name = await this.load(module, this.rootPath);\n      } catch (e: unknown) {\n        console.error(e);\n        continue;\n      }\n\n      if (\n        !this.command.commands.find(\n          (c) => (c as unknown as Record<string, string>)[\"_name\"] === name\n        )\n      )\n        try {\n          this.command.command(name).addCommand(this.modules[name]);\n        } catch (e: unknown) {\n          console.error(e);\n        }\n    }\n    console.log(\n      `loaded modules:\\n${Object.keys(this.modules)\n        .map((k) => `- ${k}`)\n        .join(\"\\n\")}`\n    );\n  }\n\n  /**\n   * @description Recursively searches for CLI module files in the directory structure\n   * @summary Crawls the basePath up to the specified number of folder levels to find files named according to CLI_FILE_NAME\n   * \n   * @param {string} basePath The absolute base path to start searching in\n   * @param {number} [levels=2] The maximum number of directory levels to crawl\n   * @return {string[]} An array of file paths to CLI modules\n   * \n   * @private\n   */\n  private crawl(basePath: string, levels: number = 2) {\n    if (levels <= 0) return [];\n    return fs.readdirSync(basePath).reduce((accum: string[], file) => {\n      file = path.join(basePath, file);\n      if (fs.statSync(file).isDirectory()) {\n        accum.push(...this.crawl(file, levels - 1));\n      } else if (file.match(new RegExp(`${CLI_FILE_NAME}.[cm]?js$`, \"gm\"))) {\n        accum.push(file);\n      }\n      return accum;\n    }, []);\n  }\n\n  /**\n   * @description Executes the CLI with the provided arguments\n   * @summary Boots the CLI by loading all modules, then parses and executes the command specified in the arguments\n   *\n   * @param {string[]} [args=process.argv] Command line arguments to parse and execute\n   * @return {Promise<void>} A promise that resolves when the command execution is complete\n   * \n   * @mermaid\n   * sequenceDiagram\n   *   participant Client\n   *   participant CliWrapper\n   *   participant Command\n   *   \n   *   Client->>CliWrapper: run(args)\n   *   CliWrapper->>CliWrapper: boot()\n   *   Note over CliWrapper: Loads all modules\n   *   CliWrapper->>Command: parseAsync(args)\n   *   Command-->>CliWrapper: result\n   *   CliWrapper-->>Client: result\n   */\n  async run(args: string[] = process.argv) {\n    await this.boot();\n    return this.command.parseAsync(args);\n  }\n}\n","export * from \"./CliWrapper\";\n\n/**\n * @description Decaf-ts' CLI module\n * @summary This file will crawl the current working directory for files called {@link CLI_FILE_NAME}\n * within the @decaf-ts namespace and load them as subcommands. It serves as the main entry point\n * for the CLI functionality, exporting the CliWrapper class and VERSION constant.\n *\n * @example\n * run module command     - $ npx decaf <module name> <module command> ...<module command options>\n * get module help        - $ npx decaf help <module name>;\n * list imported modules  - $ npx decaf list;\n * get cli help           - $ npx decaf help;\n *\n * @module CLI\n */\n\n/**\n * @description Stores the current package version\n * @summary A constant that holds the version string of the package, which is replaced during build\n * @const VERSION\n * @memberOf module:CLI\n */\nexport const VERSION = \"##VERSION##\";\n"],"names":["Command"],"mappings":"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"}