mixcli 3.0.0

package/dist/index.js

@@ -0,0 +1,1141 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+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 __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// package.json
+var require_package = __commonJS({
+  "package.json"(exports, module2) {
+    module2.exports = {
+      name: "mixcli",
+      version: "3.0.0",
+      description: "Develop command line tool scaffolding for monorepo",
+      repository: "https://github.com/zhangfisher/mixed-cli.git",
+      homepage: "https://zhangfisher.github.io/mixed-cli/",
+      main: "./dist/index.js",
+      module: "./dist/index.mjs",
+      types: "./dist/index.d.ts",
+      scripts: {
+        build: "tsup",
+        "build:watch": "tsup --watch",
+        release: "npm publish"
+      },
+      files: [
+        "dist",
+        "readme.md",
+        "package.json"
+      ],
+      keywords: [],
+      author: "",
+      license: "ISC",
+      dependencies: {
+        "@types/prompts": "^2.4.4",
+        "@voerkai18n/runtime": "^2.0.8",
+        "art-template": "^4.13.2",
+        commander: "^11.0.0",
+        "flex-tools": "^1.3.27",
+        "fs-extra": "^11.1.1",
+        glob: "^10.3.4",
+        logsets: "^1.3.7",
+        prompts: "^2.4.2",
+        "string.prototype.replaceall": "^1.0.7"
+      },
+      devDependencies: {
+        "@types/fs-extra": "^11.0.1",
+        "@types/node": "^20.5.7",
+        typescript: "^5.2.2"
+      }
+    };
+  }
+});
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  BREAK: () => BREAK,
+  MixCli: () => MixCli,
+  MixCommand: () => MixCommand,
+  MixOption: () => MixOption,
+  addBuiltInOptions: () => addBuiltInOptions,
+  createFileByTemplate: () => createFileByTemplate,
+  fileExists: () => fileExists,
+  fixIndent: () => fixIndent,
+  isDebug: () => isDebug,
+  isEnablePrompts: () => isEnablePrompts,
+  mkDirs: () => mkDirs,
+  mkdir: () => mkdir,
+  outputDebug: () => outputDebug,
+  outputStr: () => outputStr,
+  readFile: () => readFile,
+  writeFile: () => writeFile
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/cli.ts
+var import_string = require("flex-tools/string");
+var import_liteEvent = require("flex-tools/events/liteEvent");
+var import_logsets2 = __toESM(require("logsets"));
+var import_assignObject = require("flex-tools/object/assignObject");
+
+// src/command.ts
+var import_commander2 = require("commander");
+var import_prompts = __toESM(require("prompts"));
+
+// src/option.ts
+var import_commander = require("commander");
+
+// src/utils.ts
+var import_art_template = __toESM(require("art-template"));
+var import_fs_extra = __toESM(require("fs-extra"));
+var import_node_path = __toESM(require("path"));
+var import_promisify = require("flex-tools/func/promisify");
+var import_logsets = __toESM(require("logsets"));
+function outputStr(str, vars) {
+  import_logsets.default.log(fixIndent(str), vars);
+}
+function fixIndent(text, indent) {
+  let indentValue = indent == void 0 || indent === true ? 0 : typeof indent == "number" ? indent : -1;
+  if (indentValue == -1)
+    return text;
+  let lines = text.split("\n");
+  let minSpaceCount = lines.reduce((minCount, line, index) => {
+    var _a;
+    if (index == 0)
+      return minCount;
+    const spaceCount = ((_a = line.match(/^\s*/)) == null ? void 0 : _a[0].length) || 0;
+    return Math.min(minCount, spaceCount);
+  }, 9999);
+  lines = lines.map((line) => line.substring(minSpaceCount));
+  return lines.join("\n");
+}
+function addBuiltInOptions(command) {
+  command.option("--work-dirs <values...>", "\u6307\u5B9A\u5DE5\u4F5C\u76EE\u5F55", { hidden: true, optional: true, required: true, prompt: false });
+  command.option("--disable-prompts", "\u7981\u7528\u6240\u6709\u4EA4\u4E92\u63D0\u793A", { hidden: true, prompt: false });
+  command.option("--debug-cli", "\u663E\u793A\u8C03\u8BD5\u4FE1\u606F", { hidden: true, prompt: false });
+}
+function isDebug() {
+  return process.argv.includes("--debug-cli");
+}
+function isEnablePrompts() {
+  return !process.argv.includes("--disable-prompts");
+}
+function outputDebug(message, ...args) {
+  let vars = args.length == 1 && typeof args[0] == "function" ? args[0]() : args;
+  if (isDebug())
+    import_logsets.default.log(`[MixCli] ${message}`, ...vars);
+}
+var fileExists = (0, import_promisify.promisify)(import_fs_extra.default.exists, {
+  parseCallback: (results) => {
+    return results[0];
+  }
+});
+var readFile = (0, import_promisify.promisify)(import_fs_extra.default.readFile);
+var writeFile = (0, import_promisify.promisify)(import_fs_extra.default.writeFile);
+var mkdir = (0, import_promisify.promisify)(import_fs_extra.default.mkdir);
+function createFileByTemplate(_0, _1) {
+  return __async(this, arguments, function* (targetFile, tmplFile, vars = {}) {
+    tmplFile = import_node_path.default.isAbsolute(tmplFile) ? tmplFile : import_node_path.default.join(process.cwd(), tmplFile);
+    if (!import_fs_extra.default.existsSync(tmplFile)) {
+      throw new Error("\u6A21\u677F\u6587\u4EF6\u4E0D\u5B58\u5728:" + tmplFile);
+    }
+    targetFile = import_node_path.default.isAbsolute(targetFile) ? targetFile : import_node_path.default.join(process.cwd(), targetFile);
+    const outPath = import_node_path.default.dirname(targetFile);
+    if (!(yield fileExists(outPath))) {
+      yield mkdir(outPath, { recursive: true });
+    }
+    const template = (0, import_art_template.default)(tmplFile, yield readFile(tmplFile, { encoding: "utf-8" }));
+    yield writeFile(targetFile, template(vars), { encoding: "utf-8" });
+    return targetFile;
+  });
+}
+function mkDirs(_0, _1) {
+  return __async(this, arguments, function* (dirs, { callback, base }) {
+    if (!Array.isArray(dirs))
+      throw new Error("dirs\u53C2\u6570\u5FC5\u987B\u4E3A\u5B57\u7B26\u4E32\u6570\u7EC4");
+    for (let dir of dirs) {
+      if (!import_node_path.default.isAbsolute(dir))
+        dir = import_node_path.default.join(base || process.cwd(), dir);
+      if (typeof callback == "function")
+        callback(dir);
+      yield mkdir(dir, { recursive: true });
+    }
+  });
+}
+
+// src/prompt.ts
+var promptTypeMap = {
+  boolean: "confirm",
+  string: "text",
+  number: "number",
+  array: "list"
+};
+var supportedPromptTypes = ["text", "password", "invisible", "number", "confirm", "list", "toggle", "select", "multiselect", "autocomplete", "date", "autocompleteMultiselect"];
+var PromptManager = class {
+  // 对应的FlexOption或FlexArgument
+  constructor(promptable, promptArgs) {
+    this._promptable = promptable;
+    this.args = promptArgs === void 0 ? "auto" : promptArgs;
+  }
+  /**
+   * 返回输入的是否是有效的prompt类型
+   * @param type 
+   * @returns 
+   */
+  isValid(type) {
+    return supportedPromptTypes.includes(String(type));
+  }
+  /**
+   * 推断是否需要提示
+   * 
+   */
+  isNeed(input, defaultValue) {
+    const promptArg = this.args;
+    const inputValue = input || defaultValue;
+    const hasInput = !(inputValue === void 0);
+    if (promptArg === true)
+      return true;
+    if (promptArg === false)
+      return false;
+    if (typeof promptArg == "object") {
+      return !hasInput;
+    }
+    if (typeof promptArg == "string" && supportedPromptTypes.includes(promptArg)) {
+      return !hasInput;
+    }
+    if (this._promptable.argChoices && this._promptable.argChoices.indexOf(inputValue) == -1) {
+      return true;
+    }
+    return !hasInput;
+  }
+  /**
+   * 返回生成prompt对象
+   * 
+   * @param inputValue   从命令行输入的值
+   */
+  get(inputValue) {
+    const { description, promptChoices, validate, defaultValue } = this._promptable;
+    let input = inputValue || defaultValue;
+    if (!this.isNeed(input, defaultValue))
+      return;
+    let promptType = this.infer(inputValue);
+    const prompt = __spreadValues({
+      type: promptType,
+      name: this._promptable.name(),
+      message: description,
+      initial: input
+    }, typeof this.args == "object" ? this.args : {});
+    prompt.validate = validate == null ? void 0 : validate.bind(this._promptable);
+    if (promptType == "multiselect")
+      prompt.instructions = false;
+    if (["select", "multiselect"].includes(promptType)) {
+      let index = promptChoices == null ? void 0 : promptChoices.findIndex((item) => item.value == input);
+      prompt.initial = index == -1 ? void 0 : index;
+    }
+    if (Array.isArray(promptChoices)) {
+      prompt.choices = promptChoices;
+    }
+    return prompt;
+  }
+  /**
+   * 推断prompt类型
+   * 
+   * @param inputValue   从命令行输入的值
+   */
+  infer(inputValue) {
+    const { argChoices, variadic, defaultValue } = this._promptable;
+    let input = inputValue || defaultValue;
+    let promptType = /(\<[\w\.]+\>)|(\[[\w\.]+\])/.test(this._promptable.flags) ? "text" : "confirm";
+    let promptArg = this.args;
+    if (this.isValid(promptArg)) {
+      promptType = promptArg;
+    } else {
+      if (typeof promptArg == "object") {
+        promptType = promptArg.type;
+      } else {
+        if (argChoices) {
+          promptType = variadic ? "multiselect" : "select";
+        } else {
+          const datatype = Array.isArray(defaultValue) ? "array" : typeof defaultValue;
+          if (Array.isArray(input) || variadic) {
+            promptType = "list";
+          } else {
+            if (datatype in promptTypeMap) {
+              promptType = promptTypeMap[datatype];
+            }
+          }
+        }
+      }
+    }
+    outputDebug("\u9009\u9879<{}> -> \u63D0\u793A\u7C7B\u578B<{}>", [this._promptable.name(), promptType]);
+    return promptType;
+  }
+};
+
+// src/option.ts
+var MixOption = class extends import_commander.Option {
+  constructor(flags, description, optsOrDefault) {
+    super(flags, description);
+    let params = {};
+    if (arguments.length == 3 && typeof arguments[2] == "object") {
+      params = Object.assign({}, arguments[2]);
+    } else if (arguments.length == 3) {
+      params.default = arguments[2];
+    }
+    if (params.prompt === void 0)
+      params.prompt = "auto";
+    if (params.default)
+      this.default(params.default, params.defaultDescription);
+    if (params.choices)
+      this.choices(params.choices);
+    if (params.conflicts)
+      this.conflicts(params.conflicts);
+    if (params.env)
+      this.env(params.env);
+    if (params.argParser)
+      this.argParser(params.argParser);
+    if (params.hideHelp)
+      this.hideHelp(params.hideHelp);
+    if (params.hidden)
+      this.hidden = params.hidden;
+    if (params.mandatory)
+      this.makeOptionMandatory(params.mandatory);
+    if (params.implies)
+      this.implies(params.implies);
+    if (params.optional)
+      this.optional = params.optional;
+    if (typeof params.validate == "function")
+      this._validate = params.validate.bind(this);
+    if (params.required) {
+      this.required = params.required;
+      if (!this._validate)
+        this._validate = (value) => String(value).length > 0;
+    }
+    this.prompt = new PromptManager(this, params.prompt);
+  }
+  validate(value) {
+    if (typeof this._validate == "function") {
+      return this._validate(value);
+    } else {
+      return true;
+    }
+  }
+  // @ts-ignore
+  choices(values) {
+    if (!this.promptChoices) {
+      this.promptChoices = values.map((choice) => {
+        if (typeof choice == "object") {
+          return choice;
+        } else {
+          return { title: choice, value: choice };
+        }
+      });
+    }
+    super.choices(this.promptChoices.map((item) => item.value));
+  }
+  resetChoices() {
+    super.choices(this.promptChoices.map((item) => item.value));
+  }
+  addChoice(value) {
+    if (!this.promptChoices || !Array.isArray(this.promptChoices))
+      this.promptChoices = [];
+    this.promptChoices.push(typeof value == "string" ? { title: value, value } : value);
+    this.resetChoices();
+  }
+  removeChoice(value) {
+    var _a;
+    this.promptChoices = (_a = this.promptChoices) == null ? void 0 : _a.filter((choice) => choice.value !== value);
+    this.resetChoices();
+  }
+  clearChoice() {
+    this.promptChoices = [];
+    this.resetChoices();
+  }
+  /**
+   * 返回选项的提示对象
+   * 
+   * @remarks
+   * 
+   *
+   * 
+   * @param inputValue 
+   * @returns 
+   */
+  getPrompt(inputValue) {
+    var _a;
+    return (_a = this.prompt) == null ? void 0 : _a.get(inputValue);
+  }
+};
+
+// src/command.ts
+var import_node_path2 = __toESM(require("path"));
+var import_node_fs = __toESM(require("fs"));
+var BREAK = Symbol("BREAK_ACTION");
+var MixCommand = class extends import_commander2.Command {
+  // 是否启用交互提示
+  constructor(name) {
+    super(name);
+    this._beforeHooks = [];
+    this._afterHooks = [];
+    this._customPrompts = [];
+    this._optionValues = {};
+    // 命令行输入的选项值
+    this._actions = [];
+    // 允许多个action
+    this._enable_prompts = true;
+    const self = this;
+    if (!this.isRoot)
+      addBuiltInOptions(this);
+    this.hook("preAction", function() {
+      return __async(this, arguments, function* () {
+        self._optionValues = self.getOptionValues(this.hookedCommand);
+        try {
+          yield self.preActionHook.apply(self, arguments);
+        } catch (e) {
+        }
+      });
+    });
+  }
+  /**
+   * 是否是根命令
+   */
+  get isRoot() {
+    return !!!this.parent;
+  }
+  get actions() {
+    return this._actions;
+  }
+  get beforeHooks() {
+    return this._beforeHooks;
+  }
+  get afterHooks() {
+    return this._afterHooks;
+  }
+  get fullname() {
+    let names = [this.name()];
+    let parent = this.parent;
+    while (parent) {
+      if (parent.name() !== "root") {
+        names.unshift(parent.name());
+      }
+      parent = parent.parent;
+    }
+    return names.join(".");
+  }
+  /**
+   * 返回根命令
+   */
+  root() {
+    let root = this;
+    while (root && root.parent != null) {
+      root = root.parent;
+    }
+    return root;
+  }
+  action(fn) {
+    const actionFunc = arguments[0];
+    if (arguments.length == 1 && typeof actionFunc == "function") {
+      this._actions.push({
+        id: Math.random().toString(36).substring(2),
+        enhance: false,
+        fn: actionFunc
+      });
+    } else if (arguments.length == 2 && typeof actionFunc == "function" && typeof arguments[1] == "object") {
+      const actionFn = arguments[0];
+      const actionOpts = Object.assign({ at: "append" }, arguments[1]);
+      if (actionOpts.at == "replace")
+        this._actions = [];
+      const actionItem = {
+        id: actionOpts.id || Math.random().toString(36).substring(2),
+        enhance: actionOpts.enhance == void 0 ? true : actionOpts.enhance,
+        fn: actionFn
+      };
+      if (typeof actionOpts.at == "number") {
+        this._actions.splice(Number(actionOpts.at), 0, actionItem);
+      } else if (["append", "before"].includes(actionOpts.at)) {
+        this._actions.push(actionItem);
+      } else if (["preappend", "after"].includes(actionOpts.at)) {
+        this._actions.splice(0, 0, actionItem);
+      } else {
+        this._actions.push(actionItem);
+      }
+    } else {
+      console.log("[mixed-cli] action params error");
+    }
+    return super.action(this.getWrapperedAction());
+  }
+  /**
+   * 读取命令配置值，包括父命令提供的配置选项
+   * @param command
+   */
+  getOptionValues(command) {
+    let opts = {};
+    let parent = command;
+    while (parent) {
+      Object.assign(opts, parent._optionValues);
+      parent = parent.parent;
+    }
+    return opts;
+  }
+  /**
+   * 本函数在运行时子类进行action生成该命令的action
+   */
+  getWrapperedAction() {
+    return this.wrapperWorkDirsAction(this.wrapperChainActions());
+  }
+  /**
+   * 向上查找所有祖先命令
+   */
+  getAncestorCommands() {
+    let cmds = [];
+    let cmd = this;
+    while (cmd) {
+      cmd = cmd.parent;
+      if (cmd) {
+        cmds.push(cmd);
+      }
+    }
+    return cmds;
+  }
+  /***
+   * 将所有actions包装成一个链式调用的函数
+   */
+  wrapperChainActions() {
+    const self = this;
+    return function() {
+      return __async(this, arguments, function* () {
+        const args = Array.from(arguments);
+        let preValue;
+        let actionOpts = {}, actionArgs = [], cmd;
+        if (args.length >= 2) {
+          cmd = args[args.length - 1];
+          actionOpts = args[args.length - 2];
+          actionArgs = args.slice(0, args.length - 2);
+        }
+        yield self.executeBeforeHooks({ args: actionArgs, options: actionOpts, command: cmd });
+        try {
+          for (let action of self._actions) {
+            try {
+              if (action.enhance) {
+                outputDebug("\u6267\u884C<{}>: args={}, options={}", () => [
+                  self.name(),
+                  actionArgs,
+                  actionOpts
+                ]);
+                preValue = yield action.fn.call(this, {
+                  command: cmd,
+                  value: preValue,
+                  args: actionArgs,
+                  options: actionOpts
+                });
+              } else {
+                preValue = yield action.fn.apply(this, args);
+              }
+              if (preValue === BREAK)
+                break;
+            } catch (e) {
+              outputDebug("\u547D\u4EE4{}\u7684Action({})\u6267\u884C\u51FA\u9519:{}", [self.name, action.id, e]);
+              throw e;
+            }
+          }
+        } finally {
+          yield self.executeAfterHooks({
+            value: preValue,
+            args: actionArgs,
+            options: actionOpts,
+            command: cmd
+          });
+        }
+      });
+    };
+  }
+  /**
+   * 当传入--work-dirs时用来处理工作目录
+   */
+  wrapperWorkDirsAction(fn) {
+    const self = this;
+    return function() {
+      return __async(this, arguments, function* () {
+        let workDirs = self._optionValues.workDirs;
+        if (!workDirs) {
+          return yield fn.apply(this, Array.from(arguments));
+        }
+        if (!Array.isArray(workDirs))
+          workDirs = workDirs.split(",");
+        workDirs = workDirs.reduce((dirs, dir) => {
+          if (typeof dir == "string")
+            dirs.push(...dir.split(","));
+          return dirs;
+        }, []);
+        for (let workDir of workDirs) {
+          const cwd = process.cwd();
+          try {
+            if (!import_node_path2.default.isAbsolute(workDir))
+              workDir = import_node_path2.default.join(cwd, workDir);
+            if (import_node_fs.default.existsSync(workDir) && import_node_fs.default.statSync(workDir).isDirectory()) {
+              outputDebug("\u5207\u6362\u5230\u5DE5\u4F5C\u76EE\u5F55:{}", workDir);
+              process.chdir(workDir);
+              yield fn.apply(this, Array.from(arguments));
+            } else {
+              outputDebug("\u65E0\u6548\u7684\u5DE5\u4F5C\u76EE\u5F55:{}", workDir);
+            }
+          } catch (e) {
+            throw e;
+          } finally {
+            process.chdir(cwd);
+          }
+        }
+      });
+    };
+  }
+  getOption(name) {
+    return this.options.find((option) => option.name() == name);
+  }
+  /**
+   * 添加一个Before钩子
+   * @param listener
+   * @param scope     =false时代表只在本命令执行，=true时代表在本命令及其子命令执行
+   * @returns
+   */
+  before(listener, scope = true) {
+    this._beforeHooks.push([listener, scope]);
+    return this;
+  }
+  executeBeforeHooks(args) {
+    return __async(this, null, function* () {
+      const hooks = this.beforeHooks.map(
+        ([hook, scope]) => [hook, scope, this]
+      );
+      this.getAncestorCommands().forEach((cmd) => {
+        hooks.unshift(
+          ...cmd.beforeHooks.map(([hook, scope]) => {
+            return [hook, scope, cmd];
+          })
+        );
+      });
+      for (let [hook, scope, cmd] of hooks) {
+        if (!scope)
+          continue;
+        yield hook.call(cmd, args);
+      }
+    });
+  }
+  /**
+   * 添加一个After钩子
+   * @param listener
+   * @param scope     =false时代表只在本命令执行，=true时代表在本命令及其子命令执行
+   * @returns
+   */
+  after(listener, scope = true) {
+    this._afterHooks.push([listener, scope]);
+    return this;
+  }
+  executeAfterHooks(args) {
+    return __async(this, null, function* () {
+      const hooks = this.afterHooks.map(
+        ([hook, scope]) => [hook, scope, this]
+      );
+      this.getAncestorCommands().forEach((cmd) => {
+        hooks.push(
+          ...cmd.afterHooks.map(([hook, scope]) => {
+            return [hook, scope, cmd];
+          })
+        );
+      });
+      for (let [hook, scope, cmd] of hooks) {
+        if (!scope)
+          continue;
+        yield hook.call(cmd, args);
+      }
+    });
+  }
+  preActionHook(thisCommand, actionCommand) {
+    return __async(this, null, function* () {
+      if (this.isEnablePrompts()) {
+        const questions = [
+          ...this.generateAutoPrompts(),
+          ...this._customPrompts
+        ];
+        if (questions.length > 0) {
+          const results = yield (0, import_prompts.default)(questions);
+          Object.entries(results).forEach(([key, value]) => {
+            thisCommand.setOptionValue(key, value);
+          });
+        }
+      }
+    });
+  }
+  isEnablePrompts() {
+    if (isEnablePrompts() === false) {
+      return false;
+    } else {
+      return this._enable_prompts;
+    }
+  }
+  /**
+   * 生成选项自动提示
+   *
+   * @remarks
+   * FlexCli要求所有未提供默认值的Option自动生成提示
+   *
+   * - 未提供默认值，并且是必选的参数Option
+   * - 指定了choices但未提供有效值的Option
+   *
+   */
+  generateAutoPrompts() {
+    const options = this.options;
+    const optionPromports = options.filter((option) => !option.hidden && option instanceof MixOption).map((option) => option.getPrompt(this._optionValues[option.name()])).filter((prompt) => prompt);
+    outputDebug("\u547D\u4EE4<{}>\u81EA\u52A8\u751F\u6210{}\u4E2A\u9009\u9879\u63D0\u793A:{}", [
+      this.name(),
+      optionPromports.length,
+      optionPromports.map((prompt) => `${prompt.name}(${prompt.type})`).join(",")
+    ]);
+    return optionPromports;
+  }
+  option(flags, description, options) {
+    const option = new MixOption(...arguments);
+    if (option.required && !this.isEnablePrompts())
+      option.mandatory = true;
+    return this.addOption(option);
+  }
+  /**
+   * 添加提示
+   *
+   * @remarks
+   *
+   * 添加一些自定义提示
+   *
+   *
+   * @param questions
+   * @param show              是否显示提示信息，auto表示只有在用户没有提供option的值时才显示提示信息,always表示总是显示提示信息，never表示不显示提示信息
+   * @returns
+   */
+  prompt(questions) {
+    this._customPrompts.push(...Array.isArray(questions) ? questions : [questions]);
+    return this;
+  }
+  /**
+   *
+   *  选择命令并执行
+   *
+   * @remorks
+   *
+   * 当命令具有多个子命令时，并且没有提供默认子命令时，提示用户选择一个子命令
+   *
+   */
+  selectCommands() {
+    return __async(this, null, function* () {
+      const choices = this.commands.map((command2) => ({
+        title: `${command2.description()}(${command2.name()})`,
+        value: command2.name()
+      }));
+      const result = yield (0, import_prompts.default)({
+        type: "select",
+        name: "command",
+        message: "\u8BF7\u9009\u62E9\u547D\u4EE4:",
+        choices
+      });
+      const command = this.commands.find((command2) => command2.name() === result.command);
+      yield command == null ? void 0 : command.parseAsync([result.command], { from: "user" });
+    });
+  }
+  /**
+   * 禁用/启用所有提示
+   */
+  disablePrompts() {
+    this._enable_prompts = false;
+    return this;
+  }
+  enablePrompts() {
+    this._enable_prompts = true;
+    return this;
+  }
+};
+
+// src/finder.ts
+var import_flex_tools = require("flex-tools");
+var import_glob = require("glob");
+var import_node_fs2 = __toESM(require("fs"));
+var import_node_path3 = __toESM(require("path"));
+var import_getPackageJson = require("flex-tools/package/getPackageJson");
+function getMatchedDependencies(entry) {
+  const pacakgeMacher = this.options.include;
+  if (!(pacakgeMacher instanceof RegExp))
+    return [];
+  const { dependencies = {}, devDependencies = {}, peerDependencies = {}, optionalDependencies = {}, bundleDependencies = {} } = (0, import_getPackageJson.getPackageJson)(entry);
+  const packageNames = [
+    ...Object.keys(dependencies),
+    ...Object.keys(devDependencies),
+    ...Object.keys(peerDependencies),
+    ...Object.keys(optionalDependencies),
+    ...Object.keys(bundleDependencies)
+  ];
+  return packageNames.filter((name) => name !== "@voerka/cli" && pacakgeMacher.test(name));
+}
+function isMatched(str, reg) {
+  const regexps = reg ? Array.isArray(reg) ? reg : [reg] : [];
+  return regexps.some((regexp) => {
+    if (typeof regexp === "string") {
+      return new RegExp(regexp).test(str);
+    } else if (regexp instanceof RegExp) {
+      return regexp.test(str);
+    } else {
+      return false;
+    }
+  });
+}
+function findCliPaths(packageName, entry) {
+  const includeMacher = this.options.include;
+  const excludeMacher = this.options.exclude;
+  if (!includeMacher)
+    return [];
+  const packageRoot = (0, import_flex_tools.getPackageRootPath)(entry || process.cwd());
+  const packagePath = packageName ? import_node_path3.default.dirname(require.resolve(packageName, { paths: [packageRoot] })) : packageName;
+  const packageNames = getMatchedDependencies.call(this, packagePath);
+  const cliDirs = [];
+  if (entry !== void 0)
+    cliDirs.push(import_node_path3.default.join(packagePath, this.options.cliDir));
+  packageNames.filter((name) => {
+    return isMatched(name, includeMacher) && !isMatched(name, excludeMacher);
+  }).forEach((name) => {
+    outputDebug("\u5339\u914D\u5305:{}", `${packageName ? name + " <- " + packageName : name}`);
+    try {
+      const packageEntry = import_node_path3.default.dirname(require.resolve(name, { paths: packagePath ? [packagePath] : [process.cwd()] }));
+      const packageCliDir = import_node_path3.default.join(packageEntry, this.options.cliDir);
+      let dependencies = getMatchedDependencies.call(this, packageEntry);
+      cliDirs.push(...dependencies.reduce((result, dependencie) => {
+        outputDebug("\u5339\u914D\u5305:{}", `${dependencie} <- ${name}`);
+        result.push(...findCliPaths.call(this, dependencie, packageEntry));
+        return result;
+      }, []));
+      if (import_node_fs2.default.existsSync(packageCliDir)) {
+        cliDirs.push(packageCliDir);
+      }
+    } catch (e) {
+      outputDebug("\u89E3\u6790\u5305<{}>\u8DEF\u5F84\u51FA\u9519\uFF1A{}", [name, e.stack]);
+    }
+  });
+  return [...new Set(cliDirs)];
+}
+function showError(e) {
+  if (isDebug()) {
+    outputDebug("\u5BFC\u5165\u547D\u4EE4<>\u51FA\u9519:{}", e.stack);
+  } else {
+    console.error(e);
+  }
+}
+function findCommands(cli) {
+  return __async(this, null, function* () {
+    const cliDirs = findCliPaths.call(cli);
+    const commands = [];
+    const files = [];
+    cliDirs.forEach((dir) => {
+      files.push(...(0, import_glob.globSync)("*", {
+        cwd: dir,
+        absolute: true
+      }).filter((file) => (file.endsWith(".js") || file.endsWith(".cjs") || file.endsWith(".mjs")) && !import_node_fs2.default.statSync(file).isDirectory()));
+    });
+    for (let file of files) {
+      try {
+        outputDebug("\u5BFC\u5165\u547D\u4EE4:{}", file);
+        if (file.endsWith(".cjs") || file.endsWith(".js")) {
+          commands.push(require(file));
+        } else if (file.endsWith(".mjs")) {
+          const cmd = yield import(`file://${file}`);
+          commands.push(cmd.default);
+        }
+      } catch (e) {
+        if (e.code === "ERR_REQUIRE_ESM") {
+          try {
+            const cmd = yield import(`file://${file.replace(".js", ".mjs")}`);
+            commands.push(cmd.default);
+          } catch (err) {
+            showError(err);
+          }
+        } else {
+          showError(e);
+        }
+      }
+    }
+    return commands;
+  });
+}
+
+// src/cli.ts
+var import_asyncSignal = require("flex-tools/async/asyncSignal");
+var import_string_prototype = __toESM(require("string.prototype.replaceall"));
+import_string_prototype.default.shim();
+var MixCli = class extends import_liteEvent.LiteEvent {
+  constructor(options) {
+    super();
+    this.findSignals = [];
+    this.options = (0, import_assignObject.assignObject)({
+      name: "mixcli",
+      package: null,
+      cliDir: "cli",
+      prompt: "auto"
+    }, options);
+    this.createRootCommand();
+  }
+  get context() {
+    return this.options.context;
+  }
+  get name() {
+    return this.options.name;
+  }
+  /**
+   * 是否禁用了所有的交互提示
+   */
+  get isDisabledPrompts() {
+    return this.root.rawArgs.includes("--no-prompts");
+  }
+  /**
+   * 扫描当前工程的依赖，加载匹配include的依赖下的命令
+   */
+  installCommands() {
+    return __async(this, null, function* () {
+      const cmders = yield findCommands(this);
+      for (let cmder of cmders) {
+        try {
+          if (typeof cmder === "function") {
+            let cmds = cmder(this);
+            cmds = cmds ? Array.isArray(cmds) ? cmds : [cmds] : [];
+            this.register(() => cmds);
+          }
+        } catch (e) {
+        }
+      }
+    });
+  }
+  /**
+   * 创建根命令
+   * 
+   */
+  createRootCommand() {
+    this.root = new MixCommand(this.name);
+    this.root.helpOption("-h, --help").version(require_package().version, "-v, --version").action(() => {
+      if (this.options.logo)
+        import_logsets2.default.log(fixIndent(this.options.logo, 2));
+      console.log();
+      let title = this.options.title || this.options.name;
+      if (Array.isArray(title)) {
+        import_logsets2.default.log(String(title[0]).firstUpper(), [...title.slice(1)]);
+      } else {
+        import_logsets2.default.log(`${title.firstUpper()}       Version: {}`, this.options.version);
+      }
+      if (this.options.description)
+        import_logsets2.default.log(import_logsets2.default.colors.darkGray(this.options.description));
+      console.log();
+      this.root.help();
+    });
+    addBuiltInOptions(this.root);
+    if (this.options.before)
+      this.root.hook("preAction", this.options.before);
+    if (this.options.after)
+      this.root.hook("postAction", this.options.after);
+  }
+  /**
+   * 添加帮助选项
+   * 
+   * @param text      帮助文本
+   * @param position  显示位置，可选值：before|after|beforeAll|afterAll
+   * @param fixIndent   是否自动修正缩进，如果为true，则会自动修正缩进，当显示多行时文本时，会自动修正缩进
+   * 
+   */
+  addHelp(text, { pos = "beforeAll", alignIndent = true }) {
+    if (alignIndent)
+      text = fixIndent(text, alignIndent);
+    this.root.addHelpText(pos, text);
+  }
+  /**
+   * 注册一个命令
+   * @param cmd 
+   */
+  register(cmd) {
+    if (typeof cmd == "function") {
+      let result = cmd(this);
+      let cmds = result instanceof Array ? result : result == void 0 ? [] : [result];
+      for (let cmd2 of cmds) {
+        if (cmd2 instanceof MixCommand) {
+          if (this.hasCommand(cmd2.name())) {
+            import_logsets2.default.error(`Command <${cmd2.name()}> has been registered!`);
+          } else {
+            this.root.addCommand(cmd2);
+            cmd2._cli = this;
+            this.emit("register", cmd2.fullname, true);
+          }
+        }
+      }
+    } else {
+      import_logsets2.default.error("Invalid command");
+    }
+  }
+  hasCommand(name) {
+    return this.root.commands.some((c) => c.name() == name);
+  }
+  /**
+   * 根据命令名称查找命令
+   * 
+   * @remarks
+   * 
+   * find("dev")
+   * find("dev.microservice")  支持多级命令
+   * find("abc",DevCommand)  允许指定从DevCommand下开始查找abc命令
+   * 
+   * @param name 
+   */
+  get(name) {
+    const names = name.split(".");
+    let curCmd = this.root;
+    let resultCmd;
+    while (names.length > 0) {
+      const topName = names.shift();
+      const r = curCmd.commands.find((c) => c.name() == topName);
+      if (r && names.length == 0) {
+        resultCmd = r;
+      }
+      curCmd = r;
+    }
+    return resultCmd;
+  }
+  /**
+   * 查找一个命令
+   * 
+   * 如果命令不存在，则等待命令注册后再返回
+   * 
+   * 在多包场景下，如果命令在其他包中注册并且该包中的命令还没注册，则会等待命令注册后再返回
+   * 
+   * @param name 
+   * @returns 
+   */
+  find(name) {
+    const cmd = this.get(name);
+    if (cmd) {
+      return Promise.resolve(cmd);
+    } else {
+      const signal = (0, import_asyncSignal.asyncSignal)();
+      this.findSignals.push(signal);
+      return new Promise((resolve) => {
+        let listener;
+        listener = this.on("register", (fullname) => {
+          if (fullname == `${this.name}.${name}`) {
+            listener.off();
+            signal.resolve();
+            this.findSignals = this.findSignals.filter((s) => s != signal);
+            resolve(this.get(name));
+          }
+        }, { objectify: true });
+      });
+    }
+  }
+  /**
+   * 判断命令是否存在
+   * 
+   * @param name 
+   * @returns 
+   */
+  exists(name) {
+    if (name in this.root.commands) {
+      return true;
+    } else {
+      return this.get(name) != void 0;
+    }
+  }
+  /**
+   * 运行命令行程序
+   */
+  run() {
+    this.installCommands().then(() => {
+      return Promise.all(this.findSignals.map((signal) => signal(1e4))).then(() => {
+        this.root.parseAsync(process.argv);
+      });
+    });
+  }
+  /**
+   * 创建一个命令
+   * 
+   * 
+   */
+  create() {
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BREAK,
+  MixCli,
+  MixCommand,
+  MixOption,
+  addBuiltInOptions,
+  createFileByTemplate,
+  fileExists,
+  fixIndent,
+  isDebug,
+  isEnablePrompts,
+  mkDirs,
+  mkdir,
+  outputDebug,
+  outputStr,
+  readFile,
+  writeFile
+});
+//# sourceMappingURL=index.js.map