bob-core 1.4.0 → 2.0.0-beta.1

package/dist/esm/index.js

@@ -1,276 +1,416 @@
-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 I from "minimist";
+import a from "chalk";
+import w from "prompts";
+import * as F from "node:fs";
+import S from "path";
+import * as V from "string-similarity";
+class y extends Error {
 }
-class v extends c {
+class J extends y {
   constructor(t) {
-    super(`Argument "${t.name}" is required.`), this.paramSignature = 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.paramSignature.name}} is required.`);
+  pretty(t) {
+    t.log(a`  {white.bgRed  ERROR } Argument {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 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}`);
+class $ extends y {
+  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(t) {
+    t.log(a`  {white.bgRed  ERROR } Option {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}`);
+  }
+}
+function E(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 D(r) {
+  return typeof r == "string" ? E(r) : Array.isArray(r) ? [] : typeof r == "object" && r.type ? r.default !== void 0 ? r.default : E(r.type) : null;
+}
+function f(r) {
+  return typeof r == "string" || Array.isArray(r) ? {
+    type: r,
+    default: D(r),
+    description: "",
+    alias: [],
+    required: !1,
+    variadic: !1
+  } : {
+    type: r.type,
+    default: r.default ?? D(r.type),
+    description: r.description ?? "",
+    alias: r.alias ? Array.isArray(r.alias) ? r.alias : [r.alias] : [],
+    required: r.required ?? !1,
+    variadic: r.variadic ?? !1
+  };
+}
+class H extends y {
+  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`\n{yellow Available options}:`);
+      for (const [n, i] of e) {
+        const s = f(i), o = typeof s.alias == "string" ? [s.alias] : s.alias, l = Array.isArray(s.type) ? `[${s.type[0]}]` : s.type, u = `--${n}${o.length > 0 ? o.map((m) => `, -${m}`).join("") : ""}`, c = " ".repeat(30 - u.length);
+        t.log(a`  {green ${u}} ${c} ${s.description || "\b"} {white (${l})}`);
       }
-      t("");
+      t.log("");
     }
-    t(o`{white.bgRed  ERROR } Option {bold.yellow ${this.option}} is missing in the signature.`);
+    t.log(a`{white.bgRed  ERROR } Option {bold.yellow ${this.option}} is not recognized.`);
   }
 }
-class w extends c {
+class j extends y {
+  constructor(t) {
+    super(`Command "${t}" not found.`), this.command = t;
+  }
+  pretty(t) {
+    t.log(a`{bgRed  ERROR } Command {yellow ${this.command}} not found.`);
+  }
+}
+class v extends y {
   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}`);
+    super(`Missing ${t} in the command signature`), this.argument = t, this.argumentsSchema = e;
+  }
+  pretty(t) {
+    const e = Object.entries(this.argumentsSchema);
+    if (e.length) {
+      t.log(a`\n{yellow Available arguments}:`);
+      for (const [n, i] of e) {
+        const s = f(i), o = Array.isArray(s.type) ? `[${s.type[0]}]` : s.type, l = o ? a`{white (${o})}` : "", u = " ".repeat(20 - n.length);
+        t.log(a`  {green ${n}} ${u} ${s.description ?? "\b"} ${l}`);
       }
-      t("");
+      t.log("");
     }
-    t(o`{white.bgRed  ERROR } Argument {bold.yellow ${this.argument}} is missing in the signature.`);
+    t.log(a`{white.bgRed  ERROR } Argument {bold.yellow ${this.argument}} is missing in the signature.`);
   }
 }
