@navios/commander 1.0.0 → 1.2.0

package/lib/legacy-compat/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":["createClassContext","Command","OriginalCommand","options","target","context","originalDecorator","createClassContext","CliModule","OriginalCliModule","options","commands","controllers","imports","guards","overrides","target","context","originalDecorator"],"sources":["../../../../node_modules/@navios/di/lib/legacy-compat/index.mjs","../../src/legacy-compat/decorators/command.decorator.mts","../../src/legacy-compat/decorators/cli-module.decorator.mts"],"sourcesContent":["import { t as Injectable$1 } from \"../injectable.decorator-CyPrBzBN.mjs\";\nimport { t as Factory$1 } from \"../factory.decorator-_IPWcwQn.mjs\";\n\n//#region src/legacy-compat/context-compat.mts\n/**\n* Compatibility layer for converting legacy decorator signatures to Stage 3 format.\n*\n* This module provides utilities to create mock Stage 3 decorator contexts\n* from legacy decorator arguments, and manages metadata storage using WeakMap.\n*/ const classMetadataMap = /* @__PURE__ */ new WeakMap();\n/**\n* Gets the constructor from a prototype (for method decorators).\n*/ function getConstructor(prototype) {\n\tif (!prototype || typeof prototype !== \"object\") return null;\n\tconst constructor = prototype.constructor;\n\tif (constructor && typeof constructor === \"function\") return constructor;\n\treturn null;\n}\n/**\n* Creates a mock ClassDecoratorContext for legacy class decorators.\n* @internal\n*/ function createClassContext(target) {\n\tif (!classMetadataMap.has(target)) classMetadataMap.set(target, {});\n\tconst metadata = classMetadataMap.get(target);\n\treturn {\n\t\tkind: \"class\",\n\t\tname: target.name,\n\t\tmetadata,\n\t\taddInitializer() {}\n\t};\n}\n/**\n* Creates a mock ClassMethodDecoratorContext for legacy method decorators.\n*\n* Note: Method decorators need to share metadata with the class context\n* because endpoint metadata is stored at the class level.\n* @internal\n*/ function createMethodContext(target, propertyKey, descriptor) {\n\tconst constructor = getConstructor(target);\n\tif (!constructor) throw new Error(\"[Navios] Could not determine class constructor from method decorator target.\");\n\tif (!classMetadataMap.has(constructor)) classMetadataMap.set(constructor, {});\n\treturn {\n\t\tkind: \"method\",\n\t\tname: propertyKey,\n\t\tmetadata: classMetadataMap.get(constructor),\n\t\tstatic: false,\n\t\tprivate: false,\n\t\taccess: {\n\t\t\thas: () => true,\n\t\t\tget: () => descriptor.value,\n\t\t\tset: () => {}\n\t\t},\n\t\taddInitializer() {}\n\t};\n}\n\n//#endregion\n//#region src/legacy-compat/injectable.decorator.mts\n/**\n* Legacy-compatible Injectable decorator.\n*\n* Works with TypeScript experimental decorators (legacy API).\n*\n* @param options - Injectable configuration options\n* @returns A class decorator compatible with legacy decorator API\n*\n* @example\n* ```typescript\n* @Injectable()\n* export class UserService {\n*   getUser(id: string) {\n*     return { id, name: 'John' }\n*   }\n* }\n* ```\n*/ function Injectable(options = {}) {\n\treturn function(target) {\n\t\tconst context = createClassContext(target);\n\t\treturn (Object.keys(options).length === 0 ? Injectable$1() : Injectable$1(options))(target, context);\n\t};\n}\n\n//#endregion\n//#region src/legacy-compat/factory.decorator.mts\n/**\n* Legacy-compatible Factory decorator.\n*\n* Works with TypeScript experimental decorators (legacy API).\n*\n* @param options - Factory configuration options\n* @returns A class decorator compatible with legacy decorator API\n*\n* @example\n* ```typescript\n* @Factory()\n* export class DatabaseConnectionFactory {\n*   create() {\n*     return { host: 'localhost', port: 5432 }\n*   }\n* }\n* ```\n*/ function Factory(options = {}) {\n\treturn function(target) {\n\t\tconst context = createClassContext(target);\n\t\treturn (Object.keys(options).length === 0 ? Factory$1() : Factory$1(options))(target, context);\n\t};\n}\n\n//#endregion\nexport { Factory, Injectable, createClassContext, createMethodContext };\n//# sourceMappingURL=index.mjs.map","import type { ClassType } from '@navios/core'\nimport { createClassContext } from '@navios/di/legacy-compat'\n\nimport {\n  Command as OriginalCommand,\n  type CommandOptions,\n} from '../../decorators/command.decorator.mjs'\n\nexport type { CommandOptions }\n\n/**\n * Legacy-compatible Command decorator.\n *\n * Works with TypeScript experimental decorators (legacy API).\n *\n * @param options - Command configuration options\n * @returns A class decorator compatible with legacy decorator API\n *\n * @example\n * ```typescript\n * import { Command, CommandHandler } from '@navios/commander/legacy-compat'\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 function Command(options: CommandOptions) {\n  return function (target: ClassType) {\n    const context = createClassContext(target)\n    const originalDecorator = OriginalCommand(options)\n    return originalDecorator(target, context)\n  }\n}\n","import type { ClassType } from '@navios/core'\nimport { createClassContext } from '@navios/di/legacy-compat'\n\nimport {\n  CliModule as OriginalCliModule,\n  type CliModuleOptions,\n} from '../../decorators/cli-module.decorator.mjs'\n\nexport type { CliModuleOptions }\n\n/**\n * Legacy-compatible CliModule decorator.\n *\n * Works with TypeScript experimental decorators (legacy API).\n *\n * @param options - CLI module configuration options\n * @returns A class decorator compatible with legacy decorator API\n *\n * @example\n * ```typescript\n * import { CliModule } from '@navios/commander/legacy-compat'\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 */\nexport function CliModule(\n  options: CliModuleOptions = {\n    commands: [],\n    controllers: [],\n    imports: [],\n    guards: [],\n    overrides: [],\n  },\n) {\n  return function (target: ClassType) {\n    const context = createClassContext(target)\n    const originalDecorator = OriginalCliModule(options)\n    return originalDecorator(target, context)\n  }\n}\n"],"x_google_ignoreList":[0],"mappings":";;;;;;;;;;;GASG,MAAM,mCAAmC,IAAI,SAAS;;;;GAYtD,SAAS,mBAAmB,QAAQ;AACtC,KAAI,CAAC,iBAAiB,IAAI,OAAO,CAAE,kBAAiB,IAAI,QAAQ,EAAE,CAAC;CACnE,MAAM,WAAW,iBAAiB,IAAI,OAAO;AAC7C,QAAO;EACN,MAAM;EACN,MAAM,OAAO;EACb;EACA,iBAAiB;EACjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GCUF,SAAgBC,QAAQE,SAAuB;AAC7C,QAAO,SAAUC,QAAiB;EAChC,MAAMC,UAAUL,mBAAmBI,OAAAA;AAEnC,SAD0BF,UAAgBC,QAAAA,CACjBC,QAAQC,QAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GCZrC,SAAgBG,UACdE,UAA4B;CAC1BC,UAAU,EAAE;CACZC,aAAa,EAAE;CACfC,SAAS,EAAE;CACXC,QAAQ,EAAE;CACVC,WAAW,EAAE;CACd,EAAA;AAED,QAAO,SAAUC,QAAiB;EAChC,MAAMC,UAAUV,mBAAmBS,OAAAA;AAEnC,SAD0BP,YAAkBC,QAAAA,CACnBM,QAAQC,QAAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@navios/commander",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "author": {
     "name": "Oleksandr Hanzha",
     "email": "alex@granted.name"
@@ -8,12 +8,18 @@
   "repository": {
     "directory": "packages/commander",
     "type": "git",
-    "url": "https://github.com/Arilas/navios.git"
+    "url": "https://github.com/navios-org/commander.git"
   },
   "license": "MIT",
   "peerDependencies": {
+    "@navios/commander-tui": "^1.0.0",
     "zod": "^4.0.0"
   },
+  "peerDependenciesMeta": {
+    "@navios/commander-tui": {
+      "optional": true
+    }
+  },
   "typings": "./lib/index.d.mts",
   "main": "./lib/index.cjs",
   "module": "./lib/index.mjs",
@@ -27,12 +33,23 @@
         "types": "./lib/index.d.cts",
         "default": "./lib/index.cjs"
       }
