@akanjs/cli 2.4.0-rc.9 → 2.4.1-rc.0

package/index-hdqztm58.js

@@ -0,0 +1,758 @@
+// @bun
+import {
+  AppExecutor,
+  Executor,
+  LibExecutor,
+  ModuleExecutor,
+  PkgExecutor,
+  WorkspaceExecutor,
+  getDirname
+} from "./index-a6sbyy0b.js";
+import {
+  FileSys
+} from "./index-61keag0s.js";
+
+// pkgs/@akanjs/devkit/commandDecorators/targetMeta.ts
+var COMMAND_META = Symbol("akan.command.meta");
+var getTargetMetas = (command) => {
+  const targetMetaMap = command[COMMAND_META];
+  if (!targetMetaMap)
+    throw new Error(`TargetMeta is not defined for ${command.name}`);
+  return [...targetMetaMap.values()];
+};
+var camelToKebabCase = (str) => str.replace(/([A-Z])/g, "-$1").toLowerCase();
+var getTargetCommandNames = (targetMeta) => {
+  const kebabKey = camelToKebabCase(targetMeta.key);
+  if (targetMeta.targetOption.short !== true)
+    return [kebabKey];
+  return [
+    kebabKey,
+    kebabKey.split("-").map((s) => s.slice(0, 1)).join("")
+  ];
+};
+
+// pkgs/@akanjs/devkit/commandDecorators/argMeta.ts
+var getArgMetas = (command, key) => {
+  const allArgMetas = [...command[COMMAND_META]?.get(key)?.args ?? []];
+  const argMetas = allArgMetas.filter((argMeta) => argMeta.type === "Option");
+  const internalArgMetas = allArgMetas.filter((argMeta) => argMeta.type !== "Option");
+  return [allArgMetas, argMetas, internalArgMetas];
+};
+var createInternalArgToken = (type) => ({ type });
+var normalizePrimitiveArgType = (type) => {
+  if (type === String)
+    return "string";
+  if (type === Number)
+    return "number";
+  if (type === Boolean)
+    return "boolean";
+  throw new Error(`Invalid primitive argument type: ${type}`);
+};
+var App = createInternalArgToken("App");
+var Lib = createInternalArgToken("Lib");
+var Sys = createInternalArgToken("Sys");
+var Exec = createInternalArgToken("Exec");
+var Pkg = createInternalArgToken("Pkg");
+var Module = createInternalArgToken("Module");
+var Workspace = createInternalArgToken("Workspace");
+
+// pkgs/@akanjs/devkit/commandDecorators/command.ts
+import path from "path";
+import { confirm, input, select } from "@inquirer/prompts";
+import { Logger } from "akanjs/common";
+import chalk2 from "chalk";
+import { program } from "commander";
+
+// pkgs/@akanjs/devkit/commandDecorators/dependencyBuilder.ts
+var capitalize = (value) => value.slice(0, 1).toUpperCase() + value.slice(1);
+var createDependencyKey = (refName, kind) => `${refName}${capitalize(kind)}`;
+
+class CommandContainer {
+  static #instances = new Map;
+  static #resolving = new Set;
+  static get(dep) {
+    const instance = CommandContainer.#instances.get(dep);
+    if (instance)
+      return instance;
+    if (CommandContainer.#resolving.has(dep))
+      throw new Error(`Circular command dependency: ${dep.name}`);
+    CommandContainer.#resolving.add(dep);
+    try {
+      const nextInstance = new dep;
+      CommandContainer.#instances.set(dep, nextInstance);
+      return nextInstance;
+    } finally {
+      CommandContainer.#resolving.delete(dep);
+    }
+  }
+  static clear() {
+    CommandContainer.#instances.clear();
+    CommandContainer.#resolving.clear();
+  }
+}
+var getDependencyKey = (dep) => dep.dependencyKey;
+var assertUniqueDependencies = (deps) => {
+  const keys = new Map;
+  const classes = new Set;
+  for (const dep of deps) {
+    if (classes.has(dep))
+      throw new Error(`Duplicate command dependency class: ${dep.name}`);
+    classes.add(dep);
+    const key = getDependencyKey(dep);
+    const existing = keys.get(key);
+    if (existing)
+      throw new Error(`Duplicate command dependency key "${key}": ${existing.name}, ${dep.name}`);
+    keys.set(key, dep);
+  }
+};
+var injectDependencies = (target, deps) => {
+  assertUniqueDependencies(deps);
+  for (const dep of deps) {
+    Object.defineProperty(target, getDependencyKey(dep), {
+      configurable: true,
+      enumerable: false,
+      value: CommandContainer.get(dep),
+      writable: false
+    });
+  }
+  return target;
+};
+var runner = (refName) => {
+
+  class RunnerBase {
+    static refName = refName;
+    static dependencyKind = "runner";
+    static dependencyKey = createDependencyKey(refName, "runner");
+  }
+  return RunnerBase;
+};
+var script = (refName, deps = []) => {
+  assertUniqueDependencies(deps);
+
+  class ScriptBase {
+    static refName = refName;
+    static dependencyKind = "script";
+    static dependencyKey = createDependencyKey(refName, "script");
+    constructor() {
+      injectDependencies(this, deps);
+    }
+  }
+  return ScriptBase;
+};
+
+// pkgs/@akanjs/devkit/commandDecorators/helpFormatter.ts
+import chalk from "chalk";
+var camelToKebabCase2 = (str) => str.replace(/([A-Z])/g, "-$1").toLowerCase();
+var formatChoice = (choice) => typeof choice === "object" ? choice.label : choice.toString();
+var groupCommands = (commands) => {
+  const groups = new Map;
+  for (const command of commands) {
+    const className = command.name.replace("Command", "");
+    const groupName = className;
+    if (!groups.has(groupName)) {
+      groups.set(groupName, { name: groupName, commands: [] });
+    }
+    const targetMetas = getTargetMetas(command);
+    for (const targetMeta of targetMetas) {
+      if (targetMeta.targetOption.devOnly)
+        continue;
+      const [allArgMetas] = getArgMetas(command, targetMeta.key);
+      const args = allArgMetas.filter((arg) => arg.type !== "Option").map((arg) => {
+        if (arg.type === "Workspace")
+          return "";
+        if (arg.type === "Module")
+          return "[sys:module]";
+        if (arg.type === "Argument") {
+          return `[${arg.name}]`;
+        }
+        return `[${arg.type.toLowerCase()}]`;
+      }).filter(Boolean);
+      const group = groups.get(groupName);
+      if (group) {
+        group.commands.push({
+          key: camelToKebabCase2(targetMeta.key),
+          args,
+          desc: targetMeta.targetOption.desc
+        });
+      }
+    }
+  }
+  return groups;
+};
+var formatHelp = (commands, version) => {
+  const groups = groupCommands(commands);
+  const lines = [];
+  lines.push("");
+  lines.push(chalk.bold.cyan("  \u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557"));
+  lines.push(chalk.bold.cyan("  \u2551") + chalk.bold.white("              Akan.js Framework CLI            ") + chalk.bold.cyan("    \u2551"));
+  lines.push(chalk.bold.cyan("  \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D"));
+  lines.push("");
+  lines.push(chalk.gray(`  Version: ${version}`));
+  lines.push("");
+  lines.push(chalk.bold.yellow("  USAGE"));
+  lines.push("");
+  lines.push(chalk.gray("    $ ") + chalk.white("akan") + chalk.gray(" <command> [options]"));
+  lines.push("");
+  lines.push(chalk.bold.yellow("  COMMANDS"));
+  lines.push("");
+  for (const [groupName, group] of groups) {
+    if (group.commands.length === 0)
+      continue;
+    lines.push(chalk.bold.magenta(`    ${groupName}`));
+    lines.push("");
+    for (const cmd of group.commands) {
+      const cmdName = chalk.green(cmd.key);
+      const cmdArgs = cmd.args.length > 0 ? chalk.gray(` ${cmd.args.join(" ")}`) : "";
+      if (cmd.desc) {
+        const maxLineLength = 70;
+        const cmdPrefix = `      ${cmdName}${cmdArgs}`;
+        const indent = "        ";
+        if (cmdPrefix.length + cmd.desc.length + 3 < maxLineLength) {
+          lines.push(`${cmdPrefix}  ${chalk.gray(cmd.desc)}`);
+        } else {
+          lines.push(cmdPrefix);
+          lines.push(`${indent}${chalk.gray(cmd.desc)}`);
+        }
+      } else {
+        lines.push(`      ${cmdName}${cmdArgs}`);
+      }
+    }
+    lines.push("");
+  }
+  lines.push(chalk.bold.yellow("  OPTIONS"));
+  lines.push("");
+  lines.push(`      ${chalk.green("-v, --verbose")}      ${chalk.gray("Enable verbose output")}`);
+  lines.push(`      ${chalk.green("-h, --help")}         ${chalk.gray("Display this help message")}`);
+  lines.push(`      ${chalk.green("-V, --version")}      ${chalk.gray("Output version number")}`);
+  lines.push("");
+  lines.push(chalk.bold.yellow("  EXAMPLES"));
+  lines.push("");
+  lines.push(chalk.gray("    # Create a new workspace"));
+  lines.push(chalk.white("    $ akan create-workspace myproject"));
+  lines.push("");
+  lines.push(chalk.gray("    # Start development server"));
+  lines.push(chalk.white("    $ akan start myapp"));
+  lines.push("");
+  lines.push(chalk.gray("    # Create a new module"));
+  lines.push(chalk.white("    $ akan create-module userProfile"));
+  lines.push("");
+  lines.push(chalk.gray("  Documentation: ") + chalk.cyan("https://akanjs.com/docs"));
+  lines.push(chalk.gray("  Report issues: ") + chalk.cyan("https://github.com/akan-team/akanjs/issues"));
+  lines.push("");
+  return lines.join(`
+`);
+};
+var formatCommandHelp = (command, key) => {
+  const [allArgMetas, argMetas] = getArgMetas(command, key);
+  const kebabKey = camelToKebabCase2(key);
+  const lines = [];
+  const targetMetas = getTargetMetas(command);
+  const targetMeta = targetMetas.find((t) => t.key === key);
+  const commandDesc = targetMeta?.targetOption.desc;
+  lines.push("");
+  lines.push(chalk.bold.cyan(`  Command: ${kebabKey}`));
+  if (commandDesc) {
+    lines.push(chalk.gray(`  ${commandDesc}`));
+  }
+  lines.push("");
+  const args = allArgMetas.filter((arg) => arg.type !== "Option").map((arg) => {
+    if (arg.type === "Workspace")
+      return "";
+    if (arg.type === "Module")
+      return "[sys:module]";
+    if (arg.type === "Argument") {
+      return `[${camelToKebabCase2(arg.name)}]`;
+    }
+    return `[${arg.type.toLowerCase()}]`;
+  }).filter(Boolean).join(" ");
+  lines.push(chalk.bold.yellow("  USAGE"));
+  lines.push("");
+  lines.push(chalk.gray("    $ ") + chalk.white(`akan ${kebabKey}`) + (args ? chalk.gray(` ${args}`) : ""));
+  lines.push("");
+  const nonOptionArgs = allArgMetas.filter((arg) => arg.type !== "Option");
+  if (nonOptionArgs.length > 0) {
+    lines.push(chalk.bold.yellow("  ARGUMENTS"));
+    lines.push("");
+    for (const arg of nonOptionArgs) {
+      if (arg.type === "Workspace")
+        continue;
+      let argName;
+      let argDesc;
+      let example = "";
+      if (arg.type === "Argument") {
+        argName = camelToKebabCase2(arg.name);
+        argDesc = arg.argsOption.desc ?? "";
+        example = arg.argsOption.example ? chalk.gray(` (e.g., ${String(arg.argsOption.example)})`) : "";
+      } else if (arg.type === "Module") {
+        argName = "sys:module";
+        argDesc = "Module in format: app-name:module-name or lib-name:module-name";
+      } else {
+        argName = arg.type.toLowerCase();
+        argDesc = `${arg.type} name in this workspace`;
+      }
+      lines.push(`      ${chalk.green(argName)}      ${chalk.gray(argDesc)}${example}`);
+    }
+    lines.push("");
+  }
+  const optionArgs = argMetas.filter((a) => a.type === "Option");
+  if (optionArgs.length > 0) {
+    lines.push(chalk.bold.yellow("  OPTIONS"));
+    lines.push("");
+    for (const arg of optionArgs) {
+      const opt = arg.argsOption;
+      const flag = opt.flag ? `-${opt.flag}, ` : "";
+      const kebabName = camelToKebabCase2(arg.name);
+      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(typeof opt.enum === "function" ? " ([dynamic choices])" : ` (${opt.enum.map(formatChoice).join(", ")})`) : "";
+      lines.push(`      ${chalk.green(optName)}      ${chalk.gray(optDesc)}${defaultVal}${choices}`);
+    }
+    lines.push("");
+  }
+  return lines.join(`
+`);
+};
+
+// pkgs/@akanjs/devkit/commandDecorators/command.ts
+var camelToKebabCase3 = (str) => str.replace(/([A-Z])/g, "-$1").toLowerCase();
+var loggedCliErrorObjects = new WeakSet;
+var loggedCliErrorMessages = new Set;
+var formatCliError = (error) => {
+  if (error instanceof Error)
+    return error.message || error.name;
+  if (typeof error === "string")
+    return error.trim() || "Unknown error";
+  if (error === null || error === undefined)
+    return "Unknown error";
+  try {
+    const json = JSON.stringify(error);
+    if (json)
+      return json;
+  } catch {
+    return String(error);
+  }
+  return String(error) || "Unknown error";
+};
+var printCliError = (error) => {
+  if (typeof error === "object" && error !== null) {
+    if (loggedCliErrorObjects.has(error))
+      return;
+    loggedCliErrorObjects.add(error);
+  }
+  const message = formatCliError(error);
+  if (loggedCliErrorMessages.has(message))
+    return;
+  loggedCliErrorMessages.add(message);
+  Logger.rawLog(`
+${chalk2.red(message)}`);
+};
+var handleOption = (programCommand, argMeta) => {
+  const {
+    type,
+    flag = argMeta.name.slice(0, 1).toLowerCase(),
+    desc = argMeta.name,
+    example,
+    enum: enumChoices,
+    ask
+  } = argMeta.argsOption;
+  const kebabName = camelToKebabCase3(argMeta.name);
+  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(", ")})` : ""}`);
+  return programCommand;
+};
+var handleArgument = (programCommand, argMeta) => {
+  const kebabName = camelToKebabCase3(argMeta.name);
+  programCommand.argument(`[${kebabName}]`, `${argMeta.argsOption.desc}${argMeta.argsOption.example ? ` (example: ${argMeta.argsOption.example})` : ""}`);
+  return programCommand;
+};
+var convertArgValue = (value, type) => {
+  if (type === "string")
+    return value;
+  else if (type === "number")
+    return Number(value);
+  else
+    return value === true || value === "true";
+};
+var normalizeEnumChoices = (enumChoices) => enumChoices.map((choice) => typeof choice === "object" ? { value: choice.value, name: choice.label } : { value: choice, name: choice.toString() });
+var resolveEnumChoices = async (argMeta, context) => {
+  const enumChoices = argMeta.argsOption.enum;
+  if (!enumChoices)
+    return null;
+  if (typeof enumChoices === "function")
+    return await enumChoices(context);
+  return enumChoices;
+};
+var getOptionValue = async (argMeta, opt, context) => {
+  const {
+    name,
+    argsOption: { enum: enumChoices, default: defaultValue, type, desc, nullable, example, ask }
+  } = argMeta;
+  if (opt[argMeta.name] !== undefined)
+    return convertArgValue(opt[argMeta.name], type ?? "string");
+  else if (defaultValue !== undefined)
+    return defaultValue;
+  if (enumChoices) {
+    const choices = normalizeEnumChoices(await resolveEnumChoices(argMeta, context) ?? []);
+    if (choices.length === 1)
+      return choices[0]?.value;
+    const choice = await select({ message: ask ?? desc ?? `Select the ${name} value`, choices });
+    return choice;
+  } 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 {
+    const message = ask ? `${ask}: ` : desc ? `${desc}: ` : `Enter the ${name} value${example ? ` (example: ${example})` : ""}: `;
+    if (argMeta.argsOption.nullable)
+      return await input({ message });
+    else
+      return convertArgValue(await input({ message }), type ?? "string");
+  }
+};
+var getArgumentValue = async (argMeta, value) => {
+  const {
+    name,
+    argsOption: { default: defaultValue, type, desc, nullable, example, ask }
+  } = argMeta;
+  if (value !== undefined)
+    return convertArgValue(value, type ?? "string");
+  else if (defaultValue !== undefined)
+    return defaultValue;
+  else if (nullable)
+    return null;
+  const message = ask ? `${ask}: ` : desc ? `${desc}: ` : `Enter the ${name} value${example ? ` (example: ${example})` : ""}: `;
+  return convertArgValue(await input({ message }), type ?? "string");
+};
+var assignCommandContext = (context, argMeta, value) => {
+  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;
+};
+var assertCurrentDirectoryIsWorkspaceRoot = async () => {
+  const cwd = process.cwd();
+  const [hasPackageJson, hasTsConfig, hasEnv] = await Promise.all([
+    FileSys.fileExists(`${cwd}/package.json`),
+    FileSys.fileExists(`${cwd}/tsconfig.json`),
+    FileSys.fileExists(`${cwd}/.env`)
+  ]);
+  if (hasPackageJson && hasTsConfig && hasEnv)
+    return;
+  throw new Error([
+    "Akan CLI commands must be run from the workspace root.",
+    `Current directory: ${cwd}`,
+    "Move to the directory that contains package.json, tsconfig.json, and .env, then run the command again."
+  ].join(`
+`));
+};
+var getInternalArgumentValue = async (argMeta, value, workspace) => {
+  if (argMeta.type === "Workspace")
+    return workspace;
+  const sysType = argMeta.type.toLowerCase();
+  const [appNames, libNames, pkgNames] = await workspace.getExecs();
+  if (sysType === "sys") {
+    if (value && appNames.includes(value))
+      return AppExecutor.from(workspace, value);
+    else if (value && libNames.includes(value))
+      return LibExecutor.from(workspace, value);
+    else {
+      const sysName = await select({
+        message: `Select the App or Lib name`,
+        choices: [...appNames, ...libNames]
+      });
+      if (appNames.includes(sysName))
+        return AppExecutor.from(workspace, sysName);
+      else if (libNames.includes(sysName))
+        return LibExecutor.from(workspace, sysName);
+      else
+        throw new Error(`Invalid system name: ${sysName}`);
+    }
+  } else if (sysType === "exec") {
+    if (value && appNames.includes(value))
+      return AppExecutor.from(workspace, value);
+    else if (value && libNames.includes(value))
+      return LibExecutor.from(workspace, value);
+    else if (value && pkgNames.includes(value))
+      return PkgExecutor.from(workspace, value);
+    else {
+      const execName = await select({
+        message: `Select the App or Lib or Pkg name`,
+        choices: [...appNames, ...libNames, ...pkgNames]
+      });
+      if (appNames.includes(execName))
+        return AppExecutor.from(workspace, execName);
+      else if (libNames.includes(execName))
+        return LibExecutor.from(workspace, execName);
+      else if (pkgNames.includes(execName))
+        return PkgExecutor.from(workspace, execName);
+      else
+        throw new Error(`Invalid system name: ${execName}`);
+    }
+  } else if (sysType === "app") {
+    if (value && appNames.includes(value))
+      return AppExecutor.from(workspace, value);
+    if (!value && appNames.length === 1 && appNames[0])
+      return AppExecutor.from(workspace, appNames[0]);
+    const appName = await select({ message: `Select the ${sysType} name`, choices: appNames });
+    return AppExecutor.from(workspace, appName);
+  } else if (sysType === "lib") {
+    if (value && libNames.includes(value))
+      return LibExecutor.from(workspace, value);
+    const libName = await select({ message: `Select the ${sysType} name`, choices: libNames });
+    return LibExecutor.from(workspace, libName);
+  } else if (sysType === "pkg") {
+    const pkgs = await workspace.getPkgs();
+    if (value && pkgs.includes(value))
+      return PkgExecutor.from(workspace, value);
+    const pkgName = await select({ message: `Select the ${sysType} name`, choices: pkgs });
+    return PkgExecutor.from(workspace, pkgName);
+  } else if (sysType === "module") {
+    if (value) {
+      const [sysName, moduleName2] = value.split(":");
+      if (!sysName || !moduleName2)
+        throw new Error(`Invalid module name: ${value}`);
+      if (appNames.includes(sysName)) {
+        const app = AppExecutor.from(workspace, sysName);
+        const modules2 = await app.getModules();
+        if (modules2.includes(moduleName2))
+          return ModuleExecutor.from(app, moduleName2);
+        else
+          throw new Error(`Invalid module name: ${moduleName2}`);
+      } else if (libNames.includes(sysName)) {
+        const lib = LibExecutor.from(workspace, sysName);
+        const modules2 = await lib.getModules();
+        if (modules2.includes(moduleName2))
+          return ModuleExecutor.from(lib, moduleName2);
+      } else
+        throw new Error(`Invalid system name: ${sysName}`);
+    }
+    const { type, name } = await select({
+      message: `select the App or Lib name`,
+      choices: [
+        ...appNames.map((name2) => ({ name: name2, value: { type: "app", name: name2 } })),
+        ...libNames.map((name2) => ({ name: name2, value: { type: "lib", name: name2 } }))
+      ]
+    });
+    const executor = type === "app" ? AppExecutor.from(workspace, name) : LibExecutor.from(workspace, name);
+    const modules = await executor.getModules();
+    const moduleName = await select({
+      message: `Select the module name`,
+      choices: modules.map((name2) => ({ name: `${executor.name}:${name2}`, value: name2 }))
+    });
+    return ModuleExecutor.from(executor, moduleName);
+  } else
+    throw new Error(`Invalid system type: ${argMeta.type}`);
+};
+var runCommands = async (...commands) => {
+  process.on("unhandledRejection", (error) => {
+    printCliError(error);
+    process.exit(1);
+  });
+  const __dirname2 = getDirname(import.meta.url);
+  const packageJsonCandidates = [`${path.dirname(Bun.main)}/package.json`, `${__dirname2}/../package.json`];
+  let cliPackageJson = null;
+  for (const packageJsonPath of packageJsonCandidates) {
+    if (!await FileSys.fileExists(packageJsonPath))
+      continue;
+    const packageJson = await FileSys.readJson(packageJsonPath);
+    if (packageJson.name === "@akanjs/cli" || packageJson.name === "@akanjs/devkit") {
+      cliPackageJson = packageJson;
+      break;
+    }
+  }
+  process.env.AKAN_VERSION = cliPackageJson?.version ?? "0.0.1";
+  const hasHelpFlag = process.argv.includes("--help") || process.argv.includes("-h");
+  const hasCommand = process.argv.length > 2 && !process.argv[2]?.startsWith("-");
+  if (hasHelpFlag || !hasCommand) {
+    if (process.argv.length === 2 || process.argv.length === 3 && hasHelpFlag) {
+      Logger.rawLog(formatHelp(commands, process.env.AKAN_VERSION));
+      process.exit(0);
+    }
+  }
+  program.version(process.env.AKAN_VERSION).description("Akan CLI").configureHelp({
+    helpWidth: 100
+  });
+  const installedAkanPackageJson = await FileSys.fileExists("./node_modules/akanjs/package.json") ? await FileSys.readJson("./node_modules/akanjs/package.json") : null;
+  if (installedAkanPackageJson && installedAkanPackageJson.version !== process.env.AKAN_VERSION) {
+    Logger.rawLog(chalk2.yellow(`
+Akan CLI version is mismatch with installed package. ${process.env.AKAN_VERSION} (global) vs ${installedAkanPackageJson.version} (akanjs)
+It may cause unexpected behavior. Run \`akan update\` to update latest akanjs.`));
+  }
+  for (const command of commands) {
+    const targetMetas = getTargetMetas(command);
+    for (const targetMeta of targetMetas) {
+      const commandNames = getTargetCommandNames(targetMeta);
+      for (const commandName of commandNames) {
+        let programCommand = program.command(commandName, {
+          hidden: targetMeta.targetOption.devOnly
+        });
+        const [allArgMetas] = getArgMetas(command, targetMeta.key);
+        for (const argMeta of allArgMetas) {
+          if (argMeta.type === "Option")
+            programCommand = handleOption(programCommand, argMeta);
+          else if (argMeta.type === "Argument")
+            programCommand = handleArgument(programCommand, argMeta);
+          else if (argMeta.type === "Workspace")
+            continue;
+          else if (argMeta.type === "Module") {
+            programCommand = programCommand.argument(`[sys-name:module-name]`, `${argMeta.type} in this workspace (apps|libs)/<sys-name>/lib/<module-name>`);
+          } else {
+            const sysType = argMeta.type.toLowerCase();
+            programCommand = programCommand.argument(`[${sysType}]`, `${sysType} in this workspace ${sysType}s/<${sysType}Name>`);
+          }
+        }
+        programCommand = programCommand.option(`-v, --verbose [boolean]`, `verbose output`);
+        programCommand.helpInformation = () => {
+          return formatCommandHelp(command, targetMeta.key);
+        };
+        programCommand.action(async (...args) => {
+          if (!targetMeta.targetOption.stdio)
+            Logger.rawLog();
+          const cmdArgs = args.slice(0, args.length - 2);
+          const opt = args[args.length - 2];
+          const commandArgs = [];
+          if (targetMeta.targetOption.runsOnWorkspaceRoot)
+            await assertCurrentDirectoryIsWorkspaceRoot();
+          const workspace = WorkspaceExecutor.fromRoot();
+          const commandContext = { values: {} };
+          for (const argMeta of allArgMetas) {
+            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]);
+            else
+              commandArgs[argMeta.idx] = await getInternalArgumentValue(argMeta, cmdArgs[argMeta.idx], workspace);
+            if (commandArgs[argMeta.idx] instanceof AppExecutor)
+              process.env.AKAN_PUBLIC_APP_NAME = commandArgs[argMeta.idx].name;
+            assignCommandContext(commandContext, argMeta, commandArgs[argMeta.idx]);
+            if (opt.verbose)
+              Executor.setVerbose(true);
+          }
+          const cmd = CommandContainer.get(command);
+          try {
+            await targetMeta.handler.call(cmd, ...commandArgs);
+            if (!targetMeta.targetOption.stdio)
+              Logger.rawLog();
+          } catch (e) {
+            printCliError(e);
+            throw e;
+          }
+        });
+      }
+    }
+  }
+  await program.parseAsync(process.argv);
+};
+
+// pkgs/@akanjs/devkit/commandDecorators/commandBuilder.ts
+class TargetBuilder {
+  targetOption;
+  #args;
+  constructor(targetOption, args = []) {
+    this.targetOption = targetOption;
+    this.#args = args;
+  }
+  arg(name, type, argsOption = {}) {
+    return new TargetBuilder(this.targetOption, [
+      ...this.#args,
+      {
+        name,
+        argsOption: { ...argsOption, type: normalizePrimitiveArgType(type) },
+        key: "",
+        idx: this.#args.length,
+        type: "Argument"
+      }
+    ]);
+  }
+  option(name, type, argsOption = {}) {
+    return new TargetBuilder(this.targetOption, [
+      ...this.#args,
+      {
+        name,
+        argsOption: { ...argsOption, type: normalizePrimitiveArgType(type) },
+        key: "",
+        idx: this.#args.length,
+        type: "Option"
+      }
+    ]);
+  }
+  with(...tokens) {
+    return new TargetBuilder(this.targetOption, [
+      ...this.#args,
+      ...tokens.map((token, offset) => ({
+        key: "",
+        idx: this.#args.length + offset,
+        type: token.type
+      }))
+    ]);
+  }
+  exec(handler) {
+    return {
+      args: this.#args,
+      handler,
+      targetOption: this.targetOption
+    };
+  }
+}
+var createTarget = (type) => (targetOption = {}) => new TargetBuilder({ runsOnWorkspaceRoot: true, ...targetOption, type });
+var createContext = () => ({
+  public: createTarget("public"),
+  cloud: createTarget("cloud"),
+  dev: createTarget("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"
+  })
+});
+var buildCommandMeta = (definitions) => {
+  const commandMeta = new Map;
+  for (const [key, definition] of Object.entries(definitions)) {
+    commandMeta.set(key, {
+      key,
+      args: definition.args.map((arg) => ({ ...arg, key })),
+      handler: definition.handler,
+      targetOption: definition.targetOption
+    });
+  }
+  return commandMeta;
+};
+function command(refName, depsOrBuilder, builder) {
+  const deps = Array.isArray(depsOrBuilder) ? depsOrBuilder : [];
+  const commandBuilder = Array.isArray(depsOrBuilder) ? builder : depsOrBuilder;
+  assertUniqueDependencies(deps);
+  const commandMeta = buildCommandMeta(commandBuilder(createContext()));
+
+  class CommandBase {
+    static refName = refName;
+    static dependencyKind = "command";
+    static dependencyKey = `${refName}Command`;
+    static [COMMAND_META] = commandMeta;
+    constructor() {
+      injectDependencies(this, deps);
+    }
+  }
+  return CommandBase;
+}
+export { getTargetMetas, getTargetCommandNames, App, Lib, Sys, Exec, Pkg, Module, Workspace, CommandContainer, runner, script, runCommands, command };