-class A extends c {
+class b extends y {
   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}`);
+    super(`Missing ${t} in the command signature`), this.option = t, this.optionsSchema = e;
+  }
+  pretty(t) {
+    const e = Object.entries(this.optionsSchema);
+    if (e.length) {
+      t.log(a`{yellow Available options}:`);
+      for (const [n, i] of e) {
+        const s = f(i), o = Array.isArray(s.type) ? `[${s.type[0]}]` : s.type, l = o ? a`{white (${o})}` : "", u = " ".repeat(20 - n.length);
+        t.log(a`  {green ${n}} ${u} ${s.description ?? "\b"} ${l}`);
       }
-      t("");
+      t.log("");
     }
-    t(o`{white.bgRed  ERROR } Option {bold.yellow ${this.option}} is not recognized.`);
+    t.log(a`{white.bgRed  ERROR } Option {bold.yellow ${this.option}} is missing in the signature.`);
   }
 }
-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);
-  }
-  command;
-  arguments = {};
-  options = {};
-  argumentsSignature = {};
-  optionSignatures = {};
-  optionAliases = {};
-  option(t) {
-    if (!this.optionSignatures[t])
-      throw new y(t, Object.values(this.optionSignatures));
-    return this.options[t];
+class C extends y {
+  constructor(t) {
+    super(`Argument "${t}" is required.`), this.argument = t;
   }
-  setOption(t, e) {
-    if (!this.optionSignatures[t])
-      throw new y(t, Object.values(this.optionSignatures));
-    this.options[t] = e;
+  pretty(t) {
+    t.log(a`{white.bgRed  ERROR } Argument {bold.yellow ${this.argument}} is required.`);
   }
-  optionHelp(t) {
-    if (!this.optionSignatures[t])
-      throw new y(t, Object.values(this.optionSignatures));
-    return this.optionSignatures[t].help;
+}
+class T extends y {
+  constructor(t) {
+    super(`Argument "${t}" is required.`), this.option = t;
   }
-  argument(t) {
-    if (!this.argumentsSignature[t])
-      throw new w(t, Object.values(this.argumentsSignature));
-    return this.arguments[t];
+  pretty(t) {
+    t.log(a`{white.bgRed  ERROR } Option {bold.yellow ${this.option}} is required.`);
   }
-  setArgument(t, e) {
-    if (!this.argumentsSignature[t])
-      throw new w(t, Object.values(this.argumentsSignature));
-    this.arguments[t] = e;
+}
+function A(r, t, e, n) {
+  if (r == null)
+    return n ?? null;
+  if (t === "string")
+    return String(r);
+  if (t === "number") {
+    const i = Number(r);
+    if (isNaN(i))
+      throw new $({
+        option: e,
+        reason: `Expected a number, got "${r}"`
+      });
+    return i;
+  }
+  if (t === "boolean")
+    return typeof r == "boolean" ? r : r === "true" || r === "1" ? !0 : r === "false" || r === "0" ? !1 : !!r;
+  if (Array.isArray(t)) {
+    const i = t[0], s = Array.isArray(r) ? r : [r];
+    if (i === "string")
+      return s.map((o) => String(o));
+    if (i === "number")
+      return s.map((o) => {
+        const l = Number(o);
+        if (isNaN(l))
+          throw new $({
+            option: e,
+            reason: `Expected array of numbers, got "${o}" in array`
+          });
+        return l;
+      });
+  }
+  return r;
+}
+class k {
+  options;
+  parsedOptions = null;
+  arguments;
+  parsedArguments = null;
+  io;
+  constructor(t) {
+    this.options = t.options, this.arguments = t.arguments, this.io = t.io;
   }
-  argumentHelp(t) {
-    if (!this.argumentsSignature[t])
-      throw new w(t, Object.values(this.argumentsSignature));
-    return this.argumentsSignature[t].help;
+  // === 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(t) {
+    const { _: e, ...n } = I(t);
+    return this.validateUnknownOptions(n), this.parsedOptions = this.handleOptions(n), this.parsedArguments = this.handleArguments(e), {
+      options: this.parsedOptions,
+      arguments: this.parsedArguments
+    };
   }
-  getArgumentSignatures() {
-    return this.argumentsSignature;
+  /**
+   * Validates the parsed options and arguments
+   * @throws {Error} If validation fails
+   */
+  async validate() {
+    for (const t in this.options)
+      if (f(this.options[t]).required && (this.parsedOptions?.[t] === void 0 || this.parsedOptions?.[t] === null))
+        throw new T(t);
+    for (const t in this.arguments)
+      if (f(this.arguments[t]).required && (this.parsedArguments?.[t] === void 0 || this.parsedArguments?.[t] === null))
+        throw new C(t);
   }
-  getOptionSignatures() {
-    return this.optionSignatures;
+  /**
+   * 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(t) {
+    if (!this.parsedOptions)
+      throw new Error("Options have not been parsed yet. Call init() first.");
+    return this.parsedOptions[t];
   }
-  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;
+  /**
+   * 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(t) {
+    if (!this.parsedArguments)
+      throw new Error("Arguments have not been parsed yet. Call init() first.");
+    return this.parsedArguments[t];
   }
-  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);
-      }
+  // === PRIVATE HELPERS ===
+  /**
+   * Validates that all provided options are recognized
+   * @throws {InvalidOption} If an unknown option is found
+   */
+  validateUnknownOptions(t) {
+    const e = /* @__PURE__ */ new Set();
+    for (const n in this.options) {
+      e.add(n);
+      const i = f(this.options[n]);
+      for (const s of i.alias)
+        e.add(s);
     }
+    for (const n in t)
+      if (!e.has(n))
+        throw new H(n, this.options);
   }
+  /**
+   * Processes named options from minimist output
+   */
   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]);
+    const e = {};
+    for (const n in this.options) {
+      const i = f(this.options[n]);
+      e[n] = this.resolveOptionValue(
+        n,
+        i,
+        t,
+        "option"
+      );
     }
+    return e;
   }
-  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;
+  /**
+   * Processes positional arguments from minimist output
+   */
+  handleArguments(t) {
+    const e = {}, n = [...t];
+    for (const i in this.arguments) {
+      const s = f(this.arguments[i]);
+      if (s.variadic) {
+        e[i] = this.handleVariadicArgument(i, s, n);
+        continue;
+      }
+      e[i] = this.resolveArgumentValue(i, s, n.shift());
     }
+    return e;
   }
-  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;
-    }
+  /**
+   * Handles variadic arguments that consume all remaining positional values
+   */
+  handleVariadicArgument(t, e, n) {
+    return n.length ? A(n, e.type, t, e.default) : e.default;
   }
-  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();
-    }
-    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 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;
+  /**
+   * Resolves a single positional argument value with defaults and type conversion
+   * Note: Does not validate required arguments - validation happens in subclass validate() methods
+   */
+  resolveArgumentValue(t, e, n) {
+    return n === void 0 ? e.default : A(n, e.type, t, e.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;
-        }
-        if (s)
-          this.setArgument(t, s);
-        else
-          throw new v(n);
+  /**
+   * Resolves an option value from the parsed option values object
+   * Handles alias resolution, defaults, and type conversion
+   */
+  resolveOptionValue(t, e, n, i) {
+    let s;
+    const o = [t, ...e.alias];
+    for (const l of o)
+      if (l in n) {
+        s = n[l];
+        break;
       }
-      if (!e?.length && n.variadic && !n.optional)
-        throw new v(n);
+    if (s === void 0) {
+      if (e.required)
+        throw new $({
+          option: t,
+          reason: `${i === "option" ? "Option" : "Argument"} is required but not provided`
+        });
+      return e.default;
     }
+    return A(s, e.type, t, e.default);
+  }
+  optionDefinitions() {
+    const t = {};
+    for (const e in this.options)
+      t[e] = f(this.options[e]);
+    return t;
+  }
+  argumentDefinitions() {
+    const t = {};
+    for (const e in this.arguments)
+      t[e] = f(this.arguments[e]);
+    return t;
+  }
+  availableOptions() {
+    return Object.keys(this.options);
+  }
+  availableArguments() {
+    return Object.keys(this.arguments);
   }
 }
-function C(u) {
-  return new Array(u + 5).join(" ");
+function O(r) {
+  return new Array(r + 5).join(" ");
 }
-class V {
+class M {
+  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 = a`Display help for the given command. When no command is given display help for the {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 t = this.parser.argumentDefinitions(), e = this.parser.optionDefinitions(), n = Object.entries(t), i = Object.entries(e), s = i.map(([m, h]) => {
+      const d = Array.isArray(h.alias) ? h.alias : h.alias ? [h.alias] : [];
+      return {
+        name: m,
+        ...h,
+        optionWithAlias: `--${m}${d.map((p) => `, -${p}`).join("")}`
+      };
+    }), o = n.filter(([, m]) => m.required);
+    this.io.log(a`{yellow Description}:`), this.io.log(a`  ${this.description}\n`), this.io.log(a`{yellow Usage}:`), this.io.log(a`  ${this.command} ${o.length > 0 ? o.map(([m]) => `<${m}>`).join(" ") : "\b"} [options]`);
+    const l = Math.max(...s.map((m) => m.optionWithAlias.length), 0), u = Math.max(...n.map(([m]) => m.length), 0), c = u > l ? u : l;
+    if (n.length > 0) {
+      this.io.log(a`\n{yellow Arguments}:`);
+      for (const [m, h] of n) {
+        const d = O(c - m.length);
+        let p = a`  {green ${m}} ${d} ${h.description ?? "\b"}`;
+        if (h.default !== void 0 && !h.required) {
+          const N = (Array.isArray(h.type) ? `[${h.type[0]}]` : h.type) === "array" || Array.isArray(h.type) ? JSON.stringify(h.default) : h.default;
+          p += a` {yellow [default: ${N}]}`;
         }
-        a.variadic && (p += o` {white (variadic)}`), t(p);
+        h.variadic && (p += a` {white (variadic)}`), this.io.log(p);
       }
     }
-    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 (i.length > 0) {
+      this.io.log(a`\n{yellow Options}:`);
+      for (const m of s) {
+        const h = O(c - m.optionWithAlias.length);
+        let d = a`{green ${m.optionWithAlias}} ${h} ${m.description ?? "\b"}`;
+        if (m.type) {
+          const p = Array.isArray(m.type) ? `[${m.type[0]}]` : m.type;
+          d += a` {white (${p})}`;
+        }
+        if (m.default !== void 0 && !m.required) {
+          const x = (Array.isArray(m.type) ? `[${m.type[0]}]` : m.type) === "array" || Array.isArray(m.type) ? JSON.stringify(m.default) : m.default;
+          d += a` {yellow [default: ${x}]}`;
         }
-        t(p);
+        this.io.log(d);
       }
     }
     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`\n{yellow Examples}:`);
+      let m = process.argv[0].split("/").pop();
+      m === "node" && (m += " " + process.argv[1].split("/").pop());
+      for (const [h, d] of this.commandsExamples.entries())
+        h > 0 && this.io.log(""), this.io.log(`  ${d.description}
+`), this.io.log(a`    {green ${m} ${d.command}}`);
     }
     return -1;
   }
 }