+    },
+    "./legacy-compat": {
+      "import": {
+        "types": "./lib/legacy-compat/index.d.mts",
+        "default": "./lib/legacy-compat/index.mjs"
+      },
+      "require": {
+        "types": "./lib/legacy-compat/index.d.cts",
+        "default": "./lib/legacy-compat/index.cjs"
+      }
     }
   },
   "devDependencies": {
+    "@navios/builder": "^1.0.0",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3",
-    "zod": "^4.2.1"
+    "zod": "^4.3.5"
   },
   "dependencies": {
     "@navios/core": "^1.0.0"

package/src/commander.factory.mts

@@ -1,16 +1,11 @@
-import type {
-  ClassTypeWithInstance,
-  LogLevel,
-  NaviosApplication,
-  NaviosModule,
-} from '@navios/core'
-
 import { ConsoleLogger, NaviosFactory } from '@navios/core'
 
-import type { CliEnvironment } from './interfaces/environment.interface.mjs'
+import type { ClassTypeWithInstance, LogLevel, NaviosApplication, NaviosModule } from '@navios/core'
 
 import { defineCliEnvironment } from './define-environment.mjs'
 
+import type { CliEnvironment } from './interfaces/environment.interface.mjs'
+
 /**
  * Logger display options for CLI applications.
  * All options default to false for cleaner CLI output.
@@ -55,16 +50,76 @@ export interface CommanderLoggerOptions {
   showTimeDiff?: boolean
 }
 
+/**
+ * TUI-specific options for terminal UI mode.
+ * Only used when enableTUI is true.
+ *
+ * @public
+ */
+export 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
  */
 export 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
 }
 
 /**
@@ -122,6 +177,50 @@ export class CommanderFactory {
     appModule: ClassTypeWithInstance<TModule>,
     options: CommanderFactoryOptions = {},
   ): Promise<NaviosApplication<CliEnvironment>> {
+    if (options.enableTUI) {
+      // Dynamic import to keep commander-tui as optional peer dependency
+      let tuiModule: typeof import('@navios/commander-tui')
+      try {
+        tuiModule = await import('@navios/commander-tui')
+      } catch {
+        throw new Error(
+          'TUI mode requires @navios/commander-tui package. ' +
+            'Install it with: npm install @navios/commander-tui',
+        )
+      }
+
+      const { overrideConsoleLogger, ScreenManager } = tuiModule
+
+      // Override the ConsoleLogger service to use the ScreenLogger service instead of the default ConsoleLogger service.
+      overrideConsoleLogger(options.tuiOptions?.hideDefaultScreen ?? false)
+
+      if (options.tuiOptions?.hideDefaultScreen) {
+        // Import the help command override to ensure it is registered
+        await import('./overrides/help.command.mjs')
+      }
+      // Create app without custom logger - TUI override handles it
+      const app = await NaviosFactory.create<CliEnvironment>(appModule, {
+        adapter: defineCliEnvironment(),
+        logger: options.logLevels,
+      })
+
+      // Get screen manager and bind TUI before returning
+      const screenManager = await app.get(ScreenManager)
+      await screenManager.bind({
+        exitOnCtrlC: options.tuiOptions?.exitOnCtrlC,
+        sidebarWidth: options.tuiOptions?.sidebarWidth,
+        sidebarPosition: options.tuiOptions?.sidebarPosition,
+        sidebarTitle: options.tuiOptions?.sidebarTitle,
+        autoClose: options.tuiOptions?.autoClose,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        theme: options.tuiOptions?.theme as any,
+        useMouse: options.tuiOptions?.useMouse,
+      })
+
+      return app
+    }
+
+    // Standard (non-TUI) mode - existing behavior unchanged
     const app = await NaviosFactory.create<CliEnvironment>(appModule, {
       adapter: defineCliEnvironment(),
       logger: ConsoleLogger.create({

package/src/commands/help.command.mts

@@ -1,11 +1,11 @@
 import { inject, Logger } from '@navios/core'
-
 import { z } from 'zod'
 
-import type { CommandHandler } from '../interfaces/command-handler.interface.mjs'
-
 import { Command } from '../decorators/command.decorator.mjs'
 import { CommandRegistryService } from '../services/command-registry.service.mjs'
+import { HelpCommandToken } from '../tokens/help-command.token.mjs'
+
+import type { CommandHandler } from '../interfaces/command-handler.interface.mjs'
 
 const helpOptionsSchema = z.object({
   command: z.string().optional(),
@@ -19,6 +19,7 @@ type HelpOptions = z.infer<typeof helpOptionsSchema>
  * @public
  */
 @Command({
+  token: HelpCommandToken,
   path: 'help',
   description: 'Show available commands or help for a specific command',
   optionsSchema: helpOptionsSchema,

package/src/decorators/command.decorator.mts

@@ -1,16 +1,23 @@
-import type { ClassType, Registry } from '@navios/core'
-import type { ZodObject } from 'zod'
-
 import { Injectable, InjectableScope, InjectionToken } from '@navios/core'
 
+import type { ClassType, ClassTypeWithInstance, Registry } from '@navios/core'
+import type { ZodObject } from 'zod'
+
 import { getCommandMetadata } from '../metadata/index.mjs'
 
+import type { CommandHandler } from '../interfaces/index.mjs'
+
 /**
  * Options for the `@Command` decorator.
  *
  * @public
  */
 export 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').
@@ -71,22 +78,24 @@ export interface CommandOptions {
 export function Command({
   path,
   description,
+  token,
   optionsSchema,
   priority,
   registry,
 }: CommandOptions) {
   return function (target: ClassType, context: ClassDecoratorContext) {
     if (context.kind !== 'class') {
-      throw new Error(
-        '[Navios Commander] @Command decorator can only be used on classes.',
-      )
+      throw new Error('[Navios Commander] @Command decorator can only be used on classes.')
     }
-    const token = InjectionToken.create(target)
+    const tokenToUse =
+      token ?? InjectionToken.create<ClassTypeWithInstance<CommandHandler<any>>>(target)
+
     if (context.metadata) {
       getCommandMetadata(target, context, path, description, optionsSchema)
     }
+    // @ts-expect-error Injectable is callable
     return Injectable({
-      token,
+      token: tokenToUse,
       scope: InjectableScope.Singleton,
       priority,
       registry,

package/src/legacy-compat/decorators/cli-module.decorator.mts

@@ -0,0 +1,46 @@
+import type { ClassType } from '@navios/core'
+import { createClassContext } from '@navios/di/legacy-compat'
+
+import {
+  CliModule as OriginalCliModule,
+  type CliModuleOptions,
+} from '../../decorators/cli-module.decorator.mjs'
+
+export type { CliModuleOptions }
+
+/**
+ * Legacy-compatible CliModule decorator.
+ *
+ * Works with TypeScript experimental decorators (legacy API).
+ *
+ * @param options - CLI module configuration options
+ * @returns A class decorator compatible with legacy decorator API
+ *
+ * @example
+ * ```typescript
+ * import { CliModule } from '@navios/commander/legacy-compat'
+ * import { GreetCommand } from './greet.command'
+ * import { UserModule } from './user.module'
+ *
+ * @CliModule({
+ *   commands: [GreetCommand],
+ *   imports: [UserModule]
+ * })
+ * export class AppModule {}
+ * ```
+ */
+export function CliModule(
+  options: CliModuleOptions = {
+    commands: [],
+    controllers: [],
+    imports: [],
+    guards: [],
+    overrides: [],
+  },
+) {
+  return function (target: ClassType) {
+    const context = createClassContext(target)
+    const originalDecorator = OriginalCliModule(options)
+    return originalDecorator(target, context)
+  }
+}

package/src/legacy-compat/decorators/command.decorator.mts

@@ -0,0 +1,46 @@
+import type { ClassType } from '@navios/core'
+import { createClassContext } from '@navios/di/legacy-compat'
+
+import {
+  Command as OriginalCommand,
+  type CommandOptions,
+} from '../../decorators/command.decorator.mjs'
+
+export type { CommandOptions }
+
+/**
+ * Legacy-compatible Command decorator.
+ *
+ * Works with TypeScript experimental decorators (legacy API).
+ *
+ * @param options - Command configuration options
+ * @returns A class decorator compatible with legacy decorator API
+ *
+ * @example
+ * ```typescript
+ * import { Command, CommandHandler } from '@navios/commander/legacy-compat'
+ * 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 function Command(options: CommandOptions) {
+  return function (target: ClassType) {
+    const context = createClassContext(target)
+    const originalDecorator = OriginalCommand(options)
+    return originalDecorator(target, context)
+  }
+}

package/src/legacy-compat/decorators/index.mts

@@ -0,0 +1,2 @@
+export * from './command.decorator.mjs'
+export * from './cli-module.decorator.mjs'

package/src/legacy-compat/index.mts

@@ -0,0 +1,31 @@
+/**
+ * Legacy-compatible decorators for projects using TypeScript experimental decorators.
+ *
+ * These decorators wrap the Stage 3 decorator implementations and convert
+ * the legacy decorator arguments to Stage 3 format internally.
+ *
+ * @example
+ * ```typescript
+ * import { Command, CliModule, CommandHandler } from '@navios/commander/legacy-compat'
+ *
+ * @Command({ path: 'greet' })
+ * export class GreetCommand implements CommandHandler {
+ *   async execute() {
+ *     console.log('Hello!')
+ *   }
+ * }
+ *
+ * @CliModule({
+ *   commands: [GreetCommand],
+ * })
+ * export class AppModule {}
+ * ```
+ *
+ * @packageDocumentation
+ */
+
+// Export legacy-compatible decorators (commander-specific)
+export * from './decorators/index.mjs'
+
+// Re-export core/DI legacy-compat utilities for convenience
+export * from '@navios/core/legacy-compat'

package/src/overrides/help.command.mts

@@ -0,0 +1,40 @@
+import { ScreenLogger } from '@navios/commander-tui'
+import { inject } from '@navios/core'
+import { z } from 'zod'
+
+import { Command } from '../decorators/command.decorator.mjs'
+import { CommandRegistryService } from '../services/command-registry.service.mjs'
+import { HelpCommandToken } from '../tokens/help-command.token.mjs'
+
+import type { CommandHandler } from '../interfaces/command-handler.interface.mjs'
+
+const helpOptionsSchema = z.object({
+  command: z.string().optional(),
+})
+
+type HelpOptions = z.infer<typeof helpOptionsSchema>
+
+/**
+ * Built-in help command that lists all available commands or shows help for a specific command.
+ *
+ * @public
+ */
+@Command({
+  token: HelpCommandToken,
+  path: 'help',
+  description: 'Show available commands or help for a specific command',
+  optionsSchema: helpOptionsSchema,
+  priority: 1000,
+})
+export class HelpCommand implements CommandHandler<HelpOptions> {
+  private logger = inject(ScreenLogger, { screen: { name: 'Help', static: true }, context: 'Help' })
+  private commandRegistry = inject(CommandRegistryService)
+
+  async execute(options: HelpOptions): Promise<void> {
+    if (options.command) {
+      this.logger.log(this.commandRegistry.formatCommandHelp(options.command))
+    } else {
+      this.logger.log(this.commandRegistry.formatCommandList())
+    }
+  }
+}

package/src/tokens/help-command.token.mts

@@ -0,0 +1,5 @@
+import { InjectionToken } from '@navios/core'
+
+import type { HelpCommand } from '../overrides/help.command.mjs'
+
+export const HelpCommandToken = InjectionToken.create<HelpCommand>('HelpCommand')

package/tsconfig.json

@@ -10,9 +10,6 @@
     },
     {
       "path": "./tsconfig.spec.json"
-    },
-    {
-      "path": "../core"
     }
   ]
 }

package/tsconfig.spec.json

@@ -2,7 +2,7 @@
   "extends": "./tsconfig.json",
   "compilerOptions": {
     "outDir": "../../dist/out-tsc",
-    "types": ["bun-types"]
+    "types": []
   },
   "include": ["src/**/*.spec.mts"],
   "references": [

package/tsdown.config.mts

@@ -3,7 +3,7 @@ import { defineConfig } from 'tsdown'
 import swc from 'unplugin-swc'
 
 export default defineConfig({
-  entry: ['src/index.mts'],
+  entry: ['src/index.mts', 'src/legacy-compat/index.mts'],
   outDir: 'lib',
   format: ['esm', 'cjs'],
   clean: true,

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

@@ -1,147 +0,0 @@
-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;
-    /**
-     * @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 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 +0,0 @@
-{"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"}