@akanjs/devkit 0.0.54 → 0.0.56

package/index.cjs

@@ -0,0 +1,17 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var devkit_exports = {};
+module.exports = __toCommonJS(devkit_exports);
+__reExport(devkit_exports, require("./src"), module.exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akanjs/devkit",
-  "version": "0.0.54",
+  "version": "0.0.56",
   "type": "module",
   "publishConfig": {
     "access": "public"
@@ -14,5 +14,25 @@
   "engines": {
     "node": ">=22"
   },
-  "dependencies": {}
+  "dependencies": {
+    "@inquirer/prompts": "^7.2.1",
+    "@langchain/core": "^0.3.27",
+    "@langchain/openai": "^0.3.16",
+    "@nx/devkit": "^20.7.2",
+    "@trapezedev/project": "^7.1.3",
+    "axios": "^1.7.9",
+    "commander": "^13.1.0",
+    "form-data": "^4.0.1",
+    "js-yaml": "^4.1.0",
+    "ora": "^3.4.0",
+    "reflect-metadata": "^0.2.2",
+    "tunnel-ssh": "^5.2.0",
+    "typescript": "^5.8.3"
+  },
+  "exports": {
+    ".": {
+      "require": "./index.cjs",
+      "import": "./index.js"
+    }
+  }
 }

package/src/aiEditor.cjs

@@ -0,0 +1,46 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var aiEditor_exports = {};
+__export(aiEditor_exports, {
+  AiEditor: () => AiEditor
+});
+module.exports = __toCommonJS(aiEditor_exports);
+var import_prompts = require("@langchain/core/prompts");
+var import_runnables = require("@langchain/core/runnables");
+var import_openai = require("@langchain/openai");
+class AiEditor {
+  chat;
+  constructor(apiKey = process.env.DEEPSEEK_API_KEY) {
+    this.chat = new import_openai.ChatOpenAI({
+      modelName: "deepseek-reasoner",
+      temperature: 0.7,
+      streaming: true,
+      // Enable streaming
+      configuration: { baseURL: "https://api.deepseek.com/v1", apiKey }
+    });
+  }
+  #createProcessingChain() {
+    return import_runnables.RunnableSequence.from([import_prompts.PromptTemplate.fromTemplate(`Answer concisely: {question}`), this.chat]);
+  }
+  async edit(question) {
+    const chain = this.#createProcessingChain();
+    const stream = await chain.stream({ question });
+    for await (const chunk of stream) {
+    }
+  }
+}

package/src/auth.cjs

@@ -0,0 +1,64 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var auth_exports = {};
+__export(auth_exports, {
+  getAkanGlobalConfig: () => getAkanGlobalConfig,
+  getHostConfig: () => getHostConfig,
+  getSelf: () => getSelf,
+  setAkanGlobalConfig: () => setAkanGlobalConfig,
+  setHostConfig: () => setHostConfig
+});
+module.exports = __toCommonJS(auth_exports);
+var import_fs = __toESM(require("fs"), 1);
+var import_constants = require("./constants");
+const getAkanGlobalConfig = () => {
+  const akanConfig = import_fs.default.existsSync(import_constants.configPath) ? JSON.parse(import_fs.default.readFileSync(import_constants.configPath, "utf8")) : import_constants.defaultAkanGlobalConfig;
+  return akanConfig;
+};
+const setAkanGlobalConfig = (akanConfig) => {
+  import_fs.default.mkdirSync(import_constants.basePath, { recursive: true });
+  import_fs.default.writeFileSync(import_constants.configPath, JSON.stringify(akanConfig, null, 2));
+};
+const getHostConfig = (host = import_constants.akanCloudHost) => {
+  const akanConfig = getAkanGlobalConfig();
+  return akanConfig[host] ?? import_constants.defaultHostConfig;
+};
+const setHostConfig = (host = import_constants.akanCloudHost, config = {}) => {
+  const akanConfig = getAkanGlobalConfig();
+  akanConfig[host] = config;
+  setAkanGlobalConfig(akanConfig);
+};
+const getSelf = async (token) => {
+  try {
+    const res = await fetch(`${import_constants.akanCloudBackendUrl}/user/getSelf`, { headers: { Authorization: `Bearer ${token}` } });
+    const user = await res.json();
+    return user;
+  } catch (e) {
+    return null;
+  }
+};

