bob-core 2.0.0-beta.4 → 2.0.0-beta.6

package/dist/esm/index.js

@@ -1,174 +1,141 @@
-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 {
+import q from "minimist";
+import l from "chalk";
+import y from "prompts";
+import * as D from "node:fs";
+import R from "path";
+import * as P from "string-similarity";
+class f extends Error {
 }
-class J extends y {
-  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;
+class U extends f {
+  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(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}`);
+  pretty(e) {
+    e.log(l`  {white.bgRed  ERROR } Argument {bold.yellow ${this.param.param}} value is invalid. `), (this.param.value || this.param.reason) && e.log(""), this.param.value && e.log(l`  {blue Value}: ${this.param.value}`), this.param.reason && e.log(l`  {yellow Reason}: ${this.param.reason}`);
   }
 }
-class b 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;
+class A extends f {
+  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(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}`);
+  pretty(e) {
+    e.log(l`  {white.bgRed  ERROR } Option {bold.yellow ${this.param.option}} value is invalid. `), (this.param.value || this.param.reason) && e.log(""), this.param.value && e.log(l`  {blue Value}: ${this.param.value}`), this.param.reason && e.log(l`  {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 x(i) {
+  if (i === "string" || i === "secret" || i === "number") return null;
+  if (i === "boolean") return !1;
+  if (Array.isArray(i) && i.length === 1) {
+    if (i[0] === "string") return [];
+    if (i[0] === "number") return [];
+  }
+  throw new Error("Invalid option type: " + i);
 }
-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 k(i) {
+  return !Array.isArray(i) && typeof i == "object" && i.type ? i.default !== void 0 ? i.default : x(i.type) : x(i);
 }
-function f(r) {
-  return typeof r == "string" || Array.isArray(r) ? {
-    type: r,
-    default: D(r),
+function g(i) {
+  return typeof i == "string" || Array.isArray(i) ? {
+    type: i,
+    default: k(i),
     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
+    type: i.type,
+    default: i.default ?? k(i.type),
+    description: i.description ?? "",
+    alias: i.alias ? Array.isArray(i.alias) ? i.alias : [i.alias] : [],
+    required: i.required ?? !1,
+    variadic: i.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})}`);
+class b extends f {
+  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(l`\n{yellow Available options}:`);
+      for (const [n, s] of t) {
+        const r = g(s), o = typeof r.alias == "string" ? [r.alias] : r.alias, u = Array.isArray(r.type) ? `[${r.type[0]}]` : r.type, m = `--${n}${o.length > 0 ? o.map((a) => `, -${a}`).join("") : ""}`, p = " ".repeat(30 - m.length);
+        e.log(l`  {green ${m}} ${p} ${r.description || "\b"} {white (${u})}`);
       }
-      t.log("");
+      e.log("");
     }
-    t.log(a`{white.bgRed  ERROR } Option {bold.yellow ${this.option}} is not recognized.`);
+    e.log(l`{white.bgRed  ERROR } Option {bold.yellow ${this.option}} is not recognized.`);
   }
 }
-class j extends y {
-  constructor(t) {
-    super(`Command "${t}" not found.`), this.command = t;
+class V extends f {
+  constructor(e) {
+    super(`Command "${e}" not found.`), this.command = e;
   }
-  pretty(t) {
-    t.log(a`{bgRed  ERROR } Command {yellow ${this.command}} not found.`);
+  pretty(e) {
+    e.log(l`{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.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.log("");
-    }
-    t.log(a`{white.bgRed  ERROR } Argument {bold.yellow ${this.argument}} is missing in the signature.`);
+class E extends f {
+  constructor(e) {
+    super(`Argument "${e}" is required.`), this.argument = e;
   }
-}
-class A extends y {
-  constructor(t, e) {
-    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.log("");
-    }
-    t.log(a`{white.bgRed  ERROR } Option {bold.yellow ${this.option}} is missing in the signature.`);
+  pretty(e) {
+    e.log(l`{white.bgRed  ERROR } Argument {bold.yellow ${this.argument}} is required.`);
   }
 }
-class C extends y {
-  constructor(t) {
-    super(`Argument "${t}" is required.`), this.argument = t;
+class I extends f {
+  constructor(e) {
+    super(`Argument "${e}" is required.`), this.option = e;
   }
-  pretty(t) {
-    t.log(a`{white.bgRed  ERROR } Argument {bold.yellow ${this.argument}} is required.`);
+  pretty(e) {
+    e.log(l`{white.bgRed  ERROR } Option {bold.yellow ${this.option}} is required.`);
   }
 }
-class T extends y {
-  constructor(t) {
-    super(`Argument "${t}" is required.`), this.option = t;
-  }
-  pretty(t) {
-    t.log(a`{white.bgRed  ERROR } Option {bold.yellow ${this.option}} is required.`);
-  }
-}
-function $(r, t, e, n) {
-  if (r == null)
+function v(i, e, t, n) {
+  if (i == null)
     return n ?? null;
-  if (t === "string")
-    return String(r);
-  if (t === "number") {
-    const i = Number(r);
-    if (isNaN(i))
-      throw new b({
-        option: e,
-        reason: `Expected a number, got "${r}"`
+  if (e === "string")
+    return String(i);
+  if (e === "number") {
+    const s = Number(i);
+    if (isNaN(s))
+      throw new A({
+        option: t,
+        reason: `Expected a number, got "${i}"`
       });
-    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 b({
-            option: e,
+    return s;
+  }
+  if (e === "boolean")
+    return typeof i == "boolean" ? i : i === "true" || i === "1" ? !0 : i === "false" || i === "0" ? !1 : !!i;
+  if (Array.isArray(e)) {
+    const s = e[0], r = Array.isArray(i) ? i : [i];
+    if (s === "string")
+      return r.map((o) => String(o));
+    if (s === "number")
+      return r.map((o) => {
+        const u = Number(o);
+        if (isNaN(u))
+          throw new A({
+            option: t,
             reason: `Expected array of numbers, got "${o}" in array`
           });
-        return l;
+        return u;
       });
   }
-  return r;
+  return i;
 }
-class k {
+class F {
   options;
   parsedOptions = null;
   arguments;
   parsedArguments = null;
   io;
-  constructor(t) {
-    this.options = t.options, this.arguments = t.arguments, this.io = t.io;
+  shouldPromptForMissingOptions = !0;
+  constructor(e) {
+    this.options = e.options, this.arguments = e.arguments, this.io = e.io;
   }
   // === PUBLIC METHODS ===
   /**
@@ -178,9 +145,9 @@ class k {
    * @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), {
+  init(e) {
+    const { _: t, ...n } = q(e);
+    return this.validateUnknownOptions(n), this.parsedOptions = this.handleOptions(n), this.parsedArguments = this.handleArguments(t), {
       options: this.parsedOptions,
       arguments: this.parsedArguments
     };
@@ -190,12 +157,32 @@ class k {
    * @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);
+    for (const e in this.options)
+      if (g(this.options[e]).required && (this.parsedOptions?.[e] === void 0 || this.parsedOptions?.[e] === null))
+        throw new I(e);
+    for (const e in this.arguments) {
+      const t = g(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] = v(s, t.type, e);
+            continue;
+          }
+        }
+        throw new E(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] = v(s, t.type, e);
+            continue;
+          }
+        }
+        throw new E(e);
+      }
+    }
   }
   /**
    * Retrieves a parsed option value by name
@@ -203,10 +190,17 @@ class k {
    * @returns The typed option value
    * @throws {Error} If init() has not been called yet
    */
-  option(t) {
+  option(e) {
     if (!this.parsedOptions)
       throw new Error("Options have not been parsed yet. Call init() first.");
-    return this.parsedOptions[t];
+    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 b(e, this.options);
+    this.parsedOptions[e] = t;
   }
   /**
    * Retrieves a parsed argument value by name
@@ -214,105 +208,111 @@ class k {
    * @returns The typed argument value
    * @throws {Error} If init() has not been called yet
    */
-  argument(t) {
+  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.");
-    return this.parsedArguments[t];
+    if (!(e in this.arguments))
+      throw new b(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(t) {
-    const e = /* @__PURE__ */ new Set();
+  validateUnknownOptions(e) {
+    const t = /* @__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);
+      t.add(n);
+      const s = g(this.options[n]);
+      for (const r of s.alias)
+        t.add(r);
     }
-    for (const n in t)
-      if (!e.has(n))
-        throw new H(n, this.options);
+    for (const n in e)
+      if (!t.has(n))
+        throw new b(n, this.options);
   }
   /**
    * Processes named options from minimist output
    */
-  handleOptions(t) {
-    const e = {};
+  handleOptions(e) {
+    const t = {};
     for (const n in this.options) {
-      const i = f(this.options[n]);
-      e[n] = this.resolveOptionValue(
+      const s = g(this.options[n]);
+      t[n] = this.resolveOptionValue(
         n,
-        i,
-        t,
-        "option"
+        s,
+        e
       );
     }
-    return e;
+    return t;
   }
   /**
    * 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);
+  handleArguments(e) {
+    const t = {}, n = [...e];
+    for (const s in this.arguments) {
+      const r = g(this.arguments[s]);
+      if (r.variadic) {
+        t[s] = this.handleVariadicArgument(s, r, n);
         continue;
       }
-      e[i] = this.resolveArgumentValue(i, s, n.shift());
+      t[s] = this.resolveArgumentValue(s, r, n.shift());
     }
-    return e;
+    return t;
   }
   /**
    * Handles variadic arguments that consume all remaining positional values
    */
-  handleVariadicArgument(t, e, n) {
-    return n.length ? $(n, e.type, t, e.default) : e.default;
+  handleVariadicArgument(e, t, n) {
+    return n.length ? v(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(t, e, n) {
-    return n === void 0 ? e.default : $(n, e.type, t, e.default);
+  resolveArgumentValue(e, t, n) {
+    return n === void 0 ? t.default : v(n, t.type, e, t.default);
   }
   /**
    * Resolves an option value from the parsed option values object
    * Handles alias resolution, defaults, and type conversion
    */
-  resolveOptionValue(t, e, n, i) {
+  resolveOptionValue(e, t, n) {
     let s;
-    const o = [t, ...e.alias];
-    for (const l of o)
-      if (l in n) {
-        s = n[l];
+    const r = [e, ...t.alias];
+    for (const o of r)
+      if (o in n) {
+        s = n[o];
         break;
       }
     if (s === void 0) {
-      if (e.required)
-        throw new b({
-          option: t,
-          reason: `${i === "option" ? "Option" : "Argument"} is required but not provided`
+      if (t.required)
+        throw new A({
+          option: e,
+          reason: "Required option is missing"
         });
-      return e.default;
+      return t.default;
     }
-    return $(s, e.type, t, e.default);
+    return v(s, t.type, e, t.default);
   }
   optionDefinitions() {
-    const t = {};
-    for (const e in this.options)
-      t[e] = f(this.options[e]);
-    return t;
+    const e = {};
+    for (const t in this.options)
+      e[t] = g(this.options[t]);
+    return e;
   }
   argumentDefinitions() {
-    const t = {};
-    for (const e in this.arguments)
-      t[e] = f(this.arguments[e]);
-    return t;
+    const e = {};
+    for (const t in this.arguments)
+      e[t] = g(this.arguments[t]);
+    return e;
   }
   availableOptions() {
     return Object.keys(this.options);
@@ -320,152 +320,213 @@ class k {
   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 = l`{yellow.bold ${e}} is required`;
+    return t.description && (n += l`: {gray (${t.description})}`), n += `
+`, Array.isArray(t.type) ? (n += l`Please provide one or more values, separated by commas:\n`, await this.io.askForList(
+      n,
+      void 0,
+      {
+        validate: (s) => s.length ? !0 : "Please enter at least one value"
+      }
+    )) : await this.io.askForInput(
+      n,
+      void 0,
+      {
+        type: t.type === "number" ? "number" : t.type === "secret" ? "password" : "text",
+        validate: (s) => {
+          if (t.type === "number") {
+            const r = Number(s);
+            if (isNaN(r))
+              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 O(r) {
-  return new Array(r + 5).join(" ");
+function O(i) {
+  return new Array(i + 5).join(" ");
 }
-class W {
+class H {
   type = "boolean";
   option = "help";
   alias = ["h"];
   default = !1;
-  description = a`Display help for the given command. When no command is given display help for the {green list} command`;
+  description = l`Display help for the given command. When no command is given display help for the {green list} command`;
   async handler() {
-    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] : [];
+    const e = this.parser.argumentDefinitions(), t = this.parser.optionDefinitions(), n = Object.entries(e), s = Object.entries(t), r = s.map(([a, d]) => {
+      const c = Array.isArray(d.alias) ? d.alias : d.alias ? [d.alias] : [];
       return {
-        name: m,
-        ...h,
-        optionWithAlias: `--${m}${d.map((p) => `, -${p}`).join("")}`
+        name: a,
+        ...d,
+        optionWithAlias: `--${a}${c.map((h) => `, -${h}`).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;
+    }), o = n.filter(([, a]) => a.required);
+    this.io.log(l`{yellow Description}:`), this.io.log(l`  ${this.description}\n`), this.io.log(l`{yellow Usage}:`), this.io.log(l`  ${this.command} ${o.length > 0 ? o.map(([a]) => `<${a}>`).join(" ") : "\b"} [options]`);
+    const u = Math.max(...r.map((a) => a.optionWithAlias.length), 0), m = Math.max(...n.map(([a]) => a.length), 0), p = m > u ? m : u;
     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 L = (Array.isArray(h.type) ? `[${h.type[0]}]` : h.type) === "array" || Array.isArray(h.type) ? JSON.stringify(h.default) : h.default;
-          p += a` {yellow [default: ${L}]}`;
+      this.io.log(l`\n{yellow Arguments}:`);
+      for (const [a, d] of n) {
+        const c = O(p - a.length);
+        let h = l`  {green ${a}} ${c} ${d.description ?? "\b"}`;
+        if (d.default !== void 0 && !d.required) {
+          const N = (Array.isArray(d.type) ? `[${d.type[0]}]` : d.type) === "array" || Array.isArray(d.type) ? JSON.stringify(d.default) : d.default;
+          h += l` {yellow [default: ${N}]}`;
         }
-        h.variadic && (p += a` {white (variadic)}`), this.io.log(p);
+        d.variadic && (h += l` {white (variadic)}`), this.io.log(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 (s.length > 0) {
+      this.io.log(l`\n{yellow Options}:`);
+      for (const a of r) {
+        const d = O(p - a.optionWithAlias.length);
+        let c = l`{green ${a.optionWithAlias}} ${d} ${a.description ?? "\b"}`;
+        if (a.type) {
+          const h = Array.isArray(a.type) ? `[${a.type[0]}]` : a.type;
+          c += l` {white (${h})}`;
         }
-        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}]}`;
+        if (a.default !== void 0 && !a.required) {
+          const $ = (Array.isArray(a.type) ? `[${a.type[0]}]` : a.type) === "array" || Array.isArray(a.type) ? JSON.stringify(a.default) : a.default;
+          c += l` {yellow [default: ${$}]}`;
         }
-        this.io.log(d);
+        this.io.log(c);
       }
     }
     if (this.commandsExamples.length > 0) {
-      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}}`);
+      this.io.log(l`\n{yellow Examples}:`);
+      let a = process.argv[0].split("/").pop();
+      a === "node" && (a += " " + process.argv[1].split("/").pop());
+      for (const [d, c] of this.commandsExamples.entries())
+        d > 0 && this.io.log(""), this.io.log(`  ${c.description}
+`), this.io.log(l`    {green ${a} ${c.command}}`);
     }
     return -1;
   }
 }
-class q {
+class S {
   logger;
-  constructor(t) {
-    this.logger = t;
+  constructor(e) {
+    this.logger = e;
   }
   /**
    * Logger methods
    */
-  log(...t) {
-    this.logger.log(...t);
+  log(...e) {
+    this.logger.log(...e);
   }
-  info(...t) {
-    this.logger.info(...t);
+  info(...e) {
+    this.logger.info(...e);
   }
-  warn(...t) {
-    this.logger.warn(...t);
+  warn(...e) {
+    this.logger.warn(...e);
   }
-  error(...t) {
-    this.logger.error(...t);
+  error(...e) {
+    this.logger.error(...e);
   }
-  debug(...t) {
-    this.logger.debug(...t);
+  debug(...e) {
+    this.logger.debug(...e);
   }
   /**
    * Prompt utils
    */
-  async askForConfirmation(t = "Do you want to continue?", e) {
-    return (await w({
+  async askForConfirmation(e = "Do you want to continue?", t) {
+    return (await y({
       type: "confirm",
       name: "value",
-      message: t,
-      initial: e ?? !1
+      message: e,
+      initial: t ?? !1
     })).value;
   }
-  async askForInput(t, e, n) {
-    return (await w({
+  async askForInput(e, t, n) {
+    return (await y({
       type: "text",
       name: "value",
-      message: t,
-      initial: e,
+      message: e,
+      initial: t,
+      ...n
+    }))?.value ?? null;
+  }
+  async askForDate(e, t, n) {
+    return (await y({
+      type: "date",
+      name: "value",
+      message: e,
+      initial: t,
+      ...n
+    }))?.value ?? null;
+  }
+  async askForList(e, t, n) {
+    return (await y({
+      type: "list",
+      name: "value",
+      message: e,
+      initial: t,
       ...n
     }))?.value ?? null;
   }
-  async askForToggle(t, e, n) {
-    return (await w({
+  async askForToggle(e, t, n) {
+    return (await y({
       type: "toggle",
       name: "value",
-      message: t,
-      initial: e,
+      message: e,
+      initial: t,
       ...n
     }))?.value ?? null;
   }
-  async askForSelect(t, e, n) {
-    if (e.length === 0)
+  async askForSelect(e, t, n) {
+    if (t.length === 0)
       throw new Error("No options provided");
-    const i = [];
-    for (const o of e)
-      typeof o == "string" ? i.push({ title: o, value: o }) : i.push(o);
-    return (await w({
+    const s = [];
+    for (const o of t)
+      typeof o == "string" ? s.push({ title: o, value: o }) : s.push(o);
+    return (await y({
       type: "select",
       name: "value",
-      message: t,
-      choices: i,
+      message: e,
+      choices: s,
       ...n
     }))?.value ?? null;
   }
-  newLoader(t = "", e = ["⠙", "⠘", "⠰", "⠴", "⠤", "⠦", "⠆", "⠃", "⠋", "⠉"], n = 100) {
-    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"));
+  newLoader(e = "", t = ["⠙", "⠘", "⠰", "⠴", "⠤", "⠦", "⠆", "⠃", "⠋", "⠉"], n = 100) {
+    let s = e, r = null, o = 0;
+    const u = setInterval(function() {
+      r && (process.stdout.write(new TextEncoder().encode("\r" + " ".repeat(r.length + 5) + "\r")), r = 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]: u,
-      [Symbol.asyncDispose]: u,
-      updateText: (c) => {
-        s = i, i = c;
+      [Symbol.dispose]: m,
+      [Symbol.asyncDispose]: m,
+      updateText: (p) => {
+        r = s, s = p;
       },
-      stop: u
+      stop: m
     };
   }
 }
-class R {
+class C {
   _command;
   description = "";
+  group;
   commandsExamples = [];
   get command() {
     return this._command;
@@ -473,81 +534,89 @@ class R {
   ctx;
   io;
   logger;
-  _handler;
   parser;
+  disablePromptingFlag = !1;
+  _preHandler;
+  _handler;
   tmp;
   defaultOptions() {
-    return [new W()];
+    return [new H()];
   }
-  newCommandParser(t) {
-    return new k({
-      io: t.io,
-      options: t.options,
-      arguments: t.arguments
+  newCommandParser(e) {
+    return new F({
+      io: e.io,
+      options: e.options,
+      arguments: e.arguments
     });
   }
-  newCommandIO(t) {
-    return new q(t.logger);
+  newCommandIO(e) {
+    return new S(e.logger);
   }
-  constructor(t, e) {
-    this._command = t, this.description = e?.description ?? "";
+  constructor(e, t) {
+    this._command = e, this.description = t?.description ?? "", this.group = t?.group;
     const n = this.defaultOptions();
     if (n.length > 0) {
       this.tmp = {
         options: {},
         arguments: {}
       };
-      for (const i of n)
-        this.tmp.options[i.option] = i;
+      for (const s of n)
+        this.tmp.options[s.option] = s;
     }
   }
-  handler(t) {
-    return this._handler = t, this;
+  disablePrompting() {
+    return this.disablePromptingFlag = !0, this;
   }
-  options(t) {
+  preHandler(e) {
+    return this._preHandler = e, this;
+  }
+  handler(e) {
+    return this._handler = e, this;
+  }
+  options(e) {
     return this.tmp = {
       options: {
         ...this.tmp?.options ?? {},
-        ...t
+        ...e
       },
       arguments: this.tmp?.arguments ?? {}
     }, this;
   }
-  arguments(t) {
+  arguments(e) {
     return this.tmp = {
       options: this.tmp?.options ?? {},
       arguments: {
         ...this.tmp?.arguments ?? {},
-        ...t
+        ...e
       }
     }, this;
   }
-  async run(t) {
+  async run(e) {
     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 ?? {};
+    let t;
+    if (this.ctx = e.ctx, this.logger = e.logger, this.io = this.newCommandIO({
+      logger: e.logger
+    }), e && "args" in e) {
+      const r = this.tmp?.options ?? {};
       for (const o of this.defaultOptions())
-        o.option in s || (s[o.option] = o);
+        o.option in r || (r[o.option] = o);
       this.parser = this.newCommandParser({
         io: this.io,
-        options: s,
+        options: r,
         arguments: this.tmp?.arguments ?? {}
-      }), e = this.parser.init(t.args);
+      }), t = this.parser.init(e.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;
+        if (t.options[o.option] === !0) {
+          const u = await o.handler.call(this);
+          if (u && u !== 0)
+            return u;
         }
-      await this.parser.validate();
+      this.disablePromptingFlag && this.parser.disablePrompting(), await this.parser.validate();
     } else
-      e = {
-        options: t.options,
-        arguments: t.arguments
+      t = {
+        options: e.options,
+        arguments: e.arguments
       };
     const n = this.preHandle ? await this.preHandle() : null;
     if (n && n !== 0)
@@ -556,105 +625,42 @@ class R {
       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;
+    return await this._handler(e.ctx, t) ?? 0;
   }
 }
-class g extends k {
+class w extends F {
   command;
-  argumentsSchema;
-  optionsSchema;
-  constructor(t) {
-    const e = g.parseSignature(
-      t.signature,
-      t.helperDefinitions,
-      t.defaultOptions
+  constructor(e) {
+    const t = w.parseSignature(
+      e.signature,
+      e.helperDefinitions,
+      e.defaultOptions
     );
-    super({ io: t.io, options: e.options, arguments: e.arguments }), this.command = e.command, this.optionsSchema = e.options, this.argumentsSchema = e.arguments;
+    super({ io: e.io, options: t.options, arguments: t.arguments }), this.command = t.command;
   }
   /**
    * 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
+  static parseSignature(e, t, n) {
+    const [s, ...r] = e.split(/\{(.*?)\}/g).map((m) => m.trim()).filter(Boolean), o = {}, u = {};
+    for (const m of r) {
+      const { name: p, isOption: a, definition: d } = w.parseParamSignature(
+        m,
+        t
       );
-      m ? o[c] = h : l[c] = h;
+      a ? o[p] = d : u[p] = d;
     }
-    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
+    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: i, options: o, arguments: l };
-  }
-  // === PUBLIC API ===
-  /**
-   * Retrieves an option value by name, with signature validation
-   */
-  option(t) {
-    if (!this.optionsSchema[t])
-      throw new A(t, this.optionsSchema);
-    return super.option(t);
-  }
-  /**
-   * Sets an option value programmatically
-   */
-  setOption(t, e) {
-    if (!this.optionsSchema[t])
-      throw new A(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 A(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;
+    return { command: s, options: o, arguments: u };
   }
   /**
    * Parses a single parameter signature like "{name}" or "{--force}" or "{files*}"
@@ -670,9 +676,9 @@ class g extends k {
    * - {--opt=}       -> string option
    * - {--opt|o}      -> option with alias
    */
-  static parseParamSignature(t, e) {
-    let n = t, i = !1;
-    const s = {
+  static parseParamSignature(e, t) {
+    let n = e, s = !1;
+    const r = {
       required: !0,
       type: "string",
       description: void 0,
@@ -680,73 +686,28 @@ class g extends k {
       variadic: !1
     };
     if (n.includes(":")) {
-      const [o, l] = n.split(":");
-      n = o.trim(), s.description = l.trim();
+      const [o, u] = n.split(":");
+      n = o.trim(), r.description = u.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");
+      const [o, u] = n.split("=");
+      n = o.trim(), r.default = u.trim(), r.required = !1, r.default.length ? r.default === "true" ? (r.default = !0, r.type = "boolean") : r.default === "false" && (r.default = !1, r.type = "boolean") : r.default = null;
+    } else n.startsWith("--") && (r.required = !1, r.default = !1, r.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);
+      const [o, ...u] = n.split("|");
+      n = o.trim(), r.alias = u.map((m) => m.trim());
     }
-  }
-  /**
-   * 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;
+    return n.startsWith("--") && (s = !0, n = n.slice(2)), r.default === "*" && (r.default = [], r.type = ["string"]), n.endsWith("?") && (r.required = !1, n = n.slice(0, -1)), n.endsWith("*") && (r.type = ["string"], r.variadic = !0, r.default = [], n = n.slice(0, -1)), r.description = r.description ?? t[n] ?? t[`--${n}`], { name: n, isOption: s, definition: r };
   }
 }
-class K extends R {
+class z extends C {
   helperDefinitions = {};
   get command() {
     return this.parser ? this.parser.command : this.signature.split(" ")[0];
   }
-  newCommandParser(t) {
-    return new g({
-      io: t.io,
+  newCommandParser(e) {
+    return new w({
+      io: e.io,
       signature: this.signature,
       helperDefinitions: this.helperDefinitions,
       defaultOptions: this.defaultOptions()
@@ -755,113 +716,66 @@ class K extends R {
   constructor() {
     super("");
   }
-  // Helper methods from LegacyCommand
-  setOption(t, e) {
-    this.parser.setOption(t, e);
-  }
-  setArgument(t, e) {
-    this.parser instanceof g && this.parser.setArgument(t, e);
+  option(e, t = null) {
+    return this.parser instanceof w ? this.parser.option(e) ?? t : t;
   }
-  option(t, e = null) {
-    return this.parser instanceof g ? this.parser.option(t) ?? e : e;
-  }
-  optionBoolean(t, e = !1) {
-    return this.parser instanceof g ? this.parser.option(t) ?? e : e;
-  }
-  optionArray(t, 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) {
-    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 instanceof g ? this.parser.argument(t) ?? e : e;
-  }
-  argumentArray(t, 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 instanceof g ? this.parser.argument(t) ?? e : e;
-  }
-  argumentNumber(t, e = null) {
-    if (this.parser instanceof g) {
-      const n = this.parser.argument(t);
-      return n ? typeof n == "number" ? n : parseInt(n) : e;
-    }
-    return e;
+  argument(e, t = null) {
+    return this.parser instanceof w ? this.parser.argument(e) ?? t : t;
   }
   // Prompt utils
-  async askForConfirmation(...t) {
-    return this.io.askForConfirmation(...t);
+  async askForConfirmation(...e) {
+    return this.io.askForConfirmation(...e);
   }
-  async askForInput(...t) {
-    return this.io.askForInput(...t);
+  async askForInput(...e) {
+    return this.io.askForInput(...e);
   }
-  async askForSelect(...t) {
-    return this.io.askForSelect(...t);
+  async askForSelect(...e) {
+    return this.io.askForSelect(...e);
   }
-  newLoader(...t) {
-    return this.io.newLoader(...t);
+  newLoader(...e) {
+    return this.io.newLoader(...e);
   }
 }
-class N {
+class L {
   level;
-  constructor(t = {}) {
-    this.level = t.level ?? "info";
+  constructor(e = {}) {
+    this.level = e.level ?? "info";
   }
-  shouldLog(t) {
-    const e = ["debug", "info", "warn", "error"], n = e.indexOf(this.level);
-    return e.indexOf(t) >= n;
+  shouldLog(e) {
+    const t = ["debug", "info", "warn", "error"], n = t.indexOf(this.level);
+    return t.indexOf(e) >= n;
   }
-  setLevel(t) {
-    this.level = t;
+  setLevel(e) {
+    this.level = e;
   }
   getLevel() {
     return this.level;
   }
-  log(...t) {
-    console.log(...t);
+  log(...e) {
+    console.log(...e);
   }
-  info(...t) {
-    this.shouldLog("info") && console.log(...t);
+  info(...e) {
+    this.shouldLog("info") && console.log(...e);
   }
-  warn(...t) {
-    this.shouldLog("warn") && console.warn(...t);
+  warn(...e) {
+    this.shouldLog("warn") && console.warn(...e);
   }
-  error(...t) {
-    this.shouldLog("error") && console.error(...t);
+  error(...e) {
+    this.shouldLog("error") && console.error(...e);
   }
-  debug(...t) {
-    this.shouldLog("debug") && console.log(...t);
+  debug(...e) {
+    this.shouldLog("debug") && console.log(...e);
   }
 }
-class M {
+class j {
   commands = {};
   io;
   logger;
   get CommandIOClass() {
-    return q;
+    return S;
   }
-  constructor(t) {
-    this.logger = t ?? new N(), this.io = new this.CommandIOClass(this.logger);
+  constructor(e) {
+    this.logger = e ?? new L(), this.io = new this.CommandIOClass(this.logger);
   }
   getAvailableCommands() {
     return Object.keys(this.commands);
@@ -869,192 +783,186 @@ class M {
   getCommands() {
     return Object.values(this.commands);
   }
-  commandResolver = async (t) => {
-    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;
-    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;
+  commandResolver = async (e) => {
+    let t = (await import(e)).default;
+    if (!t)
+      throw new Error(`The command at path ${e} does not have a default export.`);
+    return t?.default && (t = t.default), typeof t == "function" ? new t() : t instanceof C ? t : null;
   };
-  setCommandResolver(t) {
-    this.commandResolver = t;
+  setCommandResolver(e) {
+    this.commandResolver = e;
+  }
+  fileCheck = (e) => !0;
+  setFileCheck(e) {
+    return this.fileCheck = e, this;
   }
-  registerCommand(t, e = !1) {
-    const n = t.command;
+  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 C && 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 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;
+  async runCommand(e, t, ...n) {
+    const s = typeof t == "string" ? this.commands[t] : t, r = typeof t == "string" ? t : s.command;
+    if (!s) {
+      const o = await this.suggestCommand(r);
+      return o ? await this.runCommand(e, o, ...n) : 1;
     }
-    return await i.run({
-      ctx: t,
+    return await s.run({
+      ctx: e,
       logger: this.logger,
       args: n
     }) ?? 0;
   }
-  async suggestCommand(t) {
-    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);
+  async suggestCommand(e) {
+    const t = this.getAvailableCommands(), { bestMatch: n, bestMatchIndex: s, ratings: r } = P.findBestMatch(e, t), o = r.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 l = e[i];
-      return await this.askRunSimilarCommand(t, l) ? l : null;
+      const u = t[s];
+      return await this.askRunSimilarCommand(e, u) ? u : null;
     }
     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?}`,
+      this.io.error(l`{bgRed  ERROR } Command {yellow ${e}} not found.\n`);
+      const u = await this.io.askForSelect(
+        l`{green Did you mean to run one of these commands instead?}`,
         o
       );
-      if (l)
-        return l;
+      if (u)
+        return u;
     }
-    throw new j(t);
+    throw new V(e);
   }
-  async askRunSimilarCommand(t, e) {
-    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 askRunSimilarCommand(e, t) {
+    return this.io.error(l`{bgRed  ERROR } Command {yellow ${e}} not found.\n`), this.io.askForConfirmation(l`{green Do you want to run {yellow ${t}} instead?} `);
   }
-  async *listCommandsFiles(t) {
-    const e = F.readdirSync(t, { withFileTypes: !0 });
-    for (const n of e) {
-      const i = S.resolve(t, n.name);
+  async *listCommandsFiles(e) {
+    const t = D.readdirSync(e, { withFileTypes: !0 });
+    for (const n of t) {
+      const s = R.resolve(e, n.name);
       if (n.isDirectory())
-        yield* this.listCommandsFiles(S.resolve(t, n.name));
+        yield* this.listCommandsFiles(R.resolve(e, n.name));
       else {
-        if (!i.endsWith(".ts") && !i.endsWith(".js"))
+        if (!s.endsWith(".ts") && !s.endsWith(".js") && !s.endsWith(".mjs") && !s.endsWith(".cjs"))
           continue;
-        yield i;
+        yield s;
       }
     }
   }
 }
-class B extends R {
-  constructor(t) {
+class W extends C {
+  constructor(e) {
     super("help", {
-      description: a.bold("Show help information about the CLI and its commands")
-    }), this.opts = t;
+      description: l.bold("Show help information about the CLI and its commands")
+    }), this.opts = e;
   }
   async handle() {
-    const t = this.opts.commandRegistry.getCommands(), e = this.opts.cliName ?? "Bob CLI", n = this.opts.cliVersion ?? "0.0.0", i = (await import("./package-ye8xt3By.js"))?.default?.version ?? "0.0.0";
-    this.io.log(a`${e} {green ${n}} (core: {yellow ${i}})
+    const e = this.opts.commandRegistry.getCommands(), t = this.opts.cliName ?? "Bob CLI", n = this.opts.cliVersion ?? "0.0.0", s = (await import("./package-B_VxJm2q.js"))?.default?.version ?? "0.0.0";
+    this.io.log(l`${t} {green ${n}} (core: {yellow ${s}})
 
 {yellow Usage}:
   command [options] [arguments]
 
 {yellow Available commands}:
 `);
-    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 r = Math.max(...e.map((m) => m.command.length)) ?? 0, o = {};
+    for (const m of e) {
+      const p = m.group ?? m.command.split(":")[0];
+      o[p] || (o[p] = []), o[p].push(m);
     }
-    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 p = O(s - d.command.length);
-        m && (p = p.slice(2)), this.io.log(a`${m ? "  " : ""}{green ${d.command}} ${p} ${d.description}`);
+    const u = Object.entries(o).sort(([m], [p]) => m.toLowerCase().localeCompare(p.toLowerCase())).sort(([, m], [, p]) => m.length - p.length);
+    for (const [m, p] of u) {
+      const a = p.length > 1;
+      a && this.io.log(l`{yellow ${m}}:`);
+      const d = p.sort((c, h) => c.command.toLowerCase().localeCompare(h.command.toLowerCase()));
+      for (const c of d) {
+        let h = O(r - c.command.length);
+        a && (h = h.slice(2)), this.io.log(l`${a ? "  " : ""}{green ${c.command}} ${h} ${c.description}`);
       }
     }
   }
 }
-class P {
+class T {
   logger;
-  constructor(t) {
-    this.logger = t;
+  constructor(e) {
+    this.logger = e;
   }
-  handle(t) {
-    if (t instanceof y)
-      return t.pretty(this.logger), -1;
-    throw t;
+  handle(e) {
+    if (e instanceof f)
+      return e.pretty(this.logger), -1;
+    throw e;
   }
 }
-class Q {
+class J {
   ctx;
   logger;
   commandRegistry;
   exceptionHandler;
   helpCommand;
-  newCommandRegistry(t) {
-    return new M(t.logger);
+  newCommandRegistry(e) {
+    return new j(e.logger);
   }
-  newHelpCommand(t) {
-    return new B(t);
+  newHelpCommand(e) {
+    return new W(e);
   }
-  newExceptionHandler(t) {
-    return new P(t.logger);
+  newExceptionHandler(e) {
+    return new T(e.logger);
   }
-  constructor(t = {}) {
-    this.ctx = t.ctx, this.logger = t.logger ?? new N(), this.commandRegistry = this.newCommandRegistry({
+  constructor(e = {}) {
+    this.ctx = e.ctx, this.logger = e.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,
+      cliName: e.name,
+      cliVersion: e.version,
       commandRegistry: this.commandRegistry
     });
   }
-  setCommandResolver(t) {
-    this.commandRegistry.setCommandResolver(t);
+  setCommandResolver(e) {
+    this.commandRegistry.setCommandResolver(e);
   }
-  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.bind(this.exceptionHandler)) : 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 {
-  b as BadCommandOption,
-  J as BadCommandParameter,
-  y as BobError,
-  Q as Cli,
-  R as Command,
-  q as CommandIO,
-  j as CommandNotFoundError,
-  k as CommandParser,
-  M as CommandRegistry,
-  g as CommandSignatureParser,
-  K as CommandWithSignature,
-  P as ExceptionHandler,
-  W as HelpOption,
-  H as InvalidOption,
-  N as Logger,
-  C as MissingRequiredArgumentValue,
-  T as MissingRequiredOptionValue,
-  v as MissingSignatureArgument,
-  A as MissingSignatureOption
+  A as BadCommandOption,
+  U as BadCommandParameter,
+  f as BobError,
+  J as Cli,
+  C as Command,
+  S as CommandIO,
+  V as CommandNotFoundError,
+  F as CommandParser,
+  j as CommandRegistry,
+  w as CommandSignatureParser,
+  z as CommandWithSignature,
+  T as ExceptionHandler,
+  H as HelpOption,
+  b as InvalidOption,
+  L as Logger,
+  E as MissingRequiredArgumentValue,
+  I as MissingRequiredOptionValue
 };