bob-core 2.1.0 → 3.0.0-alpha.0

package/dist/esm/src/index.js

@@ -1,1079 +1,935 @@
-import y from "prompts";
-import a from "chalk";
-import q from "minimist";
-import I from "node:fs";
-import x 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
-    };
-  }
+import e from "prompts";
+import t from "chalk";
+import n from "minimist";
+import r from "node:fs";
+import i from "node:path";
+//#region src/CommandIO.ts
+var a = class {
+	logger;
+	constructor(e) {
+		this.logger = e.logger;
+	}
+	log(...e) {
+		this.logger.log(...e);
+	}
+	info(...e) {
+		this.logger.info(...e);
+	}
+	warn(...e) {
+		this.logger.warn(...e);
+	}
+	error(...e) {
+		this.logger.error(...e);
+	}
+	debug(...e) {
+		this.logger.debug(...e);
+	}
+	async askForConfirmation(t = "Do you want to continue?", n) {
+		return (await e({
+			type: "confirm",
+			name: "value",
+			message: t,
+			initial: n ?? !1
+		})).value;
+	}
+	async askForInput(t, n, r) {
+		return (await e({
+			type: "text",
+			name: "value",
+			message: t,
+			initial: n,
+			...r
+		}))?.value ?? null;
+	}
+	async askForDate(t, n, r) {
+		return (await e({
+			type: "date",
+			name: "value",
+			message: t,
+			initial: n,
+			...r
+		}))?.value ?? null;
+	}
+	async askForList(t, n, r) {
+		return (await e({
+			type: "list",
+			name: "value",
+			message: t,
+			initial: n,
+			...r
+		}))?.value ?? null;
+	}
+	async askForToggle(t, n, r) {
+		return (await e({
+			type: "toggle",
+			name: "value",
+			message: t,
+			initial: n,
+			...r
+		}))?.value ?? null;
+	}
+	async askForSelect(t, n, r) {
+		if (n.length === 0) throw Error("No options provided");
+		let i = [];
+		for (let e of n) typeof e == "string" ? i.push({
+			title: e,
+			value: e
+		}) : i.push(e);
+		return (await e({
+			type: "select",
+			name: "value",
+			message: t,
+			choices: i,
+			...r
+		}))?.value ?? null;
+	}
+	newLoader(e = "", t = [
+		"⠙",
+		"⠘",
+		"⠰",
+		"⠴",
+		"⠤",
+		"⠦",
+		"⠆",
+		"⠃",
+		"⠋",
+		"⠉"
+	], n = 100) {
+		let r = e, i = null, a = 0, o = setInterval(function() {
+			i &&= (process.stdout.write(new TextEncoder().encode("\r" + " ".repeat(i.length + 5) + "\r")), null), process.stdout.write(new TextEncoder().encode("\r" + t[a++] + " " + r)), a %= t.length;
+		}, n), s = () => {
+			clearInterval(o), process.stdout.write(new TextEncoder().encode("\r" + " ".repeat(r.length + 5) + "\r"));
+		};
+		return {
+			[Symbol.dispose]: s,
+			[Symbol.asyncDispose]: s,
+			updateText: (e) => {
+				i = r, r = e;
+			},
+			stop: s
+		};
+	}
+}, o = class extends Error {
+	$type = "BobError";
+}, s = class extends o {
+	constructor(e, t = {}) {
+		super(`Flag ${e} is not recognized`), this.flag = e, this.flagsSchema = t;
+	}
+	pretty(e) {
+		e.log(""), e.log(`  ${t.bold.white.bgRed(" ERROR ")} Flag ${t.bold.yellow(this.flag)} is not recognized.`);
+		let n = Object.entries(this.flagsSchema);
+		if (n.length > 0) {
+			e.log(""), e.log(`  ${t.dim("Available flags:")}`), e.log("");
+			let r = n.map(([e, t]) => {
+				let n = t.alias ? typeof t.alias == "string" ? [t.alias] : t.alias : [], r = Array.isArray(t.type) ? `[${t.type[0]}]` : t.type === "enum" && t.options ? t.options.join(" | ") : t.type;
+				return {
+					nameWithAlias: `--${e}${n.length > 0 ? n.map((e) => `, -${e}`).join("") : ""}`,
+					description: t.description || "",
+					typeDisplay: r
+				};
+			}), i = Math.max(...r.map((e) => e.nameWithAlias.length));
+			for (let n of r) {
+				let r = " ".repeat(i - n.nameWithAlias.length + 2);
+				e.log(`    ${t.green(n.nameWithAlias)}${r}${n.description}  ${t.dim(`(${n.typeDisplay})`)}`);
+			}
+		}
+		e.log("");
+	}
+}, c = class extends o {
+	constructor(e) {
+		super(`Argument "${e}" is required.`), this.argument = e;
+	}
+	pretty(e) {
+		e.log(""), e.log(`  ${t.bold.white.bgRed(" ERROR ")} Argument ${t.bold.yellow(this.argument)} is required.`), e.log("");
+	}
+}, l = class extends o {
+	constructor(e) {
+		super(`Flag "${e}" is required.`), this.flag = e;
+	}
+	pretty(e) {
+		e.log(""), e.log(`  ${t.bold.white.bgRed(" ERROR ")} Flag ${t.bold.yellow(this.flag)} is required.`), e.log("");
+	}
+}, u = class extends o {
+	constructor(e, t) {
+		let n = `Argument "${e.arg}" value is invalid.`;
+		e.reason ? n += ` Reason: ${e.reason}` : n += ` Value: "${e.value}"`, super(n), this.detail = e, this.argDefinition = t;
+	}
+	pretty(e) {
+		let n = [];
+		if (this.detail.reason != null && n.push(["Reason", this.detail.reason]), this.detail.value != null && n.push(["Value", this.detail.value]), this.argDefinition?.help != null && n.push(["Help", t.green(this.argDefinition.help)]), e.log(""), e.log(`  ${t.bold.white.bgRed(" ERROR ")} Argument ${t.bold.yellow(this.detail.arg)} value is invalid.`), n.length > 0) {
+			e.log("");
+			let r = Math.max(...n.map(([e]) => e.length));
+			for (let [i, a] of n) e.log(`  ${" ".repeat(r - i.length)}${t.dim(i)}  ${a}`);
+		}
+		e.log("");
+	}
+}, d = class extends o {
+	constructor(e, t) {
+		let n = `Flag "${e.flag}" value is invalid.`;
+		e.reason ? n += ` Reason: ${e.reason}` : n += ` Value: "${e.value}"`, super(n), this.param = e, this.flagDefinition = t;
+	}
+	pretty(e) {
+		let n = [];
+		if (this.param.reason != null && n.push(["Reason", this.param.reason]), this.param.value != null && n.push(["Value", this.param.value]), this.flagDefinition?.help != null && n.push(["Help", t.green(this.flagDefinition.help)]), e.log(""), e.log(`  ${t.bold.white.bgRed(" ERROR ")} Flag ${t.bold.yellow(this.param.flag)} value is invalid.`), n.length > 0) {
+			e.log("");
+			let r = Math.max(...n.map(([e]) => e.length));
+			for (let [i, a] of n) e.log(`  ${" ".repeat(r - i.length)}${t.dim(i)}  ${a}`);
+		}
+		e.log("");
+	}
+}, f = class extends o {
+	constructor(e) {
+		super(`Command "${e}" not found.`), this.command = e;
+	}
+	pretty(e) {
+		e.log(""), e.log(`  ${t.bold.white.bgRed(" ERROR ")} Command ${t.bold.yellow(this.command)} not found.`), e.log("");
+	}
+}, p = class extends o {
+	constructor(e, t) {
+		super(`Too many arguments provided. Expected ${e}, got ${t}.`), this.expected = e, this.received = t;
+	}
+	pretty(e) {
+		e.log(""), e.log(`  ${t.bold.white.bgRed(" ERROR ")} Too many arguments. Expected ${t.bold.yellow(String(this.expected))}, got ${t.bold.yellow(String(this.received))}.`), e.log("");
+	}
+}, m = class {
+	flags;
+	parsedFlags = null;
+	args;
+	parsedArguments = null;
+	io;
+	shouldPromptForMissingFlags = !0;
+	shouldValidateUnknownFlags = !0;
+	shouldRejectExtraArguments = !1;
+	constructor(e) {
+		this.opts = e, this.io = e.io, this.flags = e.flags, this.args = e.args;
+	}
+	async init(e) {
+		let { _: t, ...r } = n(e);
+		return this.shouldValidateUnknownFlags && this.validateUnknownFlags(r), this.parsedFlags = await this.handleOptions(r), this.parsedArguments = await this.handleArguments(t), {
+			flags: this.parsedFlags,
+			args: this.parsedArguments
+		};
+	}
+	async validate() {
+		for (let e in this.flags) {
+			let t = this.flags[e], n = this.parsedFlags?.[e], r = this.isEmptyValue(n), i = "multiple" in t && t.multiple;
+			if (t.required && r) throw new l(e);
+			if (!r && t.validate) {
+				let r = i && Array.isArray(n) ? n : [n];
+				for (let n of r) {
+					let r = await t.validate(n);
+					if (r !== !0) throw new d({
+						flag: e,
+						reason: r,
+						value: n
+					});
+				}
+			}
+		}
+		for (let e in this.args) {
+			let t = this.args[e], n = this.parsedArguments?.[e], r = this.isEmptyValue(n), i = "multiple" in t && t.multiple;
+			if (t.required && r) {
+				if (!this.shouldPromptForMissingFlags) throw new c(e);
+				let n = await this.promptForArgument(e, t);
+				if (n && this.parsedArguments) {
+					this.parsedArguments[e] = await this.parseValue(n, t, {
+						name: e,
+						isArg: !0
+					});
+					continue;
+				}
+				throw new c(e);
+			}
+			if (!r && t.validate) {
+				let r = i && Array.isArray(n) ? n : [n];
+				for (let n of r) {
+					let r = await t.validate(n);
+					if (r !== !0) throw new u({
+						arg: e,
+						reason: r,
+						value: n
+					});
+				}
+			}
+		}
+	}
+	flag(e, t) {
+		if (!this.parsedFlags) throw Error("Flags have not been parsed yet. Call init() first.");
+		return this.isEmptyValue(this.parsedFlags[e]) && t !== void 0 ? t : this.parsedFlags[e];
+	}
+	async setFlag(e, t) {
+		if (!this.parsedFlags) throw Error("Flags have not been parsed yet. Call init() first.");
+		if (!(e in this.flags)) throw new s(e, this.flags);
+		if (this.flags[e].validate) {
+			let n = await this.flags[e].validate(t);
+			if (n !== !0) throw new d({
+				flag: e,
+				reason: n,
+				value: t
+			});
+		}
+		this.parsedFlags[e] = t;
+	}
+	argument(e, t) {
+		if (!this.parsedArguments) throw Error("Arguments have not been parsed yet. Call init() first.");
+		return this.isEmptyValue(this.parsedArguments[e]) && t !== void 0 ? t : this.parsedArguments[e];
+	}
+	async setArgument(e, t) {
+		if (!this.parsedArguments) throw Error("Arguments have not been parsed yet. Call init() first.");
+		if (!(e in this.args)) throw new u({
+			arg: e,
+			reason: `Argument "${e}" is not recognized`
+		});
+		if (this.args[e].validate) {
+			let n = await this.args[e].validate(t);
+			if (n !== !0) throw new u({
+				arg: e,
+				reason: n,
+				value: t
+			});
+		}
+		this.parsedArguments[e] = t;
+	}
+	isEmptyValue(e) {
+		return e == null || typeof e == "string" && e.trim() === "" || Array.isArray(e) && e.length === 0;
+	}
+	validateUnknownFlags(e) {
+		let t = /* @__PURE__ */ new Set();
+		for (let e in this.flags) {
+			t.add(e);
+			let n = this.flags[e];
+			for (let e of n.alias ?? []) t.add(e);
+		}
+		for (let n in e) if (!t.has(n)) throw new s(n, this.flags);
+	}
+	async handleOptions(e) {
+		let t = {};
+		for (let n in this.flags) t[n] = await this.resolveFlagValue(n, this.flags[n], e);
+		return t;
+	}
+	async handleArguments(e) {
+		let t = {}, n = [...e], r = Object.keys(this.args).length;
+		for (let e in this.args) {
+			let r = this.args[e];
+			if ("multiple" in r && r.multiple) {
+				t[e] = await this.parseValue(n, r, {
+					name: e,
+					isArg: !0
+				}), n.length = 0;
+				continue;
+			}
+			t[e] = await this.parseValue(n.shift(), r, {
+				name: e,
+				isArg: !0
+			});
+		}
+		if (this.shouldRejectExtraArguments && n.length > 0) throw new p(r, r + n.length);
+		return t;
+	}
+	async resolveFlagValue(e, t, n) {
+		let r, i = [e];
+		t.alias && i.push(...Array.isArray(t.alias) ? t.alias : [t.alias]);
+		for (let e of i) if (e in n) {
+			r = n[e];
+			break;
+		}
+		return this.parseValue(r, t, { name: e });
+	}
+	async parseValue(e, t, n) {
+		if (this.isEmptyValue(e)) return typeof t.default == "function" ? await t.default() : t.default;
+		if ("multiple" in t && t.multiple) {
+			Array.isArray(e) || (e = [e]);
+			let r = [];
+			for (let i of e) r.push(await this.safeParse(i, t, n));
+			return r;
+		}
+		return this.safeParse(e, t, n);
+	}
+	async safeParse(e, t, n) {
+		try {
+			return t.parse(e, this.opts.ctx);
+		} catch (t) {
+			if (!n) throw t;
+			let r = t instanceof Error ? t.message : String(t);
+			throw n.isArg ? new u({
+				arg: n.name,
+				value: e,
+				reason: r
+			}) : new d({
+				flag: n.name,
+				value: e,
+				reason: r
+			});
+		}
+	}
+	disablePrompting() {
+		return this.shouldPromptForMissingFlags = !1, this;
+	}
+	allowUnknownFlags() {
+		return this.shouldValidateUnknownFlags = !1, this;
+	}
+	strictMode() {
+		return this.shouldRejectExtraArguments = !0, this;
+	}
+	async promptForArgument(e, n) {
+		let r = n.type;
+		if (r === "enum" && n.options) {
+			let r = `${t.yellow.bold(e)} is required`;
+			n.description && (r += `: ${t.gray(`(${n.description})`)}`), r += ` ${t.green("(enum)")}\n`;
+			let i = n.options.map((e) => ({
+				title: e,
+				value: e
+			}));
+			return await this.io.askForSelect(r, i);
+		}
+		let i = "multiple" in n && n.multiple;
+		if (!i && !["string", "number"].includes(r)) return null;
+		let a = `${t.yellow.bold(e)} is required`;
+		return n.description && (a += `: ${t.gray(`(${n.description})`)}`), a += ` ${t.green(`(${r}${i ? "[]" : ""})`)}\n`, i ? (a += "Please provide one or more values, separated by commas:\n", await this.io.askForList(a, void 0, {
+			separator: ",",
+			validate: (e) => {
+				if (this.isEmptyValue(e) && n.required) return "Please enter at least one value";
+				for (let t of e.split(",")) {
+					let e = n.validate ? n.validate(t) : !0;
+					if (e !== !0) return typeof e == "string" ? `${t} ${e}` : `Invalid value: "${t.trim()}"`;
+				}
+				return !0;
+			}
+		})) : await this.io.askForInput(a, void 0, {
+			type: r === "number" ? "number" : "secret" in n && n.secret ? "password" : "text",
+			validate: (e) => {
+				if (this.isEmptyValue(e) && n.required) return "This value is required";
+				let t = n.validate ? n.validate(e) : !0;
+				return t === !0 ? !0 : typeof t == "string" ? t : "Invalid value";
+			}
+		});
+	}
+}, h = {
+	string(e) {
+		return {
+			default: e?.multiple ? [] : null,
+			parse: (e) => {
+				if (typeof e == "boolean") throw Error(`Expected a string, got boolean "${e}"`);
+				return String(e);
+			},
+			...e,
+			type: "string"
+		};
+	},
+	number(e) {
+		return {
+			default: e?.multiple ? [] : null,
+			validate(t) {
+				return e?.min !== void 0 && t < e.min ? `is below minimum ${e.min}` : e?.max !== void 0 && t > e.max ? `exceeds maximum ${e.max}` : !0;
+			},
+			parse: (e) => {
+				let t = typeof e == "number" ? e : Number(e);
+				if (isNaN(t)) throw Error("must be a valid number");
+				return t;
+			},
+			...e,
+			type: "number"
+		};
+	},
+	boolean(e) {
+		return {
+			default: !1,
+			parse: (e) => {
+				if (typeof e == "boolean") return e;
+				let t = String(e).toLowerCase();
+				return t === "true" || t === "1" ? !0 : t === "false" || t === "0" ? !1 : !!e;
+			},
+			...e,
+			type: "boolean"
+		};
+	},
+	enum(e) {
+		return {
+			default: e.multiple ? [] : null,
+			validate(t) {
+				return e.options.includes(t) ? !0 : `must be one of: ${e.options.map((e) => `"${e}"`).join(", ")}`;
+			},
+			parse: (e) => String(e),
+			...e,
+			type: "enum"
+		};
+	},
+	file(e) {
+		return {
+			default: null,
+			parse: (e) => String(e),
+			validate(t) {
+				return e?.exists && !r.existsSync(t) ? "file does not exist" : !0;
+			},
+			...e,
+			type: "file"
+		};
+	},
+	directory(e) {
+		return {
+			default: null,
+			parse: (e) => String(e),
+			validate(t) {
+				return e?.exists && !(r.existsSync(t) && r.lstatSync(t).isDirectory()) ? "directory does not exist" : !0;
+			},
+			...e,
+			type: "directory"
+		};
+	},
+	url(e) {
+		return {
+			default: null,
+			parse: (e) => new URL(String(e)),
+			...e,
+			type: "url"
+		};
+	},
+	custom(e) {
+		return (t) => ({
+			default: e?.multiple || t?.multiple ? [] : null,
+			parse: (e) => e,
+			...e,
+			...t,
+			type: "custom"
+		});
+	}
+}, g = h;
+//#endregion
+//#region src/lib/string.ts
+function _(e) {
+	return Array(e + 5).join(" ");
 }
