bob-core 2.0.0-beta.7 → 2.0.0-beta.8

package/dist/esm/index.js

@@ -3,25 +3,25 @@ import l from "chalk";
 import y from "prompts";
 import * as D from "node:fs";
 import R from "path";
-import * as P from "string-similarity";
+import * as I from "string-similarity";
 class f extends Error {
 }
 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;
+  constructor(t) {
+    let e = `Argument "${t.param}" value is invalid.`;
+    t.reason ? e += ` Reason: ${t.reason}` : e += ` Value: "${t.value}"`, super(e), this.param = t;
   }
-  pretty(e) {
-    e.log(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}`);
+  pretty(t) {
+    t.log(l`  {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(l`  {blue Value}: ${this.param.value}`), this.param.reason && t.log(l`  {yellow Reason}: ${this.param.reason}`);
   }
 }
 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;
+  constructor(t) {
+    let e = `Option "${t.option}" value is invalid.`;
+    t.reason ? e += ` Reason: ${t.reason}` : e += ` Value: "${t.value}"`, super(e), this.param = t;
   }
-  pretty(e) {
-    e.log(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}`);
+  pretty(t) {
+    t.log(l`  {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(l`  {blue Value}: ${this.param.value}`), this.param.reason && t.log(l`  {yellow Reason}: ${this.param.reason}`);
   }
 }
 function x(i) {
@@ -33,20 +33,20 @@ function x(i) {
   }
   throw new Error("Invalid option type: " + i);
 }
-function k(i) {
+function F(i) {
   return !Array.isArray(i) && typeof i == "object" && i.type ? i.default !== void 0 ? i.default : x(i.type) : x(i);
 }
 function g(i) {
   return typeof i == "string" || Array.isArray(i) ? {
     type: i,
-    default: k(i),
+    default: F(i),
     description: "",
     alias: [],
     required: !1,
     variadic: !1
   } : {
     type: i.type,
-    default: i.default ?? k(i.type),
+    default: i.default ?? F(i.type),
     description: i.description ?? "",
     alias: i.alias ? Array.isArray(i.alias) ? i.alias : [i.alias] : [],
     required: i.required ?? !1,
@@ -54,64 +54,64 @@ function g(i) {
   };
 }
 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) {
+  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(l`\n{yellow Available options}:`);
+      for (const [n, s] of e) {
         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(l`  {green ${m}} ${p} ${r.description || "\b"} {white (${u})}`);
       }
-      e.log("");
+      t.log("");
     }
-    e.log(l`{white.bgRed  ERROR } Option {bold.yellow ${this.option}} is not recognized.`);
+    t.log(l`{white.bgRed  ERROR } Option {bold.yellow ${this.option}} is not recognized.`);
   }
 }
