@navios/commander 1.0.0 → 1.2.0

package/lib/cli-module.decorator-CkP22084.cjs

@@ -0,0 +1,71 @@
+const require_command_decorator = require('./command.decorator-UrNJmQN0.cjs');
+let _navios_core = require("@navios/core");
+
+//#region src/decorators/cli-module.decorator.mts
+/**
+* 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 {}
+* ```
+*/ function CliModule({ commands = [], controllers = [], imports = [], guards = [], overrides = [], priority, registry } = {
+	commands: [],
+	controllers: [],
+	imports: [],
+	guards: [],
+	overrides: []
+}) {
+	return (target, context) => {
+		if (context.kind !== "class") throw new Error("[Navios Commander] @CliModule decorator can only be used on classes.");
+		const result = (0, _navios_core.Module)({
+			controllers,
+			imports,
+			guards,
+			overrides,
+			priority,
+			registry
+		})(target, context);
+		const commandSet = (0, _navios_core.getModuleCustomEntry)((0, _navios_core.getModuleMetadata)(target, context), require_command_decorator.CommandEntryKey, () => /* @__PURE__ */ new Set());
+		for (const command of commands) commandSet.add(command);
+		return result;
+	};
+}
+
+//#endregion
+Object.defineProperty(exports, 'CliModule', {
+  enumerable: true,
+  get: function () {
+    return CliModule;
+  }
+});
+//# sourceMappingURL=cli-module.decorator-CkP22084.cjs.map

package/lib/cli-module.decorator-CkP22084.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli-module.decorator-CkP22084.cjs","names":["Module","getModuleMetadata","getModuleCustomEntry","CommandEntryKey","CliModule","commands","controllers","imports","guards","overrides","priority","registry","target","context","kind","Error","result","metadata","commandSet","Set","command","add"],"sources":["../src/decorators/cli-module.decorator.mts"],"sourcesContent":["import type { ClassType, Registry } from '@navios/core'\n\nimport { Module, getModuleMetadata, getModuleCustomEntry } from '@navios/core'\n\nimport {\n  CommandEntryKey,\n  type CommandEntryValue,\n} from '../metadata/command-entry.metadata.mjs'\n\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/**\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 function CliModule(\n  {\n    commands = [],\n    controllers = [],\n    imports = [],\n    guards = [],\n    overrides = [],\n    priority,\n    registry,\n  }: CliModuleOptions = {\n    commands: [],\n    controllers: [],\n    imports: [],\n    guards: [],\n    overrides: [],\n  },\n) {\n  return (target: ClassType, context: ClassDecoratorContext) => {\n    if (context.kind !== 'class') {\n      throw new Error(\n        '[Navios Commander] @CliModule decorator can only be used on classes.',\n      )\n    }\n\n    // Apply standard @Module decorator first\n    const result = Module({\n      controllers,\n      imports,\n      guards,\n      overrides,\n      priority,\n      registry,\n    })(target, context)\n\n    // Get the module metadata that @Module just created\n    const metadata = getModuleMetadata(target, context)\n\n    // Store commands in customEntries\n    const commandSet = getModuleCustomEntry<CommandEntryValue>(\n      metadata,\n      CommandEntryKey,\n      () => new Set(),\n    )\n    for (const command of commands) {\n      commandSet.add(command)\n    }\n\n    return result\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2FA,SAAgBI,UACd,EACEC,WAAW,EAAE,EACbC,cAAc,EAAE,EAChBC,UAAU,EAAE,EACZC,SAAS,EAAE,EACXC,YAAY,EAAE,EACdC,UACAC,aACoB;CACpBN,UAAU,EAAE;CACZC,aAAa,EAAE;CACfC,SAAS,EAAE;CACXC,QAAQ,EAAE;CACVC,WAAW,EAAE;CACd,EAAA;AAED,SAAQG,QAAmBC,YAAAA;AACzB,MAAIA,QAAQC,SAAS,QACnB,OAAM,IAAIC,MACR,uEAAA;EAKJ,MAAMC,kCAAgB;GACpBV;GACAC;GACAC;GACAC;GACAC;GACAC;GACF,CAAA,CAAGC,QAAQC,QAAAA;EAMX,MAAMK,wFAH6BN,QAAQC,QAAAA,EAKzCV,iEACM,IAAIgB,KAAAA,CAAAA;AAEZ,OAAK,MAAMC,WAAWf,SACpBa,YAAWG,IAAID,QAAAA;AAGjB,SAAOJ"}

package/lib/cli-module.decorator-DGuGfpex.d.mts

@@ -0,0 +1,411 @@
+import { AbstractAdapterInterface, AdapterEnvironment, ClassType, ClassTypeWithInstance, InjectionToken, Registry } from "@navios/core";
+import { ZodObject } from "zod";
+
+//#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/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/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/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/decorators/command.decorator.d.mts
+/**
+ * Options for the `@Command` decorator.
+ *
+ * @public
+ */
+interface CommandOptions {
+  /**
+   * The token to use for the command.
+   * If provided, the command will be registered with this token.
+   */
+  token?: InjectionToken<ClassTypeWithInstance<CommandHandler<any>>>;
+  /**
+   * 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,
+  token,
+  optionsSchema,
+  priority,
+  registry
+}: CommandOptions): (target: ClassType, context: ClassDecoratorContext) => any;
+//#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
+export { CommanderExecutionContext as a, extractCommandMetadata as c, CliAdapterOptions as d, CliEnvironment as f, CommandOptions as i, getCommandMetadata as l, CommandHandler as m, CliModuleOptions as n, CommandMetadata as o, AbstractCliAdapterInterface as p, Command as r, CommandMetadataKey as s, CliModule as t, hasCommandMetadata as u };
+//# sourceMappingURL=cli-module.decorator-DGuGfpex.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cli-module.decorator-DGuGfpex.d.mts","names":["CommandHandler","TOptions","Promise","AbstractAdapterInterface","AbstractCliAdapterInterface","Promise","Record","Array","AdapterEnvironment","AbstractCliAdapterInterface","CliAdapterOptions","CliEnvironment","ClassType","ZodObject","CommandMetadataKey","CommandMetadata","Map","getCommandMetadata","ClassDecoratorContext","extractCommandMetadata","hasCommandMetadata","CommandMetadata","CommanderExecutionContext","InjectionToken","ClassType","ClassTypeWithInstance","Registry","ZodObject","CommandHandler","CommandOptions","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'\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 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 { 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 { 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 { ClassType, ClassTypeWithInstance, Registry } from '@navios/core';\nimport type { ZodObject } from 'zod';\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 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, token, optionsSchema, priority, registry, }: CommandOptions): (target: ClassType, context: ClassDecoratorContext) => any;\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"],"mappings":"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"}