bob-core 1.4.0 → 2.0.0-beta.10

package/dist/esm/index.js

@@ -1,437 +1,1058 @@
-import b from "minimist";
-import o from "chalk";
-import f from "prompts";
-import * as R from "node:fs";
-import $ from "path";
-import * as O from "string-similarity";
-class c extends Error {
+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 {
+  logger;
+  constructor(e) {
+    this.logger = e;
+  }
+  /**
+   * Logger methods
+   */
+  log(...e) {
+    this.logger.log(...e);
+  }
+  info(...e) {
+    this.logger.info(...e);
+  }
+  warn(...e) {
+    this.logger.warn(...e);
+  }
+  error(...e) {
+    this.logger.error(...e);
+  }
+  debug(...e) {
+    this.logger.debug(...e);
+  }
+  /**
+   * Prompt utils
+   */
+  async askForConfirmation(e = "Do you want to continue?", t) {
+    return (await b({
+      type: "confirm",
+      name: "value",
+      message: e,
+      initial: t ?? !1
+    })).value;
+  }
+  async askForInput(e, t, n) {
+    return (await b({
+      type: "text",
+      name: "value",
+      message: e,
+      initial: t,
+      ...n
+    }))?.value ?? null;
+  }
+  async askForDate(e, t, n) {
+    return (await b({
+      type: "date",
+      name: "value",
+      message: e,
+      initial: t,
+      ...n
+    }))?.value ?? null;
+  }
+  async askForList(e, t, n) {
+    return (await b({
+      type: "list",
+      name: "value",
+      message: e,
+      initial: t,
+      ...n
+    }))?.value ?? null;
+  }
+  async askForToggle(e, t, n) {
+    return (await b({
+      type: "toggle",
+      name: "value",
+      message: e,
+      initial: t,
+      ...n
+    }))?.value ?? null;
+  }
+  async askForSelect(e, t, n) {
+    if (t.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({
+      type: "select",
+      name: "value",
+      message: e,
+      choices: s,
+      ...n
+    }))?.value ?? null;
+  }
+  newLoader(e = "", t = ["⠙", "⠘", "⠰", "⠴", "⠤", "⠦", "⠆", "⠃", "⠋", "⠉"], n = 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;
+    }, n), m = () => {
+      clearInterval(u), process.stdout.write(new TextEncoder().encode("\r" + " ".repeat(s.length + 5) + "\r"));
+    };
+    return {
+      [Symbol.dispose]: m,
+      [Symbol.asyncDispose]: m,
+      updateText: (h) => {
+        i = s, s = h;
+      },
+      stop: m
+    };
+  }
 }
