@navios/commander 1.1.0 → 1.3.0

package/lib/legacy-compat/index.d.cts

@@ -0,0 +1,63 @@
+import { i as CommandOptions, n as CliModuleOptions } from "../cli-module.decorator-DVl8009Q.cjs";
+import { ClassType } from "@navios/core";
+export * from "@navios/core/legacy-compat";
+
+//#region src/legacy-compat/decorators/command.decorator.d.mts
+
+/**
+ * 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}!`)
+ *   }
+ * }
+ * ```
+ */
+declare function Command(options: CommandOptions): (target: ClassType) => any;
+//#endregion
+//#region src/legacy-compat/decorators/cli-module.decorator.d.mts
+/**
+ * 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 {}
+ * ```
+ */
+declare function CliModule(options?: CliModuleOptions): (target: ClassType) => ClassType;
+//#endregion
+export { CliModule, type CliModuleOptions, Command, type CommandOptions };
+//# sourceMappingURL=index.d.cts.map

package/lib/legacy-compat/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":["ClassType","CommandOptions","Command","ClassType","CliModuleOptions","CliModule"],"sources":["../../src/legacy-compat/decorators/command.decorator.d.mts","../../src/legacy-compat/decorators/cli-module.decorator.d.mts"],"sourcesContent":["import type { ClassType } from '@navios/core';\nimport { type CommandOptions } from '../../decorators/command.decorator.mjs';\nexport type { CommandOptions };\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 declare function Command(options: CommandOptions): (target: ClassType) => any;\n//# sourceMappingURL=command.decorator.d.mts.map","import type { ClassType } from '@navios/core';\nimport { type CliModuleOptions } from '../../decorators/cli-module.decorator.mjs';\nexport type { CliModuleOptions };\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 declare function CliModule(options?: CliModuleOptions): (target: ClassType) => ClassType;\n//# sourceMappingURL=cli-module.decorator.d.mts.map"],"mappings":";;;;;;;;;AAgCA;;;;ACRA;;;;;;;;;;;;;;;;;;;;;;iBDQwBE,OAAAA,UAAiBD,0BAA0BD;;;;;;AAAnE;;;;ACRA;;;;;;;;;;;;;;iBAAwBK,SAAAA,WAAoBD,4BAA4BD,cAAcA"}

package/lib/legacy-compat/index.d.mts

@@ -0,0 +1,63 @@
+import { i as CommandOptions, n as CliModuleOptions } from "../cli-module.decorator-DGuGfpex.mjs";
+import { ClassType } from "@navios/core";
+export * from "@navios/core/legacy-compat";
+
+//#region src/legacy-compat/decorators/command.decorator.d.mts
+
+/**
+ * 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}!`)
+ *   }
+ * }
+ * ```
+ */
+declare function Command(options: CommandOptions): (target: ClassType) => any;
+//#endregion
+//#region src/legacy-compat/decorators/cli-module.decorator.d.mts
+/**
+ * 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 {}
+ * ```
+ */
+declare function CliModule(options?: CliModuleOptions): (target: ClassType) => ClassType;
+//#endregion
+export { CliModule, type CliModuleOptions, Command, type CommandOptions };
+//# sourceMappingURL=index.d.mts.map

package/lib/legacy-compat/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":["ClassType","CommandOptions","Command","ClassType","CliModuleOptions","CliModule"],"sources":["../../src/legacy-compat/decorators/command.decorator.d.mts","../../src/legacy-compat/decorators/cli-module.decorator.d.mts"],"sourcesContent":["import type { ClassType } from '@navios/core';\nimport { type CommandOptions } from '../../decorators/command.decorator.mjs';\nexport type { CommandOptions };\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 declare function Command(options: CommandOptions): (target: ClassType) => any;\n//# sourceMappingURL=command.decorator.d.mts.map","import type { ClassType } from '@navios/core';\nimport { type CliModuleOptions } from '../../decorators/cli-module.decorator.mjs';\nexport type { CliModuleOptions };\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 declare function CliModule(options?: CliModuleOptions): (target: ClassType) => ClassType;\n//# sourceMappingURL=cli-module.decorator.d.mts.map"],"mappings":";;;;;;;;;AAgCA;;;;ACRA;;;;;;;;;;;;;;;;;;;;;;iBDQwBE,OAAAA,UAAiBD,0BAA0BD;;;;;;AAAnE;;;;ACRA;;;;;;;;;;;;;;iBAAwBK,SAAAA,WAAoBD,4BAA4BD,cAAcA"}

