bob-core 2.0.0-beta.8 → 2.0.0

package/dist/esm/index.js

@@ -1,971 +0,0 @@
-import q from "minimist";
-import l from "chalk";
-import y from "prompts";
-import * as D from "node:fs";
-import R from "path";
-import * as I from "string-similarity";
-class f extends Error {
-}
-class U extends f {
-  constructor(t) {
-    let e = `Argument "${t.param}" value is invalid.`;
-    t.reason ? e += ` Reason: ${t.reason}` : e += ` Value: "${t.value}"`, super(e), this.param = t;
-  }
-  pretty(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(t) {
-    let e = `Option "${t.option}" value is invalid.`;
-    t.reason ? e += ` Reason: ${t.reason}` : e += ` Value: "${t.value}"`, super(e), this.param = t;
-  }
-  pretty(t) {
-    t.log(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) {
-  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 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: F(i),
-    description: "",
-    alias: [],
-    required: !1,
-    variadic: !1
-  } : {
-    type: 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,
-    variadic: i.variadic ?? !1
-  };
-}
-class b extends f {
-  constructor(t, e = {}) {
-    super(`Invalid option ${t} in not recognized`), this.option = t, this.optionsSchema = e;
-  }
-  pretty(t) {
-    const e = Object.entries(this.optionsSchema);
-    if (e.length > 0) {
-      t.log(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);
-        t.log(l`  {green ${m}} ${p} ${r.description || "\b"} {white (${u})}`);
-      }
-      t.log("");
-    }
-    t.log(l`{white.bgRed  ERROR } Option {bold.yellow ${this.option}} is not recognized.`);
-  }
-}
-class P extends f {
-  constructor(t) {
-    super(`Command "${t}" not found.`), this.command = t;
-  }
-  pretty(t) {
-    t.log(l`{bgRed  ERROR } Command {yellow ${this.command}} not found.`);
-  }
-}
-class E extends f {
-  constructor(t) {
-    super(`Argument "${t}" is required.`), this.argument = t;
-  }
-  pretty(t) {
-    t.log(l`{white.bgRed  ERROR } Argument {bold.yellow ${this.argument}} is required.`);
-  }
-}
-class V extends f {
-  constructor(t) {
-    super(`Argument "${t}" is required.`), this.option = t;
-  }
-  pretty(t) {
-    t.log(l`{white.bgRed  ERROR } Option {bold.yellow ${this.option}} is required.`);
-  }
-}
-function v(i, t, e, n) {
-  if (i == null)
-    return n ?? null;
-  if (t === "string")
-    return String(i);
-  if (t === "number") {
-    const s = Number(i);
-    if (isNaN(s))
-      throw new A({
-        option: e,
-        reason: `Expected a number, got "${i}"`
-      });
-    return s;
-  }
-  if (t === "boolean")
-    return typeof i == "boolean" ? i : i === "true" || i === "1" ? !0 : i === "false" || i === "0" ? !1 : !!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")
-      return r.map((o) => {
-        const u = Number(o);
-        if (isNaN(u))
-          throw new A({
-            option: e,
-            reason: `Expected array of numbers, got "${o}" in array`
-          });
-        return u;
-      });
-  }
-  return i;
-}
-class k {
-  options;
-  parsedOptions = null;
-  arguments;
-  parsedArguments = null;
-  io;
-  shouldPromptForMissingOptions = !0;
-  constructor(t) {
-    this.options = t.options, this.arguments = t.arguments, this.io = t.io;
-  }
-  // === PUBLIC METHODS ===
-  /**
-   * Parses raw command-line arguments into structured options and arguments
-   * @param args - Raw command line arguments (typically from process.argv.slice(2))
-   * @returns Object containing parsed options and arguments
-   * @throws {InvalidOption} If an unknown option is provided
-   * @throws {BadCommandOption} If a value cannot be converted to the expected type
-   */
-  init(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
-    };
-  }
-  /**
-   * Validates the parsed options and arguments
-   * @throws {Error} If validation fails
-   */
-  async validate() {
-    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(t, e);
-          if (s && this.parsedArguments) {
-            this.parsedArguments[t] = v(s, e.type, t);
-            continue;
-          }
-        }
-        throw new E(t);
-      }
-      if (e.required && e.variadic && Array.isArray(n) && n.length === 0) {
-        if (this.shouldPromptForMissingOptions) {
-          const s = await this.promptForArgument(t, e);
-          if (s && this.parsedArguments) {
-            this.parsedArguments[t] = v(s, e.type, t);
-            continue;
-          }
-        }
-        throw new E(t);
-      }
-    }
-  }
-  /**
-   * Retrieves a parsed option value by name
-   * @param name - The option name
-   * @returns The typed option value
-   * @throws {Error} If init() has not been called yet
-   */
-  option(t) {
-    if (!this.parsedOptions)
-      throw new Error("Options have not been parsed yet. Call init() first.");
-    return this.parsedOptions[t];
-  }
-  setOption(t, e) {
-    if (!this.parsedOptions)
-      throw new Error("Options have not been parsed yet. Call init() first.");
-    if (!(t in this.options))
-      throw new b(t, this.options);
-    this.parsedOptions[t] = e;
-  }
-  /**
-   * Retrieves a parsed argument value by name
-   * @param name - The argument name
-   * @returns The typed argument value
-   * @throws {Error} If init() has not been called yet
-   */
-  argument(t) {
-    if (!this.parsedArguments)
-      throw new Error("Arguments have not been parsed yet. Call init() first.");
-    return this.parsedArguments[t];
-  }
-  setArgument(t, e) {
-    if (!this.parsedArguments)
-      throw new Error("Arguments have not been parsed yet. Call init() first.");
-    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(t) {
-    const e = /* @__PURE__ */ new Set();
-    for (const n in this.options) {
-      e.add(n);
-      const s = g(this.options[n]);
-      for (const r of s.alias)
-        e.add(r);
-    }
-    for (const n in t)
-      if (!e.has(n))
-        throw new b(n, this.options);
-  }
-  /**
-   * Processes named options from minimist output
-   */
-  handleOptions(t) {
-    const e = {};
-    for (const n in this.options) {
-      const s = g(this.options[n]);
-      e[n] = this.resolveOptionValue(
-        n,
-        s,
-        t
-      );
-    }
-    return e;
-  }
-  /**
-   * Processes positional arguments from minimist output
-   */
-  handleArguments(t) {
-    const e = {}, n = [...t];
-    for (const s in this.arguments) {
-      const r = g(this.arguments[s]);
-      if (r.variadic) {
-        e[s] = this.handleVariadicArgument(s, r, n);
-        continue;
-      }
-      e[s] = this.resolveArgumentValue(s, r, n.shift());
-    }
-    return e;
-  }
-  /**
-   * Handles variadic arguments that consume all remaining positional values
-   */
-  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(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(t, e, n) {
-    let s;
-    const r = [t, ...e.alias];
-    for (const o of r)
-      if (o in n) {
-        s = n[o];
-        break;
-      }
-    if (s === void 0) {
-      if (e.required)
-        throw new A({
-          option: t,
-          reason: "Required option is missing"
-        });
-      return e.default;
-    }
-    return v(s, e.type, t, e.default);
-  }
-  optionDefinitions() {
-    const t = {};
-    for (const e in this.options)
-      t[e] = g(this.options[e]);
-    return t;
-  }
-  argumentDefinitions() {
-    const t = {};
-    for (const e in this.arguments)
-      t[e] = g(this.arguments[e]);
-    return t;
-  }
-  availableOptions() {
-    return Object.keys(this.options);
-  }
-  availableArguments() {
-    return Object.keys(this.arguments);
-  }
-  /**
-   * Disables prompting for missing argument values
-   * Useful for non-interactive environments
-   */
-  disablePrompting() {
-    return this.shouldPromptForMissingOptions = !1, this;
-  }
-  /**
-   * Prompts the user to provide a missing argument value via CommandIO
-   * Used by validate() when shouldPromptForMissingArgs is enabled
-   * @param argumentName - The name of the missing argument
-   * @param argDef - The argument's definition for type and description
-   * @returns The user-provided value, or null if none given
-   */
-  async promptForArgument(t, e) {
-    if (!Array.isArray(e.type) && !["string", "number", "secret"].includes(e.type))
-      return null;
-    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,
-      {
-        validate: (s) => s.length ? !0 : "Please enter at least one value"
-      }
-    )) : await this.io.askForInput(
-      n,
-      void 0,
-      {
-        type: e.type === "number" ? "number" : e.type === "secret" ? "password" : "text",
-        validate: (s) => {
-          if (e.type === "number") {
-            const r = Number(s);
-            if (isNaN(r))
-              return "Please enter a valid number";
-          } else if (e.type === "string" && (typeof s != "string" || !s.length))
-            return "Please enter a valid text";
-          return !0;
-        }
-      }
-    );
-  }
-}
-function O(i) {
-  return new Array(i + 5).join(" ");
-}
-class H {
-  type = "boolean";
-  option = "help";
-  alias = ["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 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,
-        ...d,
-        optionWithAlias: `--${a}${h.map((c) => `, -${c}`).join("")}`
-      };
-    }), 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(l`\n{yellow Arguments}:`);
-      for (const [a, d] of n) {
-        const h = O(p - a.length);
-        let c = l`  {green ${a}} ${h} ${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;
-          c += l` {yellow [default: ${N}]}`;
-        }
-        d.variadic && (c += l` {white (variadic)}`), this.io.log(c);
-      }
-    }
-    if (s.length > 0) {
-      this.io.log(l`\n{yellow Options}:`);
-      for (const a of r) {
-        const d = O(p - a.optionWithAlias.length);
-        let h = l`{green ${a.optionWithAlias}} ${d} ${a.description ?? "\b"}`;
-        if (a.type) {
-          const c = Array.isArray(a.type) ? `[${a.type[0]}]` : a.type;
-          h += l` {white (${c})}`;
-        }
-        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;
-          h += l` {yellow [default: ${$}]}`;
-        }
-        this.io.log(h);
-      }
-    }
-    if (this.commandsExamples.length > 0) {
-      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, h] of this.commandsExamples.entries())
-        d > 0 && this.io.log(""), this.io.log(`  ${h.description}
-`), this.io.log(l`    {green ${a} ${h.command}}`);
-    }
-    return -1;
-  }
-}
-class S {
-  logger;
-  constructor(t) {
-    this.logger = t;
-  }
-  /**
-   * Logger methods
-   */
-  log(...t) {
-    this.logger.log(...t);
-  }
-  info(...t) {
-    this.logger.info(...t);
-  }
-  warn(...t) {
-    this.logger.warn(...t);
-  }
-  error(...t) {
-    this.logger.error(...t);
-  }
-  debug(...t) {
-    this.logger.debug(...t);
-  }
-  /**
-   * Prompt utils
-   */
-  async askForConfirmation(t = "Do you want to continue?", e) {
-    return (await y({
-      type: "confirm",
-      name: "value",
-      message: t,
-      initial: e ?? !1
-    })).value;
-  }
-  async askForInput(t, e, n) {
-    return (await y({
-      type: "text",
-      name: "value",
-      message: t,
-      initial: e,
-      ...n
-    }))?.value ?? null;
-  }
-  async askForDate(t, e, n) {
-    return (await y({
-      type: "date",
-      name: "value",
-      message: t,
-      initial: e,
-      ...n
-    }))?.value ?? null;
-  }
-  async askForList(t, e, n) {
-    return (await y({
-      type: "list",
-      name: "value",
-      message: t,
-      initial: e,
-      ...n
-    }))?.value ?? null;
-  }
-  async askForToggle(t, e, n) {
-    return (await y({
-      type: "toggle",
-      name: "value",
-      message: t,
-      initial: e,
-      ...n
-    }))?.value ?? null;
-  }
-  async askForSelect(t, e, n) {
-    if (e.length === 0)
-      throw new Error("No options provided");
-    const s = [];
-    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: t,
-      choices: s,
-      ...n
-    }))?.value ?? null;
-  }
-  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" + e[o++] + " " + s)), o = o % e.length;
-    }, n), m = () => {
-      clearInterval(u), process.stdout.write(new TextEncoder().encode("\r" + " ".repeat(s.length + 5) + "\r"));
-    };
-    return {
-      [Symbol.dispose]: m,
-      [Symbol.asyncDispose]: m,
-      updateText: (p) => {
-        r = s, s = p;
-      },
-      stop: m
-    };
-  }
-}
-class C {
-  _command;
-  description = "";
-  group;
-  commandsExamples = [];
-  get command() {
-    return this._command;
-  }
-  ctx;
-  io;
-  logger;
-  parser;
-  disablePromptingFlag = !1;
-  _preHandler;
-  _handler;
-  tmp;
-  defaultOptions() {
-    return [new H()];
-  }
-  newCommandParser(t) {
-    return new k({
-      io: t.io,
-      options: t.options,
-      arguments: t.arguments
-    });
-  }
-  newCommandIO(t) {
-    return new S(t.logger);
-  }
-  constructor(t, e) {
-    this._command = t, this.description = e?.description ?? "", this.group = e?.group;
-    const n = this.defaultOptions();
-    if (n.length > 0) {
-      this.tmp = {
-        options: {},
-        arguments: {}
-      };
-      for (const s of n)
-        this.tmp.options[s.option] = s;
-    }
-  }
-  disablePrompting() {
-    return this.disablePromptingFlag = !0, this;
-  }
-  preHandler(t) {
-    return this._preHandler = t, this;
-  }
-  handler(t) {
-    return this._handler = t, this;
-  }
-  options(t) {
-    return this.tmp = {
-      options: {
-        ...this.tmp?.options ?? {},
-        ...t
-      },
-      arguments: this.tmp?.arguments ?? {}
-    }, this;
-  }
-  arguments(t) {
-    return this.tmp = {
-      options: this.tmp?.options ?? {},
-      arguments: {
-        ...this.tmp?.arguments ?? {},
-        ...t
-      }
-    }, this;
-  }
-  async run(t) {
-    if (!this._handler && !this.handle)
-      throw new Error(`No handler defined for command ${this.command || "(unknown)"}`);
-    let e;
-    if (this.ctx = t.ctx, this.logger = t.logger, this.io = this.newCommandIO({
-      logger: t.logger
-    }), t && "args" in t) {
-      const r = this.tmp?.options ?? {};
-      for (const o of this.defaultOptions())
-        o.option in r || (r[o.option] = o);
-      this.parser = this.newCommandParser({
-        io: this.io,
-        options: r,
-        arguments: this.tmp?.arguments ?? {}
-      }), e = this.parser.init(t.args);
-      for (const o of this.defaultOptions())
-        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
-      e = {
-        options: t.options,
-        arguments: t.arguments
-      };
-    const n = this.preHandle ? await this.preHandle() : null;
-    if (n && n !== 0)
-      return n;
-    if (!this._handler && this.handle)
-      this._handler = this.handle.bind(this);
-    else if (!this._handler)
-      throw new Error(`No handler defined for command ${this.command || "(unknown)"}`);
-    return await this._handler(t.ctx, e) ?? 0;
-  }
-}
-class w extends k {
-  command;
-  constructor(t) {
-    const e = w.parseSignature(
-      t.signature,
-      t.helperDefinitions,
-      t.defaultOptions
-    );
-    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(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,
-        e
-      );
-      a ? o[p] = d : u[p] = d;
-    }
-    for (const m of n)
-      o[m.option] = {
-        type: m.type,
-        required: m.required,
-        alias: m.alias,
-        variadic: m.variadic ?? !1,
-        description: m.description,
-        default: m.default ?? null
-      };
-    return { command: s, options: o, arguments: u };
-  }
-  /**
-   * Parses a single parameter signature like "{name}" or "{--force}" or "{files*}"
-   * Extracts name, type, default value, aliases, description, etc.
-   *
-   * Signature syntax:
-   * - {arg}          -> required string argument
-   * - {arg?}         -> optional argument
-   * - {arg=default}  -> argument with default value
-   * - {arg*}         -> variadic argument (array)
-   * - {arg:desc}     -> argument with description
-   * - {--opt}        -> boolean option
-   * - {--opt=}       -> string option
-   * - {--opt|o}      -> option with alias
-   */
-  static parseParamSignature(t, e) {
-    let n = t, s = !1;
-    const r = {
-      required: !0,
-      type: "string",
-      description: void 0,
-      default: null,
-      variadic: !1
-    };
-    if (n.includes(":")) {
-      const [o, u] = n.split(":");
-      n = o.trim(), r.description = u.trim();
-    }
-    if (n.includes("=")) {
-      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, ...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 ?? e[n] ?? e[`--${n}`], { name: n, isOption: s, definition: r };
-  }
-}
-class z extends C {
-  helperDefinitions = {};
-  get command() {
-    return this.parser ? this.parser.command : this.signature.split(" ")[0];
-  }
-  newCommandParser(t) {
-    return new w({
-      io: t.io,
-      signature: this.signature,
-      helperDefinitions: this.helperDefinitions,
-      defaultOptions: this.defaultOptions()
-    });
-  }
-  constructor() {
-    super("");
-  }
-  option(t, e = null) {
-    return this.parser instanceof w ? this.parser.option(t) ?? e : e;
-  }
-  argument(t, e = null) {
-    return this.parser instanceof w ? this.parser.argument(t) ?? e : e;
-  }
-  // Prompt utils
-  async askForConfirmation(...t) {
-    return this.io.askForConfirmation(...t);
-  }
-  async askForInput(...t) {
-    return this.io.askForInput(...t);
-  }
-  async askForSelect(...t) {
-    return this.io.askForSelect(...t);
-  }
-  newLoader(...t) {
-    return this.io.newLoader(...t);
-  }
-}
-class L {
-  level;
-  constructor(t = {}) {
-    this.level = t.level ?? "info";
-  }
-  shouldLog(t) {
-    const e = ["debug", "info", "warn", "error"], n = e.indexOf(this.level);
-    return e.indexOf(t) >= n;
-  }
-  setLevel(t) {
-    this.level = t;
-  }
-  getLevel() {
-    return this.level;
-  }
-  log(...t) {
-    console.log(...t);
-  }
-  info(...t) {
-    this.shouldLog("info") && console.log(...t);
-  }
-  warn(...t) {
-    this.shouldLog("warn") && console.warn(...t);
-  }
-  error(...t) {
-    this.shouldLog("error") && console.error(...t);
-  }
-  debug(...t) {
-    this.shouldLog("debug") && console.log(...t);
-  }
-}
-class j {
-  commands = {};
-  io;
-  logger;
-  get CommandIOClass() {
-    return S;
-  }
-  constructor(t) {
-    this.logger = t ?? new L(), this.io = new this.CommandIOClass(this.logger);
-  }
-  getAvailableCommands() {
-    return Object.keys(this.commands);
-  }
-  getCommands() {
-    return Object.values(this.commands);
-  }
-  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;
-  };
-  withCommandResolver(t) {
-    return this.commandResolver = t, this;
-  }
-  withFileImporter(t) {
-    return this.importFile = t, this;
-  }
-  registerCommand(t, e = !1) {
-    const n = t.command;
-    if (!n)
-      throw new Error("Command signature is invalid, it must have a command name.");
-    if (!e && this.commands[n])
-      throw new Error(`Command ${n} already registered.`);
-    this.commands[n] = t;
-  }
-  async loadCommandsPath(t) {
-    for await (const e of this.listCommandsFiles(t))
-      try {
-        const n = await this.commandResolver(e);
-        n instanceof C && this.registerCommand(n);
-      } catch (n) {
-        throw new Error(`Command ${e} failed to load. ${n}`, {
-          cause: n
-        });
-      }
-  }
-  async runCommand(t, e, ...n) {
-    const s = typeof e == "string" ? this.commands[e] : e, r = typeof e == "string" ? e : s.command;
-    if (!s) {
-      const o = await this.suggestCommand(r);
-      return o ? await this.runCommand(t, o, ...n) : 1;
-    }
-    return await s.run({
-      ctx: t,
-      logger: this.logger,
-      args: n
-    }) ?? 0;
-  }
-  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 = e[s];
-      return await this.askRunSimilarCommand(t, u) ? u : null;
-    }
-    if (o.length) {
-      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
-      );
-      if (u)
-        return u;
-    }
-    throw new P(t);
-  }
-  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(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(t, n.name));
-      else {
-        if (!s.endsWith(".ts") && !s.endsWith(".js") && !s.endsWith(".mjs") && !s.endsWith(".cjs"))
-          continue;
-        yield s;
-      }
-    }
-  }
-}
-class W extends C {
-  constructor(t) {
-    super("help", {
-      description: l.bold("Show help information about the CLI and its commands")
-    }), this.opts = t;
-  }
-  async handle() {
-    const t = this.opts.commandRegistry.getCommands(), e = this.opts.cliName ?? "Bob CLI", n = this.opts.cliVersion ?? "0.0.0", s = (await import("./package-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(...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);
-    }
-    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((h, c) => h.command.toLowerCase().localeCompare(c.command.toLowerCase()));
-      for (const h of d) {
-        let c = O(r - h.command.length);
-        a && (c = c.slice(2)), this.io.log(l`${a ? "  " : ""}{green ${h.command}} ${c} ${h.description}`);
-      }
-    }
-  }
-}
-class T {
-  logger;
-  constructor(t) {
-    this.logger = t;
-  }
-  handle(t) {
-    if (t instanceof f)
-      return t.pretty(this.logger), -1;
-    throw t;
-  }
-}
-class J {
-  ctx;
-  logger;
-  commandRegistry;
-  exceptionHandler;
-  helpCommand;
-  newCommandRegistry(t) {
-    return new j(t.logger);
-  }
-  newHelpCommand(t) {
-    return new W(t);
-  }
-  newExceptionHandler(t) {
-    return new T(t.logger);
-  }
-  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: t.name,
-      cliVersion: t.version,
-      commandRegistry: this.commandRegistry
-    });
-  }
-  withCommandResolver(t) {
-    return this.commandRegistry.withCommandResolver(t), this;
-  }
-  withFileImporter(t) {
-    return this.commandRegistry.withFileImporter(t), this;
-  }
-  async withCommands(...t) {
-    for (const e of t)
-      typeof e == "string" ? await this.commandRegistry.loadCommandsPath(e) : typeof e == "function" ? this.registerCommand(new e()) : this.registerCommand(e);
-  }
-  async 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(t) {
-    this.commandRegistry.registerCommand(t);
-  }
-}
-export {
-  A as BadCommandOption,
-  U as BadCommandParameter,
-  f as BobError,
-  J as Cli,
-  C as Command,
-  S as CommandIO,
-  P as CommandNotFoundError,
-  k 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,
-  V as MissingRequiredOptionValue
-};