-class v extends c {
-  constructor(t) {
-    super(`Argument "${t.name}" is required.`), this.paramSignature = t;
+const E = 10, L = (r = 0) => (e) => `\x1B[${e + r}m`, M = (r = 0) => (e) => `\x1B[${38 + r};5;${e}m`, q = (r = 0) => (e, t, n) => `\x1B[${38 + r};2;${e};${t};${n}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]
   }
-  pretty() {
-    const t = console.log;
-    t(o`{white.bgRed  ERROR } Argument {bold.yellow ${this.paramSignature.name}} is required.`);
+};
+Object.keys(c.modifier);
+const te = Object.keys(c.color), ne = Object.keys(c.bgColor);
+[...te, ...ne];
+function re() {
+  const r = /* @__PURE__ */ new Map();
+  for (const [e, t] of Object.entries(c)) {
+    for (const [n, s] of Object.entries(t))
+      c[n] = {
+        open: `\x1B[${s[0]}m`,
+        close: `\x1B[${s[1]}m`
+      }, t[n] = c[n], r.set(s[0], s[1]);
+    Object.defineProperty(c, e, {
+      value: t,
+      enumerable: !1
+    });
   }
+  return Object.defineProperty(c, "codes", {
+    value: r,
+    enumerable: !1
+  }), c.color.close = "\x1B[39m", c.bgColor.close = "\x1B[49m", c.color.ansi = L(), c.color.ansi256 = M(), c.color.ansi16m = q(), c.bgColor.ansi = L(E), c.bgColor.ansi256 = M(E), c.bgColor.ansi16m = q(E), Object.defineProperties(c, {
+    rgbToAnsi256: {
+      value(e, t, n) {
+        return e === t && t === n ? 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(n / 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 [n] = t;
+        n.length === 3 && (n = [...n].map((i) => i + i).join(""));
+        const s = Number.parseInt(n, 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, n, s;
+        if (e >= 232)
+          t = ((e - 232) * 10 + 8) / 255, n = t, s = t;
+        else {
+          e -= 16;
+          const u = e % 36;
+          t = Math.floor(e / 36) / 5, n = Math.floor(u / 6) / 5, s = u % 6 / 5;
+        }
+        const i = Math.max(t, n, s) * 2;
+        if (i === 0)
+          return 30;
+        let o = 30 + (Math.round(s) << 2 | Math.round(n) << 1 | Math.round(t));
+        return i === 2 && (o += 60), o;
+      },
+      enumerable: !1
+    },
+    rgbToAnsi: {
+      value: (e, t, n) => c.ansi256ToAnsi(c.rgbToAnsi256(e, t, n)),
+      enumerable: !1
+    },
+    hexToAnsi: {
+      value: (e) => c.ansi256ToAnsi(c.hexToAnsi256(e)),
+      enumerable: !1
+    }
+  }), c;
 }
-class y extends c {
-  constructor(t, e) {
-    super(`Missing ${t} in the command signature`), this.option = t, this.optionsSignature = e;
-  }
-  pretty() {
-    const t = console.log;
-    if (this.optionsSignature.length) {
-      t(o`{yellow Available options}:`);
-      for (const e of this.optionsSignature) {
-        const n = e.type ? o`{white (${e.type})}` : "", s = " ".repeat(20 - e.name.length);
-        t(o`  {green ${e.name}} ${s} ${e.help ?? "\b"} ${n}`);
-      }
-      t("");
+const f = re(), D = (() => {
+  if (!("navigator" in globalThis))
+    return 0;
+  if (globalThis.navigator.userAgentData) {
+    const r = navigator.userAgentData.brands.find(({ brand: e }) => e === "Chromium");
+    if (r && r.version > 93)
+      return 3;
+  }
+  return /\b(Chrome|Chromium)\//.test(globalThis.navigator.userAgent) ? 1 : 0;
+})(), V = D !== 0 && {
+  level: D
+}, se = {
+  stdout: V,
+  stderr: V
+};
+function ie(r, e, t) {
+  let n = r.indexOf(e);
+  if (n === -1)
+    return r;
+  const s = e.length;
+  let i = 0, o = "";
+  do
+    o += r.slice(i, n) + e + t, i = n + s, n = r.indexOf(e, i);
+  while (n !== -1);
+  return o += r.slice(i), o;
+}
+function oe(r, e, t, n) {
+  let s = 0, i = "";
+  do {
+    const o = r[n - 1] === "\r";
+    i += r.slice(s, o ? n - 1 : n) + e + (o ? `\r
+` : `
+`) + t, s = n + 1, n = r.indexOf(`
+`, s);
+  } while (n !== -1);
+  return i += r.slice(s), i;
+}
+const { stdout: H, stderr: W } = se, S = Symbol("GENERATOR"), $ = Symbol("STYLER"), O = Symbol("IS_EMPTY"), G = [
+  "ansi",
+  "ansi",
+  "ansi256",
+  "ansi16m"
+], A = /* @__PURE__ */ Object.create(null), ae = (r, 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;
+  r.level = e.level === void 0 ? t : e.level;
+}, le = (r) => {
+  const e = (...t) => t.join(" ");
+  return ae(e, r), Object.setPrototypeOf(e, R.prototype), e;
+};
+function R(r) {
+  return le(r);
+}
+Object.setPrototypeOf(R.prototype, Function.prototype);
+for (const [r, e] of Object.entries(f))
+  A[r] = {
+    get() {
+      const t = x(this, N(e.open, e.close, this[$]), this[O]);
+      return Object.defineProperty(this, r, { value: t }), t;
     }
-    t(o`{white.bgRed  ERROR } Option {bold.yellow ${this.option}} is missing in the signature.`);
+  };
+A.visible = {
+  get() {
+    const r = x(this, this[$], !0);
+    return Object.defineProperty(this, "visible", { value: r }), r;
   }
+};
+const T = (r, e, t, ...n) => r === "rgb" ? e === "ansi16m" ? f[t].ansi16m(...n) : e === "ansi256" ? f[t].ansi256(f.rgbToAnsi256(...n)) : f[t].ansi(f.rgbToAnsi(...n)) : r === "hex" ? T("rgb", e, t, ...f.hexToRgb(...n)) : f[t][r](...n), ue = ["rgb", "hex", "ansi256"];
+for (const r of ue) {
+  A[r] = {
+    get() {
+      const { level: t } = this;
+      return function(...n) {
+        const s = N(T(r, G[t], "color", ...n), f.color.close, this[$]);
+        return x(this, s, this[O]);
+      };
+    }
+  };
+  const e = "bg" + r[0].toUpperCase() + r.slice(1);
+  A[e] = {
+    get() {
+      const { level: t } = this;
+      return function(...n) {
+        const s = N(T(r, G[t], "bgColor", ...n), f.bgColor.close, this[$]);
+        return x(this, s, this[O]);
+      };
+    }
+  };
 }
-class w extends c {
-  constructor(t, e) {
-    super(`Missing ${t} in the command signature`), this.argument = t, this.argumentSignatures = e;
-  }
-  pretty() {
-    const t = console.log;
-    if (this.argumentSignatures.length) {
-      t(o`\n{yellow Available arguments}:`);
-      for (const e of this.argumentSignatures) {
-        const n = e.type ? o`{white (${e.type})}` : "", s = " ".repeat(20 - e.name.length);
-        t(o`  {green ${e.name}} ${s} ${e.help ?? "\b"} ${n}`);
-      }
-      t("");
+const me = Object.defineProperties(() => {
+}, {
+  ...A,
+  level: {
+    enumerable: !0,
+    get() {
+      return this[S].level;
+    },
+    set(r) {
+      this[S].level = r;
     }
-    t(o`{white.bgRed  ERROR } Argument {bold.yellow ${this.argument}} is missing in the signature.`);
   }
+}), N = (r, e, t) => {
+  let n, s;
+  return t === void 0 ? (n = r, s = e) : (n = t.openAll + r, s = e + t.closeAll), {
+    open: r,
+    close: e,
+    openAll: n,
+    closeAll: s,
+    parent: t
+  };
+}, x = (r, e, t) => {
+  const n = (...s) => de(n, s.length === 1 ? "" + s[0] : s.join(" "));
+  return Object.setPrototypeOf(n, me), n[S] = r, n[$] = e, n[O] = t, n;
+}, de = (r, e) => {
+  if (r.level <= 0 || !e)
+    return r[O] ? "" : e;
+  let t = r[$];
+  if (t === void 0)
+    return e;
+  const { openAll: n, 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, n, i)), n + e + s;
+};
+Object.defineProperties(R.prototype, A);
+const a = R();
+R({ level: W ? W.level : 0 });
+class w extends Error {
+}
+function _(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);
+}
+function U(r) {
+  return !Array.isArray(r) && typeof r == "object" && r.type ? r.default !== void 0 ? r.default : _(r.type) : _(r);
 }
-class A extends c {
-  constructor(t, e) {
-    super(`Invalid option ${t} in not recognized`), this.option = t, this.optionsSignature = e;
-  }
-  pretty() {
-    const t = console.log;
-    if (this.optionsSignature.length > 0) {
-      t(o`\n{yellow Available options}:`);
-      for (const e of this.optionsSignature) {
-        const n = e.type ? o`{white (${e.type})}` : "", s = `--${e.name}${e.alias?.map((i) => `, -${i}`).join("") ?? ""}`, r = " ".repeat(30 - s.length);
-        t(o`  {green ${s}} ${r} ${e.help ?? "\b"} ${n}`);
+function y(r) {
+  return typeof r == "string" || Array.isArray(r) ? {
+    alias: [],
+    default: U(r),
+    description: "",
+    required: !1,
+    secret: !1,
+    type: r,
+    variadic: !1
+  } : {
+    alias: r.alias ? Array.isArray(r.alias) ? r.alias : [r.alias] : [],
+    default: r.default ?? U(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(`
+${a.yellow("Available options")}:`);
+      for (const [n, 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 = `--${n}${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})`)}`);
       }
-      t("");
+      e.log("");
     }
-    t(o`{white.bgRed  ERROR } Option {bold.yellow ${this.option}} is not recognized.`);
+    e.log(`${a.white.bgRed(" ERROR ")} Option ${a.bold.yellow(this.option)} is not recognized.`);
   }
 }
