@navios/commander 1.0.0 → 1.2.0

package/lib/index.d.mts

@@ -1,46 +1,8 @@
-import { AbstractAdapterInterface, AdapterEnvironment, AnyInjectableType, ClassType, ClassTypeWithInstance, InjectionToken, LogLevel, ModuleMetadata, NaviosApplication, NaviosModule, Registry } from "@navios/core";
+import { a as CommanderExecutionContext, c as extractCommandMetadata, d as CliAdapterOptions, f as CliEnvironment, i as CommandOptions, l as getCommandMetadata, m as CommandHandler, n as CliModuleOptions, o as CommandMetadata, p as AbstractCliAdapterInterface, r as Command, s as CommandMetadataKey, t as CliModule, u as hasCommandMetadata } from "./cli-module.decorator-DGuGfpex.mjs";
+import { AnyInjectableType, ClassType, ClassTypeWithInstance, InjectionToken, LogLevel, ModuleMetadata, NaviosApplication, NaviosModule } from "@navios/core";
 import { ZodObject, z } from "zod";
 export * from "@navios/core";
 
-//#region src/interfaces/command-handler.interface.d.mts
-
-/**
- * Interface that all command classes must implement.
- *
- * Commands decorated with `@Command` must implement this interface.
- * The `execute` method is called when the command is invoked.
- *
- * @template TOptions - The type of options that the command accepts
- *
- * @example
- * ```typescript
- * import { Command, CommandHandler } from '@navios/commander'
- * import { z } from 'zod'
- *
- * const optionsSchema = z.object({
- *   name: z.string()
- * })
- *
- * type Options = z.infer<typeof optionsSchema>
- *
- * @Command({ path: 'greet', optionsSchema })
- * export class GreetCommand implements CommandHandler<Options> {
- *   async execute(options: Options) {
- *     console.log(`Hello, ${options.name}!`)
- *   }
- * }
- * ```
- */
-interface CommandHandler<TOptions = any> {
-  /**
-   * Executes the command with the provided options.
-   *
-   * @param options - The validated command options (validated against the command's schema if provided)
-   * @returns A promise or void
-   */
-  execute(options: TOptions): void | Promise<void>;
-}
-//#endregion
 //#region src/commands/help.command.d.mts
 declare const helpOptionsSchema: z.ZodObject<{
   command: z.ZodOptional<z.ZodString>;
@@ -57,87 +19,6 @@ declare class HelpCommand implements CommandHandler<HelpOptions> {
   execute(options: HelpOptions): Promise<void>;
 }
 //#endregion
-//#region src/interfaces/abstract-cli-adapter.interface.d.mts
-/**
- * Interface for CLI adapters.
- * Extends the base adapter interface with CLI-specific methods.
- *
- * @public
- */
-interface AbstractCliAdapterInterface extends AbstractAdapterInterface {
-  /**
-   * Run the CLI application with the given arguments.
-   * Parses arguments and executes the matching command.
-   *
-   * @param argv - Command-line arguments array (defaults to `process.argv`)
-   *
-   * @example
-   * ```typescript
-   * const adapter = app.getAdapter() as AbstractCliAdapterInterface
-   * await adapter.run(process.argv)
-   * ```
-   */
-  run(argv?: string[]): Promise<void>;
-  /**
-   * Execute a command programmatically with the provided options.
-   *
-   * @param path - The command path (e.g., 'greet', 'user:create')
-   * @param options - The command options object
-   *
-   * @example
-   * ```typescript
-   * await adapter.executeCommand('user:create', {
-   *   name: 'John',
-   *   email: 'john@example.com',
-   * })
-   * ```
-   */
-  executeCommand(path: string, options: Record<string, unknown>): Promise<void>;
-  /**
-   * Get all registered command paths and their class references.
-   *
-   * @returns Array of objects containing path and class
-   *
-   * @example
-   * ```typescript
-   * const commands = adapter.getAllCommands()
-   * commands.forEach(({ path }) => console.log(path))
-   * ```
-   */
-  getAllCommands(): Array<{
-    path: string;
-    class: unknown;
-  }>;
-}
-//#endregion
-//#region src/interfaces/environment.interface.d.mts
-/**
- * Options for configuring the CLI adapter.
- *
- * @public
- */
-interface CliAdapterOptions {}
-/**
- * Environment type definition for CLI adapters.
- * Used with NaviosFactory.create<CliEnvironment>() for type-safe CLI applications.
- *
- * @public
- *
- * @example
- * ```typescript
- * import { NaviosFactory } from '@navios/core'
- * import { defineCliEnvironment, type CliEnvironment } from '@navios/commander'
- *
- * const app = await NaviosFactory.create<CliEnvironment>(AppModule, {
- *   adapter: defineCliEnvironment(),
- * })
- * ```
- */
-interface CliEnvironment extends AdapterEnvironment {
-  options: CliAdapterOptions;
-  adapter: AbstractCliAdapterInterface;
-}
-//#endregion
 //#region src/commander.factory.d.mts
 /**
  * Logger display options for CLI applications.
@@ -182,16 +63,75 @@ interface CommanderLoggerOptions {
    */
   showTimeDiff?: boolean;
 }
