bob-core 2.0.0-beta.13 → 2.0.0-beta.15

package/dist/esm/index.js

@@ -1,515 +1,244 @@
-import b from "prompts";
-import X from "minimist";
-import * as Z from "node:fs";
-import I from "path";
-import * as ee from "string-similarity";
-class z {
+import y from "prompts";
+import a from "chalk";
+import q from "minimist";
+import * as I from "node:fs";
+import R from "path";
+class S {
   logger;
-  constructor(e) {
-    this.logger = e;
+  constructor(t) {
+    this.logger = t.logger;
   }
   /**
    * Logger methods
    */
-  log(...e) {
-    this.logger.log(...e);
+  log(...t) {
+    this.logger.log(...t);
   }
-  info(...e) {
-    this.logger.info(...e);
+  info(...t) {
+    this.logger.info(...t);
   }
-  warn(...e) {
-    this.logger.warn(...e);
+  warn(...t) {
+    this.logger.warn(...t);
   }
-  error(...e) {
-    this.logger.error(...e);
+  error(...t) {
+    this.logger.error(...t);
   }
-  debug(...e) {
-    this.logger.debug(...e);
+  debug(...t) {
+    this.logger.debug(...t);
   }
   /**
    * Prompt utils
    */
-  async askForConfirmation(e = "Do you want to continue?", t) {
-    return (await b({
+  async askForConfirmation(t = "Do you want to continue?", e) {
+    return (await y({
       type: "confirm",
       name: "value",
-      message: e,
-      initial: t ?? !1
+      message: t,
+      initial: e ?? !1
     })).value;
   }
-  async askForInput(e, t, r) {
-    return (await b({
+  async askForInput(t, e, i) {
+    return (await y({
       type: "text",
       name: "value",
-      message: e,
-      initial: t,
-      ...r
+      message: t,
+      initial: e,
+      ...i
     }))?.value ?? null;
   }
-  async askForDate(e, t, r) {
-    return (await b({
+  async askForDate(t, e, i) {
+    return (await y({
       type: "date",
       name: "value",
-      message: e,
-      initial: t,
-      ...r
+      message: t,
+      initial: e,
+      ...i
     }))?.value ?? null;
   }
-  async askForList(e, t, r) {
-    return (await b({
+  async askForList(t, e, i) {
+    return (await y({
       type: "list",
       name: "value",
-      message: e,
-      initial: t,
-      ...r
+      message: t,
+      initial: e,
+      ...i
     }))?.value ?? null;
   }
-  async askForToggle(e, t, r) {
-    return (await b({
+  async askForToggle(t, e, i) {
+    return (await y({
       type: "toggle",
       name: "value",
-      message: e,
-      initial: t,
-      ...r
+      message: t,
+      initial: e,
+      ...i
     }))?.value ?? null;
   }
-  async askForSelect(e, t, r) {
-    if (t.length === 0)
+  async askForSelect(t, e, i) {
+    if (e.length === 0)
       throw new Error("No options provided");
-    const s = [];
-    for (const o of t)
-      typeof o == "string" ? s.push({ title: o, value: o }) : s.push(o);
-    return (await b({
+    const n = [];
+    for (const o of e)
+      typeof o == "string" ? n.push({ title: o, value: o }) : n.push(o);
+    return (await y({
       type: "select",
       name: "value",
-      message: e,
-      choices: s,
-      ...r
+      message: t,
+      choices: n,
+      ...i
     }))?.value ?? null;
   }
-  newLoader(e = "", t = ["⠙", "⠘", "⠰", "⠴", "⠤", "⠦", "⠆", "⠃", "⠋", "⠉"], r = 100) {
-    let s = e, i = null, o = 0;
-    const u = setInterval(function() {
-      i && (process.stdout.write(new TextEncoder().encode("\r" + " ".repeat(i.length + 5) + "\r")), i = null), process.stdout.write(new TextEncoder().encode("\r" + t[o++] + " " + s)), o = o % t.length;
-    }, r), m = () => {
-      clearInterval(u), process.stdout.write(new TextEncoder().encode("\r" + " ".repeat(s.length + 5) + "\r"));
+  newLoader(t = "", e = ["⠙", "⠘", "⠰", "⠴", "⠤", "⠦", "⠆", "⠃", "⠋", "⠉"], i = 100) {
+    let n = t, s = null, o = 0;
+    const m = setInterval(function() {
+      s && (process.stdout.write(new TextEncoder().encode("\r" + " ".repeat(s.length + 5) + "\r")), s = null), process.stdout.write(new TextEncoder().encode("\r" + e[o++] + " " + n)), o = o % e.length;
+    }, i), u = () => {
+      clearInterval(m), process.stdout.write(new TextEncoder().encode("\r" + " ".repeat(n.length + 5) + "\r"));
     };
     return {
-      [Symbol.dispose]: m,
-      [Symbol.asyncDispose]: m,
+      [Symbol.dispose]: u,
+      [Symbol.asyncDispose]: u,
       updateText: (h) => {
-        i = s, s = h;
+        s = n, n = h;
       },
-      stop: m
+      stop: u
     };
   }
 }
-const F = 10, L = (n = 0) => (e) => `\x1B[${e + n}m`, M = (n = 0) => (e) => `\x1B[${38 + n};5;${e}m`, V = (n = 0) => (e, t, r) => `\x1B[${38 + n};2;${e};${t};${r}m`, c = {
-  modifier: {
-    reset: [0, 0],
-    // 21 isn't widely supported and 22 does the same thing
-    bold: [1, 22],
-    dim: [2, 22],
-    italic: [3, 23],
-    underline: [4, 24],
-    overline: [53, 55],
-    inverse: [7, 27],
-    hidden: [8, 28],
-    strikethrough: [9, 29]
-  },
-  color: {
-    black: [30, 39],
-    red: [31, 39],
-    green: [32, 39],
-    yellow: [33, 39],
-    blue: [34, 39],
-    magenta: [35, 39],
-    cyan: [36, 39],
-    white: [37, 39],
-    // Bright color
-    blackBright: [90, 39],
-    gray: [90, 39],
-    // Alias of `blackBright`
-    grey: [90, 39],
-    // Alias of `blackBright`
-    redBright: [91, 39],
-    greenBright: [92, 39],
-    yellowBright: [93, 39],
-    blueBright: [94, 39],
-    magentaBright: [95, 39],
-    cyanBright: [96, 39],
-    whiteBright: [97, 39]
-  },
-  bgColor: {
-    bgBlack: [40, 49],
-    bgRed: [41, 49],
-    bgGreen: [42, 49],
-    bgYellow: [43, 49],
-    bgBlue: [44, 49],
-    bgMagenta: [45, 49],
-    bgCyan: [46, 49],
-    bgWhite: [47, 49],
-    // Bright color
-    bgBlackBright: [100, 49],
-    bgGray: [100, 49],
-    // Alias of `bgBlackBright`
-    bgGrey: [100, 49],
-    // Alias of `bgBlackBright`
-    bgRedBright: [101, 49],
-    bgGreenBright: [102, 49],
-    bgYellowBright: [103, 49],
-    bgBlueBright: [104, 49],
-    bgMagentaBright: [105, 49],
-    bgCyanBright: [106, 49],
-    bgWhiteBright: [107, 49]
-  }
-};
-Object.keys(c.modifier);
-const te = Object.keys(c.color), re = Object.keys(c.bgColor);
-[...te, ...re];
-function ne() {
-  const n = /* @__PURE__ */ new Map();
-  for (const [e, t] of Object.entries(c)) {
-    for (const [r, s] of Object.entries(t))
-      c[r] = {
-        open: `\x1B[${s[0]}m`,
-        close: `\x1B[${s[1]}m`
-      }, t[r] = c[r], n.set(s[0], s[1]);
-    Object.defineProperty(c, e, {
-      value: t,
-      enumerable: !1
-    });
-  }
-  return Object.defineProperty(c, "codes", {
-    value: n,
-    enumerable: !1
-  }), c.color.close = "\x1B[39m", c.bgColor.close = "\x1B[49m", c.color.ansi = L(), c.color.ansi256 = M(), c.color.ansi16m = V(), c.bgColor.ansi = L(F), c.bgColor.ansi256 = M(F), c.bgColor.ansi16m = V(F), Object.defineProperties(c, {
-    rgbToAnsi256: {
-      value(e, t, r) {
-        return e === t && t === r ? e < 8 ? 16 : e > 248 ? 231 : Math.round((e - 8) / 247 * 24) + 232 : 16 + 36 * Math.round(e / 255 * 5) + 6 * Math.round(t / 255 * 5) + Math.round(r / 255 * 5);
-      },
-      enumerable: !1
-    },
-    hexToRgb: {
-      value(e) {
-        const t = /[a-f\d]{6}|[a-f\d]{3}/i.exec(e.toString(16));
-        if (!t)
-          return [0, 0, 0];
-        let [r] = t;
-        r.length === 3 && (r = [...r].map((i) => i + i).join(""));
-        const s = Number.parseInt(r, 16);
-        return [
-          /* eslint-disable no-bitwise */
-          s >> 16 & 255,
-          s >> 8 & 255,
-          s & 255
-          /* eslint-enable no-bitwise */
-        ];
-      },
-      enumerable: !1
-    },
-    hexToAnsi256: {
-      value: (e) => c.rgbToAnsi256(...c.hexToRgb(e)),
-      enumerable: !1
-    },
-    ansi256ToAnsi: {
-      value(e) {
-        if (e < 8)
-          return 30 + e;
-        if (e < 16)
-          return 90 + (e - 8);
-        let t, r, s;
-        if (e >= 232)
-          t = ((e - 232) * 10 + 8) / 255, r = t, s = t;
-        else {
-          e -= 16;
-          const u = e % 36;
-          t = Math.floor(e / 36) / 5, r = Math.floor(u / 6) / 5, s = u % 6 / 5;
-        }
-        const i = Math.max(t, r, s) * 2;
-        if (i === 0)
-          return 30;
-        let o = 30 + (Math.round(s) << 2 | Math.round(r) << 1 | Math.round(t));
-        return i === 2 && (o += 60), o;
-      },
-      enumerable: !1
-    },
-    rgbToAnsi: {
-      value: (e, t, r) => c.ansi256ToAnsi(c.rgbToAnsi256(e, t, r)),
-      enumerable: !1
-    },
-    hexToAnsi: {
-      value: (e) => c.ansi256ToAnsi(c.hexToAnsi256(e)),
-      enumerable: !1
-    }
-  }), c;
-}
-const f = ne(), q = (() => {
-  if (!("navigator" in globalThis))
-    return 0;
-  if (globalThis.navigator.userAgentData) {
-    const n = navigator.userAgentData.brands.find(({ brand: e }) => e === "Chromium");
-    if (n && n.version > 93)
-      return 3;
-  }
-  return /\b(Chrome|Chromium)\//.test(globalThis.navigator.userAgent) ? 1 : 0;
-})(), D = q !== 0 && {
-  level: q
-}, se = {
-  stdout: D,
-  stderr: D
-};
-function ie(n, e, t) {
-  let r = n.indexOf(e);
-  if (r === -1)
-    return n;
-  const s = e.length;
-  let i = 0, o = "";
-  do
-    o += n.slice(i, r) + e + t, i = r + s, r = n.indexOf(e, i);
-  while (r !== -1);
-  return o += n.slice(i), o;
+class f extends Error {
 }
-function oe(n, e, t, r) {
-  let s = 0, i = "";
-  do {
-    const o = n[r - 1] === "\r";
-    i += n.slice(s, o ? r - 1 : r) + e + (o ? `\r
-` : `
-`) + t, s = r + 1, r = n.indexOf(`
-`, s);
-  } while (r !== -1);
-  return i += n.slice(s), i;
+function x(r) {
+  if (r === "string" || r === "number") return null;
+  if (r === "boolean") return !1;
+  if (Array.isArray(r) && r.length === 1) {
+    if (r[0] === "string") return [];
+    if (r[0] === "number") return [];
+  }
+  throw new Error("Invalid option type: " + r);
 }
-const { stdout: H, stderr: W } = se, S = Symbol("GENERATOR"), v = Symbol("STYLER"), C = Symbol("IS_EMPTY"), G = [
-  "ansi",
-  "ansi",
-  "ansi256",
-  "ansi16m"
-], A = /* @__PURE__ */ Object.create(null), ae = (n, e = {}) => {
-  if (e.level && !(Number.isInteger(e.level) && e.level >= 0 && e.level <= 3))
-    throw new Error("The `level` option should be an integer from 0 to 3");
-  const t = H ? H.level : 0;
-  n.level = e.level === void 0 ? t : e.level;
-}, le = (n) => {
-  const e = (...t) => t.join(" ");
-  return ae(e, n), Object.setPrototypeOf(e, O.prototype), e;
-};
-function O(n) {
-  return le(n);
+function E(r) {
+  return typeof r == "string" || Array.isArray(r) ? x(r) : r.default !== void 0 ? r.default : x(r.type);
 }
-Object.setPrototypeOf(O.prototype, Function.prototype);
-for (const [n, e] of Object.entries(f))
-  A[n] = {
-    get() {
-      const t = R(this, N(e.open, e.close, this[v]), this[C]);
-      return Object.defineProperty(this, n, { value: t }), t;
-    }
-  };
-A.visible = {
-  get() {
-    const n = R(this, this[v], !0);
-    return Object.defineProperty(this, "visible", { value: n }), n;
-  }
-};
-const T = (n, e, t, ...r) => n === "rgb" ? e === "ansi16m" ? f[t].ansi16m(...r) : e === "ansi256" ? f[t].ansi256(f.rgbToAnsi256(...r)) : f[t].ansi(f.rgbToAnsi(...r)) : n === "hex" ? T("rgb", e, t, ...f.hexToRgb(...r)) : f[t][n](...r), ue = ["rgb", "hex", "ansi256"];
-for (const n of ue) {
-  A[n] = {
-    get() {
-      const { level: t } = this;
-      return function(...r) {
-        const s = N(T(n, G[t], "color", ...r), f.color.close, this[v]);
-        return R(this, s, this[C]);
-      };
-    }
-  };
-  const e = "bg" + n[0].toUpperCase() + n.slice(1);
-  A[e] = {
-    get() {
-      const { level: t } = this;
-      return function(...r) {
-        const s = N(T(n, G[t], "bgColor", ...r), f.bgColor.close, this[v]);
-        return R(this, s, this[C]);
-      };
-    }
-  };
-}
-const me = Object.defineProperties(() => {
-}, {
-  ...A,
-  level: {
-    enumerable: !0,
-    get() {
-      return this[S].level;
-    },
-    set(n) {
-      this[S].level = n;
-    }
-  }
-}), N = (n, e, t) => {
-  let r, s;
-  return t === void 0 ? (r = n, s = e) : (r = t.openAll + n, s = e + t.closeAll), {
-    open: n,
-    close: e,
-    openAll: r,
-    closeAll: s,
-    parent: t
-  };
-}, R = (n, e, t) => {
-  const r = (...s) => de(r, s.length === 1 ? "" + s[0] : s.join(" "));
-  return Object.setPrototypeOf(r, me), r[S] = n, r[v] = e, r[C] = t, r;
-}, de = (n, e) => {
-  if (n.level <= 0 || !e)
-    return n[C] ? "" : e;
-  let t = n[v];
-  if (t === void 0)
-    return e;
-  const { openAll: r, closeAll: s } = t;
-  if (e.includes("\x1B"))
-    for (; t !== void 0; )
-      e = ie(e, t.close, t.open), t = t.parent;
-  const i = e.indexOf(`
-`);
-  return i !== -1 && (e = oe(e, s, r, i)), r + e + s;
-};
-Object.defineProperties(O.prototype, A);
-const a = O();
-O({ level: W ? W.level : 0 });
-class w extends Error {
-}
-function _(n) {
-  if (n === "string" || n === "number") return null;
-  if (n === "boolean") return !1;
-  if (Array.isArray(n) && n.length === 1) {
-    if (n[0] === "string") return [];
-    if (n[0] === "number") return [];
-  }
-  throw new Error("Invalid option type: " + n);
-}
-function U(n) {
-  return typeof n == "string" || Array.isArray(n) ? _(n) : n.default !== void 0 ? n.default : _(n.type);
-}
-function y(n) {
-  return typeof n == "string" || Array.isArray(n) ? {
+function g(r) {
+  return typeof r == "string" || Array.isArray(r) ? {
     alias: [],
-    default: U(n),
+    default: E(r),
     description: "",
     required: !1,
     secret: !1,
-    type: n,
+    type: r,
     variadic: !1
   } : {
-    alias: n.alias ? Array.isArray(n.alias) ? n.alias : [n.alias] : [],
-    default: n.default ?? U(n.type),
-    description: n.description ?? "",
-    required: n.required ?? !1,
-    secret: n.secret ?? !1,
-    type: n.type,
-    variadic: n.variadic ?? !1
+    alias: r.alias ? Array.isArray(r.alias) ? r.alias : [r.alias] : [],
+    default: r.default ?? E(r.type),
+    description: r.description ?? "",
+    required: r.required ?? !1,
+    secret: r.secret ?? !1,
+    type: r.type,
+    variadic: r.variadic ?? !1
   };
 }
-class k extends w {
-  constructor(e, t = {}) {
-    super(`Invalid option ${e} in not recognized`), this.option = e, this.optionsSchema = t;
-  }
-  pretty(e) {
-    const t = Object.entries(this.optionsSchema);
-    if (t.length > 0) {
-      e.log(`
+class b extends f {
+  constructor(t, e = {}) {
+    super(`Invalid option ${t} in not recognized`), this.option = t, this.optionsSchema = e;
+  }
+  pretty(t) {
+    const e = Object.entries(this.optionsSchema);
+    if (e.length > 0) {
+      t.log(`
 ${a.yellow("Available options")}:`);
-      for (const [r, s] of t) {
-        const i = y(s), o = typeof i.alias == "string" ? [i.alias] : i.alias, u = Array.isArray(i.type) ? `[${i.type[0]}]` : i.type, m = `--${r}${o.length > 0 ? o.map((l) => `, -${l}`).join("") : ""}`, h = " ".repeat(30 - m.length);
-        e.log(`  ${a.green(m)} ${h} ${i.description || "\b"} ${a.white(`(${u})`)}`);
+      for (const [i, n] of e) {
+        const s = g(n), o = typeof s.alias == "string" ? [s.alias] : s.alias, m = Array.isArray(s.type) ? `[${s.type[0]}]` : s.type, u = `--${i}${o.length > 0 ? o.map((l) => `, -${l}`).join("") : ""}`, h = " ".repeat(30 - u.length);
+        t.log(`  ${a.green(u)} ${h} ${s.description || "\b"} ${a.white(`(${m})`)}`);
       }
-      e.log("");
+      t.log("");
     }
-    e.log(`${a.white.bgRed(" ERROR ")} Option ${a.bold.yellow(this.option)} is not recognized.`);
+    t.log(`${a.white.bgRed(" ERROR ")} Option ${a.bold.yellow(this.option)} is not recognized.`);
   }
 }
-class Y extends w {
-  constructor(e) {
-    super(`Argument "${e}" is required.`), this.argument = e;
+class F extends f {
+  constructor(t) {
+    super(`Argument "${t}" is required.`), this.argument = t;
   }
-  pretty(e) {
-    e.log(`${a.white.bgRed(" ERROR ")} Argument ${a.bold.yellow(this.argument)} is required.`);
+  pretty(t) {
+    t.log(`${a.white.bgRed(" ERROR ")} Argument ${a.bold.yellow(this.argument)} is required.`);
   }
 }
-class ce extends w {
-  constructor(e) {
-    super(`Argument "${e}" is required.`), this.option = e;
+class V extends f {
+  constructor(t) {
+    super(`Argument "${t}" is required.`), this.option = t;
   }
-  pretty(e) {
-    e.log(`${a.white.bgRed(" ERROR ")} Option ${a.bold.yellow(this.option)} is required.`);
+  pretty(t) {
+    t.log(`${a.white.bgRed(" ERROR ")} Option ${a.bold.yellow(this.option)} is required.`);
   }
 }
-class Ae extends w {
-  constructor(e) {
-    let t = `Argument "${e.param}" value is invalid.`;
-    e.reason ? t += ` Reason: ${e.reason}` : t += ` Value: "${e.value}"`, super(t), this.param = e;
+class U extends f {
+  constructor(t) {
+    let e = `Argument "${t.param}" value is invalid.`;
+    t.reason ? e += ` Reason: ${t.reason}` : e += ` Value: "${t.value}"`, super(e), this.param = t;
   }
-  pretty(e) {
-    e.log(`  ${a.white.bgRed(" ERROR ")} Argument ${a.bold.yellow(this.param.param)} value is invalid. `), (this.param.value || this.param.reason) && e.log(""), this.param.value && e.log(`  ${a.blue("Value")}: ${this.param.value}`), this.param.reason && e.log(`  ${a.yellow("Reason")}: ${this.param.reason}`);
+  pretty(t) {
+    t.log(`  ${a.white.bgRed(" ERROR ")} Argument ${a.bold.yellow(this.param.param)} value is invalid. `), (this.param.value || this.param.reason) && t.log(""), this.param.value && t.log(`  ${a.blue("Value")}: ${this.param.value}`), this.param.reason && t.log(`  ${a.yellow("Reason")}: ${this.param.reason}`);
   }
 }
-class B extends w {
-  constructor(e) {
-    let t = `Option "${e.option}" value is invalid.`;
-    e.reason ? t += ` Reason: ${e.reason}` : t += ` Value: "${e.value}"`, super(t), this.param = e;
+class C extends f {
+  constructor(t) {
+    let e = `Option "${t.option}" value is invalid.`;
+    t.reason ? e += ` Reason: ${t.reason}` : e += ` Value: "${t.value}"`, super(e), this.param = t;
   }
-  pretty(e) {
-    e.log(`  ${a.white.bgRed(" ERROR ")} Option ${a.bold.yellow(this.param.option)} value is invalid. `), (this.param.value || this.param.reason) && e.log(""), this.param.value && e.log(`  ${a.blue("Value")}: ${this.param.value}`), this.param.reason && e.log(`  ${a.yellow("Reason")}: ${this.param.reason}`);
+  pretty(t) {
+    t.log(`  ${a.white.bgRed(" ERROR ")} Option ${a.bold.yellow(this.param.option)} value is invalid. `), (this.param.value || this.param.reason) && t.log(""), this.param.value && t.log(`  ${a.blue("Value")}: ${this.param.value}`), this.param.reason && t.log(`  ${a.yellow("Reason")}: ${this.param.reason}`);
   }
 }
-class he extends w {
-  constructor(e) {
-    super(`Command "${e}" not found.`), this.command = e;
+class P extends f {
+  constructor(t) {
+    super(`Command "${t}" not found.`), this.command = t;
   }
-  pretty(e) {
-    e.log(`${a.bgRed(" ERROR ")} Command ${a.yellow(this.command)} not found.`);
+  pretty(t) {
+    t.log(`${a.bgRed(" ERROR ")} Command ${a.yellow(this.command)} not found.`);
   }
 }
-function $(n, e, t, r) {
-  if (n == null)
-    return r ?? null;
-  if (e === "string")
-    return String(n);
-  if (e === "number") {
-    const s = Number(n);
-    if (isNaN(s))
-      throw new B({
-        option: t,
-        reason: `Expected a number, got "${n}"`
+function w(r, t, e, i) {
+  if (r == null)
+    return i ?? null;
+  if (t === "string")
+    return String(r);
+  if (t === "number") {
+    const n = Number(r);
+    if (isNaN(n))
+      throw new C({
+        option: e,
+        reason: `Expected a number, got "${r}"`
       });
-    return s;
-  }
-  if (e === "boolean")
-    return typeof n == "boolean" ? n : n === "true" || n === "1" ? !0 : n === "false" || n === "0" ? !1 : !!n;
-  if (Array.isArray(e)) {
-    const s = e[0], i = Array.isArray(n) ? n : [n];
-    if (s === "string")
-      return i.map((o) => String(o));
-    if (s === "number")
-      return i.map((o) => {
-        const u = Number(o);
-        if (isNaN(u))
-          throw new B({
-            option: t,
+    return n;
+  }
+  if (t === "boolean")
+    return typeof r == "boolean" ? r : r === "true" || r === "1" ? !0 : r === "false" || r === "0" ? !1 : !!r;
+  if (Array.isArray(t)) {
+    const n = t[0], s = Array.isArray(r) ? r : [r];
+    if (n === "string")
+      return s.map((o) => String(o));
+    if (n === "number")
+      return s.map((o) => {
+        const m = Number(o);
+        if (isNaN(m))
+          throw new C({
+            option: e,
             reason: `Expected array of numbers, got "${o}" in array`
           });
-        return u;
+        return m;
       });
   }
-  return n;
+  return r;
 }
-class J {
+class k {
   options;
   parsedOptions = null;
   arguments;
   parsedArguments = null;
   io;
   shouldPromptForMissingOptions = !0;
-  constructor(e) {
-    this.options = e.options, this.arguments = e.arguments, this.io = e.io;
+  constructor(t) {
+    this.options = t.options, this.arguments = t.arguments, this.io = t.io;
   }
   // === PUBLIC METHODS ===
   /**
@@ -519,9 +248,9 @@ class J {
    * @throws {InvalidOption} If an naan option is provided
    * @throws {BadCommandOption} If a value cannot be converted to the expected type
    */
-  init(e) {
-    const { _: t, ...r } = X(e);
-    return this.validateUnknownOptions(r), this.parsedOptions = this.handleOptions(r), this.parsedArguments = this.handleArguments(t), {
+  init(t) {
+    const { _: e, ...i } = q(t);
+    return this.validateUnknownOptions(i), this.parsedOptions = this.handleOptions(i), this.parsedArguments = this.handleArguments(e), {
       options: this.parsedOptions,
       arguments: this.parsedArguments
     };
@@ -531,30 +260,30 @@ class J {
    * @throws {Error} If validation fails
    */
   async validate() {
-    for (const e in this.options)
-      if (y(this.options[e]).required && (this.parsedOptions?.[e] === void 0 || this.parsedOptions?.[e] === null))
-        throw new ce(e);
-    for (const e in this.arguments) {
-      const t = y(this.arguments[e]), r = this.parsedArguments?.[e];
-      if (t.required && r == null) {
+    for (const t in this.options)
+      if (g(this.options[t]).required && (this.parsedOptions?.[t] === void 0 || this.parsedOptions?.[t] === null))
+        throw new V(t);
+    for (const t in this.arguments) {
+      const e = g(this.arguments[t]), i = this.parsedArguments?.[t];
+      if (e.required && i == null) {
         if (this.shouldPromptForMissingOptions) {
-          const s = await this.promptForArgument(e, t);
-          if (s && this.parsedArguments) {
-            this.parsedArguments[e] = $(s, t.type, e);
+          const n = await this.promptForArgument(t, e);
+          if (n && this.parsedArguments) {
+            this.parsedArguments[t] = w(n, e.type, t);
             continue;
           }
         }
-        throw new Y(e);
+        throw new F(t);
       }
-      if (t.required && t.variadic && Array.isArray(r) && r.length === 0) {
+      if (e.required && e.variadic && Array.isArray(i) && i.length === 0) {
         if (this.shouldPromptForMissingOptions) {
-          const s = await this.promptForArgument(e, t);
-          if (s && this.parsedArguments) {
-            this.parsedArguments[e] = $(s, t.type, e);
+          const n = await this.promptForArgument(t, e);
+          if (n && this.parsedArguments) {
+            this.parsedArguments[t] = w(n, e.type, t);
             continue;
           }
         }
-        throw new Y(e);
+        throw new F(t);
       }
     }
   }
@@ -565,17 +294,17 @@ class J {
    * @returns The typed option value
    * @throws {Error} If init() has not been called yet
    */
-  option(e, t) {
+  option(t, e) {
     if (!this.parsedOptions)
       throw new Error("Options have not been parsed yet. Call init() first.");
-    return this.isEmptyValue(this.parsedOptions[e]) && t !== void 0 ? t : this.parsedOptions[e];
+    return this.isEmptyValue(this.parsedOptions[t]) && e !== void 0 ? e : this.parsedOptions[t];
   }
-  setOption(e, t) {
+  setOption(t, e) {
     if (!this.parsedOptions)
       throw new Error("Options have not been parsed yet. Call init() first.");
-    if (!(e in this.options))
-      throw new k(e, this.options);
-    this.parsedOptions[e] = t;
+    if (!(t in this.options))
+      throw new b(t, this.options);
+    this.parsedOptions[t] = e;
   }
   /**
    * Retrieves a parsed argument value by name
@@ -584,17 +313,17 @@ class J {
    * @returns The typed argument value
    * @throws {Error} If init() has not been called yet
    */
-  argument(e, t) {
+  argument(t, e) {
     if (!this.parsedArguments)
       throw new Error("Arguments have not been parsed yet. Call init() first.");
-    return this.isEmptyValue(this.parsedArguments[e]) && t !== void 0 ? t : this.parsedArguments[e];
+    return this.isEmptyValue(this.parsedArguments[t]) && e !== void 0 ? e : this.parsedArguments[t];
   }
-  setArgument(e, t) {
+  setArgument(t, e) {
     if (!this.parsedArguments)
       throw new Error("Arguments have not been parsed yet. Call init() first.");
-    if (!(e in this.arguments))
-      throw new k(e, this.arguments);
-    this.parsedArguments[e] = t;
+    if (!(t in this.arguments))
+      throw new b(t, this.arguments);
+    this.parsedArguments[t] = e;
   }
   // === PRIVATE HELPERS ===
   /**
@@ -602,97 +331,97 @@ class J {
    * @param value - The value to check
    * @returns true if the value is null, undefined, or an empty array
    */
-  isEmptyValue(e) {
-    return e == null || Array.isArray(e) && e.length === 0;
+  isEmptyValue(t) {
+    return t == null || Array.isArray(t) && t.length === 0;
   }
   /**
    * Validates that all provided options are recognized
    * @throws {InvalidOption} If an unknown option is found
    */
-  validateUnknownOptions(e) {
-    const t = /* @__PURE__ */ new Set();
-    for (const r in this.options) {
-      t.add(r);
-      const s = y(this.options[r]);
-      for (const i of s.alias)
-        t.add(i);
+  validateUnknownOptions(t) {
+    const e = /* @__PURE__ */ new Set();
+    for (const i in this.options) {
+      e.add(i);
+      const n = g(this.options[i]);
+      for (const s of n.alias)
+        e.add(s);
     }
-    for (const r in e)
-      if (!t.has(r))
-        throw new k(r, this.options);
+    for (const i in t)
+      if (!e.has(i))
+        throw new b(i, this.options);
   }
   /**
    * Processes named options from minimist output
    */
-  handleOptions(e) {
-    const t = {};
-    for (const r in this.options) {
-      const s = y(this.options[r]);
-      t[r] = this.resolveOptionValue(r, s, e);
+  handleOptions(t) {
+    const e = {};
+    for (const i in this.options) {
+      const n = g(this.options[i]);
+      e[i] = this.resolveOptionValue(i, n, t);
     }
-    return t;
+    return e;
   }
   /**
    * Processes positional arguments from minimist output
    */
-  handleArguments(e) {
-    const t = {}, r = [...e];
-    for (const s in this.arguments) {
-      const i = y(this.arguments[s]);
-      if (i.variadic) {
-        t[s] = this.handleVariadicArgument(s, i, r);
+  handleArguments(t) {
+    const e = {}, i = [...t];
+    for (const n in this.arguments) {
+      const s = g(this.arguments[n]);
+      if (s.variadic) {
+        e[n] = this.handleVariadicArgument(n, s, i);
         continue;
       }
-      t[s] = this.resolveArgumentValue(s, i, r.shift());
+      e[n] = this.resolveArgumentValue(n, s, i.shift());
     }
-    return t;
+    return e;
   }
   /**
    * Handles variadic arguments that consume all remaining positional values
    */
-  handleVariadicArgument(e, t, r) {
-    return r.length ? $(r, t.type, e, t.default) : t.default;
+  handleVariadicArgument(t, e, i) {
+    return i.length ? w(i, e.type, t, e.default) : e.default;
   }
   /**
    * Resolves a single positional argument value with defaults and type conversion
    * Note: Does not validate required arguments - validation happens in subclass validate() methods
    */
-  resolveArgumentValue(e, t, r) {
-    return r === void 0 ? t.default : $(r, t.type, e, t.default);
+  resolveArgumentValue(t, e, i) {
+    return i === void 0 ? e.default : w(i, e.type, t, e.default);
   }
   /**
    * Resolves an option value from the parsed option values object
    * Handles alias resolution, defaults, and type conversion
    */
-  resolveOptionValue(e, t, r) {
-    let s;
-    const i = [e, ...t.alias];
-    for (const o of i)
-      if (o in r) {
-        s = r[o];
+  resolveOptionValue(t, e, i) {
+    let n;
+    const s = [t, ...e.alias];
+    for (const o of s)
+      if (o in i) {
+        n = i[o];
         break;
       }
-    if (s === void 0) {
-      if (t.required)
-        throw new B({
-          option: e,
+    if (n === void 0) {
+      if (e.required)
+        throw new C({
+          option: t,
           reason: "Required option is missing"
         });
-      return t.default;
+      return e.default;
     }
-    return $(s, t.type, e, t.default);
+    return w(n, e.type, t, e.default);
   }
   optionDefinitions() {
-    const e = {};
-    for (const t in this.options)
-      e[t] = y(this.options[t]);
-    return e;
+    const t = {};
+    for (const e in this.options)
+      t[e] = g(this.options[e]);
+    return t;
   }
   argumentDefinitions() {
-    const e = {};
-    for (const t in this.arguments)
-      e[t] = y(this.arguments[t]);
-    return e;
+    const t = {};
+    for (const e in this.arguments)
+      t[e] = g(this.arguments[e]);
+    return t;
   }
   availableOptions() {
     return Object.keys(this.options);
@@ -714,89 +443,89 @@ class J {
    * @param argDef - The argument's definition for type and description
    * @returns The user-provided value, or null if none given
    */
-  async promptForArgument(e, t) {
-    if (!Array.isArray(t.type) && !["string", "number", "secret"].includes(t.type))
+  async promptForArgument(t, e) {
+    if (!Array.isArray(e.type) && !["string", "number", "secret"].includes(e.type))
       return null;
-    let r = `${a.yellow.bold(e)} is required`;
-    return t.description && (r += `: ${a.gray(`(${t.description})`)}`), r += ` ${a.green(`(${t.type}${t.variadic == !0 ? "[]" : ""})`)}
-`, Array.isArray(t.type) ? (r += `Please provide one or more values, separated by commas:
-`, await this.io.askForList(r, void 0, {
+    let i = `${a.yellow.bold(t)} is required`;
+    return e.description && (i += `: ${a.gray(`(${e.description})`)}`), i += ` ${a.green(`(${e.type}${e.variadic == !0 ? "[]" : ""})`)}
+`, Array.isArray(e.type) ? (i += `Please provide one or more values, separated by commas:
+`, await this.io.askForList(i, void 0, {
       separator: ",",
-      validate: (s) => {
-        if (!s.length)
+      validate: (n) => {
+        if (!n.length)
           return "Please enter at least one value";
-        if (t.type[0] === "number") {
-          for (const i of s.split(","))
-            if (isNaN(Number(i)))
+        if (e.type[0] === "number") {
+          for (const s of n.split(","))
+            if (isNaN(Number(s)))
               return "Please enter only valid numbers";
         }
         return !0;
       }
-    })) : await this.io.askForInput(r, void 0, {
-      type: t.type === "number" ? "number" : t.secret ? "password" : "text",
-      validate: (s) => {
-        if (s == null || typeof s == "string" && !s.length)
+    })) : await this.io.askForInput(i, void 0, {
+      type: e.type === "number" ? "number" : e.secret ? "password" : "text",
+      validate: (n) => {
+        if (n == null || typeof n == "string" && !n.length)
           return "This value is required";
-        if (t.type === "number") {
-          const i = Number(s);
-          if (isNaN(i))
+        if (e.type === "number") {
+          const s = Number(n);
+          if (isNaN(s))
             return "Please enter a valid number";
-        } else if (t.type === "string" && (typeof s != "string" || !s.length))
+        } else if (e.type === "string" && (typeof n != "string" || !n.length))
           return "Please enter a valid text";
         return !0;
       }
     });
   }
 }
-function j(n) {
-  return new Array(n + 5).join(" ");
+function A(r) {
+  return new Array(r + 5).join(" ");
 }
-class pe {
+class D {
   type = "boolean";
   option = "help";
   alias = ["h"];
   default = !1;
   description = `Display help for the given command. When no command is given display help for the ${a.green("list")} command`;
   async handler() {
-    const e = this.parser.argumentDefinitions(), t = this.parser.optionDefinitions(), r = Object.entries(e), s = Object.entries(t), i = s.map(([l, d]) => {
-      const p = Array.isArray(d.alias) ? d.alias : d.alias ? [d.alias] : [];
+    const t = this.parser.argumentDefinitions(), e = this.parser.optionDefinitions(), i = Object.entries(t), n = Object.entries(e), s = n.map(([l, d]) => {
+      const c = Array.isArray(d.alias) ? d.alias : d.alias ? [d.alias] : [];
       return {
         name: l,
         ...d,
-        optionWithAlias: `--${l}${p.map((g) => `, -${g}`).join("")}`
+        optionWithAlias: `--${l}${c.map((p) => `, -${p}`).join("")}`
       };
-    }), o = r.filter(([, l]) => l.required);
+    }), o = i.filter(([, l]) => l.required);
     this.io.log(a.yellow("Description:")), this.io.log(`  ${this.description}
 `), this.io.log(a.yellow("Usage:")), this.io.log(`  ${this.command} ${o.length > 0 ? o.map(([l]) => `<${l}>`).join(" ") : "\b"} [options]`);
-    const u = Math.max(...i.map((l) => l.optionWithAlias.length), 0), m = Math.max(...r.map(([l]) => l.length), 0), h = m > u ? m : u;
-    if (r.length > 0) {
+    const m = Math.max(...s.map((l) => l.optionWithAlias.length), 0), u = Math.max(...i.map(([l]) => l.length), 0), h = u > m ? u : m;
+    if (i.length > 0) {
       this.io.log(`
 ${a.yellow("Arguments")}:`);
-      for (const [l, d] of r) {
-        const p = j(h - l.length);
-        let g = `  ${a.green(l)} ${p} ${d.description ?? "\b"}`;
+      for (const [l, d] of i) {
+        const c = A(h - l.length);
+        let p = `  ${a.green(l)} ${c} ${d.description ?? "\b"}`;
         if (d.default !== void 0 && !d.required) {
-          const Q = (Array.isArray(d.type) ? `[${d.type[0]}]` : d.type) === "array" || Array.isArray(d.type) ? JSON.stringify(d.default) : d.default;
-          g += ` ${a.yellow(`[default: ${Q}]`)}`;
+          const L = (Array.isArray(d.type) ? `[${d.type[0]}]` : d.type) === "array" || Array.isArray(d.type) ? JSON.stringify(d.default) : d.default;
+          p += ` ${a.yellow(`[default: ${L}]`)}`;
         }
-        d.variadic && (g += ` ${a.white("(variadic)")}`), this.io.log(g);
+        d.variadic && (p += ` ${a.white("(variadic)")}`), this.io.log(p);
       }
     }
-    if (s.length > 0) {
+    if (n.length > 0) {
       this.io.log(`
 ${a.yellow("Options")}:`);
-      for (const l of i) {
-        const d = j(h - l.optionWithAlias.length);
-        let p = `${a.green(l.optionWithAlias)} ${d} ${l.description ?? "\b"}`;
+      for (const l of s) {
+        const d = A(h - l.optionWithAlias.length);
+        let c = `${a.green(l.optionWithAlias)} ${d} ${l.description ?? "\b"}`;
         if (l.type) {
-          const g = Array.isArray(l.type) ? `[${l.type[0]}]` : l.type;
-          p += ` ${a.white(`(${g})`)}`;
+          const p = Array.isArray(l.type) ? `[${l.type[0]}]` : l.type;
+          c += ` ${a.white(`(${p})`)}`;
         }
         if (l.default !== void 0 && !l.required) {
-          const P = (Array.isArray(l.type) ? `[${l.type[0]}]` : l.type) === "array" || Array.isArray(l.type) ? JSON.stringify(l.default) : l.default;
-          p += ` ${a.yellow(`[default: ${P}]`)}`;
+          const O = (Array.isArray(l.type) ? `[${l.type[0]}]` : l.type) === "array" || Array.isArray(l.type) ? JSON.stringify(l.default) : l.default;
+          c += ` ${a.yellow(`[default: ${O}]`)}`;
         }
-        this.io.log(p);
+        this.io.log(c);
       }
     }
     if (this.commandsExamples.length > 0) {
@@ -804,14 +533,14 @@ ${a.yellow("Options")}:`);
 ${a.yellow("Examples")}:`);
       let l = process.argv[0].split("/").pop();
       l === "node" && (l += " " + process.argv[1].split("/").pop());
-      for (const [d, p] of this.commandsExamples.entries())
-        d > 0 && this.io.log(""), this.io.log(`  ${p.description}
-`), this.io.log(`    ${a.green(`${l} ${p.command}`)}`);
+      for (const [d, c] of this.commandsExamples.entries())
+        d > 0 && this.io.log(""), this.io.log(`  ${c.description}
+`), this.io.log(`    ${a.green(`${l} ${c.command}`)}`);
     }
     return -1;
   }
 }
-class x {
+class v {
   _command;
   description;
   group;
@@ -828,125 +557,125 @@ class x {
   _handler;
   tmp;
   defaultOptions() {
-    return [new pe()];
+    return [new D()];
   }
-  newCommandParser(e) {
-    return new J({
-      io: e.io,
-      options: e.options,
-      arguments: e.arguments
+  newCommandParser(t) {
+    return new k({
+      io: t.io,
+      options: t.options,
+      arguments: t.arguments
     });
   }
-  newCommandIO(e) {
-    return new z(e.logger);
+  newCommandIO(t) {
+    return new S(t);
   }
-  constructor(e, t) {
-    this._command = e, this.description = t?.description ?? "", this.group = t?.group, this.tmp = {
-      options: t?.options ?? {},
-      arguments: t?.arguments ?? {}
+  constructor(t, e) {
+    this._command = t, this.description = e?.description ?? "", this.group = e?.group, this.tmp = {
+      options: e?.options ?? {},
+      arguments: e?.arguments ?? {}
     };
-    const r = this.defaultOptions();
-    if (r.length > 0)
-      for (const s of r)
-        this.tmp.options[s.option] = s;
+    const i = this.defaultOptions();
+    if (i.length > 0)
+      for (const n of i)
+        this.tmp.options[n.option] = n;
   }
   disablePrompting() {
     return this.disablePromptingFlag = !0, this;
   }
-  preHandler(e) {
-    return this._preHandler = e, this;
+  preHandler(t) {
+    return this._preHandler = t, this;
   }
-  handler(e) {
-    return this._handler = e, this;
+  handler(t) {
+    return this._handler = t, this;
   }
-  options(e) {
+  options(t) {
     return this.tmp = {
       options: {
         ...this.tmp?.options ?? {},
-        ...e
+        ...t
       },
       arguments: this.tmp?.arguments ?? {}
     }, this;
   }
-  arguments(e) {
+  arguments(t) {
     return this.tmp = {
       options: this.tmp?.options ?? {},
       arguments: {
         ...this.tmp?.arguments ?? {},
-        ...e
+        ...t
       }
     }, this;
   }
-  async run(e) {
+  async run(t) {
     if (!this._handler && !this.handle)
       throw new Error(`No handler defined for command ${this.command || "(unknown)"}`);
-    let t;
-    if (this.ctx = e.ctx, this.logger = e.logger, this.io = this.newCommandIO({
-      logger: e.logger
-    }), e && "args" in e) {
-      const i = this.tmp?.options ?? {};
+    let e;
+    if (this.ctx = t.ctx, this.logger = t.logger, this.io = this.newCommandIO({
+      logger: t.logger
+    }), t && "args" in t) {
+      const s = this.tmp?.options ?? {};
       for (const o of this.defaultOptions())
-        o.option in i || (i[o.option] = o);
+        o.option in s || (s[o.option] = o);
       this.parser = this.newCommandParser({
         io: this.io,
-        options: i,
+        options: s,
         arguments: this.tmp?.arguments ?? {}
-      }), t = this.parser.init(e.args);
+      }), e = this.parser.init(t.args);
       for (const o of this.defaultOptions())
-        if (t.options[o.option] === !0) {
-          const u = await o.handler.call(this);
-          if (u && u !== 0)
-            return u;
+        if (e.options[o.option] === !0) {
+          const m = await o.handler.call(this);
+          if (m && m !== 0)
+            return m;
         }
       this.disablePromptingFlag && this.parser.disablePrompting(), await this.parser.validate();
     } else
-      t = {
-        options: e.options,
-        arguments: e.arguments
+      e = {
+        options: t.options,
+        arguments: t.arguments
       };
-    const r = this.preHandle ? await this.preHandle() : null;
-    if (r && r !== 0)
-      return r;
+    const i = this.preHandle ? await this.preHandle() : null;
+    if (i && i !== 0)
+      return i;
     if (!this._handler && this.handle)
       this._handler = this.handle.bind(this);
     else if (!this._handler)
       throw new Error(`No handler defined for command ${this.command || "(unknown)"}`);
-    return await this._handler(e.ctx, t) ?? 0;
+    return await this._handler(t.ctx, e) ?? 0;
   }
 }
-class E extends J {
+class $ extends k {
   command;
-  constructor(e) {
-    const t = E.parseSignature(e.signature, e.helperDefinitions, e.defaultOptions);
+  constructor(t) {
+    const e = $.parseSignature(t.signature, t.helperDefinitions, t.defaultOptions);
     super({
-      io: e.io,
-      options: t.options,
-      arguments: t.arguments
-    }), this.command = t.command;
+      io: t.io,
+      options: e.options,
+      arguments: e.arguments
+    }), this.command = e.command;
   }
   /**
    * Parses command signature string into command name and parameter schemas
    * Example: "migrate {name} {--force}" -> { command: "migrate", arguments: {name: ...}, options: {force: ...} }
    */
-  static parseSignature(e, t, r) {
-    const [s, ...i] = e.split(/\{(.*?)\}/g).map((m) => m.trim()).filter(Boolean), o = {}, u = {};
-    for (const m of i) {
-      const { name: h, isOption: l, definition: d } = E.parseParamSignature(m, t);
-      l ? o[h] = d : u[h] = d;
+  static parseSignature(t, e, i) {
+    const [n, ...s] = t.split(/\{(.*?)\}/g).map((u) => u.trim()).filter(Boolean), o = {}, m = {};
+    for (const u of s) {
+      const { name: h, isOption: l, definition: d } = $.parseParamSignature(u, e);
+      l ? o[h] = d : m[h] = d;
     }
-    for (const m of r)
-      o[m.option] = {
-        type: m.type,
-        required: m.required,
-        alias: m.alias,
-        variadic: m.variadic ?? !1,
-        description: m.description,
-        default: m.default ?? null
+    for (const u of i)
+      o[u.option] = {
+        type: u.type,
+        required: u.required,
+        alias: u.alias,
+        variadic: u.variadic ?? !1,
+        description: u.description,
+        default: u.default ?? null
       };
     return {
-      command: s,
+      command: n,
       options: o,
-      arguments: u
+      arguments: m
     };
   }
   /**
@@ -963,38 +692,38 @@ class E extends J {
    * - {--opt=}       -> string option
    * - {--opt|o}      -> option with alias
    */
-  static parseParamSignature(e, t) {
-    let r = e, s = !1;
-    const i = {
+  static parseParamSignature(t, e) {
+    let i = t, n = !1;
+    const s = {
       required: !0,
       type: "string",
       description: void 0,
       default: null,
       variadic: !1
     };
-    if (r.includes(":")) {
-      const [o, u] = r.split(":");
-      r = o.trim(), i.description = u.trim();
+    if (i.includes(":")) {
+      const [o, m] = i.split(":");
+      i = o.trim(), s.description = m.trim();
     }
-    if (r.includes("=")) {
-      const [o, u] = r.split("=");
-      r = o.trim(), i.default = u.trim(), i.required = !1, typeof i.default == "string" && !i.default.length ? i.default = null : i.default === "true" ? (i.default = !0, i.type = "boolean") : i.default === "false" && (i.default = !1, i.type = "boolean");
-    } else r.startsWith("--") && (i.required = !1, i.default = !1, i.type = "boolean");
-    if (r.includes("|")) {
-      const [o, ...u] = r.split("|");
-      r = o.trim(), i.alias = u.map((m) => m.trim());
+    if (i.includes("=")) {
+      const [o, m] = i.split("=");
+      i = o.trim(), s.default = m.trim(), s.required = !1, typeof s.default == "string" && !s.default.length ? s.default = null : s.default === "true" ? (s.default = !0, s.type = "boolean") : s.default === "false" && (s.default = !1, s.type = "boolean");
+    } else i.startsWith("--") && (s.required = !1, s.default = !1, s.type = "boolean");
+    if (i.includes("|")) {
+      const [o, ...m] = i.split("|");
+      i = o.trim(), s.alias = m.map((u) => u.trim());
     }
-    return r.startsWith("--") && (s = !0, r = r.slice(2)), i.default === "*" && (i.default = [], i.type = ["string"]), r.endsWith("?") && (i.required = !1, r = r.slice(0, -1)), r.endsWith("*") && (i.type = ["string"], i.variadic = !0, i.default = [], r = r.slice(0, -1)), i.description = i.description ?? t[r] ?? t[`--${r}`], { name: r, isOption: s, definition: i };
+    return i.startsWith("--") && (n = !0, i = i.slice(2)), s.default === "*" && (s.default = [], s.type = ["string"]), i.endsWith("?") && (s.required = !1, i = i.slice(0, -1)), i.endsWith("*") && (s.type = ["string"], s.variadic = !0, s.default = [], i = i.slice(0, -1)), s.description = s.description ?? e[i] ?? e[`--${i}`], { name: i, isOption: n, definition: s };
   }
 }
-class $e extends x {
+class z extends v {
   helperDefinitions = {};
   get command() {
     return this.parser ? this.parser.command : this.signature.split(" ")[0];
   }
-  newCommandParser(e) {
-    return new E({
-      io: e.io,
+  newCommandParser(t) {
+    return new $({
+      io: t.io,
       signature: this.signature,
       helperDefinitions: this.helperDefinitions,
       defaultOptions: this.defaultOptions()
@@ -1003,66 +732,109 @@ class $e extends x {
   constructor() {
     super("");
   }
-  option(e, t = null) {
-    return this.parser.option(e, t);
+  option(t, e = null) {
+    return this.parser.option(t, e);
   }
-  argument(e, t = null) {
-    return this.parser.argument(e, t);
+  argument(t, e = null) {
+    return this.parser.argument(t, e);
   }
   // Prompt utils
-  async askForConfirmation(...e) {
-    return this.io.askForConfirmation(...e);
+  async askForConfirmation(...t) {
+    return this.io.askForConfirmation(...t);
   }
-  async askForInput(...e) {
-    return this.io.askForInput(...e);
+  async askForInput(...t) {
+    return this.io.askForInput(...t);
   }
-  async askForSelect(...e) {
-    return this.io.askForSelect(...e);
+  async askForSelect(...t) {
+    return this.io.askForSelect(...t);
   }
-  newLoader(...e) {
-    return this.io.newLoader(...e);
+  newLoader(...t) {
+    return this.io.newLoader(...t);
   }
 }
-class K {
+class N {
   level;
-  constructor(e = {}) {
-    this.level = e.level ?? "info";
+  constructor(t = {}) {
+    this.level = t.level ?? "info";
   }
-  shouldLog(e) {
-    const t = ["debug", "info", "warn", "error"], r = t.indexOf(this.level);
-    return t.indexOf(e) >= r;
+  shouldLog(t) {
+    const e = ["debug", "info", "warn", "error"], i = e.indexOf(this.level);
+    return e.indexOf(t) >= i;
   }
-  setLevel(e) {
-    this.level = e;
+  setLevel(t) {
+    this.level = t;
   }
   getLevel() {
     return this.level;
   }
-  log(...e) {
-    console.log(...e);
+  log(...t) {
+    console.log(...t);
   }
-  info(...e) {
-    this.shouldLog("info") && console.log(...e);
+  info(...t) {
+    this.shouldLog("info") && console.log(...t);
   }
-  warn(...e) {
-    this.shouldLog("warn") && console.warn(...e);
+  warn(...t) {
+    this.shouldLog("warn") && console.warn(...t);
   }
-  error(...e) {
-    this.shouldLog("error") && console.error(...e);
+  error(...t) {
+    this.shouldLog("error") && console.error(...t);
   }
-  debug(...e) {
-    this.shouldLog("debug") && console.log(...e);
+  debug(...t) {
+    this.shouldLog("debug") && console.log(...t);
   }
 }
-class ge {
+class H {
+  /**
+   * Generate bigrams (character pairs) from a string
+   */
+  getBigrams(t) {
+    const e = [], i = t.toLowerCase();
+    for (let n = 0; n < i.length - 1; n++)
+      e.push(i.slice(n, n + 2));
+    return e;
+  }
+  /**
+   * Calculate Dice's Coefficient similarity between two strings (0-1 scale)
+   */
+  calculateSimilarity(t, e) {
+    if (t === e) return 1;
+    if (t.length < 2 || e.length < 2) return 0;
+    const i = this.getBigrams(t), n = this.getBigrams(e), s = new Set(n);
+    let o = 0;
+    for (const m of i)
+      s.has(m) && (o++, s.delete(m));
+    return 2 * o / (i.length + n.length);
+  }
+  /**
+   * Find best matching string and ratings for all candidates
+   */
+  findBestMatch(t, e) {
+    const i = e.map((o) => ({
+      target: o,
+      rating: this.calculateSimilarity(t, o)
+    }));
+    let n = 0, s = i[0]?.rating ?? 0;
+    for (let o = 1; o < i.length; o++)
+      i[o].rating > s && (s = i[o].rating, n = o);
+    return {
+      ratings: i,
+      bestMatch: i[n],
+      bestMatchIndex: n
+    };
+  }
+}
+class j {
   commands = {};
   io;
   logger;
-  get CommandIOClass() {
-    return z;
+  stringSimilarity;
+  newCommandIO(t) {
+    return new S(t);
   }
-  constructor(e) {
-    this.logger = e ?? new K(), this.io = new this.CommandIOClass(this.logger);
+  constructor(t) {
+    this.logger = t?.logger ?? new N(), this.io = this.newCommandIO({
+      logger: this.logger
+    }), this.stringSimilarity = t?.stringSimilarity ?? new H();
   }
   getAvailableCommands() {
     return Object.keys(this.commands);
@@ -1070,188 +842,189 @@ class ge {
   getCommands() {
     return Object.values(this.commands);
   }
-  importFile = async (e) => (await import(e)).default;
-  commandResolver = async (e) => {
-    let t = await this.importFile(e);
-    if (!t)
-      throw new Error(`The command at path ${e} does not have a default export.`);
-    return t && typeof t == "object" && "default" in t && (t = t.default), typeof t == "function" ? new t() : t instanceof x ? t : null;
+  importFile = async (t) => (await import(t)).default;
+  commandResolver = async (t) => {
+    let e = await this.importFile(t);
+    if (!e)
+      throw new Error(`The command at path ${t} does not have a default export.`);
+    return e && typeof e == "object" && "default" in e && (e = e.default), typeof e == "function" ? new e() : e instanceof v ? e : null;
   };
-  withCommandResolver(e) {
-    return this.commandResolver = e, this;
+  withCommandResolver(t) {
+    return this.commandResolver = t, this;
   }
-  withFileImporter(e) {
-    return this.importFile = e, this;
+  withFileImporter(t) {
+    return this.importFile = t, this;
   }
-  registerCommand(e, t = !1) {
-    const r = e.command;
-    if (!r)
+  registerCommand(t, e = !1) {
+    const i = t.command;
+    if (!i)
       throw new Error("Command signature is invalid, it must have a command name.");
-    if (!t && this.commands[r])
-      throw new Error(`Command ${r} already registered.`);
-    this.commands[r] = e;
+    if (!e && this.commands[i])
+      throw new Error(`Command ${i} already registered.`);
+    this.commands[i] = t;
   }
-  async loadCommandsPath(e) {
-    for await (const t of this.listCommandsFiles(e))
+  async loadCommandsPath(t) {
+    for await (const e of this.listCommandsFiles(t))
       try {
-        const r = await this.commandResolver(t);
-        r instanceof x && this.registerCommand(r);
-      } catch (r) {
-        throw new Error(`Command ${t} failed to load. ${r}`, {
-          cause: r
+        const i = await this.commandResolver(e);
+        i instanceof v && this.registerCommand(i);
+      } catch (i) {
+        throw new Error(`Command ${e} failed to load. ${i}`, {
+          cause: i
         });
       }
   }
-  async runCommand(e, t, ...r) {
-    const s = typeof t == "string" ? this.commands[t] : t, i = typeof t == "string" ? t : s.command;
-    if (!s) {
-      const o = await this.suggestCommand(i);
-      return o ? await this.runCommand(e, o, ...r) : 1;
+  async runCommand(t, e, ...i) {
+    const n = typeof e == "string" ? this.commands[e] : e, s = typeof e == "string" ? e : n.command;
+    if (!n) {
+      const o = await this.suggestCommand(s);
+      return o ? await this.runCommand(t, o, ...i) : 1;
     }
-    return await s.run({
-      ctx: e,
+    return await n.run({
+      ctx: t,
       logger: this.logger,
-      args: r
+      args: i
     }) ?? 0;
   }
-  async suggestCommand(e) {
-    const t = this.getAvailableCommands(), { bestMatch: r, bestMatchIndex: s, ratings: i } = ee.findBestMatch(e, t), o = i.filter((u) => u.rating > 0.3).map((u) => u.target);
-    if (r.rating > 0 && o.length <= 1 || r.rating > 0.7 && o.length > 1) {
-      const u = t[s];
-      return await this.askRunSimilarCommand(e, u) ? u : null;
+  async suggestCommand(t) {
+    const e = this.getAvailableCommands(), { bestMatch: i, bestMatchIndex: n, ratings: s } = this.stringSimilarity.findBestMatch(t, e), o = s.filter((m) => m.rating > 0.3).map((m) => m.target);
+    if (i.rating > 0 && o.length <= 1 || i.rating > 0.7 && o.length > 1) {
+      const m = e[n];
+      return await this.askRunSimilarCommand(t, m) ? m : null;
     }
     if (o.length) {
-      this.io.error(`${a.bgRed(" ERROR ")} Command ${a.yellow(e)} not found.
+      this.io.error(`${a.bgRed(" ERROR ")} Command ${a.yellow(t)} not found.
 `);
-      const u = await this.io.askForSelect(a.green("Did you mean to run one of these commands instead?"), o);
-      if (u)
-        return u;
+      const m = await this.io.askForSelect(a.green("Did you mean to run one of these commands instead?"), o);
+      if (m)
+        return m;
     }
-    throw new he(e);
-  }
-  async askRunSimilarCommand(e, t) {
-    return this.io.error(`${a.bgRed(" ERROR ")} Command ${a.yellow(e)} not found.
-`), this.io.askForConfirmation(`${a.green(`Do you want to run ${a.yellow(t)} instead?`)} `);
-  }
-  async *listCommandsFiles(e) {
-    const t = Z.readdirSync(e, { withFileTypes: !0 });
-    for (const r of t) {
-      const s = I.resolve(e, r.name);
-      if (r.isDirectory())
-        yield* this.listCommandsFiles(I.resolve(e, r.name));
+    throw new P(t);
+  }
+  async askRunSimilarCommand(t, e) {
+    return this.io.error(`${a.bgRed(" ERROR ")} Command ${a.yellow(t)} not found.
+`), this.io.askForConfirmation(`${a.green(`Do you want to run ${a.yellow(e)} instead?`)} `);
+  }
+  async *listCommandsFiles(t) {
+    const e = I.readdirSync(t, { withFileTypes: !0 });
+    for (const i of e) {
+      const n = R.resolve(t, i.name);
+      if (i.isDirectory())
+        yield* this.listCommandsFiles(R.resolve(t, i.name));
       else {
-        if (!s.endsWith(".ts") && !s.endsWith(".js") && !s.endsWith(".mjs") && !s.endsWith(".cjs"))
+        if (!n.endsWith(".ts") && !n.endsWith(".js") && !n.endsWith(".mjs") && !n.endsWith(".cjs"))
           continue;
-        yield s;
+        yield n;
       }
     }
   }
 }
-class fe {
+class W {
   logger;
-  constructor(e) {
-    this.logger = e;
+  constructor(t) {
+    this.logger = t;
   }
-  handle(e) {
-    if (e instanceof w)
-      return e.pretty(this.logger), -1;
-    throw e;
+  handle(t) {
+    if (t instanceof f)
+      return t.pretty(this.logger), -1;
+    throw t;
   }
 }
-class ye extends x {
-  constructor(e) {
+class M extends v {
+  constructor(t) {
     super("help", {
       description: a.bold("Show help information about the CLI and its commands")
-    }), this.opts = e;
+    }), this.opts = t;
   }
   async handle() {
-    const e = this.opts.commandRegistry.getCommands(), t = this.opts.cliName ?? "Bob CLI", r = this.opts.cliVersion ?? "0.0.0", s = (await import("./package-CtFSlXKR.js"))?.default?.version ?? "0.0.0";
-    this.io.log(`${t} ${a.green(r)} (core: ${a.yellow(s)})
+    const t = this.opts.commandRegistry.getCommands(), e = this.opts.cliName ?? "Bob CLI", i = this.opts.cliVersion ?? "0.0.0", n = (await import("./package-C-2LYcDa.js"))?.default?.version ?? "0.0.0";
+    this.io.log(`${e} ${a.green(i)} (core: ${a.yellow(n)})
 
 ${a.yellow("Usage")}:
   command [options] [arguments]
 
 ${a.yellow("Available commands")}:
 `);
-    const i = Math.max(...e.map((m) => m.command.length)) ?? 0, o = {};
-    for (const m of e) {
-      const h = m.group ?? m.command.split(":")[0];
-      o[h] || (o[h] = []), o[h].push(m);
+    const s = Math.max(...t.map((u) => u.command.length)) ?? 0, o = {};
+    for (const u of t) {
+      const h = u.group ?? u.command.split(":")[0];
+      o[h] || (o[h] = []), o[h].push(u);
     }
-    const u = Object.entries(o).sort(([m], [h]) => m.toLowerCase().localeCompare(h.toLowerCase())).sort(([, m], [, h]) => m.length - h.length);
-    for (const [m, h] of u) {
+    const m = Object.entries(o).sort(([u], [h]) => u.toLowerCase().localeCompare(h.toLowerCase())).sort(([, u], [, h]) => u.length - h.length);
+    for (const [u, h] of m) {
       const l = h.length > 1;
-      l && this.io.log(a.yellow(`${m}:`));
-      const d = h.sort((p, g) => p.command.toLowerCase().localeCompare(g.command.toLowerCase()));
-      for (const p of d) {
-        let g = j(i - p.command.length);
-        l && (g = g.slice(2)), this.io.log(`${l ? "  " : ""}${a.green(p.command)} ${g} ${p.description}`);
+      l && this.io.log(a.yellow(`${u}:`));
+      const d = h.sort((c, p) => c.command.toLowerCase().localeCompare(p.command.toLowerCase()));
+      for (const c of d) {
+        let p = A(s - c.command.length);
+        l && (p = p.slice(2)), this.io.log(`${l ? "  " : ""}${a.green(c.command)} ${p} ${c.description}`);
       }
     }
   }
 }
-class Ce {
+class J {
   ctx;
   logger;
   commandRegistry;
   exceptionHandler;
   helpCommand;
-  newCommandRegistry(e) {
-    return new ge(e.logger);
+  newCommandRegistry(t) {
+    return new j(t);
   }
-  newHelpCommand(e) {
-    return new ye(e);
+  newHelpCommand(t) {
+    return new M(t);
   }
-  newExceptionHandler(e) {
-    return new fe(e.logger);
+  newExceptionHandler(t) {
+    return new W(t.logger);
   }
-  constructor(e = {}) {
-    this.ctx = e.ctx, this.logger = e.logger ?? new K(), this.commandRegistry = this.newCommandRegistry({
+  constructor(t = {}) {
+    this.ctx = t.ctx, this.logger = t.logger ?? new N(), this.commandRegistry = this.newCommandRegistry({
       logger: this.logger
     }), this.exceptionHandler = this.newExceptionHandler({
       logger: this.logger
     }), this.helpCommand = this.newHelpCommand({
-      cliName: e.name,
-      cliVersion: e.version,
+      cliName: t.name,
+      cliVersion: t.version,
       commandRegistry: this.commandRegistry
     });
   }
-  withCommandResolver(e) {
-    return this.commandRegistry.withCommandResolver(e), this;
+  withCommandResolver(t) {
+    return this.commandRegistry.withCommandResolver(t), this;
   }
-  withFileImporter(e) {
-    return this.commandRegistry.withFileImporter(e), this;
+  withFileImporter(t) {
+    return this.commandRegistry.withFileImporter(t), this;
   }
-  async withCommands(...e) {
-    for (const t of e)
-      typeof t == "string" ? await this.commandRegistry.loadCommandsPath(t) : typeof t == "function" ? this.registerCommand(new t()) : this.registerCommand(t);
+  async withCommands(...t) {
+    for (const e of t)
+      typeof e == "string" ? await this.commandRegistry.loadCommandsPath(e) : typeof e == "function" ? this.registerCommand(new e()) : this.registerCommand(e);
   }
-  async runCommand(e, ...t) {
-    return e ? await this.commandRegistry.runCommand(this.ctx ?? {}, e, ...t).catch(this.exceptionHandler.handle.bind(this.exceptionHandler)) : await this.runHelpCommand();
+  async runCommand(t, ...e) {
+    return t ? await this.commandRegistry.runCommand(this.ctx ?? {}, t, ...e).catch(this.exceptionHandler.handle.bind(this.exceptionHandler)) : await this.runHelpCommand();
   }
   async runHelpCommand() {
     return await this.runCommand(this.helpCommand);
   }
-  registerCommand(e) {
-    this.commandRegistry.registerCommand(e);
+  registerCommand(t) {
+    this.commandRegistry.registerCommand(t);
   }
 }
 export {
-  B as BadCommandOption,
-  Ae as BadCommandParameter,
-  w as BobError,
-  Ce as Cli,
-  x as Command,
-  z as CommandIO,
-  he as CommandNotFoundError,
-  J as CommandParser,
-  ge as CommandRegistry,
-  E as CommandSignatureParser,
-  $e as CommandWithSignature,
-  fe as ExceptionHandler,
-  pe as HelpOption,
-  k as InvalidOption,
-  K as Logger,
-  Y as MissingRequiredArgumentValue,
-  ce as MissingRequiredOptionValue
+  C as BadCommandOption,
+  U as BadCommandParameter,
+  f as BobError,
+  J as Cli,
+  v as Command,
+  S as CommandIO,
+  P as CommandNotFoundError,
+  k as CommandParser,
+  j as CommandRegistry,
+  $ as CommandSignatureParser,
+  z as CommandWithSignature,
+  W as ExceptionHandler,
+  D as HelpOption,
+  b as InvalidOption,
+  N as Logger,
+  F as MissingRequiredArgumentValue,
+  V as MissingRequiredOptionValue,
+  H as StringSimilarity
 };