@navios/commander 1.0.0 → 1.2.0

package/lib/index.d.cts

@@ -1,46 +1,8 @@
-import { AbstractAdapterInterface, AdapterEnvironment, AnyInjectableType, ClassType, ClassTypeWithInstance, InjectionToken, LogLevel, ModuleMetadata, NaviosApplication, NaviosModule, Registry } from "@navios/core";
+import { a as CommandHandler, i as CommandOptions, n as CliModuleOptions, r as Command, t as CliModule } from "./cli-module.decorator-DVl8009Q.cjs";
+import { AbstractAdapterInterface, AdapterEnvironment, 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>;
@@ -182,16 +144,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,168 +268,122 @@ 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
+//#region src/metadata/command.metadata.d.mts
 /**
- * Options for the `@Command` decorator.
+ * @internal
+ * Symbol key used to store command metadata on classes.
+ */
+declare const CommandMetadataKey: unique symbol;
+/**
+ * Metadata associated with a command.
  *
  * @public
  */
-interface CommandOptions {
+interface CommandMetadata {
   /**
-   * 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').
+   * The command path (e.g., 'greet', 'user:create').
    */
   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.
+   * Map of custom attributes that can be attached to the command.
    */
-  registry?: Registry;
+  customAttributes: Map<string | symbol, any>;
 }
 /**
- * Decorator that marks a class as a CLI command.
+ * Gets or creates command metadata for a class.
  *
- * The decorated class must implement the `CommandHandler` interface with an `execute` method.
- * The command will be automatically registered when its module is loaded.
+ * @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 options - Configuration options for the command
- * @returns A class decorator function
+ * @param target - The command class
+ * @returns The command metadata
+ * @throws {Error} If the class is not decorated with @Command
  *
  * @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}!`)
- *   }
- * }
+ * const metadata = extractCommandMetadata(GreetCommand)
+ * console.log(metadata.path) // 'greet'
  * ```
  */
-declare function Command({
-  path,
-  description,
-  optionsSchema,
-  priority,
-  registry
-}: CommandOptions): (target: ClassType, context: ClassDecoratorContext) => ClassType;
+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/decorators/cli-module.decorator.d.mts
+//#region src/interfaces/commander-execution-context.interface.d.mts
 /**
- * Options for the `@CliModule` decorator.
+ * Execution context for a command execution.
  *
- * @public
+ * 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())
+ *   }
+ * }
+ * ```
  */
-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>;
+declare class CommanderExecutionContext {
+  private readonly command;
+  private readonly commandPath;
+  private readonly options;
   /**
-   * Guards to apply to all controllers in this module.
-   * Guards are executed in reverse order (last guard first).
+   * @internal
+   * Creates a new execution context.
    */
-  guards?: ClassType[] | Set<ClassType>;
+  constructor(command: CommandMetadata, commandPath: string, options: any);
   /**
-   * 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.
+   * Gets the command metadata.
+   *
+   * @returns The command metadata including path and options schema
    */
-  overrides?: ClassType[] | Set<ClassType>;
+  getCommand(): CommandMetadata;
   /**
-   * Priority level for the module.
-   * Higher priority modules will be loaded first.
+   * Gets the command path that was invoked.
+   *
+   * @returns The command path (e.g., 'greet', 'user:create')
    */
-  priority?: number;
+  getCommandPath(): string;
   /**
-   * Registry to use for the module.
-   * Registry is used to store the module and its commands.
+   * Gets the validated command options.
+   *
+   * Options are validated against the command's Zod schema if one was provided.
+   *
+   * @returns The validated options object
    */
-  registry?: Registry;
+  getOptions(): any;
 }
-/**
- * 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
 /**
@@ -464,69 +439,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 +660,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 +686,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.cts.map