bob-core 2.0.0-beta.9 → 2.0.0

package/dist/esm/src/index.js

@@ -0,0 +1,1029 @@
+import y from "prompts";
+import a from "chalk";
+import q from "minimist";
+import I from "node:fs";
+import R from "node:path";
+class S {
+  logger;
+  constructor(t) {
+    this.logger = t.logger;
+  }
+  /**
+   * 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, i) {
+    return (await y({
+      type: "text",
+      name: "value",
+      message: t,
+      initial: e,
+      ...i
+    }))?.value ?? null;
+  }
+  async askForDate(t, e, i) {
+    return (await y({
+      type: "date",
+      name: "value",
+      message: t,
+      initial: e,
+      ...i
+    }))?.value ?? null;
+  }
+  async askForList(t, e, i) {
+    return (await y({
+      type: "list",
+      name: "value",
+      message: t,
+      initial: e,
+      ...i
+    }))?.value ?? null;
+  }
+  async askForToggle(t, e, i) {
+    return (await y({
+      type: "toggle",
+      name: "value",
+      message: t,
+      initial: e,
+      ...i
+    }))?.value ?? null;
+  }
+  async askForSelect(t, e, i) {
+    if (e.length === 0)
+      throw new Error("No options provided");
+    const n = [];
+    for (const o of e)
+      typeof o == "string" ? n.push({ title: o, value: o }) : n.push(o);
+    return (await y({
+      type: "select",
+      name: "value",
+      message: t,
+      choices: n,
+      ...i
+    }))?.value ?? null;
+  }
+  newLoader(t = "", e = ["⠙", "⠘", "⠰", "⠴", "⠤", "⠦", "⠆", "⠃", "⠋", "⠉"], i = 100) {
+    let n = t, s = null, o = 0;
+    const u = 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++] + " " + n)), o = o % e.length;
+    }, i), m = () => {
+      clearInterval(u), process.stdout.write(new TextEncoder().encode("\r" + " ".repeat(n.length + 5) + "\r"));
+    };
+    return {
+      [Symbol.dispose]: m,
+      [Symbol.asyncDispose]: m,
+      updateText: (h) => {
+        s = n, n = h;
+      },
+      stop: m
+    };
+  }
+}
+class f extends Error {
+}
+function x(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 E(r) {
+  return typeof r == "string" || Array.isArray(r) ? x(r) : r.default !== void 0 ? r.default : x(r.type);
+}
+function g(r) {
+  return typeof r == "string" || Array.isArray(r) ? {
+    alias: [],
+    default: E(r),
+    description: "",
+    required: !1,
+    secret: !1,
+    type: r,
+    variadic: !1
+  } : {
+    alias: r.alias ? Array.isArray(r.alias) ? r.alias : [r.alias] : [],
+    default: r.default ?? E(r.type),
+    description: r.description ?? "",
+    required: r.required ?? !1,
+    secret: r.secret ?? !1,
+    type: r.type,
+    variadic: r.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(`
+${a.yellow("Available options")}:`);
+      for (const [i, n] of e) {
+        const s = g(n), o = s.alias ? typeof s.alias == "string" ? [s.alias] : s.alias : [], u = Array.isArray(s.type) ? `[${s.type[0]}]` : s.type, m = `--${i}${o.length > 0 ? o.map((l) => `, -${l}`).join("") : ""}`, h = " ".repeat(30 - m.length);
+        t.log(`  ${a.green(m)} ${h} ${s.description || "\b"} ${a.white(`(${u})`)}`);
+      }
+      t.log("");
+    }
+    t.log(`${a.white.bgRed(" ERROR ")} Option ${a.bold.yellow(this.option)} is not recognized.`);
+  }
+}
+class F extends f {
+  constructor(t) {
+    super(`Argument "${t}" is required.`), this.argument = t;
+  }
+  pretty(t) {
+    t.log(`${a.white.bgRed(" ERROR ")} Argument ${a.bold.yellow(this.argument)} is required.`);
+  }
+}
+class V extends f {
+  constructor(t) {
+    super(`Argument "${t}" is required.`), this.option = t;
+  }
+  pretty(t) {
+    t.log(`${a.white.bgRed(" ERROR ")} Option ${a.bold.yellow(this.option)} is required.`);
+  }
+}
+class z 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(`  ${a.white.bgRed(" ERROR ")} Argument ${a.bold.yellow(this.param.param)} value is invalid. `), (this.param.value || this.param.reason) && t.log(""), this.param.value && t.log(`  ${a.blue("Value")}: ${this.param.value}`), this.param.reason && t.log(`  ${a.yellow("Reason")}: ${this.param.reason}`);
+  }
+}
+class C 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(`  ${a.white.bgRed(" ERROR ")} Option ${a.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}`);
+  }
+}
+class P extends f {
+  constructor(t) {
+    super(`Command "${t}" not found.`), this.command = t;
+  }
+  pretty(t) {
+    t.log(`${a.bgRed(" ERROR ")} Command ${a.yellow(this.command)} not found.`);
+  }
+}
+function w(r, t, e, i) {
+  if (r == null)
+    return i ?? null;
+  if (t === "string")
+    return String(r);
+  if (t === "number") {
+    const n = Number(r);
+    if (isNaN(n))
+      throw new C({
+        option: e,
+        reason: `Expected a number, got "${r}"`
+      });
+    return n;
+  }
+  if (t === "boolean")
+    return typeof r == "boolean" ? r : r === "true" || r === "1" ? !0 : r === "false" || r === "0" ? !1 : !!r;
+  if (Array.isArray(t)) {
+    const n = t[0], s = Array.isArray(r) ? r : [r];
+    if (n === "string")
+      return s.map((o) => String(o));
+    if (n === "number")
+      return s.map((o) => {
+        const u = Number(o);
+        if (isNaN(u))
+          throw new C({
+            option: e,
+            reason: `Expected array of numbers, got "${o}" in array`
+          });
+        return u;
+      });
+  }
+  return r;
+}
+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 naan option is provided
+   * @throws {BadCommandOption} If a value cannot be converted to the expected type
+   */
+  init(t) {
+    const { _: e, ...i } = q(t);
+    return this.validateUnknownOptions(i), this.parsedOptions = this.handleOptions(i), 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]), i = this.parsedArguments?.[t];
+      if (e.required && i == null) {
+        if (this.shouldPromptForMissingOptions) {
+          const n = await this.promptForArgument(t, e);
+          if (n && this.parsedArguments) {
+            this.parsedArguments[t] = w(n, e.type, t);
+            continue;
+          }
+        }
+        throw new F(t);
+      }
+      if (e.required && e.variadic && Array.isArray(i) && i.length === 0) {
+        if (this.shouldPromptForMissingOptions) {
+          const n = await this.promptForArgument(t, e);
+          if (n && this.parsedArguments) {
+            this.parsedArguments[t] = w(n, e.type, t);
+            continue;
+          }
+        }
+        throw new F(t);
+      }
+    }
+  }
+  /**
+   * Retrieves a parsed option value by name
+   * @param name - The option name
+   * @param defaultValue - Optional default value if option is not set
+   * @returns The typed option value
+   * @throws {Error} If init() has not been called yet
+   */
+  option(t, e) {
+    if (!this.parsedOptions)
+      throw new Error("Options have not been parsed yet. Call init() first.");
+    return this.isEmptyValue(this.parsedOptions[t]) && e !== void 0 ? e : 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
+   * @param defaultValue - Optional default value if argument is not set
+   * @returns The typed argument value
+   * @throws {Error} If init() has not been called yet
+   */
+  argument(t, e) {
+    if (!this.parsedArguments)
+      throw new Error("Arguments have not been parsed yet. Call init() first.");
+    return this.isEmptyValue(this.parsedArguments[t]) && e !== void 0 ? e : 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 ===
+  /**
+   * Checks if a value should be considered "empty" for default value purposes
+   * @param value - The value to check
+   * @returns true if the value is null, undefined, or an empty array
+   */
+  isEmptyValue(t) {
+    return t == null || Array.isArray(t) && t.length === 0;
+  }
+  /**
+   * Validates that all provided options are recognized
+   * @throws {InvalidOption} If an unknown option is found
+   */
+  validateUnknownOptions(t) {
+    const e = /* @__PURE__ */ new Set();
+    for (const i in this.options) {
+      e.add(i);
+      const n = g(this.options[i]);
+      for (const s of n.alias)
+        e.add(s);
+    }
+    for (const i in t)
+      if (!e.has(i))
+        throw new b(i, this.options);
+  }
+  /**
+   * Processes named options from minimist output
+   */
+  handleOptions(t) {
+    const e = {};
+    for (const i in this.options) {
+      const n = g(this.options[i]);
+      e[i] = this.resolveOptionValue(i, n, t);
+    }
+    return e;
+  }
+  /**
+   * Processes positional arguments from minimist output
+   */
+  handleArguments(t) {
+    const e = {}, i = [...t];
+    for (const n in this.arguments) {
+      const s = g(this.arguments[n]);
+      if (s.variadic) {
+        e[n] = this.handleVariadicArgument(n, s, i);
+        continue;
+      }
+      e[n] = this.resolveArgumentValue(n, s, i.shift());
+    }
+    return e;
+  }
+  /**
+   * Handles variadic arguments that consume all remaining positional values
+   */
+  handleVariadicArgument(t, e, i) {
+    return i.length ? w(i, 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, i) {
+    return i === void 0 ? e.default : w(i, 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, i) {
+    let n;
+    const s = [t, ...e.alias];
+    for (const o of s)
+      if (o in i) {
+        n = i[o];
+        break;
+      }
+    if (n === void 0) {
+      if (e.required)
+        throw new C({
+          option: t,
+          reason: "Required option is missing"
+        });
+      return e.default;
+    }
+    return w(n, 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 i = `${a.yellow.bold(t)} is required`;
+    return e.description && (i += `: ${a.gray(`(${e.description})`)}`), i += ` ${a.green(`(${e.type}${e.variadic == !0 ? "[]" : ""})`)}
+`, Array.isArray(e.type) ? (i += `Please provide one or more values, separated by commas:
+`, await this.io.askForList(i, void 0, {
+      separator: ",",
+      validate: (n) => {
+        if (!n.length)
+          return "Please enter at least one value";
+        if (e.type[0] === "number") {
+          for (const s of n.split(","))
+            if (isNaN(Number(s)))
+              return "Please enter only valid numbers";
+        }
+        return !0;
+      }
+    })) : await this.io.askForInput(i, void 0, {
+      type: e.type === "number" ? "number" : e.secret ? "password" : "text",
+      validate: (n) => {
+        if (n == null || typeof n == "string" && !n.length)
+          return "This value is required";
+        if (e.type === "number") {
+          const s = Number(n);
+          if (isNaN(s))
+            return "Please enter a valid number";
+        } else if (e.type === "string" && (typeof n != "string" || !n.length))
+          return "Please enter a valid text";
+        return !0;
+      }
+    });
+  }
+}
+function A(r) {
+  return new Array(r + 5).join(" ");
+}
+class H {
+  type = "boolean";
+  option = "help";
+  alias = ["h"];
+  default = !1;
+  description = `Display help for the given command. When no command is given display help for the ${a.green("list")} command`;
+  async handler() {
+    const t = this.parser.argumentDefinitions(), e = this.parser.optionDefinitions(), i = Object.entries(t), n = Object.entries(e), s = n.map(([l, d]) => {
+      const p = Array.isArray(d.alias) ? d.alias : d.alias ? [d.alias] : [];
+      return {
+        name: l,
+        ...d,
+        optionWithAlias: `--${l}${p.map((c) => `, -${c}`).join("")}`
+      };
+    }), o = i.filter(([, l]) => l.required);
+    this.io.log(a.yellow("Description:")), this.io.log(`  ${this.description}
+`), this.io.log(a.yellow("Usage:")), this.io.log(`  ${this.command} ${o.length > 0 ? o.map(([l]) => `<${l}>`).join(" ") : "\b"} [options]`);
+    const u = Math.max(...s.map((l) => l.optionWithAlias.length), 0), m = Math.max(...i.map(([l]) => l.length), 0), h = m > u ? m : u;
+    if (i.length > 0) {
+      this.io.log(`
+${a.yellow("Arguments")}:`);
+      for (const [l, d] of i) {
+        const p = A(h - l.length);
+        let c = `  ${a.green(l)} ${p} ${d.description ?? "\b"}`;
+        if (d.default !== void 0 && !d.required) {
+          const L = (Array.isArray(d.type) ? `[${d.type[0]}]` : d.type) === "array" || Array.isArray(d.type) ? JSON.stringify(d.default) : d.default;
+          c += ` ${a.yellow(`[default: ${L}]`)}`;
+        }
+        d.variadic && (c += ` ${a.white("(variadic)")}`), this.io.log(c);
+      }
+    }
+    if (n.length > 0) {
+      this.io.log(`
+${a.yellow("Options")}:`);
+      for (const l of s) {
+        const d = A(h - l.optionWithAlias.length);
+        let p = `${a.green(l.optionWithAlias)} ${d} ${l.description ?? "\b"}`;
+        if (l.type) {
+          const c = Array.isArray(l.type) ? `[${l.type[0]}]` : l.type;
+          p += ` ${a.white(`(${c})`)}`;
+        }
+        if (l.default !== void 0 && !l.required) {
+          const O = (Array.isArray(l.type) ? `[${l.type[0]}]` : l.type) === "array" || Array.isArray(l.type) ? JSON.stringify(l.default) : l.default;
+          p += ` ${a.yellow(`[default: ${O}]`)}`;
+        }
+        this.io.log(p);
+      }
+    }
+    if (this.commandsExamples.length > 0) {
+      this.io.log(`
+${a.yellow("Examples")}:`);
+      let l = process.argv[0].split("/").pop();
+      l === "node" && (l += " " + process.argv[1].split("/").pop());
+      for (const [d, p] of this.commandsExamples.entries())
+        d > 0 && this.io.log(""), this.io.log(`  ${p.description}
+`), this.io.log(`    ${a.green(`${l} ${p.command}`)}`);
+    }
+    return -1;
+  }
+}
+class v {
+  _command;
+  description;
+  group;
+  commandsExamples = [];
+  get command() {
+    return this._command;
+  }
+  ctx;
+  io;
+  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);
+  }
+  constructor(t, e) {
+    this._command = t, this.description = e?.description ?? "", this.group = e?.group, this.tmp = {
+      options: e?.options ?? {},
+      arguments: e?.arguments ?? {}
+    };
+    const i = this.defaultOptions();
+    if (i.length > 0)
+      for (const n of i)
+        this.tmp.options[n.option] = n;
+  }
+  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.io = this.newCommandIO({
+      logger: t.logger
+    }), t && "args" in t) {
+      const n = this.tmp?.options ?? {};
+      for (const s of this.defaultOptions())
+        s.option in n || (n[s.option] = s);
+      this.parser = this.newCommandParser({
+        io: this.io,
+        options: n,
+        arguments: this.tmp?.arguments ?? {}
+      }), e = this.parser.init(t.args);
+      for (const s of this.defaultOptions())
+        if (e.options[s.option] === !0) {
+          const o = await s.handler.call(this);
+          if (o && o !== 0)
+            return o;
+        }
+      this.disablePromptingFlag && this.parser.disablePrompting(), await this.parser.validate();
+    } else
+      e = {
+        options: t.options,
+        arguments: t.arguments
+      };
+    if (!this._preHandler && this.preHandle && (this._preHandler = this.preHandle.bind(this)), this._preHandler) {
+      const n = await this._preHandler(t.ctx, e);
+      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 $ extends k {
+  command;
+  constructor(t) {
+    const e = $.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, i) {
+    const [n, ...s] = t.split(/\{(.*?)\}/g).map((m) => m.trim()).filter(Boolean), o = {}, u = {};
+    for (const m of s) {
+      const { name: h, isOption: l, definition: d } = $.parseParamSignature(m, e);
+      l ? o[h] = d : u[h] = d;
+    }
+    for (const m of i)
+      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: n,
+      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 i = t, n = !1;
+    const s = {
+      required: !0,
+      type: "string",
+      description: void 0,
+      default: null,
+      variadic: !1
+    };
+    if (i.includes(":")) {
+      const [o, u] = i.split(":");
+      i = o.trim(), s.description = u.trim();
+    }
+    if (i.includes("=")) {
+      const [o, u] = i.split("=");
+      i = o.trim(), s.default = u.trim(), s.required = !1, typeof s.default == "string" && !s.default.length ? s.default = null : s.default === "true" ? (s.default = !0, s.type = "boolean") : s.default === "false" && (s.default = !1, s.type = "boolean");
+    } else i.startsWith("--") && (s.required = !1, s.default = !1, s.type = "boolean");
+    if (i.includes("|")) {
+      const [o, ...u] = i.split("|");
+      i = o.trim(), s.alias = u.map((m) => m.trim());
+    }
+    return i.startsWith("--") && (n = !0, i = i.slice(2)), s.default === "*" && (s.default = [], s.type = ["string"]), i.endsWith("?") && (s.required = !1, i = i.slice(0, -1)), i.endsWith("*") && (s.type = ["string"], s.variadic = !0, s.default = [], i = i.slice(0, -1)), s.description = s.description ?? e[i] ?? e[`--${i}`], { name: i, isOption: n, definition: s };
+  }
+}
+class J extends v {
+  helperDefinitions = {};
+  get command() {
+    return this.parser ? this.parser.command : this.signature.split(" ")[0];
+  }
+  newCommandParser(t) {
+    return new $({
+      io: t.io,
+      signature: this.signature,
+      helperDefinitions: this.helperDefinitions,
+      defaultOptions: this.defaultOptions()
+    });
+  }
+  constructor() {
+    super("");
+  }
+  option(t, e = null) {
+    return this.parser.option(t, e);
+  }
+  argument(t, e = null) {
+    return this.parser.argument(t, 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 N {
+  level;
+  constructor(t = {}) {
+    this.level = t.level ?? "info";
+  }
+  shouldLog(t) {
+    const e = ["debug", "info", "warn", "error"], i = e.indexOf(this.level);
+    return e.indexOf(t) >= i;
+  }
+  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 D {
+  /**
+   * Generate bigrams (character pairs) from a string
+   */
+  getBigrams(t) {
+    const e = [], i = t.toLowerCase();
+    for (let n = 0; n < i.length - 1; n++)
+      e.push(i.slice(n, n + 2));
+    return e;
+  }
+  /**
+   * Calculate Dice's Coefficient similarity between two strings (0-1 scale)
+   */
+  calculateSimilarity(t, e) {
+    if (t === e) return 1;
+    if (t.length < 2 || e.length < 2) return 0;
+    const i = this.getBigrams(t), n = this.getBigrams(e), s = new Set(n);
+    let o = 0;
+    for (const u of i)
+      s.has(u) && (o++, s.delete(u));
+    return 2 * o / (i.length + n.length);
+  }
+  /**
+   * Find best matching string and ratings for all candidates
+   */
+  findBestMatch(t, e) {
+    const i = e.map((o) => ({
+      target: o,
+      rating: this.calculateSimilarity(t, o)
+    }));
+    let n = 0, s = i[0]?.rating ?? 0;
+    for (let o = 1; o < i.length; o++)
+      i[o].rating > s && (s = i[o].rating, n = o);
+    return {
+      ratings: i,
+      bestMatch: i[n],
+      bestMatchIndex: n
+    };
+  }
+}
+class j {
+  commands = {};
+  io;
+  logger;
+  stringSimilarity;
+  newCommandIO(t) {
+    return new S(t);
+  }
+  constructor(t) {
+    this.logger = t?.logger ?? new N(), this.io = this.newCommandIO({
+      logger: this.logger
+    }), this.stringSimilarity = t?.stringSimilarity ?? new D();
+  }
+  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);
+    return e ? (e && typeof e == "object" && "default" in e && (e = e.default), typeof e == "function" ? new e() : e instanceof v ? e : null) : null;
+  };
+  withCommandResolver(t) {
+    return this.commandResolver = t, this;
+  }
+  withFileImporter(t) {
+    return this.importFile = t, this;
+  }
+  registerCommand(t, e = !1) {
+    const i = t.command;
+    if (!i)
+      throw new Error("Command signature is invalid, it must have a command name.");
+    if (!e && this.commands[i])
+      throw new Error(`Command ${i} already registered.`);
+    this.commands[i] = t;
+  }
+  async loadCommandsPath(t) {
+    for await (const e of this.listCommandsFiles(t))
+      try {
+        const i = await this.commandResolver(e);
+        i instanceof v && this.registerCommand(i);
+      } catch (i) {
+        throw new Error(`Command ${e} failed to load. ${i}`, {
+          cause: i
+        });
+      }
+  }
+  async runCommand(t, e, ...i) {
+    const n = typeof e == "string" ? this.commands[e] : e, s = typeof e == "string" ? e : n.command;
+    if (!n) {
+      const o = await this.suggestCommand(s);
+      return o ? await this.runCommand(t, o, ...i) : 1;
+    }
+    return await n.run({
+      ctx: t,
+      logger: this.logger,
+      args: i
+    }) ?? 0;
+  }
+  async suggestCommand(t) {
+    const e = this.getAvailableCommands(), { bestMatch: i, bestMatchIndex: n, ratings: s } = this.stringSimilarity.findBestMatch(t, e), o = s.filter((u) => u.rating > 0.3).map((u) => u.target);
+    if (i.rating > 0 && o.length <= 1 || i.rating > 0.7 && o.length > 1) {
+      const u = e[n];
+      return await this.askRunSimilarCommand(t, u) ? u : null;
+    }
+    if (o.length) {
+      this.io.error(`${a.bgRed(" ERROR ")} Command ${a.yellow(t)} not found.
+`);
+      const u = await this.io.askForSelect(a.green("Did you mean to run one of these commands instead?"), o);
+      if (u)
+        return u;
+    }
+    throw new P(t);
+  }
+  async askRunSimilarCommand(t, e) {
+    return this.io.error(`${a.bgRed(" ERROR ")} Command ${a.yellow(t)} not found.
+`), this.io.askForConfirmation(`${a.green(`Do you want to run ${a.yellow(e)} instead?`)} `);
+  }
+  async *listCommandsFiles(t) {
+    const e = I.readdirSync(t, { withFileTypes: !0 });
+    for (const i of e) {
+      const n = R.resolve(t, i.name);
+      if (i.isDirectory())
+        yield* this.listCommandsFiles(R.resolve(t, i.name));
+      else {
+        if (!n.endsWith(".ts") && !n.endsWith(".js") && !n.endsWith(".mjs") && !n.endsWith(".cjs"))
+          continue;
+        yield n;
+      }
+    }
+  }
+}
+class W {
+  logger;
+  constructor(t) {
+    this.logger = t;
+  }
+  handle(t) {
+    if (t instanceof f)
+      return t.pretty(this.logger), -1;
+    throw t;
+  }
+}
+class M extends v {
+  constructor(t) {
+    super("help", {
+      description: a.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", i = this.opts.cliVersion ?? "0.0.0", n = (await import("../package-DbMvpGfM.js"))?.default?.version ?? "0.0.0";
+    this.io.log(`${e} ${a.green(i)} (core: ${a.yellow(n)})
+
+${a.yellow("Usage")}:
+  command [options] [arguments]
+
+${a.yellow("Available commands")}:
+`);
+    const s = Math.max(...t.map((m) => m.command.length)) ?? 0, o = {};
+    for (const m of t) {
+      const h = m.group ?? m.command.split(":")[0];
+      o[h] || (o[h] = []), o[h].push(m);
+    }
+    const u = Object.entries(o).sort(([m], [h]) => m.toLowerCase().localeCompare(h.toLowerCase())).sort(([, m], [, h]) => m.length - h.length);
+    for (const [m, h] of u) {
+      const l = h.length > 1;
+      l && this.io.log(a.yellow(`${m}:`));
+      const d = h.sort((p, c) => p.command.toLowerCase().localeCompare(c.command.toLowerCase()));
+      for (const p of d) {
+        let c = A(s - p.command.length);
+        l && (c = c.slice(2)), this.io.log(`${l ? "  " : ""}${a.green(p.command)} ${c} ${p.description}`);
+      }
+    }
+  }
+}
+class K {
+  ctx;
+  logger;
+  commandRegistry;
+  exceptionHandler;
+  helpCommand;
+  newCommandRegistry(t) {
+    return new j(t);
+  }
+  newHelpCommand(t) {
+    return new M(t);
+  }
+  newExceptionHandler(t) {
+    return new W(t.logger);
+  }
+  constructor(t = {}) {
+    this.ctx = t.ctx, this.logger = t.logger ?? new N(), 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 {
+  C as BadCommandOption,
+  z as BadCommandParameter,
+  f as BobError,
+  K as Cli,
+  v as Command,
+  S as CommandIO,
+  P as CommandNotFoundError,
+  k as CommandParser,
+  j as CommandRegistry,
+  $ as CommandSignatureParser,
+  J as CommandWithSignature,
+  W as ExceptionHandler,
+  H as HelpOption,
+  b as InvalidOption,
+  N as Logger,
+  F as MissingRequiredArgumentValue,
+  V as MissingRequiredOptionValue,
+  D as StringSimilarity
+};