@chatbi-v/cli 2.0.1 → 2.0.2

package/dist/index.mjs

@@ -0,0 +1,2769 @@
+import {
+  build
+} from "./chunk-WCPZB47I.mjs";
+import {
+  init
+} from "./chunk-LJFX6MNO.mjs";
+import {
+  sync
+} from "./chunk-4OD6C56P.mjs";
+import {
+  ConfigManager,
+  CoreKit,
+  require_prompts
+} from "./chunk-WIVHOK75.mjs";
+import {
+  fetch
+} from "./chunk-V7IEPMC4.mjs";
+import {
+  Sandbox,
+  require_lib as require_lib2
+} from "./chunk-7A54IJI5.mjs";
+import {
+  execa
+} from "./chunk-SBGVKO4C.mjs";
+import {
+  boxen,
+  createSpinner,
+  getCliRoot,
+  logger,
+  printBox,
+  require_lib,
+  require_picocolors,
+  source_default
+} from "./chunk-Y24V4GQG.mjs";
+import {
+  __commonJS,
+  __toESM,
+  init_esm_shims
+} from "./chunk-TX5M36S5.mjs";
+
+// ../../node_modules/.pnpm/tinycolor2@1.6.0/node_modules/tinycolor2/cjs/tinycolor.js
+var require_tinycolor = __commonJS({
+  "../../node_modules/.pnpm/tinycolor2@1.6.0/node_modules/tinycolor2/cjs/tinycolor.js"(exports, module) {
+    "use strict";
+    init_esm_shims();
+    (function(global, factory) {
+      typeof exports === "object" && typeof module !== "undefined" ? module.exports = factory() : typeof define === "function" && define.amd ? define(factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, global.tinycolor = factory());
+    })(exports, (function() {
+      "use strict";
+      function _typeof(obj) {
+        "@babel/helpers - typeof";
+        return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(obj2) {
+          return typeof obj2;
+        } : function(obj2) {
+          return obj2 && "function" == typeof Symbol && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+        }, _typeof(obj);
+      }
+      var trimLeft = /^\s+/;
+      var trimRight = /\s+$/;
+      function tinycolor(color, opts) {
+        color = color ? color : "";
+        opts = opts || {};
+        if (color instanceof tinycolor) {
+          return color;
+        }
+        if (!(this instanceof tinycolor)) {
+          return new tinycolor(color, opts);
+        }
+        var rgb = inputToRGB(color);
+        this._originalInput = color, this._r = rgb.r, this._g = rgb.g, this._b = rgb.b, this._a = rgb.a, this._roundA = Math.round(100 * this._a) / 100, this._format = opts.format || rgb.format;
+        this._gradientType = opts.gradientType;
+        if (this._r < 1) this._r = Math.round(this._r);
+        if (this._g < 1) this._g = Math.round(this._g);
+        if (this._b < 1) this._b = Math.round(this._b);
+        this._ok = rgb.ok;
+      }
+      tinycolor.prototype = {
+        isDark: function isDark() {
+          return this.getBrightness() < 128;
+        },
+        isLight: function isLight() {
+          return !this.isDark();
+        },
+        isValid: function isValid() {
+          return this._ok;
+        },
+        getOriginalInput: function getOriginalInput() {
+          return this._originalInput;
+        },
+        getFormat: function getFormat() {
+          return this._format;
+        },
+        getAlpha: function getAlpha() {
+          return this._a;
+        },
+        getBrightness: function getBrightness() {
+          var rgb = this.toRgb();
+          return (rgb.r * 299 + rgb.g * 587 + rgb.b * 114) / 1e3;
+        },
+        getLuminance: function getLuminance() {
+          var rgb = this.toRgb();
+          var RsRGB, GsRGB, BsRGB, R, G, B;
+          RsRGB = rgb.r / 255;
+          GsRGB = rgb.g / 255;
+          BsRGB = rgb.b / 255;
+          if (RsRGB <= 0.03928) R = RsRGB / 12.92;
+          else R = Math.pow((RsRGB + 0.055) / 1.055, 2.4);
+          if (GsRGB <= 0.03928) G = GsRGB / 12.92;
+          else G = Math.pow((GsRGB + 0.055) / 1.055, 2.4);
+          if (BsRGB <= 0.03928) B = BsRGB / 12.92;
+          else B = Math.pow((BsRGB + 0.055) / 1.055, 2.4);
+          return 0.2126 * R + 0.7152 * G + 0.0722 * B;
+        },
+        setAlpha: function setAlpha(value) {
+          this._a = boundAlpha(value);
+          this._roundA = Math.round(100 * this._a) / 100;
+          return this;
+        },
+        toHsv: function toHsv() {
+          var hsv = rgbToHsv(this._r, this._g, this._b);
+          return {
+            h: hsv.h * 360,
+            s: hsv.s,
+            v: hsv.v,
+            a: this._a
+          };
+        },
+        toHsvString: function toHsvString() {
+          var hsv = rgbToHsv(this._r, this._g, this._b);
+          var h = Math.round(hsv.h * 360), s = Math.round(hsv.s * 100), v = Math.round(hsv.v * 100);
+          return this._a == 1 ? "hsv(" + h + ", " + s + "%, " + v + "%)" : "hsva(" + h + ", " + s + "%, " + v + "%, " + this._roundA + ")";
+        },
+        toHsl: function toHsl() {
+          var hsl = rgbToHsl(this._r, this._g, this._b);
+          return {
+            h: hsl.h * 360,
+            s: hsl.s,
+            l: hsl.l,
+            a: this._a
+          };
+        },
+        toHslString: function toHslString() {
+          var hsl = rgbToHsl(this._r, this._g, this._b);
+          var h = Math.round(hsl.h * 360), s = Math.round(hsl.s * 100), l = Math.round(hsl.l * 100);
+          return this._a == 1 ? "hsl(" + h + ", " + s + "%, " + l + "%)" : "hsla(" + h + ", " + s + "%, " + l + "%, " + this._roundA + ")";
+        },
+        toHex: function toHex(allow3Char) {
+          return rgbToHex(this._r, this._g, this._b, allow3Char);
+        },
+        toHexString: function toHexString(allow3Char) {
+          return "#" + this.toHex(allow3Char);
+        },
+        toHex8: function toHex8(allow4Char) {
+          return rgbaToHex(this._r, this._g, this._b, this._a, allow4Char);
+        },
+        toHex8String: function toHex8String(allow4Char) {
+          return "#" + this.toHex8(allow4Char);
+        },
+        toRgb: function toRgb() {
+          return {
+            r: Math.round(this._r),
+            g: Math.round(this._g),
+            b: Math.round(this._b),
+            a: this._a
+          };
+        },
+        toRgbString: function toRgbString() {
+          return this._a == 1 ? "rgb(" + Math.round(this._r) + ", " + Math.round(this._g) + ", " + Math.round(this._b) + ")" : "rgba(" + Math.round(this._r) + ", " + Math.round(this._g) + ", " + Math.round(this._b) + ", " + this._roundA + ")";
+        },
+        toPercentageRgb: function toPercentageRgb() {
+          return {
+            r: Math.round(bound01(this._r, 255) * 100) + "%",
+            g: Math.round(bound01(this._g, 255) * 100) + "%",
+            b: Math.round(bound01(this._b, 255) * 100) + "%",
+            a: this._a
+          };
+        },
+        toPercentageRgbString: function toPercentageRgbString() {
+          return this._a == 1 ? "rgb(" + Math.round(bound01(this._r, 255) * 100) + "%, " + Math.round(bound01(this._g, 255) * 100) + "%, " + Math.round(bound01(this._b, 255) * 100) + "%)" : "rgba(" + Math.round(bound01(this._r, 255) * 100) + "%, " + Math.round(bound01(this._g, 255) * 100) + "%, " + Math.round(bound01(this._b, 255) * 100) + "%, " + this._roundA + ")";
+        },
+        toName: function toName() {
+          if (this._a === 0) {
+            return "transparent";
+          }
+          if (this._a < 1) {
+            return false;
+          }
+          return hexNames[rgbToHex(this._r, this._g, this._b, true)] || false;
+        },
+        toFilter: function toFilter(secondColor) {
+          var hex8String = "#" + rgbaToArgbHex(this._r, this._g, this._b, this._a);
+          var secondHex8String = hex8String;
+          var gradientType = this._gradientType ? "GradientType = 1, " : "";
+          if (secondColor) {
+            var s = tinycolor(secondColor);
+            secondHex8String = "#" + rgbaToArgbHex(s._r, s._g, s._b, s._a);
+          }
+          return "progid:DXImageTransform.Microsoft.gradient(" + gradientType + "startColorstr=" + hex8String + ",endColorstr=" + secondHex8String + ")";
+        },
+        toString: function toString(format) {
+          var formatSet = !!format;
+          format = format || this._format;
+          var formattedString = false;
+          var hasAlpha = this._a < 1 && this._a >= 0;
+          var needsAlphaFormat = !formatSet && hasAlpha && (format === "hex" || format === "hex6" || format === "hex3" || format === "hex4" || format === "hex8" || format === "name");
+          if (needsAlphaFormat) {
+            if (format === "name" && this._a === 0) {
+              return this.toName();
+            }
+            return this.toRgbString();
+          }
+          if (format === "rgb") {
+            formattedString = this.toRgbString();
+          }
+          if (format === "prgb") {
+            formattedString = this.toPercentageRgbString();
+          }
+          if (format === "hex" || format === "hex6") {
+            formattedString = this.toHexString();
+          }
+          if (format === "hex3") {
+            formattedString = this.toHexString(true);
+          }
+          if (format === "hex4") {
+            formattedString = this.toHex8String(true);
+          }
+          if (format === "hex8") {
+            formattedString = this.toHex8String();
+          }
+          if (format === "name") {
+            formattedString = this.toName();
+          }
+          if (format === "hsl") {
+            formattedString = this.toHslString();
+          }
+          if (format === "hsv") {
+            formattedString = this.toHsvString();
+          }
+          return formattedString || this.toHexString();
+        },
+        clone: function clone() {
+          return tinycolor(this.toString());
+        },
+        _applyModification: function _applyModification(fn, args) {
+          var color = fn.apply(null, [this].concat([].slice.call(args)));
+          this._r = color._r;
+          this._g = color._g;
+          this._b = color._b;
+          this.setAlpha(color._a);
+          return this;
+        },
+        lighten: function lighten() {
+          return this._applyModification(_lighten, arguments);
+        },
+        brighten: function brighten() {
+          return this._applyModification(_brighten, arguments);
+        },
+        darken: function darken() {
+          return this._applyModification(_darken, arguments);
+        },
+        desaturate: function desaturate() {
+          return this._applyModification(_desaturate, arguments);
+        },
+        saturate: function saturate() {
+          return this._applyModification(_saturate, arguments);
+        },
+        greyscale: function greyscale() {
+          return this._applyModification(_greyscale, arguments);
+        },
+        spin: function spin() {
+          return this._applyModification(_spin, arguments);
+        },
+        _applyCombination: function _applyCombination(fn, args) {
+          return fn.apply(null, [this].concat([].slice.call(args)));
+        },
+        analogous: function analogous() {
+          return this._applyCombination(_analogous, arguments);
+        },
+        complement: function complement() {
+          return this._applyCombination(_complement, arguments);
+        },
+        monochromatic: function monochromatic() {
+          return this._applyCombination(_monochromatic, arguments);
+        },
+        splitcomplement: function splitcomplement() {
+          return this._applyCombination(_splitcomplement, arguments);
+        },
+        // Disabled until https://github.com/bgrins/TinyColor/issues/254
+        // polyad: function (number) {
+        //   return this._applyCombination(polyad, [number]);
+        // },
+        triad: function triad() {
+          return this._applyCombination(polyad, [3]);
+        },
+        tetrad: function tetrad() {
+          return this._applyCombination(polyad, [4]);
+        }
+      };
+      tinycolor.fromRatio = function(color, opts) {
+        if (_typeof(color) == "object") {
+          var newColor = {};
+          for (var i in color) {
+            if (color.hasOwnProperty(i)) {
+              if (i === "a") {
+                newColor[i] = color[i];
+              } else {
+                newColor[i] = convertToPercentage(color[i]);
+              }
+            }
+          }
+          color = newColor;
+        }
+        return tinycolor(color, opts);
+      };
+      function inputToRGB(color) {
+        var rgb = {
+          r: 0,
+          g: 0,
+          b: 0
+        };
+        var a = 1;
+        var s = null;
+        var v = null;
+        var l = null;
+        var ok = false;
+        var format = false;
+        if (typeof color == "string") {
+          color = stringInputToObject(color);
+        }
+        if (_typeof(color) == "object") {
+          if (isValidCSSUnit(color.r) && isValidCSSUnit(color.g) && isValidCSSUnit(color.b)) {
+            rgb = rgbToRgb(color.r, color.g, color.b);
+            ok = true;
+            format = String(color.r).substr(-1) === "%" ? "prgb" : "rgb";
+          } else if (isValidCSSUnit(color.h) && isValidCSSUnit(color.s) && isValidCSSUnit(color.v)) {
+            s = convertToPercentage(color.s);
+            v = convertToPercentage(color.v);
+            rgb = hsvToRgb(color.h, s, v);
+            ok = true;
+            format = "hsv";
+          } else if (isValidCSSUnit(color.h) && isValidCSSUnit(color.s) && isValidCSSUnit(color.l)) {
+            s = convertToPercentage(color.s);
+            l = convertToPercentage(color.l);
+            rgb = hslToRgb(color.h, s, l);
+            ok = true;
+            format = "hsl";
+          }
+          if (color.hasOwnProperty("a")) {
+            a = color.a;
+          }
+        }
+        a = boundAlpha(a);
+        return {
+          ok,
+          format: color.format || format,
+          r: Math.min(255, Math.max(rgb.r, 0)),
+          g: Math.min(255, Math.max(rgb.g, 0)),
+          b: Math.min(255, Math.max(rgb.b, 0)),
+          a
+        };
+      }
+      function rgbToRgb(r, g, b) {
+        return {
+          r: bound01(r, 255) * 255,
+          g: bound01(g, 255) * 255,
+          b: bound01(b, 255) * 255
+        };
+      }
+      function rgbToHsl(r, g, b) {
+        r = bound01(r, 255);
+        g = bound01(g, 255);
+        b = bound01(b, 255);
+        var max = Math.max(r, g, b), min = Math.min(r, g, b);
+        var h, s, l = (max + min) / 2;
+        if (max == min) {
+          h = s = 0;
+        } else {
+          var d = max - min;
+          s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+          switch (max) {
+            case r:
+              h = (g - b) / d + (g < b ? 6 : 0);
+              break;
+            case g:
+              h = (b - r) / d + 2;
+              break;
+            case b:
+              h = (r - g) / d + 4;
+              break;
+          }
+          h /= 6;
+        }
+        return {
+          h,
+          s,
+          l
+        };
+      }
+      function hslToRgb(h, s, l) {
+        var r, g, b;
+        h = bound01(h, 360);
+        s = bound01(s, 100);
+        l = bound01(l, 100);
+        function hue2rgb(p2, q2, t) {
+          if (t < 0) t += 1;
+          if (t > 1) t -= 1;
+          if (t < 1 / 6) return p2 + (q2 - p2) * 6 * t;
+          if (t < 1 / 2) return q2;
+          if (t < 2 / 3) return p2 + (q2 - p2) * (2 / 3 - t) * 6;
+          return p2;
+        }
+        if (s === 0) {
+          r = g = b = l;
+        } else {
+          var q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+          var p = 2 * l - q;
+          r = hue2rgb(p, q, h + 1 / 3);
+          g = hue2rgb(p, q, h);
+          b = hue2rgb(p, q, h - 1 / 3);
+        }
+        return {
+          r: r * 255,
+          g: g * 255,
+          b: b * 255
+        };
+      }
+      function rgbToHsv(r, g, b) {
+        r = bound01(r, 255);
+        g = bound01(g, 255);
+        b = bound01(b, 255);
+        var max = Math.max(r, g, b), min = Math.min(r, g, b);
+        var h, s, v = max;
+        var d = max - min;
+        s = max === 0 ? 0 : d / max;
+        if (max == min) {
+          h = 0;
+        } else {
+          switch (max) {
+            case r:
+              h = (g - b) / d + (g < b ? 6 : 0);
+              break;
+            case g:
+              h = (b - r) / d + 2;
+              break;
+            case b:
+              h = (r - g) / d + 4;
+              break;
+          }
+          h /= 6;
+        }
+        return {
+          h,
+          s,
+          v
+        };
+      }
+      function hsvToRgb(h, s, v) {
+        h = bound01(h, 360) * 6;
+        s = bound01(s, 100);
+        v = bound01(v, 100);
+        var i = Math.floor(h), f = h - i, p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s), mod = i % 6, r = [v, q, p, p, t, v][mod], g = [t, v, v, q, p, p][mod], b = [p, p, t, v, v, q][mod];
+        return {
+          r: r * 255,
+          g: g * 255,
+          b: b * 255
+        };
+      }
+      function rgbToHex(r, g, b, allow3Char) {
+        var hex = [pad2(Math.round(r).toString(16)), pad2(Math.round(g).toString(16)), pad2(Math.round(b).toString(16))];
+        if (allow3Char && hex[0].charAt(0) == hex[0].charAt(1) && hex[1].charAt(0) == hex[1].charAt(1) && hex[2].charAt(0) == hex[2].charAt(1)) {
+          return hex[0].charAt(0) + hex[1].charAt(0) + hex[2].charAt(0);
+        }
+        return hex.join("");
+      }
+      function rgbaToHex(r, g, b, a, allow4Char) {
+        var hex = [pad2(Math.round(r).toString(16)), pad2(Math.round(g).toString(16)), pad2(Math.round(b).toString(16)), pad2(convertDecimalToHex(a))];
+        if (allow4Char && hex[0].charAt(0) == hex[0].charAt(1) && hex[1].charAt(0) == hex[1].charAt(1) && hex[2].charAt(0) == hex[2].charAt(1) && hex[3].charAt(0) == hex[3].charAt(1)) {
+          return hex[0].charAt(0) + hex[1].charAt(0) + hex[2].charAt(0) + hex[3].charAt(0);
+        }
+        return hex.join("");
+      }
+      function rgbaToArgbHex(r, g, b, a) {
+        var hex = [pad2(convertDecimalToHex(a)), pad2(Math.round(r).toString(16)), pad2(Math.round(g).toString(16)), pad2(Math.round(b).toString(16))];
+        return hex.join("");
+      }
+      tinycolor.equals = function(color1, color2) {
+        if (!color1 || !color2) return false;
+        return tinycolor(color1).toRgbString() == tinycolor(color2).toRgbString();
+      };
+      tinycolor.random = function() {
+        return tinycolor.fromRatio({
+          r: Math.random(),
+          g: Math.random(),
+          b: Math.random()
+        });
+      };
+      function _desaturate(color, amount) {
+        amount = amount === 0 ? 0 : amount || 10;
+        var hsl = tinycolor(color).toHsl();
+        hsl.s -= amount / 100;
+        hsl.s = clamp01(hsl.s);
+        return tinycolor(hsl);
+      }
+      function _saturate(color, amount) {
+        amount = amount === 0 ? 0 : amount || 10;
+        var hsl = tinycolor(color).toHsl();
+        hsl.s += amount / 100;
+        hsl.s = clamp01(hsl.s);
+        return tinycolor(hsl);
+      }
+      function _greyscale(color) {
+        return tinycolor(color).desaturate(100);
+      }
+      function _lighten(color, amount) {
+        amount = amount === 0 ? 0 : amount || 10;
+        var hsl = tinycolor(color).toHsl();
+        hsl.l += amount / 100;
+        hsl.l = clamp01(hsl.l);
+        return tinycolor(hsl);
+      }
+      function _brighten(color, amount) {
+        amount = amount === 0 ? 0 : amount || 10;
+        var rgb = tinycolor(color).toRgb();
+        rgb.r = Math.max(0, Math.min(255, rgb.r - Math.round(255 * -(amount / 100))));
+        rgb.g = Math.max(0, Math.min(255, rgb.g - Math.round(255 * -(amount / 100))));
+        rgb.b = Math.max(0, Math.min(255, rgb.b - Math.round(255 * -(amount / 100))));
+        return tinycolor(rgb);
+      }
+      function _darken(color, amount) {
+        amount = amount === 0 ? 0 : amount || 10;
+        var hsl = tinycolor(color).toHsl();
+        hsl.l -= amount / 100;
+        hsl.l = clamp01(hsl.l);
+        return tinycolor(hsl);
+      }
+      function _spin(color, amount) {
+        var hsl = tinycolor(color).toHsl();
+        var hue = (hsl.h + amount) % 360;
+        hsl.h = hue < 0 ? 360 + hue : hue;
+        return tinycolor(hsl);
+      }
+      function _complement(color) {
+        var hsl = tinycolor(color).toHsl();
+        hsl.h = (hsl.h + 180) % 360;
+        return tinycolor(hsl);
+      }
+      function polyad(color, number) {
+        if (isNaN(number) || number <= 0) {
+          throw new Error("Argument to polyad must be a positive number");
+        }
+        var hsl = tinycolor(color).toHsl();
+        var result = [tinycolor(color)];
+        var step = 360 / number;
+        for (var i = 1; i < number; i++) {
+          result.push(tinycolor({
+            h: (hsl.h + i * step) % 360,
+            s: hsl.s,
+            l: hsl.l
+          }));
+        }
+        return result;
+      }
+      function _splitcomplement(color) {
+        var hsl = tinycolor(color).toHsl();
+        var h = hsl.h;
+        return [tinycolor(color), tinycolor({
+          h: (h + 72) % 360,
+          s: hsl.s,
+          l: hsl.l
+        }), tinycolor({
+          h: (h + 216) % 360,
+          s: hsl.s,
+          l: hsl.l
+        })];
+      }
+      function _analogous(color, results, slices) {
+        results = results || 6;
+        slices = slices || 30;
+        var hsl = tinycolor(color).toHsl();
+        var part = 360 / slices;
+        var ret = [tinycolor(color)];
+        for (hsl.h = (hsl.h - (part * results >> 1) + 720) % 360; --results; ) {
+          hsl.h = (hsl.h + part) % 360;
+          ret.push(tinycolor(hsl));
+        }
+        return ret;
+      }
+      function _monochromatic(color, results) {
+        results = results || 6;
+        var hsv = tinycolor(color).toHsv();
+        var h = hsv.h, s = hsv.s, v = hsv.v;
+        var ret = [];
+        var modification = 1 / results;
+        while (results--) {
+          ret.push(tinycolor({
+            h,
+            s,
+            v
+          }));
+          v = (v + modification) % 1;
+        }
+        return ret;
+      }
+      tinycolor.mix = function(color1, color2, amount) {
+        amount = amount === 0 ? 0 : amount || 50;
+        var rgb1 = tinycolor(color1).toRgb();
+        var rgb2 = tinycolor(color2).toRgb();
+        var p = amount / 100;
+        var rgba = {
+          r: (rgb2.r - rgb1.r) * p + rgb1.r,
+          g: (rgb2.g - rgb1.g) * p + rgb1.g,
+          b: (rgb2.b - rgb1.b) * p + rgb1.b,
+          a: (rgb2.a - rgb1.a) * p + rgb1.a
+        };
+        return tinycolor(rgba);
+      };
+      tinycolor.readability = function(color1, color2) {
+        var c1 = tinycolor(color1);
+        var c2 = tinycolor(color2);
+        return (Math.max(c1.getLuminance(), c2.getLuminance()) + 0.05) / (Math.min(c1.getLuminance(), c2.getLuminance()) + 0.05);
+      };
+      tinycolor.isReadable = function(color1, color2, wcag2) {
+        var readability = tinycolor.readability(color1, color2);
+        var wcag2Parms, out;
+        out = false;
+        wcag2Parms = validateWCAG2Parms(wcag2);
+        switch (wcag2Parms.level + wcag2Parms.size) {
+          case "AAsmall":
+          case "AAAlarge":
+            out = readability >= 4.5;
+            break;
+          case "AAlarge":
+            out = readability >= 3;
+            break;
+          case "AAAsmall":
+            out = readability >= 7;
+            break;
+        }
+        return out;
+      };
+      tinycolor.mostReadable = function(baseColor, colorList, args) {
+        var bestColor = null;
+        var bestScore = 0;
+        var readability;
+        var includeFallbackColors, level, size;
+        args = args || {};
+        includeFallbackColors = args.includeFallbackColors;
+        level = args.level;
+        size = args.size;
+        for (var i = 0; i < colorList.length; i++) {
+          readability = tinycolor.readability(baseColor, colorList[i]);
+          if (readability > bestScore) {
+            bestScore = readability;
+            bestColor = tinycolor(colorList[i]);
+          }
+        }
+        if (tinycolor.isReadable(baseColor, bestColor, {
+          level,
+          size
+        }) || !includeFallbackColors) {
+          return bestColor;
+        } else {
+          args.includeFallbackColors = false;
+          return tinycolor.mostReadable(baseColor, ["#fff", "#000"], args);
+        }
+      };
+      var names = tinycolor.names = {
+        aliceblue: "f0f8ff",
+        antiquewhite: "faebd7",
+        aqua: "0ff",
+        aquamarine: "7fffd4",
+        azure: "f0ffff",
+        beige: "f5f5dc",
+        bisque: "ffe4c4",
+        black: "000",
+        blanchedalmond: "ffebcd",
+        blue: "00f",
+        blueviolet: "8a2be2",
+        brown: "a52a2a",
+        burlywood: "deb887",
+        burntsienna: "ea7e5d",
+        cadetblue: "5f9ea0",
+        chartreuse: "7fff00",
+        chocolate: "d2691e",
+        coral: "ff7f50",
+        cornflowerblue: "6495ed",
+        cornsilk: "fff8dc",
+        crimson: "dc143c",
+        cyan: "0ff",
+        darkblue: "00008b",
+        darkcyan: "008b8b",
+        darkgoldenrod: "b8860b",
+        darkgray: "a9a9a9",
+        darkgreen: "006400",
+        darkgrey: "a9a9a9",
+        darkkhaki: "bdb76b",
+        darkmagenta: "8b008b",
+        darkolivegreen: "556b2f",
+        darkorange: "ff8c00",
+        darkorchid: "9932cc",
+        darkred: "8b0000",
+        darksalmon: "e9967a",
+        darkseagreen: "8fbc8f",
+        darkslateblue: "483d8b",
+        darkslategray: "2f4f4f",
+        darkslategrey: "2f4f4f",
+        darkturquoise: "00ced1",
+        darkviolet: "9400d3",
+        deeppink: "ff1493",
+        deepskyblue: "00bfff",
+        dimgray: "696969",
+        dimgrey: "696969",
+        dodgerblue: "1e90ff",
+        firebrick: "b22222",
+        floralwhite: "fffaf0",
+        forestgreen: "228b22",
+        fuchsia: "f0f",
+        gainsboro: "dcdcdc",
+        ghostwhite: "f8f8ff",
+        gold: "ffd700",
+        goldenrod: "daa520",
+        gray: "808080",
+        green: "008000",
+        greenyellow: "adff2f",
+        grey: "808080",
+        honeydew: "f0fff0",
+        hotpink: "ff69b4",
+        indianred: "cd5c5c",
+        indigo: "4b0082",
+        ivory: "fffff0",
+        khaki: "f0e68c",
+        lavender: "e6e6fa",
+        lavenderblush: "fff0f5",
+        lawngreen: "7cfc00",
+        lemonchiffon: "fffacd",
+        lightblue: "add8e6",
+        lightcoral: "f08080",
+        lightcyan: "e0ffff",
+        lightgoldenrodyellow: "fafad2",
+        lightgray: "d3d3d3",
+        lightgreen: "90ee90",
+        lightgrey: "d3d3d3",
+        lightpink: "ffb6c1",
+        lightsalmon: "ffa07a",
+        lightseagreen: "20b2aa",
+        lightskyblue: "87cefa",
+        lightslategray: "789",
+        lightslategrey: "789",
+        lightsteelblue: "b0c4de",
+        lightyellow: "ffffe0",
+        lime: "0f0",
+        limegreen: "32cd32",
+        linen: "faf0e6",
+        magenta: "f0f",
+        maroon: "800000",
+        mediumaquamarine: "66cdaa",
+        mediumblue: "0000cd",
+        mediumorchid: "ba55d3",
+        mediumpurple: "9370db",
+        mediumseagreen: "3cb371",
+        mediumslateblue: "7b68ee",
+        mediumspringgreen: "00fa9a",
+        mediumturquoise: "48d1cc",
+        mediumvioletred: "c71585",
+        midnightblue: "191970",
+        mintcream: "f5fffa",
+        mistyrose: "ffe4e1",
+        moccasin: "ffe4b5",
+        navajowhite: "ffdead",
+        navy: "000080",
+        oldlace: "fdf5e6",
+        olive: "808000",
+        olivedrab: "6b8e23",
+        orange: "ffa500",
+        orangered: "ff4500",
+        orchid: "da70d6",
+        palegoldenrod: "eee8aa",
+        palegreen: "98fb98",
+        paleturquoise: "afeeee",
+        palevioletred: "db7093",
+        papayawhip: "ffefd5",
+        peachpuff: "ffdab9",
+        peru: "cd853f",
+        pink: "ffc0cb",
+        plum: "dda0dd",
+        powderblue: "b0e0e6",
+        purple: "800080",
+        rebeccapurple: "663399",
+        red: "f00",
+        rosybrown: "bc8f8f",
+        royalblue: "4169e1",
+        saddlebrown: "8b4513",
+        salmon: "fa8072",
+        sandybrown: "f4a460",
+        seagreen: "2e8b57",
+        seashell: "fff5ee",
+        sienna: "a0522d",
+        silver: "c0c0c0",
+        skyblue: "87ceeb",
+        slateblue: "6a5acd",
+        slategray: "708090",
+        slategrey: "708090",
+        snow: "fffafa",
+        springgreen: "00ff7f",
+        steelblue: "4682b4",
+        tan: "d2b48c",
+        teal: "008080",
+        thistle: "d8bfd8",
+        tomato: "ff6347",
+        turquoise: "40e0d0",
+        violet: "ee82ee",
+        wheat: "f5deb3",
+        white: "fff",
+        whitesmoke: "f5f5f5",
+        yellow: "ff0",
+        yellowgreen: "9acd32"
+      };
+      var hexNames = tinycolor.hexNames = flip(names);
+      function flip(o) {
+        var flipped = {};
+        for (var i in o) {
+          if (o.hasOwnProperty(i)) {
+            flipped[o[i]] = i;
+          }
+        }
+        return flipped;
+      }
+      function boundAlpha(a) {
+        a = parseFloat(a);
+        if (isNaN(a) || a < 0 || a > 1) {
+          a = 1;
+        }
+        return a;
+      }
+      function bound01(n, max) {
+        if (isOnePointZero(n)) n = "100%";
+        var processPercent = isPercentage(n);
+        n = Math.min(max, Math.max(0, parseFloat(n)));
+        if (processPercent) {
+          n = parseInt(n * max, 10) / 100;
+        }
+        if (Math.abs(n - max) < 1e-6) {
+          return 1;
+        }
+        return n % max / parseFloat(max);
+      }
+      function clamp01(val) {
+        return Math.min(1, Math.max(0, val));
+      }
+      function parseIntFromHex(val) {
+        return parseInt(val, 16);
+      }
+      function isOnePointZero(n) {
+        return typeof n == "string" && n.indexOf(".") != -1 && parseFloat(n) === 1;
+      }
+      function isPercentage(n) {
+        return typeof n === "string" && n.indexOf("%") != -1;
+      }
+      function pad2(c) {
+        return c.length == 1 ? "0" + c : "" + c;
+      }
+      function convertToPercentage(n) {
+        if (n <= 1) {
+          n = n * 100 + "%";
+        }
+        return n;
+      }
+      function convertDecimalToHex(d) {
+        return Math.round(parseFloat(d) * 255).toString(16);
+      }
+      function convertHexToDecimal(h) {
+        return parseIntFromHex(h) / 255;
+      }
+      var matchers = (function() {
+        var CSS_INTEGER = "[-\\+]?\\d+%?";
+        var CSS_NUMBER = "[-\\+]?\\d*\\.\\d+%?";
+        var CSS_UNIT = "(?:" + CSS_NUMBER + ")|(?:" + CSS_INTEGER + ")";
+        var PERMISSIVE_MATCH3 = "[\\s|\\(]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")\\s*\\)?";
+        var PERMISSIVE_MATCH4 = "[\\s|\\(]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")\\s*\\)?";
+        return {
+          CSS_UNIT: new RegExp(CSS_UNIT),
+          rgb: new RegExp("rgb" + PERMISSIVE_MATCH3),
+          rgba: new RegExp("rgba" + PERMISSIVE_MATCH4),
+          hsl: new RegExp("hsl" + PERMISSIVE_MATCH3),
+          hsla: new RegExp("hsla" + PERMISSIVE_MATCH4),
+          hsv: new RegExp("hsv" + PERMISSIVE_MATCH3),
+          hsva: new RegExp("hsva" + PERMISSIVE_MATCH4),
+          hex3: /^#?([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,
+          hex6: /^#?([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/,
+          hex4: /^#?([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,
+          hex8: /^#?([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/
+        };
+      })();
+      function isValidCSSUnit(color) {
+        return !!matchers.CSS_UNIT.exec(color);
+      }
+      function stringInputToObject(color) {
+        color = color.replace(trimLeft, "").replace(trimRight, "").toLowerCase();
+        var named = false;
+        if (names[color]) {
+          color = names[color];
+          named = true;
+        } else if (color == "transparent") {
+          return {
+            r: 0,
+            g: 0,
+            b: 0,
+            a: 0,
+            format: "name"
+          };
+        }
+        var match;
+        if (match = matchers.rgb.exec(color)) {
+          return {
+            r: match[1],
+            g: match[2],
+            b: match[3]
+          };
+        }
+        if (match = matchers.rgba.exec(color)) {
+          return {
+            r: match[1],
+            g: match[2],
+            b: match[3],
+            a: match[4]
+          };
+        }
+        if (match = matchers.hsl.exec(color)) {
+          return {
+            h: match[1],
+            s: match[2],
+            l: match[3]
+          };
+        }
+        if (match = matchers.hsla.exec(color)) {
+          return {
+            h: match[1],
+            s: match[2],
+            l: match[3],
+            a: match[4]
+          };
+        }
+        if (match = matchers.hsv.exec(color)) {
+          return {
+            h: match[1],
+            s: match[2],
+            v: match[3]
+          };
+        }
+        if (match = matchers.hsva.exec(color)) {
+          return {
+            h: match[1],
+            s: match[2],
+            v: match[3],
+            a: match[4]
+          };
+        }
+        if (match = matchers.hex8.exec(color)) {
+          return {
+            r: parseIntFromHex(match[1]),
+            g: parseIntFromHex(match[2]),
+            b: parseIntFromHex(match[3]),
+            a: convertHexToDecimal(match[4]),
+            format: named ? "name" : "hex8"
+          };
+        }
+        if (match = matchers.hex6.exec(color)) {
+          return {
+            r: parseIntFromHex(match[1]),
+            g: parseIntFromHex(match[2]),
+            b: parseIntFromHex(match[3]),
+            format: named ? "name" : "hex"
+          };
+        }
+        if (match = matchers.hex4.exec(color)) {
+          return {
+            r: parseIntFromHex(match[1] + "" + match[1]),
+            g: parseIntFromHex(match[2] + "" + match[2]),
+            b: parseIntFromHex(match[3] + "" + match[3]),
+            a: convertHexToDecimal(match[4] + "" + match[4]),
+            format: named ? "name" : "hex8"
+          };
+        }
+        if (match = matchers.hex3.exec(color)) {
+          return {
+            r: parseIntFromHex(match[1] + "" + match[1]),
+            g: parseIntFromHex(match[2] + "" + match[2]),
+            b: parseIntFromHex(match[3] + "" + match[3]),
+            format: named ? "name" : "hex"
+          };
+        }
+        return false;
+      }
+      function validateWCAG2Parms(parms) {
+        var level, size;
+        parms = parms || {
+          level: "AA",
+          size: "small"
+        };
+        level = (parms.level || "AA").toUpperCase();
+        size = (parms.size || "small").toLowerCase();
+        if (level !== "AA" && level !== "AAA") {
+          level = "AA";
+        }
+        if (size !== "small" && size !== "large") {
+          size = "small";
+        }
+        return {
+          level,
+          size
+        };
+      }
+      return tinycolor;
+    }));
+  }
+});
+
+// ../../node_modules/.pnpm/tinygradient@1.1.5/node_modules/tinygradient/index.js
+var require_tinygradient = __commonJS({
+  "../../node_modules/.pnpm/tinygradient@1.1.5/node_modules/tinygradient/index.js"(exports, module) {
+    "use strict";
+    init_esm_shims();
+    var tinycolor = require_tinycolor();
+    var RGBA_MAX = { r: 256, g: 256, b: 256, a: 1 };
+    var HSVA_MAX = { h: 360, s: 1, v: 1, a: 1 };
+    function stepize(start, end, steps) {
+      let step = {};
+      for (let k in start) {
+        if (start.hasOwnProperty(k)) {
+          step[k] = steps === 0 ? 0 : (end[k] - start[k]) / steps;
+        }
+      }
+      return step;
+    }
+    function interpolate(step, start, i, max) {
+      let color = {};
+      for (let k in start) {
+        if (start.hasOwnProperty(k)) {
+          color[k] = step[k] * i + start[k];
+          color[k] = color[k] < 0 ? color[k] + max[k] : max[k] !== 1 ? color[k] % max[k] : color[k];
+        }
+      }
+      return color;
+    }
+    function interpolateRgb(stop1, stop2, steps) {
+      const start = stop1.color.toRgb();
+      const end = stop2.color.toRgb();
+      const step = stepize(start, end, steps);
+      let gradient2 = [stop1.color];
+      for (let i = 1; i < steps; i++) {
+        const color = interpolate(step, start, i, RGBA_MAX);
+        gradient2.push(tinycolor(color));
+      }
+      return gradient2;
+    }
+    function interpolateHsv(stop1, stop2, steps, mode) {
+      const start = stop1.color.toHsv();
+      const end = stop2.color.toHsv();
+      if (start.s === 0 || end.s === 0) {
+        return interpolateRgb(stop1, stop2, steps);
+      }
+      let trigonometric;
+      if (typeof mode === "boolean") {
+        trigonometric = mode;
+      } else {
+        const trigShortest = start.h < end.h && end.h - start.h < 180 || start.h > end.h && start.h - end.h > 180;
+        trigonometric = mode === "long" && trigShortest || mode === "short" && !trigShortest;
+      }
+      const step = stepize(start, end, steps);
+      let gradient2 = [stop1.color];
+      let diff;
+      if (start.h <= end.h && !trigonometric || start.h >= end.h && trigonometric) {
+        diff = end.h - start.h;
+      } else if (trigonometric) {
+        diff = 360 - end.h + start.h;
+      } else {
+        diff = 360 - start.h + end.h;
+      }
+      step.h = Math.pow(-1, trigonometric ? 1 : 0) * Math.abs(diff) / steps;
+      for (let i = 1; i < steps; i++) {
+        const color = interpolate(step, start, i, HSVA_MAX);
+        gradient2.push(tinycolor(color));
+      }
+      return gradient2;
+    }
+    function computeSubsteps(stops, steps) {
+      const l = stops.length;
+      steps = parseInt(steps, 10);
+      if (isNaN(steps) || steps < 2) {
+        throw new Error("Invalid number of steps (< 2)");
+      }
+      if (steps < l) {
+        throw new Error("Number of steps cannot be inferior to number of stops");
+      }
+      let substeps = [];
+      for (let i = 1; i < l; i++) {
+        const step = (steps - 1) * (stops[i].pos - stops[i - 1].pos);
+        substeps.push(Math.max(1, Math.round(step)));
+      }
+      let totalSubsteps = 1;
+      for (let n = l - 1; n--; ) totalSubsteps += substeps[n];
+      while (totalSubsteps !== steps) {
+        if (totalSubsteps < steps) {
+          const min = Math.min.apply(null, substeps);
+          substeps[substeps.indexOf(min)]++;
+          totalSubsteps++;
+        } else {
+          const max = Math.max.apply(null, substeps);
+          substeps[substeps.indexOf(max)]--;
+          totalSubsteps--;
+        }
+      }
+      return substeps;
+    }
+    function computeAt(stops, pos, method, max) {
+      if (pos < 0 || pos > 1) {
+        throw new Error("Position must be between 0 and 1");
+      }
+      let start, end;
+      for (let i = 0, l = stops.length; i < l - 1; i++) {
+        if (pos >= stops[i].pos && pos < stops[i + 1].pos) {
+          start = stops[i];
+          end = stops[i + 1];
+          break;
+        }
+      }
+      if (!start) {
+        start = end = stops[stops.length - 1];
+      }
+      const step = stepize(start.color[method](), end.color[method](), (end.pos - start.pos) * 100);
+      const color = interpolate(step, start.color[method](), (pos - start.pos) * 100, max);
+      return tinycolor(color);
+    }
+    var TinyGradient = class _TinyGradient {
+      /**
+       * @param {StopInput[]|ColorInput[]} stops
+       * @returns {TinyGradient}
+       */
+      constructor(stops) {
+        if (stops.length < 2) {
+          throw new Error("Invalid number of stops (< 2)");
+        }
+        const havingPositions = stops[0].pos !== void 0;
+        let l = stops.length;
+        let p = -1;
+        let lastColorLess = false;
+        this.stops = stops.map((stop, i) => {
+          const hasPosition = stop.pos !== void 0;
+          if (havingPositions ^ hasPosition) {
+            throw new Error("Cannot mix positionned and not posionned color stops");
+          }
+          if (hasPosition) {
+            const hasColor = stop.color !== void 0;
+            if (!hasColor && (lastColorLess || i === 0 || i === l - 1)) {
+              throw new Error("Cannot define two consecutive position-only stops");
+            }
+            lastColorLess = !hasColor;
+            stop = {
+              color: hasColor ? tinycolor(stop.color) : null,
+              colorLess: !hasColor,
+              pos: stop.pos
+            };
+            if (stop.pos < 0 || stop.pos > 1) {
+              throw new Error("Color stops positions must be between 0 and 1");
+            } else if (stop.pos < p) {
+              throw new Error("Color stops positions are not ordered");
+            }
+            p = stop.pos;
+          } else {
+            stop = {
+              color: tinycolor(stop.color !== void 0 ? stop.color : stop),
+              pos: i / (l - 1)
+            };
+          }
+          return stop;
+        });
+        if (this.stops[0].pos !== 0) {
+          this.stops.unshift({
+            color: this.stops[0].color,
+            pos: 0
+          });
+          l++;
+        }
+        if (this.stops[l - 1].pos !== 1) {
+          this.stops.push({
+            color: this.stops[l - 1].color,
+            pos: 1
+          });
+        }
+      }
+      /**
+       * Return new instance with reversed stops
+       * @return {TinyGradient}
+       */
+      reverse() {
+        let stops = [];
+        this.stops.forEach(function(stop) {
+          stops.push({
+            color: stop.color,
+            pos: 1 - stop.pos
+          });
+        });
+        return new _TinyGradient(stops.reverse());
+      }
+      /**
+       * Return new instance with looped stops
+       * @return {TinyGradient}
+       */
+      loop() {
+        let stops1 = [];
+        let stops2 = [];
+        this.stops.forEach((stop) => {
+          stops1.push({
+            color: stop.color,
+            pos: stop.pos / 2
+          });
+        });
+        this.stops.slice(0, -1).forEach((stop) => {
+          stops2.push({
+            color: stop.color,
+            pos: 1 - stop.pos / 2
+          });
+        });
+        return new _TinyGradient(stops1.concat(stops2.reverse()));
+      }
+      /**
+       * Generate gradient with RGBa interpolation
+       * @param {number} steps
+       * @return {tinycolor[]}
+       */
+      rgb(steps) {
+        const substeps = computeSubsteps(this.stops, steps);
+        let gradient2 = [];
+        this.stops.forEach((stop, i) => {
+          if (stop.colorLess) {
+            stop.color = interpolateRgb(this.stops[i - 1], this.stops[i + 1], 2)[1];
+          }
+        });
+        for (let i = 0, l = this.stops.length; i < l - 1; i++) {
+          const rgb = interpolateRgb(this.stops[i], this.stops[i + 1], substeps[i]);
+          gradient2.splice(gradient2.length, 0, ...rgb);
+        }
+        gradient2.push(this.stops[this.stops.length - 1].color);
+        return gradient2;
+      }
+      /**
+       * Generate gradient with HSVa interpolation
+       * @param {number} steps
+       * @param {boolean|'long'|'short'} [mode=false]
+       *    - false to step in clockwise
+       *    - true to step in trigonometric order
+       *    - 'short' to use the shortest way
+       *    - 'long' to use the longest way
+       * @return {tinycolor[]}
+       */
+      hsv(steps, mode) {
+        const substeps = computeSubsteps(this.stops, steps);
+        let gradient2 = [];
+        this.stops.forEach((stop, i) => {
+          if (stop.colorLess) {
+            stop.color = interpolateHsv(this.stops[i - 1], this.stops[i + 1], 2, mode)[1];
+          }
+        });
+        for (let i = 0, l = this.stops.length; i < l - 1; i++) {
+          const hsv = interpolateHsv(this.stops[i], this.stops[i + 1], substeps[i], mode);
+          gradient2.splice(gradient2.length, 0, ...hsv);
+        }
+        gradient2.push(this.stops[this.stops.length - 1].color);
+        return gradient2;
+      }
+      /**
+       * Generate CSS3 command (no prefix) for this gradient
+       * @param {String} [mode=linear] - 'linear' or 'radial'
+       * @param {String} [direction] - default is 'to right' or 'ellipse at center'
+       * @return {String}
+       */
+      css(mode, direction) {
+        mode = mode || "linear";
+        direction = direction || (mode === "linear" ? "to right" : "ellipse at center");
+        let css = mode + "-gradient(" + direction;
+        this.stops.forEach(function(stop) {
+          css += ", " + (stop.colorLess ? "" : stop.color.toRgbString() + " ") + stop.pos * 100 + "%";
+        });
+        css += ")";
+        return css;
+      }
+      /**
+       * Returns the color at specific position with RGBa interpolation
+       * @param {number} pos, between 0 and 1
+       * @return {tinycolor}
+       */
+      rgbAt(pos) {
+        return computeAt(this.stops, pos, "toRgb", RGBA_MAX);
+      }
+      /**
+       * Returns the color at specific position with HSVa interpolation
+       * @param {number} pos, between 0 and 1
+       * @return {tinycolor}
+       */
+      hsvAt(pos) {
+        return computeAt(this.stops, pos, "toHsv", HSVA_MAX);
+      }
+    };
+    module.exports = function(stops) {
+      if (arguments.length === 1) {
+        if (!Array.isArray(arguments[0])) {
+          throw new Error('"stops" is not an array');
+        }
+        stops = arguments[0];
+      } else {
+        stops = Array.prototype.slice.call(arguments);
+      }
+      return new TinyGradient(stops);
+    };
+  }
+});
+
+// src/index.ts
+init_esm_shims();
+
+// ../../node_modules/.pnpm/cac@6.7.14/node_modules/cac/dist/index.mjs
+init_esm_shims();
+import { EventEmitter } from "events";
+function toArr(any) {
+  return any == null ? [] : Array.isArray(any) ? any : [any];
+}
+function toVal(out, key, val, opts) {
+  var x, old = out[key], nxt = !!~opts.string.indexOf(key) ? val == null || val === true ? "" : String(val) : typeof val === "boolean" ? val : !!~opts.boolean.indexOf(key) ? val === "false" ? false : val === "true" || (out._.push((x = +val, x * 0 === 0) ? x : val), !!val) : (x = +val, x * 0 === 0) ? x : val;
+  out[key] = old == null ? nxt : Array.isArray(old) ? old.concat(nxt) : [old, nxt];
+}
+function mri2(args, opts) {
+  args = args || [];
+  opts = opts || {};
+  var k, arr, arg, name, val, out = { _: [] };
+  var i = 0, j = 0, idx = 0, len = args.length;
+  const alibi = opts.alias !== void 0;
+  const strict = opts.unknown !== void 0;
+  const defaults = opts.default !== void 0;
+  opts.alias = opts.alias || {};
+  opts.string = toArr(opts.string);
+  opts.boolean = toArr(opts.boolean);
+  if (alibi) {
+    for (k in opts.alias) {
+      arr = opts.alias[k] = toArr(opts.alias[k]);
+      for (i = 0; i < arr.length; i++) {
+        (opts.alias[arr[i]] = arr.concat(k)).splice(i, 1);
+      }
+    }
+  }
+  for (i = opts.boolean.length; i-- > 0; ) {
+    arr = opts.alias[opts.boolean[i]] || [];
+    for (j = arr.length; j-- > 0; ) opts.boolean.push(arr[j]);
+  }
+  for (i = opts.string.length; i-- > 0; ) {
+    arr = opts.alias[opts.string[i]] || [];
+    for (j = arr.length; j-- > 0; ) opts.string.push(arr[j]);
+  }
+  if (defaults) {
+    for (k in opts.default) {
+      name = typeof opts.default[k];
+      arr = opts.alias[k] = opts.alias[k] || [];
+      if (opts[name] !== void 0) {
+        opts[name].push(k);
+        for (i = 0; i < arr.length; i++) {
+          opts[name].push(arr[i]);
+        }
+      }
+    }
+  }
+  const keys = strict ? Object.keys(opts.alias) : [];
+  for (i = 0; i < len; i++) {
+    arg = args[i];
+    if (arg === "--") {
+      out._ = out._.concat(args.slice(++i));
+      break;
+    }
+    for (j = 0; j < arg.length; j++) {
+      if (arg.charCodeAt(j) !== 45) break;
+    }
+    if (j === 0) {
+      out._.push(arg);
+    } else if (arg.substring(j, j + 3) === "no-") {
+      name = arg.substring(j + 3);
+      if (strict && !~keys.indexOf(name)) {
+        return opts.unknown(arg);
+      }
+      out[name] = false;
+    } else {
+      for (idx = j + 1; idx < arg.length; idx++) {
+        if (arg.charCodeAt(idx) === 61) break;
+      }
+      name = arg.substring(j, idx);
+      val = arg.substring(++idx) || (i + 1 === len || ("" + args[i + 1]).charCodeAt(0) === 45 || args[++i]);
+      arr = j === 2 ? [name] : name;
+      for (idx = 0; idx < arr.length; idx++) {
+        name = arr[idx];
+        if (strict && !~keys.indexOf(name)) return opts.unknown("-".repeat(j) + name);
+        toVal(out, name, idx + 1 < arr.length || val, opts);
+      }
+    }
+  }
+  if (defaults) {
+    for (k in opts.default) {
+      if (out[k] === void 0) {
+        out[k] = opts.default[k];
+      }
+    }
+  }
+  if (alibi) {
+    for (k in out) {
+      arr = opts.alias[k] || [];
+      while (arr.length > 0) {
+        out[arr.shift()] = out[k];
+      }
+    }
+  }
+  return out;
+}
+var removeBrackets = (v) => v.replace(/[<[].+/, "").trim();
+var findAllBrackets = (v) => {
+  const ANGLED_BRACKET_RE_GLOBAL = /<([^>]+)>/g;
+  const SQUARE_BRACKET_RE_GLOBAL = /\[([^\]]+)\]/g;
+  const res = [];
+  const parse = (match) => {
+    let variadic = false;
+    let value = match[1];
+    if (value.startsWith("...")) {
+      value = value.slice(3);
+      variadic = true;
+    }
+    return {
+      required: match[0].startsWith("<"),
+      value,
+      variadic
+    };
+  };
+  let angledMatch;
+  while (angledMatch = ANGLED_BRACKET_RE_GLOBAL.exec(v)) {
+    res.push(parse(angledMatch));
+  }
+  let squareMatch;
+  while (squareMatch = SQUARE_BRACKET_RE_GLOBAL.exec(v)) {
+    res.push(parse(squareMatch));
+  }
+  return res;
+};
+var getMriOptions = (options) => {
+  const result = { alias: {}, boolean: [] };
+  for (const [index, option] of options.entries()) {
+    if (option.names.length > 1) {
+      result.alias[option.names[0]] = option.names.slice(1);
+    }
+    if (option.isBoolean) {
+      if (option.negated) {
+        const hasStringTypeOption = options.some((o, i) => {
+          return i !== index && o.names.some((name) => option.names.includes(name)) && typeof o.required === "boolean";
+        });
+        if (!hasStringTypeOption) {
+          result.boolean.push(option.names[0]);
+        }
+      } else {
+        result.boolean.push(option.names[0]);
+      }
+    }
+  }
+  return result;
+};
+var findLongest = (arr) => {
+  return arr.sort((a, b) => {
+    return a.length > b.length ? -1 : 1;
+  })[0];
+};
+var padRight = (str, length) => {
+  return str.length >= length ? str : `${str}${" ".repeat(length - str.length)}`;
+};
+var camelcase = (input) => {
+  return input.replace(/([a-z])-([a-z])/g, (_, p1, p2) => {
+    return p1 + p2.toUpperCase();
+  });
+};
+var setDotProp = (obj, keys, val) => {
+  let i = 0;
+  let length = keys.length;
+  let t = obj;
+  let x;
+  for (; i < length; ++i) {
+    x = t[keys[i]];
+    t = t[keys[i]] = i === length - 1 ? val : x != null ? x : !!~keys[i + 1].indexOf(".") || !(+keys[i + 1] > -1) ? {} : [];
+  }
+};
+var setByType = (obj, transforms) => {
+  for (const key of Object.keys(transforms)) {
+    const transform = transforms[key];
+    if (transform.shouldTransform) {
+      obj[key] = Array.prototype.concat.call([], obj[key]);
+      if (typeof transform.transformFunction === "function") {
+        obj[key] = obj[key].map(transform.transformFunction);
+      }
+    }
+  }
+};
+var getFileName = (input) => {
+  const m = /([^\\\/]+)$/.exec(input);
+  return m ? m[1] : "";
+};
+var camelcaseOptionName = (name) => {
+  return name.split(".").map((v, i) => {
+    return i === 0 ? camelcase(v) : v;
+  }).join(".");
+};
+var CACError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = this.constructor.name;
+    if (typeof Error.captureStackTrace === "function") {
+      Error.captureStackTrace(this, this.constructor);
+    } else {
+      this.stack = new Error(message).stack;
+    }
+  }
+};
+var Option = class {
+  constructor(rawName, description, config) {
+    this.rawName = rawName;
+    this.description = description;
+    this.config = Object.assign({}, config);
+    rawName = rawName.replace(/\.\*/g, "");
+    this.negated = false;
+    this.names = removeBrackets(rawName).split(",").map((v) => {
+      let name = v.trim().replace(/^-{1,2}/, "");
+      if (name.startsWith("no-")) {
+        this.negated = true;
+        name = name.replace(/^no-/, "");
+      }
+      return camelcaseOptionName(name);
+    }).sort((a, b) => a.length > b.length ? 1 : -1);
+    this.name = this.names[this.names.length - 1];
+    if (this.negated && this.config.default == null) {
+      this.config.default = true;
+    }
+    if (rawName.includes("<")) {
+      this.required = true;
+    } else if (rawName.includes("[")) {
+      this.required = false;
+    } else {
+      this.isBoolean = true;
+    }
+  }
+};
+var processArgs = process.argv;
+var platformInfo = `${process.platform}-${process.arch} node-${process.version}`;
+var Command = class {
+  constructor(rawName, description, config = {}, cli2) {
+    this.rawName = rawName;
+    this.description = description;
+    this.config = config;
+    this.cli = cli2;
+    this.options = [];
+    this.aliasNames = [];
+    this.name = removeBrackets(rawName);
+    this.args = findAllBrackets(rawName);
+    this.examples = [];
+  }
+  usage(text) {
+    this.usageText = text;
+    return this;
+  }
+  allowUnknownOptions() {
+    this.config.allowUnknownOptions = true;
+    return this;
+  }
+  ignoreOptionDefaultValue() {
+    this.config.ignoreOptionDefaultValue = true;
+    return this;
+  }
+  version(version, customFlags = "-v, --version") {
+    this.versionNumber = version;
+    this.option(customFlags, "Display version number");
+    return this;
+  }
+  example(example) {
+    this.examples.push(example);
+    return this;
+  }
+  option(rawName, description, config) {
+    const option = new Option(rawName, description, config);
+    this.options.push(option);
+    return this;
+  }
+  alias(name) {
+    this.aliasNames.push(name);
+    return this;
+  }
+  action(callback) {
+    this.commandAction = callback;
+    return this;
+  }
+  isMatched(name) {
+    return this.name === name || this.aliasNames.includes(name);
+  }
+  get isDefaultCommand() {
+    return this.name === "" || this.aliasNames.includes("!");
+  }
+  get isGlobalCommand() {
+    return this instanceof GlobalCommand;
+  }
+  hasOption(name) {
+    name = name.split(".")[0];
+    return this.options.find((option) => {
+      return option.names.includes(name);
+    });
+  }
+  outputHelp() {
+    const { name, commands } = this.cli;
+    const {
+      versionNumber,
+      options: globalOptions,
+      helpCallback
+    } = this.cli.globalCommand;
+    let sections = [
+      {
+        body: `${name}${versionNumber ? `/${versionNumber}` : ""}`
+      }
+    ];
+    sections.push({
+      title: "Usage",
+      body: `  $ ${name} ${this.usageText || this.rawName}`
+    });
+    const showCommands = (this.isGlobalCommand || this.isDefaultCommand) && commands.length > 0;
+    if (showCommands) {
+      const longestCommandName = findLongest(commands.map((command) => command.rawName));
+      sections.push({
+        title: "Commands",
+        body: commands.map((command) => {
+          return `  ${padRight(command.rawName, longestCommandName.length)}  ${command.description}`;
+        }).join("\n")
+      });
+      sections.push({
+        title: `For more info, run any command with the \`--help\` flag`,
+        body: commands.map((command) => `  $ ${name}${command.name === "" ? "" : ` ${command.name}`} --help`).join("\n")
+      });
+    }
+    let options = this.isGlobalCommand ? globalOptions : [...this.options, ...globalOptions || []];
+    if (!this.isGlobalCommand && !this.isDefaultCommand) {
+      options = options.filter((option) => option.name !== "version");
+    }
+    if (options.length > 0) {
+      const longestOptionName = findLongest(options.map((option) => option.rawName));
+      sections.push({
+        title: "Options",
+        body: options.map((option) => {
+          return `  ${padRight(option.rawName, longestOptionName.length)}  ${option.description} ${option.config.default === void 0 ? "" : `(default: ${option.config.default})`}`;
+        }).join("\n")
+      });
+    }
+    if (this.examples.length > 0) {
+      sections.push({
+        title: "Examples",
+        body: this.examples.map((example) => {
+          if (typeof example === "function") {
+            return example(name);
+          }
+          return example;
+        }).join("\n")
+      });
+    }
+    if (helpCallback) {
+      sections = helpCallback(sections) || sections;
+    }
+    console.log(sections.map((section) => {
+      return section.title ? `${section.title}:
+${section.body}` : section.body;
+    }).join("\n\n"));
+  }
+  outputVersion() {
+    const { name } = this.cli;
+    const { versionNumber } = this.cli.globalCommand;
+    if (versionNumber) {
+      console.log(`${name}/${versionNumber} ${platformInfo}`);
+    }
+  }
+  checkRequiredArgs() {
+    const minimalArgsCount = this.args.filter((arg) => arg.required).length;
+    if (this.cli.args.length < minimalArgsCount) {
+      throw new CACError(`missing required args for command \`${this.rawName}\``);
+    }
+  }
+  checkUnknownOptions() {
+    const { options, globalCommand } = this.cli;
+    if (!this.config.allowUnknownOptions) {
+      for (const name of Object.keys(options)) {
+        if (name !== "--" && !this.hasOption(name) && !globalCommand.hasOption(name)) {
+          throw new CACError(`Unknown option \`${name.length > 1 ? `--${name}` : `-${name}`}\``);
+        }
+      }
+    }
+  }
+  checkOptionValue() {
+    const { options: parsedOptions, globalCommand } = this.cli;
+    const options = [...globalCommand.options, ...this.options];
+    for (const option of options) {
+      const value = parsedOptions[option.name.split(".")[0]];
+      if (option.required) {
+        const hasNegated = options.some((o) => o.negated && o.names.includes(option.name));
+        if (value === true || value === false && !hasNegated) {
+          throw new CACError(`option \`${option.rawName}\` value is missing`);
+        }
+      }
+    }
+  }
+};
+var GlobalCommand = class extends Command {
+  constructor(cli2) {
+    super("@@global@@", "", {}, cli2);
+  }
+};
+var __assign = Object.assign;
+var CAC = class extends EventEmitter {
+  constructor(name = "") {
+    super();
+    this.name = name;
+    this.commands = [];
+    this.rawArgs = [];
+    this.args = [];
+    this.options = {};
+    this.globalCommand = new GlobalCommand(this);
+    this.globalCommand.usage("<command> [options]");
+  }
+  usage(text) {
+    this.globalCommand.usage(text);
+    return this;
+  }
+  command(rawName, description, config) {
+    const command = new Command(rawName, description || "", config, this);
+    command.globalCommand = this.globalCommand;
+    this.commands.push(command);
+    return command;
+  }
+  option(rawName, description, config) {
+    this.globalCommand.option(rawName, description, config);
+    return this;
+  }
+  help(callback) {
+    this.globalCommand.option("-h, --help", "Display this message");
+    this.globalCommand.helpCallback = callback;
+    this.showHelpOnExit = true;
+    return this;
+  }
+  version(version, customFlags = "-v, --version") {
+    this.globalCommand.version(version, customFlags);
+    this.showVersionOnExit = true;
+    return this;
+  }
+  example(example) {
+    this.globalCommand.example(example);
+    return this;
+  }
+  outputHelp() {
+    if (this.matchedCommand) {
+      this.matchedCommand.outputHelp();
+    } else {
+      this.globalCommand.outputHelp();
+    }
+  }
+  outputVersion() {
+    this.globalCommand.outputVersion();
+  }
+  setParsedInfo({ args, options }, matchedCommand, matchedCommandName) {
+    this.args = args;
+    this.options = options;
+    if (matchedCommand) {
+      this.matchedCommand = matchedCommand;
+    }
+    if (matchedCommandName) {
+      this.matchedCommandName = matchedCommandName;
+    }
+    return this;
+  }
+  unsetMatchedCommand() {
+    this.matchedCommand = void 0;
+    this.matchedCommandName = void 0;
+  }
+  parse(argv = processArgs, {
+    run = true
+  } = {}) {
+    this.rawArgs = argv;
+    if (!this.name) {
+      this.name = argv[1] ? getFileName(argv[1]) : "cli";
+    }
+    let shouldParse = true;
+    for (const command of this.commands) {
+      const parsed = this.mri(argv.slice(2), command);
+      const commandName = parsed.args[0];
+      if (command.isMatched(commandName)) {
+        shouldParse = false;
+        const parsedInfo = __assign(__assign({}, parsed), {
+          args: parsed.args.slice(1)
+        });
+        this.setParsedInfo(parsedInfo, command, commandName);
+        this.emit(`command:${commandName}`, command);
+      }
+    }
+    if (shouldParse) {
+      for (const command of this.commands) {
+        if (command.name === "") {
+          shouldParse = false;
+          const parsed = this.mri(argv.slice(2), command);
+          this.setParsedInfo(parsed, command);
+          this.emit(`command:!`, command);
+        }
+      }
+    }
+    if (shouldParse) {
+      const parsed = this.mri(argv.slice(2));
+      this.setParsedInfo(parsed);
+    }
+    if (this.options.help && this.showHelpOnExit) {
+      this.outputHelp();
+      run = false;
+      this.unsetMatchedCommand();
+    }
+    if (this.options.version && this.showVersionOnExit && this.matchedCommandName == null) {
+      this.outputVersion();
+      run = false;
+      this.unsetMatchedCommand();
+    }
+    const parsedArgv = { args: this.args, options: this.options };
+    if (run) {
+      this.runMatchedCommand();
+    }
+    if (!this.matchedCommand && this.args[0]) {
+      this.emit("command:*");
+    }
+    return parsedArgv;
+  }
+  mri(argv, command) {
+    const cliOptions = [
+      ...this.globalCommand.options,
+      ...command ? command.options : []
+    ];
+    const mriOptions = getMriOptions(cliOptions);
+    let argsAfterDoubleDashes = [];
+    const doubleDashesIndex = argv.indexOf("--");
+    if (doubleDashesIndex > -1) {
+      argsAfterDoubleDashes = argv.slice(doubleDashesIndex + 1);
+      argv = argv.slice(0, doubleDashesIndex);
+    }
+    let parsed = mri2(argv, mriOptions);
+    parsed = Object.keys(parsed).reduce((res, name) => {
+      return __assign(__assign({}, res), {
+        [camelcaseOptionName(name)]: parsed[name]
+      });
+    }, { _: [] });
+    const args = parsed._;
+    const options = {
+      "--": argsAfterDoubleDashes
+    };
+    const ignoreDefault = command && command.config.ignoreOptionDefaultValue ? command.config.ignoreOptionDefaultValue : this.globalCommand.config.ignoreOptionDefaultValue;
+    let transforms = /* @__PURE__ */ Object.create(null);
+    for (const cliOption of cliOptions) {
+      if (!ignoreDefault && cliOption.config.default !== void 0) {
+        for (const name of cliOption.names) {
+          options[name] = cliOption.config.default;
+        }
+      }
+      if (Array.isArray(cliOption.config.type)) {
+        if (transforms[cliOption.name] === void 0) {
+          transforms[cliOption.name] = /* @__PURE__ */ Object.create(null);
+          transforms[cliOption.name]["shouldTransform"] = true;
+          transforms[cliOption.name]["transformFunction"] = cliOption.config.type[0];
+        }
+      }
+    }
+    for (const key of Object.keys(parsed)) {
+      if (key !== "_") {
+        const keys = key.split(".");
+        setDotProp(options, keys, parsed[key]);
+        setByType(options, transforms);
+      }
+    }
+    return {
+      args,
+      options
+    };
+  }
+  runMatchedCommand() {
+    const { args, options, matchedCommand: command } = this;
+    if (!command || !command.commandAction)
+      return;
+    command.checkUnknownOptions();
+    command.checkOptionValue();
+    command.checkRequiredArgs();
+    const actionArgs = [];
+    command.args.forEach((arg, index) => {
+      if (arg.variadic) {
+        actionArgs.push(args.slice(index));
+      } else {
+        actionArgs.push(args[index]);
+      }
+    });
+    actionArgs.push(options);
+    return command.commandAction.apply(this, actionArgs);
+  }
+};
+var cac = (name = "") => new CAC(name);
+var dist_default = cac;
+
+// src/index.ts
+var import_picocolors7 = __toESM(require_picocolors());
+import figlet from "figlet";
+
+// ../../node_modules/.pnpm/gradient-string@3.0.0/node_modules/gradient-string/dist/index.js
+init_esm_shims();
+var import_tinygradient = __toESM(require_tinygradient(), 1);
+var gradient = (...colors) => {
+  let gradient2;
+  let options;
+  if (colors.length === 0) {
+    throw new Error("Missing gradient colors");
+  }
+  if (!Array.isArray(colors[0])) {
+    if (colors.length === 1) {
+      throw new Error(`Expected an array of colors, received ${JSON.stringify(colors[0])}`);
+    }
+    gradient2 = (0, import_tinygradient.default)(...colors);
+  } else {
+    gradient2 = (0, import_tinygradient.default)(colors[0]);
+    options = validateOptions(colors[1]);
+  }
+  const fn = (str, deprecatedOptions) => {
+    return applyGradient(str ? str.toString() : "", gradient2, deprecatedOptions ?? options);
+  };
+  fn.multiline = (str, deprecatedOptions) => multiline(str ? str.toString() : "", gradient2, deprecatedOptions ?? options);
+  return fn;
+};
+var getColors = (gradient2, options, count) => {
+  return options.interpolation?.toLowerCase() === "hsv" ? gradient2.hsv(count, options.hsvSpin?.toLowerCase() || false) : gradient2.rgb(count);
+};
+function applyGradient(str, gradient2, opts) {
+  const options = validateOptions(opts);
+  const colorsCount = Math.max(str.replace(/\s/g, "").length, gradient2.stops.length);
+  const colors = getColors(gradient2, options, colorsCount);
+  let result = "";
+  for (const s of str) {
+    result += s.match(/\s/g) ? s : source_default.hex(colors.shift()?.toHex() || "#000")(s);
+  }
+  return result;
+}
+function multiline(str, gradient2, opts) {
+  const options = validateOptions(opts);
+  const lines = str.split("\n");
+  const maxLength = Math.max(...lines.map((l) => l.length), gradient2.stops.length);
+  const colors = getColors(gradient2, options, maxLength);
+  const results = [];
+  for (const line of lines) {
+    const lineColors = colors.slice(0);
+    let lineResult = "";
+    for (const l of line) {
+      lineResult += source_default.hex(lineColors.shift()?.toHex() || "#000")(l);
+    }
+    results.push(lineResult);
+  }
+  return results.join("\n");
+}
+function validateOptions(opts) {
+  const options = { interpolation: "rgb", hsvSpin: "short", ...opts };
+  if (opts !== void 0 && typeof opts !== "object") {
+    throw new TypeError(`Expected \`options\` to be an \`object\`, got \`${typeof opts}\``);
+  }
+  if (typeof options.interpolation !== "string") {
+    throw new TypeError(`Expected \`options.interpolation\` to be \`rgb\` or \`hsv\`, got \`${typeof options.interpolation}\``);
+  }
+  if (options.interpolation.toLowerCase() === "hsv" && typeof options.hsvSpin !== "string") {
+    throw new TypeError(`Expected \`options.hsvSpin\` to be a \`short\` or \`long\`, got \`${typeof options.hsvSpin}\``);
+  }
+  return options;
+}
+var aliases = {
+  atlas: { colors: ["#feac5e", "#c779d0", "#4bc0c8"], options: {} },
+  cristal: { colors: ["#bdfff3", "#4ac29a"], options: {} },
+  teen: { colors: ["#77a1d3", "#79cbca", "#e684ae"], options: {} },
+  mind: { colors: ["#473b7b", "#3584a7", "#30d2be"], options: {} },
+  morning: { colors: ["#ff5f6d", "#ffc371"], options: { interpolation: "hsv" } },
+  vice: { colors: ["#5ee7df", "#b490ca"], options: { interpolation: "hsv" } },
+  passion: { colors: ["#f43b47", "#453a94"], options: {} },
+  fruit: { colors: ["#ff4e50", "#f9d423"], options: {} },
+  instagram: { colors: ["#833ab4", "#fd1d1d", "#fcb045"], options: {} },
+  retro: {
+    colors: ["#3f51b1", "#5a55ae", "#7b5fac", "#8f6aae", "#a86aa4", "#cc6b8e", "#f18271", "#f3a469", "#f7c978"],
+    options: {}
+  },
+  summer: { colors: ["#fdbb2d", "#22c1c3"], options: {} },
+  rainbow: { colors: ["#ff0000", "#ff0100"], options: { interpolation: "hsv", hsvSpin: "long" } },
+  pastel: { colors: ["#74ebd5", "#74ecd5"], options: { interpolation: "hsv", hsvSpin: "long" } }
+};
+function gradientAlias(alias) {
+  const result = (str) => gradient(...alias.colors)(str, alias.options);
+  result.multiline = (str = "") => gradient(...alias.colors).multiline(str, alias.options);
+  return result;
+}
+var dist_default2 = gradient;
+var atlas = gradientAlias(aliases.atlas);
+var cristal = gradientAlias(aliases.cristal);
+var teen = gradientAlias(aliases.teen);
+var mind = gradientAlias(aliases.mind);
+var morning = gradientAlias(aliases.morning);
+var vice = gradientAlias(aliases.vice);
+var passion = gradientAlias(aliases.passion);
+var fruit = gradientAlias(aliases.fruit);
+var instagram = gradientAlias(aliases.instagram);
+var retro = gradientAlias(aliases.retro);
+var summer = gradientAlias(aliases.summer);
+var rainbow = gradientAlias(aliases.rainbow);
+var pastel = gradientAlias(aliases.pastel);
+gradient.atlas = atlas;
+gradient.cristal = cristal;
+gradient.teen = teen;
+gradient.mind = mind;
+gradient.morning = morning;
+gradient.vice = vice;
+gradient.passion = passion;
+gradient.fruit = fruit;
+gradient.instagram = instagram;
+gradient.retro = retro;
+gradient.summer = summer;
+gradient.rainbow = rainbow;
+gradient.pastel = pastel;
+
+// src/commands/dev.ts
+init_esm_shims();
+async function dev(options = {}) {
+  const cwd = process.cwd();
+  await CoreKit.startDev(cwd, options);
+}
+
+// src/commands/add.ts
+init_esm_shims();
+var import_fs_extra = __toESM(require_lib());
+var import_picocolors = __toESM(require_picocolors());
+var import_prompts = __toESM(require_prompts());
+var import_handlebars = __toESM(require_lib2());
+import path from "path";
+async function add(options) {
+  let { name, type, displayName, description } = options;
+  const cwd = process.cwd();
+  const pkgPath = path.join(cwd, "package.json");
+  if (!import_fs_extra.default.existsSync(pkgPath)) {
+    logger.error("\u672A\u627E\u5230 package.json\u3002\u8BF7\u5728 ChatBI-V \u9879\u76EE\u6839\u76EE\u5F55\u4E0B\u8FD0\u884C\u6B64\u547D\u4EE4\u3002");
+    return;
+  }
+  const pkg = await import_fs_extra.default.readJson(pkgPath);
+  const isMonorepo = pkg.workspaces && (pkg.workspaces.includes("plugins/*") || pkg.workspaces.packages?.includes("plugins/*"));
+  if (!isMonorepo) {
+    logger.error("\u5F53\u524D\u4E0D\u662F Monorepo \u9879\u76EE\uFF0C\u65E0\u6CD5\u6DFB\u52A0\u63D2\u4EF6 (\u8BF7\u5728\u5305\u542B plugins/ \u5DE5\u4F5C\u7A7A\u95F4\u7684\u9879\u76EE\u4E2D\u8FD0\u884C)");
+    process.exit(1);
+  }
+  const response = await (0, import_prompts.default)([
+    {
+      type: name ? null : "text",
+      name: "pluginName",
+      message: "\u8BF7\u8F93\u5165\u63D2\u4EF6\u540D\u79F0 (ID, \u5EFA\u8BAE\u5C0F\u5199\u548C\u4E2D\u5212\u7EBF):",
+      initial: "my-custom-plugin",
+      validate: (value) => /^[a-z0-9-]+$/.test(value) || "\u540D\u79F0\u53EA\u80FD\u5305\u542B\u5C0F\u5199\u5B57\u6BCD\u3001\u6570\u5B57\u548C\u4E2D\u5212\u7EBF"
+    },
+    {
+      type: displayName ? null : "text",
+      name: "pluginDisplayName",
+      message: "\u8BF7\u8F93\u5165\u63D2\u4EF6\u663E\u793A\u540D\u79F0 (\u4E2D\u6587):",
+      initial: (prev) => prev || name
+    },
+    {
+      type: description ? null : "text",
+      name: "pluginDescription",
+      message: "\u8BF7\u8F93\u5165\u63D2\u4EF6\u63CF\u8FF0:",
+      initial: "\u4E00\u4E2A\u7B80\u5355\u7684 ChatBI-V \u63D2\u4EF6"
+    },
+    {
+      type: type ? null : "select",
+      name: "pluginType",
+      message: "\u8BF7\u9009\u62E9\u63D2\u4EF6\u7C7B\u578B:",
+      choices: [
+        { title: "Business (\u4E1A\u52A1\u63D2\u4EF6)", value: "business", description: "\u5305\u542B UI \u754C\u9762\u548C\u4E1A\u52A1\u903B\u8F91" },
+        { title: "System (\u7CFB\u7EDF\u63D2\u4EF6)", value: "system", description: "\u4FA7\u91CD\u4E8E\u5E95\u5C42\u80FD\u529B\u548C\u7CFB\u7EDF\u6269\u5C55" }
+      ],
+      initial: 0
+    }
+  ], {
+    onCancel: () => {
+      logger.warn("\u5DF2\u53D6\u6D88\u6DFB\u52A0\u63D2\u4EF6");
+      process.exit(0);
+    }
+  });
+  name = name || response.pluginName;
+  type = type || response.pluginType;
+  displayName = displayName || response.pluginDisplayName || name;
+  description = description || response.pluginDescription || "";
+  let cleanName = name;
+  if (cleanName.endsWith("-plugin")) {
+    cleanName = cleanName.replace(/-plugin$/, "");
+  }
+  const folderName = cleanName.startsWith("plugin-") ? cleanName : `plugin-${cleanName}`;
+  const pluginDir = path.resolve(cwd, "plugins", folderName);
+  if (import_fs_extra.default.existsSync(pluginDir)) {
+    logger.error(`\u63D2\u4EF6\u76EE\u5F55 ${folderName} \u5DF2\u5B58\u5728\u3002`);
+    return;
+  }
+  const spinner = createSpinner(`\u6B63\u5728\u6DFB\u52A0\u65B0\u63D2\u4EF6: ${import_picocolors.default.bold(name)}...`).start();
+  const myCliRoot = await getCliRoot();
+  const templateDir = path.join(myCliRoot, "templates/plugin");
+  if (!import_fs_extra.default.existsSync(templateDir)) {
+    spinner.fail("\u627E\u4E0D\u5230\u63D2\u4EF6\u6A21\u677F");
+    throw new Error(`\u627E\u4E0D\u5230\u63D2\u4EF6\u6A21\u677F: ${templateDir}`);
+  }
+  const targetDir = pluginDir;
+  spinner.text = "\u6B63\u5728\u52A0\u8F7D\u914D\u7F6E...";
+  const config = await ConfigManager.loadConfig(cwd);
+  const coreSource = config.coreSource || "local";
+  let corePath = "file:../../.chatbi/core";
+  if (coreSource === "npm") {
+    if (!config.coreVersion) {
+      const cliPkg = await import_fs_extra.default.readJson(path.join(myCliRoot, "package.json"));
+      corePath = cliPkg.version;
+    } else {
+      corePath = config.coreVersion;
+    }
+  }
+  const data = {
+    // 兼容旧模板
+    name: `@chatbi-v/${folderName}`,
+    pluginId: cleanName,
+    pluginType: type,
+    className: cleanName.split("-").map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join(""),
+    isBusiness: type === "business",
+    corePath,
+    // 新模板变量
+    pluginName: cleanName,
+    pluginPackageName: `@chatbi-v/${folderName}`,
+    pluginVersion: "0.1.0",
+    pluginDisplayName: displayName,
+    pluginDescription: description,
+    pluginClassName: cleanName.split("-").map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join(""),
+    pluginPath: folderName,
+    pluginFolderName: folderName,
+    // Fix: 注入 tsconfigPath，确保 tsconfig.json 能正确 extend
+    tsconfigPath: "../../.chatbi/tsconfig.json"
+  };
+  const renderFile = async (src, dest) => {
+    const content = await import_fs_extra.default.readFile(src, "utf-8");
+    let result = content;
+    const hasHandlebarsVars = content.includes("{{");
+    if (hasHandlebarsVars) {
+      try {
+        const safeContent = content.replace(/\{\{(?!\s*([#/]?(?:if|else|each|with|unless|name|version|projectName|projectTitle|projectVersion|cliVersion|tsconfigPath|theme|isNebula|isGlass|isBusiness|isApp|isShell|pluginName|pluginPackageName|pluginVersion|pluginDisplayName|pluginDescription|pluginClassName|pluginPath|pluginFolderName|pluginType|pluginId|className))\b)/g, "\\{{");
+        const templateFn = import_handlebars.default.compile(safeContent);
+        result = templateFn(data);
+      } catch (e) {
+        result = content;
+        for (const [key, val] of Object.entries(data)) {
+          const regex = new RegExp(`\\{\\{\\s*${key}\\s*\\}\\}`, "g");
+          result = result.replace(regex, String(val));
+        }
+      }
+    }
+    await import_fs_extra.default.outputFile(dest.replace(".hbs", ""), result);
+  };
+  const processTemplates = async (currentSrc, currentDest) => {
+    const files = await import_fs_extra.default.readdir(currentSrc);
+    for (const file of files) {
+      const srcPath = path.join(currentSrc, file);
+      const destPath = path.join(currentDest, file);
+      const stats = await import_fs_extra.default.stat(srcPath);
+      if (stats.isDirectory()) {
+        await import_fs_extra.default.ensureDir(destPath);
+        await processTemplates(srcPath, destPath);
+      } else if (file.endsWith(".hbs")) {
+        await renderFile(srcPath, destPath);
+      } else {
+        await import_fs_extra.default.copy(srcPath, destPath);
+      }
+    }
+  };
+  spinner.text = "\u6B63\u5728\u751F\u6210\u63D2\u4EF6\u6587\u4EF6...";
+  await processTemplates(templateDir, targetDir);
+  spinner.succeed(`\u63D2\u4EF6 ${import_picocolors.default.bold(name)} \u6DFB\u52A0\u6210\u529F\uFF01`);
+  printBox(
+    `${import_picocolors.default.green(import_picocolors.default.bold("\u2728 \u63D2\u4EF6\u521B\u5EFA\u6210\u529F!"))}
+
+${import_picocolors.default.white("\u9879\u76EE\u8DEF\u5F84: ")} ${import_picocolors.default.cyan(`plugins/${folderName}`)}
+${import_picocolors.default.white("\u63D2\u4EF6 ID:   ")} ${import_picocolors.default.cyan(cleanName)}
+${import_picocolors.default.white("\u63D2\u4EF6\u7C7B\u578B: ")} ${import_picocolors.default.cyan(type)}
+
+${import_picocolors.default.white("\u63A5\u4E0B\u6765\u4F60\u53EF\u4EE5:")}
+${import_picocolors.default.cyan("  pnpm dev")}  \u542F\u52A8\u5F00\u53D1\u73AF\u5883\u67E5\u770B\u6548\u679C`,
+    "Plugin Created"
+  );
+}
+
+// src/commands/gl.ts
+init_esm_shims();
+var import_fs_extra2 = __toESM(require_lib());
+var import_picocolors2 = __toESM(require_picocolors());
+var import_prompts2 = __toESM(require_prompts());
+import path2 from "path";
+async function gl(options) {
+  const { type: initialType, prompt: initialPrompt } = options;
+  const cwd = process.cwd();
+  const pkgPath = path2.join(cwd, "package.json");
+  if (!import_fs_extra2.default.existsSync(pkgPath)) {
+    logger.error("\u672A\u627E\u5230 package.json\u3002\u8BF7\u5728 ChatBI-V \u9879\u76EE\u6839\u76EE\u5F55\u4E0B\u8FD0\u884C\u6B64\u547D\u4EE4\u3002");
+    return;
+  }
+  const response = await (0, import_prompts2.default)([
+    {
+      type: initialType ? null : "select",
+      name: "genType",
+      message: "\u8BF7\u9009\u62E9 AI \u811A\u624B\u67B6\u6307\u4EE4:",
+      choices: [
+        { title: "\u{1F916} smart", value: "smart", description: "\u667A\u80FD\u51B3\u7B56 (\u6839\u636E\u9700\u6C42\u81EA\u52A8\u9009\u62E9\u5DE5\u5177)" },
+        { title: "\u{1F50C} plugin", value: "plugin", description: "\u751F\u6210\u65B0\u63D2\u4EF6" },
+        { title: "\u{1F9E9} component", value: "component", description: "\u751F\u6210\u4E1A\u52A1\u7EC4\u4EF6" },
+        { title: "\u{1F4E1} api", value: "api", description: "\u751F\u6210 API \u5B9A\u4E49\u4E0E\u8BF7\u6C42\u51FD\u6570" },
+        { title: "\u{1F3AD} mock", value: "mock", description: "\u751F\u6210 Mock \u6D4B\u8BD5\u6570\u636E" },
+        { title: "\u{1F6E0}\uFE0F  util", value: "util", description: "\u751F\u6210\u5DE5\u5177\u51FD\u6570" },
+        { title: "\u{1F4C4} doc", value: "doc", description: "\u751F\u6210\u9879\u76EE\u6587\u6863" },
+        { title: "\u2728 chat", value: "chat", description: "\u81EA\u7531\u5BF9\u8BDD" }
+      ],
+      initial: 0
+    },
+    {
+      type: (prev, values) => initialPrompt || values.genType === "chat" ? null : "text",
+      name: "userPrompt",
+      message: "\u8BF7\u8F93\u5165\u8BE6\u7EC6\u9700\u6C42\u63CF\u8FF0:",
+      initial: initialPrompt || ""
+    }
+  ], {
+    onCancel: () => {
+      logger.warn("\u5DF2\u53D6\u6D88 AI \u751F\u6210");
+      process.exit(0);
+    }
+  });
+  const genType = initialType || response.genType;
+  const userPrompt = initialPrompt || response.userPrompt;
+  if (!userPrompt && genType !== "chat") {
+    logger.error("\u9700\u6C42\u63CF\u8FF0\u4E0D\u80FD\u4E3A\u7A7A\u3002");
+    return;
+  }
+  logger.info(`\u6B63\u5728\u547C\u53EB AI \u5F15\u64CE [\u6A21\u5F0F: ${import_picocolors2.default.bold(genType)}]...`);
+  const toolsContext = `
+[Available Tools & Capabilities]
+- Tool: plugin -> For creating new feature modules. Requires: name, type (business|system).
+- Tool: component -> For UI elements. Tech: AntD5, Tailwind.
+- Tool: api -> For network requests. Structure: src/api/[name].ts, uses shared request util, defines TS interfaces.
+- Tool: mock -> For dev data. Structure: mock/[name].ts, follows Mock.js or MSW format.
+- Tool: util -> For pure functions. Structure: src/utils/[name].ts, requires unit tests.
+- Tool: doc -> For documentation. Format: Markdown, structure: docs/[type]/[name].md.
+
+[Tool Functions Implementation Details]
+- API Function: Should include request method, URL, params/data types, and response type. Use '@chatbi-v/core/request'.
+- Mock Function: Should provide realistic data based on API definition.
+- Plugin Function: Should follow the Micro-Kernel architecture, registering to 'pluginManager'.
+
+[Requirement Slots / Missing Info]
+If the user's request is ambiguous or missing key information, you MUST output: "SLOT_REQUIRED: [Field Name] | [Question to User]".
+`.trim();
+  const templatesContext = `
+[Project Templates Structure]
+- Plugin: class extends Plugin, metadata: { id, name, version, type, routes, extensions }.
+- API: export const fetchData = (params: T) => request.get<R>('/url', { params }).
+- Mock: export default { 'GET /api/test': { code: 200, data: {} } }.
+- UI: React 18, Ant Design 5, Tailwind CSS 3.
+`.trim();
+  const systemContext = `[Context: ChatBI-V System | Dir: ${cwd} | Tech: React18, AntD5, Tailwind, Micro-Kernel]
+${toolsContext}
+${templatesContext}
+
+[Decision Logic]
+If genType is 'smart', you must first decide which tool is most appropriate.
+If the requirement is clear, proceed with generation.
+If not, use the SLOT_REQUIRED format.`.trim();
+  const finalPrompt = userPrompt ? `${systemContext}
+
+[User Request]: ${userPrompt}` : systemContext;
+  const geminiCmd = genType === "smart" ? "chat" : genType;
+  const spinner = createSpinner("AI \u5F15\u64CE\u6B63\u5728\u601D\u8003\u4E2D... (\u53EF\u80FD\u9700\u8981\u51E0\u5341\u79D2\uFF0C\u8BF7\u8010\u5FC3\u7B49\u5F85)");
+  let currentPrompt = finalPrompt;
+  let retry = true;
+  while (retry) {
+    spinner.start();
+    try {
+      const { stdout } = await execa("gemini", [geminiCmd, currentPrompt], {
+        stdio: "pipe"
+      });
+      spinner.stop();
+      if (stdout.includes("SLOT_REQUIRED:")) {
+        const slots = [];
+        const lines = stdout.split("\n");
+        for (const line of lines) {
+          if (line.includes("SLOT_REQUIRED:")) {
+            const match = line.match(/SLOT_REQUIRED:\s*([^|]+)\|\s*(.+)/);
+            if (match) {
+              slots.push({
+                type: "text",
+                name: match[1].trim(),
+                message: match[2].trim()
+              });
+            }
+          }
+        }
+        if (slots.length > 0) {
+          logger.info(import_picocolors2.default.yellow("\n\u{1F4DD} AI \u9700\u8981\u66F4\u591A\u4FE1\u606F\u4EE5\u7EE7\u7EED:"));
+          const answers = await (0, import_prompts2.default)(slots, {
+            onCancel: () => process.exit(0)
+          });
+          const answerContext = Object.entries(answers).map(([k, v]) => `[${k}]: ${v}`).join("\n");
+          currentPrompt += `
+
+[User Answers]:
+${answerContext}
+
+Please proceed with generation based on these answers.`;
+          logger.info("\u6B63\u5728\u6839\u636E\u60A8\u7684\u53CD\u9988\u91CD\u65B0\u547C\u53EB AI...");
+          continue;
+        }
+      }
+      console.log("\n" + stdout);
+      retry = false;
+      logger.success(`AI \u547D\u4EE4 [gemini ${geminiCmd}] \u6267\u884C\u5B8C\u6BD5!`);
+    } catch (error) {
+      spinner.stop();
+      if (error.code === "ENOENT") {
+        logger.error("\u672A\u5728\u7CFB\u7EDF\u4E2D\u627E\u5230 `gemini-cli` \u547D\u4EE4\u3002");
+        logger.info(import_picocolors2.default.yellow("\u8BF7\u786E\u4FDD\u5DF2\u5B89\u88C5 gemini-cli \u5E76\u5C06\u5176\u6DFB\u52A0\u5230\u7CFB\u7EDF PATH \u4E2D\u3002"));
+      } else {
+        logger.error(`AI \u751F\u6210\u8FC7\u7A0B\u4E2D\u51FA\u9519: ${error.message}`);
+      }
+      throw error;
+    }
+  }
+}
+
+// src/commands/doctor.ts
+init_esm_shims();
+var import_fs_extra3 = __toESM(require_lib());
+var import_picocolors3 = __toESM(require_picocolors());
+import path3 from "path";
+import glob from "fast-glob";
+async function doctor(options = {}) {
+  logger.info("\u6B63\u5728\u8BCA\u65AD\u9879\u76EE\u5065\u5EB7\u72B6\u51B5...\n");
+  const cwd = process.cwd();
+  let hasIssues = false;
+  const issues = [];
+  logger.info(import_picocolors3.default.bold("Step 1: \u68C0\u67E5\u57FA\u7840\u73AF\u5883..."));
+  const nodeVersion = process.version;
+  if (parseInt(nodeVersion.slice(1).split(".")[0]) < 18) {
+    logger.error(`Node.js \u7248\u672C\u592A\u4F4E: ${nodeVersion} (\u8981\u6C42 >=18)`);
+    hasIssues = true;
+    issues.push(`Node.js \u7248\u672C\u8FC7\u4F4E (${nodeVersion})`);
+  } else {
+    logger.success(`Node.js \u7248\u672C: ${nodeVersion}`);
+  }
+  try {
+    const { execa: execa2 } = await import("./execa-METROS6Z.mjs");
+    const { stdout: pnpmVer } = await execa2("pnpm", ["-v"]);
+    logger.success(`pnpm \u7248\u672C: ${pnpmVer}`);
+  } catch (e) {
+    logger.warn("\u672A\u68C0\u6D4B\u5230 pnpm\uFF0C\u5EFA\u8BAE\u5B89\u88C5\u4EE5\u83B7\u5F97\u6700\u4F73\u4F53\u9A8C");
+  }
+  logger.info(import_picocolors3.default.bold("\nStep 2: \u68C0\u67E5\u5185\u6838\u6C99\u7BB1\u73AF\u5883..."));
+  const version = await CoreKit.resolveVersion(cwd);
+  const versionPath = Sandbox.getVersionPath(version);
+  if (!import_fs_extra3.default.existsSync(versionPath)) {
+    logger.error(`\u5185\u6838\u6C99\u7BB1\u7248\u672C ${version} \u5C1A\u672A\u5B89\u88C5`);
+    console.log(import_picocolors3.default.gray(`   \u5EFA\u8BAE\u8FD0\u884C 'chatbi sync' \u6216 'chatbi use ${version}' \u8FDB\u884C\u5B89\u88C5\u3002`));
+    hasIssues = true;
+    issues.push(`\u5185\u6838\u6C99\u7BB1\u672A\u5B89\u88C5 (${version})`);
+  } else {
+    logger.success(`\u5185\u6838\u6C99\u7BB1\u5C31\u7EEA (\u7248\u672C: ${version})`);
+    const sandboxNm = path3.join(versionPath, "node_modules");
+    if (!import_fs_extra3.default.existsSync(sandboxNm)) {
+      logger.warn("\u6C99\u7BB1\u4F9D\u8D56\u672A\u5B89\u88C5\uFF0C\u5C06\u5BFC\u81F4\u6784\u5EFA\u5931\u8D25");
+      hasIssues = true;
+      issues.push("\u6C99\u7BB1\u4F9D\u8D56\u7F3A\u5931");
+    }
+    const missingDeps = [];
+    for (const dep of Sandbox.CORE_PACKAGES) {
+      if (!import_fs_extra3.default.existsSync(path3.join(sandboxNm, dep))) {
+        missingDeps.push(dep);
+      }
+    }
+    if (missingDeps.length > 0) {
+    }
+  }
+  logger.info(import_picocolors3.default.bold("\nStep 3: \u68C0\u67E5\u865A\u62DF\u4F9D\u8D56\u6620\u5C04..."));
+  const chatbiDir = path3.join(cwd, ".chatbi");
+  if (!import_fs_extra3.default.existsSync(chatbiDir)) {
+    logger.warn("\u672A\u53D1\u73B0\u865A\u62DF\u4F9D\u8D56\u914D\u7F6E (.chatbi \u76EE\u5F55)");
+    hasIssues = true;
+    issues.push("\u7F3A\u5931 .chatbi \u76EE\u5F55");
+  } else {
+    const pathsJson = path3.join(chatbiDir, "tsconfig.paths.json");
+    const aliasJson = path3.join(chatbiDir, "vite.alias.json");
+    if (!import_fs_extra3.default.existsSync(pathsJson) || !import_fs_extra3.default.existsSync(aliasJson)) {
+      logger.warn("\u865A\u62DF\u4F9D\u8D56\u914D\u7F6E\u6587\u4EF6\u4E0D\u5B8C\u6574");
+      hasIssues = true;
+      issues.push("\u865A\u62DF\u4F9D\u8D56\u914D\u7F6E\u4E0D\u5B8C\u6574");
+    } else {
+      logger.success("\u865A\u62DF\u4F9D\u8D56\u914D\u7F6E\u5DF2\u751F\u6210");
+    }
+  }
+  const tsConfigPath = path3.join(cwd, "tsconfig.json");
+  if (import_fs_extra3.default.existsSync(tsConfigPath)) {
+    try {
+      const tsConfig = await import_fs_extra3.default.readJson(tsConfigPath);
+      const extendsPath = tsConfig.extends;
+      const expectedPaths = ["./.chatbi/tsconfig.paths.json", ".chatbi/tsconfig.paths.json"];
+      let hasExtend = false;
+      if (typeof extendsPath === "string") {
+        hasExtend = expectedPaths.includes(extendsPath);
+      } else if (Array.isArray(extendsPath)) {
+        hasExtend = extendsPath.some((p) => expectedPaths.includes(p));
+      }
+      if (!hasExtend) {
+        logger.warn("tsconfig.json \u672A\u7EE7\u627F\u865A\u62DF\u4F9D\u8D56\u914D\u7F6E");
+        hasIssues = true;
+        issues.push("tsconfig.json \u914D\u7F6E\u7F3A\u5931");
+      } else {
+        logger.success("tsconfig.json \u914D\u7F6E\u6B63\u5E38");
+      }
+    } catch (e) {
+      logger.error("\u89E3\u6790 tsconfig.json \u5931\u8D25");
+    }
+  }
+  const viteConfigPath = path3.join(cwd, "vite.config.ts");
+  if (import_fs_extra3.default.existsSync(viteConfigPath)) {
+    const content = await import_fs_extra3.default.readFile(viteConfigPath, "utf-8");
+    if (!content.includes("vite.alias.json")) {
+      logger.warn("vite.config.ts \u53EF\u80FD\u672A\u52A0\u8F7D\u865A\u62DF\u522B\u540D\u914D\u7F6E");
+    }
+  }
+  logger.info(import_picocolors3.default.bold("\nStep 4: \u626B\u63CF\u4EE3\u7801\u89C4\u5219..."));
+  const rules = [
+    {
+      id: "plugin-lifecycle-init",
+      description: "\u63D2\u4EF6\u751F\u547D\u5468\u671F init() \u5DF2\u53D8\u66F4\u4E3A onLoad()",
+      pattern: /async\s+init\s*\(\s*context\s*:\s*PluginContext\s*\)/g,
+      fix: (content) => content.replace(/async\s+init\s*\(\s*context\s*:\s*PluginContext\s*\)/g, "async onLoad(context: PluginContext)")
+    },
+    {
+      id: "plugin-lifecycle-destroy",
+      description: "\u63D2\u4EF6\u751F\u547D\u5468\u671F destroy() \u5DF2\u53D8\u66F4\u4E3A onUnload()",
+      pattern: /async\s+destroy\s*\(\s*\)/g,
+      fix: (content) => content.replace(/async\s+destroy\s*\(\s*\)/g, "async onUnload()")
+    }
+  ];
+  const files = await glob(["src/**/*.{ts,tsx}"], { cwd, absolute: true });
+  const codeIssues = [];
+  if (files.length > 0) {
+    const scanSpinner = createSpinner(`\u6B63\u5728\u626B\u63CF ${files.length} \u4E2A\u6587\u4EF6...`).start();
+    for (const file of files) {
+      const content = await import_fs_extra3.default.readFile(file, "utf-8");
+      for (const rule of rules) {
+        if (rule.pattern.test(content)) {
+          codeIssues.push({
+            file,
+            ruleId: rule.id,
+            description: rule.description,
+            rule
+          });
+        }
+      }
+    }
+    if (codeIssues.length > 0) {
+      scanSpinner.fail(`\u53D1\u73B0 ${codeIssues.length} \u4E2A\u4EE3\u7801\u89C4\u8303\u95EE\u9898`);
+      hasIssues = true;
+      codeIssues.forEach((issue) => {
+        const relativePath = path3.relative(cwd, issue.file);
+        issues.push(`\u4EE3\u7801\u89C4\u8303 [${issue.ruleId}]: ${relativePath}`);
+      });
+    } else {
+      scanSpinner.succeed("\u4EE3\u7801\u89C4\u8303\u68C0\u67E5\u901A\u8FC7");
+    }
+  }
+  if (!hasIssues) {
+    printBox(
+      import_picocolors3.default.green(import_picocolors3.default.bold("\u2728 \u8BCA\u65AD\u5B8C\u6210\uFF1A\u9879\u76EE\u4E00\u5207\u6B63\u5E38\uFF01")),
+      "Doctor Report"
+    );
+  } else {
+    const issueList = issues.map((i) => import_picocolors3.default.red(`\u2022 ${i}`)).join("\n");
+    printBox(
+      `${import_picocolors3.default.yellow(import_picocolors3.default.bold("\u26A0\uFE0F \u8BCA\u65AD\u5B8C\u6210\uFF1A\u53D1\u73B0\u4EE5\u4E0B\u95EE\u9898"))}
+
+${issueList}
+
+${import_picocolors3.default.cyan("\u5EFA\u8BAE\u6839\u636E\u63D0\u793A\u8FDB\u884C\u4FEE\u590D")}`,
+      "Doctor Report"
+    );
+    if (options.fix) {
+      if (codeIssues.length > 0) {
+        const fixSpinner = createSpinner("\u6B63\u5728\u4FEE\u590D\u4EE3\u7801\u89C4\u8303\u95EE\u9898...").start();
+        for (const issue of codeIssues) {
+          const content = await import_fs_extra3.default.readFile(issue.file, "utf-8");
+          const newContent = issue.rule.fix(content);
+          await import_fs_extra3.default.writeFile(issue.file, newContent);
+        }
+        fixSpinner.succeed("\u4EE3\u7801\u4FEE\u590D\u5B8C\u6210");
+      }
+      logger.info("\u6B63\u5728\u4FEE\u590D\u73AF\u5883\u914D\u7F6E...");
+      const { sync: sync2 } = await import("./sync-7HPKGVFY.mjs");
+      await sync2({ force: true });
+      logger.success("\u81EA\u52A8\u4FEE\u590D\u5B8C\u6210\uFF0C\u8BF7\u91CD\u65B0\u8FD0\u884C\u8BCA\u65AD\u3002");
+    }
+  }
+}
+
+// src/commands/discover.ts
+init_esm_shims();
+var import_picocolors4 = __toESM(require_picocolors());
+async function discover() {
+  const cwd = process.cwd();
+  const spinner = createSpinner("\u6B63\u5728\u626B\u63CF\u9879\u76EE\u4E2D\u7684\u63D2\u4EF6...").start();
+  const plugins = await CoreKit.discoverPlugins(cwd);
+  if (plugins.length === 0) {
+    spinner.warn("\u672A\u53D1\u73B0\u4EFB\u4F55\u63D2\u4EF6");
+    logger.info(import_picocolors4.default.gray("\u8BF7\u786E\u4FDD\u63D2\u4EF6\u4F4D\u4E8E plugins/ \u76EE\u5F55\u4E0B\uFF0C\u4E14\u5305\u542B package.json\u3002"));
+  } else {
+    spinner.succeed(`\u53D1\u73B0\u4E86 ${import_picocolors4.default.cyan(plugins.length)} \u4E2A\u63D2\u4EF6`);
+    const pluginList = plugins.map((p) => `- ${import_picocolors4.default.bold(p.name)} ${import_picocolors4.default.gray(`(${p.id})`)}
+  ${import_picocolors4.default.gray(p.path)}`).join("\n\n");
+    printBox(
+      `${import_picocolors4.default.green(import_picocolors4.default.bold("\u2728 \u63D2\u4EF6\u626B\u63CF\u7ED3\u679C"))}
+
+${pluginList}`,
+      "Plugin Discovery"
+    );
+  }
+}
+
+// src/commands/ls.ts
+init_esm_shims();
+var import_picocolors5 = __toESM(require_picocolors());
+async function ls() {
+  const versions = await CoreKit.listVersions();
+  const currentVersion = await CoreKit.resolveVersion(process.cwd());
+  const globalCurrentVersion = await CoreKit.resolveVersion();
+  logger.info("\u5DF2\u5B89\u88C5\u7684\u5185\u6838\u6C99\u7BB1\u7248\u672C:");
+  if (versions.length === 0) {
+    logger.warn("\u5C1A\u672A\u5B89\u88C5\u4EFB\u4F55\u7248\u672C\uFF0C\u8BF7\u8FD0\u884C chatbi sync \u8FDB\u884C\u5B89\u88C5\u3002");
+  } else {
+    const list = versions.map((v) => {
+      const isGlobalCurrent = v === globalCurrentVersion;
+      const isProjectCurrent = v === currentVersion;
+      let prefix = "  ";
+      if (isProjectCurrent) {
+        prefix = import_picocolors5.default.green(" *");
+      } else if (isGlobalCurrent) {
+        prefix = import_picocolors5.default.blue(" >");
+      }
+      let suffix = "";
+      if (isProjectCurrent && isGlobalCurrent) {
+        suffix = import_picocolors5.default.gray(" (\u5F53\u524D\u9879\u76EE & \u5168\u5C40)");
+      } else if (isProjectCurrent) {
+        suffix = import_picocolors5.default.gray(" (\u5F53\u524D\u9879\u76EE)");
+      } else if (isGlobalCurrent) {
+        suffix = import_picocolors5.default.gray(" (\u5168\u5C40)");
+      }
+      return `${prefix} ${import_picocolors5.default.white(v)}${suffix}`;
+    }).join("\n");
+    printBox(
+      list + import_picocolors5.default.gray("\n\n\u63D0\u793A: * \u5F53\u524D\u9879\u76EE\u4F7F\u7528, > \u5168\u5C40\u9ED8\u8BA4\u4F7F\u7528"),
+      "Kernel Versions"
+    );
+  }
+  await Sandbox.visualizeStatus(process.cwd());
+}
+
+// src/commands/use.ts
+init_esm_shims();
+var import_fs_extra4 = __toESM(require_lib());
+import path4 from "path";
+async function use(version, options = {}) {
+  const versions = await CoreKit.listVersions();
+  if (!versions.includes(version)) {
+    logger.warn(`\u7248\u672C ${version} \u5C1A\u672A\u5B89\u88C5\uFF0C\u6B63\u5728\u5C1D\u8BD5\u5B89\u88C5...`);
+    await Sandbox.prepare(version);
+  }
+  if (options.global) {
+    await Sandbox.useVersion(version);
+    logger.success(`\u5DF2\u5207\u6362\u5168\u5C40\u5185\u6838\u7248\u672C\u81F3: ${version}`);
+  } else {
+    const cwd = process.cwd();
+    const versionFilePath = path4.join(cwd, ".chatbi-version");
+    await import_fs_extra4.default.writeFile(versionFilePath, version, "utf-8");
+    logger.success(`\u5DF2\u5207\u6362\u5F53\u524D\u9879\u76EE\u5185\u6838\u7248\u672C\u4E3A: ${version}`);
+  }
+  await sync({ version, force: false });
+}
+
+// src/commands/install.ts
+init_esm_shims();
+var import_fs_extra5 = __toESM(require_lib());
+var import_picocolors6 = __toESM(require_picocolors());
+import path5 from "path";
+async function install(target) {
+  if (target.endsWith(".tgz") && import_fs_extra5.default.existsSync(target)) {
+    const spinner = createSpinner(`\u6B63\u5728\u5B89\u88C5\u672C\u5730\u79BB\u7EBF\u5305: ${import_picocolors6.default.bold(target)}...`).start();
+    try {
+      const tgzPath = path5.resolve(target);
+      const match = path5.basename(target).match(/chatbi-core-(.+)\.tgz/);
+      let version = "unknown";
+      if (match) {
+        version = match[1];
+      }
+      if (version === "unknown") {
+        spinner.warn("\u65E0\u6CD5\u4ECE\u6587\u4EF6\u540D\u8BC6\u522B\u7248\u672C\uFF0C\u5C06\u4F7F\u7528\u5F53\u524D\u65F6\u95F4\u6233\u4F5C\u4E3A\u7248\u672C\u53F7");
+        version = `local-${Date.now()}`;
+      }
+      const versionRoot = Sandbox.getVersionRoot();
+      await import_fs_extra5.default.ensureDir(versionRoot);
+      spinner.text = "\u6B63\u5728\u89E3\u538B\u6587\u4EF6...";
+      await execa("tar", ["-xzf", tgzPath, "-C", versionRoot]);
+      spinner.succeed(`\u672C\u5730\u5305\u5DF2\u5B89\u88C5\u81F3\u6C99\u7BB1: ${version}`);
+      spinner.text = "\u6B63\u5728\u51C6\u5907\u5185\u6838\u73AF\u5883...";
+      await Sandbox.prepare(version);
+      spinner.succeed("\u5185\u6838\u73AF\u5883\u5C31\u7EEA");
+      printBox(
+        import_picocolors6.default.green(import_picocolors6.default.bold("\u2728 \u672C\u5730\u5185\u6838\u5B89\u88C5\u6210\u529F!")) + "\n\n" + import_picocolors6.default.white("\u7248\u672C: ") + import_picocolors6.default.cyan(version) + "\n" + import_picocolors6.default.white("\u8DEF\u5F84: ") + import_picocolors6.default.gray(Sandbox.getVersionPath(version)),
+        "Install Success"
+      );
+    } catch (e) {
+      spinner.fail("\u5B89\u88C5\u5931\u8D25");
+      throw e;
+    }
+  } else {
+    const { fetch: fetch2 } = await import("./fetch-7X2UFWIV.mjs");
+    await fetch2(target);
+  }
+}
+
+// package.json
+var package_default = {
+  name: "@chatbi-v/cli",
+  version: "2.0.2",
+  description: "Standardized CLI tooling for ChatBI Monorepo",
+  main: "dist/index.js",
+  bin: {
+    "chatbi-cli": "./bin/chatbi-cli.js"
+  },
+  files: [
+    "dist",
+    "bin",
+    "templates"
+  ],
+  publishConfig: {
+    access: "public"
+  },
+  scripts: {
+    build: "chatbi-cli build",
+    dev: "chatbi-cli build --watch",
+    test: "vitest"
+  },
+  dependencies: {
+    boxen: "^8.0.1",
+    cac: "^6.7.14",
+    execa: "^8.0.1",
+    "fast-glob": "^3.3.3",
+    figlet: "^1.9.4",
+    "fs-extra": "^11.2.0",
+    "gradient-string": "^3.0.0",
+    handlebars: "^4.7.8",
+    jiti: "^2.6.1",
+    ora: "^7.0.1",
+    picocolors: "^1.0.0",
+    prompts: "^2.4.2",
+    tsup: "^8.5.1",
+    typescript: "^5.0.0",
+    vite: "^5.4.21"
+  },
+  devDependencies: {
+    "@types/boxen": "^3.0.5",
+    "@types/figlet": "^1.7.0",
+    "@types/fs-extra": "^11.0.0",
+    "@types/gradient-string": "^1.1.6",
+    "@types/node": "^20.0.0",
+    "@types/prompts": "^2.4.9",
+    "@vitest/coverage-v8": "1.6.1",
+    tsup: "^8.5.1",
+    vitest: "^1.0.0"
+  }
+};
+
+// src/index.ts
+var cli = dist_default("chatbi-cli");
+var showHeader = () => {
+  const title = figlet.textSync("ChatBI-V CLI", { font: "Standard" });
+  console.log(dist_default2.pastel.multiline(title));
+  console.log(
+    boxen(import_picocolors7.default.cyan(`ChatBI-V \u7EDF\u4E00\u5F00\u53D1\u5DE5\u5177 v${package_default.version}`), {
+      padding: 0,
+      margin: { top: 1, bottom: 1 },
+      borderStyle: "round",
+      borderColor: "cyan",
+      title: "CoreKit Enabled",
+      titleAlignment: "center"
+    })
+  );
+};
+var wrapAction = (action, commandName) => {
+  return async (...args) => {
+    showHeader();
+    try {
+      await action(...args);
+    } catch (e) {
+      logger.error(`${commandName} \u6267\u884C\u5931\u8D25`, e);
+      process.exit(1);
+    }
+  };
+};
+cli.command("dev", "\u542F\u52A8\u5F00\u53D1\u670D\u52A1\u5668").alias("d").option("--port <port>", "\u7AEF\u53E3\u53F7").action(wrapAction(dev, "dev"));
+cli.command("build", "\u6784\u5EFA\u5F53\u524D\u9879\u76EE").alias("b").option("--watch", "\u5F00\u542F\u76D1\u542C\u6A21\u5F0F").action(wrapAction(build, "build"));
+cli.command("fetch <version>", "\u83B7\u53D6\u6307\u5B9A\u7248\u672C\u7684\u5185\u6838 (\u652F\u6301\u6253\u5305)").option("--pack", "\u6253\u5305\u4E3A\u79BB\u7EBF\u5B89\u88C5\u5305 (.tgz)").action(wrapAction(fetch, "fetch"));
+cli.command("install <target>", "\u5B89\u88C5\u5185\u6838 (\u652F\u6301\u7248\u672C\u53F7\u6216\u79BB\u7EBF\u5305\u8DEF\u5F84)").action(wrapAction(install, "install"));
+cli.command("init [name]", "\u521D\u59CB\u5316\u4E00\u4E2A\u65B0\u7684\u4E1A\u52A1\u63D2\u4EF6\u9879\u76EE").alias("create").alias("i").option("--project-type <type>", "\u9879\u76EE\u7C7B\u578B (monorepo | app | plugin)").option("--include-app", "Monorepo \u4E2D\u5305\u542B App").option("--no-include-app", "Monorepo \u4E2D\u4E0D\u5305\u542B App").option("--include-plugin", "Monorepo \u4E2D\u5305\u542B Plugin").option("--no-include-plugin", "Monorepo \u4E2D\u4E0D\u5305\u542B Plugin").option("--plugin-type <type>", "\u63D2\u4EF6\u7C7B\u578B (business | system)").option("--theme <theme>", "\u4E3B\u9898 (standard | nebula | glass)").action(wrapAction(async (name, options) => {
+  await init({
+    name,
+    projectType: options.projectType,
+    includeApp: options.includeApp,
+    includePlugin: options.includePlugin,
+    pluginType: options.pluginType,
+    theme: options.theme
+  });
+}, "init"));
+cli.command("add [name]", "\u5728\u5F53\u524D\u9879\u76EE\u4E2D\u6DFB\u52A0\u4E00\u4E2A\u65B0\u63D2\u4EF6").option("-t, --type <type>", "\u63D2\u4EF6\u7C7B\u578B (business | system)").option("--display-name <name>", "\u63D2\u4EF6\u663E\u793A\u540D\u79F0").option("--desc <description>", "\u63D2\u4EF6\u63CF\u8FF0").action(wrapAction(async (name, options) => {
+  await add({
+    name,
+    type: options.type,
+    displayName: options.displayName,
+    description: options.desc
+  });
+}, "add"));
+cli.command("update [targetVersion]", "\u66F4\u65B0\u5185\u6838\u7248\u672C").alias("up").action(wrapAction(async (targetVersion) => {
+  const { sync: sync2 } = await import("./sync-7HPKGVFY.mjs");
+  await sync2({ version: targetVersion, force: true });
+  logger.success("\u66F4\u65B0\u5B8C\u6210\uFF01");
+}, "update"));
+cli.command("sync", "\u540C\u6B65\u5185\u6838\u4F9D\u8D56\u4E0E\u89C4\u8303").alias("s").option("-v, --core-version <version>", "\u6307\u5B9A\u5185\u6838\u7248\u672C").option("-f, --force", "\u5F3A\u5236\u91CD\u65B0\u521D\u59CB\u5316\u5185\u6838\u6C99\u7BB1").option("--clean", "\u6E05\u7406\u5E76\u91CD\u7F6E\u6C99\u7BB1").action(wrapAction(async (options) => {
+  await sync({ ...options, version: options.coreVersion });
+  console.log("");
+  await doctor({ fix: false });
+}, "sync"));
+cli.command("doctor", "\u8BCA\u65AD\u9879\u76EE\u5065\u5EB7\u72B6\u51B5\u5E76\u4FEE\u590D").alias("dr").option("--fix", "\u81EA\u52A8\u4FEE\u590D\u53D1\u73B0\u7684\u95EE\u9898").action(wrapAction(doctor, "doctor"));
+cli.command("list", "\u5217\u51FA\u6240\u6709\u5DF2\u5B89\u88C5\u7684\u5185\u6838\u6C99\u7BB1\u7248\u672C").alias("ls").action(wrapAction(ls, "ls"));
+cli.command("use <version>", "\u5207\u6362\u5F53\u524D\u9879\u76EE\u4F7F\u7528\u7684\u5185\u6838\u7248\u672C").alias("u").option("--global", "\u5207\u6362\u5168\u5C40\u9ED8\u8BA4\u5185\u6838\u7248\u672C").action(wrapAction(use, "use"));
+cli.command("gl", "\u4F7F\u7528 AI \u811A\u624B\u67B6\u751F\u6210\u4EE3\u7801\u6216\u6587\u6863").option("-t, --type <type>", "\u751F\u6210\u7C7B\u578B (plugin|util|doc|component)").option("-p, --prompt <prompt>", "AI \u9700\u6C42\u63CF\u8FF0").action(wrapAction(gl, "gl"));
+cli.command("discover", "\u626B\u63CF\u5E76\u53D1\u73B0\u5F53\u524D\u9879\u76EE\u4E2D\u7684\u63D2\u4EF6").action(wrapAction(discover, "discover"));
+cli.command("bench", "\u8FD0\u884C CLI \u6027\u80FD\u57FA\u51C6\u6D4B\u8BD5").action(wrapAction(async () => {
+  const { bench } = await import("./bench-ACSHVGHE.mjs");
+  await bench();
+}, "bench"));
+cli.help((sections) => {
+  showHeader();
+  sections[0].body = import_picocolors7.default.white("ChatBI-V \u5F00\u53D1\u8005\u547D\u4EE4\u884C\u5DE5\u5177\uFF0C\u52A9\u529B\u5FEB\u901F\u5F00\u53D1\u548C\u6784\u5EFA\u63D2\u4EF6\u3002");
+});
+cli.version(package_default.version);
+if (process.argv.length <= 2) {
+  cli.outputHelp();
+} else {
+  cli.parse();
+}