@navios/commander 1.0.0-alpha.4 → 1.1.0

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

@@ -0,0 +1,611 @@
+let _navios_core = require("@navios/core");
+
+//#region src/metadata/command.metadata.mts
+/**
+* @internal
+* Symbol key used to store command metadata on classes.
+*/ const CommandMetadataKey = Symbol("CommandMetadataKey");
+/**
+* Gets or creates command metadata for a class.
+*
+* @internal
+* @param target - The command class
+* @param context - The decorator context
+* @param path - The command path
+* @param description - Optional description for help text
+* @param optionsSchema - Optional Zod schema
+* @returns The command metadata
+*/ function getCommandMetadata(target, context, path, description, optionsSchema) {
+	if (context.metadata) {
+		const metadata = context.metadata[CommandMetadataKey];
+		if (metadata) return metadata;
+		else {
+			const newMetadata = {
+				path,
+				description,
+				optionsSchema,
+				customAttributes: /* @__PURE__ */ new Map()
+			};
+			context.metadata[CommandMetadataKey] = newMetadata;
+			target[CommandMetadataKey] = newMetadata;
+			return newMetadata;
+		}
+	}
+	throw new Error("[Navios Commander] Wrong environment.");
+}
+/**
+* Extracts command metadata from a class.
+*
+* @param target - The command class
+* @returns The command metadata
+* @throws {Error} If the class is not decorated with @Command
+*
+* @example
+* ```typescript
+* const metadata = extractCommandMetadata(GreetCommand)
+* console.log(metadata.path) // 'greet'
+* ```
+*/ function extractCommandMetadata(target) {
+	const metadata = target[CommandMetadataKey];
+	if (!metadata) throw new Error("[Navios Commander] Command metadata not found. Make sure to use @Command decorator.");
+	return metadata;
+}
+/**
+* Checks if a class has command metadata.
+*
+* @param target - The class to check
+* @returns `true` if the class is decorated with @Command, `false` otherwise
+*/ function hasCommandMetadata(target) {
+	return !!target[CommandMetadataKey];
+}
+
+//#endregion
+//#region src/metadata/command-entry.metadata.mts
+/**
+* Symbol key for storing commands in ModuleMetadata.customEntries.
+* Used by @CliModule to store command classes.
+*
+* @public
+*/ const CommandEntryKey = Symbol("CommandEntryKey");
+/**
+* Extracts commands from a module's metadata.
+* Returns empty set if no commands are defined.
+*
+* @param moduleClass - The module class decorated with @CliModule or @Module
+* @returns Set of command classes registered in the module
+*
+* @example
+* ```typescript
+* const commands = extractModuleCommands(AppModule)
+* for (const command of commands) {
+*   console.log(command.name)
+* }
+* ```
+*/ function extractModuleCommands(moduleClass) {
+	return (0, _navios_core.extractModuleMetadata)(moduleClass).customEntries.get(CommandEntryKey) ?? /* @__PURE__ */ new Set();
+}
+
+//#endregion
+//#region src/decorators/command.decorator.mts
+/**
+* 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}!`)
+*   }
+* }
+* ```
+*/ function Command({ path, description, token, optionsSchema, priority, registry }) {
+	return function(target, context) {
+		if (context.kind !== "class") throw new Error("[Navios Commander] @Command decorator can only be used on classes.");
+		const tokenToUse = token ?? _navios_core.InjectionToken.create(target);
+		if (context.metadata) getCommandMetadata(target, context, path, description, optionsSchema);
+		return (0, _navios_core.Injectable)({
+			token: tokenToUse,
+			scope: _navios_core.InjectableScope.Singleton,
+			priority,
+			registry
+		})(target, context);
+	};
+}
+
+//#endregion
+//#region src/services/command-registry.service.mts
+function applyDecs2203RFactory() {
+	function createAddInitializerMethod(initializers, decoratorFinishedRef) {
+		return function addInitializer(initializer) {
+			assertNotFinished(decoratorFinishedRef, "addInitializer");
+			assertCallable(initializer, "An initializer");
+			initializers.push(initializer);
+		};
+	}
+	function memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, metadata, value) {
+		var kindStr;
+		switch (kind) {
+			case 1:
+				kindStr = "accessor";
+				break;
+			case 2:
+				kindStr = "method";
+				break;
+			case 3:
+				kindStr = "getter";
+				break;
+			case 4:
+				kindStr = "setter";
+				break;
+			default: kindStr = "field";
+		}
+		var ctx = {
+			kind: kindStr,
+			name: isPrivate ? "#" + name : name,
+			static: isStatic,
+			private: isPrivate,
+			metadata
+		};
+		var decoratorFinishedRef = { v: false };
+		ctx.addInitializer = createAddInitializerMethod(initializers, decoratorFinishedRef);
+		var get, set;
+		if (kind === 0) if (isPrivate) {
+			get = desc.get;
+			set = desc.set;
+		} else {
+			get = function() {
+				return this[name];
+			};
+			set = function(v) {
+				this[name] = v;
+			};
+		}
+		else if (kind === 2) get = function() {
+			return desc.value;
+		};
+		else {
+			if (kind === 1 || kind === 3) get = function() {
+				return desc.get.call(this);
+			};
+			if (kind === 1 || kind === 4) set = function(v) {
+				desc.set.call(this, v);
+			};
+		}
+		ctx.access = get && set ? {
+			get,
+			set
+		} : get ? { get } : { set };
+		try {
+			return dec(value, ctx);
+		} finally {
+			decoratorFinishedRef.v = true;
+		}
+	}
+	function assertNotFinished(decoratorFinishedRef, fnName) {
+		if (decoratorFinishedRef.v) throw new Error("attempted to call " + fnName + " after decoration was finished");
+	}
+	function assertCallable(fn, hint) {
+		if (typeof fn !== "function") throw new TypeError(hint + " must be a function");
+	}
+	function assertValidReturnValue(kind, value) {
+		var type = typeof value;
+		if (kind === 1) {
+			if (type !== "object" || value === null) throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0");
+			if (value.get !== void 0) assertCallable(value.get, "accessor.get");
+			if (value.set !== void 0) assertCallable(value.set, "accessor.set");
+			if (value.init !== void 0) assertCallable(value.init, "accessor.init");
+		} else if (type !== "function") {
+			var hint;
+			if (kind === 0) hint = "field";
+			else if (kind === 10) hint = "class";
+			else hint = "method";
+			throw new TypeError(hint + " decorators must return a function or void 0");
+		}
+	}
+	function applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, metadata) {
+		var decs = decInfo[0];
+		var desc, init, value;
+		if (isPrivate) if (kind === 0 || kind === 1) desc = {
+			get: decInfo[3],
+			set: decInfo[4]
+		};
+		else if (kind === 3) desc = { get: decInfo[3] };
+		else if (kind === 4) desc = { set: decInfo[3] };
+		else desc = { value: decInfo[3] };
+		else if (kind !== 0) desc = Object.getOwnPropertyDescriptor(base, name);
+		if (kind === 1) value = {
+			get: desc.get,
+			set: desc.set
+		};
+		else if (kind === 2) value = desc.value;
+		else if (kind === 3) value = desc.get;
+		else if (kind === 4) value = desc.set;
+		var newValue, get, set;
+		if (typeof decs === "function") {
+			newValue = memberDec(decs, name, desc, initializers, kind, isStatic, isPrivate, metadata, value);
+			if (newValue !== void 0) {
+				assertValidReturnValue(kind, newValue);
+				if (kind === 0) init = newValue;
+				else if (kind === 1) {
+					init = newValue.init;
+					get = newValue.get || value.get;
+					set = newValue.set || value.set;
+					value = {
+						get,
+						set
+					};
+				} else value = newValue;
+			}
+		} else for (var i = decs.length - 1; i >= 0; i--) {
+			var dec = decs[i];
+			newValue = memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, metadata, value);
+			if (newValue !== void 0) {
+				assertValidReturnValue(kind, newValue);
+				var newInit;
+				if (kind === 0) newInit = newValue;
+				else if (kind === 1) {
+					newInit = newValue.init;
+					get = newValue.get || value.get;
+					set = newValue.set || value.set;
+					value = {
+						get,
+						set
+					};
+				} else value = newValue;
+				if (newInit !== void 0) if (init === void 0) init = newInit;
+				else if (typeof init === "function") init = [init, newInit];
+				else init.push(newInit);
+			}
+		}
+		if (kind === 0 || kind === 1) {
+			if (init === void 0) init = function(instance, init$1) {
+				return init$1;
+			};
+			else if (typeof init !== "function") {
+				var ownInitializers = init;
+				init = function(instance, init$1) {
+					var value$1 = init$1;
+					for (var i$1 = 0; i$1 < ownInitializers.length; i$1++) value$1 = ownInitializers[i$1].call(instance, value$1);
+					return value$1;
+				};
+			} else {
+				var originalInitializer = init;
+				init = function(instance, init$1) {
+					return originalInitializer.call(instance, init$1);
+				};
+			}
+			ret.push(init);
+		}
+		if (kind !== 0) {
+			if (kind === 1) {
+				desc.get = value.get;
+				desc.set = value.set;
+			} else if (kind === 2) desc.value = value;
+			else if (kind === 3) desc.get = value;
+			else if (kind === 4) desc.set = value;
+			if (isPrivate) if (kind === 1) {
+				ret.push(function(instance, args) {
+					return value.get.call(instance, args);
+				});
+				ret.push(function(instance, args) {
+					return value.set.call(instance, args);
+				});
+			} else if (kind === 2) ret.push(value);
+			else ret.push(function(instance, args) {
+				return value.call(instance, args);
+			});
+			else Object.defineProperty(base, name, desc);
+		}
+	}
+	function applyMemberDecs(Class, decInfos, metadata) {
+		var ret = [];
+		var protoInitializers;
+		var staticInitializers;
+		var existingProtoNonFields = /* @__PURE__ */ new Map();
+		var existingStaticNonFields = /* @__PURE__ */ new Map();
+		for (var i = 0; i < decInfos.length; i++) {
+			var decInfo = decInfos[i];
+			if (!Array.isArray(decInfo)) continue;
+			var kind = decInfo[1];
+			var name = decInfo[2];
+			var isPrivate = decInfo.length > 3;
+			var isStatic = kind >= 5;
+			var base;
+			var initializers;
+			if (isStatic) {
+				base = Class;
+				kind = kind - 5;
+				staticInitializers = staticInitializers || [];
+				initializers = staticInitializers;
+			} else {
+				base = Class.prototype;
+				protoInitializers = protoInitializers || [];
+				initializers = protoInitializers;
+			}
+			if (kind !== 0 && !isPrivate) {
+				var existingNonFields = isStatic ? existingStaticNonFields : existingProtoNonFields;
+				var existingKind = existingNonFields.get(name) || 0;
+				if (existingKind === true || existingKind === 3 && kind !== 4 || existingKind === 4 && kind !== 3) throw new Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: " + name);
+				else if (!existingKind && kind > 2) existingNonFields.set(name, kind);
+				else existingNonFields.set(name, true);
+			}
+			applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, metadata);
+		}
+		pushInitializers(ret, protoInitializers);
+		pushInitializers(ret, staticInitializers);
+		return ret;
+	}
+	function pushInitializers(ret, initializers) {
+		if (initializers) ret.push(function(instance) {
+			for (var i = 0; i < initializers.length; i++) initializers[i].call(instance);
+			return instance;
+		});
+	}
+	function applyClassDecs(targetClass, classDecs, metadata) {
+		if (classDecs.length > 0) {
+			var initializers = [];
+			var newClass = targetClass;
+			var name = targetClass.name;
+			for (var i = classDecs.length - 1; i >= 0; i--) {
+				var decoratorFinishedRef = { v: false };
+				try {
+					var nextNewClass = classDecs[i](newClass, {
+						kind: "class",
+						name,
+						addInitializer: createAddInitializerMethod(initializers, decoratorFinishedRef),
+						metadata
+					});
+				} finally {
+					decoratorFinishedRef.v = true;
+				}
+				if (nextNewClass !== void 0) {
+					assertValidReturnValue(10, nextNewClass);
+					newClass = nextNewClass;
+				}
+			}
+			return [defineMetadata(newClass, metadata), function() {
+				for (var i$1 = 0; i$1 < initializers.length; i$1++) initializers[i$1].call(newClass);
+			}];
+		}
+	}
+	function defineMetadata(Class, metadata) {
+		return Object.defineProperty(Class, Symbol.metadata || Symbol.for("Symbol.metadata"), {
+			configurable: true,
+			enumerable: true,
+			value: metadata
+		});
+	}
+	return function applyDecs2203R(targetClass, memberDecs, classDecs, parentClass) {
+		if (parentClass !== void 0) var parentMetadata = parentClass[Symbol.metadata || Symbol.for("Symbol.metadata")];
+		var metadata = Object.create(parentMetadata === void 0 ? null : parentMetadata);
+		var e = applyMemberDecs(targetClass, memberDecs, metadata);
+		if (!classDecs.length) defineMetadata(targetClass, metadata);
+		return {
+			e,
+			get c() {
+				return applyClassDecs(targetClass, classDecs, metadata);
+			}
+		};
+	};
+}
+function _apply_decs_2203_r(targetClass, memberDecs, classDecs, parentClass) {
+	return (_apply_decs_2203_r = applyDecs2203RFactory())(targetClass, memberDecs, classDecs, parentClass);
+}
+var _dec, _initClass;
+let _CommandRegistryService;
+_dec = (0, _navios_core.Injectable)();
+var CommandRegistryService = class {
+	static {
+		({c: [_CommandRegistryService, _initClass]} = _apply_decs_2203_r(this, [], [_dec]));
+	}
+	commands = /* @__PURE__ */ new Map();
+	/**
+	* Register a command with its metadata.
+	*
+	* @param path - The command path (e.g., 'greet', 'user:create')
+	* @param command - The registered command data
+	* @throws Error if a command with the same path is already registered
+	*/ register(path, command) {
+		if (this.commands.has(path)) throw new Error(`[Navios Commander] Duplicate command path: ${path}`);
+		this.commands.set(path, command);
+	}
+	/**
+	* Get a command by its path.
+	*
+	* @param path - The command path
+	* @returns The registered command or undefined if not found
+	*/ getByPath(path) {
+		return this.commands.get(path);
+	}
+	/**
+	* Get all registered commands.
+	*
+	* @returns Map of path to registered command
+	*/ getAll() {
+		return new Map(this.commands);
+	}
+	/**
+	* Get all registered commands as an array of path and class pairs.
+	* Useful for listing available commands.
+	*
+	* @returns Array of objects containing path and class
+	*/ getAllAsArray() {
+		const result = [];
+		for (const [path, { class: cls }] of this.commands) result.push({
+			path,
+			class: cls
+		});
+		return result;
+	}
+	/**
+	* Formats help text listing all available commands with descriptions.
+	*
+	* @returns Formatted string listing all commands
+	*/ formatCommandList() {
+		const lines = ["Available commands:", ""];
+		for (const [path, { metadata }] of this.commands) {
+			const description = metadata.description;
+			if (description) lines.push(`  ${path.padEnd(20)} ${description}`);
+			else lines.push(`  ${path}`);
+		}
+		return lines.join("\n");
+	}
+	/**
+	* Formats help text for a specific command.
+	*
+	* @param commandPath - The command path to show help for
+	* @returns Formatted string with command help
+	*/ formatCommandHelp(commandPath) {
+		const command = this.commands.get(commandPath);
+		if (!command) return `Unknown command: ${commandPath}\n\n${this.formatCommandList()}`;
+		const { metadata } = command;
+		const lines = [];
+		lines.push(`Usage: ${metadata.path} [options]`);
+		lines.push("");
+		if (metadata.description) {
+			lines.push(metadata.description);
+			lines.push("");
+		}
+		if (metadata.optionsSchema) {
+			lines.push("Options:");
+			try {
+				const shape = metadata.optionsSchema.def.shape;
+				if (shape && typeof shape === "object") for (const [key, fieldSchema] of Object.entries(shape)) {
+					const optionFlag = `--${key.replace(/([A-Z])/g, "-$1").toLowerCase()}`;
+					const fieldType = this.getSchemaTypeName(fieldSchema);
+					lines.push(`  ${optionFlag.padEnd(20)} ${fieldType}`);
+				}
+			} catch {}
+		}
+		return lines.join("\n");
+	}
+	/**
+	* Gets a human-readable type name from a Zod schema.
+	*/ getSchemaTypeName(schema) {
+		try {
+			let currentSchema = schema;
+			let typeName = currentSchema?.def?.type;
+			let isOptional = false;
+			let defaultValue;
+			while (typeName === "optional" || typeName === "default") {
+				if (typeName === "optional") isOptional = true;
+				if (typeName === "default") {
+					isOptional = true;
+					defaultValue = currentSchema?.def?.defaultValue?.();
+				}
+				currentSchema = currentSchema?.def?.innerType;
+				typeName = currentSchema?.def?.type;
+			}
+			let result = `<${typeName || "unknown"}>`;
+			if (defaultValue !== void 0) result += ` (default: ${JSON.stringify(defaultValue)})`;
+			else if (isOptional) result += " (optional)";
+			const description = this.getSchemaMeta(schema)?.description;
+			if (description) result += ` - ${description}`;
+			return result;
+		} catch {
+			return "<unknown>";
+		}
+	}
+	/**
+	* Gets metadata from a Zod schema, traversing innerType if needed.
+	* Zod v4 stores meta at the outermost layer when .meta() is called last,
+	* or in innerType when .meta() is called before .optional()/.default().
+	*/ getSchemaMeta(schema) {
+		try {
+			const directMeta = schema.meta?.();
+			if (directMeta) return directMeta;
+			const innerType = schema.def?.innerType;
+			if (innerType) return this.getSchemaMeta(innerType);
+			return;
+		} catch {
+			return;
+		}
+	}
+	/**
+	* Clear all registered commands.
+	*/ clear() {
+		this.commands.clear();
+	}
+	static {
+		_initClass();
+	}
+};
+
+//#endregion
+//#region src/tokens/help-command.token.mts
+const HelpCommandToken = _navios_core.InjectionToken.create("HelpCommand");
+
+//#endregion
+Object.defineProperty(exports, 'Command', {
+  enumerable: true,
+  get: function () {
+    return Command;
+  }
+});
+Object.defineProperty(exports, 'CommandEntryKey', {
+  enumerable: true,
+  get: function () {
+    return CommandEntryKey;
+  }
+});
+Object.defineProperty(exports, 'CommandMetadataKey', {
+  enumerable: true,
+  get: function () {
+    return CommandMetadataKey;
+  }
+});
+Object.defineProperty(exports, 'HelpCommandToken', {
+  enumerable: true,
+  get: function () {
+    return HelpCommandToken;
+  }
+});
+Object.defineProperty(exports, '_CommandRegistryService', {
+  enumerable: true,
+  get: function () {
+    return _CommandRegistryService;
+  }
+});
+Object.defineProperty(exports, 'extractCommandMetadata', {
+  enumerable: true,
+  get: function () {
+    return extractCommandMetadata;
+  }
+});
+Object.defineProperty(exports, 'extractModuleCommands', {
+  enumerable: true,
+  get: function () {
+    return extractModuleCommands;
+  }
+});
+Object.defineProperty(exports, 'getCommandMetadata', {
+  enumerable: true,
+  get: function () {
+    return getCommandMetadata;
+  }
+});
+Object.defineProperty(exports, 'hasCommandMetadata', {
+  enumerable: true,
+  get: function () {
+    return hasCommandMetadata;
+  }
+});
+//# sourceMappingURL=help-command.token-DcvTjwbA.cjs.map

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

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