package/lib/legacy-compat/index.mjs

@@ -0,0 +1,101 @@
+import { t as Command$1 } from "../command.decorator-DVLSAqYZ.mjs";
+import { t as CliModule$1 } from "../cli-module.decorator-UGbtkRYc.mjs";
+
+export * from "@navios/core/legacy-compat"
+
+//#region ../../node_modules/@navios/di/lib/legacy-compat/index.mjs
+/**
+* Compatibility layer for converting legacy decorator signatures to Stage 3 format.
+*
+* This module provides utilities to create mock Stage 3 decorator contexts
+* from legacy decorator arguments, and manages metadata storage using WeakMap.
+*/ const classMetadataMap = /* @__PURE__ */ new WeakMap();
+/**
+* Creates a mock ClassDecoratorContext for legacy class decorators.
+* @internal
+*/ function createClassContext(target) {
+	if (!classMetadataMap.has(target)) classMetadataMap.set(target, {});
+	const metadata = classMetadataMap.get(target);
+	return {
+		kind: "class",
+		name: target.name,
+		metadata,
+		addInitializer() {}
+	};
+}
+
+//#endregion
+//#region src/legacy-compat/decorators/command.decorator.mts
+/**
+* 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}!`)
+*   }
+* }
+* ```
+*/ function Command(options) {
+	return function(target) {
+		const context = createClassContext(target);
+		return Command$1(options)(target, context);
+	};
+}
+
+//#endregion
+//#region src/legacy-compat/decorators/cli-module.decorator.mts
+/**
+* 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 {}
+* ```
+*/ function CliModule(options = {
+	commands: [],
+	controllers: [],
+	imports: [],
+	guards: [],
+	overrides: []
+}) {
+	return function(target) {
+		const context = createClassContext(target);
+		return CliModule$1(options)(target, context);
+	};
+}
+
+//#endregion
+export { CliModule, Command };
+//# sourceMappingURL=index.mjs.map

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.1.0",
+  "version": "1.3.0",
   "author": {
     "name": "Oleksandr Hanzha",
     "email": "alex@granted.name"
@@ -33,6 +33,16 @@
         "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": {

package/src/commander.factory.mts

@@ -62,6 +62,11 @@ export interface CommanderTuiOptions {
    * @default true
    */
   exitOnCtrlC?: boolean
+  /**
+   * Adapter to use for the TUI.
+   * @default 'react'
+   */
+  adapter?: 'react' | 'solid'
   /**
    * Sidebar width in columns.
    */
@@ -178,6 +183,11 @@ export class CommanderFactory {
     options: CommanderFactoryOptions = {},
   ): Promise<NaviosApplication<CliEnvironment>> {
     if (options.enableTUI) {
+      if (options.tuiOptions?.adapter === 'solid') {
+        await import('@navios/commander-tui/adapters/solid')
+      } else {
+        await import('@navios/commander-tui/adapters/react')
+      }
       // Dynamic import to keep commander-tui as optional peer dependency
       let tuiModule: typeof import('@navios/commander-tui')
       try {

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/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/lib/help-command.token-BPEgaaxY.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"help-command.token-BPEgaaxY.mjs","names":["CommandMetadataKey","Symbol","getCommandMetadata","target","context","path","description","optionsSchema","metadata","newMetadata","customAttributes","Map","Error","extractCommandMetadata","hasCommandMetadata","extractModuleMetadata","CommandEntryKey","Symbol","extractModuleCommands","moduleClass","metadata","customEntries","get","Set","Injectable","InjectableScope","InjectionToken","getCommandMetadata","Command","path","description","token","optionsSchema","priority","registry","target","context","kind","Error","tokenToUse","create","metadata","scope","Singleton","Injectable","CommandRegistryService","commands","Map","register","path","command","has","Error","set","getByPath","get","getAll","getAllAsArray","result","class","cls","push","formatCommandList","lines","metadata","description","padEnd","join","formatCommandHelp","commandPath","optionsSchema","shape","def","key","fieldSchema","Object","entries","kebabKey","replace","toLowerCase","optionFlag","fieldType","getSchemaTypeName","schema","currentSchema","typeName","type","isOptional","defaultValue","innerType","undefined","JSON","stringify","getSchemaMeta","directMeta","meta","clear","InjectionToken","HelpCommandToken","create"],"sources":["../src/metadata/command.metadata.mts","../src/metadata/command-entry.metadata.mts","../src/decorators/command.decorator.mts","../src/services/command-registry.service.mts","../src/tokens/help-command.token.mts"],"sourcesContent":["import type { ClassType } from '@navios/core'\nimport type { ZodObject } from 'zod'\n\n/**\n * @internal\n * Symbol key used to store command metadata on classes.\n */\nexport const CommandMetadataKey = Symbol('CommandMetadataKey')\n\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/**\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 function getCommandMetadata(\n  target: ClassType,\n  context: ClassDecoratorContext,\n  path: string,\n  description?: string,\n  optionsSchema?: ZodObject,\n): CommandMetadata {\n  if (context.metadata) {\n    const metadata = context.metadata[CommandMetadataKey] as\n      | CommandMetadata\n      | undefined\n    if (metadata) {\n      return metadata\n    } else {\n      const newMetadata: CommandMetadata = {\n        path,\n        description,\n        optionsSchema,\n        customAttributes: new Map<string | symbol, any>(),\n      }\n      context.metadata[CommandMetadataKey] = newMetadata\n      // @ts-expect-error We add a custom metadata key to the target\n      target[CommandMetadataKey] = newMetadata\n      return newMetadata\n    }\n  }\n  throw new Error('[Navios Commander] Wrong environment.')\n}\n\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 function extractCommandMetadata(target: ClassType): CommandMetadata {\n  // @ts-expect-error We add a custom metadata key to the target\n  const metadata = target[CommandMetadataKey] as CommandMetadata | undefined\n  if (!metadata) {\n    throw new Error(\n      '[Navios Commander] Command metadata not found. Make sure to use @Command decorator.',\n    )\n  }\n  return metadata\n}\n\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 function hasCommandMetadata(target: ClassType): boolean {\n  // @ts-expect-error We add a custom metadata key to the target\n  const metadata = target[CommandMetadataKey] as CommandMetadata | undefined\n  return !!metadata\n}\n","import type { ClassType } from '@navios/core'\n\nimport { extractModuleMetadata } from '@navios/core'\n\n/**\n * Symbol key for storing commands in ModuleMetadata.customEntries.\n * Used by @CliModule to store command classes.\n *\n * @public\n */\nexport const CommandEntryKey = Symbol('CommandEntryKey')\n\n/**\n * Type for the command entry value stored in customEntries.\n *\n * @public\n */\nexport type CommandEntryValue = Set<ClassType>\n\n/**\n * Extracts commands from a module's metadata.\n * Returns empty set if no commands are defined.\n *\n * @param moduleClass - The module class decorated with @CliModule or @Module\n * @returns Set of command classes registered in the module\n *\n * @example\n * ```typescript\n * const commands = extractModuleCommands(AppModule)\n * for (const command of commands) {\n *   console.log(command.name)\n * }\n * ```\n */\nexport function extractModuleCommands(moduleClass: ClassType): Set<ClassType> {\n  const metadata = extractModuleMetadata(moduleClass)\n  return (\n    (metadata.customEntries.get(CommandEntryKey) as CommandEntryValue) ??\n    new Set()\n  )\n}\n","import { Injectable, InjectableScope, InjectionToken } from '@navios/core'\n\nimport type { ClassType, ClassTypeWithInstance, Registry } from '@navios/core'\nimport type { ZodObject } from 'zod'\n\nimport { getCommandMetadata } from '../metadata/index.mjs'\n\nimport type { CommandHandler } from '../interfaces/index.mjs'\n\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/**\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 function Command({\n  path,\n  description,\n  token,\n  optionsSchema,\n  priority,\n  registry,\n}: CommandOptions) {\n  return function (target: ClassType, context: ClassDecoratorContext) {\n    if (context.kind !== 'class') {\n      throw new Error('[Navios Commander] @Command decorator can only be used on classes.')\n    }\n    const tokenToUse =\n      token ?? InjectionToken.create<ClassTypeWithInstance<CommandHandler<any>>>(target)\n\n    if (context.metadata) {\n      getCommandMetadata(target, context, path, description, optionsSchema)\n    }\n    // @ts-expect-error Injectable is callable\n    return Injectable({\n      token: tokenToUse,\n      scope: InjectableScope.Singleton,\n      priority,\n      registry,\n    })(target, context)\n  }\n}\n","import type { ClassType } from '@navios/core'\n\nimport { Injectable } from '@navios/core'\n\nimport type { CommandMetadata } from '../metadata/index.mjs'\n\n/**\n * Represents a registered command with its metadata and module information.\n *\n * @public\n */\nexport interface RegisteredCommand {\n  /**\n   * The command class\n   */\n  class: ClassType\n  /**\n   * The command metadata from @Command decorator\n   */\n  metadata: CommandMetadata\n  /**\n   * Name of the module this command belongs to\n   */\n  moduleName: string\n}\n\n/**\n * Service for registering and looking up CLI commands.\n * Used internally by the CLI adapter to manage discovered commands.\n *\n * @public\n */\n@Injectable()\nexport class CommandRegistryService {\n  private commands = new Map<string, RegisteredCommand>()\n\n  /**\n   * Register a command with its metadata.\n   *\n   * @param path - The command path (e.g., 'greet', 'user:create')\n   * @param command - The registered command data\n   * @throws Error if a command with the same path is already registered\n   */\n  register(path: string, command: RegisteredCommand): void {\n    if (this.commands.has(path)) {\n      throw new Error(`[Navios Commander] Duplicate command path: ${path}`)\n    }\n    this.commands.set(path, command)\n  }\n\n  /**\n   * Get a command by its path.\n   *\n   * @param path - The command path\n   * @returns The registered command or undefined if not found\n   */\n  getByPath(path: string): RegisteredCommand | undefined {\n    return this.commands.get(path)\n  }\n\n  /**\n   * Get all registered commands.\n   *\n   * @returns Map of path to registered command\n   */\n  getAll(): Map<string, RegisteredCommand> {\n    return new Map(this.commands)\n  }\n\n  /**\n   * Get all registered commands as an array of path and class pairs.\n   * Useful for listing available commands.\n   *\n   * @returns Array of objects containing path and class\n   */\n  getAllAsArray(): Array<{ path: string; class: ClassType }> {\n    const result: Array<{ path: string; class: ClassType }> = []\n    for (const [path, { class: cls }] of this.commands) {\n      result.push({ path, class: cls })\n    }\n    return result\n  }\n\n  /**\n   * Formats help text listing all available commands with descriptions.\n   *\n   * @returns Formatted string listing all commands\n   */\n  formatCommandList(): string {\n    const lines = ['Available commands:', '']\n    for (const [path, { metadata }] of this.commands) {\n      const description = metadata.description\n      if (description) {\n        lines.push(`  ${path.padEnd(20)} ${description}`)\n      } else {\n        lines.push(`  ${path}`)\n      }\n    }\n    return lines.join('\\n')\n  }\n\n  /**\n   * Formats help text for a specific command.\n   *\n   * @param commandPath - The command path to show help for\n   * @returns Formatted string with command help\n   */\n  formatCommandHelp(commandPath: string): string {\n    const command = this.commands.get(commandPath)\n    if (!command) {\n      return `Unknown command: ${commandPath}\\n\\n${this.formatCommandList()}`\n    }\n\n    const { metadata } = command\n    const lines: string[] = []\n\n    lines.push(`Usage: ${metadata.path} [options]`)\n    lines.push('')\n\n    if (metadata.description) {\n      lines.push(metadata.description)\n      lines.push('')\n    }\n\n    // Extract options from schema if available\n    if (metadata.optionsSchema) {\n      lines.push('Options:')\n      try {\n        const shape = metadata.optionsSchema.def.shape\n        if (shape && typeof shape === 'object') {\n          for (const [key, fieldSchema] of Object.entries(shape)) {\n            const kebabKey = key.replace(/([A-Z])/g, '-$1').toLowerCase()\n            const optionFlag = `--${kebabKey}`\n            const fieldType = this.getSchemaTypeName(fieldSchema as any)\n            lines.push(`  ${optionFlag.padEnd(20)} ${fieldType}`)\n          }\n        }\n      } catch {\n        // Schema introspection failed, skip options\n      }\n    }\n\n    return lines.join('\\n')\n  }\n\n  /**\n   * Gets a human-readable type name from a Zod schema.\n   */\n  private getSchemaTypeName(schema: any): string {\n    try {\n      let currentSchema = schema\n      let typeName = currentSchema?.def?.type\n      let isOptional = false\n      let defaultValue: any\n\n      // Unwrap optional/default wrappers\n      while (typeName === 'optional' || typeName === 'default') {\n        if (typeName === 'optional') {\n          isOptional = true\n        }\n        if (typeName === 'default') {\n          isOptional = true\n          defaultValue = currentSchema?.def?.defaultValue?.()\n        }\n        currentSchema = currentSchema?.def?.innerType\n        typeName = currentSchema?.def?.type\n      }\n\n      let result = `<${typeName || 'unknown'}>`\n      if (defaultValue !== undefined) {\n        result += ` (default: ${JSON.stringify(defaultValue)})`\n      } else if (isOptional) {\n        result += ' (optional)'\n      }\n\n      // Get description from meta() if available\n      const description = this.getSchemaMeta(schema)?.description\n      if (description) {\n        result += ` - ${description}`\n      }\n\n      return result\n    } catch {\n      return '<unknown>'\n    }\n  }\n\n  /**\n   * Gets metadata from a Zod schema, traversing innerType if needed.\n   * Zod v4 stores meta at the outermost layer when .meta() is called last,\n   * or in innerType when .meta() is called before .optional()/.default().\n   */\n  private getSchemaMeta(schema: any): Record<string, unknown> | undefined {\n    try {\n      // First check direct meta (when .meta() is called last in chain)\n      const directMeta = schema.meta?.()\n      if (directMeta) return directMeta\n\n      // Check innerType for wrapped schemas (optional, default, etc.)\n      const innerType = schema.def?.innerType\n      if (innerType) {\n        return this.getSchemaMeta(innerType)\n      }\n\n      return undefined\n    } catch {\n      return undefined\n    }\n  }\n\n  /**\n   * Clear all registered commands.\n   */\n  clear(): void {\n    this.commands.clear()\n  }\n}\n","import { InjectionToken } from '@navios/core'\n\nimport type { HelpCommand } from '../overrides/help.command.mjs'\n\nexport const HelpCommandToken = InjectionToken.create<HelpCommand>('HelpCommand')\n"],"mappings":"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"}

package/lib/help-command.token-DcvTjwbA.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"help-command.token-DcvTjwbA.cjs","names":["CommandMetadataKey","Symbol","getCommandMetadata","target","context","path","description","optionsSchema","metadata","newMetadata","customAttributes","Map","Error","extractCommandMetadata","hasCommandMetadata","extractModuleMetadata","CommandEntryKey","Symbol","extractModuleCommands","moduleClass","metadata","customEntries","get","Set","Injectable","InjectableScope","InjectionToken","getCommandMetadata","Command","path","description","token","optionsSchema","priority","registry","target","context","kind","Error","tokenToUse","create","metadata","scope","Singleton","Injectable","CommandRegistryService","commands","Map","register","path","command","has","Error","set","getByPath","get","getAll","getAllAsArray","result","class","cls","push","formatCommandList","lines","metadata","description","padEnd","join","formatCommandHelp","commandPath","optionsSchema","shape","def","key","fieldSchema","Object","entries","kebabKey","replace","toLowerCase","optionFlag","fieldType","getSchemaTypeName","schema","currentSchema","typeName","type","isOptional","defaultValue","innerType","undefined","JSON","stringify","getSchemaMeta","directMeta","meta","clear","InjectionToken","HelpCommandToken","create"],"sources":["../src/metadata/command.metadata.mts","../src/metadata/command-entry.metadata.mts","../src/decorators/command.decorator.mts","../src/services/command-registry.service.mts","../src/tokens/help-command.token.mts"],"sourcesContent":["import type { ClassType } from '@navios/core'\nimport type { ZodObject } from 'zod'\n\n/**\n * @internal\n * Symbol key used to store command metadata on classes.\n */\nexport const CommandMetadataKey = Symbol('CommandMetadataKey')\n\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/**\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 function getCommandMetadata(\n  target: ClassType,\n  context: ClassDecoratorContext,\n  path: string,\n  description?: string,\n  optionsSchema?: ZodObject,\n): CommandMetadata {\n  if (context.metadata) {\n    const metadata = context.metadata[CommandMetadataKey] as\n      | CommandMetadata\n      | undefined\n    if (metadata) {\n      return metadata\n    } else {\n      const newMetadata: CommandMetadata = {\n        path,\n        description,\n        optionsSchema,\n        customAttributes: new Map<string | symbol, any>(),\n      }\n      context.metadata[CommandMetadataKey] = newMetadata\n      // @ts-expect-error We add a custom metadata key to the target\n      target[CommandMetadataKey] = newMetadata\n      return newMetadata\n    }\n  }\n  throw new Error('[Navios Commander] Wrong environment.')\n}\n\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 function extractCommandMetadata(target: ClassType): CommandMetadata {\n  // @ts-expect-error We add a custom metadata key to the target\n  const metadata = target[CommandMetadataKey] as CommandMetadata | undefined\n  if (!metadata) {\n    throw new Error(\n      '[Navios Commander] Command metadata not found. Make sure to use @Command decorator.',\n    )\n  }\n  return metadata\n}\n\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 function hasCommandMetadata(target: ClassType): boolean {\n  // @ts-expect-error We add a custom metadata key to the target\n  const metadata = target[CommandMetadataKey] as CommandMetadata | undefined\n  return !!metadata\n}\n","import type { ClassType } from '@navios/core'\n\nimport { extractModuleMetadata } from '@navios/core'\n\n/**\n * Symbol key for storing commands in ModuleMetadata.customEntries.\n * Used by @CliModule to store command classes.\n *\n * @public\n */\nexport const CommandEntryKey = Symbol('CommandEntryKey')\n\n/**\n * Type for the command entry value stored in customEntries.\n *\n * @public\n */\nexport type CommandEntryValue = Set<ClassType>\n\n/**\n * Extracts commands from a module's metadata.\n * Returns empty set if no commands are defined.\n *\n * @param moduleClass - The module class decorated with @CliModule or @Module\n * @returns Set of command classes registered in the module\n *\n * @example\n * ```typescript\n * const commands = extractModuleCommands(AppModule)\n * for (const command of commands) {\n *   console.log(command.name)\n * }\n * ```\n */\nexport function extractModuleCommands(moduleClass: ClassType): Set<ClassType> {\n  const metadata = extractModuleMetadata(moduleClass)\n  return (\n    (metadata.customEntries.get(CommandEntryKey) as CommandEntryValue) ??\n    new Set()\n  )\n}\n","import { Injectable, InjectableScope, InjectionToken } from '@navios/core'\n\nimport type { ClassType, ClassTypeWithInstance, Registry } from '@navios/core'\nimport type { ZodObject } from 'zod'\n\nimport { getCommandMetadata } from '../metadata/index.mjs'\n\nimport type { CommandHandler } from '../interfaces/index.mjs'\n\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/**\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 function Command({\n  path,\n  description,\n  token,\n  optionsSchema,\n  priority,\n  registry,\n}: CommandOptions) {\n  return function (target: ClassType, context: ClassDecoratorContext) {\n    if (context.kind !== 'class') {\n      throw new Error('[Navios Commander] @Command decorator can only be used on classes.')\n    }\n    const tokenToUse =\n      token ?? InjectionToken.create<ClassTypeWithInstance<CommandHandler<any>>>(target)\n\n    if (context.metadata) {\n      getCommandMetadata(target, context, path, description, optionsSchema)\n    }\n    // @ts-expect-error Injectable is callable\n    return Injectable({\n      token: tokenToUse,\n      scope: InjectableScope.Singleton,\n      priority,\n      registry,\n    })(target, context)\n  }\n}\n","import type { ClassType } from '@navios/core'\n\nimport { Injectable } from '@navios/core'\n\nimport type { CommandMetadata } from '../metadata/index.mjs'\n\n/**\n * Represents a registered command with its metadata and module information.\n *\n * @public\n */\nexport interface RegisteredCommand {\n  /**\n   * The command class\n   */\n  class: ClassType\n  /**\n   * The command metadata from @Command decorator\n   */\n  metadata: CommandMetadata\n  /**\n   * Name of the module this command belongs to\n   */\n  moduleName: string\n}\n\n/**\n * Service for registering and looking up CLI commands.\n * Used internally by the CLI adapter to manage discovered commands.\n *\n * @public\n */\n@Injectable()\nexport class CommandRegistryService {\n  private commands = new Map<string, RegisteredCommand>()\n\n  /**\n   * Register a command with its metadata.\n   *\n   * @param path - The command path (e.g., 'greet', 'user:create')\n   * @param command - The registered command data\n   * @throws Error if a command with the same path is already registered\n   */\n  register(path: string, command: RegisteredCommand): void {\n    if (this.commands.has(path)) {\n      throw new Error(`[Navios Commander] Duplicate command path: ${path}`)\n    }\n    this.commands.set(path, command)\n  }\n\n  /**\n   * Get a command by its path.\n   *\n   * @param path - The command path\n   * @returns The registered command or undefined if not found\n   */\n  getByPath(path: string): RegisteredCommand | undefined {\n    return this.commands.get(path)\n  }\n\n  /**\n   * Get all registered commands.\n   *\n   * @returns Map of path to registered command\n   */\n  getAll(): Map<string, RegisteredCommand> {\n    return new Map(this.commands)\n  }\n\n  /**\n   * Get all registered commands as an array of path and class pairs.\n   * Useful for listing available commands.\n   *\n   * @returns Array of objects containing path and class\n   */\n  getAllAsArray(): Array<{ path: string; class: ClassType }> {\n    const result: Array<{ path: string; class: ClassType }> = []\n    for (const [path, { class: cls }] of this.commands) {\n      result.push({ path, class: cls })\n    }\n    return result\n  }\n\n  /**\n   * Formats help text listing all available commands with descriptions.\n   *\n   * @returns Formatted string listing all commands\n   */\n  formatCommandList(): string {\n    const lines = ['Available commands:', '']\n    for (const [path, { metadata }] of this.commands) {\n      const description = metadata.description\n      if (description) {\n        lines.push(`  ${path.padEnd(20)} ${description}`)\n      } else {\n        lines.push(`  ${path}`)\n      }\n    }\n    return lines.join('\\n')\n  }\n\n  /**\n   * Formats help text for a specific command.\n   *\n   * @param commandPath - The command path to show help for\n   * @returns Formatted string with command help\n   */\n  formatCommandHelp(commandPath: string): string {\n    const command = this.commands.get(commandPath)\n    if (!command) {\n      return `Unknown command: ${commandPath}\\n\\n${this.formatCommandList()}`\n    }\n\n    const { metadata } = command\n    const lines: string[] = []\n\n    lines.push(`Usage: ${metadata.path} [options]`)\n    lines.push('')\n\n    if (metadata.description) {\n      lines.push(metadata.description)\n      lines.push('')\n    }\n\n    // Extract options from schema if available\n    if (metadata.optionsSchema) {\n      lines.push('Options:')\n      try {\n        const shape = metadata.optionsSchema.def.shape\n        if (shape && typeof shape === 'object') {\n          for (const [key, fieldSchema] of Object.entries(shape)) {\n            const kebabKey = key.replace(/([A-Z])/g, '-$1').toLowerCase()\n            const optionFlag = `--${kebabKey}`\n            const fieldType = this.getSchemaTypeName(fieldSchema as any)\n            lines.push(`  ${optionFlag.padEnd(20)} ${fieldType}`)\n          }\n        }\n      } catch {\n        // Schema introspection failed, skip options\n      }\n    }\n\n    return lines.join('\\n')\n  }\n\n  /**\n   * Gets a human-readable type name from a Zod schema.\n   */\n  private getSchemaTypeName(schema: any): string {\n    try {\n      let currentSchema = schema\n      let typeName = currentSchema?.def?.type\n      let isOptional = false\n      let defaultValue: any\n\n      // Unwrap optional/default wrappers\n      while (typeName === 'optional' || typeName === 'default') {\n        if (typeName === 'optional') {\n          isOptional = true\n        }\n        if (typeName === 'default') {\n          isOptional = true\n          defaultValue = currentSchema?.def?.defaultValue?.()\n        }\n        currentSchema = currentSchema?.def?.innerType\n        typeName = currentSchema?.def?.type\n      }\n\n      let result = `<${typeName || 'unknown'}>`\n      if (defaultValue !== undefined) {\n        result += ` (default: ${JSON.stringify(defaultValue)})`\n      } else if (isOptional) {\n        result += ' (optional)'\n      }\n\n      // Get description from meta() if available\n      const description = this.getSchemaMeta(schema)?.description\n      if (description) {\n        result += ` - ${description}`\n      }\n\n      return result\n    } catch {\n      return '<unknown>'\n    }\n  }\n\n  /**\n   * Gets metadata from a Zod schema, traversing innerType if needed.\n   * Zod v4 stores meta at the outermost layer when .meta() is called last,\n   * or in innerType when .meta() is called before .optional()/.default().\n   */\n  private getSchemaMeta(schema: any): Record<string, unknown> | undefined {\n    try {\n      // First check direct meta (when .meta() is called last in chain)\n      const directMeta = schema.meta?.()\n      if (directMeta) return directMeta\n\n      // Check innerType for wrapped schemas (optional, default, etc.)\n      const innerType = schema.def?.innerType\n      if (innerType) {\n        return this.getSchemaMeta(innerType)\n      }\n\n      return undefined\n    } catch {\n      return undefined\n    }\n  }\n\n  /**\n   * Clear all registered commands.\n   */\n  clear(): void {\n    this.commands.clear()\n  }\n}\n","import { InjectionToken } from '@navios/core'\n\nimport type { HelpCommand } from '../overrides/help.command.mjs'\n\nexport const HelpCommandToken = InjectionToken.create<HelpCommand>('HelpCommand')\n"],"mappings":"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"}