-class x {
-  constructor(t, e, n, s, ...r) {
-    this.io = t, this.signature = e, this.helperDefinitions = n, this.defaultCommandOptions = s;
-    const [i, ...m] = e.split(/\{(.*?)\}/g).map((p) => p.trim()).filter(Boolean), { _: a, ...l } = b(r);
-    this.command = i, this.parseSignature(m), this.parseDefaultOptions(), this.handleArguments(a), this.handleOptions(l);
+class Y extends w {
+  constructor(e) {
+    super(`Argument "${e}" is required.`), this.argument = e;
   }
-  command;
-  arguments = {};
-  options = {};
-  argumentsSignature = {};
-  optionSignatures = {};
-  optionAliases = {};
-  option(t) {
-    if (!this.optionSignatures[t])
-      throw new y(t, Object.values(this.optionSignatures));
-    return this.options[t];
-  }
-  setOption(t, e) {
-    if (!this.optionSignatures[t])
-      throw new y(t, Object.values(this.optionSignatures));
-    this.options[t] = e;
-  }
-  optionHelp(t) {
-    if (!this.optionSignatures[t])
-      throw new y(t, Object.values(this.optionSignatures));
-    return this.optionSignatures[t].help;
-  }
-  argument(t) {
-    if (!this.argumentsSignature[t])
-      throw new w(t, Object.values(this.argumentsSignature));
-    return this.arguments[t];
-  }
-  setArgument(t, e) {
-    if (!this.argumentsSignature[t])
-      throw new w(t, Object.values(this.argumentsSignature));
-    this.arguments[t] = e;
-  }
-  argumentHelp(t) {
-    if (!this.argumentsSignature[t])
-      throw new w(t, Object.values(this.argumentsSignature));
-    return this.argumentsSignature[t].help;
-  }
-  getArgumentSignatures() {
-    return this.argumentsSignature;
-  }
-  getOptionSignatures() {
-    return this.optionSignatures;
-  }
-  getParamValue(t, e) {
-    return e.type === "boolean" ? t === "true" || t === "1" ? !0 : t === "false" || t === "0" ? !1 : !!t : e.type === "array" ? t ? Array.isArray(t) ? t : [t] : [] : t ?? e.defaultValue;
-  }
-  handleArguments(t) {
-    for (const [e, n] of Object.entries(this.arguments)) {
-      const s = this.argumentsSignature[e];
-      if (s.variadic)
-        this.arguments[e] = t;
-      else {
-        const r = t.shift();
-        this.arguments[e] = this.getParamValue(r, s);
+  pretty(e) {
+    e.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;
+  }
+  pretty(e) {
+    e.log(`${a.white.bgRed(" ERROR ")} Option ${a.bold.yellow(this.option)} is required.`);
+  }
+}
+class $e 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;
+  }
+  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}`);
+  }
+}
+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;
+  }
+  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}`);
+  }
+}
+class he extends w {
+  constructor(e) {
+    super(`Command "${e}" not found.`), this.command = e;
+  }
+  pretty(e) {
+    e.log(`${a.bgRed(" ERROR ")} Command ${a.yellow(this.command)} not found.`);
+  }
+}
+function C(r, e, t, n) {
+  if (r == null)
+    return n ?? null;
+  if (e === "string")
+    return String(r);
+  if (e === "number") {
+    const s = Number(r);
+    if (isNaN(s))
+      throw new B({
+        option: t,
+        reason: `Expected a number, got "${r}"`
+      });
+    return s;
+  }
+  if (e === "boolean")
+    return typeof r == "boolean" ? r : r === "true" || r === "1" ? !0 : r === "false" || r === "0" ? !1 : !!r;
+  if (Array.isArray(e)) {
+    const s = e[0], i = Array.isArray(r) ? r : [r];
+    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,
+            reason: `Expected array of numbers, got "${o}" in array`
+          });
+        return u;
+      });
+  }
+  return r;
+}
+class J {
+  options;
+  parsedOptions = null;
+  arguments;
+  parsedArguments = null;
+  io;
+  shouldPromptForMissingOptions = !0;
+  constructor(e) {
+    this.options = e.options, this.arguments = e.arguments, this.io = e.io;
+  }
+  // === PUBLIC METHODS ===
+  /**
+   * Parses raw command-line arguments into structured options and arguments
+   * @param args - Raw command line arguments (typically from process.argv.slice(2))
+   * @returns Object containing parsed options and arguments
+   * @throws {InvalidOption} If an unknown option is provided
+   * @throws {BadCommandOption} If a value cannot be converted to the expected type
+   */
+  init(e) {
+    const { _: t, ...n } = X(e);
+    return this.validateUnknownOptions(n), this.parsedOptions = this.handleOptions(n), this.parsedArguments = this.handleArguments(t), {
+      options: this.parsedOptions,
+      arguments: this.parsedArguments
+    };
+  }
+  /**
+   * Validates the parsed options and arguments
+   * @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]), n = this.parsedArguments?.[e];
+      if (t.required && n == null) {
+        if (this.shouldPromptForMissingOptions) {
+          const s = await this.promptForArgument(e, t);
+          if (s && this.parsedArguments) {
+            this.parsedArguments[e] = C(s, t.type, e);
+            continue;
+          }
+        }
+        throw new Y(e);
+      }
+      if (t.required && t.variadic && Array.isArray(n) && n.length === 0) {
+        if (this.shouldPromptForMissingOptions) {
+          const s = await this.promptForArgument(e, t);
+          if (s && this.parsedArguments) {
+            this.parsedArguments[e] = C(s, t.type, e);
+            continue;
+          }
+        }
+        throw new Y(e);
       }
     }
   }
-  handleOptions(t) {
-    for (const [e, n] of Object.entries(t)) {
-      const s = this.optionAliases[e], r = this.optionSignatures[e] ?? this.optionSignatures[s];
-      if (!r)
-        throw new A(e, Object.values(this.optionSignatures));
-      this.options[e] = this.getParamValue(n, r);
-      for (const i of r.alias ?? [])
-        t[i] && (this.options[r.name] = t[i]);
-    }
+  /**
+   * Retrieves a parsed option value by name
+   * @param name - The option name
+   * @returns The typed option value
+   * @throws {Error} If init() has not been called yet
+   */
+  option(e) {
+    if (!this.parsedOptions)
+      throw new Error("Options have not been parsed yet. Call init() first.");
+    return this.parsedOptions[e];
+  }
+  setOption(e, t) {
+    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;
   }
-  parseSignature(t) {
-    for (const e of t) {
-      const n = this.parseParamSignature(e);
-      if (n.isOption) {
-        this.options[n.name] = n.defaultValue ?? null, this.optionSignatures[n.name] = n;
-        for (const s of n.alias ?? [])
-          this.optionAliases[s] = n.name;
-      } else
-        this.arguments[n.name] = n.defaultValue ?? null, this.argumentsSignature[n.name] = n;
+  /**
+   * Retrieves a parsed argument value by name
+   * @param name - The argument name
+   * @returns The typed argument value
+   * @throws {Error} If init() has not been called yet
+   */
+  argument(e) {
+    if (!this.parsedArguments)
+      throw new Error("Arguments have not been parsed yet. Call init() first.");
+    return this.parsedArguments[e];
+  }
+  setArgument(e, t) {
+    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;
+  }
+  // === PRIVATE HELPERS ===
+  /**
+   * Validates that all provided options are recognized
+   * @throws {InvalidOption} If an unknown option is found
+   */
+  validateUnknownOptions(e) {
+    const t = /* @__PURE__ */ new Set();
+    for (const n in this.options) {
+      t.add(n);
+      const s = y(this.options[n]);
+      for (const i of s.alias)
+        t.add(i);
     }
+    for (const n in e)
+      if (!t.has(n))
+        throw new k(n, this.options);
   }
-  parseDefaultOptions() {
-    if (this.defaultCommandOptions.length) {
-      for (const t of this.defaultCommandOptions)
-        if (this.optionSignatures[t.option] = {
-          name: t.option,
-          type: t.defaultValue == null ? "string" : typeof t.defaultValue == "boolean" ? "boolean" : Array.isArray(t.defaultValue) ? "array" : "string",
-          optional: !0,
-          alias: t.alias,
-          variadic: !1,
-          help: t.description,
-          defaultValue: t.defaultValue ?? null,
-          isOption: !0
-        }, this.options[t.option] = t.defaultValue, t.alias)
-          for (const e of t.alias)
-            this.optionAliases[e] = t.option;
+  /**
+   * Processes named options from minimist output
+   */
+  handleOptions(e) {
+    const t = {};
+    for (const n in this.options) {
+      const s = y(this.options[n]);
+      t[n] = this.resolveOptionValue(n, s, e);
     }
+    return t;
   }
-  parseParamSignature(t) {
-    const e = {
-      name: t,
-      optional: !1,
-      type: "string",
-      help: void 0,
-      defaultValue: null,
-      variadic: !1,
-      isOption: !1
-    };
-    if (e.name.includes(":")) {
-      const [n, s] = e.name.split(":");
-      e.name = n.trim(), e.help = s.trim();
+  /**
+   * Processes positional arguments from minimist output
+   */
+  handleArguments(e) {
+    const t = {}, n = [...e];
+    for (const s in this.arguments) {
+      const i = y(this.arguments[s]);
+      if (i.variadic) {
+        t[s] = this.handleVariadicArgument(s, i, n);
+        continue;
+      }
+      t[s] = this.resolveArgumentValue(s, i, n.shift());
     }
-    if (e.name.includes("=")) {
-      const [n, s] = e.name.split("=");
-      e.name = n.trim(), e.defaultValue = s.trim(), e.optional = !0, e.defaultValue.length ? e.defaultValue === "true" ? (e.defaultValue = !0, e.type = "boolean") : e.defaultValue === "false" && (e.defaultValue = !1, e.type = "boolean") : e.defaultValue = null;
-    } else
-      e.name.startsWith("--") && (e.optional = !0, e.defaultValue = !1, e.type = "boolean");
-    if (e.name.includes("|")) {
-      const [n, ...s] = e.name.split("|");
-      e.name = n.trim(), e.alias = s.map((r) => r.trim());
+    return t;
+  }
+  /**
+   * Handles variadic arguments that consume all remaining positional values
+   */
+  handleVariadicArgument(e, t, n) {
+    return n.length ? C(n, t.type, e, t.default) : t.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, n) {
+    return n === void 0 ? t.default : C(n, t.type, e, t.default);
+  }
+  /**
+   * Resolves an option value from the parsed option values object
+   * Handles alias resolution, defaults, and type conversion
+   */
+  resolveOptionValue(e, t, n) {
+    let s;
+    const i = [e, ...t.alias];
+    for (const o of i)
+      if (o in n) {
+        s = n[o];
+        break;
+      }
+    if (s === void 0) {
+      if (t.required)
+        throw new B({
+          option: e,
+          reason: "Required option is missing"
+        });
+      return t.default;
     }
-    return e.name.startsWith("--") && (e.isOption = !0, e.name = e.name.slice(2)), e.defaultValue === "*" && (e.defaultValue = [], e.type = "array"), e.name.endsWith("?") && (e.optional = !0, e.name = e.name.slice(0, -1)), e.name.endsWith("*") && (e.type = "array", e.variadic = !0, e.defaultValue = [], e.name = e.name.slice(0, -1)), e.help = e.help ?? this.helperDefinitions[e.name] ?? this.helperDefinitions[`--${e.name}`], e;
+    return C(s, t.type, e, t.default);
   }
-  async validate() {
-    for (const [t, e] of Object.entries(this.arguments)) {
-      const n = this.argumentsSignature[t];
-      if (!e && !n.optional) {
-        let s = null;
-        switch (n.type) {
-          case "string":
-            let r = o`{yellow.bold ${n.name}} is required`;
-            n.help && (r += o`: {gray (${n.help})}`), r += `
-`, s = await this.io.askForInput(r, n.defaultValue, {
-              validate: (i) => i?.trim()?.length ? !0 : `${n.name} cannot be empty`
-            });
-            break;
+  optionDefinitions() {
+    const e = {};
+    for (const t in this.options)
+      e[t] = y(this.options[t]);
+    return e;
+  }
+  argumentDefinitions() {
+    const e = {};
+    for (const t in this.arguments)
+      e[t] = y(this.arguments[t]);
+    return e;
+  }
+  availableOptions() {
+    return Object.keys(this.options);
+  }
+  availableArguments() {
+    return Object.keys(this.arguments);
+  }
+  /**
+   * Disables prompting for missing argument values
+   * Useful for non-interactive environments
+   */
+  disablePrompting() {
+    return this.shouldPromptForMissingOptions = !1, this;
+  }
+  /**
+   * Prompts the user to provide a missing argument value via CommandIO
+   * Used by validate() when shouldPromptForMissingArgs is enabled
+   * @param argumentName - The name of the missing argument
+   * @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))
+      return null;
+    let n = `${a.yellow.bold(e)} is required`;
+    return t.description && (n += `: ${a.gray(`(${t.description})`)}`), n += ` ${a.green(`(${t.type}${t.variadic == !0 ? "[]" : ""})`)}
+`, Array.isArray(t.type) ? (n += `Please provide one or more values, separated by commas:
+`, await this.io.askForList(n, void 0, {
+      separator: ",",
+      validate: (s) => {
+        if (!s.length)
+          return "Please enter at least one value";
+        if (t.type[0] === "number") {
+          for (const i of s.split(","))
+            if (isNaN(Number(i)))
+              return "Please enter only valid numbers";
         }
-        if (s)
-          this.setArgument(t, s);
-        else
-          throw new v(n);
+        return !0;
       }
-      if (!e?.length && n.variadic && !n.optional)
-        throw new v(n);
-    }
+    })) : await this.io.askForInput(n, void 0, {
+      type: t.type === "number" ? "number" : t.secret ? "password" : "text",
+      validate: (s) => {
+        if (s == null || typeof s == "string" && !s.length)
+          return "This value is required";
+        if (t.type === "number") {
+          const i = Number(s);
+          if (isNaN(i))
+            return "Please enter a valid number";
+        } else if (t.type === "string" && (typeof s != "string" || !s.length))
+          return "Please enter a valid text";
+        return !0;
+      }
+    });
   }
 }
-function C(u) {
-  return new Array(u + 5).join(" ");
+function j(r) {
+  return new Array(r + 5).join(" ");
 }
-class V {
+class pe {
+  type = "boolean";
   option = "help";
   alias = ["h"];
-  defaultValue = !1;
-  description = o`Display help for the given command. When no command is given display help for the {green list} command`;
+  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 t = console.log, e = Object.values(this.parser.getArgumentSignatures()), n = Object.values(this.parser.getOptionSignatures()).map((a) => ({
-      ...a,
-      optionWithAlias: `--${a.name}${a.alias?.map((l) => `, -${l}`).join("") ?? ""}`
-    })), s = e.filter((a) => !a.optional);
-    t(o`{yellow Description}:`), t(o`  ${this.description}\n`), t(o`{yellow Usage}:`), t(o`  ${this.command} ${s.length > 0 ? s.map((a) => `<${a.name}>`).join(" ") : "\b"} [options]`);
-    const r = Math.max(...n.map((a) => a.optionWithAlias.length)) ?? 0, i = Math.max(...e.map((a) => a.name.length)) ?? 0, m = i > r ? i : r;
-    if (e.length > 0) {
-      t(o`\n{yellow Arguments}:`);
-      for (const a of e) {
-        const l = C(m - a.name.length);
-        let p = o`  {green ${a.name}} ${l} ${a.help ?? "\b"}`;
-        if (a.defaultValue !== void 0 && a.optional) {
-          const h = a.type === "array" ? JSON.stringify(a.defaultValue) : a.defaultValue;
-          p += o` {yellow [default: ${h}]}`;
+    const e = this.parser.argumentDefinitions(), t = this.parser.optionDefinitions(), n = Object.entries(e), s = Object.entries(t), i = s.map(([l, d]) => {
+      const p = Array.isArray(d.alias) ? d.alias : d.alias ? [d.alias] : [];
+      return {
+        name: l,
+        ...d,
+        optionWithAlias: `--${l}${p.map((g) => `, -${g}`).join("")}`
+      };
+    }), o = n.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(...n.map(([l]) => l.length), 0), h = m > u ? m : u;
+    if (n.length > 0) {
+      this.io.log(`
+${a.yellow("Arguments")}:`);
+      for (const [l, d] of n) {
+        const p = j(h - l.length);
+        let g = `  ${a.green(l)} ${p} ${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}]`)}`;
         }
-        a.variadic && (p += o` {white (variadic)}`), t(p);
+        d.variadic && (g += ` ${a.white("(variadic)")}`), this.io.log(g);
       }
     }
-    if (n.length > 0) {
-      t(o`\n{yellow Options}:`);
-      for (const a of n) {
-        const l = C(m - a.optionWithAlias.length);
-        let p = o`{green ${a.optionWithAlias}} ${l} ${a.help ?? "\b"}`;
-        if (a.type && (p += o` {white (${a.type})}`), a.defaultValue !== void 0 && a.optional) {
-          const h = a.type === "array" ? JSON.stringify(a.defaultValue) : a.defaultValue;
-          p += o` {yellow [default: ${h}]}`;
+    if (s.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"}`;
+        if (l.type) {
+          const g = Array.isArray(l.type) ? `[${l.type[0]}]` : l.type;
+          p += ` ${a.white(`(${g})`)}`;
+        }
+        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}]`)}`;
         }
-        t(p);
+        this.io.log(p);
       }
     }
     if (this.commandsExamples.length > 0) {
-      t(o`\n{yellow Examples}:`);
-      let a = process.argv[0].split("/").pop();
-      a === "node" && (a += " " + process.argv[1].split("/").pop());
-      for (const [l, p] of this.commandsExamples.entries())
-        l > 0 && t(""), t(`  ${p.description}
-`), t(o`    {green ${a} ${p.command}}`);
+      this.io.log(`
+${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}`)}`);
     }
     return -1;
   }
 }
-class S {
-  /**
-   * Prompt utils
-   */
-  async askForConfirmation(t = "Do you want to continue?", e) {
-    return (await f({
-      type: "confirm",
-      name: "value",
-      message: t,
-      initial: e ?? !1
-    })).value;
+class F {
+  _command;
+  description = "";
+  group;
+  commandsExamples = [];
+  get command() {
+    return this._command;
   }
-  async askForInput(t, e, n) {
-    return (await f({
-      type: "text",
-      name: "value",
-      message: t,
-      initial: e,
-      ...n
-    }))?.value ?? null;
+  ctx;
+  io;
+  logger;
+  parser;
+  disablePromptingFlag = !1;
+  _preHandler;
+  _handler;
+  tmp;
+  defaultOptions() {
+    return [new pe()];
   }
-  async askForToggle(t, e, n) {
-    return (await f({
-      type: "toggle",
-      name: "value",
-      message: t,
-      initial: e,
-      ...n
-    }))?.value ?? null;
+  newCommandParser(e) {
+    return new J({
+      io: e.io,
+      options: e.options,
+      arguments: e.arguments
+    });
   }
-  async askForSelect(t, e, n) {
-    if (e.length === 0)
-      throw new Error("No options provided");
-    const s = [];
-    for (const i of e)
-      typeof i == "string" ? s.push({ title: i, value: i }) : s.push(i);
-    return (await f({
-      type: "select",
-      name: "value",
-      message: t,
-      choices: s,
-      ...n
-    }))?.value ?? null;
+  newCommandIO(e) {
+    return new z(e.logger);
   }
-  newLoader(t = "", e = ["⠙", "⠘", "⠰", "⠴", "⠤", "⠦", "⠆", "⠃", "⠋", "⠉"], n = 100) {
-    let s = t, r = null, i = 0;
-    const m = setInterval(function() {
-      r && (process.stdout.write(new TextEncoder().encode("\r" + " ".repeat(r.length + 5) + "\r")), r = null), process.stdout.write(new TextEncoder().encode("\r" + e[i++] + " " + s)), i = i % e.length;
-    }, n), a = () => {
-      clearInterval(m), process.stdout.write(new TextEncoder().encode("\r" + " ".repeat(s.length + 5) + "\r"));
+  constructor(e, t) {
+    this._command = e, this.description = t?.description ?? "", this.group = t?.group, this.tmp = {
+      options: t?.options ?? {},
+      arguments: t?.arguments ?? {}
     };
-    return {
-      [Symbol.dispose]: a,
-      [Symbol.asyncDispose]: a,
-      updateText: (l) => {
-        r = s, s = l;
+    const n = this.defaultOptions();
+    if (n.length > 0)
+      for (const s of n)
+        this.tmp.options[s.option] = s;
+  }
+  disablePrompting() {
+    return this.disablePromptingFlag = !0, this;
+  }
+  preHandler(e) {
+    return this._preHandler = e, this;
+  }
+  handler(e) {
+    return this._handler = e, this;
+  }
+  options(e) {
+    return this.tmp = {
+      options: {
+        ...this.tmp?.options ?? {},
+        ...e
       },
-      stop: a
-    };
+      arguments: this.tmp?.arguments ?? {}
+    }, this;
+  }
+  arguments(e) {
+    return this.tmp = {
+      options: this.tmp?.options ?? {},
+      arguments: {
+        ...this.tmp?.arguments ?? {},
+        ...e
+      }
+    }, this;
+  }
+  async run(e) {
+    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 ?? {};
+      for (const o of this.defaultOptions())
+        o.option in i || (i[o.option] = o);
+      this.parser = this.newCommandParser({
+        io: this.io,
+        options: i,
+        arguments: this.tmp?.arguments ?? {}
+      }), t = this.parser.init(e.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;
+        }
+      this.disablePromptingFlag && this.parser.disablePrompting(), await this.parser.validate();
+    } else
+      t = {
+        options: e.options,
+        arguments: e.arguments
+      };
+    const n = this.preHandle ? await this.preHandle() : null;
+    if (n && n !== 0)
+      return n;
+    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;
   }
 }
-class E {
-  ctx;
-  helperDefinitions = {};
-  commandsExamples = [];
-  parser;
-  io;
-  get CommandParserClass() {
-    return x;
+class v extends J {
+  command;
+  constructor(e) {
+    const t = v.parseSignature(e.signature, e.helperDefinitions, e.defaultOptions);
+    super({
+      io: e.io,
+      options: t.options,
+      arguments: t.arguments
+    }), this.command = t.command;
   }
-  get CommandIOClass() {
-    return S;
+  /**
+   * Parses command signature string into command name and parameter schemas
+   * Example: "migrate {name} {--force}" -> { command: "migrate", arguments: {name: ...}, options: {force: ...} }
+   */
+  static parseSignature(e, t, n) {
+    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 } = v.parseParamSignature(m, t);
+      l ? o[h] = d : u[h] = d;
+    }
+    for (const m of n)
+      o[m.option] = {
+        type: m.type,
+        required: m.required,
+        alias: m.alias,
+        variadic: m.variadic ?? !1,
+        description: m.description,
+        default: m.default ?? null
+      };
+    return {
+      command: s,
+      options: o,
+      arguments: u
+    };
   }
-  defaultOptions() {
-    return [new V()];
+  /**
+   * Parses a single parameter signature like "{name}" or "{--force}" or "{files*}"
+   * Extracts name, type, default value, aliases, description, etc.
+   *
+   * Signature syntax:
+   * - {arg}          -> required string argument
+   * - {arg?}         -> optional argument
+   * - {arg=default}  -> argument with default value
+   * - {arg*}         -> variadic argument (array)
+   * - {arg:desc}     -> argument with description
+   * - {--opt}        -> boolean option
+   * - {--opt=}       -> string option
+   * - {--opt|o}      -> option with alias
+   */
+  static parseParamSignature(e, t) {
+    let n = e, s = !1;
+    const i = {
+      required: !0,
+      type: "string",
+      description: void 0,
+      default: null,
+      variadic: !1
+    };
+    if (n.includes(":")) {
+      const [o, u] = n.split(":");
+      n = o.trim(), i.description = u.trim();
+    }
+    if (n.includes("=")) {
+      const [o, u] = n.split("=");
+      n = 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 n.startsWith("--") && (i.required = !1, i.default = !1, i.type = "boolean");
+    if (n.includes("|")) {
+      const [o, ...u] = n.split("|");
+      n = o.trim(), i.alias = u.map((m) => m.trim());
+    }
+    return n.startsWith("--") && (s = !0, n = n.slice(2)), i.default === "*" && (i.default = [], i.type = ["string"]), n.endsWith("?") && (i.required = !1, n = n.slice(0, -1)), n.endsWith("*") && (i.type = ["string"], i.variadic = !0, i.default = [], n = n.slice(0, -1)), i.description = i.description ?? t[n] ?? t[`--${n}`], { name: n, isOption: s, definition: i };
   }
+}
+class Ae extends F {
+  helperDefinitions = {};
   get command() {
     return this.parser ? this.parser.command : this.signature.split(" ")[0];
   }
-  async run(t, ...e) {
-    this.ctx = t;
-    const n = this.defaultOptions();
-    this.io = new this.CommandIOClass(), this.parser = new this.CommandParserClass(this.io, this.signature, this.helperDefinitions, n, ...e);
-    for (const r of n)
-      if (this.parser.option(r.option)) {
-        const i = await r.handler.call(this);
-        if (i && i !== 0)
-          return i;
-      }
-    await this.parser.validate();
-    const s = this.preHandle ? await this.preHandle() : null;
-    return s && s !== 0 ? s : await this.handle() ?? 0;
+  newCommandParser(e) {
+    return new v({
+      io: e.io,
+      signature: this.signature,
+      helperDefinitions: this.helperDefinitions,
+      defaultOptions: this.defaultOptions()
+    });
   }
-  setOption(t, e) {
-    this.parser.setOption(t, e);
+  constructor() {
+    super("");
   }
-  setArgument(t, e) {
-    this.parser.setArgument(t, e);
+  option(e, t = null) {
+    return this.parser instanceof v ? this.parser.option(e) ?? t : t;
   }
-  option(t, e = null) {
-    return this.parser.option(t) ?? e;
+  argument(e, t = null) {
+    return this.parser instanceof v ? this.parser.argument(e) ?? t : t;
   }
-  optionBoolean(t, e = !1) {
-    return this.parser.option(t) ?? e;
+  // Prompt utils
+  async askForConfirmation(...e) {
+    return this.io.askForConfirmation(...e);
   }
-  optionArray(t, e = []) {
-    const n = this.parser.option(t);
-    if (!Array.isArray(n))
-      throw new Error(`Option ${t} is not an array`);
-    return n.length ? n : e;
+  async askForInput(...e) {
+    return this.io.askForInput(...e);
   }
-  optionNumber(t, e = null) {
-    const n = this.parser.option(t);
-    return n ? typeof n == "number" ? n : parseInt(n) : e;
+  async askForSelect(...e) {
+    return this.io.askForSelect(...e);
   }
-  argument(t, e = null) {
-    return this.parser.argument(t) ?? e;
+  newLoader(...e) {
+    return this.io.newLoader(...e);
   }
-  argumentArray(t, e = []) {
-    const n = this.parser.argument(t);
-    if (!Array.isArray(n))
-      throw new Error(`Argument ${t} is not an array`);
-    return n?.length ? n : e;
+}
+class K {
+  level;
+  constructor(e = {}) {
+    this.level = e.level ?? "info";
   }
-  argumentBoolean(t, e = !1) {
-    return this.parser.argument(t) ?? e;
+  shouldLog(e) {
+    const t = ["debug", "info", "warn", "error"], n = t.indexOf(this.level);
+    return t.indexOf(e) >= n;
   }
-  argumentNumber(t, e = null) {
-    const n = this.parser.argument(t);
-    return n ? typeof n == "number" ? n : parseInt(n) : e;
+  setLevel(e) {
+    this.level = e;
   }
-  /**
-   * Prompt utils
-   */
-  async askForConfirmation(...t) {
-    return this.io.askForConfirmation(...t);
+  getLevel() {
+    return this.level;
   }
-  async askForInput(...t) {
-    return this.io.askForInput(...t);
+  log(...e) {
+    console.log(...e);
   }
-  async askForSelect(...t) {
-    return this.io.askForSelect(...t);
+  info(...e) {
+    this.shouldLog("info") && console.log(...e);
   }
-  newLoader(...t) {
-    return this.io.newLoader(...t);
+  warn(...e) {
+    this.shouldLog("warn") && console.warn(...e);
   }
-}
-class j extends c {
-  constructor(t) {
-    super(`Command "${t}" not found.`), this.command = t;
+  error(...e) {
+    this.shouldLog("error") && console.error(...e);
   }
-  pretty() {
-    const t = console.log;
-    t(o`{bgRed  ERROR } Command {yellow ${this.command}} not found.`);
+  debug(...e) {
+    this.shouldLog("debug") && console.log(...e);
   }
 }
-class F {
+class ge {
   commands = {};
   io;
-  get commandSuffix() {
-    return "Command";
-  }
+  logger;
   get CommandIOClass() {
-    return S;
+    return z;
   }
-  constructor() {
-    this.io = new this.CommandIOClass();
+  constructor(e) {
+    this.logger = e ?? new K(), this.io = new this.CommandIOClass(this.logger);
   }
   getAvailableCommands() {
     return Object.keys(this.commands);
@@ -439,176 +1060,188 @@ class F {
   getCommands() {
     return Object.values(this.commands);
   }
-  commandResolver = async (t) => {
-    const e = (await import(t)).default;
-    let n;
-    return e?.default ? n = new e.default() : n = new e(), n;
+  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 F ? t : null;
   };
-  setCommandResolver(t) {
-    this.commandResolver = t;
+  withCommandResolver(e) {
+    return this.commandResolver = e, this;
+  }
+  withFileImporter(e) {
+    return this.importFile = e, this;
   }
-  registerCommand(t, e = !1) {
-    const n = t.signature.split(" ")[0];
+  registerCommand(e, t = !1) {
+    const n = e.command;
     if (!n)
       throw new Error("Command signature is invalid, it must have a command name.");
-    if (!e && this.commands[n])
+    if (!t && this.commands[n])
       throw new Error(`Command ${n} already registered.`);
-    this.commands[n] = t;
+    this.commands[n] = e;
   }
-  async loadCommandsPath(t) {
-    for await (const e of this.listCommandsFiles(t))
+  async loadCommandsPath(e) {
+    for await (const t of this.listCommandsFiles(e))
       try {
-        const n = await this.commandResolver(e);
-        this.registerCommand(n);
+        const n = await this.commandResolver(t);
+        n instanceof F && this.registerCommand(n);
       } catch (n) {
-        throw new Error(`Command ${e} failed to load. ${n}`);
+        throw new Error(`Command ${t} failed to load. ${n}`, {
+          cause: n
+        });
       }
   }
-  async runCommand(t, e, ...n) {
-    const s = typeof e == "string" ? this.commands[e] : e, r = typeof e == "string" ? e : s.command;
+  async runCommand(e, t, ...n) {
+    const s = typeof t == "string" ? this.commands[t] : t, i = typeof t == "string" ? t : s.command;
     if (!s) {
-      const i = await this.suggestCommand(r);
-      return i ? await this.runCommand(t, i, ...n) : 1;
+      const o = await this.suggestCommand(i);
+      return o ? await this.runCommand(e, o, ...n) : 1;
     }
-    return await s.run(t, ...n);
-  }
-  async suggestCommand(t) {
-    const e = this.getAvailableCommands(), { bestMatch: n, bestMatchIndex: s, ratings: r } = O.findBestMatch(t, e), i = r.filter((m) => m.rating > 0.3).map((m) => m.target);
-    if (n.rating > 0 && i.length <= 1 || n.rating > 0.7 && i.length > 1) {
-      const m = e[s];
-      return await this.askRunSimilarCommand(t, m) ? m : null;
+    return await s.run({
+      ctx: e,
+      logger: this.logger,
+      args: n
+    }) ?? 0;
+  }
+  async suggestCommand(e) {
+    const t = this.getAvailableCommands(), { bestMatch: n, bestMatchIndex: s, ratings: i } = ee.findBestMatch(e, t), o = i.filter((u) => u.rating > 0.3).map((u) => u.target);
+    if (n.rating > 0 && o.length <= 1 || n.rating > 0.7 && o.length > 1) {
+      const u = t[s];
+      return await this.askRunSimilarCommand(e, u) ? u : null;
     }
-    if (i.length) {
-      console.log(o`{bgRed  ERROR } Command {yellow ${t}} not found.\n`);
-      const m = await this.io.askForSelect(
-        o`{green Did you mean to run one of these commands instead?}`,
-        i
-      );
-      if (m)
-        return m;
+    if (o.length) {
+      this.io.error(`${a.bgRed(" ERROR ")} Command ${a.yellow(e)} 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;
     }
-    throw new j(t);
+    throw new he(e);
   }
-  async askRunSimilarCommand(t, e) {
-    return console.log(o`{bgRed  ERROR } Command {yellow ${t}} not found.\n`), this.io.askForConfirmation(o`{green Do you want to run {yellow ${e}} instead?} `);
+  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(t) {
-    const e = R.readdirSync(t, { withFileTypes: !0 });
-    for (const n of e) {
-      const s = $.resolve(t, n.name);
+  async *listCommandsFiles(e) {
+    const t = Z.readdirSync(e, { withFileTypes: !0 });
+    for (const n of t) {
+      const s = I.resolve(e, n.name);
       if (n.isDirectory())
-        yield* this.listCommandsFiles($.resolve(t, n.name));
+        yield* this.listCommandsFiles(I.resolve(e, n.name));
       else {
-        if (!s.endsWith(`${this.commandSuffix}.ts`) && !s.endsWith(`${this.commandSuffix}.js`))
+        if (!s.endsWith(".ts") && !s.endsWith(".js") && !s.endsWith(".mjs") && !s.endsWith(".cjs"))
           continue;
         yield s;
       }
     }
   }
 }
-class k extends E {
-  constructor(t) {
-    super(), this.opts = t;
+class fe {
+  logger;
+  constructor(e) {
+    this.logger = e;
+  }
+  handle(e) {
+    if (e instanceof w)
+      return e.pretty(this.logger), -1;
+    throw e;
+  }
+}
+class ye extends F {
+  constructor(e) {
+    super("help", {
+      description: a.bold("Show help information about the CLI and its commands")
+    }), this.opts = e;
   }
-  signature = "help";
-  description = "Show help";
   async handle() {
-    const t = this.opts.commandRegistry.getCommands(), e = this.opts.cliName ?? "Bob CLI", n = this.opts.cliVersion ?? "0.0.0", s = (await import("./package-eljsfLkU.js"))?.default?.version ?? "0.0.0";
-    console.log(o`${e} {green ${n}} (core: {yellow ${s}})
+    const e = this.opts.commandRegistry.getCommands(), t = this.opts.cliName ?? "Bob CLI", n = this.opts.cliVersion ?? "0.0.0", s = (await import("./package-O5nP1XlU.js"))?.default?.version ?? "0.0.0";
+    this.io.log(`${t} ${a.green(n)} (core: ${a.yellow(s)})
 
-{yellow Usage}:
+${a.yellow("Usage")}:
   command [options] [arguments]
 
-{yellow Available commands}:
+${a.yellow("Available commands")}:
 `);
-    const r = Math.max(...t.map((a) => a.command.length)) ?? 0, i = {};
-    for (const a of t) {
-      const l = a.command.split(":")[0];
-      i[l] || (i[l] = []), i[l].push(a);
+    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 m = Object.entries(i).sort(([a], [l]) => a.toLowerCase().localeCompare(l.toLowerCase())).sort(([, a], [, l]) => a.length - l.length);
-    for (const [a, l] of m) {
-      const p = l.length > 1;
-      p && console.log(o`{yellow ${a}}:`);
-      const h = l.sort((d, g) => d.command.toLowerCase().localeCompare(g.command.toLowerCase()));
-      for (const d of h) {
-        let g = C(r - d.command.length);
-        p && (g = g.slice(2)), console.log(o`${p ? "  " : ""}{green ${d.command}} ${g} ${d.description}`);
+    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 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}`);
       }
     }
   }
 }
-class W extends c {
-  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() {
-    const t = console.log;
-    t(o`  {white.bgRed  ERROR } Argument {bold.yellow ${this.param.param}} value is invalid. `), (this.param.value || this.param.reason) && t(""), this.param.value && t(o`  {blue Value}: ${this.param.value}`), this.param.reason && t(o`  {yellow Reason}: ${this.param.reason}`);
-  }
-}
-class M extends c {
-  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() {
-    const t = console.log;
-    t(o`  {white.bgRed  ERROR } Option {bold.yellow ${this.param.option}} value is invalid. `), (this.param.value || this.param.reason) && t(""), this.param.value && t(o`  {blue Value}: ${this.param.value}`), this.param.reason && t(o`  {yellow Reason}: ${this.param.reason}`);
-  }
-}
-class H {
-  handle(t) {
-    if (t instanceof c)
-      return t.pretty(), -1;
-    throw t;
-  }
-}
-class N {
+class Ce {
+  ctx;
+  logger;
   commandRegistry;
   exceptionHandler;
-  ctx;
   helpCommand;
-  get CommandRegistryClass() {
-    return F;
-  }
-  get HelpCommandClass() {
-    return k;
-  }
-  get ExceptionHandlerClass() {
-    return H;
-  }
-  constructor(t = {}) {
-    this.ctx = t.ctx, this.commandRegistry = new this.CommandRegistryClass(), this.exceptionHandler = new this.ExceptionHandlerClass(), this.helpCommand = new this.HelpCommandClass({
-      cliName: t.name,
-      cliVersion: t.version,
+  newCommandRegistry(e) {
+    return new ge(e.logger);
+  }
+  newHelpCommand(e) {
+    return new ye(e);
+  }
+  newExceptionHandler(e) {
+    return new fe(e.logger);
+  }
+  constructor(e = {}) {
+    this.ctx = e.ctx, this.logger = e.logger ?? new K(), this.commandRegistry = this.newCommandRegistry({
+      logger: this.logger
+    }), this.exceptionHandler = this.newExceptionHandler({
+      logger: this.logger
+    }), this.helpCommand = this.newHelpCommand({
+      cliName: e.name,
+      cliVersion: e.version,
       commandRegistry: this.commandRegistry
     });
   }
-  setCommandResolver(t) {
-    this.commandRegistry.setCommandResolver(t);
+  withCommandResolver(e) {
+    return this.commandRegistry.withCommandResolver(e), this;
+  }
+  withFileImporter(e) {
+    return this.commandRegistry.withFileImporter(e), this;
   }
-  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 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 runCommand(t, ...e) {
-    return t ? await this.commandRegistry.runCommand(this.ctx, t, ...e).catch(this.exceptionHandler.handle) : await this.runHelpCommand();
+  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 runHelpCommand() {
     return await this.runCommand(this.helpCommand);
   }
-  registerCommand(t) {
-    this.commandRegistry.registerCommand(t);
+  registerCommand(e) {
+    this.commandRegistry.registerCommand(e);
   }
 }
 export {
-  M as BadCommandOption,
-  W as BadCommandParameter,
-  c as BobError,
-  N as Cli,
-  E as Command,
-  S as CommandIO,
-  V as HelpOption
+  B as BadCommandOption,
+  $e as BadCommandParameter,
+  w as BobError,
+  Ce as Cli,
+  F as Command,
+  z as CommandIO,
+  he as CommandNotFoundError,
+  J as CommandParser,
+  ge as CommandRegistry,
+  v as CommandSignatureParser,
+  Ae as CommandWithSignature,
+  fe as ExceptionHandler,
+  pe as HelpOption,
+  k as InvalidOption,
+  K as Logger,
+  Y as MissingRequiredArgumentValue,
+  ce as MissingRequiredOptionValue
 };