package/src/baseDevEnv.cjs

@@ -0,0 +1,45 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var baseDevEnv_exports = {};
+__export(baseDevEnv_exports, {
+  getBaseDevEnv: () => getBaseDevEnv,
+  getSshTunnelOptions: () => getSshTunnelOptions
+});
+module.exports = __toCommonJS(baseDevEnv_exports);
+const getBaseDevEnv = () => {
+  const appName = process.env.NEXT_PUBLIC_APP_NAME;
+  const repoName = process.env.NEXT_PUBLIC_REPO_NAME;
+  if (!repoName)
+    throw new Error("NEXT_PUBLIC_REPO_NAME is not set");
+  const serveDomain = process.env.NEXT_PUBLIC_SERVE_DOMAIN;
+  if (!serveDomain)
+    throw new Error("NEXT_PUBLIC_SERVE_DOMAIN is not set");
+  const env = process.env.NEXT_PUBLIC_ENV ?? "debug";
+  if (!env)
+    throw new Error("NEXT_PUBLIC_ENV is not set");
+  return { ...appName ? { appName } : {}, repoName, serveDomain, env };
+};
+const getSshTunnelOptions = (appName, environment) => {
+  const { serveDomain, repoName } = getBaseDevEnv();
+  return {
+    host: `${appName}-${environment}.${serveDomain}`,
+    port: process.env.SSU_TUNNEL_PORT ? parseInt(process.env.SSU_TUNNEL_PORT) : 32767,
+    username: process.env.SSU_TUNNEL_USERNAME ?? "root",
+    password: process.env.SSU_TUNNEL_PASSWORD ?? repoName
+  };
+};

package/src/capacitorApp.cjs