-class f extends Error {
-  $type = "BobError";
+//#endregion
+//#region src/options/HelpOption.ts
+function v(e) {
+	let t = e.type;
+	return Array.isArray(t) ? `[${t[0]}]` : t === "enum" && e.options ? `enum: ${e.options.join("|")}` : t;
 }
-function F(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) ? F(r) : r.default !== void 0 ? r.default : F(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 k 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 D 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 Q 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 H 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.`);
-  }
-}
-class P extends f {
-  constructor(t, e) {
-    super(`Too many arguments provided. Expected ${t}, got ${e}.`), this.expected = t, this.received = e;
-  }
-  pretty(t) {
-    t.log(
-      `${a.white.bgRed(" ERROR ")} Too many arguments provided. Expected ${a.bold.yellow(String(this.expected))}, got ${a.bold.yellow(String(this.received))}.`
-    );
-  }
-}
-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 N {
-  options;
-  parsedOptions = null;
-  arguments;
-  parsedArguments = null;
-  io;
-  shouldPromptForMissingOptions = !0;
-  shouldValidateUnknownOptions = !0;
-  shouldRejectExtraArguments = !1;
-  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.shouldValidateUnknownOptions && 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 D(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 k(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 k(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], n = Object.keys(this.arguments).length;
-    for (const s in this.arguments) {
-      const o = g(this.arguments[s]);
-      if (o.variadic) {
-        e[s] = this.handleVariadicArgument(s, o, i), i.length = 0;
-        continue;
-      }
-      e[s] = this.resolveArgumentValue(s, o, i.shift());
-    }
-    if (this.shouldRejectExtraArguments && i.length > 0)
-      throw new P(n, n + i.length);
-    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;
-  }
-  allowUnknownOptions() {
-    return this.shouldValidateUnknownOptions = !1, this;
-  }
-  strictMode() {
-    return this.shouldRejectExtraArguments = !0, 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 O(r) {
-  return new Array(r + 5).join(" ");
-}
-class M {
-  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 = O(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 = O(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 R = (Array.isArray(l.type) ? `[${l.type[0]}]` : l.type) === "array" || Array.isArray(l.type) ? JSON.stringify(l.default) : l.default;
-          p += ` ${a.yellow(`[default: ${R}]`)}`;
-        }
-        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 A {
-  $type = "BobCommand";
-  _command;
-  description;
-  group;
-  commandsExamples = [];
-  get command() {
-    return this._command;
-  }
-  ctx;
-  io;
-  parser;
-  disablePromptingFlag = !1;
-  allowUnknownOptionsFlag = !1;
-  hiddenFlag = !1;
-  disableDefaultOptionsFlag = !1;
-  strictModeFlag = !1;
-  _preHandler;
-  _handler;
-  tmp;
-  defaultOptions() {
-    return this.disableDefaultOptionsFlag ? [] : [new M()];
-  }
-  newCommandParser(t) {
-    return new N({
-      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;
-  }
-  allowUnknownOptions() {
-    return this.allowUnknownOptionsFlag = !0, this;
-  }
-  hidden() {
-    return this.hiddenFlag = !0, this;
-  }
-  get isHidden() {
-    return this.hiddenFlag;
-  }
-  disableDefaultOptions() {
-    return this.disableDefaultOptionsFlag = !0, this;
-  }
-  strictMode() {
-    return this.strictModeFlag = !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 ?? {}
-      }), this.allowUnknownOptionsFlag && this.parser.allowUnknownOptions(), this.strictModeFlag && this.parser.strictMode(), 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 N {
-  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 X extends A {
-  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 V {
-  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 B {
-  /**
-   * 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
-    };
-  }
-}
-function j(r) {
-  return typeof r == "object" && r !== null && "$type" in r && r.$type === "BobError";
-}
-function v(r) {
-  return typeof r == "object" && r !== null && (r instanceof A || "$type" in r && r.$type === "BobCommand");
-}
-class T {
-  commands = {};
-  io;
-  logger;
-  stringSimilarity;
-  newCommandIO(t) {
-    return new S(t);
-  }
-  constructor(t) {
-    this.logger = t?.logger ?? new V(), this.io = this.newCommandIO({
-      logger: this.logger
-    }), this.stringSimilarity = t?.stringSimilarity ?? new B();
-  }
-  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() : v(e) ? e : null) : null;
-  };
-  withCommandResolver(t) {
-    return this.commandResolver = t, this;
-  }
-  withFileImporter(t) {
-    return this.importFile = t, this;
-  }
-  registerCommand(t, e = !1) {
-    if (!v(t))
-      throw new Error("Invalid command, it must extend the Command class.");
-    const i = t.command;
-    if (!i)
-      throw new Error("Cannot register a command with no 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);
-        v(i) && 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 && (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 H(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 = x.resolve(t, i.name);
-      if (i.isDirectory())
-        yield* this.listCommandsFiles(x.resolve(t, i.name));
-      else {
-        if (!n.endsWith(".ts") && !n.endsWith(".js") && !n.endsWith(".mjs") && !n.endsWith(".cjs"))
-          continue;
-        yield n;
-      }
-    }
-  }
+var y = h.boolean({
+	alias: ["h"],
+	handler: (e, n, r) => {
+		if (!e) return { shouldStop: !1 };
+		let i = r.args, a = r.flags, o = Object.entries(i), s = Object.entries(a), c = s.map(([e, t]) => {
+			let n = Array.isArray(t.alias) ? t.alias : t.alias ? [t.alias] : [];
+			return {
+				name: e,
+				...t,
+				flagWithAlias: `--${e}${n.map((e) => `, -${e}`).join("")}`
+			};
+		}), l = o.filter(([, e]) => e.required);
+		console.log(t.yellow("Description:")), console.log(`  ${r.description}\n`), console.log(t.yellow("Usage:")), console.log(`  ${r.command} ${l.length > 0 ? l.map(([e]) => `<${e}>`).join(" ") : "\b"} [options]`);
+		let u = Math.max(...c.map((e) => e.flagWithAlias.length), 0), d = Math.max(...o.map(([e]) => e.length), 0), f = d > u ? d : u;
+		if (o.length > 0) {
+			console.log(`\n${t.yellow("Arguments")}:`);
+			for (let [e, n] of o) {
+				let r = _(f - e.length), i = `  ${t.green(e)} ${r} ${n.description ?? "\b"}`;
+				if (n.default !== void 0 && !n.required) {
+					let e = typeof n.default == "function" ? "[function]" : n.multiple ? JSON.stringify(n.default) : n.default;
+					i += ` ${t.yellow(`[default: ${e}]`)}`;
+				}
+				"multiple" in n && n.multiple && (i += ` ${t.white("(variadic)")}`), console.log(i);
+			}
+		}
+		if (s.length > 0) {
+			console.log(`\n${t.yellow("Options")}:`);
+			for (let e of c) {
+				let n = _(f - e.flagWithAlias.length), r = `  ${t.green(e.flagWithAlias)} ${n} ${e.description ?? "\b"}`;
+				if (e.type && (r += ` ${t.white(`(${v(e)})`)}`), e.default !== void 0 && !e.required) {
+					let n = typeof e.default == "function" ? "(function)" : e.default;
+					r += ` ${t.yellow(`[default: ${n}]`)}`;
+				}
+				console.log(r);
+			}
+		}
+		let p = r.examples ?? [];
+		if (p.length > 0) {
+			console.log(`\n${t.yellow("Examples")}:`);
+			let e = process.argv[0].split("/").pop();
+			e === "node" && (e += " " + process.argv[1].split("/").pop());
+			for (let [n, r] of p.entries()) n > 0 && console.log(""), console.log(`  ${r.description}\n`), console.log(`    ${t.green(`${e} ${r.command}`)}`);
+		}
+		return { shouldStop: !0 };
+	}
+}), b = class {
+	$type = "BobCommand";
+	static command = "";
+	static description = "";
+	static group;
+	static args = {};
+	static flags = {};
+	static examples = [];
+	static hidden = !1;
+	static disableDefaultOptions = !1;
+	static disablePrompting = !1;
+	static allowUnknownFlags = !1;
+	static strictMode = !1;
+	ctx;
+	io;
+	parser;
+	static baseFlags = { help: y };
+	newCommandParser(e) {
+		return new m({
+			io: e.io,
+			ctx: e.ctx,
+			flags: e.flags,
+			args: e.args
+		});
+	}
+	newCommandIO(e) {
+		return new a(e);
+	}
+	async run(e) {
+		let t = this.constructor;
+		this.ctx = e.ctx, this.io = this.newCommandIO({ logger: e.logger });
+		let n;
+		if ("flags" in e) n = {
+			flags: e.flags,
+			args: e.args
+		};
+		else {
+			this.parser = this.newCommandParser({
+				ctx: this.ctx,
+				io: this.io,
+				flags: t.disableDefaultOptions ? t.flags : {
+					...t.baseFlags,
+					...t.flags
+				},
+				args: t.args
+			}), t.allowUnknownFlags && this.parser.allowUnknownFlags(), t.strictMode && this.parser.strictMode(), t.disablePrompting && this.parser.disablePrompting();
+			let r = await this.parser.init(e.args);
+			for (let n in r.flags) {
+				let i = r.flags[n], a = t.flags[n] || t.baseFlags[n];
+				if (a && a.handler) {
+					let n = a.handler(i, e.ctx, t);
+					if (n && n.shouldStop) return -1;
+				}
+			}
+			await this.parser.validate(), n = {
+				flags: r.flags,
+				args: r.args
+			};
+		}
+		if (this.preHandle) {
+			let e = await this.preHandle();
+			if (e && e !== 0) return e;
+		}
+		return await this.handle(this.ctx, n) ?? 0;
+	}
+}, x = class {
+	level;
+	constructor(e = {}) {
+		this.level = e.level ?? "info";
+	}
+	shouldLog(e) {
+		let t = [
+			"debug",
+			"info",
+			"warn",
+			"error"
+		], n = t.indexOf(this.level);
+		return t.indexOf(e) >= n;
+	}
+	setLevel(e) {
+		this.level = e;
+	}
+	getLevel() {
+		return this.level;
+	}
+	log(...e) {
+		console.log(...e);
+	}
+	info(...e) {
+		this.shouldLog("info") && console.log(...e);
+	}
+	warn(...e) {
+		this.shouldLog("warn") && console.warn(...e);
+	}
+	error(...e) {
+		this.shouldLog("error") && console.error(...e);
+	}
+	debug(...e) {
+		this.shouldLog("debug") && console.log(...e);
+	}
+}, S = class {
+	getBigrams(e) {
+		let t = [], n = e.toLowerCase();
+		for (let e = 0; e < n.length - 1; e++) t.push(n.slice(e, e + 2));
+		return t;
+	}
+	calculateSimilarity(e, t) {
+		if (e === t) return 1;
+		if (e.length < 2 || t.length < 2) return 0;
+		let n = this.getBigrams(e), r = this.getBigrams(t), i = new Set(r), a = 0;
+		for (let e of n) i.has(e) && (a++, i.delete(e));
+		return 2 * a / (n.length + r.length);
+	}
+	findBestMatch(e, t) {
+		let n = t.map((t) => ({
+			target: t,
+			rating: this.calculateSimilarity(e, t)
+		})), r = 0, i = n[0]?.rating ?? 0;
+		for (let e = 1; e < n.length; e++) n[e].rating > i && (i = n[e].rating, r = e);
+		return {
+			ratings: n,
+			bestMatch: n[r],
+			bestMatchIndex: r
+		};
+	}
+};
+//#endregion
+//#region src/lib/helpers.ts
+function C(e) {
+	return typeof e == "object" && !!e && "$type" in e && e.$type === "BobError";
 }
-class W {
-  logger;
-  constructor(t) {
-    this.logger = t;
-  }
-  handle(t) {
-    if (j(t))
-      return t.pretty(this.logger), -1;
-    throw t;
-  }
+function w(e) {
+	return typeof e == "function" && e.prototype instanceof b;
 }
-class _ extends A {
-  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().filter((m) => !m.isHidden), e = this.opts.cliName ?? "Bob CLI", i = this.opts.cliVersion ?? "0.0.0", n = (await import("../package-uVOgoItG.js"))?.default?.version ?? "0.0.0";
-    this.io.log(`${e} ${a.green(i)} (core: ${a.yellow(n)})
+//#endregion
+//#region src/CommandRegistry.ts
+var T = class {
+	commands = {};
+	io;
+	logger;
+	stringSimilarity;
+	newCommandIO(e) {
+		return new a(e);
+	}
+	constructor(e) {
+		this.logger = e?.logger ?? new x(), this.io = this.newCommandIO({ logger: this.logger }), this.stringSimilarity = e?.stringSimilarity ?? new S();
+	}
+	getAvailableCommands() {
+		return Object.keys(this.commands);
+	}
+	getCommands() {
+		return Object.values(this.commands);
+	}
+	importFile = async (e) => (await import(e)).default;
+	commandResolver = async (e) => {
+		let t = await this.importFile(e);
+		return t ? (t && typeof t == "object" && "default" in t && (t = t.default), typeof t == "function" && w(t) ? t : null) : null;
+	};
+	withCommandResolver(e) {
+		return this.commandResolver = e, this;
+	}
+	withFileImporter(e) {
+		return this.importFile = e, this;
+	}
+	registerCommand(e, t = !1) {
+		if (!w(e)) throw Error("Invalid command, it must extend the Command class.");
+		let n = e.command;
+		if (!n) throw Error(`Cannot register a command with no name. ${e.name} `);
+		if (!t && this.commands[n]) throw Error(`Command ${n} already registered.`);
+		this.commands[n] = e;
+	}
+	async loadCommandsPath(e) {
+		for await (let t of this.listCommandsFiles(e)) try {
+			let e = await this.commandResolver(t);
+			w(e) && this.registerCommand(e);
+		} catch (e) {
+			throw Error(`Command ${t} failed to load. ${e}`, { cause: e });
+		}
+	}
+	async runCommand(e, t, ...n) {
+		let r;
+		if (typeof t == "string") {
+			let i = this.commands[t];
+			if (!i) {
+				let r = await this.suggestCommand(t);
+				return r ? await this.runCommand(e, r, ...n) : 1;
+			}
+			r = new i();
+		} else r = w(t) ? new t() : t;
+		return await r.run({
+			ctx: e,
+			logger: this.logger,
+			args: n
+		}) ?? 0;
+	}
+	async suggestCommand(e) {
+		let n = this.getAvailableCommands(), { bestMatch: r, bestMatchIndex: i, ratings: a } = this.stringSimilarity.findBestMatch(e, n), o = a.filter((e) => e.rating > .3).map((e) => e.target);
+		if (r && (r.rating > 0 && o.length <= 1 || r.rating > .7 && o.length > 1)) {
+			let t = n[i];
+			return await this.askRunSimilarCommand(e, t) ? t : null;
+		}
+		if (o.length) {
+			this.io.error(`${t.bgRed(" ERROR ")} Command ${t.yellow(e)} not found.\n`);
+			let n = await this.io.askForSelect(t.green("Did you mean to run one of these commands instead?"), o);
+			if (n) return n;
+		}
+		throw new f(e);
+	}
+	async askRunSimilarCommand(e, n) {
+		return this.io.error(`${t.bgRed(" ERROR ")} Command ${t.yellow(e)} not found.\n`), this.io.askForConfirmation(`${t.green(`Do you want to run ${t.yellow(n)} instead?`)} `);
+	}
+	async *listCommandsFiles(e) {
+		let t = r.readdirSync(e, { withFileTypes: !0 });
+		for (let n of t) {
+			let t = i.resolve(e, n.name);
+			if (n.isDirectory()) yield* this.listCommandsFiles(i.resolve(e, n.name));
+			else {
+				if (!t.endsWith(".ts") && !t.endsWith(".js") && !t.endsWith(".mjs") && !t.endsWith(".cjs")) continue;
+				yield t;
+			}
+		}
+	}
+}, E = class e {
+	static parse(t, n = {}) {
+		let [r, ...i] = t.split(/\{(.*?)\}/g).map((e) => e.trim()).filter(Boolean), a = {}, o = {};
+		for (let t of i) {
+			let { name: r, isFlag: i, definition: s } = e.parseParamSignature(t, n);
+			i ? a[r] = s : o[r] = s;
+		}
+		return {
+			command: r,
+			flags: a,
+			args: o
+		};
+	}
+	static parseParamSignature(e, t) {
+		let n = e, r = !1, i, a, o, s = !1, c = !1, l = !0;
+		if (n.includes(":")) {
+			let [e, t] = n.split(":");
+			n = e.trim(), i = t.trim();
+		}
+		if (n.includes("=")) {
+			let [e, t] = n.split("=");
+			n = e.trim();
+			let r = t.trim();
+			l = !1, r.length ? r === "*" ? (c = !0, a = []) : r === "true" ? (s = !0, a = !0) : r === "false" ? (s = !0, a = !1) : a = r : a = null;
+		} else n.startsWith("--") && (s = !0, l = !1, a = !1);
+		if (n.includes("|")) {
+			let [e, ...t] = n.split("|");
+			n = e.trim(), o = t.map((e) => e.trim());
+		}
+		n.startsWith("--") && (r = !0, n = n.slice(2)), n.endsWith("?") && (l = !1, n = n.slice(0, -1)), n.endsWith("*") && (c = !0, l = !0, a = [], n = n.slice(0, -1)), i = i ?? t[n] ?? t[`--${n}`];
+		let u, d = r ? h : g;
+		return u = s ? h.boolean({
+			description: i,
+			alias: o,
+			...a === void 0 ? {} : { default: a }
+		}) : c ? d.string({
+			description: i,
+			alias: o,
+			multiple: !0,
+			...l ? { required: !0 } : {},
+			default: a ?? []
+		}) : d.string({
+			description: i,
+			alias: o,
+			...l ? { required: !0 } : {},
+			...a === void 0 ? {} : { default: a }
+		}), {
+			name: n,
+			isFlag: r,
+			definition: u
+		};
+	}
+}, D = class extends b {
+	static signature = "";
+	static helperDefinitions = {};
+	static get command() {
+		return this.signature.split(/\s/)[0] || "";
+	}
+	async run(e) {
+		let t = this.constructor;
+		if (t.signature && !Object.prototype.hasOwnProperty.call(t, "_signatureParsed")) {
+			let e = E.parse(t.signature, t.helperDefinitions), n = Object.prototype.hasOwnProperty.call(t, "flags") ? t.flags : {}, r = Object.prototype.hasOwnProperty.call(t, "args") ? t.args : {};
+			t.flags = {
+				...e.flags,
+				...n
+			}, t.args = {
+				...e.args,
+				...r
+			}, Object.defineProperty(t, "_signatureParsed", { value: !0 });
+		}
+		return super.run(e);
+	}
+	flag(e, t = null) {
+		return this.parser.flag(e, t);
+	}
+	argument(e, t = null) {
+		return this.parser.argument(e, t);
+	}
+}, O = class {
+	logger;
+	constructor(e) {
+		this.logger = e;
+	}
+	handle(e) {
+		if (C(e)) return e.pretty(this.logger), -1;
+		throw e;
+	}
+}, k = class extends b {
+	static command = "help";
+	static description = t.bold("Show help information about the CLI and its commands");
+	constructor(e) {
+		super(), this.opts = e;
+	}
+	async handle() {
+		let e = this.opts.commandRegistry.getCommands().filter((e) => !e.hidden), n = this.opts.cliName ?? "Bob CLI", r = this.opts.cliVersion ?? "0.0.0", i = (await import("../package-DXx2gXIL.js"))?.default?.version ?? "0.0.0";
+		this.io.log(`${n} ${t.green(r)} (core: ${t.yellow(i)})
 
-${a.yellow("Usage")}:
+${t.yellow("Usage")}:
   command [options] [arguments]
 
-${a.yellow("Available commands")}:
+${t.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 = O(s - p.command.length);
-        l && (c = c.slice(2)), this.io.log(`${l ? "  " : ""}${a.green(p.command)} ${c} ${p.description}`);
-      }
-    }
-  }
-}
-class Y {
-  ctx;
-  logger;
-  commandRegistry;
-  exceptionHandler;
-  helpCommand;
-  newCommandRegistry(t) {
-    return new T(t);
-  }
-  newHelpCommand(t) {
-    return new _(t);
-  }
-  newExceptionHandler(t) {
-    return new W(t.logger);
-  }
-  constructor(t = {}) {
-    this.ctx = t.ctx, this.logger = t.logger ?? new V(), 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,
-  Q as BadCommandParameter,
-  f as BobError,
-  Y as Cli,
-  A as Command,
-  S as CommandIO,
-  H as CommandNotFoundError,
-  N as CommandParser,
-  T as CommandRegistry,
-  $ as CommandSignatureParser,
-  X as CommandWithSignature,
-  W as ExceptionHandler,
-  M as HelpOption,
-  b as InvalidOption,
-  V as Logger,
-  k as MissingRequiredArgumentValue,
-  D as MissingRequiredOptionValue,
-  B as StringSimilarity,
-  P as TooManyArguments
+		let a = Math.max(...e.map((e) => e.command.length)) ?? 0, o = {};
+		for (let t of e) {
+			let e = t.group ?? t.command.split(":")[0];
+			o[e] || (o[e] = []), o[e].push(t);
+		}
+		let s = Object.entries(o).sort(([e], [t]) => e.toLowerCase().localeCompare(t.toLowerCase())).sort(([, e], [, t]) => e.length - t.length);
+		for (let [e, n] of s) {
+			let r = n.length > 1;
+			r && this.io.log(t.yellow(`${e}:`));
+			let i = n.sort((e, t) => e.command.toLowerCase().localeCompare(t.command.toLowerCase()));
+			for (let e of i) {
+				let n = _(a - e.command.length);
+				r && (n = n.slice(2)), this.io.log(`${r ? "  " : ""}${t.green(e.command)} ${n} ${e.description}`);
+			}
+		}
+	}
+}, A = class {
+	ctx;
+	logger;
+	commandRegistry;
+	exceptionHandler;
+	helpCommand;
+	newCommandRegistry(e) {
+		return new T(e);
+	}
+	newHelpCommand(e) {
+		return new k(e);
+	}
+	newExceptionHandler(e) {
+		return new O(e.logger);
+	}
+	constructor(e = {}) {
+		this.ctx = e.ctx, this.logger = e.logger ?? new x(), this.commandRegistry = this.newCommandRegistry({ logger: this.logger }), this.exceptionHandler = this.newExceptionHandler({ logger: this.logger }), this.helpCommand = this.newHelpCommand({
+			cliName: e.name,
+			cliVersion: e.version,
+			commandRegistry: this.commandRegistry
+		});
+	}
+	withCommandResolver(e) {
+		return this.commandRegistry.withCommandResolver(e), this;
+	}
+	withFileImporter(e) {
+		return this.commandRegistry.withFileImporter(e), this;
+	}
+	async withCommands(...e) {
+		for (let t of e) typeof t == "string" ? await this.commandRegistry.loadCommandsPath(t) : typeof t == "function" ? this.registerCommand(t) : this.registerCommand(t.constructor);
+	}
+	async runCommand(e, ...t) {
+		return e ? await this.commandRegistry.runCommand(this.ctx ?? {}, e, ...t).catch(this.exceptionHandler.handle.bind(this.exceptionHandler)) : await this.runHelpCommand();
+	}
+	async runHelpCommand() {
+		return await this.runCommand(this.helpCommand);
+	}
+	registerCommand(e) {
+		this.commandRegistry.registerCommand(e);
+	}
 };
+//#endregion
+export { g as Args, u as BadCommandArgument, d as BadCommandFlag, o as BobError, A as Cli, b as Command, a as CommandIO, f as CommandNotFoundError, m as CommandParser, T as CommandRegistry, E as CommandSignatureParser, D as CommandWithSignature, O as ExceptionHandler, h as Flags, y as HelpCommandFlag, s as InvalidFlag, x as Logger, c as MissingRequiredArgumentValue, l as MissingRequiredFlagValue, S as StringSimilarity, p as TooManyArguments };