-class I extends f {
-  constructor(e) {
-    super(`Command "${e}" not found.`), this.command = e;
+class P extends f {
+  constructor(t) {
+    super(`Command "${t}" not found.`), this.command = t;
   }
-  pretty(e) {
-    e.log(l`{bgRed  ERROR } Command {yellow ${this.command}} not found.`);
+  pretty(t) {
+    t.log(l`{bgRed  ERROR } Command {yellow ${this.command}} not found.`);
   }
 }
 class E extends f {
-  constructor(e) {
-    super(`Argument "${e}" is required.`), this.argument = e;
+  constructor(t) {
+    super(`Argument "${t}" is required.`), this.argument = t;
   }
-  pretty(e) {
-    e.log(l`{white.bgRed  ERROR } Argument {bold.yellow ${this.argument}} is required.`);
+  pretty(t) {
+    t.log(l`{white.bgRed  ERROR } Argument {bold.yellow ${this.argument}} is required.`);
   }
 }
 class V extends f {
-  constructor(e) {
-    super(`Argument "${e}" is required.`), this.option = e;
+  constructor(t) {
+    super(`Argument "${t}" is required.`), this.option = t;
   }
-  pretty(e) {
-    e.log(l`{white.bgRed  ERROR } Option {bold.yellow ${this.option}} is required.`);
+  pretty(t) {
+    t.log(l`{white.bgRed  ERROR } Option {bold.yellow ${this.option}} is required.`);
   }
 }
-function v(i, e, t, n) {
+function v(i, t, e, n) {
   if (i == null)
     return n ?? null;
-  if (e === "string")
+  if (t === "string")
     return String(i);
-  if (e === "number") {
+  if (t === "number") {
     const s = Number(i);
     if (isNaN(s))
       throw new A({
-        option: t,
+        option: e,
         reason: `Expected a number, got "${i}"`
       });
     return s;
   }
-  if (e === "boolean")
+  if (t === "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 (Array.isArray(t)) {
+    const s = t[0], r = Array.isArray(i) ? i : [i];
     if (s === "string")
       return r.map((o) => String(o));
     if (s === "number")
@@ -119,7 +119,7 @@ function v(i, e, t, n) {
         const u = Number(o);
         if (isNaN(u))
           throw new A({
-            option: t,
+            option: e,
             reason: `Expected array of numbers, got "${o}" in array`
           });
         return u;
@@ -127,15 +127,15 @@ function v(i, e, t, n) {
   }
   return i;
 }
-class F {
+class k {
   options;
   parsedOptions = null;
   arguments;
   parsedArguments = null;
   io;
   shouldPromptForMissingOptions = !0;
-  constructor(e) {
-    this.options = e.options, this.arguments = e.arguments, this.io = e.io;
+  constructor(t) {
+    this.options = t.options, this.arguments = t.arguments, this.io = t.io;
   }
   // === PUBLIC METHODS ===
   /**
@@ -145,9 +145,9 @@ class F {
    * @throws {InvalidOption} If an unknown option is provided
    * @throws {BadCommandOption} If a value cannot be converted to the expected type
    */
-  init(e) {
-    const { _: t, ...n } = q(e);
-    return this.validateUnknownOptions(n), this.parsedOptions = this.handleOptions(n), this.parsedArguments = this.handleArguments(t), {
+  init(t) {
+    const { _: e, ...n } = q(t);
+    return this.validateUnknownOptions(n), this.parsedOptions = this.handleOptions(n), this.parsedArguments = this.handleArguments(e), {
       options: this.parsedOptions,
       arguments: this.parsedArguments
     };
@@ -157,30 +157,30 @@ class F {
    * @throws {Error} If validation fails
    */
   async validate() {
-    for (const e in this.options)
-      if (g(this.options[e]).required && (this.parsedOptions?.[e] === void 0 || this.parsedOptions?.[e] === null))
-        throw new V(e);
-    for (const e in this.arguments) {
-      const t = g(this.arguments[e]), n = this.parsedArguments?.[e];
-      if (t.required && n == null) {
+    for (const t in this.options)
+      if (g(this.options[t]).required && (this.parsedOptions?.[t] === void 0 || this.parsedOptions?.[t] === null))
+        throw new V(t);
+    for (const t in this.arguments) {
+      const e = g(this.arguments[t]), n = this.parsedArguments?.[t];
+      if (e.required && n == null) {
         if (this.shouldPromptForMissingOptions) {
-          const s = await this.promptForArgument(e, t);
+          const s = await this.promptForArgument(t, e);
           if (s && this.parsedArguments) {
-            this.parsedArguments[e] = v(s, t.type, e);
+            this.parsedArguments[t] = v(s, e.type, t);
             continue;
           }
         }
-        throw new E(e);
+        throw new E(t);
       }
-      if (t.required && t.variadic && Array.isArray(n) && n.length === 0) {
+      if (e.required && e.variadic && Array.isArray(n) && n.length === 0) {
         if (this.shouldPromptForMissingOptions) {
-          const s = await this.promptForArgument(e, t);
+          const s = await this.promptForArgument(t, e);
           if (s && this.parsedArguments) {
-            this.parsedArguments[e] = v(s, t.type, e);
+            this.parsedArguments[t] = v(s, e.type, t);
             continue;
           }
         }
-        throw new E(e);
+        throw new E(t);
       }
     }
   }
@@ -190,17 +190,17 @@ class F {
    * @returns The typed option value
    * @throws {Error} If init() has not been called yet
    */
-  option(e) {
+  option(t) {
     if (!this.parsedOptions)
       throw new Error("Options have not been parsed yet. Call init() first.");
-    return this.parsedOptions[e];
+    return this.parsedOptions[t];
   }
-  setOption(e, t) {
+  setOption(t, e) {
     if (!this.parsedOptions)
       throw new Error("Options have not been parsed yet. Call init() first.");
-    if (!(e in this.options))
-      throw new b(e, this.options);
-    this.parsedOptions[e] = t;
+    if (!(t in this.options))
+      throw new b(t, this.options);
+    this.parsedOptions[t] = e;
   }
   /**
    * Retrieves a parsed argument value by name
@@ -208,111 +208,111 @@ class F {
    * @returns The typed argument value
    * @throws {Error} If init() has not been called yet
    */
-  argument(e) {
+  argument(t) {
     if (!this.parsedArguments)
       throw new Error("Arguments have not been parsed yet. Call init() first.");
-    return this.parsedArguments[e];
+    return this.parsedArguments[t];
   }
-  setArgument(e, t) {
+  setArgument(t, e) {
     if (!this.parsedArguments)
       throw new Error("Arguments have not been parsed yet. Call init() first.");
-    if (!(e in this.arguments))
-      throw new b(e, this.arguments);
-    this.parsedArguments[e] = t;
+    if (!(t in this.arguments))
+      throw new b(t, this.arguments);
+    this.parsedArguments[t] = e;
   }
   // === PRIVATE HELPERS ===
   /**
    * Validates that all provided options are recognized
    * @throws {InvalidOption} If an unknown option is found
    */
-  validateUnknownOptions(e) {
-    const t = /* @__PURE__ */ new Set();
+  validateUnknownOptions(t) {
+    const e = /* @__PURE__ */ new Set();
     for (const n in this.options) {
-      t.add(n);
+      e.add(n);
       const s = g(this.options[n]);
       for (const r of s.alias)
-        t.add(r);
+        e.add(r);
     }
-    for (const n in e)
-      if (!t.has(n))
+    for (const n in t)
+      if (!e.has(n))
         throw new b(n, this.options);
   }
   /**
    * Processes named options from minimist output
    */
-  handleOptions(e) {
-    const t = {};
+  handleOptions(t) {
+    const e = {};
     for (const n in this.options) {
       const s = g(this.options[n]);
-      t[n] = this.resolveOptionValue(
+      e[n] = this.resolveOptionValue(
         n,
         s,
-        e
+        t
       );
     }
-    return t;
+    return e;
   }
   /**
    * Processes positional arguments from minimist output
    */
-  handleArguments(e) {
-    const t = {}, n = [...e];
+  handleArguments(t) {
+    const e = {}, n = [...t];
     for (const s in this.arguments) {
       const r = g(this.arguments[s]);
       if (r.variadic) {
-        t[s] = this.handleVariadicArgument(s, r, n);
+        e[s] = this.handleVariadicArgument(s, r, n);
         continue;
       }
-      t[s] = this.resolveArgumentValue(s, r, n.shift());
+      e[s] = this.resolveArgumentValue(s, r, n.shift());
     }
-    return t;
+    return e;
   }
   /**
    * Handles variadic arguments that consume all remaining positional values
    */
-  handleVariadicArgument(e, t, n) {
-    return n.length ? v(n, t.type, e, t.default) : t.default;
+  handleVariadicArgument(t, e, n) {
+    return n.length ? v(n, e.type, t, e.default) : e.default;
   }
   /**
    * Resolves a single positional argument value with defaults and type conversion
    * Note: Does not validate required arguments - validation happens in subclass validate() methods
    */
-  resolveArgumentValue(e, t, n) {
-    return n === void 0 ? t.default : v(n, t.type, e, t.default);
+  resolveArgumentValue(t, e, n) {
+    return n === void 0 ? e.default : v(n, e.type, t, e.default);
   }
   /**
    * Resolves an option value from the parsed option values object
    * Handles alias resolution, defaults, and type conversion
    */
-  resolveOptionValue(e, t, n) {
+  resolveOptionValue(t, e, n) {
     let s;
-    const r = [e, ...t.alias];
+    const r = [t, ...e.alias];
     for (const o of r)
       if (o in n) {
         s = n[o];
         break;
       }
     if (s === void 0) {
-      if (t.required)
+      if (e.required)
         throw new A({
-          option: e,
+          option: t,
           reason: "Required option is missing"
         });
-      return t.default;
+      return e.default;
     }
-    return v(s, t.type, e, t.default);
+    return v(s, e.type, t, e.default);
   }
   optionDefinitions() {
-    const e = {};
-    for (const t in this.options)
-      e[t] = g(this.options[t]);
-    return e;
+    const t = {};
+    for (const e in this.options)
+      t[e] = g(this.options[e]);
+    return t;
   }
   argumentDefinitions() {
-    const e = {};
-    for (const t in this.arguments)
-      e[t] = g(this.arguments[t]);
-    return e;
+    const t = {};
+    for (const e in this.arguments)
+      t[e] = g(this.arguments[e]);
+    return t;
   }
   availableOptions() {
     return Object.keys(this.options);
@@ -334,12 +334,12 @@ class F {
    * @param argDef - The argument's definition for type and description
    * @returns The user-provided value, or null if none given
    */
-  async promptForArgument(e, t) {
-    if (!Array.isArray(t.type) && !["string", "number", "secret"].includes(t.type))
+  async promptForArgument(t, e) {
+    if (!Array.isArray(e.type) && !["string", "number", "secret"].includes(e.type))
       return null;
-    let 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(
+    let n = l`{yellow.bold ${t}} is required`;
+    return e.description && (n += l`: {gray (${e.description})}`), n += `
+`, Array.isArray(e.type) ? (n += l`Please provide one or more values, separated by commas:\n`, await this.io.askForList(
       n,
       void 0,
       {
@@ -349,13 +349,13 @@ class F {
       n,
       void 0,
       {
-        type: t.type === "number" ? "number" : t.type === "secret" ? "password" : "text",
+        type: e.type === "number" ? "number" : e.type === "secret" ? "password" : "text",
         validate: (s) => {
-          if (t.type === "number") {
+          if (e.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))
+          } else if (e.type === "string" && (typeof s != "string" || !s.length))
             return "Please enter a valid text";
           return !0;
         }
@@ -373,7 +373,7 @@ class H {
   default = !1;
   description = l`Display help for the given command. When no command is given display help for the {green list} command`;
   async handler() {
-    const e = this.parser.argumentDefinitions(), t = this.parser.optionDefinitions(), n = Object.entries(e), s = Object.entries(t), r = s.map(([a, d]) => {
+    const t = this.parser.argumentDefinitions(), e = this.parser.optionDefinitions(), n = Object.entries(t), s = Object.entries(e), r = s.map(([a, d]) => {
       const h = Array.isArray(d.alias) ? d.alias : d.alias ? [d.alias] : [];
       return {
         name: a,
@@ -424,92 +424,92 @@ class H {
 }
 class S {
   logger;
-  constructor(e) {
-    this.logger = e;
+  constructor(t) {
+    this.logger = t;
   }
   /**
    * Logger methods
    */
-  log(...e) {
-    this.logger.log(...e);
+  log(...t) {
+    this.logger.log(...t);
   }
-  info(...e) {
-    this.logger.info(...e);
+  info(...t) {
+    this.logger.info(...t);
   }
-  warn(...e) {
-    this.logger.warn(...e);
+  warn(...t) {
+    this.logger.warn(...t);
   }
-  error(...e) {
-    this.logger.error(...e);
+  error(...t) {
+    this.logger.error(...t);
   }
-  debug(...e) {
-    this.logger.debug(...e);
+  debug(...t) {
+    this.logger.debug(...t);
   }
   /**
    * Prompt utils
    */
-  async askForConfirmation(e = "Do you want to continue?", t) {
+  async askForConfirmation(t = "Do you want to continue?", e) {
     return (await y({
       type: "confirm",
       name: "value",
-      message: e,
-      initial: t ?? !1
+      message: t,
+      initial: e ?? !1
     })).value;
   }
-  async askForInput(e, t, n) {
+  async askForInput(t, e, n) {
     return (await y({
       type: "text",
       name: "value",
-      message: e,
-      initial: t,
+      message: t,
+      initial: e,
       ...n
     }))?.value ?? null;
   }
-  async askForDate(e, t, n) {
+  async askForDate(t, e, n) {
     return (await y({
       type: "date",
       name: "value",
-      message: e,
-      initial: t,
+      message: t,
+      initial: e,
       ...n
     }))?.value ?? null;
   }
-  async askForList(e, t, n) {
+  async askForList(t, e, n) {
     return (await y({
       type: "list",
       name: "value",
-      message: e,
-      initial: t,
+      message: t,
+      initial: e,
       ...n
     }))?.value ?? null;
   }
-  async askForToggle(e, t, n) {
+  async askForToggle(t, e, n) {
     return (await y({
       type: "toggle",
       name: "value",
-      message: e,
-      initial: t,
+      message: t,
+      initial: e,
       ...n
     }))?.value ?? null;
   }
-  async askForSelect(e, t, n) {
-    if (t.length === 0)
+  async askForSelect(t, e, n) {
+    if (e.length === 0)
       throw new Error("No options provided");
     const s = [];
-    for (const o of t)
+    for (const o of e)
       typeof o == "string" ? s.push({ title: o, value: o }) : s.push(o);
     return (await y({
       type: "select",
       name: "value",
-      message: e,
+      message: t,
       choices: s,
       ...n
     }))?.value ?? null;
   }
-  newLoader(e = "", t = ["⠙", "⠘", "⠰", "⠴", "⠤", "⠦", "⠆", "⠃", "⠋", "⠉"], n = 100) {
-    let s = e, r = null, o = 0;
+  newLoader(t = "", e = ["⠙", "⠘", "⠰", "⠴", "⠤", "⠦", "⠆", "⠃", "⠋", "⠉"], n = 100) {
+    let s = t, 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;
+      r && (process.stdout.write(new TextEncoder().encode("\r" + " ".repeat(r.length + 5) + "\r")), r = null), process.stdout.write(new TextEncoder().encode("\r" + e[o++] + " " + s)), o = o % e.length;
     }, n), m = () => {
       clearInterval(u), process.stdout.write(new TextEncoder().encode("\r" + " ".repeat(s.length + 5) + "\r"));
     };
@@ -542,18 +542,18 @@ class C {
   defaultOptions() {
     return [new H()];
   }
-  newCommandParser(e) {
-    return new F({
-      io: e.io,
-      options: e.options,
-      arguments: e.arguments
+  newCommandParser(t) {
+    return new k({
+      io: t.io,
+      options: t.options,
+      arguments: t.arguments
     });
   }
-  newCommandIO(e) {
-    return new S(e.logger);
+  newCommandIO(t) {
+    return new S(t.logger);
   }
-  constructor(e, t) {
-    this._command = e, this.description = t?.description ?? "", this.group = t?.group;
+  constructor(t, e) {
+    this._command = t, this.description = e?.description ?? "", this.group = e?.group;
     const n = this.defaultOptions();
     if (n.length > 0) {
       this.tmp = {
@@ -567,37 +567,37 @@ class C {
   disablePrompting() {
     return this.disablePromptingFlag = !0, this;
   }
-  preHandler(e) {
-    return this._preHandler = e, this;
+  preHandler(t) {
+    return this._preHandler = t, this;
   }
-  handler(e) {
-    return this._handler = e, this;
+  handler(t) {
+    return this._handler = t, this;
   }
-  options(e) {
+  options(t) {
     return this.tmp = {
       options: {
         ...this.tmp?.options ?? {},
-        ...e
+        ...t
       },
       arguments: this.tmp?.arguments ?? {}
     }, this;
   }
-  arguments(e) {
+  arguments(t) {
     return this.tmp = {
       options: this.tmp?.options ?? {},
       arguments: {
         ...this.tmp?.arguments ?? {},
-        ...e
+        ...t
       }
     }, this;
   }
-  async run(e) {
+  async run(t) {
     if (!this._handler && !this.handle)
       throw new Error(`No handler defined for command ${this.command || "(unknown)"}`);
-    let t;
-    if (this.ctx = e.ctx, this.logger = e.logger, this.io = this.newCommandIO({
-      logger: e.logger
-    }), e && "args" in e) {
+    let e;
+    if (this.ctx = t.ctx, this.logger = t.logger, this.io = this.newCommandIO({
+      logger: t.logger
+    }), t && "args" in t) {
       const r = this.tmp?.options ?? {};
       for (const o of this.defaultOptions())
         o.option in r || (r[o.option] = o);
@@ -605,18 +605,18 @@ class C {
         io: this.io,
         options: r,
         arguments: this.tmp?.arguments ?? {}
-      }), t = this.parser.init(e.args);
+      }), e = this.parser.init(t.args);
       for (const o of this.defaultOptions())
-        if (t.options[o.option] === !0) {
+        if (e.options[o.option] === !0) {
           const u = await o.handler.call(this);
           if (u && u !== 0)
             return u;
         }
       this.disablePromptingFlag && this.parser.disablePrompting(), await this.parser.validate();
     } else
-      t = {
-        options: e.options,
-        arguments: e.arguments
+      e = {
+        options: t.options,
+        arguments: t.arguments
       };
     const n = this.preHandle ? await this.preHandle() : null;
     if (n && n !== 0)
@@ -625,29 +625,29 @@ class C {
       this._handler = this.handle.bind(this);
     else if (!this._handler)
       throw new Error(`No handler defined for command ${this.command || "(unknown)"}`);
-    return await this._handler(e.ctx, t) ?? 0;
+    return await this._handler(t.ctx, e) ?? 0;
   }
 }
-class w extends F {
+class w extends k {
   command;
-  constructor(e) {
-    const t = w.parseSignature(
-      e.signature,
-      e.helperDefinitions,
-      e.defaultOptions
+  constructor(t) {
+    const e = w.parseSignature(
+      t.signature,
+      t.helperDefinitions,
+      t.defaultOptions
     );
-    super({ io: e.io, options: t.options, arguments: t.arguments }), this.command = t.command;
+    super({ io: t.io, options: e.options, arguments: e.arguments }), this.command = e.command;
   }
   /**
    * Parses command signature string into command name and parameter schemas
    * Example: "migrate {name} {--force}" -> { command: "migrate", arguments: {name: ...}, options: {force: ...} }
    */
-  static parseSignature(e, t, n) {
-    const [s, ...r] = e.split(/\{(.*?)\}/g).map((m) => m.trim()).filter(Boolean), o = {}, u = {};
+  static parseSignature(t, e, n) {
+    const [s, ...r] = t.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
+        e
       );
       a ? o[p] = d : u[p] = d;
     }
@@ -676,8 +676,8 @@ class w extends F {
    * - {--opt=}       -> string option
    * - {--opt|o}      -> option with alias
    */
-  static parseParamSignature(e, t) {
-    let n = e, s = !1;
+  static parseParamSignature(t, e) {
+    let n = t, s = !1;
     const r = {
       required: !0,
       type: "string",
@@ -697,7 +697,7 @@ class w extends F {
       const [o, ...u] = n.split("|");
       n = o.trim(), r.alias = u.map((m) => m.trim());
     }
-    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 };
+    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 ?? e[n] ?? e[`--${n}`], { name: n, isOption: s, definition: r };
   }
 }
 class z extends C {
@@ -705,9 +705,9 @@ class z extends C {
   get command() {
     return this.parser ? this.parser.command : this.signature.split(" ")[0];
   }
-  newCommandParser(e) {
+  newCommandParser(t) {
     return new w({
-      io: e.io,
+      io: t.io,
       signature: this.signature,
       helperDefinitions: this.helperDefinitions,
       defaultOptions: this.defaultOptions()
@@ -716,55 +716,55 @@ class z extends C {
   constructor() {
     super("");
   }
-  option(e, t = null) {
-    return this.parser instanceof w ? this.parser.option(e) ?? t : t;
+  option(t, e = null) {
+    return this.parser instanceof w ? this.parser.option(t) ?? e : e;
   }
-  argument(e, t = null) {
-    return this.parser instanceof w ? this.parser.argument(e) ?? t : t;
+  argument(t, e = null) {
+    return this.parser instanceof w ? this.parser.argument(t) ?? e : e;
   }
   // Prompt utils
-  async askForConfirmation(...e) {
-    return this.io.askForConfirmation(...e);
+  async askForConfirmation(...t) {
+    return this.io.askForConfirmation(...t);
   }
-  async askForInput(...e) {
-    return this.io.askForInput(...e);
+  async askForInput(...t) {
+    return this.io.askForInput(...t);
   }
-  async askForSelect(...e) {
-    return this.io.askForSelect(...e);
+  async askForSelect(...t) {
+    return this.io.askForSelect(...t);
   }
-  newLoader(...e) {
-    return this.io.newLoader(...e);
+  newLoader(...t) {
+    return this.io.newLoader(...t);
   }
 }
 class L {
   level;
-  constructor(e = {}) {
-    this.level = e.level ?? "info";
+  constructor(t = {}) {
+    this.level = t.level ?? "info";
   }
-  shouldLog(e) {
-    const t = ["debug", "info", "warn", "error"], n = t.indexOf(this.level);
-    return t.indexOf(e) >= n;
+  shouldLog(t) {
+    const e = ["debug", "info", "warn", "error"], n = e.indexOf(this.level);
+    return e.indexOf(t) >= n;
   }
-  setLevel(e) {
-    this.level = e;
+  setLevel(t) {
+    this.level = t;
   }
   getLevel() {
     return this.level;
   }
-  log(...e) {
-    console.log(...e);
+  log(...t) {
+    console.log(...t);
   }
-  info(...e) {
-    this.shouldLog("info") && console.log(...e);
+  info(...t) {
+    this.shouldLog("info") && console.log(...t);
   }
-  warn(...e) {
-    this.shouldLog("warn") && console.warn(...e);
+  warn(...t) {
+    this.shouldLog("warn") && console.warn(...t);
   }
-  error(...e) {
-    this.shouldLog("error") && console.error(...e);
+  error(...t) {
+    this.shouldLog("error") && console.error(...t);
   }
-  debug(...e) {
-    this.shouldLog("debug") && console.log(...e);
+  debug(...t) {
+    this.shouldLog("debug") && console.log(...t);
   }
 }
 class j {
@@ -774,8 +774,8 @@ class j {
   get CommandIOClass() {
     return S;
   }
-  constructor(e) {
-    this.logger = e ?? new L(), this.io = new this.CommandIOClass(this.logger);
+  constructor(t) {
+    this.logger = t ?? new L(), this.io = new this.CommandIOClass(this.logger);
   }
   getAvailableCommands() {
     return Object.keys(this.commands);
@@ -783,62 +783,58 @@ class j {
   getCommands() {
     return Object.values(this.commands);
   }
-  importFile = async (e) => (await import(e)).default;
-  commandResolver = async (e) => {
-    let t = await this.importFile(e);
-    if (!t)
-      throw new Error(`The command at path ${e} does not have a default export.`);
-    return t?.default && (t = t.default), typeof t == "function" ? new t() : t instanceof C ? t : null;
+  importFile = async (t) => (await import(t)).default;
+  commandResolver = async (t) => {
+    let e = await this.importFile(t);
+    if (!e)
+      throw new Error(`The command at path ${t} does not have a default export.`);
+    return e?.default && (e = e.default), typeof e == "function" ? new e() : e instanceof C ? e : null;
   };
-  setCommandResolver(e) {
-    return this.commandResolver = e, this;
-  }
-  setFileImporter(e) {
-    return this.importFile = e, this;
+  withCommandResolver(t) {
+    return this.commandResolver = t, this;
   }
-  fileCheck = (e) => !0;
-  setFileCheck(e) {
-    return this.fileCheck = e, this;
+  withFileImporter(t) {
+    return this.importFile = t, this;
   }
-  registerCommand(e, t = !1) {
-    const n = e.command;
+  registerCommand(t, e = !1) {
+    const n = t.command;
     if (!n)
       throw new Error("Command signature is invalid, it must have a command name.");
-    if (!t && this.commands[n])
+    if (!e && this.commands[n])
       throw new Error(`Command ${n} already registered.`);
-    this.commands[n] = e;
+    this.commands[n] = t;
   }
-  async loadCommandsPath(e) {
-    for await (const t of this.listCommandsFiles(e))
+  async loadCommandsPath(t) {
+    for await (const e of this.listCommandsFiles(t))
       try {
-        const n = await this.commandResolver(t);
+        const n = await this.commandResolver(e);
         n instanceof C && this.registerCommand(n);
       } catch (n) {
-        throw new Error(`Command ${t} failed to load. ${n}`, {
+        throw new Error(`Command ${e} failed to load. ${n}`, {
           cause: n
         });
       }
   }
-  async runCommand(e, t, ...n) {
-    const s = typeof t == "string" ? this.commands[t] : t, r = typeof t == "string" ? t : s.command;
+  async runCommand(t, e, ...n) {
+    const s = typeof e == "string" ? this.commands[e] : e, r = typeof e == "string" ? e : s.command;
     if (!s) {
       const o = await this.suggestCommand(r);
-      return o ? await this.runCommand(e, o, ...n) : 1;
+      return o ? await this.runCommand(t, o, ...n) : 1;
     }
     return await s.run({
-      ctx: e,
+      ctx: t,
       logger: this.logger,
       args: n
     }) ?? 0;
   }
-  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);
+  async suggestCommand(t) {
+    const e = this.getAvailableCommands(), { bestMatch: n, bestMatchIndex: s, ratings: r } = I.findBestMatch(t, e), 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 u = t[s];
-      return await this.askRunSimilarCommand(e, u) ? u : null;
+      const u = e[s];
+      return await this.askRunSimilarCommand(t, u) ? u : null;
     }
     if (o.length) {
-      this.io.error(l`{bgRed  ERROR } Command {yellow ${e}} not found.\n`);
+      this.io.error(l`{bgRed  ERROR } Command {yellow ${t}} not found.\n`);
       const u = await this.io.askForSelect(
         l`{green Did you mean to run one of these commands instead?}`,
         o
@@ -846,17 +842,17 @@ class j {
       if (u)
         return u;
     }
-    throw new I(e);
+    throw new P(t);
   }
-  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 askRunSimilarCommand(t, e) {
+    return this.io.error(l`{bgRed  ERROR } Command {yellow ${t}} not found.\n`), this.io.askForConfirmation(l`{green Do you want to run {yellow ${e}} instead?} `);
   }
-  async *listCommandsFiles(e) {
-    const t = D.readdirSync(e, { withFileTypes: !0 });
-    for (const n of t) {
-      const s = R.resolve(e, n.name);
+  async *listCommandsFiles(t) {
+    const e = D.readdirSync(t, { withFileTypes: !0 });
+    for (const n of e) {
+      const s = R.resolve(t, n.name);
       if (n.isDirectory())
-        yield* this.listCommandsFiles(R.resolve(e, n.name));
+        yield* this.listCommandsFiles(R.resolve(t, n.name));
       else {
         if (!s.endsWith(".ts") && !s.endsWith(".js") && !s.endsWith(".mjs") && !s.endsWith(".cjs"))
           continue;
@@ -866,22 +862,22 @@ class j {
   }
 }
 class W extends C {
-  constructor(e) {
+  constructor(t) {
     super("help", {
       description: l.bold("Show help information about the CLI and its commands")
-    }), this.opts = e;
+    }), this.opts = t;
   }
   async handle() {
-    const e = this.opts.commandRegistry.getCommands(), t = this.opts.cliName ?? "Bob CLI", n = this.opts.cliVersion ?? "0.0.0", s = (await import("./package-D2VbJdgN.js"))?.default?.version ?? "0.0.0";
-    this.io.log(l`${t} {green ${n}} (core: {yellow ${s}})
+    const t = this.opts.commandRegistry.getCommands(), e = this.opts.cliName ?? "Bob CLI", n = this.opts.cliVersion ?? "0.0.0", s = (await import("./package-ODN3iB6L.js"))?.default?.version ?? "0.0.0";
+    this.io.log(l`${e} {green ${n}} (core: {yellow ${s}})
 
 {yellow Usage}:
   command [options] [arguments]
 
 {yellow Available commands}:
 `);
-    const r = Math.max(...e.map((m) => m.command.length)) ?? 0, o = {};
-    for (const m of e) {
+    const r = Math.max(...t.map((m) => m.command.length)) ?? 0, o = {};
+    for (const m of t) {
       const p = m.group ?? m.command.split(":")[0];
       o[p] || (o[p] = []), o[p].push(m);
     }
@@ -899,13 +895,13 @@ class W extends C {
 }
 class T {
   logger;
-  constructor(e) {
-    this.logger = e;
+  constructor(t) {
+    this.logger = t;
   }
-  handle(e) {
-    if (e instanceof f)
-      return e.pretty(this.logger), -1;
-    throw e;
+  handle(t) {
+    if (t instanceof f)
+      return t.pretty(this.logger), -1;
+    throw t;
   }
 }
 class J {
@@ -914,41 +910,44 @@ class J {
   commandRegistry;
   exceptionHandler;
   helpCommand;
-  newCommandRegistry(e) {
-    return new j(e.logger);
+  newCommandRegistry(t) {
+    return new j(t.logger);
   }
-  newHelpCommand(e) {
-    return new W(e);
+  newHelpCommand(t) {
+    return new W(t);
   }
-  newExceptionHandler(e) {
-    return new T(e.logger);
+  newExceptionHandler(t) {
+    return new T(t.logger);
   }
-  constructor(e = {}) {
-    this.ctx = e.ctx, this.logger = e.logger ?? new L(), this.commandRegistry = this.newCommandRegistry({
+  constructor(t = {}) {
+    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: e.name,
-      cliVersion: e.version,
+      cliName: t.name,
+      cliVersion: t.version,
       commandRegistry: this.commandRegistry
     });
   }
-  setCommandResolver(e) {
-    this.commandRegistry.setCommandResolver(e);
+  withCommandResolver(t) {
+    return this.commandRegistry.withCommandResolver(t), this;
+  }
+  withFileImporter(t) {
+    return this.commandRegistry.withFileImporter(t), this;
   }
-  async withCommands(...e) {
-    for (const t of e)
-      typeof t == "string" ? await this.commandRegistry.loadCommandsPath(t) : typeof t == "function" ? this.registerCommand(new t()) : this.registerCommand(t);
+  async withCommands(...t) {
+    for (const e of t)
+      typeof e == "string" ? await this.commandRegistry.loadCommandsPath(e) : typeof e == "function" ? this.registerCommand(new e()) : this.registerCommand(e);
   }
-  async runCommand(e, ...t) {
-    return e ? await this.commandRegistry.runCommand(this.ctx, e, ...t).catch(this.exceptionHandler.handle.bind(this.exceptionHandler)) : await this.runHelpCommand();
+  async runCommand(t, ...e) {
+    return t ? await this.commandRegistry.runCommand(this.ctx, t, ...e).catch(this.exceptionHandler.handle.bind(this.exceptionHandler)) : await this.runHelpCommand();
   }
   async runHelpCommand() {
     return await this.runCommand(this.helpCommand);
   }
-  registerCommand(e) {
-    this.commandRegistry.registerCommand(e);
+  registerCommand(t) {
+    this.commandRegistry.registerCommand(t);
   }
 }
 export {
@@ -958,8 +957,8 @@ export {
   J as Cli,
   C as Command,
   S as CommandIO,
-  I as CommandNotFoundError,
-  F as CommandParser,
+  P as CommandNotFoundError,
+  k as CommandParser,
   j as CommandRegistry,
   w as CommandSignatureParser,
   z as CommandWithSignature,