@@ -0,0 +1,153 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var capacitorApp_exports = {};
+__export(capacitorApp_exports, {
+  CapacitorApp: () => CapacitorApp
+});
+module.exports = __toCommonJS(capacitorApp_exports);
+var import_common = require("@akanjs/common");
+var import_project = require("@trapezedev/project");
+var import_fs = __toESM(require("fs"), 1);
+class CapacitorApp {
+  constructor(app) {
+    this.app = app;
+  }
+  project;
+  iosTargetName = "App";
+  async init() {
+    const project = new import_project.MobileProject(this.app.cwdPath, {
+      android: { path: "android" },
+      ios: { path: "ios/App" }
+    });
+    await project.load();
+    if (!project.android)
+      throw new Error(`Android is not added, Please add platform first
+ akan serve-android ${this.app.name}`);
+    if (!project.ios)
+      throw new Error(`iOS is not added, Please add platform first
+ akan serve-ios ${this.app.name}`);
+    this.project = project;
+    return this;
+  }
+  async save() {
+    await this.project.commit();
+  }
+  async releaseIos() {
+    const isAdded = import_fs.default.existsSync(`${this.app.cwdPath}/ios/App/Podfile`);
+    if (!isAdded) {
+      await this.app.spawn("npx cap add ios");
+      await this.app.spawn("npx @capacitor/assets generate");
+    } else
+      this.app.log(`iOS already added, skip adding process`);
+    await this.app.spawn("cross-env", ["APP_OPERATION_MODE=release", "npx", "cap", "sync", "ios"]);
+  }
+  async releaseAndroid() {
+    const isAdded = import_fs.default.existsSync(`${this.app.cwdPath}/android/app/build.gradle`);
+    if (!isAdded) {
+      await this.app.spawn("npx cap add android");
+      await this.app.spawn("npx @capacitor/assets generate");
+    } else
+      this.app.log(`android already added, skip adding process`);
+    await this.app.spawn("cross-env", ["APP_OPERATION_MODE=release", "npx", "cap", "sync", "android"]);
+  }
+  async addCamera() {
+    await this.#setPermissionInIos({
+      cameraUsageDescription: "$(PRODUCT_NAME) requires access to the camera to take photos.",
+      photoAddUsageDescription: "$(PRODUCT_NAME) requires access to the photo library to take photos.",
+      photoUsageDescription: "$(PRODUCT_NAME) requires access to the photo library to take photos."
+    });
+    this.#setPermissionsInAndroid(["READ_MEDIA_IMAGES", "READ_EXTERNAL_STORAGE", "WRITE_EXTERNAL_STORAGE"]);
+  }
+  async addContact() {
+    await this.#setPermissionInIos({
+      contactsUsageDescription: "$(PRODUCT_NAME) requires access to the contacts to add new contacts."
+    });
+    this.#setPermissionsInAndroid(["READ_CONTACTS", "WRITE_CONTACTS"]);
+  }
+  async addLocation() {
+    await this.#setPermissionInIos({
+      locationAlwaysUsageDescription: "$(PRODUCT_NAME) requires access to the location to get the user's location.",
+      locationWhenInUseUsageDescription: "$(PRODUCT_NAME) requires access to the location to get the user's location."
+    });
+    this.#setPermissionsInAndroid(["ACCESS_COARSE_LOCATION", "ACCESS_FINE_LOCATION"]);
+    this.#setFeaturesInAndroid(["android.hardware.location.gps"]);
+  }
+  async #setPermissionInIos(permissions) {
+    const updateNs = Object.fromEntries(
+      Object.entries(permissions).map(([key, value]) => [`NS${(0, import_common.capitalize)(key)}`, value])
+    );
+    await Promise.all([
+      this.project.ios.updateInfoPlist(this.iosTargetName, "Debug", updateNs),
+      this.project.ios.updateInfoPlist(this.iosTargetName, "Release", updateNs)
+    ]);
+  }
+  #setFeaturesInAndroid(features) {
+    for (const feature of features) {
+      if (this.#hasFeatureInAndroid(feature)) {
+        this.app.logger.info(`${feature} already exists in android`);
+        return this;
+      }
+      this.app.logger.info(`Adding ${feature} to android`);
+      this.project.android.getAndroidManifest().injectFragment("manifest", `<uses-feature android:name="${feature}" />`);
+    }
+    return this;
+  }
+  #getFeaturesInAndroid() {
+    const androidManifest = this.project.android.getAndroidManifest();
+    const element = androidManifest.getDocumentElement();
+    if (!element)
+      throw new Error("manifest not found");
+    const usesFeature = element.getElementsByTagName("uses-feature");
+    return Array.from(usesFeature).map((feature) => feature.getAttribute("android:name"));
+  }
+  #hasFeatureInAndroid(feature) {
+    return this.#getFeaturesInAndroid().includes(feature);
+  }
+  #setPermissionsInAndroid(permissions) {
+    for (const permission of permissions) {
+      if (this.#hasPermissionInAndroid(permission)) {
+        this.app.logger.info(`${permission} already exists in android`);
+        return this;
+      }
+      this.app.logger.info(`Adding ${permission} to android`);
+      this.project.android.getAndroidManifest().injectFragment("manifest", `<uses-permission android:name="android.permission.${permission}" />`);
+    }
+    return this;
+  }
+  #getPermissionsInAndroid() {
+    const androidManifest = this.project.android.getAndroidManifest();
+    const element = androidManifest.getDocumentElement();
+    if (!element)
+      throw new Error("manifest not found");
+    const usesPermission = element.getElementsByTagName("uses-permission");
+    return Array.from(usesPermission).map((permission) => permission.getAttribute("android:name"));
+  }
+  #hasPermissionInAndroid(permission) {
+    return this.#getPermissionsInAndroid().includes(permission);
+  }
+}

package/src/commandDecorators/argMeta.cjs