+/**
+ * TUI-specific options for terminal UI mode.
+ * Only used when enableTUI is true.
+ *
+ * @public
+ */
+interface CommanderTuiOptions {
+  /**
+   * Exit on Ctrl+C.
+   * @default true
+   */
+  exitOnCtrlC?: boolean;
+  /**
+   * Sidebar width in columns.
+   */
+  sidebarWidth?: number;
+  /**
+   * Sidebar position.
+   */
+  sidebarPosition?: 'left' | 'right';
+  /**
+   * Sidebar header title.
+   */
+  sidebarTitle?: string;
+  /**
+   * Auto close after all screens complete successfully.
+   * Set to true for default delay (5000ms), or specify delay in milliseconds.
+   */
+  autoClose?: boolean | number;
+  /**
+   * Theme preset name ('dark', 'light', 'high-contrast') or custom theme object.
+   */
+  theme?: string | Record<string, unknown>;
+  /**
+   * Enable mouse support.
+   * @default false
+   */
+  useMouse?: boolean;
+  /**
+   * Hide the default console logger screen from the sidebar.
+   * @default false
+   */
+  hideDefaultScreen?: boolean;
+}
 /**
  * Configuration options for CommanderFactory.
  *
  * @public
  */
 interface CommanderFactoryOptions {
+  /**
+   * Enabled log levels.
+   * @default ['log', 'error', 'warn', 'debug', 'verbose', 'fatal']
+   */
+  logLevels?: LogLevel[];
   /**
    * Logger display options. These override the default CLI-friendly logger settings.
+   * Ignored when enableTUI is true.
    */
   logger?: CommanderLoggerOptions;
+  /**
+   * Enable TUI mode with @navios/commander-tui.
+   * Requires @navios/commander-tui to be installed.
+   */
+  enableTUI?: boolean;
+  /**
+   * TUI-specific options. Only used when enableTUI is true.
+   */
+  tuiOptions?: CommanderTuiOptions;
 }
 /**
  * Factory class for creating CLI applications.
@@ -247,169 +187,6 @@ declare class CommanderFactory {
   static create<TModule extends NaviosModule = NaviosModule>(appModule: ClassTypeWithInstance<TModule>, options?: CommanderFactoryOptions): Promise<NaviosApplication<CliEnvironment>>;
 }
 //#endregion
-//#region src/decorators/command.decorator.d.mts
-/**
- * Options for the `@Command` decorator.
- *
- * @public
- */
-interface CommandOptions {
-  /**
-   * The command path that users will invoke from the CLI.
-   * Can be a single word (e.g., 'greet') or multi-word with colons (e.g., 'user:create', 'db:migrate').
-   */
-  path: string;
-  /**
-   * Optional description of the command for help text.
-   * Displayed when users run `help` or `--help`.
-   */
-  description?: string;
-  /**
-   * Optional Zod schema for validating command options.
-   * If provided, options will be validated and parsed according to this schema.
-   */
-  optionsSchema?: ZodObject;
-  /**
-   * Priority level for the command.
-   * Higher priority commands will be loaded first.
-   */
-  priority?: number;
-  /**
-   * Registry to use for the command.
-   * Registry is used to store the command and its options schema.
-   */
-  registry?: Registry;
-}
-/**
- * Decorator that marks a class as a CLI command.
- *
- * The decorated class must implement the `CommandHandler` interface with an `execute` method.
- * The command will be automatically registered when its module is loaded.
- *
- * @param options - Configuration options for the command
- * @returns A class decorator function
- *
- * @example
- * ```typescript
- * import { Command, CommandHandler } from '@navios/commander'
- * import { z } from 'zod'
- *
- * const optionsSchema = z.object({
- *   name: z.string(),
- *   greeting: z.string().optional().default('Hello')
- * })
- *
- * @Command({
- *   path: 'greet',
- *   optionsSchema: optionsSchema
- * })
- * export class GreetCommand implements CommandHandler<z.infer<typeof optionsSchema>> {
- *   async execute(options) {
- *     console.log(`${options.greeting}, ${options.name}!`)
- *   }
- * }
- * ```
- */
-declare function Command({
-  path,
-  description,
-  optionsSchema,
-  priority,
-  registry
-}: CommandOptions): (target: ClassType, context: ClassDecoratorContext) => ClassType;
-//#endregion
-//#region src/decorators/cli-module.decorator.d.mts
-/**
- * Options for the `@CliModule` decorator.
- *
- * @public
- */
-interface CliModuleOptions {
-  /**
-   * Array or Set of command classes to register in this module.
-   * Commands must be decorated with `@Command`.
-   */
-  commands?: ClassType[] | Set<ClassType>;
-  /**
-   * Array or Set of controller classes for HTTP endpoints.
-   * Allows mixing HTTP and CLI functionality in the same module.
-   */
-  controllers?: ClassType[] | Set<ClassType>;
-  /**
-   * Array or Set of other modules to import.
-   * Imported modules' commands and controllers will be available.
-   */
-  imports?: ClassType[] | Set<ClassType>;
-  /**
-   * Guards to apply to all controllers in this module.
-   * Guards are executed in reverse order (last guard first).
-   */
-  guards?: ClassType[] | Set<ClassType>;
-  /**
-   * Service override classes to import for side effects.
-   * These classes are imported to ensure their @Injectable decorators execute,
-   * allowing them to register with the DI system. Overrides should use the same
-   * InjectionToken as the original service with a higher priority.
-   */
-  overrides?: ClassType[] | Set<ClassType>;
-  /**
-   * Priority level for the module.
-   * Higher priority modules will be loaded first.
-   */
-  priority?: number;
-  /**
-   * Registry to use for the module.
-   * Registry is used to store the module and its commands.
-   */
-  registry?: Registry;
-}
-/**
- * Decorator that marks a class as a CLI module.
- *
- * This decorator extends the standard @Module decorator, adding support for
- * CLI commands while maintaining full compatibility with HTTP controllers.
- * Modules organize commands and can import other modules to compose larger
- * CLI applications.
- *
- * The module can optionally implement `NaviosModule` interface for lifecycle hooks.
- *
- * @param options - Configuration options for the module
- * @returns A class decorator function
- *
- * @example
- * ```typescript
- * import { CliModule } from '@navios/commander'
- * import { GreetCommand } from './greet.command'
- * import { UserModule } from './user.module'
- *
- * @CliModule({
- *   commands: [GreetCommand],
- *   imports: [UserModule]
- * })
- * export class AppModule {}
- * ```
- *
- * @example
- * ```typescript
- * // Mixed HTTP and CLI module
- * @CliModule({
- *   controllers: [HealthController],
- *   commands: [MigrateCommand],
- *   imports: [DatabaseModule],
- * })
- * export class AppModule {}
- * ```
- */
-declare function CliModule({
-  commands,
-  controllers,
-  imports,
-  guards,
-  overrides,
-  priority,
-  registry
-}?: CliModuleOptions): (target: ClassType, context: ClassDecoratorContext) => ClassType;
-//#endregion
 //#region src/services/commander-adapter.service.d.mts
 /**
  * CLI adapter service that implements the AbstractCliAdapterInterface.
@@ -464,69 +241,6 @@ declare class CommanderAdapterService implements AbstractCliAdapterInterface {
   }>;
 }
 //#endregion
-//#region src/metadata/command.metadata.d.mts
-/**
- * @internal
- * Symbol key used to store command metadata on classes.
- */
-declare const CommandMetadataKey: unique symbol;
-/**
- * Metadata associated with a command.
- *
- * @public
- */
-interface CommandMetadata {
-  /**
-   * The command path (e.g., 'greet', 'user:create').
-   */
-  path: string;
-  /**
-   * Optional description of the command for help text.
-   */
-  description?: string;
-  /**
-   * Optional Zod schema for validating command options.
-   */
-  optionsSchema?: ZodObject;
-  /**
-   * Map of custom attributes that can be attached to the command.
-   */
-  customAttributes: Map<string | symbol, any>;
-}
-/**
- * Gets or creates command metadata for a class.
- *
- * @internal
- * @param target - The command class
- * @param context - The decorator context
- * @param path - The command path
- * @param description - Optional description for help text
- * @param optionsSchema - Optional Zod schema
- * @returns The command metadata
- */
-declare function getCommandMetadata(target: ClassType, context: ClassDecoratorContext, path: string, description?: string, optionsSchema?: ZodObject): CommandMetadata;
-/**
- * Extracts command metadata from a class.
- *
- * @param target - The command class
- * @returns The command metadata
- * @throws {Error} If the class is not decorated with @Command
- *
- * @example
- * ```typescript
- * const metadata = extractCommandMetadata(GreetCommand)
- * console.log(metadata.path) // 'greet'
- * ```
- */
-declare function extractCommandMetadata(target: ClassType): CommandMetadata;
-/**
- * Checks if a class has command metadata.
- *
- * @param target - The class to check
- * @returns `true` if the class is decorated with @Command, `false` otherwise
- */
-declare function hasCommandMetadata(target: ClassType): boolean;
-//#endregion
 //#region src/metadata/command-entry.metadata.d.mts
 /**
  * Symbol key for storing commands in ModuleMetadata.customEntries.
@@ -748,60 +462,6 @@ declare function defineCliEnvironment(): {
   tokens: Map<InjectionToken<any, undefined, false>, AnyInjectableType>;
 };
 //#endregion
-//#region src/interfaces/commander-execution-context.interface.d.mts
-/**
- * Execution context for a command execution.
- *
- * Provides access to command metadata, path, and validated options during command execution.
- * This context is automatically injected and available via the `CommandExecutionContext` token.
- *
- * @example
- * ```typescript
- * import { inject, Injectable } from '@navios/core'
- * import { CommandExecutionContext } from '@navios/commander'
- *
- * @Injectable()
- * class CommandLogger {
- *   private ctx = inject(CommandExecutionContext)
- *
- *   log() {
- *     console.log('Command:', this.ctx.getCommandPath())
- *     console.log('Options:', this.ctx.getOptions())
- *   }
- * }
- * ```
- */
-declare class CommanderExecutionContext {
-  private readonly command;
-  private readonly commandPath;
-  private readonly options;
-  /**
-   * @internal
-   * Creates a new execution context.
-   */
-  constructor(command: CommandMetadata, commandPath: string, options: any);
-  /**
-   * Gets the command metadata.
-   *
-   * @returns The command metadata including path and options schema
-   */
-  getCommand(): CommandMetadata;
-  /**
-   * Gets the command path that was invoked.
-   *
-   * @returns The command path (e.g., 'greet', 'user:create')
-   */
-  getCommandPath(): string;
-  /**
-   * Gets the validated command options.
-   *
-   * Options are validated against the command's Zod schema if one was provided.
-   *
-   * @returns The validated options object
-   */
-  getOptions(): any;
-}
-//#endregion
 //#region src/tokens/execution-context.token.d.mts
 /**
  * Injection token for accessing the current command execution context.
@@ -828,5 +488,5 @@ declare class CommanderExecutionContext {
  */
 declare const CommandExecutionContext: InjectionToken<CommanderExecutionContext, undefined, false>;
 //#endregion
