@navios/commander 0.5.1 → 0.7.0

package/CHANGELOG.md

@@ -0,0 +1,32 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.7.0] - 2025-12-18
+
+### Added
+
+- **Comprehensive JSDoc Documentation**: Added detailed JSDoc comments to all public APIs including:
+  - `CommanderFactory` class and `create` method
+  - `CommanderApplication` class and all methods (`init`, `run`, `executeCommand`, `getAllCommands`, `getContainer`, `close`)
+  - `Command` decorator function and `CommandOptions` interface
+  - `CliModule` decorator function and `CliModuleOptions` interface
+  - `CommandHandler` interface with generic type parameter
+  - `CommanderExecutionContext` class and all methods (`getCommand`, `getCommandPath`, `getOptions`)
+  - `CommandExecutionContext` injection token
+  - `CommandMetadata` and `CliModuleMetadata` interfaces
+  - Metadata utility functions (`getCommandMetadata`, `extractCommandMetadata`, `hasCommandMetadata`, `getCliModuleMetadata`, `extractCliModuleMetadata`, `hasCliModuleMetadata`)
+  - `CliParserService` class and `ParsedCliArgs` interface
+  - `CliModuleLoaderService` class and `CommandWithMetadata` interface
+
+### Documentation
+
+- Complete JSDoc comments for better IDE support and developer experience
+- Enhanced type information and parameter descriptions
+- Added usage examples in JSDoc comments for all public APIs
+- Improved discoverability of API features through comprehensive documentation
+- Updated README to accurately reflect the ExecutionContext API
+

package/README.md

@@ -23,6 +23,7 @@ Commands are defined using the `@Command` decorator. Each command must implement
 
 ```typescript
 import { Command, CommandHandler } from '@navios/commander'
+
 import { z } from 'zod'
 
 const greetOptionsSchema = z.object({
@@ -49,6 +50,7 @@ Modules organize commands and can import other modules:
 
 ```typescript
 import { CliModule } from '@navios/commander'
