@decaf-ts/cli 0.3.5 → 0.3.6

package/dist/cli.esm.cjs

@@ -3,25 +3,35 @@ import fs from 'fs';
 import path from 'path';
 
 /**
- * @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 {
@@ -32,11 +42,12 @@ class CLIUtils {
         }
     }
     /**
-     * @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) {
@@ -44,10 +55,12 @@ class CLIUtils {
         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);
@@ -57,9 +70,11 @@ class CLIUtils {
             .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) {
@@ -71,27 +86,42 @@ class CLIUtils {
         }
     }
     /**
-     * @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
  */
@@ -100,26 +130,47 @@ class CliWrapper {
         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 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;
@@ -127,7 +178,7 @@ class CliWrapper {
             const module = await CLIUtils.loadFromFile(filePath);
             name = module.name;
             const cmd = new Command();
-            CLIUtils.initialize(cmd, path.dirname(rootPath));
+            CLIUtils.initialize(cmd, rootPath);
             let m = module();
             if (m instanceof Promise)
                 m = await m;
@@ -139,12 +190,36 @@ class CliWrapper {
         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")) {
@@ -152,7 +227,7 @@ class CliWrapper {
             }
             let name;
             try {
-                name = await this.load(module, process.cwd());
+                name = await this.load(module, this.rootPath);
             }
             catch (e) {
                 console.error(e);
@@ -171,9 +246,13 @@ class CliWrapper {
             .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) {
@@ -191,9 +270,24 @@ class CliWrapper {
         }, []);
     }
     /**
-     * @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();
@@ -204,7 +298,8 @@ class CliWrapper {
 /**
  * @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>
@@ -215,26 +310,12 @@ class CliWrapper {
  * @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.4";
+const VERSION = "0.3.6";
 
 export { CliWrapper, VERSION };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"cli.esm.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":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"cli.esm.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":[],"mappings":"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"}