@navios/commander 1.5.1 → 1.7.0

package/src/services/cli-parser.service.mts

@@ -16,6 +16,7 @@ export interface ParsedCliArgs {
   /**
    * Parsed options as key-value pairs.
    * Keys are converted from kebab-case to camelCase.
+   * Supports object notation (e.g., --obj.field=value creates { obj: { field: value } }).
    */
   options: Record<string, any>
   /**
@@ -33,6 +34,8 @@ export interface ParsedCliArgs {
  * - Boolean flags
  * - Array options
  * - Positional arguments
+ * - Object notation: `--obj.field=value` or `--obj.nested.field value`
+ *   Creates nested objects automatically (e.g., { obj: { field: value } })
  *
  * @public
  */
@@ -81,52 +84,103 @@ export class CliParserService {
 
       if (arg.startsWith('--')) {
         // Long option format: --key=value or --key value
+        // Also supports object notation: --obj.field=value or --obj.field value
         const key = arg.slice(2)
         const equalIndex = key.indexOf('=')
 
         if (equalIndex !== -1) {
-          // Format: --key=value
+          // Format: --key=value or --obj.field=value
           const optionName = key.slice(0, equalIndex)
           const optionValue = key.slice(equalIndex + 1)
-          const camelCaseKey = this.camelCase(optionName)
-          const isArray = arrayFields.has(camelCaseKey) || arrayFields.has(optionName)
 
-          if (isArray) {
-            // For array fields, accumulate values
-            if (!options[camelCaseKey]) {
-              options[camelCaseKey] = []
+          if (this.isObjectNotation(optionName)) {
+            // Object notation: --obj.field=value
+            const processedPath = this.processObjectNotationKey(optionName)
+            const isArray = optionsSchema ? this.isNestedArray(optionsSchema, processedPath) : false
+
+            if (isArray) {
+              const existingValue = this.getNestedProperty(options, processedPath)
+              if (!Array.isArray(existingValue)) {
+                this.setNestedProperty(options, processedPath, [])
+              }
+              this.getNestedProperty(options, processedPath).push(this.parseValue(optionValue))
+            } else {
+              this.setNestedProperty(options, processedPath, this.parseValue(optionValue))
             }
-            options[camelCaseKey].push(this.parseValue(optionValue))
           } else {
-            options[camelCaseKey] = this.parseValue(optionValue)
+            // Flat option: --key=value
+            const camelCaseKey = this.camelCase(optionName)
+            const isArray = arrayFields.has(camelCaseKey) || arrayFields.has(optionName)
+
+            if (isArray) {
+              // For array fields, accumulate values
+              if (!options[camelCaseKey]) {
+                options[camelCaseKey] = []
+              }
+              options[camelCaseKey].push(this.parseValue(optionValue))
+            } else {
+              options[camelCaseKey] = this.parseValue(optionValue)
+            }
           }
           i++
         } else {
           // Format: --key value or --boolean-flag
-          const camelCaseKey = this.camelCase(key)
-          const isBoolean = booleanFields.has(camelCaseKey) || booleanFields.has(key)
-          const isArray = arrayFields.has(camelCaseKey) || arrayFields.has(key)
-          const nextArg = args[i + 1]
-
-          if (isBoolean) {
-            // Known boolean flag from schema
-            options[camelCaseKey] = true
-            i++
-          } else if (isArray && nextArg && !nextArg.startsWith('-')) {
-            // Known array field from schema - accumulate values
-            if (!options[camelCaseKey]) {
-              options[camelCaseKey] = []
+          // Also supports: --obj.field value or --obj.boolean-flag
+
+          if (this.isObjectNotation(key)) {
+            // Object notation: --obj.field value or --obj.flag
+            const processedPath = this.processObjectNotationKey(key)
+            const isBoolean = optionsSchema
+              ? this.isNestedBoolean(optionsSchema, processedPath)
+              : false
+            const isArray = optionsSchema ? this.isNestedArray(optionsSchema, processedPath) : false
+            const nextArg = args[i + 1]
+
+            if (isBoolean) {
+              this.setNestedProperty(options, processedPath, true)
+              i++
+            } else if (isArray && nextArg && !nextArg.startsWith('-')) {
+              const existingValue = this.getNestedProperty(options, processedPath)
+              if (!Array.isArray(existingValue)) {
+                this.setNestedProperty(options, processedPath, [])
+              }
+              this.getNestedProperty(options, processedPath).push(this.parseValue(nextArg))
+              i += 2
+            } else if (nextArg && !nextArg.startsWith('-')) {
+              this.setNestedProperty(options, processedPath, this.parseValue(nextArg))
+              i += 2
+            } else {
+              // Assume boolean flag
+              this.setNestedProperty(options, processedPath, true)
+              i++
             }
-            options[camelCaseKey].push(this.parseValue(nextArg))
-            i += 2
-          } else if (nextArg && !nextArg.startsWith('-')) {
-            // Has a value
-            options[camelCaseKey] = this.parseValue(nextArg)
-            i += 2
           } else {
-            // Assume boolean flag
-            options[camelCaseKey] = true
-            i++
+            // Flat option: --key value or --flag
+            const camelCaseKey = this.camelCase(key)
+            const isBoolean = booleanFields.has(camelCaseKey) || booleanFields.has(key)
+            const isArray = arrayFields.has(camelCaseKey) || arrayFields.has(key)
+            const nextArg = args[i + 1]
+
+            if (isBoolean) {
+              // Known boolean flag from schema
+              options[camelCaseKey] = true
+              i++
+            } else if (isArray && nextArg && !nextArg.startsWith('-')) {
+              // Known array field from schema - accumulate values
+              if (!options[camelCaseKey]) {
+                options[camelCaseKey] = []
+              }
+              options[camelCaseKey].push(this.parseValue(nextArg))
+              i += 2
+            } else if (nextArg && !nextArg.startsWith('-')) {
+              // Has a value
+              options[camelCaseKey] = this.parseValue(nextArg)
+              i += 2
+            } else {
+              // Assume boolean flag
+              options[camelCaseKey] = true
+              i++
+            }
           }
         }
       } else if (arg.startsWith('-') && arg.length > 1 && arg !== '-') {
@@ -321,4 +375,115 @@ export class CliParserService {
       return false
     }
   }
+
+  /**
+   * Sets a nested property on an object using dot notation path.
+   * Creates intermediate objects as needed.
+   *
+   * @example
+   * setNestedProperty({}, 'a.b.c', 'value') // { a: { b: { c: 'value' } } }
+   */
+  private setNestedProperty(obj: Record<string, any>, path: string, value: any): void {
+    const parts = path.split('.')
+    let current = obj
+
+    for (let i = 0; i < parts.length - 1; i++) {
+      const part = parts[i]
+      if (!(part in current) || typeof current[part] !== 'object' || current[part] === null) {
+        current[part] = {}
+      }
+      current = current[part]
+    }
+
+    current[parts[parts.length - 1]] = value
+  }
+
+  /**
+   * Gets a nested property from an object using dot notation path.
+   * Returns undefined if path doesn't exist.
+   */
+  private getNestedProperty(obj: Record<string, any>, path: string): any {
+    const parts = path.split('.')
+    let current = obj
+
+    for (const part of parts) {
+      if (current === undefined || current === null || typeof current !== 'object') {
+        return undefined
+      }
+      current = current[part]
+    }
+
+    return current
+  }
+
+  /**
+   * Checks if an option key contains dot notation (object notation).
+   * Returns true for keys like "obj.field" or "deep.nested.value".
+   */
+  private isObjectNotation(key: string): boolean {
+    return key.includes('.')
+  }
+
+  /**
+   * Processes an option key that may contain object notation.
+   * Converts each segment from kebab-case to camelCase.
+   *
+   * @example
+   * processObjectNotationKey('my-obj.field-name') // 'myObj.fieldName'
+   */
+  private processObjectNotationKey(key: string): string {
+    return key
+      .split('.')
+      .map((segment) => this.camelCase(segment))
+      .join('.')
+  }
+
+  /**
+   * Gets the nested schema for a given dot-notation path.
+   * Returns undefined if the path doesn't lead to a valid schema.
+   */
+  private getNestedSchema(schema: z.ZodObject, path: string): z.ZodType | undefined {
+    try {
+      const parts = path.split('.')
+      let currentSchema: any = schema
+
+      for (const part of parts) {
+        // Unwrap optional/default wrappers
+        while (currentSchema?.def?.type === 'optional' || currentSchema?.def?.type === 'default') {
+          currentSchema = currentSchema.def.innerType
+        }
+
+        if (currentSchema?.def?.type !== 'object') {
+          return undefined
+        }
+
+        const shape = currentSchema.def.shape
+        if (!shape || !(part in shape)) {
+          return undefined
+        }
+
+        currentSchema = shape[part]
+      }
+
+      return currentSchema
+    } catch {
+      return undefined
+    }
+  }
+
+  /**
+   * Checks if a nested path represents a boolean field in the schema.
+   */
+  private isNestedBoolean(schema: z.ZodObject, path: string): boolean {
+    const nestedSchema = this.getNestedSchema(schema, path)
+    return nestedSchema ? this.isSchemaBoolean(nestedSchema) : false
+  }
+
+  /**
+   * Checks if a nested path represents an array field in the schema.
+   */
+  private isNestedArray(schema: z.ZodObject, path: string): boolean {
+    const nestedSchema = this.getNestedSchema(schema, path)
+    return nestedSchema ? this.isSchemaArray(nestedSchema) : false
+  }
 }

package/src/services/command-registry.service.mts

@@ -133,6 +133,9 @@ export class CommandRegistryService {
             const optionFlag = `--${kebabKey}`
             const fieldType = this.getSchemaTypeName(fieldSchema as any)
             lines.push(`  ${optionFlag.padEnd(20)} ${fieldType}`)
+
+            // Check for nested object fields and display them with dot notation
+            this.formatNestedObjectOptions(fieldSchema as any, kebabKey, lines, '    ')
           }
         }
       } catch {
@@ -143,6 +146,54 @@ export class CommandRegistryService {
     return lines.join('\n')
   }
 
+  /**
+   * Recursively formats nested object options for help display.
+   * Shows nested fields with dot notation (e.g., --config.port)
+   */
+  private formatNestedObjectOptions(
+    schema: any,
+    parentPath: string,
+    lines: string[],
+    indent: string,
+  ): void {
+    try {
+      let currentSchema = schema
+      let typeName = currentSchema?.def?.type
+
+      // Unwrap optional/default wrappers
+      while (typeName === 'optional' || typeName === 'default') {
+        currentSchema = currentSchema?.def?.innerType
+        typeName = currentSchema?.def?.type
+      }
+
+      if (typeName !== 'object') {
+        return
+      }
+
+      const shape = currentSchema?.def?.shape
+      if (!shape || typeof shape !== 'object') {
+        return
+      }
+
+      for (const [key, fieldSchema] of Object.entries(shape)) {
+        const kebabKey = key.replace(/([A-Z])/g, '-$1').toLowerCase()
+        const optionFlag = `--${parentPath}.${kebabKey}`
+        const fieldType = this.getSchemaTypeName(fieldSchema as any)
+        lines.push(`${indent}${optionFlag.padEnd(20 - indent.length + 2)} ${fieldType}`)
+
+        // Recurse for deeper nesting
+        this.formatNestedObjectOptions(
+          fieldSchema as any,
+          `${parentPath}.${kebabKey}`,
+          lines,
+          indent + '  ',
+        )
+      }
+    } catch {
+      // Silently fail if schema introspection fails
+    }
+  }
+
   /**
    * Gets a human-readable type name from a zod/v4 schema.
    */

package/src/services/commander-adapter.service.mts

@@ -130,7 +130,7 @@ export class CommanderAdapterService implements AbstractCliAdapterInterface {
         ? this.cliParser.parse(argv, command.metadata.optionsSchema)
         : preliminaryParse
 
-      await this.executeCommand(parsed.command, parsed.options)
+      await this.executeCommand(parsed.command, parsed.options, parsed.positionals)
     } catch (error) {
       if (error instanceof Error) {
         this.logger.error(`Error: ${error.message}`)
@@ -146,7 +146,11 @@ export class CommanderAdapterService implements AbstractCliAdapterInterface {
   /**
    * Execute a command programmatically with the provided options.
    */
-  async executeCommand(path: string, options: Record<string, unknown> = {}): Promise<void> {
+  async executeCommand(
+    path: string,
+    options: Record<string, unknown> = {},
+    positionals: string[] = [],
+  ): Promise<void> {
     const command = this.commandRegistry.getByPath(path)
     if (!command) {
       throw new Error(`[Navios Commander] Command not found: ${path}`)
@@ -161,7 +165,12 @@ export class CommanderAdapterService implements AbstractCliAdapterInterface {
     }
 
     // Create execution context
-    const executionContext = new CommanderExecutionContext(metadata, path, validatedOptions)
+    const executionContext = new CommanderExecutionContext(
+      metadata,
+      path,
+      validatedOptions,
+      positionals,
+    )
 
     // Begin request scope
     const requestId = `cmd-${Date.now()}-${Math.random().toString(36).substring(7)}`
@@ -177,7 +186,7 @@ export class CommanderAdapterService implements AbstractCliAdapterInterface {
         throw new Error(`Command ${path} does not implement execute method`)
       }
 
-      await commandInstance.execute(validatedOptions)
+      await commandInstance.execute(validatedOptions, positionals)
     } finally {
       await scopeContainer.endRequest()
     }

package/lib/cli-module.decorator-BzsOEMPH.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cli-module.decorator-BzsOEMPH.d.cts","names":["CommandHandler","TOptions","Promise","InjectionToken","ClassType","ClassTypeWithInstance","Registry","z","CommandHandler","CommandOptions","ZodObject","Command","path","description","token","optionsSchema","priority","registry","ClassDecoratorContext","ClassType","Registry","CliModuleOptions","Set","CliModule","commands","controllers","imports","guards","overrides","priority","registry","ClassDecoratorContext"],"sources":["../src/interfaces/command-handler.interface.d.mts","../src/decorators/command.decorator.d.mts","../src/decorators/cli-module.decorator.d.mts"],"sourcesContent":["/**\n * Interface that all command classes must implement.\n *\n * Commands decorated with `@Command` must implement this interface.\n * The `execute` method is called when the command is invoked.\n *\n * @template TOptions - The type of options that the command accepts\n *\n * @example\n * ```typescript\n * import { Command, CommandHandler } from '@navios/commander'\n * import { z } from 'zod/v4'\n *\n * const optionsSchema = z.object({\n *   name: z.string()\n * })\n *\n * type Options = z.infer<typeof optionsSchema>\n *\n * @Command({ path: 'greet', optionsSchema })\n * export class GreetCommand implements CommandHandler<Options> {\n *   async execute(options: Options) {\n *     console.log(`Hello, ${options.name}!`)\n *   }\n * }\n * ```\n */\nexport interface CommandHandler<TOptions = any> {\n  /**\n   * Executes the command with the provided options.\n   *\n   * @param options - The validated command options (validated against the command's schema if provided)\n   * @returns A promise or void\n   */\n  execute(options: TOptions): void | Promise<void>\n}\n//# sourceMappingURL=command-handler.interface.d.mts.map\n","import { InjectionToken } from '@navios/core'\n\nimport type { ClassType, ClassTypeWithInstance, Registry } from '@navios/core'\nimport type { z } from 'zod/v4'\n\nimport type { CommandHandler } from '../interfaces/index.mjs'\n/**\n * Options for the `@Command` decorator.\n *\n * @public\n */\nexport interface CommandOptions {\n  /**\n   * The token to use for the command.\n   * If provided, the command will be registered with this token.\n   */\n  token?: InjectionToken<ClassTypeWithInstance<CommandHandler<any>>>\n  /**\n   * The command path that users will invoke from the CLI.\n   * Can be a single word (e.g., 'greet') or multi-word with colons (e.g., 'user:create', 'db:migrate').\n   */\n  path: string\n  /**\n   * Optional description of the command for help text.\n   * Displayed when users run `help` or `--help`.\n   */\n  description?: string\n  /**\n   * Optional zod/v4 schema for validating command options.\n   * If provided, options will be validated and parsed according to this schema.\n   */\n  optionsSchema?: z.ZodObject\n  /**\n   * Priority level for the command.\n   * Higher priority commands will be loaded first.\n   */\n  priority?: number\n  /**\n   * Registry to use for the command.\n   * Registry is used to store the command and its options schema.\n   */\n  registry?: Registry\n}\n/**\n * Decorator that marks a class as a CLI command.\n *\n * The decorated class must implement the `CommandHandler` interface with an `execute` method.\n * The command will be automatically registered when its module is loaded.\n *\n * @param options - Configuration options for the command\n * @returns A class decorator function\n *\n * @example\n * ```typescript\n * import { Command, CommandHandler } from '@navios/commander'\n * import { z } from 'zod/v4'\n *\n * const optionsSchema = z.object({\n *   name: z.string(),\n *   greeting: z.string().optional().default('Hello')\n * })\n *\n * @Command({\n *   path: 'greet',\n *   optionsSchema: optionsSchema\n * })\n * export class GreetCommand implements CommandHandler<z.infer<typeof optionsSchema>> {\n *   async execute(options) {\n *     console.log(`${options.greeting}, ${options.name}!`)\n *   }\n * }\n * ```\n */\nexport declare function Command({\n  path,\n  description,\n  token,\n  optionsSchema,\n  priority,\n  registry,\n}: CommandOptions): (\n  target: ClassType,\n  context: ClassDecoratorContext<abstract new (...args: any) => any>,\n) => any\n//# sourceMappingURL=command.decorator.d.mts.map\n","import type { ClassType, Registry } from '@navios/core'\n/**\n * Options for the `@CliModule` decorator.\n *\n * @public\n */\nexport interface CliModuleOptions {\n  /**\n   * Array or Set of command classes to register in this module.\n   * Commands must be decorated with `@Command`.\n   */\n  commands?: ClassType[] | Set<ClassType>\n  /**\n   * Array or Set of controller classes for HTTP endpoints.\n   * Allows mixing HTTP and CLI functionality in the same module.\n   */\n  controllers?: ClassType[] | Set<ClassType>\n  /**\n   * Array or Set of other modules to import.\n   * Imported modules' commands and controllers will be available.\n   */\n  imports?: ClassType[] | Set<ClassType>\n  /**\n   * Guards to apply to all controllers in this module.\n   * Guards are executed in reverse order (last guard first).\n   */\n  guards?: ClassType[] | Set<ClassType>\n  /**\n   * Service override classes to import for side effects.\n   * These classes are imported to ensure their @Injectable decorators execute,\n   * allowing them to register with the DI system. Overrides should use the same\n   * InjectionToken as the original service with a higher priority.\n   */\n  overrides?: ClassType[] | Set<ClassType>\n  /**\n   * Priority level for the module.\n   * Higher priority modules will be loaded first.\n   */\n  priority?: number\n  /**\n   * Registry to use for the module.\n   * Registry is used to store the module and its commands.\n   */\n  registry?: Registry\n}\n/**\n * Decorator that marks a class as a CLI module.\n *\n * This decorator extends the standard @Module decorator, adding support for\n * CLI commands while maintaining full compatibility with HTTP controllers.\n * Modules organize commands and can import other modules to compose larger\n * CLI applications.\n *\n * The module can optionally implement `NaviosModule` interface for lifecycle hooks.\n *\n * @param options - Configuration options for the module\n * @returns A class decorator function\n *\n * @example\n * ```typescript\n * import { CliModule } from '@navios/commander'\n * import { GreetCommand } from './greet.command'\n * import { UserModule } from './user.module'\n *\n * @CliModule({\n *   commands: [GreetCommand],\n *   imports: [UserModule]\n * })\n * export class AppModule {}\n * ```\n *\n * @example\n * ```typescript\n * // Mixed HTTP and CLI module\n * @CliModule({\n *   controllers: [HealthController],\n *   commands: [MigrateCommand],\n *   imports: [DatabaseModule],\n * })\n * export class AppModule {}\n * ```\n */\nexport declare function CliModule({\n  commands,\n  controllers,\n  imports,\n  guards,\n  overrides,\n  priority,\n  registry,\n}?: CliModuleOptions): (\n  target: ClassType,\n  context: ClassDecoratorContext<abstract new (...args: any) => any>,\n) => ClassType\n//# sourceMappingURL=cli-module.decorator.d.mts.map\n"],"mappings":";;;;;;;;;AA2BA;;;;AChBA;;;;;;;AA8DA;;;;;;;;;;;;UD9CiBA;;AErBjB;;;;;EAUkCmB,OAAAA,CAAAA,OAAAA,EFkBflB,QElBekB,CAAAA,EAAAA,IAAAA,GFkBGjB,OElBHiB,CAAAA,IAAAA,CAAAA;;;;;;ADLlC;;;AAKUhB,UALOM,cAAAA,CAKPN;EAeQI;;;AA0ClB;EACEK,KAAAA,CAAAA,EA1DQT,cA0DRS,CA1DuBP,qBA0DvBO,CA1D6CJ,cA0D7CI,CAAAA,GAAAA,CAAAA,CAAAA,CAAAA;EACAC;;;;EAIAI,IAAAA,EAAAA,MAAAA;EACCR;;;;;;;AC1EH;;EAK+BU,aAAAA,CAAAA,EDoBbZ,CAAAA,CAAEG,SCpBWS;EAAJG;;;;EAUfH,QAAAA,CAAAA,EAAAA,MAAAA;EAAkBA;;;;EAKLG,QAAAA,CAAAA,EDeZhB,QCfYgB;;;;;;AAwDzB;;;;;;;;;;;;;;;;;;;;;;;;;;iBDTwBX,OAAAA;;;;;;;GAOrBF,0BACOL,oBACCc;;;;;;ADvDX;;UErBiBG,gBAAAA;;ADKjB;;;EAKUlB,QAAAA,CAAAA,ECLGgB,SDKHhB,EAAAA,GCLiBmB,GDKjBnB,CCLqBgB,SDKrBhB,CAAAA;EAeQI;;;AA0ClB;EACEK,WAAAA,CAAAA,EC1DcO,SD0DdP,EAAAA,GC1D4BU,GD0D5BV,CC1DgCO,SD0DhCP,CAAAA;EACAC;;;;EAIAI,OAAAA,CAAAA,EC1DUE,SD0DVF,EAAAA,GC1DwBK,GD0DxBL,CC1D4BE,SD0D5BF,CAAAA;EACCR;;;;WCtDQU,cAAcG,IAAIH;;;AApB7B;;;;EAUgBA,SAAAA,CAAAA,EAiBFA,SAjBEA,EAAAA,GAiBYG,GAjBZH,CAiBgBA,SAjBhBA,CAAAA;EAAkBA;;;;EAKRG,QAAAA,CAAAA,EAAAA,MAAAA;EAKfH;;;;EAOqBA,QAAAA,CAAAA,EAUnBC,QAVmBD;;;;AAiDhC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAwBI,SAAAA;;;;;;;;IAQpBF,4BACMF,oBACCY,8DACNZ"}

package/lib/cli-module.decorator-CCV_elPP.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cli-module.decorator-CCV_elPP.d.mts","names":["CommandHandler","TOptions","Promise","AbstractAdapterInterface","AbstractCliAdapterInterface","Promise","Record","Array","AdapterEnvironment","AbstractCliAdapterInterface","CliAdapterOptions","CliEnvironment","ClassType","z","CommandMetadataKey","CommandMetadata","ZodObject","Map","getCommandMetadata","ClassDecoratorContext","extractCommandMetadata","hasCommandMetadata","CommandMetadata","CommanderExecutionContext","InjectionToken","ClassType","ClassTypeWithInstance","Registry","z","CommandHandler","CommandOptions","ZodObject","Command","path","description","token","optionsSchema","priority","registry","ClassDecoratorContext","ClassType","Registry","CliModuleOptions","Set","CliModule","commands","controllers","imports","guards","overrides","priority","registry","ClassDecoratorContext"],"sources":["../src/interfaces/command-handler.interface.d.mts","../src/interfaces/abstract-cli-adapter.interface.d.mts","../src/interfaces/environment.interface.d.mts","../src/metadata/command.metadata.d.mts","../src/interfaces/commander-execution-context.interface.d.mts","../src/decorators/command.decorator.d.mts","../src/decorators/cli-module.decorator.d.mts"],"sourcesContent":["/**\n * Interface that all command classes must implement.\n *\n * Commands decorated with `@Command` must implement this interface.\n * The `execute` method is called when the command is invoked.\n *\n * @template TOptions - The type of options that the command accepts\n *\n * @example\n * ```typescript\n * import { Command, CommandHandler } from '@navios/commander'\n * import { z } from 'zod/v4'\n *\n * const optionsSchema = z.object({\n *   name: z.string()\n * })\n *\n * type Options = z.infer<typeof optionsSchema>\n *\n * @Command({ path: 'greet', optionsSchema })\n * export class GreetCommand implements CommandHandler<Options> {\n *   async execute(options: Options) {\n *     console.log(`Hello, ${options.name}!`)\n *   }\n * }\n * ```\n */\nexport interface CommandHandler<TOptions = any> {\n  /**\n   * Executes the command with the provided options.\n   *\n   * @param options - The validated command options (validated against the command's schema if provided)\n   * @returns A promise or void\n   */\n  execute(options: TOptions): void | Promise<void>\n}\n//# sourceMappingURL=command-handler.interface.d.mts.map\n","import type { AbstractAdapterInterface } from '@navios/core'\n/**\n * Interface for CLI adapters.\n * Extends the base adapter interface with CLI-specific methods.\n *\n * @public\n */\nexport interface AbstractCliAdapterInterface extends AbstractAdapterInterface {\n  /**\n   * Run the CLI application with the given arguments.\n   * Parses arguments and executes the matching command.\n   *\n   * @param argv - Command-line arguments array (defaults to `process.argv`)\n   *\n   * @example\n   * ```typescript\n   * const adapter = app.getAdapter() as AbstractCliAdapterInterface\n   * await adapter.run(process.argv)\n   * ```\n   */\n  run(argv?: string[]): Promise<void>\n  /**\n   * Execute a command programmatically with the provided options.\n   *\n   * @param path - The command path (e.g., 'greet', 'user:create')\n   * @param options - The command options object\n   *\n   * @example\n   * ```typescript\n   * await adapter.executeCommand('user:create', {\n   *   name: 'John',\n   *   email: 'john@example.com',\n   * })\n   * ```\n   */\n  executeCommand(path: string, options: Record<string, unknown>): Promise<void>\n  /**\n   * Get all registered command paths and their class references.\n   *\n   * @returns Array of objects containing path and class\n   *\n   * @example\n   * ```typescript\n   * const commands = adapter.getAllCommands()\n   * commands.forEach(({ path }) => console.log(path))\n   * ```\n   */\n  getAllCommands(): Array<{\n    path: string\n    class: unknown\n  }>\n}\n//# sourceMappingURL=abstract-cli-adapter.interface.d.mts.map\n","import type { AdapterEnvironment } from '@navios/core'\n\nimport type { AbstractCliAdapterInterface } from './abstract-cli-adapter.interface.mjs'\n/**\n * Options for configuring the CLI adapter.\n *\n * @public\n */\nexport interface CliAdapterOptions {}\n/**\n * Environment type definition for CLI adapters.\n * Used with NaviosFactory.create<CliEnvironment>() for type-safe CLI applications.\n *\n * @public\n *\n * @example\n * ```typescript\n * import { NaviosFactory } from '@navios/core'\n * import { defineCliEnvironment, type CliEnvironment } from '@navios/commander'\n *\n * const app = await NaviosFactory.create<CliEnvironment>(AppModule, {\n *   adapter: defineCliEnvironment(),\n * })\n * ```\n */\nexport interface CliEnvironment extends AdapterEnvironment {\n  options: CliAdapterOptions\n  adapter: AbstractCliAdapterInterface\n}\n//# sourceMappingURL=environment.interface.d.mts.map\n","import type { ClassType } from '@navios/core'\nimport type { z } from 'zod/v4'\n/**\n * @internal\n * Symbol key used to store command metadata on classes.\n */\nexport declare const CommandMetadataKey: unique symbol\n/**\n * Metadata associated with a command.\n *\n * @public\n */\nexport interface CommandMetadata {\n  /**\n   * The command path (e.g., 'greet', 'user:create').\n   */\n  path: string\n  /**\n   * Optional description of the command for help text.\n   */\n  description?: string\n  /**\n   * Optional zod/v4 schema for validating command options.\n   */\n  optionsSchema?: z.ZodObject\n  /**\n   * Map of custom attributes that can be attached to the command.\n   */\n  customAttributes: Map<string | symbol, any>\n}\n/**\n * Gets or creates command metadata for a class.\n *\n * @internal\n * @param target - The command class\n * @param context - The decorator context\n * @param path - The command path\n * @param description - Optional description for help text\n * @param optionsSchema - Optional zod/v4 schema\n * @returns The command metadata\n */\nexport declare function getCommandMetadata(\n  target: ClassType,\n  context: ClassDecoratorContext,\n  path: string,\n  description?: string,\n  optionsSchema?: z.ZodObject,\n): CommandMetadata\n/**\n * Extracts command metadata from a class.\n *\n * @param target - The command class\n * @returns The command metadata\n * @throws {Error} If the class is not decorated with @Command\n *\n * @example\n * ```typescript\n * const metadata = extractCommandMetadata(GreetCommand)\n * console.log(metadata.path) // 'greet'\n * ```\n */\nexport declare function extractCommandMetadata(target: ClassType): CommandMetadata\n/**\n * Checks if a class has command metadata.\n *\n * @param target - The class to check\n * @returns `true` if the class is decorated with @Command, `false` otherwise\n */\nexport declare function hasCommandMetadata(target: ClassType): boolean\n//# sourceMappingURL=command.metadata.d.mts.map\n","import type { CommandMetadata } from '../metadata/command.metadata.mjs'\n/**\n * Execution context for a command execution.\n *\n * Provides access to command metadata, path, and validated options during command execution.\n * This context is automatically injected and available via the `CommandExecutionContext` token.\n *\n * @example\n * ```typescript\n * import { inject, Injectable } from '@navios/core'\n * import { CommandExecutionContext } from '@navios/commander'\n *\n * @Injectable()\n * class CommandLogger {\n *   private ctx = inject(CommandExecutionContext)\n *\n *   log() {\n *     console.log('Command:', this.ctx.getCommandPath())\n *     console.log('Options:', this.ctx.getOptions())\n *   }\n * }\n * ```\n */\nexport declare class CommanderExecutionContext {\n  private readonly command\n  private readonly commandPath\n  private readonly options\n  /**\n   * @internal\n   * Creates a new execution context.\n   */\n  constructor(command: CommandMetadata, commandPath: string, options: any)\n  /**\n   * Gets the command metadata.\n   *\n   * @returns The command metadata including path and options schema\n   */\n  getCommand(): CommandMetadata\n  /**\n   * Gets the command path that was invoked.\n   *\n   * @returns The command path (e.g., 'greet', 'user:create')\n   */\n  getCommandPath(): string\n  /**\n   * Gets the validated command options.\n   *\n   * Options are validated against the command's zod/v4 schema if one was provided.\n   *\n   * @returns The validated options object\n   */\n  getOptions(): any\n}\n//# sourceMappingURL=commander-execution-context.interface.d.mts.map\n","import { InjectionToken } from '@navios/core'\n\nimport type { ClassType, ClassTypeWithInstance, Registry } from '@navios/core'\nimport type { z } from 'zod/v4'\n\nimport type { CommandHandler } from '../interfaces/index.mjs'\n/**\n * Options for the `@Command` decorator.\n *\n * @public\n */\nexport interface CommandOptions {\n  /**\n   * The token to use for the command.\n   * If provided, the command will be registered with this token.\n   */\n  token?: InjectionToken<ClassTypeWithInstance<CommandHandler<any>>>\n  /**\n   * The command path that users will invoke from the CLI.\n   * Can be a single word (e.g., 'greet') or multi-word with colons (e.g., 'user:create', 'db:migrate').\n   */\n  path: string\n  /**\n   * Optional description of the command for help text.\n   * Displayed when users run `help` or `--help`.\n   */\n  description?: string\n  /**\n   * Optional zod/v4 schema for validating command options.\n   * If provided, options will be validated and parsed according to this schema.\n   */\n  optionsSchema?: z.ZodObject\n  /**\n   * Priority level for the command.\n   * Higher priority commands will be loaded first.\n   */\n  priority?: number\n  /**\n   * Registry to use for the command.\n   * Registry is used to store the command and its options schema.\n   */\n  registry?: Registry\n}\n/**\n * Decorator that marks a class as a CLI command.\n *\n * The decorated class must implement the `CommandHandler` interface with an `execute` method.\n * The command will be automatically registered when its module is loaded.\n *\n * @param options - Configuration options for the command\n * @returns A class decorator function\n *\n * @example\n * ```typescript\n * import { Command, CommandHandler } from '@navios/commander'\n * import { z } from 'zod/v4'\n *\n * const optionsSchema = z.object({\n *   name: z.string(),\n *   greeting: z.string().optional().default('Hello')\n * })\n *\n * @Command({\n *   path: 'greet',\n *   optionsSchema: optionsSchema\n * })\n * export class GreetCommand implements CommandHandler<z.infer<typeof optionsSchema>> {\n *   async execute(options) {\n *     console.log(`${options.greeting}, ${options.name}!`)\n *   }\n * }\n * ```\n */\nexport declare function Command({\n  path,\n  description,\n  token,\n  optionsSchema,\n  priority,\n  registry,\n}: CommandOptions): (\n  target: ClassType,\n  context: ClassDecoratorContext<abstract new (...args: any) => any>,\n) => any\n//# sourceMappingURL=command.decorator.d.mts.map\n","import type { ClassType, Registry } from '@navios/core'\n/**\n * Options for the `@CliModule` decorator.\n *\n * @public\n */\nexport interface CliModuleOptions {\n  /**\n   * Array or Set of command classes to register in this module.\n   * Commands must be decorated with `@Command`.\n   */\n  commands?: ClassType[] | Set<ClassType>\n  /**\n   * Array or Set of controller classes for HTTP endpoints.\n   * Allows mixing HTTP and CLI functionality in the same module.\n   */\n  controllers?: ClassType[] | Set<ClassType>\n  /**\n   * Array or Set of other modules to import.\n   * Imported modules' commands and controllers will be available.\n   */\n  imports?: ClassType[] | Set<ClassType>\n  /**\n   * Guards to apply to all controllers in this module.\n   * Guards are executed in reverse order (last guard first).\n   */\n  guards?: ClassType[] | Set<ClassType>\n  /**\n   * Service override classes to import for side effects.\n   * These classes are imported to ensure their @Injectable decorators execute,\n   * allowing them to register with the DI system. Overrides should use the same\n   * InjectionToken as the original service with a higher priority.\n   */\n  overrides?: ClassType[] | Set<ClassType>\n  /**\n   * Priority level for the module.\n   * Higher priority modules will be loaded first.\n   */\n  priority?: number\n  /**\n   * Registry to use for the module.\n   * Registry is used to store the module and its commands.\n   */\n  registry?: Registry\n}\n/**\n * Decorator that marks a class as a CLI module.\n *\n * This decorator extends the standard @Module decorator, adding support for\n * CLI commands while maintaining full compatibility with HTTP controllers.\n * Modules organize commands and can import other modules to compose larger\n * CLI applications.\n *\n * The module can optionally implement `NaviosModule` interface for lifecycle hooks.\n *\n * @param options - Configuration options for the module\n * @returns A class decorator function\n *\n * @example\n * ```typescript\n * import { CliModule } from '@navios/commander'\n * import { GreetCommand } from './greet.command'\n * import { UserModule } from './user.module'\n *\n * @CliModule({\n *   commands: [GreetCommand],\n *   imports: [UserModule]\n * })\n * export class AppModule {}\n * ```\n *\n * @example\n * ```typescript\n * // Mixed HTTP and CLI module\n * @CliModule({\n *   controllers: [HealthController],\n *   commands: [MigrateCommand],\n *   imports: [DatabaseModule],\n * })\n * export class AppModule {}\n * ```\n */\nexport declare function CliModule({\n  commands,\n  controllers,\n  imports,\n  guards,\n  overrides,\n  priority,\n  registry,\n}?: CliModuleOptions): (\n  target: ClassType,\n  context: ClassDecoratorContext<abstract new (...args: any) => any>,\n) => ClassType\n//# sourceMappingURL=cli-module.decorator.d.mts.map\n"],"mappings":"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"}

package/lib/help-command.token-DamE31Aw.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"help-command.token-DamE31Aw.cjs","names":["Injectable","CommandRegistryService","commands","Map","register","path","command","has","Error","set","getByPath","get","getAll","getAllAsArray","result","class","cls","push","formatCommandList","lines","metadata","description","padEnd","join","formatCommandHelp","commandPath","optionsSchema","shape","def","key","fieldSchema","Object","entries","kebabKey","replace","toLowerCase","optionFlag","fieldType","getSchemaTypeName","schema","currentSchema","typeName","type","isOptional","defaultValue","innerType","undefined","JSON","stringify","getSchemaMeta","directMeta","meta","clear","InjectionToken","HelpCommandToken","create"],"sources":["../src/services/command-registry.service.mts","../src/tokens/help-command.token.mts"],"sourcesContent":["import { Injectable } from '@navios/core'\n\nimport type { ClassType } from '@navios/core'\n\nimport type { CommandMetadata } from '../metadata/index.mjs'\n\n/**\n * Represents a registered command with its metadata and module information.\n *\n * @public\n */\nexport interface RegisteredCommand {\n  /**\n   * The command class\n   */\n  class: ClassType\n  /**\n   * The command metadata from @Command decorator\n   */\n  metadata: CommandMetadata\n  /**\n   * Name of the module this command belongs to\n   */\n  moduleName: string\n}\n\n/**\n * Service for registering and looking up CLI commands.\n * Used internally by the CLI adapter to manage discovered commands.\n *\n * @public\n */\n@Injectable()\nexport class CommandRegistryService {\n  private commands = new Map<string, RegisteredCommand>()\n\n  /**\n   * Register a command with its metadata.\n   *\n   * @param path - The command path (e.g., 'greet', 'user:create')\n   * @param command - The registered command data\n   * @throws Error if a command with the same path is already registered\n   */\n  register(path: string, command: RegisteredCommand): void {\n    if (this.commands.has(path)) {\n      throw new Error(`[Navios Commander] Duplicate command path: ${path}`)\n    }\n    this.commands.set(path, command)\n  }\n\n  /**\n   * Get a command by its path.\n   *\n   * @param path - The command path\n   * @returns The registered command or undefined if not found\n   */\n  getByPath(path: string): RegisteredCommand | undefined {\n    return this.commands.get(path)\n  }\n\n  /**\n   * Get all registered commands.\n   *\n   * @returns Map of path to registered command\n   */\n  getAll(): Map<string, RegisteredCommand> {\n    return new Map(this.commands)\n  }\n\n  /**\n   * Get all registered commands as an array of path and class pairs.\n   * Useful for listing available commands.\n   *\n   * @returns Array of objects containing path and class\n   */\n  getAllAsArray(): Array<{ path: string; class: ClassType }> {\n    const result: Array<{ path: string; class: ClassType }> = []\n    for (const [path, { class: cls }] of this.commands) {\n      result.push({ path, class: cls })\n    }\n    return result\n  }\n\n  /**\n   * Formats help text listing all available commands with descriptions.\n   *\n   * @returns Formatted string listing all commands\n   */\n  formatCommandList(): string {\n    const lines = ['Available commands:', '']\n    for (const [path, { metadata }] of this.commands) {\n      const description = metadata.description\n      if (description) {\n        lines.push(`  ${path.padEnd(20)} ${description}`)\n      } else {\n        lines.push(`  ${path}`)\n      }\n    }\n    return lines.join('\\n')\n  }\n\n  /**\n   * Formats help text for a specific command.\n   *\n   * @param commandPath - The command path to show help for\n   * @returns Formatted string with command help\n   */\n  formatCommandHelp(commandPath: string): string {\n    const command = this.commands.get(commandPath)\n    if (!command) {\n      return `Unknown command: ${commandPath}\\n\\n${this.formatCommandList()}`\n    }\n\n    const { metadata } = command\n    const lines: string[] = []\n\n    lines.push(`Usage: ${metadata.path} [options]`)\n    lines.push('')\n\n    if (metadata.description) {\n      lines.push(metadata.description)\n      lines.push('')\n    }\n\n    // Extract options from schema if available\n    if (metadata.optionsSchema) {\n      lines.push('Options:')\n      try {\n        const shape = metadata.optionsSchema.def.shape\n        if (shape && typeof shape === 'object') {\n          for (const [key, fieldSchema] of Object.entries(shape)) {\n            const kebabKey = key.replace(/([A-Z])/g, '-$1').toLowerCase()\n            const optionFlag = `--${kebabKey}`\n            const fieldType = this.getSchemaTypeName(fieldSchema as any)\n            lines.push(`  ${optionFlag.padEnd(20)} ${fieldType}`)\n          }\n        }\n      } catch {\n        // Schema introspection failed, skip options\n      }\n    }\n\n    return lines.join('\\n')\n  }\n\n  /**\n   * Gets a human-readable type name from a zod/v4 schema.\n   */\n  private getSchemaTypeName(schema: any): string {\n    try {\n      let currentSchema = schema\n      let typeName = currentSchema?.def?.type\n      let isOptional = false\n      let defaultValue: any\n\n      // Unwrap optional/default wrappers\n      while (typeName === 'optional' || typeName === 'default') {\n        if (typeName === 'optional') {\n          isOptional = true\n        }\n        if (typeName === 'default') {\n          isOptional = true\n          defaultValue = currentSchema?.def?.defaultValue?.()\n        }\n        currentSchema = currentSchema?.def?.innerType\n        typeName = currentSchema?.def?.type\n      }\n\n      let result = `<${typeName || 'unknown'}>`\n      if (defaultValue !== undefined) {\n        result += ` (default: ${JSON.stringify(defaultValue)})`\n      } else if (isOptional) {\n        result += ' (optional)'\n      }\n\n      // Get description from meta() if available\n      const description = this.getSchemaMeta(schema)?.description\n      if (description) {\n        result += ` - ${description}`\n      }\n\n      return result\n    } catch {\n      return '<unknown>'\n    }\n  }\n\n  /**\n   * Gets metadata from a zod/v4 schema, traversing innerType if needed.\n   * zod/v4 v4 stores meta at the outermost layer when .meta() is called last,\n   * or in innerType when .meta() is called before .optional()/.default().\n   */\n  private getSchemaMeta(schema: any): Record<string, unknown> | undefined {\n    try {\n      // First check direct meta (when .meta() is called last in chain)\n      const directMeta = schema.meta?.()\n      if (directMeta) return directMeta\n\n      // Check innerType for wrapped schemas (optional, default, etc.)\n      const innerType = schema.def?.innerType\n      if (innerType) {\n        return this.getSchemaMeta(innerType)\n      }\n\n      return undefined\n    } catch {\n      return undefined\n    }\n  }\n\n  /**\n   * Clear all registered commands.\n   */\n  clear(): void {\n    this.commands.clear()\n  }\n}\n","import { InjectionToken } from '@navios/core'\n\nimport type { HelpCommand } from '../overrides/help.command.mjs'\n\nexport const HelpCommandToken = InjectionToken.create<HelpCommand>('HelpCommand')\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCAgCCA;AACM,IAAMC,yBAAN,MAAMA;;;;CACHC,2BAAW,IAAIC,KAAAA;;;;;;;IASvBC,SAASC,MAAcC,SAAkC;AACvD,MAAI,KAAKJ,SAASK,IAAIF,KAAAA,CACpB,OAAM,IAAIG,MAAM,8CAA8CH,OAAM;AAEtE,OAAKH,SAASO,IAAIJ,MAAMC,QAAAA;;;;;;;IAS1BI,UAAUL,MAA6C;AACrD,SAAO,KAAKH,SAASS,IAAIN,KAAAA;;;;;;IAQ3BO,SAAyC;AACvC,SAAO,IAAIT,IAAI,KAAKD,SAAQ;;;;;;;IAS9BW,gBAA2D;EACzD,MAAMC,SAAoD,EAAE;AAC5D,OAAK,MAAM,CAACT,MAAM,EAAEU,OAAOC,UAAU,KAAKd,SACxCY,QAAOG,KAAK;GAAEZ;GAAMU,OAAOC;GAAI,CAAA;AAEjC,SAAOF;;;;;;IAQTI,oBAA4B;EAC1B,MAAMC,QAAQ,CAAC,uBAAuB,GAAG;AACzC,OAAK,MAAM,CAACd,MAAM,EAAEe,eAAe,KAAKlB,UAAU;GAChD,MAAMmB,cAAcD,SAASC;AAC7B,OAAIA,YACFF,OAAMF,KAAK,KAAKZ,KAAKiB,OAAO,GAAA,CAAI,GAAGD,cAAa;OAEhDF,OAAMF,KAAK,KAAKZ,OAAM;;AAG1B,SAAOc,MAAMI,KAAK,KAAA;;;;;;;IASpBC,kBAAkBC,aAA6B;EAC7C,MAAMnB,UAAU,KAAKJ,SAASS,IAAIc,YAAAA;AAClC,MAAI,CAACnB,QACH,QAAO,oBAAoBmB,YAAY,MAAM,KAAKP,mBAAiB;EAGrE,MAAM,EAAEE,aAAad;EACrB,MAAMa,QAAkB,EAAE;AAE1BA,QAAMF,KAAK,UAAUG,SAASf,KAAK,YAAW;AAC9Cc,QAAMF,KAAK,GAAA;AAEX,MAAIG,SAASC,aAAa;AACxBF,SAAMF,KAAKG,SAASC,YAAW;AAC/BF,SAAMF,KAAK,GAAA;;AAIb,MAAIG,SAASM,eAAe;AAC1BP,SAAMF,KAAK,WAAA;AACX,OAAI;IACF,MAAMU,QAAQP,SAASM,cAAcE,IAAID;AACzC,QAAIA,SAAS,OAAOA,UAAU,SAC5B,MAAK,MAAM,CAACE,KAAKC,gBAAgBC,OAAOC,QAAQL,MAAAA,EAAQ;KAEtD,MAAMS,aAAa,KADFP,IAAIK,QAAQ,YAAY,MAAA,CAAOC,aAAW;KAE3D,MAAME,YAAY,KAAKC,kBAAkBR,YAAAA;AACzCX,WAAMF,KAAK,KAAKmB,WAAWd,OAAO,GAAA,CAAI,GAAGe,YAAW;;WAGlD;;AAKV,SAAOlB,MAAMI,KAAK,KAAA;;;;IAMpB,kBAA0BgB,QAAqB;AAC7C,MAAI;GACF,IAAIC,gBAAgBD;GACpB,IAAIE,WAAWD,eAAeZ,KAAKc;GACnC,IAAIC,aAAa;GACjB,IAAIC;AAGJ,UAAOH,aAAa,cAAcA,aAAa,WAAW;AACxD,QAAIA,aAAa,WACfE,cAAa;AAEf,QAAIF,aAAa,WAAW;AAC1BE,kBAAa;AACbC,oBAAeJ,eAAeZ,KAAKgB,gBAAAA;;AAErCJ,oBAAgBA,eAAeZ,KAAKiB;AACpCJ,eAAWD,eAAeZ,KAAKc;;GAGjC,IAAI5B,SAAS,IAAI2B,YAAY,UAAU;AACvC,OAAIG,iBAAiBE,OACnBhC,WAAU,cAAciC,KAAKC,UAAUJ,aAAAA,CAAc;YAC5CD,WACT7B,WAAU;GAIZ,MAAMO,cAAc,KAAK4B,cAAcV,OAAAA,EAASlB;AAChD,OAAIA,YACFP,WAAU,MAAMO;AAGlB,UAAOP;UACD;AACN,UAAO;;;;;;;IASX,cAAsByB,QAAkD;AACtE,MAAI;GAEF,MAAMW,aAAaX,OAAOY,QAAI;AAC9B,OAAID,WAAY,QAAOA;GAGvB,MAAML,YAAYN,OAAOX,KAAKiB;AAC9B,OAAIA,UACF,QAAO,KAAKI,cAAcJ,UAAAA;AAG5B;UACM;AACN;;;;;IAOJO,QAAc;AACZ,OAAKlD,SAASkD,OAAK;;;;;;;;;AClNvB,MAAaE,mBAAmBD,4BAAeE,OAAoB,cAAA"}

package/lib/help-command.token-XHx3WkoD.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"help-command.token-XHx3WkoD.mjs","names":["Injectable","CommandRegistryService","commands","Map","register","path","command","has","Error","set","getByPath","get","getAll","getAllAsArray","result","class","cls","push","formatCommandList","lines","metadata","description","padEnd","join","formatCommandHelp","commandPath","optionsSchema","shape","def","key","fieldSchema","Object","entries","kebabKey","replace","toLowerCase","optionFlag","fieldType","getSchemaTypeName","schema","currentSchema","typeName","type","isOptional","defaultValue","innerType","undefined","JSON","stringify","getSchemaMeta","directMeta","meta","clear","InjectionToken","HelpCommandToken","create"],"sources":["../src/services/command-registry.service.mts","../src/tokens/help-command.token.mts"],"sourcesContent":["import { Injectable } from '@navios/core'\n\nimport type { ClassType } from '@navios/core'\n\nimport type { CommandMetadata } from '../metadata/index.mjs'\n\n/**\n * Represents a registered command with its metadata and module information.\n *\n * @public\n */\nexport interface RegisteredCommand {\n  /**\n   * The command class\n   */\n  class: ClassType\n  /**\n   * The command metadata from @Command decorator\n   */\n  metadata: CommandMetadata\n  /**\n   * Name of the module this command belongs to\n   */\n  moduleName: string\n}\n\n/**\n * Service for registering and looking up CLI commands.\n * Used internally by the CLI adapter to manage discovered commands.\n *\n * @public\n */\n@Injectable()\nexport class CommandRegistryService {\n  private commands = new Map<string, RegisteredCommand>()\n\n  /**\n   * Register a command with its metadata.\n   *\n   * @param path - The command path (e.g., 'greet', 'user:create')\n   * @param command - The registered command data\n   * @throws Error if a command with the same path is already registered\n   */\n  register(path: string, command: RegisteredCommand): void {\n    if (this.commands.has(path)) {\n      throw new Error(`[Navios Commander] Duplicate command path: ${path}`)\n    }\n    this.commands.set(path, command)\n  }\n\n  /**\n   * Get a command by its path.\n   *\n   * @param path - The command path\n   * @returns The registered command or undefined if not found\n   */\n  getByPath(path: string): RegisteredCommand | undefined {\n    return this.commands.get(path)\n  }\n\n  /**\n   * Get all registered commands.\n   *\n   * @returns Map of path to registered command\n   */\n  getAll(): Map<string, RegisteredCommand> {\n    return new Map(this.commands)\n  }\n\n  /**\n   * Get all registered commands as an array of path and class pairs.\n   * Useful for listing available commands.\n   *\n   * @returns Array of objects containing path and class\n   */\n  getAllAsArray(): Array<{ path: string; class: ClassType }> {\n    const result: Array<{ path: string; class: ClassType }> = []\n    for (const [path, { class: cls }] of this.commands) {\n      result.push({ path, class: cls })\n    }\n    return result\n  }\n\n  /**\n   * Formats help text listing all available commands with descriptions.\n   *\n   * @returns Formatted string listing all commands\n   */\n  formatCommandList(): string {\n    const lines = ['Available commands:', '']\n    for (const [path, { metadata }] of this.commands) {\n      const description = metadata.description\n      if (description) {\n        lines.push(`  ${path.padEnd(20)} ${description}`)\n      } else {\n        lines.push(`  ${path}`)\n      }\n    }\n    return lines.join('\\n')\n  }\n\n  /**\n   * Formats help text for a specific command.\n   *\n   * @param commandPath - The command path to show help for\n   * @returns Formatted string with command help\n   */\n  formatCommandHelp(commandPath: string): string {\n    const command = this.commands.get(commandPath)\n    if (!command) {\n      return `Unknown command: ${commandPath}\\n\\n${this.formatCommandList()}`\n    }\n\n    const { metadata } = command\n    const lines: string[] = []\n\n    lines.push(`Usage: ${metadata.path} [options]`)\n    lines.push('')\n\n    if (metadata.description) {\n      lines.push(metadata.description)\n      lines.push('')\n    }\n\n    // Extract options from schema if available\n    if (metadata.optionsSchema) {\n      lines.push('Options:')\n      try {\n        const shape = metadata.optionsSchema.def.shape\n        if (shape && typeof shape === 'object') {\n          for (const [key, fieldSchema] of Object.entries(shape)) {\n            const kebabKey = key.replace(/([A-Z])/g, '-$1').toLowerCase()\n            const optionFlag = `--${kebabKey}`\n            const fieldType = this.getSchemaTypeName(fieldSchema as any)\n            lines.push(`  ${optionFlag.padEnd(20)} ${fieldType}`)\n          }\n        }\n      } catch {\n        // Schema introspection failed, skip options\n      }\n    }\n\n    return lines.join('\\n')\n  }\n\n  /**\n   * Gets a human-readable type name from a zod/v4 schema.\n   */\n  private getSchemaTypeName(schema: any): string {\n    try {\n      let currentSchema = schema\n      let typeName = currentSchema?.def?.type\n      let isOptional = false\n      let defaultValue: any\n\n      // Unwrap optional/default wrappers\n      while (typeName === 'optional' || typeName === 'default') {\n        if (typeName === 'optional') {\n          isOptional = true\n        }\n        if (typeName === 'default') {\n          isOptional = true\n          defaultValue = currentSchema?.def?.defaultValue?.()\n        }\n        currentSchema = currentSchema?.def?.innerType\n        typeName = currentSchema?.def?.type\n      }\n\n      let result = `<${typeName || 'unknown'}>`\n      if (defaultValue !== undefined) {\n        result += ` (default: ${JSON.stringify(defaultValue)})`\n      } else if (isOptional) {\n        result += ' (optional)'\n      }\n\n      // Get description from meta() if available\n      const description = this.getSchemaMeta(schema)?.description\n      if (description) {\n        result += ` - ${description}`\n      }\n\n      return result\n    } catch {\n      return '<unknown>'\n    }\n  }\n\n  /**\n   * Gets metadata from a zod/v4 schema, traversing innerType if needed.\n   * zod/v4 v4 stores meta at the outermost layer when .meta() is called last,\n   * or in innerType when .meta() is called before .optional()/.default().\n   */\n  private getSchemaMeta(schema: any): Record<string, unknown> | undefined {\n    try {\n      // First check direct meta (when .meta() is called last in chain)\n      const directMeta = schema.meta?.()\n      if (directMeta) return directMeta\n\n      // Check innerType for wrapped schemas (optional, default, etc.)\n      const innerType = schema.def?.innerType\n      if (innerType) {\n        return this.getSchemaMeta(innerType)\n      }\n\n      return undefined\n    } catch {\n      return undefined\n    }\n  }\n\n  /**\n   * Clear all registered commands.\n   */\n  clear(): void {\n    this.commands.clear()\n  }\n}\n","import { InjectionToken } from '@navios/core'\n\nimport type { HelpCommand } from '../overrides/help.command.mjs'\n\nexport const HelpCommandToken = InjectionToken.create<HelpCommand>('HelpCommand')\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCCA,YAAAA;AACM,IAAMC,yBAAN,MAAMA;;;;CACHC,2BAAW,IAAIC,KAAAA;;;;;;;IASvBC,SAASC,MAAcC,SAAkC;AACvD,MAAI,KAAKJ,SAASK,IAAIF,KAAAA,CACpB,OAAM,IAAIG,MAAM,8CAA8CH,OAAM;AAEtE,OAAKH,SAASO,IAAIJ,MAAMC,QAAAA;;;;;;;IAS1BI,UAAUL,MAA6C;AACrD,SAAO,KAAKH,SAASS,IAAIN,KAAAA;;;;;;IAQ3BO,SAAyC;AACvC,SAAO,IAAIT,IAAI,KAAKD,SAAQ;;;;;;;IAS9BW,gBAA2D;EACzD,MAAMC,SAAoD,EAAE;AAC5D,OAAK,MAAM,CAACT,MAAM,EAAEU,OAAOC,UAAU,KAAKd,SACxCY,QAAOG,KAAK;GAAEZ;GAAMU,OAAOC;GAAI,CAAA;AAEjC,SAAOF;;;;;;IAQTI,oBAA4B;EAC1B,MAAMC,QAAQ,CAAC,uBAAuB,GAAG;AACzC,OAAK,MAAM,CAACd,MAAM,EAAEe,eAAe,KAAKlB,UAAU;GAChD,MAAMmB,cAAcD,SAASC;AAC7B,OAAIA,YACFF,OAAMF,KAAK,KAAKZ,KAAKiB,OAAO,GAAA,CAAI,GAAGD,cAAa;OAEhDF,OAAMF,KAAK,KAAKZ,OAAM;;AAG1B,SAAOc,MAAMI,KAAK,KAAA;;;;;;;IASpBC,kBAAkBC,aAA6B;EAC7C,MAAMnB,UAAU,KAAKJ,SAASS,IAAIc,YAAAA;AAClC,MAAI,CAACnB,QACH,QAAO,oBAAoBmB,YAAY,MAAM,KAAKP,mBAAiB;EAGrE,MAAM,EAAEE,aAAad;EACrB,MAAMa,QAAkB,EAAE;AAE1BA,QAAMF,KAAK,UAAUG,SAASf,KAAK,YAAW;AAC9Cc,QAAMF,KAAK,GAAA;AAEX,MAAIG,SAASC,aAAa;AACxBF,SAAMF,KAAKG,SAASC,YAAW;AAC/BF,SAAMF,KAAK,GAAA;;AAIb,MAAIG,SAASM,eAAe;AAC1BP,SAAMF,KAAK,WAAA;AACX,OAAI;IACF,MAAMU,QAAQP,SAASM,cAAcE,IAAID;AACzC,QAAIA,SAAS,OAAOA,UAAU,SAC5B,MAAK,MAAM,CAACE,KAAKC,gBAAgBC,OAAOC,QAAQL,MAAAA,EAAQ;KAEtD,MAAMS,aAAa,KADFP,IAAIK,QAAQ,YAAY,MAAA,CAAOC,aAAW;KAE3D,MAAME,YAAY,KAAKC,kBAAkBR,YAAAA;AACzCX,WAAMF,KAAK,KAAKmB,WAAWd,OAAO,GAAA,CAAI,GAAGe,YAAW;;WAGlD;;AAKV,SAAOlB,MAAMI,KAAK,KAAA;;;;IAMpB,kBAA0BgB,QAAqB;AAC7C,MAAI;GACF,IAAIC,gBAAgBD;GACpB,IAAIE,WAAWD,eAAeZ,KAAKc;GACnC,IAAIC,aAAa;GACjB,IAAIC;AAGJ,UAAOH,aAAa,cAAcA,aAAa,WAAW;AACxD,QAAIA,aAAa,WACfE,cAAa;AAEf,QAAIF,aAAa,WAAW;AAC1BE,kBAAa;AACbC,oBAAeJ,eAAeZ,KAAKgB,gBAAAA;;AAErCJ,oBAAgBA,eAAeZ,KAAKiB;AACpCJ,eAAWD,eAAeZ,KAAKc;;GAGjC,IAAI5B,SAAS,IAAI2B,YAAY,UAAU;AACvC,OAAIG,iBAAiBE,OACnBhC,WAAU,cAAciC,KAAKC,UAAUJ,aAAAA,CAAc;YAC5CD,WACT7B,WAAU;GAIZ,MAAMO,cAAc,KAAK4B,cAAcV,OAAAA,EAASlB;AAChD,OAAIA,YACFP,WAAU,MAAMO;AAGlB,UAAOP;UACD;AACN,UAAO;;;;;;;IASX,cAAsByB,QAAkD;AACtE,MAAI;GAEF,MAAMW,aAAaX,OAAOY,QAAI;AAC9B,OAAID,WAAY,QAAOA;GAGvB,MAAML,YAAYN,OAAOX,KAAKiB;AAC9B,OAAIA,UACF,QAAO,KAAKI,cAAcJ,UAAAA;AAG5B;UACM;AACN;;;;;IAOJO,QAAc;AACZ,OAAKlD,SAASkD,OAAK;;;;;;;;;AClNvB,MAAaE,mBAAmBD,eAAeE,OAAoB,cAAA"}