@@ -0,0 +1,67 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var argMeta_exports = {};
+__export(argMeta_exports, {
+  App: () => App,
+  Lib: () => Lib,
+  Option: () => Option,
+  Pkg: () => Pkg,
+  Sys: () => Sys,
+  Workspace: () => Workspace,
+  argTypes: () => argTypes,
+  getArgMetas: () => getArgMetas,
+  internalArgTypes: () => internalArgTypes
+});
+module.exports = __toCommonJS(argMeta_exports);
+var import_reflect_metadata = require("reflect-metadata");
+const argTypes = ["Option"];
+const internalArgTypes = ["Workspace", "App", "Lib", "Sys", "Pkg"];
+const getArgMetas = (command, key) => {
+  const allArgMetas = getArgMetasOnPrototype(command.prototype, key);
+  const argMetas = allArgMetas.filter((argMeta) => argMeta.type === "Option");
+  const internalArgMetas = allArgMetas.filter((argMeta) => argMeta.type !== "Option");
+  return [allArgMetas, argMetas, internalArgMetas];
+};
+const getArgMetasOnPrototype = (prototype, key) => {
+  return Reflect.getMetadata("args", prototype, key) ?? [];
+};
+const setArgMetasOnPrototype = (prototype, key, argMetas) => {
+  Reflect.defineMetadata("args", argMetas, prototype, key);
+};
+const getArg = (type) => function(name, argsOption = {}) {
+  return function(prototype, key, idx) {
+    const argMetas = getArgMetasOnPrototype(prototype, key);
+    argMetas[idx] = { name, argsOption, key, idx, type };
+    setArgMetasOnPrototype(prototype, key, argMetas);
+  };
+};
+const Option = getArg("Option");
+const createArgMetaDecorator = (type) => {
+  return function(option = {}) {
+    return function(prototype, key, idx) {
+      const argMetas = getArgMetasOnPrototype(prototype, key);
+      argMetas[idx] = { key, idx, type, option };
+      setArgMetasOnPrototype(prototype, key, argMetas);
+    };
+  };
+};
+const App = createArgMetaDecorator("App");
+const Lib = createArgMetaDecorator("Lib");
+const Sys = createArgMetaDecorator("Sys");
+const Pkg = createArgMetaDecorator("Pkg");
+const Workspace = createArgMetaDecorator("Workspace");

package/src/commandDecorators/command.cjs