-export { AbstractCliAdapterInterface, CliAdapterOptions, CliEnvironment, CliModule, CliModuleOptions, CliParserService, Command, CommandEntryKey, CommandEntryValue, CommandExecutionContext, CommandHandler, CommandMetadata, CommandMetadataKey, CommandOptions, CommandRegistryService, CommanderAdapterService, CommanderExecutionContext, CommanderFactory, CommanderFactoryOptions, CommanderLoggerOptions, HelpCommand, ParsedCliArgs, RegisteredCommand, defineCliEnvironment, extractCommandMetadata, extractModuleCommands, getCommandMetadata, hasCommandMetadata };
+export { AbstractCliAdapterInterface, CliAdapterOptions, CliEnvironment, CliModule, CliModuleOptions, CliParserService, Command, CommandEntryKey, CommandEntryValue, CommandExecutionContext, CommandHandler, CommandMetadata, CommandMetadataKey, CommandOptions, CommandRegistryService, CommanderAdapterService, CommanderExecutionContext, CommanderFactory, CommanderFactoryOptions, CommanderLoggerOptions, CommanderTuiOptions, HelpCommand, ParsedCliArgs, RegisteredCommand, defineCliEnvironment, extractCommandMetadata, extractModuleCommands, getCommandMetadata, hasCommandMetadata };
 //# sourceMappingURL=index.d.mts.map

