akanjs 2.0.0-rc.6 → 2.0.0

package/cli/workspace/workspace.runner.ts

@@ -1,12 +1,11 @@
 import path from "node:path";
 import { type Exec, type PackageJson, runner, type Workspace, WorkspaceExecutor } from "akanjs/devkit";
-import latestVersion from "latest-version";
 
 export class WorkspaceRunner extends runner("workspace") {
   async createWorkspace(
     repoName: string,
     appName: string,
-    { dirname = ".", tag = "latest", init = true }: { dirname?: string; tag?: string; init?: boolean },
+    { dirname = ".", init = true, akanVersion }: { dirname?: string; init?: boolean; akanVersion: string },
   ) {
     const cwdPath = process.cwd();
     const workspaceRoot = path.join(cwdPath, dirname, repoName);
@@ -21,18 +20,17 @@ export class WorkspaceRunner extends runner("workspace") {
     templateSpinner.succeed(`Workspace files created in ${dirname}/${repoName}`);
     
     const rootPackageJson = await workspace.getPackageJson();
-    const latestPublishedVersion = await latestVersion("akanjs", { version: tag });
     const packageJson: PackageJson = {
       ...rootPackageJson,
       dependencies: {
         ...rootPackageJson.dependencies,
-        akanjs: latestPublishedVersion,
+        akanjs: akanVersion,
       },
       devDependencies: {
         ...rootPackageJson.devDependencies,
       },
     };
-    workspace.setPackageJson(packageJson);
+    await workspace.setPackageJson(packageJson);
 
     if (init) {
       const installSpinner = workspace.spinning("Installing dependencies with bun...");
@@ -40,14 +38,6 @@ export class WorkspaceRunner extends runner("workspace") {
       installSpinner.succeed("Dependencies installed with bun");
     }
 
-    const gitSpinner = workspace.spinning("Initializing git repository and commit...");
-    try {
-      await workspace.commit("Initial commit", { init: true });
-      gitSpinner.succeed("Git repository initialized and committed");
-    } catch (_) {
-      gitSpinner.fail("Git repository initialization failed. It's not fatal, you can commit manually");
-    }
-
     return workspace;
   }
   async lint(exec: Exec, workspace: Workspace, { fix = true }: { fix?: boolean } = {}) {

package/cli/workspace/workspace.script.ts

@@ -1,29 +1,44 @@
+import path from "node:path";
 import { Logger } from "akanjs/common";
 import { AppExecutor, type Exec, LibExecutor, PkgExecutor, script, type Workspace } from "akanjs/devkit";
 
 import { ApplicationScript } from "../application/application.script";
 import { LibraryScript } from "../library/library.script";
+import { PackageScript } from "../package/package.script";
 import { WorkspaceRunner } from "./workspace.runner";
 
-export class WorkspaceScript extends script("workspace", [WorkspaceRunner, ApplicationScript, LibraryScript]) {
+export class WorkspaceScript extends script("workspace", [
+  WorkspaceRunner,
+  ApplicationScript,
+  LibraryScript,
+  PackageScript,
+]) {
   async createWorkspace(
     repoName: string,
     appName: string,
-    {
-      dirname = ".",
-      installLibs = false,
-      tag = "latest",
-      init = true,
-    }: { dirname?: string; installLibs?: boolean; tag?: string; init?: boolean },
+    { dirname = ".", installLibs = false, init = true }: { dirname?: string; installLibs?: boolean; init?: boolean },
   ) {
-    const workspace = await this.workspaceRunner.createWorkspace(repoName, appName, { dirname, tag, init });
+    const akanVersion = await this.packageScript.version({ log: false });
+    const workspace = await this.workspaceRunner.createWorkspace(repoName, appName, {
+      dirname,
+      init,
+      akanVersion,
+    });
     if (installLibs) {
       await this.libraryScript.installLibrary(workspace, "util");
       await this.libraryScript.installLibrary(workspace, "shared");
     }
     await this.applicationScript.createApplication(appName, workspace, { libs: installLibs ? ["util", "shared"] : [] });
+    const gitSpinner = workspace.spinning("Initializing git repository and commit...");
+    try {
+      await workspace.commit("Initial commit", { init: true });
+      gitSpinner.succeed("Git repository initialized and committed");
+    } catch (_) {
+      gitSpinner.fail("Git repository initialization failed. It's not fatal, you can commit manually");
+    }
+    const workspacePath = path.join(dirname, repoName);
     Logger.rawLog(`\n🎉 Welcome aboard! Workspace created in ${dirname}/${repoName}`);
-    Logger.rawLog(`🚀 Run \`cd ${repoName} && akan start ${appName}\` to start the development server.`);
+    Logger.rawLog(`🚀 Run \`cd ${workspacePath} && akan start ${appName}\` to start the development server.`);
     
     Logger.rawLog(`\n👋 Happy coding!`);
   }

package/client/csrTypes.ts

@@ -111,7 +111,7 @@ export interface LayoutModule {
 }
 export type RouteModule = PageModule | LayoutModule;
 export interface Route {
-  csrConfig?: PageConfig;
+  PageConfig?: PageConfig;
   path: string;
   renderPage?: RouteRender;
   renderLayout?: RouteRender;

package/constant/fieldInfo.ts

@@ -190,7 +190,7 @@ export class ConstantField<
   }
   static getBaseInsightField(): FieldObject {
     return {
-      count: field(Int, { default: 0, accumulate: { $sum: 1 } }).toField(),
+      count: field(Int, { default: 0, accumulate: {} }).toField(),
     };
   }
   readonly nullable: Nullable;

package/constant/serialize.ts

@@ -54,7 +54,7 @@ const serializeInput = <Input = unknown>(
       Object.entries(modelRef[FIELD_META]).map(([key, field]) => [
         key,
         field.isClass && !field.isScalar
-          ? serialize(ID, field.arrDepth, (value as Record<string, unknown>)?.[key], serializeType, {
+          ? serialize(ID, field.arrDepth, getRelationId((value as Record<string, unknown>)?.[key]), serializeType, {
               nullable: field.nullable,
               key,
             })
@@ -67,6 +67,12 @@ const serializeInput = <Input = unknown>(
   }
 };
 
+const getRelationId = (value: unknown): unknown => {
+  if (Array.isArray(value)) return value.map((item) => getRelationId(item));
+  if (value && typeof value === "object" && "id" in value) return (value as { id: unknown }).id;
+  return value;
+};
+
 export const serialize = (
   argRef: ConstantCls | PrimitiveScalar,
   arrDepth: number,

package/devkit/capacitor.base.config.ts

@@ -53,7 +53,7 @@ export const withBase = (
             androidScheme: "http",
             url: localCsrUrl(ip, target),
             cleartext: true,
-            allowNavigation: [`http://${ip}:8282/*`],
+            allowNavigation: [ip, "localhost"],
           }
         : {
             allowNavigation: ["*"],

package/devkit/capacitorApp.ts

@@ -201,7 +201,11 @@ export class CapacitorApp {
       .relative(this.targetRoot, path.join(this.app.cwdPath, "akan.app.json"))
       .split(path.sep)
       .join("/");
-    const content = `import { withBase } from "akanjs/devkit/capacitor.base.config";
+    const baseConfigPath = path
+      .relative(this.targetRoot, path.join(this.app.workspace.cwdPath, "pkgs/akanjs/devkit/capacitor.base.config"))
+      .split(path.sep)
+      .join("/");
+    const content = `import { withBase } from "${baseConfigPath.startsWith(".") ? baseConfigPath : `./${baseConfigPath}`}";
 import appInfo from "${appInfoPath}";
 
 export default withBase((config) => config, appInfo, "${this.target.name}");

package/devkit/commandDecorators/argMeta.ts

@@ -18,19 +18,33 @@ export type InternalArgType = (typeof internalArgTypes)[number];
 export type PrimitiveArgType = StringConstructor | NumberConstructor | BooleanConstructor;
 export type NormalizedPrimitiveArgType = "string" | "number" | "boolean";
 
-export interface ArgsOption {
+export type CommandContext = {
+  values: Record<string, unknown>;
+  app?: AppExecutor;
+  lib?: LibExecutor;
+  sys?: SysExecutor;
+  pkg?: PkgExecutor;
+  module?: ModuleExecutor;
+  exec?: Executor;
+};
+
+export type EnumChoice = string | number | { label: string; value: string | number | boolean };
+export type EnumChoices = readonly EnumChoice[];
+export type DynamicEnum<Context> = (context: Context) => EnumChoices | Promise<EnumChoices>;
+
+export interface ArgsOption<Context = CommandContext> {
   type?: "string" | "number" | "boolean";
   flag?: string;
   desc?: string;
   default?: string | number | boolean;
   nullable?: boolean;
   example?: string | number | boolean;
-  enum?: (string | number)[] | readonly (string | number)[] | { label: string; value: string | number | boolean }[];
+  enum?: EnumChoices | DynamicEnum<Context>;
   ask?: string;
 }
-export interface ArgMeta {
+export interface ArgMeta<Context = CommandContext> {
   name: string;
-  argsOption: ArgsOption;
+  argsOption: ArgsOption<Context>;
   key: string;
   idx: number;
   type: ArgType;
@@ -52,12 +66,12 @@ export const getArgMetas = (
   return [allArgMetas, argMetas, internalArgMetas];
 };
 
-export interface InternalArgToken<T = unknown> {
-  type: InternalArgType;
+export interface InternalArgToken<T = unknown, Type extends InternalArgType = InternalArgType> {
+  type: Type;
   _value: T;
 }
 
-const createInternalArgToken = <T>(type: InternalArgType) => ({ type }) as InternalArgToken<T>;
+const createInternalArgToken = <T, Type extends InternalArgType>(type: Type) => ({ type }) as InternalArgToken<T, Type>;
 
 export const normalizePrimitiveArgType = (type: PrimitiveArgType): NormalizedPrimitiveArgType => {
   if (type === String) return "string";
@@ -66,23 +80,23 @@ export const normalizePrimitiveArgType = (type: PrimitiveArgType): NormalizedPri
   throw new Error(`Invalid primitive argument type: ${type}`);
 };
 
-export const App = createInternalArgToken<AppExecutor>("App");
+export const App = createInternalArgToken<AppExecutor, "App">("App");
 export type App = AppExecutor;
 
-export const Lib = createInternalArgToken<LibExecutor>("Lib");
+export const Lib = createInternalArgToken<LibExecutor, "Lib">("Lib");
 export type Lib = LibExecutor;
 
-export const Sys = createInternalArgToken<SysExecutor>("Sys");
+export const Sys = createInternalArgToken<SysExecutor, "Sys">("Sys");
 export type Sys = SysExecutor;
 
-export const Exec = createInternalArgToken<Executor>("Exec");
+export const Exec = createInternalArgToken<Executor, "Exec">("Exec");
 export type Exec = Executor;
 
-export const Pkg = createInternalArgToken<PkgExecutor>("Pkg");
+export const Pkg = createInternalArgToken<PkgExecutor, "Pkg">("Pkg");
 export type Pkg = PkgExecutor;
 
-export const Module = createInternalArgToken<ModuleExecutor>("Module");
+export const Module = createInternalArgToken<ModuleExecutor, "Module">("Module");
 export type Module = ModuleExecutor;
 
-export const Workspace = createInternalArgToken<WorkspaceExecutor>("Workspace");
+export const Workspace = createInternalArgToken<WorkspaceExecutor, "Workspace">("Workspace");
 export type Workspace = WorkspaceExecutor;

package/devkit/commandDecorators/command.ts

@@ -5,7 +5,14 @@ import { type Command, program } from "commander";
 
 import { FileSys, getDirname, type PackageJson } from "..";
 import { AppExecutor, Executor, LibExecutor, ModuleExecutor, PkgExecutor, WorkspaceExecutor } from "../executors";
-import { type ArgMeta, getArgMetas, type InternalArgMeta } from "./argMeta";
+import {
+  type ArgMeta,
+  type CommandContext,
+  type EnumChoice,
+  type EnumChoices,
+  getArgMetas,
+  type InternalArgMeta,
+} from "./argMeta";
 import { CommandContainer } from "./dependencyBuilder";
 import { formatCommandHelp, formatHelp } from "./helpFormatter";
 import { type CommandCls, getTargetMetas } from "./targetMeta";
@@ -22,11 +29,7 @@ const handleOption = (programCommand: Command, argMeta: ArgMeta) => {
     ask,
   } = argMeta.argsOption;
   const kebabName = camelToKebabCase(argMeta.name);
-  const choices = enumChoices?.map((choice: string | number | { label: string; value: string | number | boolean }) =>
-    typeof choice === "object"
-      ? { value: choice.value, name: choice.label }
-      : { value: choice, name: choice.toString() },
-  );
+  const choices = enumChoices && typeof enumChoices !== "function" ? normalizeEnumChoices(enumChoices) : null;
   programCommand.option(
     `-${flag}, --${kebabName}${type === "boolean" ? " [boolean]" : ` <${kebabName}>`}`,
     `${desc}${ask ? ` (${ask})` : ""}${example ? ` (example: ${example})` : ""}${choices ? ` (choices: ${choices.map((choice) => choice.name).join(", ")})` : ""}`,
@@ -48,24 +51,34 @@ const convertArgValue = (value: string | boolean, type: "string" | "number" | "b
   else return value === true || value === "true";
 };
 
-const getOptionValue = async (argMeta: ArgMeta, opt: Record<string, unknown>) => {
+const normalizeEnumChoices = (enumChoices: EnumChoices) =>
+  enumChoices.map((choice: EnumChoice) =>
+    typeof choice === "object"
+      ? { value: choice.value, name: choice.label }
+      : { value: choice, name: choice.toString() },
+  );
+
+const resolveEnumChoices = async (argMeta: ArgMeta, context: CommandContext) => {
+  const enumChoices = argMeta.argsOption.enum;
+  if (!enumChoices) return null;
+  if (typeof enumChoices === "function") return await enumChoices(context);
+  return enumChoices;
+};
+
+const getOptionValue = async (argMeta: ArgMeta, opt: Record<string, unknown>, context: CommandContext) => {
   const {
     name,
     argsOption: { enum: enumChoices, default: defaultValue, type, desc, nullable, example, ask },
   } = argMeta;
   if (opt[argMeta.name] !== undefined) return convertArgValue(opt[argMeta.name] as string, type ?? "string");
   else if (defaultValue !== undefined) return defaultValue;
-  else if (nullable) return null;
 
   if (enumChoices) {
-    const choices = enumChoices.map((choice: string | number | { label: string; value: string | number | boolean }) =>
-      typeof choice === "object"
-        ? { value: choice.value, name: choice.label }
-        : { value: choice, name: choice.toString() },
-    );
+    const choices = normalizeEnumChoices((await resolveEnumChoices(argMeta, context)) ?? []);
     const choice = await select({ message: ask ?? desc ?? `Select the ${name} value`, choices });
     return choice;
-  } else if (type === "boolean") {
+  } else if (nullable) return null;
+  else if (type === "boolean") {
     const message = ask ?? desc ?? `Do you want to set ${name}? ${desc ? ` (${desc})` : ""}: `;
     return await confirm({ message });
   } else {
@@ -96,6 +109,16 @@ const getArgumentValue = async (argMeta: ArgMeta, value: string | undefined) =>
   return convertArgValue(await input({ message }), type ?? "string");
 };
 
+const assignCommandContext = (context: CommandContext, argMeta: ArgMeta | InternalArgMeta, value: unknown) => {
+  if (value instanceof AppExecutor) context.app = value;
+  else if (value instanceof LibExecutor) context.lib = value;
+  else if (value instanceof PkgExecutor) context.pkg = value;
+  else if (value instanceof ModuleExecutor) context.module = value;
+  else if (value instanceof Executor) context.exec = value;
+  if (argMeta.type === "Argument" || argMeta.type === "Option") context.values[argMeta.name] = value;
+  else context.values[argMeta.type.toLowerCase()] = value;
+};
+
 const assertCurrentDirectoryIsWorkspaceRoot = async () => {
   const cwd = process.cwd();
   const [hasPackageJson, hasTsConfig, hasEnv] = await Promise.all([
@@ -281,8 +304,10 @@ It may cause unexpected behavior. Run \`akan update\` to update latest akanjs.`,
           const commandArgs = [] as unknown[];
           if (targetMeta.targetOption.runsOnWorkspaceRoot) await assertCurrentDirectoryIsWorkspaceRoot();
           const workspace = WorkspaceExecutor.fromRoot();
+          const commandContext: CommandContext = { values: {} };
           for (const argMeta of allArgMetas) {
-            if (argMeta.type === "Option") commandArgs[argMeta.idx] = await getOptionValue(argMeta, opt);
+            if (argMeta.type === "Option")
+              commandArgs[argMeta.idx] = await getOptionValue(argMeta, opt, commandContext);
             else if (argMeta.type === "Argument")
               commandArgs[argMeta.idx] = await getArgumentValue(argMeta, cmdArgs[argMeta.idx] as string);
             else
@@ -294,6 +319,7 @@ It may cause unexpected behavior. Run \`akan update\` to update latest akanjs.`,
             
             if (commandArgs[argMeta.idx] instanceof AppExecutor)
               process.env.AKAN_PUBLIC_APP_NAME = (commandArgs[argMeta.idx] as AppExecutor).name;
+            assignCommandContext(commandContext, argMeta, commandArgs[argMeta.idx]);
             if ((opt as { verbose?: boolean }).verbose) Executor.setVerbose(true);
           }
           const cmd = CommandContainer.get(command);

package/devkit/commandDecorators/commandBuilder.ts

@@ -1,4 +1,17 @@
-import type { ArgMeta, ArgsOption, InternalArgMeta, InternalArgToken, PrimitiveArgType } from "./argMeta";
+import type {
+  App,
+  ArgMeta,
+  ArgsOption,
+  CommandContext,
+  Exec,
+  InternalArgMeta,
+  InternalArgToken,
+  Lib,
+  Module,
+  Pkg,
+  PrimitiveArgType,
+  Sys,
+} from "./argMeta";
 import { normalizePrimitiveArgType } from "./argMeta";
 import { assertUniqueDependencies, type DependencyInstanceMap, injectDependencies } from "./dependencyBuilder";
 import { COMMAND_META, type CommandCls, type TargetMeta, type TargetOption } from "./targetMeta";
@@ -9,9 +22,8 @@ type PrimitiveValue<T extends PrimitiveArgType> = T extends StringConstructor
   : T extends NumberConstructor
     ? number
     : boolean;
-type ArgsOptionInput = Record<string, never> | ArgsOption;
-type MaybeNullable<Value, Option extends ArgsOptionInput> = Option extends { nullable: true } ? Value | null : Value;
-type AddArg<Params extends unknown[], Type extends PrimitiveArgType, Option extends ArgsOptionInput> = [
+type MaybeNullable<Value, Option> = Option extends { nullable: true } ? Value | null : Value;
+type AddArg<Params extends unknown[], Type extends PrimitiveArgType, Option> = [
   ...Params,
   MaybeNullable<PrimitiveValue<Type>, Option>,
 ];
@@ -22,12 +34,31 @@ type AddInternalArgs<Params extends unknown[], Tokens extends readonly InternalA
 ]
   ? AddInternalArgs<AddInternalArg<Params, Head>, Rest>
   : Params;
+type ContextFromToken<Token extends InternalArgToken> = Token["_value"] extends App
+  ? { app: App }
+  : Token["_value"] extends Lib
+    ? { lib: Lib }
+    : Token["_value"] extends Sys
+      ? { sys: Sys }
+      : Token["_value"] extends Pkg
+        ? { pkg: Pkg }
+        : Token["_value"] extends Module
+          ? { module: Module }
+          : Token["_value"] extends Exec
+            ? { exec: Exec }
+            : object;
+type AddInternalContext<Context, Tokens extends readonly InternalArgToken[]> = Tokens extends readonly [
+  infer Head extends InternalArgToken,
+  ...infer Rest extends InternalArgToken[],
+]
+  ? AddInternalContext<Context & ContextFromToken<Head>, Rest>
+  : Context;
 type CommandHandler<Deps extends readonly DependencyCls[], Params extends unknown[]> = (
   this: DependencyInstanceMap<Deps>,
   ...args: Params
 ) => unknown | Promise<unknown>;
 
-class TargetBuilder<Deps extends readonly DependencyCls[], Params extends unknown[] = []> {
+class TargetBuilder<Deps extends readonly DependencyCls[], Params extends unknown[] = [], Context = object> {
   readonly #args: (ArgMeta | InternalArgMeta)[];
 
   constructor(
@@ -37,12 +68,12 @@ class TargetBuilder<Deps extends readonly DependencyCls[], Params extends unknow
     this.#args = args;
   }
 
-  arg<Type extends PrimitiveArgType, Option extends ArgsOptionInput = Record<string, never>>(
+  arg<Type extends PrimitiveArgType, Option extends ArgsOption<Context> = ArgsOption<Context>>(
     name: string,
     type: Type,
     argsOption: Option = {} as Option,
-  ): TargetBuilder<Deps, AddArg<Params, Type, Option>> {
-    return new TargetBuilder(this.targetOption, [
+  ): TargetBuilder<Deps, AddArg<Params, Type, Option>, Context> {
+    return new TargetBuilder<Deps, AddArg<Params, Type, Option>, Context>(this.targetOption, [
       ...this.#args,
       {
         name,
@@ -50,16 +81,16 @@ class TargetBuilder<Deps extends readonly DependencyCls[], Params extends unknow
         key: "",
         idx: this.#args.length,
         type: "Argument",
-      },
+      } as ArgMeta<CommandContext>,
     ]);
   }
 
-  option<Type extends PrimitiveArgType, Option extends ArgsOptionInput = Record<string, never>>(
+  option<Type extends PrimitiveArgType, Option extends ArgsOption<Context> = ArgsOption<Context>>(
     name: string,
     type: Type,
     argsOption: Option = {} as Option,
-  ): TargetBuilder<Deps, AddArg<Params, Type, Option>> {
-    return new TargetBuilder(this.targetOption, [
+  ): TargetBuilder<Deps, AddArg<Params, Type, Option>, Context> {
+    return new TargetBuilder<Deps, AddArg<Params, Type, Option>, Context>(this.targetOption, [
       ...this.#args,
       {
         name,
@@ -67,24 +98,27 @@ class TargetBuilder<Deps extends readonly DependencyCls[], Params extends unknow
         key: "",
         idx: this.#args.length,
         type: "Option",
-      },
+      } as ArgMeta<CommandContext>,
     ]);
   }
 
-  with<Tokens extends readonly InternalArgToken[]>(
+  with<const Tokens extends readonly InternalArgToken[]>(
     ...tokens: Tokens
-  ): TargetBuilder<Deps, AddInternalArgs<Params, Tokens>> {
-    return new TargetBuilder(this.targetOption, [
-      ...this.#args,
-      ...tokens.map(
-        (token, offset) =>
-          ({
-            key: "",
-            idx: this.#args.length + offset,
-            type: token.type,
-          }) satisfies InternalArgMeta,
-      ),
-    ]);
+  ): TargetBuilder<Deps, AddInternalArgs<Params, Tokens>, AddInternalContext<Context, Tokens>> {
+    return new TargetBuilder<Deps, AddInternalArgs<Params, Tokens>, AddInternalContext<Context, Tokens>>(
+      this.targetOption,
+      [
+        ...this.#args,
+        ...tokens.map(
+          (token, offset) =>
+            ({
+              key: "",
+              idx: this.#args.length + offset,
+              type: token.type,
+            }) satisfies InternalArgMeta,
+        ),
+      ],
+    );
   }
 
   exec(handler: CommandHandler<Deps, Params>) {
@@ -101,12 +135,12 @@ type CommandBuilderContext<Deps extends readonly DependencyCls[]> = {
   public: (targetOption?: Omit<TargetOption, "type">) => TargetBuilder<Deps>;
   cloud: (targetOption?: Omit<TargetOption, "type">) => TargetBuilder<Deps>;
   dev: (targetOption?: Omit<TargetOption, "type">) => TargetBuilder<Deps>;
-  arg: <Type extends PrimitiveArgType, Option extends ArgsOptionInput = Record<string, never>>(
+  arg: <Type extends PrimitiveArgType, Option extends ArgsOption<CommandContext> = ArgsOption<CommandContext>>(
     name: string,
     type: Type,
     argsOption?: Option,
   ) => ArgMeta;
-  option: <Type extends PrimitiveArgType, Option extends ArgsOptionInput = Record<string, never>>(
+  option: <Type extends PrimitiveArgType, Option extends ArgsOption<CommandContext> = ArgsOption<CommandContext>>(
     name: string,
     type: Type,
     argsOption?: Option,
@@ -125,20 +159,22 @@ const createContext = <Deps extends readonly DependencyCls[]>(): CommandBuilderC
   public: createTarget<Deps>("public"),
   cloud: createTarget<Deps>("cloud"),
   dev: createTarget<Deps>("dev"),
-  arg: (name, type, argsOption) => ({
-    name,
-    argsOption: { ...(argsOption ?? {}), type: normalizePrimitiveArgType(type) },
-    key: "",
-    idx: -1,
-    type: "Argument",
-  }),
-  option: (name, type, argsOption) => ({
-    name,
-    argsOption: { ...(argsOption ?? {}), type: normalizePrimitiveArgType(type) },
-    key: "",
-    idx: -1,
-    type: "Option",
-  }),
+  arg: (name, type, argsOption) =>
+    ({
+      name,
+      argsOption: { ...(argsOption ?? {}), type: normalizePrimitiveArgType(type) },
+      key: "",
+      idx: -1,
+      type: "Argument",
+    }) as ArgMeta<CommandContext>,
+  option: (name, type, argsOption) =>
+    ({
+      name,
+      argsOption: { ...(argsOption ?? {}), type: normalizePrimitiveArgType(type) },
+      key: "",
+      idx: -1,
+      type: "Option",
+    }) as ArgMeta<CommandContext>,
 });
 
 const buildCommandMeta = (definitions: Record<string, TargetDefinition>) => {

package/devkit/commandDecorators/helpFormatter.ts

@@ -1,11 +1,10 @@
 import chalk from "chalk";
 
-import { getArgMetas } from "./argMeta";
+import { type EnumChoice, getArgMetas } from "./argMeta";
 import { type CommandCls, getTargetMetas } from "./targetMeta";
 
 const camelToKebabCase = (str: string) => str.replace(/([A-Z])/g, "-$1").toLowerCase();
-const formatChoice = (choice: string | number | { label: string; value: string | number | boolean }) =>
-  typeof choice === "object" ? choice.label : choice.toString();
+const formatChoice = (choice: EnumChoice) => (typeof choice === "object" ? choice.label : choice.toString());
 
 const groupCommands = (commands: CommandCls[]) => {
   const groups = new Map<string, { name: string; commands: { key: string; args: string[]; desc?: string }[] }>();
@@ -207,7 +206,11 @@ export const formatCommandHelp = (command: CommandCls, key: string) => {
       const optName = `${flag}--${kebabName}`;
       const optDesc = opt.desc ?? "";
       const defaultVal = opt.default !== undefined ? chalk.gray(` [default: ${String(opt.default)}]`) : "";
-      const choices = opt.enum ? chalk.gray(` (${opt.enum.map(formatChoice).join(", ")})`) : "";
+      const choices = opt.enum
+        ? chalk.gray(
+            typeof opt.enum === "function" ? " ([dynamic choices])" : ` (${opt.enum.map(formatChoice).join(", ")})`,
+          )
+        : "";
       lines.push(`      ${chalk.green(optName)}      ${chalk.gray(optDesc)}${defaultVal}${choices}`);
     }
     lines.push("");