@@ -0,0 +1,160 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var command_exports = {};
+__export(command_exports, {
+  runCommands: () => runCommands
+});
+module.exports = __toCommonJS(command_exports);
+var import_prompts = require("@inquirer/prompts");
+var import_commander = require("commander");
+var import_executors = require("../executors");
+var import_argMeta = require("./argMeta");
+var import_targetMeta = require("./targetMeta");
+const camelToKebabCase = (str) => str.replace(/([A-Z])/g, "-$1").toLowerCase();
+const handleOption = (programCommand, argMeta) => {
+  const {
+    type,
+    flag = argMeta.name.slice(0, 1).toLowerCase(),
+    desc = argMeta.name,
+    example,
+    enum: choices,
+    ask
+  } = argMeta.argsOption;
+  const kebabName = camelToKebabCase(argMeta.name);
+  programCommand.option(
+    `-${flag}, --${kebabName} <${kebabName}>`,
+    `${desc}${ask ? ` (${ask})` : ""}${example ? ` (example: ${example})` : ""}${choices ? ` (choices: ${choices.join(", ")})` : ""}`
+  );
+  return programCommand;
+};
+const convertOptionValue = (value, type) => {
+  if (type === "string")
+    return value;
+  else if (type === "number")
+    return Number(value);
+  else
+    return value === "true";
+};
+const getOptionValue = async (argMeta, opt) => {
+  const {
+    name,
+    argsOption: { enum: choices, default: defaultValue, type, desc, nullable, example, ask }
+  } = argMeta;
+  if (opt[argMeta.name] !== void 0)
+    return convertOptionValue(opt[argMeta.name], type ?? "string");
+  else if (defaultValue !== void 0)
+    return defaultValue;
+  else if (nullable)
+    return null;
+  if (choices) {
+    const choice = await (0, import_prompts.select)({
+      message: ask ?? `Select the ${name} value`,
+      choices: choices.map((choice2) => choice2.toString())
+    });
+    return choice;
+  } else if (type === "boolean") {
+    const message = ask ?? `Do you want to set ${name}? ${desc ? ` (${desc})` : ""}: `;
+    return await (0, import_prompts.confirm)({ message });
+  } else {
+    const message = ask ?? `Enter the ${name} value${example ? ` (example: ${example})` : ""}: `;
+    if (argMeta.argsOption.nullable)
+      return await (0, import_prompts.input)({ message });
+    else
+      return convertOptionValue(await (0, import_prompts.input)({ message }), type ?? "string");
+  }
+};
+const getArgumentValue = async (argMeta, value, workspace) => {
+  if (argMeta.type === "Workspace")
+    return workspace;
+  const sysType = argMeta.type.toLowerCase();
+  if (sysType === "sys") {
+    const [appNames, libNames] = await workspace.getSyss();
+    const sysName = await (0, import_prompts.select)({
+      message: `Select the App or Lib name`,
+      choices: [...appNames, ...libNames]
+    });
+    if (appNames.includes(sysName))
+      return import_executors.AppExecutor.from(workspace, sysName);
+    else
+      return import_executors.LibExecutor.from(workspace, sysName);
+  } else if (sysType === "app") {
+    if (value)
+      return import_executors.AppExecutor.from(workspace, value);
+    const apps = await workspace.getApps();
+    const appName = await (0, import_prompts.select)({ message: `Select the ${sysType} name`, choices: apps });
+    return import_executors.AppExecutor.from(workspace, appName);
+  } else if (sysType === "lib") {
+    if (value)
+      return import_executors.LibExecutor.from(workspace, value);
+    const libs = await workspace.getLibs();
+    const libName = await (0, import_prompts.select)({ message: `Select the ${sysType} name`, choices: libs });
+    return import_executors.LibExecutor.from(workspace, libName);
+  } else if (sysType === "pkg") {
+    if (value)
+      return import_executors.PkgExecutor.from(workspace, value);
+    const pkgs = await workspace.getPkgs();
+    const pkgName = await (0, import_prompts.select)({ message: `Select the ${sysType} name`, choices: pkgs });
+    return import_executors.PkgExecutor.from(workspace, pkgName);
+  } else
+    throw new Error(`Invalid system type: ${argMeta.type}`);
+};
+const runCommands = async (...commands) => {
+  import_commander.program.version("0.0.1").description("An example CLI for managing a directory");
+  for (const command of commands) {
+    const targetMetas = (0, import_targetMeta.getTargetMetas)(command);
+    for (const targetMeta of targetMetas) {
+      const kebabKey = camelToKebabCase(targetMeta.key);
+      const commandNames = targetMeta.targetOption.short === true ? [
+        kebabKey,
+        typeof targetMeta.targetOption.short === "string" ? targetMeta.targetOption.short : kebabKey.split("-").map((s) => s.slice(0, 1)).join("")
+      ] : [kebabKey];
+      for (const commandName of commandNames) {
+        let programCommand = import_commander.program.command(commandName, {
+          hidden: targetMeta.targetOption.devOnly
+        });
+        const [allArgMetas] = (0, import_argMeta.getArgMetas)(command, targetMeta.key);
+        for (const argMeta of allArgMetas) {
+          if (argMeta.type === "Option")
+            programCommand = handleOption(programCommand, argMeta);
+          else if (argMeta.type === "Workspace")
+            continue;
+          const sysType = argMeta.type.toLowerCase();
+          programCommand = programCommand.argument(
+            `[${sysType}]`,
+            `${sysType} in this workspace ${sysType}s/<${sysType}Name>`
+          );
+        }
+        programCommand.action(async (...args) => {
+          const cmdArgs = args.slice(0, args.length - 2);
+          const opt = args[args.length - 2];
+          const commandArgs = [];
+          const workspace = import_executors.WorkspaceExecutor.fromRoot();
+          for (const argMeta of allArgMetas) {
+            if (argMeta.type === "Option")
+              commandArgs[argMeta.idx] = await getOptionValue(argMeta, opt);
+            else
+              commandArgs[argMeta.idx] = await getArgumentValue(argMeta, cmdArgs[argMeta.idx], workspace);
+          }
+          const cmd = new command();
+          await cmd[targetMeta.key](...commandArgs);
+        });
+      }
+    }
+  }
+  await import_commander.program.parseAsync(process.argv);
+};

package/src/commandDecorators/commandMeta.cjs

@@ -0,0 +1,26 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var commandMeta_exports = {};
+__export(commandMeta_exports, {
+  Commands: () => Commands
+});
+module.exports = __toCommonJS(commandMeta_exports);
+const Commands = () => {
+  return function(target) {
+  };
+};

package/src/commandDecorators/index.cjs

@@ -0,0 +1,21 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var commandDecorators_exports = {};
+module.exports = __toCommonJS(commandDecorators_exports);
+__reExport(commandDecorators_exports, require("./argMeta"), module.exports);
+__reExport(commandDecorators_exports, require("./commandMeta"), module.exports);
+__reExport(commandDecorators_exports, require("./targetMeta"), module.exports);
+__reExport(commandDecorators_exports, require("./types"), module.exports);
+__reExport(commandDecorators_exports, require("./command"), module.exports);