-class S {
+class q {
+  logger;
+  constructor(t) {
+    this.logger = t;
+  }
+  /**
+   * Logger methods
+   */
+  log(...t) {
+    this.logger.log(...t);
+  }
+  info(...t) {
+    this.logger.info(...t);
+  }
+  warn(...t) {
+    this.logger.warn(...t);
+  }
+  error(...t) {
+    this.logger.error(...t);
+  }
+  debug(...t) {
+    this.logger.debug(...t);
+  }
+  verbose(...t) {
+    this.logger.verbose(...t);
+  }
   /**
    * Prompt utils
    */
   async askForConfirmation(t = "Do you want to continue?", e) {
-    return (await f({
+    return (await w({
       type: "confirm",
       name: "value",
       message: t,
@@ -278,7 +418,7 @@ class S {
     })).value;
   }
   async askForInput(t, e, n) {
-    return (await f({
+    return (await w({
       type: "text",
       name: "value",
       message: t,
@@ -287,7 +427,7 @@ class S {
     }))?.value ?? null;
   }
   async askForToggle(t, e, n) {
-    return (await f({
+    return (await w({
       type: "toggle",
       name: "value",
       message: t,
@@ -298,107 +438,380 @@ class S {
   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({
+    const i = [];
+    for (const o of e)
+      typeof o == "string" ? i.push({ title: o, value: o }) : i.push(o);
+    return (await w({
       type: "select",
       name: "value",
       message: t,
-      choices: s,
+      choices: i,
       ...n
     }))?.value ?? null;
   }
   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"));
+    let i = t, s = null, o = 0;
+    const l = 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++] + " " + i)), o = o % e.length;
+    }, n), u = () => {
+      clearInterval(l), process.stdout.write(new TextEncoder().encode("\r" + " ".repeat(i.length + 5) + "\r"));
     };
     return {
-      [Symbol.dispose]: a,
-      [Symbol.asyncDispose]: a,
-      updateText: (l) => {
-        r = s, s = l;
+      [Symbol.dispose]: u,
+      [Symbol.asyncDispose]: u,
+      updateText: (c) => {
+        s = i, i = c;
       },
-      stop: a
+      stop: u
     };
   }
 }
-class E {
-  ctx;
-  helperDefinitions = {};
+class R {
+  _command;
+  description = "";
   commandsExamples = [];
-  parser;
+  get command() {
+    return this._command;
+  }
+  ctx;
   io;
-  get CommandParserClass() {
-    return x;
+  logger;
+  _handler;
+  parser;
+  tmp;
+  defaultOptions() {
+    return [new M()];
   }
-  get CommandIOClass() {
-    return S;
+  newCommandParser(t) {
+    return new k({
+      io: t.io,
+      options: t.options,
+      arguments: t.arguments
+    });
   }
-  defaultOptions() {
-    return [new V()];
+  newCommandIO(t) {
+    return new q(t.logger);
+  }
+  constructor(t, e) {
+    this._command = t, this.description = e?.description ?? "";
+    const n = this.defaultOptions();
+    if (n.length > 0) {
+      this.tmp = {
+        options: {},
+        arguments: {}
+      };
+      for (const i of n)
+        this.tmp.options[i.option] = i;
+    }
+  }
+  handler(t) {
+    return this._handler = t, this;
+  }
+  options(t) {
+    return this.tmp = {
+      options: {
+        ...this.tmp?.options ?? {},
+        ...t
+      },
+      arguments: this.tmp?.arguments ?? {}
+    }, this;
+  }
+  arguments(t) {
+    return this.tmp = {
+      options: this.tmp?.options ?? {},
+      arguments: {
+        ...this.tmp?.arguments ?? {},
+        ...t
+      }
+    }, this;
+  }
+  async run(t) {
+    if (!this._handler && !this.handle)
+      throw new Error(`No handler defined for command ${this.command || "(unknown)"}`);
+    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 s || (s[o.option] = o);
+      this.parser = this.newCommandParser({
+        io: this.io,
+        options: s,
+        arguments: this.tmp?.arguments ?? {}
+      }), e = this.parser.init(t.args);
+      for (const o of this.defaultOptions())
+        if (e.options[o.option] === !0) {
+          const l = await o.handler.call(this);
+          if (l && l !== 0)
+            return l;
+        }
+      await this.parser.validate();
+    } else
+      e = {
+        options: t.options,
+        arguments: t.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(t.ctx, e) ?? 0;
+  }
+}
+class g extends k {
+  command;
+  argumentsSchema;
+  optionsSchema;
+  constructor(t) {
+    const e = g.parseSignature(
+      t.signature,
+      t.helperDefinitions,
+      t.defaultOptions
+    );
+    super({ io: t.io, options: e.options, arguments: e.arguments }), this.command = e.command, this.optionsSchema = e.options, this.argumentsSchema = e.arguments;
+  }
+  /**
+   * Parses command signature string into command name and parameter schemas
+   * Example: "migrate {name} {--force}" -> { command: "migrate", arguments: {name: ...}, options: {force: ...} }
+   */
+  static parseSignature(t, e, n) {
+    const [i, ...s] = t.split(/\{(.*?)\}/g).map((u) => u.trim()).filter(Boolean), o = {}, l = {};
+    for (const u of s) {
+      const { name: c, isOption: m, definition: h } = g.parseParamSignature(
+        u,
+        e
+      );
+      m ? o[c] = h : l[c] = h;
+    }
+    for (const u of n)
+      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: i, options: o, arguments: l };
+  }
+  // === PUBLIC API ===
+  /**
+   * Retrieves an option value by name, with signature validation
+   */
+  option(t) {
+    if (!this.optionsSchema[t])
+      throw new b(t, this.optionsSchema);
+    return super.option(t);
+  }
+  /**
+   * Sets an option value programmatically
+   */
+  setOption(t, e) {
+    if (!this.optionsSchema[t])
+      throw new b(t, this.optionsSchema);
+    this.parsedOptions && (this.parsedOptions[t] = e);
+  }
+  /**
+   * Retrieves the description/help text for an option
+   */
+  optionHelp(t) {
+    if (!this.optionsSchema[t])
+      throw new b(t, this.optionsSchema);
+    return f(this.optionsSchema[t]).description;
+  }
+  /**
+   * Retrieves the description/help text for an argument
+   */
+  argumentHelp(t) {
+    if (!this.argumentsSchema[t])
+      throw new v(t, this.argumentsSchema);
+    return f(this.argumentsSchema[t]).description;
+  }
+  /**
+   * Retrieves an argument value by name, with signature validation
+   */
+  argument(t) {
+    if (!this.argumentsSchema[t])
+      throw new v(t, this.argumentsSchema);
+    return super.argument(t);
+  }
+  /**
+   * Sets an argument value programmatically
+   */
+  setArgument(t, e) {
+    if (!this.argumentsSchema[t])
+      throw new v(t, this.argumentsSchema);
+    this.parsedArguments && (this.parsedArguments[t] = e);
+  }
+  /**
+   * Returns all argument definitions from the signature
+   */
+  getArgumentSignatures() {
+    return this.argumentsSchema;
+  }
+  /**
+   * Returns all option definitions from the signature
+   */
+  getOptionSignatures() {
+    return this.optionsSchema;
+  }
+  /**
+   * 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(t, e) {
+    let n = t, i = !1;
+    const s = {
+      required: !0,
+      type: "string",
+      description: void 0,
+      default: null,
+      variadic: !1
+    };
+    if (n.includes(":")) {
+      const [o, l] = n.split(":");
+      n = o.trim(), s.description = l.trim();
+    }
+    if (n.includes("=")) {
+      const [o, l] = n.split("=");
+      n = o.trim(), s.default = l.trim(), s.required = !1, s.default.length ? s.default === "true" ? (s.default = !0, s.type = "boolean") : s.default === "false" && (s.default = !1, s.type = "boolean") : s.default = null;
+    } else n.startsWith("--") && (s.required = !1, s.default = !1, s.type = "boolean");
+    if (n.includes("|")) {
+      const [o, ...l] = n.split("|");
+      n = o.trim(), s.alias = l.map((u) => u.trim());
+    }
+    return n.startsWith("--") && (i = !0, n = n.slice(2)), s.default === "*" && (s.default = [], s.type = ["string"]), n.endsWith("?") && (s.required = !1, n = n.slice(0, -1)), n.endsWith("*") && (s.type = ["string"], s.variadic = !0, s.default = [], n = n.slice(0, -1)), s.description = s.description ?? e[n] ?? e[`--${n}`], { name: n, isOption: i, definition: s };
   }
+  /**
+   * Validates that all required arguments are present
+   * If missing, prompts the user via CommandIO to provide them
+   * @throws {MissingRequiredArgumentValue} If a required argument cannot be obtained
+   */
+  async validate() {
+    for (const t in this.argumentsSchema) {
+      const e = f(this.argumentsSchema[t]), n = this.argument(t);
+      if (!n && e.required) {
+        const i = await this.promptForArgument(t, e);
+        if (i)
+          this.setArgument(t, i);
+        else
+          throw new C(t);
+      }
+      if (e.variadic && e.required && typeof n == "object" && !n?.length)
+        throw new C(t);
+    }
+  }
+  /**
+   * Prompts the user to provide a missing argument value via CommandIO
+   */
+  async promptForArgument(t, e) {
+    if (e.type !== "string")
+      return null;
+    let n = a`{yellow.bold ${t}} is required`;
+    return e.description && (n += a`: {gray (${e.description})}`), n += `
+`, await this.io.askForInput(
+      n,
+      e.default,
+      {
+        validate: (i) => i?.trim()?.length ? !0 : `${t} cannot be empty`
+      }
+    );
+  }
+  optionValues() {
+    if (!this.parsedOptions)
+      throw new Error("Options have not been parsed yet. Call init() first.");
+    return this.parsedOptions;
+  }
+  argumentValues() {
+    if (!this.parsedArguments)
+      throw new Error("Arguments have not been parsed yet. Call init() first.");
+    return this.parsedArguments;
+  }
+}
+class K extends R {
+  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(t) {
+    return new g({
+      io: t.io,
+      signature: this.signature,
+      helperDefinitions: this.helperDefinitions,
+      defaultOptions: this.defaultOptions()
+    });
   }
+  constructor() {
+    super("");
+  }
+  // Helper methods from LegacyCommand
   setOption(t, e) {
     this.parser.setOption(t, e);
   }
   setArgument(t, e) {
-    this.parser.setArgument(t, e);
+    this.parser instanceof g && this.parser.setArgument(t, e);
   }
   option(t, e = null) {
-    return this.parser.option(t) ?? e;
+    return this.parser instanceof g ? this.parser.option(t) ?? e : e;
   }
   optionBoolean(t, e = !1) {
-    return this.parser.option(t) ?? e;
+    return this.parser instanceof g ? this.parser.option(t) ?? e : 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;
+    if (this.parser instanceof g) {
+      const n = this.parser.option(t);
+      if (!Array.isArray(n))
+        throw new Error(`Option ${t} is not an array`);
+      if (n.length)
+        return n;
+    }
+    return e;
   }
   optionNumber(t, e = null) {
-    const n = this.parser.option(t);
-    return n ? typeof n == "number" ? n : parseInt(n) : e;
+    if (this.parser instanceof g) {
+      const n = this.parser.option(t);
+      return n ? typeof n == "number" ? n : parseInt(n) : e;
+    }
+    return e;
   }
   argument(t, e = null) {
-    return this.parser.argument(t) ?? e;
+    return this.parser instanceof g ? this.parser.argument(t) ?? e : 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;
+    if (this.parser instanceof g) {
+      const n = this.parser.argument(t);
+      if (!Array.isArray(n))
+        throw new Error(`Argument ${t} is not an array`);
+      if (n?.length)
+        return n;
+    }
+    return e;
   }
   argumentBoolean(t, e = !1) {
-    return this.parser.argument(t) ?? e;
+    return this.parser instanceof g ? this.parser.argument(t) ?? e : e;
   }
   argumentNumber(t, e = null) {
-    const n = this.parser.argument(t);
-    return n ? typeof n == "number" ? n : parseInt(n) : e;
+    if (this.parser instanceof g) {
+      const n = this.parser.argument(t);
+      return n ? typeof n == "number" ? n : parseInt(n) : e;
+    }
+    return e;
   }
-  /**
-   * Prompt utils
-   */
+  // Prompt utils
   async askForConfirmation(...t) {
     return this.io.askForConfirmation(...t);
   }
@@ -412,26 +825,49 @@ class E {
     return this.io.newLoader(...t);
   }
 }
-class j extends c {
-  constructor(t) {
-    super(`Command "${t}" not found.`), this.command = t;
+class L {
+  level;
+  constructor(t = {}) {
+    this.level = t.level ?? "info";
+  }
+  shouldLog(t) {
+    const e = ["debug", "verbose", "info", "warn", "error", "silent"], n = e.indexOf(this.level);
+    return e.indexOf(t) >= n;
+  }
+  setLevel(t) {
+    this.level = t;
+  }
+  getLevel() {
+    return this.level;
+  }
+  log(...t) {
+    console.log(...t);
   }
-  pretty() {
-    const t = console.log;
-    t(o`{bgRed  ERROR } Command {yellow ${this.command}} not found.`);
+  info(...t) {
+    this.shouldLog("info") && console.log(...t);
+  }
+  warn(...t) {
+    this.shouldLog("warn") && console.warn(...t);
+  }
+  error(...t) {
+    this.shouldLog("error") && console.error(...t);
+  }
+  debug(...t) {
+    this.shouldLog("debug") && console.log(...t);
+  }
+  verbose(...t) {
+    this.shouldLog("verbose") && console.log(...t);
   }
 }
-class F {
+class W {
   commands = {};
   io;
-  get commandSuffix() {
-    return "Command";
-  }
+  logger;
   get CommandIOClass() {
-    return S;
+    return q;
   }
-  constructor() {
-    this.io = new this.CommandIOClass();
+  constructor(t) {
+    this.logger = t ?? new L(), this.io = new this.CommandIOClass(this.logger);
   }
   getAvailableCommands() {
     return Object.keys(this.commands);
@@ -440,15 +876,24 @@ class F {
     return Object.values(this.commands);
   }
   commandResolver = async (t) => {
-    const e = (await import(t)).default;
+    let e = (await import(t)).default;
+    if (!e)
+      throw new Error(`The command at path ${t} does not have a default export.`);
+    e?.default && (e = e.default);
     let n;
-    return e?.default ? n = new e.default() : n = new e(), n;
+    if (typeof e == "function")
+      n = new e();
+    else if (e instanceof R)
+      n = e;
+    else
+      throw new Error(`The command at path ${t} is not a valid command class.`);
+    return n;
   };
   setCommandResolver(t) {
     this.commandResolver = t;
   }
   registerCommand(t, e = !1) {
-    const n = t.signature.split(" ")[0];
+    const n = t.command;
     if (!n)
       throw new Error("Command signature is invalid, it must have a command name.");
     if (!e && this.commands[n])
@@ -461,126 +906,115 @@ class F {
         const n = await this.commandResolver(e);
         this.registerCommand(n);
       } catch (n) {
-        throw new Error(`Command ${e} failed to load. ${n}`);
+        throw new Error(`Command ${e} 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;
-    if (!s) {
-      const i = await this.suggestCommand(r);
-      return i ? await this.runCommand(t, i, ...n) : 1;
+    const i = typeof e == "string" ? this.commands[e] : e, s = typeof e == "string" ? e : i.command;
+    if (!i) {
+      const o = await this.suggestCommand(s);
+      return o ? await this.runCommand(t, o, ...n) : 1;
     }
-    return await s.run(t, ...n);
+    return await i.run({
+      ctx: t,
+      logger: this.logger,
+      args: n
+    }) ?? 0;
   }
   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;
+    const e = this.getAvailableCommands(), { bestMatch: n, bestMatchIndex: i, ratings: s } = V.findBestMatch(t, e), o = s.filter((l) => l.rating > 0.3).map((l) => l.target);
+    if (n.rating > 0 && o.length <= 1 || n.rating > 0.7 && o.length > 1) {
+      const l = e[i];
+      return await this.askRunSimilarCommand(t, l) ? l : 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 (o.length) {
+      this.io.error(a`{bgRed  ERROR } Command {yellow ${t}} not found.\n`);
+      const l = await this.io.askForSelect(
+        a`{green Did you mean to run one of these commands instead?}`,
+        o
       );
-      if (m)
-        return m;
+      if (l)
+        return l;
     }
     throw new j(t);
   }
   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?} `);
+    return this.io.error(a`{bgRed  ERROR } Command {yellow ${t}} not found.\n`), this.io.askForConfirmation(a`{green Do you want to run {yellow ${e}} instead?} `);
   }
   async *listCommandsFiles(t) {
-    const e = R.readdirSync(t, { withFileTypes: !0 });
+    const e = F.readdirSync(t, { withFileTypes: !0 });
     for (const n of e) {
-      const s = $.resolve(t, n.name);
-      if (n.isDirectory())
-        yield* this.listCommandsFiles($.resolve(t, n.name));
-      else {
-        if (!s.endsWith(`${this.commandSuffix}.ts`) && !s.endsWith(`${this.commandSuffix}.js`))
-          continue;
-        yield s;
-      }
+      const i = S.resolve(t, n.name);
+      n.isDirectory() ? yield* this.listCommandsFiles(S.resolve(t, n.name)) : yield i;
     }
   }
 }
-class k extends E {
+class B extends R {
   constructor(t) {
-    super(), this.opts = t;
+    super("help", {
+      description: a.bold("Show help information about the CLI and its commands")
+    }), this.opts = t;
   }
-  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 t = this.opts.commandRegistry.getCommands(), e = this.opts.cliName ?? "Bob CLI", n = this.opts.cliVersion ?? "0.0.0", i = (await import("./package-Pf7NCMvE.js"))?.default?.version ?? "0.0.0";
+    this.io.log(a`${e} {green ${n}} (core: {yellow ${i}})
 
 {yellow Usage}:
   command [options] [arguments]
 
 {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 s = Math.max(...t.map((u) => u.command.length)) ?? 0, o = {};
+    for (const u of t) {
+      const c = u.command.split(":")[0];
+      o[c] || (o[c] = []), o[c].push(u);
     }
-    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()));
+    const l = Object.entries(o).sort(([u], [c]) => u.toLowerCase().localeCompare(c.toLowerCase())).sort(([, u], [, c]) => u.length - c.length);
+    for (const [u, c] of l) {
+      const m = c.length > 1;
+      m && this.io.log(a`{yellow ${u}}:`);
+      const h = c.sort((d, p) => d.command.toLowerCase().localeCompare(p.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}`);
+        let p = O(s - d.command.length);
+        m && (p = p.slice(2)), this.io.log(a`${m ? "  " : ""}{green ${d.command}} ${p} ${d.description}`);
       }
     }
   }
 }
-class W extends c {
+class P {
+  logger;
   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}`);
+    this.logger = t;
   }
-}
-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;
+    if (t instanceof y)
+      return t.pretty(this.logger), -1;
     throw t;
   }
 }
-class N {
+class Q {
+  ctx;
+  logger;
   commandRegistry;
   exceptionHandler;
-  ctx;
   helpCommand;
-  get CommandRegistryClass() {
-    return F;
+  newCommandRegistry(t) {
+    return new W(t.logger);
   }
-  get HelpCommandClass() {
-    return k;
+  newHelpCommand(t) {
+    return new B(t);
   }
-  get ExceptionHandlerClass() {
-    return H;
+  newExceptionHandler(t) {
+    return new P(t.logger);
   }
   constructor(t = {}) {
-    this.ctx = t.ctx, this.commandRegistry = new this.CommandRegistryClass(), this.exceptionHandler = new this.ExceptionHandlerClass(), this.helpCommand = new this.HelpCommandClass({
+    this.ctx = t.ctx, this.logger = t.logger ?? new L(), this.commandRegistry = this.newCommandRegistry({
+      logger: this.logger
+    }), this.exceptionHandler = this.newExceptionHandler({
+      logger: this.logger
+    }), this.helpCommand = this.newHelpCommand({
       cliName: t.name,
       cliVersion: t.version,
       commandRegistry: this.commandRegistry
@@ -594,7 +1028,7 @@ class N {
       typeof e == "string" ? await this.commandRegistry.loadCommandsPath(e) : typeof e == "function" ? this.registerCommand(new e()) : this.registerCommand(e);
   }
   async runCommand(t, ...e) {
-    return t ? await this.commandRegistry.runCommand(this.ctx, t, ...e).catch(this.exceptionHandler.handle) : await this.runHelpCommand();
+    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);
@@ -604,11 +1038,23 @@ class N {
   }
 }
 export {
-  M as BadCommandOption,
-  W as BadCommandParameter,
-  c as BobError,
-  N as Cli,
-  E as Command,
-  S as CommandIO,
-  V as HelpOption
+  $ as BadCommandOption,
+  J as BadCommandParameter,
+  y as BobError,
+  Q as Cli,
+  R as Command,
+  q as CommandIO,
+  j as CommandNotFoundError,
+  k as CommandParser,
+  W as CommandRegistry,
+  g as CommandSignatureParser,
+  K as CommandWithSignature,
+  P as ExceptionHandler,
+  M as HelpOption,
+  H as InvalidOption,
+  L as Logger,
+  C as MissingRequiredArgumentValue,
+  T as MissingRequiredOptionValue,
+  v as MissingSignatureArgument,
+  b as MissingSignatureOption
 };