+
 import { GreetCommand } from './greet.command'
 
 @CliModule({
@@ -63,6 +65,7 @@ Use `CommanderFactory` to create and run your CLI application:
 
 ```typescript
 import { CommanderFactory } from '@navios/commander'
+
 import { AppModule } from './app.module'
 
 async function bootstrap() {
@@ -87,8 +90,9 @@ node dist/cli.js greet --name World --greeting Hi
 ### Advanced Example with Dependency Injection
 
 ```typescript
-import { Command, CommandHandler, CliModule } from '@navios/commander'
-import { Injectable, inject } from '@navios/di'
+import { CliModule, Command, CommandHandler } from '@navios/commander'
+import { inject, Injectable } from '@navios/di'
+
 import { z } from 'zod'
 
 // Service
@@ -108,7 +112,9 @@ const userOptionsSchema = z.object({
   path: 'user:show',
   optionsSchema: userOptionsSchema,
 })
-export class ShowUserCommand implements CommandHandler<z.infer<typeof userOptionsSchema>> {
+export class ShowUserCommand implements CommandHandler<
+  z.infer<typeof userOptionsSchema>
+> {
   private userService = inject(UserService)
 
   async execute(options: { userId: string }) {
@@ -129,6 +135,43 @@ export class UserModule {}
 export class AppModule {}
 ```
 
+### Accessing ExecutionContext
+
+The `ExecutionContext` provides access to the current command execution information, including the module metadata, command metadata, command path, and options. This is useful for middleware, guards, or any service that needs context about the current command execution.
+
+```typescript
+import { Command, CommandHandler, CommandExecutionContext } from '@navios/commander'
+import { inject, Injectable } from '@navios/di'
+
+@Injectable()
+class CommandLogger {
+  private executionContext = inject(CommandExecutionContext)
+
+  logCommandInfo() {
+    const ctx = this.executionContext
+    console.log('Command Path:', ctx.getCommandPath())
+    console.log('Command Options:', ctx.getOptions())
+    console.log('Command Metadata:', ctx.getCommand())
+  }
+}
+
+@Command({ path: 'example' })
+export class ExampleCommand implements CommandHandler {
+  private logger = inject(CommandLogger)
+
+  async execute(options: any) {
+    this.logger.logCommandInfo()
+    // Your command logic here
+  }
+}
+```
+
+The `ExecutionContext` provides the following methods:
+
+- `getCommand()` - Returns the command metadata
+- `getCommandPath()` - Returns the command path (e.g., 'user:create')
+- `getOptions()` - Returns the validated command options
+
 ### Listing All Commands
 
 ```typescript
@@ -150,6 +193,7 @@ For advanced use cases where you need to execute commands programmatically (e.g.
 
 ```typescript
 import { CommanderFactory } from '@navios/commander'
+
 import { AppModule } from './app.module'
 
 async function bootstrap() {
@@ -169,6 +213,7 @@ bootstrap()
 ```
 
 This is useful for:
+
 - Unit and integration testing
 - Building CLI tools that wrap other CLI tools
 - Programmatic automation workflows
@@ -182,6 +227,7 @@ This is useful for:
 Defines a CLI command.
 
 **Options:**
+
 - `path: string` - The command path (e.g., 'user:create', 'db:migrate')
 - `optionsSchema?: ZodSchema` - Optional Zod schema for validating command options
 
@@ -190,6 +236,7 @@ Defines a CLI command.
 Defines a CLI module.
 
 **Options:**
+
 - `commands?: ClassType[]` - Array of command classes
 - `imports?: ClassType[]` - Array of other modules to import
 
@@ -205,14 +252,13 @@ interface CommandHandler<TOptions = any> {
 }
 ```
 
-#### `CliModule`
+#### `Module` (alias for `NaviosModule`)
 
-Optional lifecycle hooks for modules.
+Optional lifecycle hooks for modules. This is an alias for `NaviosModule` from `@navios/core`.
 
 ```typescript
-interface CliModule {
-  onModuleInit?(): void | Promise<void>
-  onModuleDestroy?(): void | Promise<void>
+interface NaviosModule {
+  onModuleInit?: () => Promise<void> | void
 }
 ```
 
@@ -223,6 +269,7 @@ interface CliModule {
 Factory class for creating CLI applications.
 
 **Methods:**
+
 - `static async create(appModule, options?)` - Creates a new CommanderApplication
 
 #### `CommanderApplication`
@@ -230,6 +277,7 @@ Factory class for creating CLI applications.
 Main application class.
 
 **Methods:**
+
 - `async init()` - Initializes the application
 - `async run(argv)` - Parses command-line arguments and executes the appropriate command (default usage)
 - `async executeCommand(path, options?)` - Executes a command programmatically with options (advanced usage)

package/dist/src/commander.application.d.mts

@@ -1,29 +1,147 @@
-import type { ClassTypeWithInstance } from '@navios/di';
-import { Container } from '@navios/di';
-import type { Module } from './interfaces/index.mjs';
+import type { ClassTypeWithInstance, NaviosModule } from '@navios/core';
+import { Container } from '@navios/core';
+/**
+ * Configuration options for CommanderApplication.
+ *
+ * @public
+ */
 export interface CommanderApplicationOptions {
 }
+/**
+ * Main application class for managing CLI command execution.
+ *
+ * This class handles module loading, command registration, and command execution.
+ * It provides both programmatic and CLI-based command execution capabilities.
+ *
+ * @example
+ * ```typescript
+ * const app = await CommanderFactory.create(AppModule)
+ * await app.init()
+ * await app.run(process.argv)
+ * ```
+ */
 export declare class CommanderApplication {
     private moduleLoader;
     private cliParser;
     protected container: Container;
     private appModule;
     private options;
+    /**
+     * Indicates whether the application has been initialized.
+     * Set to `true` after `init()` is called successfully.
+     */
     isInitialized: boolean;
-    setup(appModule: ClassTypeWithInstance<Module>, options?: CommanderApplicationOptions): Promise<void>;
+    /**
+     * @internal
+     * Sets up the application with the provided module and options.
+     * This is called automatically by CommanderFactory.create().
+     */
+    setup(appModule: ClassTypeWithInstance<NaviosModule>, options?: CommanderApplicationOptions): Promise<void>;
+    /**
+     * Gets the dependency injection container used by this application.
+     *
+     * @returns The Container instance
+     *
+     * @example
+     * ```typescript
+     * const container = app.getContainer()
+     * const service = await container.get(MyService)
+     * ```
+     */
     getContainer(): Container;
+    /**
+     * Initializes the application by loading all modules and registering commands.
+     *
+     * This method must be called before executing commands or running the CLI.
+     * It traverses the module tree, loads all imported modules, and collects command metadata.
+     *
+     * @throws {Error} If the app module is not set (setup() was not called)
+     *
+     * @example
+     * ```typescript
+     * const app = await CommanderFactory.create(AppModule)
+     * await app.init() // Must be called before run() or executeCommand()
+     * ```
+     */
     init(): Promise<void>;
+    /**
+     * Executes a command programmatically with the provided options.
+     *
+     * This method is useful for testing, automation, or programmatic workflows.
+     * The options will be validated against the command's Zod schema if one is provided.
+     *
+     * @param commandPath - The command path (e.g., 'greet', 'user:create')
+     * @param options - The command options object (will be validated if schema exists)
+     * @throws {Error} If the application is not initialized
+     * @throws {Error} If the command is not found
+     * @throws {Error} If the command does not implement the execute method
+     * @throws {ZodError} If options validation fails
+     *
+     * @example
+     * ```typescript
+     * await app.executeCommand('greet', {
+     *   name: 'World',
+     *   greeting: 'Hi'
+     * })
+     * ```
+     */
     executeCommand(commandPath: string, options?: any): Promise<void>;
+    /**
+     * Gets all registered commands with their paths and class references.
+     *
+     * @returns An array of objects containing the command path and class
+     *
+     * @example
+     * ```typescript
+     * const commands = app.getAllCommands()
+     * commands.forEach(({ path }) => {
+     *   console.log(`Available: ${path}`)
+     * })
+     * ```
+     */
     getAllCommands(): {
         path: string;
         class: ClassTypeWithInstance<any>;
     }[];
     /**
-     * Runs the CLI application by parsing process.argv and executing the command
-     * @param argv - Command-line arguments (defaults to process.argv)
+     * Runs the CLI application by parsing command-line arguments and executing the appropriate command.
+     *
+     * This is the main entry point for CLI usage. It parses `argv`, validates options,
+     * and executes the matching command. Supports help command (`help`, `--help`, `-h`)
+     * which displays all available commands.
+     *
+     * @param argv - Command-line arguments array (defaults to `process.argv`)
+     * @throws {Error} If the application is not initialized
+     * @throws {Error} If no command is provided
+     * @throws {Error} If the command is not found
+     * @throws {ZodError} If options validation fails
+     *
+     * @example
+     * ```typescript
+     * // Parse and execute from process.argv
+     * await app.run()
+     *
+     * // Or provide custom arguments
+     * await app.run(['node', 'cli.js', 'greet', '--name', 'World'])
+     * ```
      */
     run(argv?: string[]): Promise<void>;
+    /**
+     * @internal
+     * Disposes of resources used by the application.
+     */
     dispose(): Promise<void>;
+    /**
+     * Closes the application and cleans up resources.
+     *
+     * This should be called when the application is no longer needed to free up resources.
+     *
+     * @example
+     * ```typescript
+     * await app.run(process.argv)
+     * await app.close()
+     * ```
+     */
     close(): Promise<void>;
 }
 //# sourceMappingURL=commander.application.d.mts.map

package/dist/src/commander.application.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"commander.application.d.mts","sourceRoot":"","sources":["../../src/commander.application.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAkB,MAAM,YAAY,CAAA;AAEvE,OAAO,EAAE,SAAS,EAAsB,MAAM,YAAY,CAAA;AAE1D,OAAO,KAAK,EAAkB,MAAM,EAAE,MAAM,wBAAwB,CAAA;AAIpE,MAAM,WAAW,2BAA2B;CAAG;AAE/C,qBACa,oBAAoB;IAC/B,OAAO,CAAC,YAAY,CAA8B;IAClD,OAAO,CAAC,SAAS,CAA2B;IAC5C,SAAS,CAAC,SAAS,YAAoB;IAEvC,OAAO,CAAC,SAAS,CAA6C;IAC9D,OAAO,CAAC,OAAO,CAAkC;IAEjD,aAAa,UAAQ;IAEf,KAAK,CACT,SAAS,EAAE,qBAAqB,CAAC,MAAM,CAAC,EACxC,OAAO,GAAE,2BAAgC;IAM3C,YAAY;IAIN,IAAI;IAUJ,cAAc,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,GAAE,GAAQ;IAoC3D,cAAc;cAIJ,MAAM;eACL,qBAAqB,CAAC,GAAG,CAAC;;IAarC;;;OAGG;IACG,GAAG,CAAC,IAAI,GAAE,MAAM,EAAiB;IAgDjC,OAAO;IAMP,KAAK;CAGZ"}
+{"version":3,"file":"commander.application.d.mts","sourceRoot":"","sources":["../../src/commander.application.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,qBAAqB,EAErB,YAAY,EACb,MAAM,cAAc,CAAA;AAErB,OAAO,EAAE,SAAS,EAAsB,MAAM,cAAc,CAAA;AAQ5D;;;;GAIG;AACH,MAAM,WAAW,2BAA2B;CAAG;AAE/C;;;;;;;;;;;;GAYG;AACH,qBACa,oBAAoB;IAC/B,OAAO,CAAC,YAAY,CAAiC;IACrD,OAAO,CAAC,SAAS,CAA2B;IAC5C,SAAS,CAAC,SAAS,YAAoB;IAEvC,OAAO,CAAC,SAAS,CAAmD;IACpE,OAAO,CAAC,OAAO,CAAkC;IAEjD;;;OAGG;IACH,aAAa,UAAQ;IAErB;;;;OAIG;IACG,KAAK,CACT,SAAS,EAAE,qBAAqB,CAAC,YAAY,CAAC,EAC9C,OAAO,GAAE,2BAAgC;IAM3C;;;;;;;;;;OAUG;IACH,YAAY;IAIZ;;;;;;;;;;;;;OAaG;IACG,IAAI;IAUV;;;;;;;;;;;;;;;;;;;;OAoBG;IACG,cAAc,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,GAAE,GAAQ;IAuD3D;;;;;;;;;;;;OAYG;IACH,cAAc;cAIJ,MAAM;eACL,qBAAqB,CAAC,GAAG,CAAC;;IAarC;;;;;;;;;;;;;;;;;;;;;OAqBG;IACG,GAAG,CAAC,IAAI,GAAE,MAAM,EAAiB;IAgDvC;;;OAGG;IACG,OAAO;IAMb;;;;;;;;;;OAUG;IACG,KAAK;CAGZ"}

package/dist/src/commander.factory.d.mts

@@ -1,8 +1,36 @@
-import type { ClassTypeWithInstance } from '@navios/di';
+import type { ClassTypeWithInstance, NaviosModule } from '@navios/core';
 import type { CommanderApplicationOptions } from './commander.application.mjs';
-import type { Module } from './interfaces/index.mjs';
 import { CommanderApplication } from './commander.application.mjs';
+/**
+ * Factory class for creating and configuring CLI applications.
+ *
+ * @example
+ * ```typescript
+ * import { CommanderFactory } from '@navios/commander'
+ * import { AppModule } from './app.module'
+ *
+ * async function bootstrap() {
+ *   const app = await CommanderFactory.create(AppModule)
+ *   await app.init()
+ *   await app.run(process.argv)
+ *   await app.close()
+ * }
+ * ```
+ */
 export declare class CommanderFactory {
-    static create(appModule: ClassTypeWithInstance<Module>, options?: CommanderApplicationOptions): Promise<CommanderApplication>;
+    /**
+     * Creates a new CommanderApplication instance and configures it with the provided module.
+     *
+     * @param appModule - The root CLI module class that contains commands and/or imports other modules
+     * @param options - Optional configuration options for the application
+     * @returns A promise that resolves to a configured CommanderApplication instance
+     *
+     * @example
+     * ```typescript
+     * const app = await CommanderFactory.create(AppModule)
+     * await app.init()
+     * ```
+     */
+    static create(appModule: ClassTypeWithInstance<NaviosModule>, options?: CommanderApplicationOptions): Promise<CommanderApplication>;
 }
 //# sourceMappingURL=commander.factory.d.mts.map

package/dist/src/commander.factory.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"commander.factory.d.mts","sourceRoot":"","sources":["../../src/commander.factory.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAA;AAIvD,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,6BAA6B,CAAA;AAC9E,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAA;AAEpD,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAElE,qBAAa,gBAAgB;WACd,MAAM,CACjB,SAAS,EAAE,qBAAqB,CAAC,MAAM,CAAC,EACxC,OAAO,GAAE,2BAAgC;CAO5C"}
+{"version":3,"file":"commander.factory.d.mts","sourceRoot":"","sources":["../../src/commander.factory.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAIvE,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,6BAA6B,CAAA;AAE9E,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAElE;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,gBAAgB;IAC3B;;;;;;;;;;;;OAYG;WACU,MAAM,CACjB,SAAS,EAAE,qBAAqB,CAAC,YAAY,CAAC,EAC9C,OAAO,GAAE,2BAAgC;CAO5C"}

package/dist/src/decorators/cli-module.decorator.d.mts

@@ -1,7 +1,42 @@
-import type { ClassType } from '@navios/di';
+import type { ClassType } from '@navios/core';
+/**
+ * Options for the `@CliModule` decorator.
+ *
+ * @public
+ */
 export 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 other CLI modules to import.
+     * Imported modules' commands will be available in this module.
+     */
     imports?: ClassType[] | Set<ClassType>;
 }
+/**
+ * Decorator that marks a class as a CLI module.
+ *
+ * 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 {}
+ * ```
+ */
 export declare function CliModule({ commands, imports }?: CliModuleOptions): (target: ClassType, context: ClassDecoratorContext) => ClassType;
 //# sourceMappingURL=cli-module.decorator.d.mts.map

package/dist/src/decorators/cli-module.decorator.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"cli-module.decorator.d.mts","sourceRoot":"","sources":["../../../src/decorators/cli-module.decorator.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AAM3C,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,EAAE,SAAS,EAAE,GAAG,GAAG,CAAC,SAAS,CAAC,CAAA;IACvC,OAAO,CAAC,EAAE,SAAS,EAAE,GAAG,GAAG,CAAC,SAAS,CAAC,CAAA;CACvC;AAED,wBAAgB,SAAS,CACvB,EAAE,QAAa,EAAE,OAAY,EAAE,GAAE,gBAGhC,IAEO,QAAQ,SAAS,EAAE,SAAS,qBAAqB,eAqB1D"}
+{"version":3,"file":"cli-module.decorator.d.mts","sourceRoot":"","sources":["../../../src/decorators/cli-module.decorator.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAM7C;;;;GAIG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;;OAGG;IACH,QAAQ,CAAC,EAAE,SAAS,EAAE,GAAG,GAAG,CAAC,SAAS,CAAC,CAAA;IACvC;;;OAGG;IACH,OAAO,CAAC,EAAE,SAAS,EAAE,GAAG,GAAG,CAAC,SAAS,CAAC,CAAA;CACvC;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,SAAS,CACvB,EAAE,QAAa,EAAE,OAAY,EAAE,GAAE,gBAGhC,IAEO,QAAQ,SAAS,EAAE,SAAS,qBAAqB,eAqB1D"}

package/dist/src/decorators/command.decorator.d.mts

@@ -1,8 +1,51 @@
-import type { ClassType } from '@navios/di';
+import type { ClassType } from '@navios/core';
 import type { ZodObject } from 'zod';
+/**
+ * Options for the `@Command` decorator.
+ *
+ * @public
+ */
 export 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 Zod schema for validating command options.
+     * If provided, options will be validated and parsed according to this schema.
+     */
     optionsSchema?: ZodObject;
 }
+/**
+ * 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}!`)
+ *   }
+ * }
+ * ```
+ */
 export declare function Command({ path, optionsSchema }: CommandOptions): (target: ClassType, context: ClassDecoratorContext) => ClassType;
 //# sourceMappingURL=command.decorator.d.mts.map

package/dist/src/decorators/command.decorator.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"command.decorator.d.mts","sourceRoot":"","sources":["../../../src/decorators/command.decorator.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AAC3C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,KAAK,CAAA;AAMpC,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAA;IACZ,aAAa,CAAC,EAAE,SAAS,CAAA;CAC1B;AAED,wBAAgB,OAAO,CAAC,EAAE,IAAI,EAAE,aAAa,EAAE,EAAE,cAAc,IAC5C,QAAQ,SAAS,EAAE,SAAS,qBAAqB,eAenE"}
+{"version":3,"file":"command.decorator.d.mts","sourceRoot":"","sources":["../../../src/decorators/command.decorator.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAC7C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,KAAK,CAAA;AAMpC;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC7B;;;OAGG;IACH,IAAI,EAAE,MAAM,CAAA;IACZ;;;OAGG;IACH,aAAa,CAAC,EAAE,SAAS,CAAA;CAC1B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,OAAO,CAAC,EAAE,IAAI,EAAE,aAAa,EAAE,EAAE,cAAc,IAC5C,QAAQ,SAAS,EAAE,SAAS,qBAAqB,eAenE"}

package/dist/src/index.d.mts

@@ -1,8 +1,9 @@
-export * from '@navios/di';
+export * from '@navios/core';
 export * from './commander.application.mjs';
 export * from './commander.factory.mjs';
 export * from './decorators/index.mjs';
 export * from './interfaces/index.mjs';
 export * from './metadata/index.mjs';
 export * from './services/index.mjs';
+export * from './tokens/index.mjs';
 //# sourceMappingURL=index.d.mts.map

package/dist/src/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../src/index.mts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAA;AAC1B,cAAc,6BAA6B,CAAA;AAC3C,cAAc,yBAAyB,CAAA;AACvC,cAAc,wBAAwB,CAAA;AACtC,cAAc,wBAAwB,CAAA;AACtC,cAAc,sBAAsB,CAAA;AACpC,cAAc,sBAAsB,CAAA"}
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../src/index.mts"],"names":[],"mappings":"AACA,cAAc,cAAc,CAAA;AAG5B,cAAc,6BAA6B,CAAA;AAC3C,cAAc,yBAAyB,CAAA;AACvC,cAAc,wBAAwB,CAAA;AACtC,cAAc,wBAAwB,CAAA;AACtC,cAAc,sBAAsB,CAAA;AACpC,cAAc,sBAAsB,CAAA;AACpC,cAAc,oBAAoB,CAAA"}

package/dist/src/interfaces/command-handler.interface.d.mts

@@ -1,4 +1,37 @@
+/**
+ * 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}!`)
+ *   }
+ * }
+ * ```
+ */
 export 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>;
 }
 //# sourceMappingURL=command-handler.interface.d.mts.map

package/dist/src/interfaces/command-handler.interface.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"command-handler.interface.d.mts","sourceRoot":"","sources":["../../../src/interfaces/command-handler.interface.mts"],"names":[],"mappings":"AAAA,MAAM,WAAW,cAAc,CAAC,QAAQ,GAAG,GAAG;IAC5C,OAAO,CAAC,OAAO,EAAE,QAAQ,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CACjD"}
+{"version":3,"file":"command-handler.interface.d.mts","sourceRoot":"","sources":["../../../src/interfaces/command-handler.interface.mts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,WAAW,cAAc,CAAC,QAAQ,GAAG,GAAG;IAC5C;;;;;OAKG;IACH,OAAO,CAAC,OAAO,EAAE,QAAQ,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CACjD"}

package/dist/src/interfaces/commander-execution-context.interface.d.mts

@@ -0,0 +1,54 @@
+import type { CommandMetadata } from '../metadata/command.metadata.mjs';
+/**
+ * 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/di'
+ * 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())
+ *   }
+ * }
+ * ```
+ */
+export 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;
+}
+//# sourceMappingURL=commander-execution-context.interface.d.mts.map

package/dist/src/interfaces/commander-execution-context.interface.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commander-execution-context.interface.d.mts","sourceRoot":"","sources":["../../../src/interfaces/commander-execution-context.interface.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAA;AAEvE;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBAAa,yBAAyB;IAMlC,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,WAAW;IAC5B,OAAO,CAAC,QAAQ,CAAC,OAAO;IAP1B;;;OAGG;gBAEgB,OAAO,EAAE,eAAe,EACxB,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,GAAG;IAG/B;;;;OAIG;IACH,UAAU,IAAI,eAAe;IAI7B;;;;OAIG;IACH,cAAc,IAAI,MAAM;IAIxB;;;;;;OAMG;IACH,UAAU,IAAI,GAAG;CAGlB"}

package/dist/src/interfaces/index.d.mts

@@ -1,3 +1,3 @@
-export * from './module.interface.mjs';
 export * from './command-handler.interface.mjs';
+export * from './commander-execution-context.interface.mjs';
 //# sourceMappingURL=index.d.mts.map

package/dist/src/interfaces/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../../src/interfaces/index.mts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAA;AACtC,cAAc,iCAAiC,CAAA"}
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../../src/interfaces/index.mts"],"names":[],"mappings":"AAAA,cAAc,iCAAiC,CAAA;AAC/C,cAAc,6CAA6C,CAAA"}

package/dist/src/interfaces/module.interface.d.mts

@@ -1,5 +1,2 @@
-export interface Module {
-    onModuleInit?(): void | Promise<void>;
-    onModuleDestroy?(): void | Promise<void>;
-}
+export type { NaviosModule as Module } from '@navios/core';
 //# sourceMappingURL=module.interface.d.mts.map

package/dist/src/interfaces/module.interface.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"module.interface.d.mts","sourceRoot":"","sources":["../../../src/interfaces/module.interface.mts"],"names":[],"mappings":"AAAA,MAAM,WAAW,MAAM;IACrB,YAAY,CAAC,IAAI,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IACrC,eAAe,CAAC,IAAI,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CACzC"}
+{"version":3,"file":"module.interface.d.mts","sourceRoot":"","sources":["../../../src/interfaces/module.interface.mts"],"names":[],"mappings":"AACA,YAAY,EAAE,YAAY,IAAI,MAAM,EAAE,MAAM,cAAc,CAAA"}