package/lib/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":["CommandHandler","TOptions","Promise","z","CommandHandler","helpOptionsSchema","ZodString","ZodOptional","core","$strip","ZodObject","HelpOptions","infer","HelpCommand","Promise","AbstractAdapterInterface","AbstractCliAdapterInterface","Promise","Record","Array","AdapterEnvironment","AbstractCliAdapterInterface","CliAdapterOptions","CliEnvironment","ClassTypeWithInstance","LogLevel","NaviosApplication","NaviosModule","CliEnvironment","CommanderLoggerOptions","CommanderFactoryOptions","CommanderFactory","TModule","Promise","ClassType","Registry","ZodObject","CommandOptions","Command","path","description","optionsSchema","priority","registry","ClassDecoratorContext","ClassType","Registry","CliModuleOptions","Set","CliModule","commands","controllers","imports","guards","overrides","priority","registry","ClassDecoratorContext","ClassType","ModuleMetadata","AbstractCliAdapterInterface","CliAdapterOptions","CommanderAdapterService","Promise","Map","Record","Array","ClassType","ZodObject","CommandMetadataKey","CommandMetadata","Map","getCommandMetadata","ClassDecoratorContext","extractCommandMetadata","hasCommandMetadata","ClassType","CommandEntryKey","CommandEntryValue","Set","extractModuleCommands","ClassType","CommandMetadata","RegisteredCommand","CommandRegistryService","Map","Array","ZodObject","ParsedCliArgs","Record","CliParserService","AnyInjectableType","InjectionToken","CommanderAdapterService","CommandRegistryService","CliParserService","defineCliEnvironment","Map","CommandMetadata","CommanderExecutionContext","InjectionToken","CommanderExecutionContext","CommandExecutionContext"],"sources":["../src/interfaces/command-handler.interface.d.mts","../src/commands/help.command.d.mts","../src/interfaces/abstract-cli-adapter.interface.d.mts","../src/interfaces/environment.interface.d.mts","../src/commander.factory.d.mts","../src/decorators/command.decorator.d.mts","../src/decorators/cli-module.decorator.d.mts","../src/services/commander-adapter.service.d.mts","../src/metadata/command.metadata.d.mts","../src/metadata/command-entry.metadata.d.mts","../src/services/command-registry.service.d.mts","../src/services/cli-parser.service.d.mts","../src/define-environment.d.mts","../src/interfaces/commander-execution-context.interface.d.mts","../src/tokens/execution-context.token.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'\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","import { z } from 'zod';\nimport type { CommandHandler } from '../interfaces/command-handler.interface.mjs';\ndeclare const helpOptionsSchema: z.ZodObject<{\n    command: z.ZodOptional<z.ZodString>;\n}, z.core.$strip>;\ntype HelpOptions = z.infer<typeof helpOptionsSchema>;\n/**\n * Built-in help command that lists all available commands or shows help for a specific command.\n *\n * @public\n */\nexport declare class HelpCommand implements CommandHandler<HelpOptions> {\n    private logger;\n    private commandRegistry;\n    execute(options: HelpOptions): Promise<void>;\n}\nexport {};\n//# sourceMappingURL=help.command.d.mts.map","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","import type { AdapterEnvironment } from '@navios/core';\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/**\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","import type { ClassTypeWithInstance, LogLevel, NaviosApplication, NaviosModule } from '@navios/core';\nimport type { CliEnvironment } from './interfaces/environment.interface.mjs';\n/**\n * Logger display options for CLI applications.\n * All options default to false for cleaner CLI output.\n *\n * @public\n */\nexport interface CommanderLoggerOptions {\n    /**\n     * Enabled log levels.\n     * @default ['log', 'error', 'warn', 'debug', 'verbose', 'fatal']\n     */\n    logLevels?: LogLevel[];\n    /**\n     * If true, will print the process ID in the log message.\n     * @default false\n     */\n    showPid?: boolean;\n    /**\n     * If true, will print the log level in the log message.\n     * @default true\n     */\n    showLogLevel?: boolean;\n    /**\n     * If true, will print the prefix/app name in the log message.\n     * @default false\n     */\n    showPrefix?: boolean;\n    /**\n     * If true, will print the context in the log message.\n     * @default true\n     */\n    showContext?: boolean;\n    /**\n     * If true, will print the absolute timestamp in the log message.\n     * @default false\n     */\n    showTimestamp?: boolean;\n    /**\n     * If enabled, will print timestamp difference between current and previous log message.\n     * @default false\n     */\n    showTimeDiff?: boolean;\n}\n/**\n * Configuration options for CommanderFactory.\n *\n * @public\n */\nexport interface CommanderFactoryOptions {\n    /**\n     * Logger display options. These override the default CLI-friendly logger settings.\n     */\n    logger?: CommanderLoggerOptions;\n}\n/**\n * Factory class for creating CLI applications.\n *\n * This is a convenience wrapper around `NaviosFactory.create()` that\n * configures everything needed for CLI usage. It sets up the CLI adapter\n * and returns a typed `NaviosApplication<CliEnvironment>`.\n *\n * @example\n * ```typescript\n * import { CommanderFactory } from '@navios/commander'\n * import { AppModule } from './app.module'\n *\n * async function bootstrap() {\n *   const app = await CommanderFactory.create(AppModule)\n *   await app.init()\n *\n *   const adapter = app.getAdapter()\n *   await adapter.run(process.argv)\n *\n *   await app.close()\n * }\n * ```\n *\n * @example\n * ```typescript\n * // Alternative: use NaviosFactory directly\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 declare class CommanderFactory {\n    /**\n     * Creates a new CLI application instance configured with the provided module.\n     *\n     * @param appModule - The root CLI module class decorated with `@CliModule`\n     * @param options - Optional configuration options for the CLI application\n     * @returns A promise that resolves to a configured NaviosApplication instance\n     *\n     * @example\n     * ```typescript\n     * const app = await CommanderFactory.create(AppModule)\n     * await app.init()\n     *\n     * const adapter = app.getAdapter()\n     * await adapter.run(process.argv)\n     * ```\n     */\n    static create<TModule extends NaviosModule = NaviosModule>(appModule: ClassTypeWithInstance<TModule>, options?: CommanderFactoryOptions): Promise<NaviosApplication<CliEnvironment>>;\n}\n//# sourceMappingURL=commander.factory.d.mts.map","import type { ClassType, Registry } from '@navios/core';\nimport type { ZodObject } from 'zod';\n/**\n * Options for the `@Command` decorator.\n *\n * @public\n */\nexport interface CommandOptions {\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 schema for validating command options.\n     * If provided, options will be validated and parsed according to this schema.\n     */\n    optionsSchema?: 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'\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({ path, description, optionsSchema, priority, registry, }: CommandOptions): (target: ClassType, context: ClassDecoratorContext) => ClassType;\n//# sourceMappingURL=command.decorator.d.mts.map","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({ commands, controllers, imports, guards, overrides, priority, registry, }?: CliModuleOptions): (target: ClassType, context: ClassDecoratorContext) => ClassType;\n//# sourceMappingURL=cli-module.decorator.d.mts.map","import type { ClassType, ModuleMetadata } from '@navios/core';\nimport type { AbstractCliAdapterInterface } from '../interfaces/abstract-cli-adapter.interface.mjs';\nimport type { CliAdapterOptions } from '../interfaces/environment.interface.mjs';\n/**\n * CLI adapter service that implements the AbstractCliAdapterInterface.\n * Handles command discovery, registration, parsing, and execution.\n *\n * @public\n */\nexport declare class CommanderAdapterService implements AbstractCliAdapterInterface {\n    private container;\n    private commandRegistry;\n    private cliParser;\n    private logger;\n    private options;\n    private isReady;\n    /**\n     * Sets up the adapter with the provided options.\n     * Called during application initialization.\n     */\n    setupAdapter(options: CliAdapterOptions): Promise<void>;\n    /**\n     * Called after all modules are loaded.\n     * Iterates through modules and extracts commands from customEntries.\n     */\n    onModulesInit(modules: Map<string, ModuleMetadata>): Promise<void>;\n    /**\n     * Registers built-in commands like help.\n     */\n    private registerBuiltInCommands;\n    /**\n     * Signals that the adapter is ready to handle commands.\n     */\n    ready(): Promise<void>;\n    /**\n     * Disposes of the adapter and cleans up resources.\n     */\n    dispose(): Promise<void>;\n    /**\n     * Run the CLI application with the given arguments.\n     * Parses arguments and executes the matching command.\n     */\n    run(argv?: string[]): Promise<void>;\n    /**\n     * Execute a command programmatically with the provided options.\n     */\n    executeCommand(path: string, options?: Record<string, unknown>): Promise<void>;\n    /**\n     * Get all registered command paths and their class references.\n     */\n    getAllCommands(): Array<{\n        path: string;\n        class: ClassType;\n    }>;\n}\n//# sourceMappingURL=commander-adapter.service.d.mts.map","import type { ClassType } from '@navios/core';\nimport type { ZodObject } from 'zod';\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 schema for validating command options.\n     */\n    optionsSchema?: 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 schema\n * @returns The command metadata\n */\nexport declare function getCommandMetadata(target: ClassType, context: ClassDecoratorContext, path: string, description?: string, optionsSchema?: ZodObject): 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","import type { ClassType } from '@navios/core';\n/**\n * Symbol key for storing commands in ModuleMetadata.customEntries.\n * Used by @CliModule to store command classes.\n *\n * @public\n */\nexport declare const CommandEntryKey: unique symbol;\n/**\n * Type for the command entry value stored in customEntries.\n *\n * @public\n */\nexport type CommandEntryValue = Set<ClassType>;\n/**\n * Extracts commands from a module's metadata.\n * Returns empty set if no commands are defined.\n *\n * @param moduleClass - The module class decorated with @CliModule or @Module\n * @returns Set of command classes registered in the module\n *\n * @example\n * ```typescript\n * const commands = extractModuleCommands(AppModule)\n * for (const command of commands) {\n *   console.log(command.name)\n * }\n * ```\n */\nexport declare function extractModuleCommands(moduleClass: ClassType): Set<ClassType>;\n//# sourceMappingURL=command-entry.metadata.d.mts.map","import type { ClassType } from '@navios/core';\nimport type { CommandMetadata } from '../metadata/index.mjs';\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 * Service for registering and looking up CLI commands.\n * Used internally by the CLI adapter to manage discovered commands.\n *\n * @public\n */\nexport declare class CommandRegistryService {\n    private commands;\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    /**\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    /**\n     * Get all registered commands.\n     *\n     * @returns Map of path to registered command\n     */\n    getAll(): Map<string, RegisteredCommand>;\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<{\n        path: string;\n        class: ClassType;\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    /**\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    /**\n     * Gets a human-readable type name from a Zod schema.\n     */\n    private getSchemaTypeName;\n    /**\n     * Gets metadata from a Zod schema, traversing innerType if needed.\n     * Zod 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;\n    /**\n     * Clear all registered commands.\n     */\n    clear(): void;\n}\n//# sourceMappingURL=command-registry.service.d.mts.map","import type { ZodObject } from 'zod';\n/**\n * Result of parsing command-line arguments.\n *\n * @public\n */\nexport interface ParsedCliArgs {\n    /**\n     * The command path (e.g., 'greet', 'user:create').\n     * Multi-word commands are joined with spaces.\n     */\n    command: string;\n    /**\n     * Parsed options as key-value pairs.\n     * Keys are converted from kebab-case to camelCase.\n     */\n    options: Record<string, any>;\n    /**\n     * Positional arguments that don't match any option flags.\n     */\n    positionals: string[];\n}\n/**\n * Service for parsing command-line arguments.\n *\n * Handles parsing of various CLI argument formats including:\n * - Long options: `--key value` or `--key=value`\n * - Short options: `-k value` or `-abc` (multiple flags)\n * - Boolean flags\n * - Array options\n * - Positional arguments\n *\n * @public\n */\nexport declare class CliParserService {\n    /**\n     * Parses command-line arguments from process.argv\n     * Commands can be multi-word (e.g., 'db migrate', 'cache clear')\n     * Expected format: node script.js command [subcommand...] --flag value --boolean-flag positional1 positional2\n     *\n     * @param argv - Array of command-line arguments (typically process.argv)\n     * @param optionsSchema - Optional Zod schema to determine boolean flags and option types\n     * @returns Parsed command (space-separated if multi-word), options, and positional arguments\n     */\n    parse(argv: string[], optionsSchema?: ZodObject): ParsedCliArgs;\n    /**\n     * Converts kebab-case to camelCase\n     */\n    private camelCase;\n    /**\n     * Attempts to parse string values into appropriate types\n     */\n    private parseValue;\n    /**\n     * Extracts boolean field names from a Zod schema\n     * Handles ZodObject, ZodOptional, and ZodDefault wrappers\n     */\n    private extractBooleanFields;\n    /**\n     * Extracts array field names from a Zod schema\n     * Handles ZodObject, ZodOptional, and ZodDefault wrappers\n     */\n    private extractArrayFields;\n    /**\n     * Checks if a Zod schema represents a boolean type\n     * Unwraps ZodOptional and ZodDefault using Zod v4 API\n     */\n    private isSchemaBoolean;\n    /**\n     * Checks if a Zod schema represents an array type\n     * Unwraps ZodOptional and ZodDefault using Zod v4 API\n     */\n    private isSchemaArray;\n}\n//# sourceMappingURL=cli-parser.service.d.mts.map","import type { AnyInjectableType, InjectionToken } from '@navios/core';\nimport { CommanderAdapterService } from './services/commander-adapter.service.mjs';\nimport { CommandRegistryService } from './services/command-registry.service.mjs';\nimport { CliParserService } from './services/cli-parser.service.mjs';\n/**\n * Defines the CLI environment configuration for use with NaviosFactory.\n *\n * This function returns the token mappings needed to configure a CLI application.\n * Use it with `NaviosFactory.create()` to create a CLI application.\n *\n * @returns Environment configuration with token mappings\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 * await app.init()\n *\n * const adapter = app.getAdapter() as AbstractCliAdapterInterface\n * await adapter.run(process.argv)\n * ```\n */\nexport declare function defineCliEnvironment(): {\n    tokens: Map<InjectionToken<any, undefined, false>, AnyInjectableType>;\n};\nexport { CommanderAdapterService, CommandRegistryService, CliParserService };\n//# sourceMappingURL=define-environment.d.mts.map","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 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","import { InjectionToken } from '@navios/core';\nimport type { CommanderExecutionContext } from '../interfaces/index.mjs';\n/**\n * Injection token for accessing the current command execution context.\n *\n * Use this token with `inject()` to access the `CommanderExecutionContext` in services\n * that need information about the currently executing command.\n *\n * @example\n * ```typescript\n * import { inject, Injectable } from '@navios/core'\n * import { CommandExecutionContext } from '@navios/commander'\n *\n * @Injectable()\n * class MyService {\n *   private ctx = inject(CommandExecutionContext)\n *\n *   doSomething() {\n *     const commandPath = this.ctx.getCommandPath()\n *     const options = this.ctx.getOptions()\n *     // Use context information...\n *   }\n * }\n * ```\n */\nexport declare const CommandExecutionContext: InjectionToken<CommanderExecutionContext, undefined, false>;\n//# sourceMappingURL=execution-context.token.d.mts.map"],"mappings":"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"}
+{"version":3,"file":"index.d.mts","names":["z","CommandHandler","helpOptionsSchema","ZodString","ZodOptional","core","$strip","ZodObject","HelpOptions","infer","HelpCommand","Promise","ClassTypeWithInstance","LogLevel","NaviosApplication","NaviosModule","CliEnvironment","CommanderLoggerOptions","CommanderTuiOptions","Record","CommanderFactoryOptions","CommanderFactory","TModule","Promise","ClassType","ModuleMetadata","AbstractCliAdapterInterface","CliAdapterOptions","CommanderAdapterService","Promise","Map","Record","Array","ClassType","CommandEntryKey","CommandEntryValue","Set","extractModuleCommands","ClassType","CommandMetadata","RegisteredCommand","CommandRegistryService","Map","Array","ZodObject","ParsedCliArgs","Record","CliParserService","AnyInjectableType","InjectionToken","CommanderAdapterService","CommandRegistryService","CliParserService","defineCliEnvironment","Map","InjectionToken","CommanderExecutionContext","CommandExecutionContext"],"sources":["../src/commands/help.command.d.mts","../src/commander.factory.d.mts","../src/services/commander-adapter.service.d.mts","../src/metadata/command-entry.metadata.d.mts","../src/services/command-registry.service.d.mts","../src/services/cli-parser.service.d.mts","../src/define-environment.d.mts","../src/tokens/execution-context.token.d.mts"],"sourcesContent":["import { z } from 'zod';\nimport type { CommandHandler } from '../interfaces/command-handler.interface.mjs';\ndeclare const helpOptionsSchema: z.ZodObject<{\n    command: z.ZodOptional<z.ZodString>;\n}, z.core.$strip>;\ntype HelpOptions = z.infer<typeof helpOptionsSchema>;\n/**\n * Built-in help command that lists all available commands or shows help for a specific command.\n *\n * @public\n */\nexport declare class HelpCommand implements CommandHandler<HelpOptions> {\n    private logger;\n    private commandRegistry;\n    execute(options: HelpOptions): Promise<void>;\n}\nexport {};\n//# sourceMappingURL=help.command.d.mts.map","import type { ClassTypeWithInstance, LogLevel, NaviosApplication, NaviosModule } from '@navios/core';\nimport type { CliEnvironment } from './interfaces/environment.interface.mjs';\n/**\n * Logger display options for CLI applications.\n * All options default to false for cleaner CLI output.\n *\n * @public\n */\nexport interface CommanderLoggerOptions {\n    /**\n     * Enabled log levels.\n     * @default ['log', 'error', 'warn', 'debug', 'verbose', 'fatal']\n     */\n    logLevels?: LogLevel[];\n    /**\n     * If true, will print the process ID in the log message.\n     * @default false\n     */\n    showPid?: boolean;\n    /**\n     * If true, will print the log level in the log message.\n     * @default true\n     */\n    showLogLevel?: boolean;\n    /**\n     * If true, will print the prefix/app name in the log message.\n     * @default false\n     */\n    showPrefix?: boolean;\n    /**\n     * If true, will print the context in the log message.\n     * @default true\n     */\n    showContext?: boolean;\n    /**\n     * If true, will print the absolute timestamp in the log message.\n     * @default false\n     */\n    showTimestamp?: boolean;\n    /**\n     * If enabled, will print timestamp difference between current and previous log message.\n     * @default false\n     */\n    showTimeDiff?: boolean;\n}\n/**\n * TUI-specific options for terminal UI mode.\n * Only used when enableTUI is true.\n *\n * @public\n */\nexport interface CommanderTuiOptions {\n    /**\n     * Exit on Ctrl+C.\n     * @default true\n     */\n    exitOnCtrlC?: boolean;\n    /**\n     * Sidebar width in columns.\n     */\n    sidebarWidth?: number;\n    /**\n     * Sidebar position.\n     */\n    sidebarPosition?: 'left' | 'right';\n    /**\n     * Sidebar header title.\n     */\n    sidebarTitle?: string;\n    /**\n     * Auto close after all screens complete successfully.\n     * Set to true for default delay (5000ms), or specify delay in milliseconds.\n     */\n    autoClose?: boolean | number;\n    /**\n     * Theme preset name ('dark', 'light', 'high-contrast') or custom theme object.\n     */\n    theme?: string | Record<string, unknown>;\n    /**\n     * Enable mouse support.\n     * @default false\n     */\n    useMouse?: boolean;\n    /**\n     * Hide the default console logger screen from the sidebar.\n     * @default false\n     */\n    hideDefaultScreen?: boolean;\n}\n/**\n * Configuration options for CommanderFactory.\n *\n * @public\n */\nexport interface CommanderFactoryOptions {\n    /**\n     * Enabled log levels.\n     * @default ['log', 'error', 'warn', 'debug', 'verbose', 'fatal']\n     */\n    logLevels?: LogLevel[];\n    /**\n     * Logger display options. These override the default CLI-friendly logger settings.\n     * Ignored when enableTUI is true.\n     */\n    logger?: CommanderLoggerOptions;\n    /**\n     * Enable TUI mode with @navios/commander-tui.\n     * Requires @navios/commander-tui to be installed.\n     */\n    enableTUI?: boolean;\n    /**\n     * TUI-specific options. Only used when enableTUI is true.\n     */\n    tuiOptions?: CommanderTuiOptions;\n}\n/**\n * Factory class for creating CLI applications.\n *\n * This is a convenience wrapper around `NaviosFactory.create()` that\n * configures everything needed for CLI usage. It sets up the CLI adapter\n * and returns a typed `NaviosApplication<CliEnvironment>`.\n *\n * @example\n * ```typescript\n * import { CommanderFactory } from '@navios/commander'\n * import { AppModule } from './app.module'\n *\n * async function bootstrap() {\n *   const app = await CommanderFactory.create(AppModule)\n *   await app.init()\n *\n *   const adapter = app.getAdapter()\n *   await adapter.run(process.argv)\n *\n *   await app.close()\n * }\n * ```\n *\n * @example\n * ```typescript\n * // Alternative: use NaviosFactory directly\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 declare class CommanderFactory {\n    /**\n     * Creates a new CLI application instance configured with the provided module.\n     *\n     * @param appModule - The root CLI module class decorated with `@CliModule`\n     * @param options - Optional configuration options for the CLI application\n     * @returns A promise that resolves to a configured NaviosApplication instance\n     *\n     * @example\n     * ```typescript\n     * const app = await CommanderFactory.create(AppModule)\n     * await app.init()\n     *\n     * const adapter = app.getAdapter()\n     * await adapter.run(process.argv)\n     * ```\n     */\n    static create<TModule extends NaviosModule = NaviosModule>(appModule: ClassTypeWithInstance<TModule>, options?: CommanderFactoryOptions): Promise<NaviosApplication<CliEnvironment>>;\n}\n//# sourceMappingURL=commander.factory.d.mts.map","import type { ClassType, ModuleMetadata } from '@navios/core';\nimport type { AbstractCliAdapterInterface } from '../interfaces/abstract-cli-adapter.interface.mjs';\nimport type { CliAdapterOptions } from '../interfaces/environment.interface.mjs';\n/**\n * CLI adapter service that implements the AbstractCliAdapterInterface.\n * Handles command discovery, registration, parsing, and execution.\n *\n * @public\n */\nexport declare class CommanderAdapterService implements AbstractCliAdapterInterface {\n    private container;\n    private commandRegistry;\n    private cliParser;\n    private logger;\n    private options;\n    private isReady;\n    /**\n     * Sets up the adapter with the provided options.\n     * Called during application initialization.\n     */\n    setupAdapter(options: CliAdapterOptions): Promise<void>;\n    /**\n     * Called after all modules are loaded.\n     * Iterates through modules and extracts commands from customEntries.\n     */\n    onModulesInit(modules: Map<string, ModuleMetadata>): Promise<void>;\n    /**\n     * Registers built-in commands like help.\n     */\n    private registerBuiltInCommands;\n    /**\n     * Signals that the adapter is ready to handle commands.\n     */\n    ready(): Promise<void>;\n    /**\n     * Disposes of the adapter and cleans up resources.\n     */\n    dispose(): Promise<void>;\n    /**\n     * Run the CLI application with the given arguments.\n     * Parses arguments and executes the matching command.\n     */\n    run(argv?: string[]): Promise<void>;\n    /**\n     * Execute a command programmatically with the provided options.\n     */\n    executeCommand(path: string, options?: Record<string, unknown>): Promise<void>;\n    /**\n     * Get all registered command paths and their class references.\n     */\n    getAllCommands(): Array<{\n        path: string;\n        class: ClassType;\n    }>;\n}\n//# sourceMappingURL=commander-adapter.service.d.mts.map","import type { ClassType } from '@navios/core';\n/**\n * Symbol key for storing commands in ModuleMetadata.customEntries.\n * Used by @CliModule to store command classes.\n *\n * @public\n */\nexport declare const CommandEntryKey: unique symbol;\n/**\n * Type for the command entry value stored in customEntries.\n *\n * @public\n */\nexport type CommandEntryValue = Set<ClassType>;\n/**\n * Extracts commands from a module's metadata.\n * Returns empty set if no commands are defined.\n *\n * @param moduleClass - The module class decorated with @CliModule or @Module\n * @returns Set of command classes registered in the module\n *\n * @example\n * ```typescript\n * const commands = extractModuleCommands(AppModule)\n * for (const command of commands) {\n *   console.log(command.name)\n * }\n * ```\n */\nexport declare function extractModuleCommands(moduleClass: ClassType): Set<ClassType>;\n//# sourceMappingURL=command-entry.metadata.d.mts.map","import type { ClassType } from '@navios/core';\nimport type { CommandMetadata } from '../metadata/index.mjs';\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 * Service for registering and looking up CLI commands.\n * Used internally by the CLI adapter to manage discovered commands.\n *\n * @public\n */\nexport declare class CommandRegistryService {\n    private commands;\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    /**\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    /**\n     * Get all registered commands.\n     *\n     * @returns Map of path to registered command\n     */\n    getAll(): Map<string, RegisteredCommand>;\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<{\n        path: string;\n        class: ClassType;\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    /**\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    /**\n     * Gets a human-readable type name from a Zod schema.\n     */\n    private getSchemaTypeName;\n    /**\n     * Gets metadata from a Zod schema, traversing innerType if needed.\n     * Zod 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;\n    /**\n     * Clear all registered commands.\n     */\n    clear(): void;\n}\n//# sourceMappingURL=command-registry.service.d.mts.map","import type { ZodObject } from 'zod';\n/**\n * Result of parsing command-line arguments.\n *\n * @public\n */\nexport interface ParsedCliArgs {\n    /**\n     * The command path (e.g., 'greet', 'user:create').\n     * Multi-word commands are joined with spaces.\n     */\n    command: string;\n    /**\n     * Parsed options as key-value pairs.\n     * Keys are converted from kebab-case to camelCase.\n     */\n    options: Record<string, any>;\n    /**\n     * Positional arguments that don't match any option flags.\n     */\n    positionals: string[];\n}\n/**\n * Service for parsing command-line arguments.\n *\n * Handles parsing of various CLI argument formats including:\n * - Long options: `--key value` or `--key=value`\n * - Short options: `-k value` or `-abc` (multiple flags)\n * - Boolean flags\n * - Array options\n * - Positional arguments\n *\n * @public\n */\nexport declare class CliParserService {\n    /**\n     * Parses command-line arguments from process.argv\n     * Commands can be multi-word (e.g., 'db migrate', 'cache clear')\n     * Expected format: node script.js command [subcommand...] --flag value --boolean-flag positional1 positional2\n     *\n     * @param argv - Array of command-line arguments (typically process.argv)\n     * @param optionsSchema - Optional Zod schema to determine boolean flags and option types\n     * @returns Parsed command (space-separated if multi-word), options, and positional arguments\n     */\n    parse(argv: string[], optionsSchema?: ZodObject): ParsedCliArgs;\n    /**\n     * Converts kebab-case to camelCase\n     */\n    private camelCase;\n    /**\n     * Attempts to parse string values into appropriate types\n     */\n    private parseValue;\n    /**\n     * Extracts boolean field names from a Zod schema\n     * Handles ZodObject, ZodOptional, and ZodDefault wrappers\n     */\n    private extractBooleanFields;\n    /**\n     * Extracts array field names from a Zod schema\n     * Handles ZodObject, ZodOptional, and ZodDefault wrappers\n     */\n    private extractArrayFields;\n    /**\n     * Checks if a Zod schema represents a boolean type\n     * Unwraps ZodOptional and ZodDefault using Zod v4 API\n     */\n    private isSchemaBoolean;\n    /**\n     * Checks if a Zod schema represents an array type\n     * Unwraps ZodOptional and ZodDefault using Zod v4 API\n     */\n    private isSchemaArray;\n}\n//# sourceMappingURL=cli-parser.service.d.mts.map","import type { AnyInjectableType, InjectionToken } from '@navios/core';\nimport { CommanderAdapterService } from './services/commander-adapter.service.mjs';\nimport { CommandRegistryService } from './services/command-registry.service.mjs';\nimport { CliParserService } from './services/cli-parser.service.mjs';\n/**\n * Defines the CLI environment configuration for use with NaviosFactory.\n *\n * This function returns the token mappings needed to configure a CLI application.\n * Use it with `NaviosFactory.create()` to create a CLI application.\n *\n * @returns Environment configuration with token mappings\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 * await app.init()\n *\n * const adapter = app.getAdapter() as AbstractCliAdapterInterface\n * await adapter.run(process.argv)\n * ```\n */\nexport declare function defineCliEnvironment(): {\n    tokens: Map<InjectionToken<any, undefined, false>, AnyInjectableType>;\n};\nexport { CommanderAdapterService, CommandRegistryService, CliParserService };\n//# sourceMappingURL=define-environment.d.mts.map","import { InjectionToken } from '@navios/core';\nimport type { CommanderExecutionContext } from '../interfaces/index.mjs';\n/**\n * Injection token for accessing the current command execution context.\n *\n * Use this token with `inject()` to access the `CommanderExecutionContext` in services\n * that need information about the currently executing command.\n *\n * @example\n * ```typescript\n * import { inject, Injectable } from '@navios/core'\n * import { CommandExecutionContext } from '@navios/commander'\n *\n * @Injectable()\n * class MyService {\n *   private ctx = inject(CommandExecutionContext)\n *\n *   doSomething() {\n *     const commandPath = this.ctx.getCommandPath()\n *     const options = this.ctx.getOptions()\n *     // Use context information...\n *   }\n * }\n * ```\n */\nexport declare const CommandExecutionContext: InjectionToken<CommanderExecutionContext, undefined, false>;\n//# sourceMappingURL=execution-context.token.d.mts.map"],"mappings":"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"}