brady-cli 1.1.0 → 1.2.5

package/dist/index.js

@@ -26,16 +26,71 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
-// node_modules/commander/lib/error.js
+// node_modules/.pnpm/sisteransi@1.0.5/node_modules/sisteransi/src/index.js
+var require_src = __commonJS({
+  "node_modules/.pnpm/sisteransi@1.0.5/node_modules/sisteransi/src/index.js"(exports2, module2) {
+    "use strict";
+    var ESC2 = "\x1B";
+    var CSI2 = `${ESC2}[`;
+    var beep = "\x07";
+    var cursor = {
+      to(x, y) {
+        if (!y) return `${CSI2}${x + 1}G`;
+        return `${CSI2}${y + 1};${x + 1}H`;
+      },
+      move(x, y) {
+        let ret = "";
+        if (x < 0) ret += `${CSI2}${-x}D`;
+        else if (x > 0) ret += `${CSI2}${x}C`;
+        if (y < 0) ret += `${CSI2}${-y}A`;
+        else if (y > 0) ret += `${CSI2}${y}B`;
+        return ret;
+      },
+      up: (count = 1) => `${CSI2}${count}A`,
+      down: (count = 1) => `${CSI2}${count}B`,
+      forward: (count = 1) => `${CSI2}${count}C`,
+      backward: (count = 1) => `${CSI2}${count}D`,
+      nextLine: (count = 1) => `${CSI2}E`.repeat(count),
+      prevLine: (count = 1) => `${CSI2}F`.repeat(count),
+      left: `${CSI2}G`,
+      hide: `${CSI2}?25l`,
+      show: `${CSI2}?25h`,
+      save: `${ESC2}7`,
+      restore: `${ESC2}8`
+    };
+    var scroll = {
+      up: (count = 1) => `${CSI2}S`.repeat(count),
+      down: (count = 1) => `${CSI2}T`.repeat(count)
+    };
+    var erase = {
+      screen: `${CSI2}2J`,
+      up: (count = 1) => `${CSI2}1J`.repeat(count),
+      down: (count = 1) => `${CSI2}J`.repeat(count),
+      line: `${CSI2}2K`,
+      lineEnd: `${CSI2}K`,
+      lineStart: `${CSI2}1K`,
+      lines(count) {
+        let clear = "";
+        for (let i = 0; i < count; i++)
+          clear += this.line + (i < count - 1 ? cursor.up() : "");
+        if (count)
+          clear += cursor.left;
+        return clear;
+      }
+    };
+    module2.exports = { cursor, scroll, erase, beep };
+  }
+});
+
+// node_modules/.pnpm/commander@14.0.3/node_modules/commander/lib/error.js
 var require_error = __commonJS({
-  "node_modules/commander/lib/error.js"(exports) {
+  "node_modules/.pnpm/commander@14.0.3/node_modules/commander/lib/error.js"(exports2) {
     var CommanderError2 = class extends Error {
       /**
        * Constructs the CommanderError class
        * @param {number} exitCode suggested exit code which could be used with process.exit
        * @param {string} code an id string representing the error
        * @param {string} message human-readable description of the error
-       * @constructor
        */
       constructor(exitCode, code, message) {
         super(message);
@@ -50,7 +105,6 @@ var require_error = __commonJS({
       /**
        * Constructs the InvalidArgumentError class
        * @param {string} [message] explanation of why argument is invalid
-       * @constructor
        */
       constructor(message) {
         super(1, "commander.invalidArgument", message);
@@ -58,14 +112,14 @@ var require_error = __commonJS({
         this.name = this.constructor.name;
       }
     };
-    exports.CommanderError = CommanderError2;
-    exports.InvalidArgumentError = InvalidArgumentError2;
+    exports2.CommanderError = CommanderError2;
+    exports2.InvalidArgumentError = InvalidArgumentError2;
   }
 });
 
-// node_modules/commander/lib/argument.js
+// node_modules/.pnpm/commander@14.0.3/node_modules/commander/lib/argument.js
 var require_argument = __commonJS({
-  "node_modules/commander/lib/argument.js"(exports) {
+  "node_modules/.pnpm/commander@14.0.3/node_modules/commander/lib/argument.js"(exports2) {
     var { InvalidArgumentError: InvalidArgumentError2 } = require_error();
     var Argument2 = class {
       /**
@@ -97,7 +151,7 @@ var require_argument = __commonJS({
             this._name = name;
             break;
         }
-        if (this._name.length > 3 && this._name.slice(-3) === "...") {
+        if (this._name.endsWith("...")) {
           this.variadic = true;
           this._name = this._name.slice(0, -3);
         }
@@ -111,18 +165,19 @@ var require_argument = __commonJS({
         return this._name;
       }
       /**
-       * @api private
+       * @package
        */
-      _concatValue(value, previous) {
+      _collectValue(value, previous) {
         if (previous === this.defaultValue || !Array.isArray(previous)) {
           return [value];
         }
-        return previous.concat(value);
+        previous.push(value);
+        return previous;
       }
       /**
        * Set the default value, and optionally supply the description to be displayed in the help.
        *
-       * @param {any} value
+       * @param {*} value
        * @param {string} [description]
        * @return {Argument}
        */
@@ -151,10 +206,12 @@ var require_argument = __commonJS({
         this.argChoices = values.slice();
         this.parseArg = (arg, previous) => {
           if (!this.argChoices.includes(arg)) {
-            throw new InvalidArgumentError2(`Allowed choices are ${this.argChoices.join(", ")}.`);
+            throw new InvalidArgumentError2(
+              `Allowed choices are ${this.argChoices.join(", ")}.`
+            );
           }
           if (this.variadic) {
-            return this._concatValue(arg, previous);
+            return this._collectValue(arg, previous);
           }
           return arg;
         };
@@ -162,6 +219,8 @@ var require_argument = __commonJS({
       }
       /**
        * Make argument required.
+       *
+       * @returns {Argument}
        */
       argRequired() {
         this.required = true;
@@ -169,6 +228,8 @@ var require_argument = __commonJS({
       }
       /**
        * Make argument optional.
+       *
+       * @returns {Argument}
        */
       argOptional() {
         this.required = false;
@@ -179,22 +240,34 @@ var require_argument = __commonJS({
       const nameOutput = arg.name() + (arg.variadic === true ? "..." : "");
       return arg.required ? "<" + nameOutput + ">" : "[" + nameOutput + "]";
     }
-    exports.Argument = Argument2;
-    exports.humanReadableArgName = humanReadableArgName;
+    exports2.Argument = Argument2;
+    exports2.humanReadableArgName = humanReadableArgName;
   }
 });
 
-// node_modules/commander/lib/help.js
+// node_modules/.pnpm/commander@14.0.3/node_modules/commander/lib/help.js
 var require_help = __commonJS({
-  "node_modules/commander/lib/help.js"(exports) {
+  "node_modules/.pnpm/commander@14.0.3/node_modules/commander/lib/help.js"(exports2) {
     var { humanReadableArgName } = require_argument();
     var Help2 = class {
       constructor() {
         this.helpWidth = void 0;
+        this.minWidthToWrap = 40;
         this.sortSubcommands = false;
         this.sortOptions = false;
         this.showGlobalOptions = false;
       }
+      /**
+       * prepareContext is called by Commander after applying overrides from `Command.configureHelp()`
+       * and just before calling `formatHelp()`.
+       *
+       * Commander just uses the helpWidth and the rest is provided for optional use by more complex subclasses.
+       *
+       * @param {{ error?: boolean, helpWidth?: number, outputHasColors?: boolean }} contextOptions
+       */
+      prepareContext(contextOptions) {
+        this.helpWidth = this.helpWidth ?? contextOptions.helpWidth ?? 80;
+      }
       /**
        * Get an array of the visible subcommands. Includes a placeholder for the implicit help command, if there is one.
        *
@@ -203,12 +276,8 @@ var require_help = __commonJS({
        */
       visibleCommands(cmd) {
         const visibleCommands = cmd.commands.filter((cmd2) => !cmd2._hidden);
-        if (cmd._hasImplicitHelpCommand()) {
-          const [, helpName, helpArgs] = cmd._helpCommandnameAndArgs.match(/([^ ]+) *(.*)/);
-          const helpCommand = cmd.createCommand(helpName).helpOption(false);
-          helpCommand.description(cmd._helpCommandDescription);
-          if (helpArgs)
-            helpCommand.arguments(helpArgs);
+        const helpCommand = cmd._getHelpCommand();
+        if (helpCommand && !helpCommand._hidden) {
           visibleCommands.push(helpCommand);
         }
         if (this.sortSubcommands) {
@@ -223,7 +292,7 @@ var require_help = __commonJS({
        *
        * @param {Option} a
        * @param {Option} b
-       * @returns number
+       * @returns {number}
        */
       compareOptions(a, b) {
         const getSortKey = (option) => {
@@ -239,18 +308,21 @@ var require_help = __commonJS({
        */
       visibleOptions(cmd) {
         const visibleOptions = cmd.options.filter((option) => !option.hidden);
-        const showShortHelpFlag = cmd._hasHelpOption && cmd._helpShortFlag && !cmd._findOption(cmd._helpShortFlag);
-        const showLongHelpFlag = cmd._hasHelpOption && !cmd._findOption(cmd._helpLongFlag);
-        if (showShortHelpFlag || showLongHelpFlag) {
-          let helpOption;
-          if (!showShortHelpFlag) {
-            helpOption = cmd.createOption(cmd._helpLongFlag, cmd._helpDescription);
-          } else if (!showLongHelpFlag) {
-            helpOption = cmd.createOption(cmd._helpShortFlag, cmd._helpDescription);
-          } else {
-            helpOption = cmd.createOption(cmd._helpFlags, cmd._helpDescription);
+        const helpOption = cmd._getHelpOption();
+        if (helpOption && !helpOption.hidden) {
+          const removeShort = helpOption.short && cmd._findOption(helpOption.short);
+          const removeLong = helpOption.long && cmd._findOption(helpOption.long);
+          if (!removeShort && !removeLong) {
+            visibleOptions.push(helpOption);
+          } else if (helpOption.long && !removeLong) {
+            visibleOptions.push(
+              cmd.createOption(helpOption.long, helpOption.description)
+            );
+          } else if (helpOption.short && !removeShort) {
+            visibleOptions.push(
+              cmd.createOption(helpOption.short, helpOption.description)
+            );
           }
-          visibleOptions.push(helpOption);
         }
         if (this.sortOptions) {
           visibleOptions.sort(this.compareOptions);
@@ -264,11 +336,12 @@ var require_help = __commonJS({
        * @returns {Option[]}
        */
       visibleGlobalOptions(cmd) {
-        if (!this.showGlobalOptions)
-          return [];
+        if (!this.showGlobalOptions) return [];
         const globalOptions = [];
-        for (let parentCmd = cmd.parent; parentCmd; parentCmd = parentCmd.parent) {
-          const visibleOptions = parentCmd.options.filter((option) => !option.hidden);
+        for (let ancestorCmd = cmd.parent; ancestorCmd; ancestorCmd = ancestorCmd.parent) {
+          const visibleOptions = ancestorCmd.options.filter(
+            (option) => !option.hidden
+          );
           globalOptions.push(...visibleOptions);
         }
         if (this.sortOptions) {
@@ -284,12 +357,12 @@ var require_help = __commonJS({
        */
       visibleArguments(cmd) {
         if (cmd._argsDescription) {
-          cmd._args.forEach((argument) => {
+          cmd.registeredArguments.forEach((argument) => {
             argument.description = argument.description || cmd._argsDescription[argument.name()] || "";
           });
         }
-        if (cmd._args.find((argument) => argument.description)) {
-          return cmd._args;
+        if (cmd.registeredArguments.find((argument) => argument.description)) {
+          return cmd.registeredArguments;
         }
         return [];
       }
@@ -300,7 +373,7 @@ var require_help = __commonJS({
        * @returns {string}
        */
       subcommandTerm(cmd) {
-        const args = cmd._args.map((arg) => humanReadableArgName(arg)).join(" ");
+        const args = cmd.registeredArguments.map((arg) => humanReadableArgName(arg)).join(" ");
         return cmd._name + (cmd._aliases[0] ? "|" + cmd._aliases[0] : "") + (cmd.options.length ? " [options]" : "") + // simplistic check for non-help option
         (args ? " " + args : "");
       }
@@ -331,7 +404,12 @@ var require_help = __commonJS({
        */
       longestSubcommandTermLength(cmd, helper) {
         return helper.visibleCommands(cmd).reduce((max, command) => {
-          return Math.max(max, helper.subcommandTerm(command).length);
+          return Math.max(
+            max,
+            this.displayWidth(
+              helper.styleSubcommandTerm(helper.subcommandTerm(command))
+            )
+          );
         }, 0);
       }
       /**
@@ -343,7 +421,10 @@ var require_help = __commonJS({
        */
       longestOptionTermLength(cmd, helper) {
         return helper.visibleOptions(cmd).reduce((max, option) => {
-          return Math.max(max, helper.optionTerm(option).length);
+          return Math.max(
+            max,
+            this.displayWidth(helper.styleOptionTerm(helper.optionTerm(option)))
+          );
         }, 0);
       }
       /**
@@ -355,7 +436,10 @@ var require_help = __commonJS({
        */
       longestGlobalOptionTermLength(cmd, helper) {
         return helper.visibleGlobalOptions(cmd).reduce((max, option) => {
-          return Math.max(max, helper.optionTerm(option).length);
+          return Math.max(
+            max,
+            this.displayWidth(helper.styleOptionTerm(helper.optionTerm(option)))
+          );
         }, 0);
       }
       /**
@@ -367,7 +451,12 @@ var require_help = __commonJS({
        */
       longestArgumentTermLength(cmd, helper) {
         return helper.visibleArguments(cmd).reduce((max, argument) => {
-          return Math.max(max, helper.argumentTerm(argument).length);
+          return Math.max(
+            max,
+            this.displayWidth(
+              helper.styleArgumentTerm(helper.argumentTerm(argument))
+            )
+          );
         }, 0);
       }
       /**
@@ -381,11 +470,11 @@ var require_help = __commonJS({
         if (cmd._aliases[0]) {
           cmdName = cmdName + "|" + cmd._aliases[0];
         }
-        let parentCmdNames = "";
-        for (let parentCmd = cmd.parent; parentCmd; parentCmd = parentCmd.parent) {
-          parentCmdNames = parentCmd.name() + " " + parentCmdNames;
+        let ancestorCmdNames = "";
+        for (let ancestorCmd = cmd.parent; ancestorCmd; ancestorCmd = ancestorCmd.parent) {
+          ancestorCmdNames = ancestorCmd.name() + " " + ancestorCmdNames;
         }
-        return parentCmdNames + cmdName + " " + cmd.usage();
+        return ancestorCmdNames + cmdName + " " + cmd.usage();
       }
       /**
        * Get the description for the command.
@@ -423,7 +512,9 @@ var require_help = __commonJS({
         if (option.defaultValue !== void 0) {
           const showDefault = option.required || option.optional || option.isBoolean() && typeof option.defaultValue === "boolean";
           if (showDefault) {
-            extraInfo.push(`default: ${option.defaultValueDescription || JSON.stringify(option.defaultValue)}`);
+            extraInfo.push(
+              `default: ${option.defaultValueDescription || JSON.stringify(option.defaultValue)}`
+            );
           }
         }
         if (option.presetArg !== void 0 && option.optional) {
@@ -433,7 +524,11 @@ var require_help = __commonJS({
           extraInfo.push(`env: ${option.envVar}`);
         }
         if (extraInfo.length > 0) {
-          return `${option.description} (${extraInfo.join(", ")})`;
+          const extraDescription = `(${extraInfo.join(", ")})`;
+          if (option.description) {
+            return `${option.description} ${extraDescription}`;
+          }
+          return extraDescription;
         }
         return option.description;
       }
@@ -452,17 +547,54 @@ var require_help = __commonJS({
           );
         }
         if (argument.defaultValue !== void 0) {
-          extraInfo.push(`default: ${argument.defaultValueDescription || JSON.stringify(argument.defaultValue)}`);
+          extraInfo.push(
+            `default: ${argument.defaultValueDescription || JSON.stringify(argument.defaultValue)}`
+          );
         }
         if (extraInfo.length > 0) {
-          const extraDescripton = `(${extraInfo.join(", ")})`;
+          const extraDescription = `(${extraInfo.join(", ")})`;
           if (argument.description) {
-            return `${argument.description} ${extraDescripton}`;
+            return `${argument.description} ${extraDescription}`;
           }
-          return extraDescripton;
+          return extraDescription;
         }
         return argument.description;
       }
+      /**
+       * Format a list of items, given a heading and an array of formatted items.
+       *
+       * @param {string} heading
+       * @param {string[]} items
+       * @param {Help} helper
+       * @returns string[]
+       */
+      formatItemList(heading, items, helper) {
+        if (items.length === 0) return [];
+        return [helper.styleTitle(heading), ...items, ""];
+      }
+      /**
+       * Group items by their help group heading.
+       *
+       * @param {Command[] | Option[]} unsortedItems
+       * @param {Command[] | Option[]} visibleItems
+       * @param {Function} getGroup
+       * @returns {Map<string, Command[] | Option[]>}
+       */
+      groupItems(unsortedItems, visibleItems, getGroup) {
+        const result = /* @__PURE__ */ new Map();
+        unsortedItems.forEach((item) => {
+          const group = getGroup(item);
+          if (!result.has(group)) result.set(group, []);
+        });
+        visibleItems.forEach((item) => {
+          const group = getGroup(item);
+          if (!result.has(group)) {
+            result.set(group, []);
+          }
+          result.get(group).push(item);
+        });
+        return result;
+      }
       /**
        * Generate the built-in help text.
        *
@@ -472,52 +604,142 @@ var require_help = __commonJS({
        */
       formatHelp(cmd, helper) {
         const termWidth = helper.padWidth(cmd, helper);
-        const helpWidth = helper.helpWidth || 80;
-        const itemIndentWidth = 2;
-        const itemSeparatorWidth = 2;
-        function formatItem(term, description) {
-          if (description) {
-            const fullText = `${term.padEnd(termWidth + itemSeparatorWidth)}${description}`;
-            return helper.wrap(fullText, helpWidth - itemIndentWidth, termWidth + itemSeparatorWidth);
-          }
-          return term;
+        const helpWidth = helper.helpWidth ?? 80;
+        function callFormatItem(term, description) {
+          return helper.formatItem(term, termWidth, description, helper);
         }
-        function formatList(textArray) {
-          return textArray.join("\n").replace(/^/gm, " ".repeat(itemIndentWidth));
-        }
-        let output = [`Usage: ${helper.commandUsage(cmd)}`, ""];
+        let output = [
+          `${helper.styleTitle("Usage:")} ${helper.styleUsage(helper.commandUsage(cmd))}`,
+          ""
+        ];
         const commandDescription = helper.commandDescription(cmd);
         if (commandDescription.length > 0) {
-          output = output.concat([helper.wrap(commandDescription, helpWidth, 0), ""]);
+          output = output.concat([
+            helper.boxWrap(
+              helper.styleCommandDescription(commandDescription),
+              helpWidth
+            ),
+            ""
+          ]);
         }
         const argumentList = helper.visibleArguments(cmd).map((argument) => {
-          return formatItem(helper.argumentTerm(argument), helper.argumentDescription(argument));
+          return callFormatItem(
+            helper.styleArgumentTerm(helper.argumentTerm(argument)),
+            helper.styleArgumentDescription(helper.argumentDescription(argument))
+          );
         });
-        if (argumentList.length > 0) {
-          output = output.concat(["Arguments:", formatList(argumentList), ""]);
-        }
-        const optionList = helper.visibleOptions(cmd).map((option) => {
-          return formatItem(helper.optionTerm(option), helper.optionDescription(option));
+        output = output.concat(
+          this.formatItemList("Arguments:", argumentList, helper)
+        );
+        const optionGroups = this.groupItems(
+          cmd.options,
+          helper.visibleOptions(cmd),
+          (option) => option.helpGroupHeading ?? "Options:"
+        );
+        optionGroups.forEach((options, group) => {
+          const optionList = options.map((option) => {
+            return callFormatItem(
+              helper.styleOptionTerm(helper.optionTerm(option)),
+              helper.styleOptionDescription(helper.optionDescription(option))
+            );
+          });
+          output = output.concat(this.formatItemList(group, optionList, helper));
         });
-        if (optionList.length > 0) {
-          output = output.concat(["Options:", formatList(optionList), ""]);
-        }
-        if (this.showGlobalOptions) {
+        if (helper.showGlobalOptions) {
           const globalOptionList = helper.visibleGlobalOptions(cmd).map((option) => {
-            return formatItem(helper.optionTerm(option), helper.optionDescription(option));
+            return callFormatItem(
+              helper.styleOptionTerm(helper.optionTerm(option)),
+              helper.styleOptionDescription(helper.optionDescription(option))
+            );
           });
-          if (globalOptionList.length > 0) {
-            output = output.concat(["Global Options:", formatList(globalOptionList), ""]);
-          }
+          output = output.concat(
+            this.formatItemList("Global Options:", globalOptionList, helper)
+          );
         }
-        const commandList = helper.visibleCommands(cmd).map((cmd2) => {
-          return formatItem(helper.subcommandTerm(cmd2), helper.subcommandDescription(cmd2));
+        const commandGroups = this.groupItems(
+          cmd.commands,
+          helper.visibleCommands(cmd),
+          (sub) => sub.helpGroup() || "Commands:"
+        );
+        commandGroups.forEach((commands, group) => {
+          const commandList = commands.map((sub) => {
+            return callFormatItem(
+              helper.styleSubcommandTerm(helper.subcommandTerm(sub)),
+              helper.styleSubcommandDescription(helper.subcommandDescription(sub))
+            );
+          });
+          output = output.concat(this.formatItemList(group, commandList, helper));
         });
-        if (commandList.length > 0) {
-          output = output.concat(["Commands:", formatList(commandList), ""]);
-        }
         return output.join("\n");
       }
+      /**
+       * Return display width of string, ignoring ANSI escape sequences. Used in padding and wrapping calculations.
+       *
+       * @param {string} str
+       * @returns {number}
+       */
+      displayWidth(str) {
+        return stripColor(str).length;
+      }
+      /**
+       * Style the title for displaying in the help. Called with 'Usage:', 'Options:', etc.
+       *
+       * @param {string} str
+       * @returns {string}
+       */
+      styleTitle(str) {
+        return str;
+      }
+      styleUsage(str) {
+        return str.split(" ").map((word) => {
+          if (word === "[options]") return this.styleOptionText(word);
+          if (word === "[command]") return this.styleSubcommandText(word);
+          if (word[0] === "[" || word[0] === "<")
+            return this.styleArgumentText(word);
+          return this.styleCommandText(word);
+        }).join(" ");
+      }
+      styleCommandDescription(str) {
+        return this.styleDescriptionText(str);
+      }
+      styleOptionDescription(str) {
+        return this.styleDescriptionText(str);
+      }
+      styleSubcommandDescription(str) {
+        return this.styleDescriptionText(str);
+      }
+      styleArgumentDescription(str) {
+        return this.styleDescriptionText(str);
+      }
+      styleDescriptionText(str) {
+        return str;
+      }
+      styleOptionTerm(str) {
+        return this.styleOptionText(str);
+      }
+      styleSubcommandTerm(str) {
+        return str.split(" ").map((word) => {
+          if (word === "[options]") return this.styleOptionText(word);
+          if (word[0] === "[" || word[0] === "<")
+            return this.styleArgumentText(word);
+          return this.styleSubcommandText(word);
+        }).join(" ");
+      }
+      styleArgumentTerm(str) {
+        return this.styleArgumentText(str);
+      }
+      styleOptionText(str) {
+        return str;
+      }
+      styleArgumentText(str) {
+        return str;
+      }
+      styleSubcommandText(str) {
+        return str;
+      }
+      styleCommandText(str) {
+        return str;
+      }
       /**
        * Calculate the pad width from the maximum term length.
        *
@@ -534,46 +756,100 @@ var require_help = __commonJS({
         );
       }
       /**
-       * Wrap the given string to width characters per line, with lines after the first indented.
-       * Do not wrap if insufficient room for wrapping (minColumnWidth), or string is manually formatted.
+       * Detect manually wrapped and indented strings by checking for line break followed by whitespace.
        *
        * @param {string} str
-       * @param {number} width
-       * @param {number} indent
-       * @param {number} [minColumnWidth=40]
-       * @return {string}
+       * @returns {boolean}
+       */
+      preformatted(str) {
+        return /\n[^\S\r\n]/.test(str);
+      }
+      /**
+       * Format the "item", which consists of a term and description. Pad the term and wrap the description, indenting the following lines.
+       *
+       * So "TTT", 5, "DDD DDDD DD DDD" might be formatted for this.helpWidth=17 like so:
+       *   TTT  DDD DDDD
+       *        DD DDD
+       *
+       * @param {string} term
+       * @param {number} termWidth
+       * @param {string} description
+       * @param {Help} helper
+       * @returns {string}
+       */
+      formatItem(term, termWidth, description, helper) {
+        const itemIndent = 2;
+        const itemIndentStr = " ".repeat(itemIndent);
+        if (!description) return itemIndentStr + term;
+        const paddedTerm = term.padEnd(
+          termWidth + term.length - helper.displayWidth(term)
+        );
+        const spacerWidth = 2;
+        const helpWidth = this.helpWidth ?? 80;
+        const remainingWidth = helpWidth - termWidth - spacerWidth - itemIndent;
+        let formattedDescription;
+        if (remainingWidth < this.minWidthToWrap || helper.preformatted(description)) {
+          formattedDescription = description;
+        } else {
+          const wrappedDescription = helper.boxWrap(description, remainingWidth);
+          formattedDescription = wrappedDescription.replace(
+            /\n/g,
+            "\n" + " ".repeat(termWidth + spacerWidth)
+          );
+        }
+        return itemIndentStr + paddedTerm + " ".repeat(spacerWidth) + formattedDescription.replace(/\n/g, `
+${itemIndentStr}`);
+      }
+      /**
+       * Wrap a string at whitespace, preserving existing line breaks.
+       * Wrapping is skipped if the width is less than `minWidthToWrap`.
        *
+       * @param {string} str
+       * @param {number} width
+       * @returns {string}
        */
-      wrap(str, width, indent, minColumnWidth = 40) {
-        const indents = " \\f\\t\\v\xA0\u1680\u2000-\u200A\u202F\u205F\u3000\uFEFF";
-        const manualIndent = new RegExp(`[\\n][${indents}]+`);
-        if (str.match(manualIndent))
-          return str;
-        const columnWidth = width - indent;
-        if (columnWidth < minColumnWidth)
-          return str;
-        const leadingStr = str.slice(0, indent);
-        const columnText = str.slice(indent).replace("\r\n", "\n");
-        const indentString = " ".repeat(indent);
-        const zeroWidthSpace = "\u200B";
-        const breaks = `\\s${zeroWidthSpace}`;
-        const regex = new RegExp(`
-|.{1,${columnWidth - 1}}([${breaks}]|$)|[^${breaks}]+?([${breaks}]|$)`, "g");
-        const lines = columnText.match(regex) || [];
-        return leadingStr + lines.map((line, i) => {
-          if (line === "\n")
-            return "";
-          return (i > 0 ? indentString : "") + line.trimEnd();
-        }).join("\n");
+      boxWrap(str, width) {
+        if (width < this.minWidthToWrap) return str;
+        const rawLines = str.split(/\r\n|\n/);
+        const chunkPattern = /[\s]*[^\s]+/g;
+        const wrappedLines = [];
+        rawLines.forEach((line) => {
+          const chunks = line.match(chunkPattern);
+          if (chunks === null) {
+            wrappedLines.push("");
+            return;
+          }
+          let sumChunks = [chunks.shift()];
+          let sumWidth = this.displayWidth(sumChunks[0]);
+          chunks.forEach((chunk) => {
+            const visibleWidth = this.displayWidth(chunk);
+            if (sumWidth + visibleWidth <= width) {
+              sumChunks.push(chunk);
+              sumWidth += visibleWidth;
+              return;
+            }
+            wrappedLines.push(sumChunks.join(""));
+            const nextChunk = chunk.trimStart();
+            sumChunks = [nextChunk];
+            sumWidth = this.displayWidth(nextChunk);
+          });
+          wrappedLines.push(sumChunks.join(""));
+        });
+        return wrappedLines.join("\n");
       }
     };
-    exports.Help = Help2;
+    function stripColor(str) {
+      const sgrPattern = /\x1b\[\d*(;\d*)*m/g;
+      return str.replace(sgrPattern, "");
+    }
+    exports2.Help = Help2;
+    exports2.stripColor = stripColor;
   }
 });
 
-// node_modules/commander/lib/option.js
+// node_modules/.pnpm/commander@14.0.3/node_modules/commander/lib/option.js
 var require_option = __commonJS({
-  "node_modules/commander/lib/option.js"(exports) {
+  "node_modules/.pnpm/commander@14.0.3/node_modules/commander/lib/option.js"(exports2) {
     var { InvalidArgumentError: InvalidArgumentError2 } = require_error();
     var Option2 = class {
       /**
@@ -605,11 +881,12 @@ var require_option = __commonJS({
         this.argChoices = void 0;
         this.conflictsWith = [];
         this.implied = void 0;
+        this.helpGroupHeading = void 0;
       }
       /**
        * Set the default value, and optionally supply the description to be displayed in the help.
        *
-       * @param {any} value
+       * @param {*} value
        * @param {string} [description]
        * @return {Option}
        */
@@ -626,7 +903,7 @@ var require_option = __commonJS({
        * new Option('--color').default('GREYSCALE').preset('RGB');
        * new Option('--donate [amount]').preset('20').argParser(parseFloat);
        *
-       * @param {any} arg
+       * @param {*} arg
        * @return {Option}
        */
       preset(arg) {
@@ -641,7 +918,7 @@ var require_option = __commonJS({
        * new Option('--rgb').conflicts('cmyk');
        * new Option('--js').conflicts(['ts', 'jsx']);
        *
-       * @param {string | string[]} names
+       * @param {(string | string[])} names
        * @return {Option}
        */
       conflicts(names) {
@@ -658,7 +935,7 @@ var require_option = __commonJS({
        *   .addOption(new Option('--log', 'write logging information to file'))
        *   .addOption(new Option('--trace', 'log extra details').implies({ log: 'trace.txt' }));
        *
-       * @param {Object} impliedOptionValues
+       * @param {object} impliedOptionValues
        * @return {Option}
        */
       implies(impliedOptionValues) {
@@ -713,13 +990,14 @@ var require_option = __commonJS({
         return this;
       }
       /**
-       * @api private
+       * @package
        */
-      _concatValue(value, previous) {
+      _collectValue(value, previous) {
         if (previous === this.defaultValue || !Array.isArray(previous)) {
           return [value];
         }
-        return previous.concat(value);
+        previous.push(value);
+        return previous;
       }
       /**
        * Only allow option value to be one of choices.
@@ -731,10 +1009,12 @@ var require_option = __commonJS({
         this.argChoices = values.slice();
         this.parseArg = (arg, previous) => {
           if (!this.argChoices.includes(arg)) {
-            throw new InvalidArgumentError2(`Allowed choices are ${this.argChoices.join(", ")}.`);
+            throw new InvalidArgumentError2(
+              `Allowed choices are ${this.argChoices.join(", ")}.`
+            );
           }
           if (this.variadic) {
-            return this._concatValue(arg, previous);
+            return this._collectValue(arg, previous);
           }
           return arg;
         };
@@ -753,20 +1033,32 @@ var require_option = __commonJS({
       }
       /**
        * Return option name, in a camelcase format that can be used
-       * as a object attribute key.
+       * as an object attribute key.
        *
        * @return {string}
-       * @api private
        */
       attributeName() {
-        return camelcase(this.name().replace(/^no-/, ""));
+        if (this.negate) {
+          return camelcase(this.name().replace(/^no-/, ""));
+        }
+        return camelcase(this.name());
+      }
+      /**
+       * Set the help group heading.
+       *
+       * @param {string} heading
+       * @return {Option}
+       */
+      helpGroup(heading) {
+        this.helpGroupHeading = heading;
+        return this;
       }
       /**
        * Check if `arg` matches the short or long flag.
        *
        * @param {string} arg
        * @return {boolean}
-       * @api private
+       * @package
        */
       is(arg) {
         return this.short === arg || this.long === arg;
@@ -777,7 +1069,7 @@ var require_option = __commonJS({
        * Options are one of boolean, negated, required argument, or optional argument.
        *
        * @return {boolean}
-       * @api private
+       * @package
        */
       isBoolean() {
         return !this.required && !this.optional && !this.negate;
@@ -807,14 +1099,13 @@ var require_option = __commonJS({
       /**
        * Did the value come from the option, and not from possible matching dual option?
        *
-       * @param {any} value
+       * @param {*} value
        * @param {Option} option
        * @returns {boolean}
        */
       valueFromOption(value, option) {
         const optionKey = option.attributeName();
-        if (!this.dualOptions.has(optionKey))
-          return true;
+        if (!this.dualOptions.has(optionKey)) return true;
         const preset = this.negativeOptions.get(optionKey).presetArg;
         const negativeValue = preset !== void 0 ? preset : false;
         return option.negate === (negativeValue === value);
@@ -828,62 +1119,86 @@ var require_option = __commonJS({
     function splitOptionFlags(flags) {
       let shortFlag;
       let longFlag;
-      const flagParts = flags.split(/[ |,]+/);
-      if (flagParts.length > 1 && !/^[[<]/.test(flagParts[1]))
+      const shortFlagExp = /^-[^-]$/;
+      const longFlagExp = /^--[^-]/;
+      const flagParts = flags.split(/[ |,]+/).concat("guard");
+      if (shortFlagExp.test(flagParts[0])) shortFlag = flagParts.shift();
+      if (longFlagExp.test(flagParts[0])) longFlag = flagParts.shift();
+      if (!shortFlag && shortFlagExp.test(flagParts[0]))
         shortFlag = flagParts.shift();
-      longFlag = flagParts.shift();
-      if (!shortFlag && /^-[^-]$/.test(longFlag)) {
+      if (!shortFlag && longFlagExp.test(flagParts[0])) {
         shortFlag = longFlag;
-        longFlag = void 0;
-      }
+        longFlag = flagParts.shift();
+      }
+      if (flagParts[0].startsWith("-")) {
+        const unsupportedFlag = flagParts[0];
+        const baseError = `option creation failed due to '${unsupportedFlag}' in option flags '${flags}'`;
+        if (/^-[^-][^-]/.test(unsupportedFlag))
+          throw new Error(
+            `${baseError}
+- a short flag is a single dash and a single character
+  - either use a single dash and a single character (for a short flag)
+  - or use a double dash for a long option (and can have two, like '--ws, --workspace')`
+          );
+        if (shortFlagExp.test(unsupportedFlag))
+          throw new Error(`${baseError}
+- too many short flags`);
+        if (longFlagExp.test(unsupportedFlag))
+          throw new Error(`${baseError}
+- too many long flags`);
+        throw new Error(`${baseError}
+- unrecognised flag format`);
+      }
+      if (shortFlag === void 0 && longFlag === void 0)
+        throw new Error(
+          `option creation failed due to no flags found in '${flags}'.`
+        );
       return { shortFlag, longFlag };
     }
-    exports.Option = Option2;
-    exports.splitOptionFlags = splitOptionFlags;
-    exports.DualOptions = DualOptions;
+    exports2.Option = Option2;
+    exports2.DualOptions = DualOptions;
   }
 });
 
-// node_modules/commander/lib/suggestSimilar.js
+// node_modules/.pnpm/commander@14.0.3/node_modules/commander/lib/suggestSimilar.js
 var require_suggestSimilar = __commonJS({
-  "node_modules/commander/lib/suggestSimilar.js"(exports) {
+  "node_modules/.pnpm/commander@14.0.3/node_modules/commander/lib/suggestSimilar.js"(exports2) {
     var maxDistance = 3;
     function editDistance(a, b) {
       if (Math.abs(a.length - b.length) > maxDistance)
         return Math.max(a.length, b.length);
-      const d = [];
+      const d2 = [];
       for (let i = 0; i <= a.length; i++) {
-        d[i] = [i];
+        d2[i] = [i];
       }
-      for (let j = 0; j <= b.length; j++) {
-        d[0][j] = j;
+      for (let j3 = 0; j3 <= b.length; j3++) {
+        d2[0][j3] = j3;
       }
-      for (let j = 1; j <= b.length; j++) {
+      for (let j3 = 1; j3 <= b.length; j3++) {
         for (let i = 1; i <= a.length; i++) {
           let cost = 1;
-          if (a[i - 1] === b[j - 1]) {
+          if (a[i - 1] === b[j3 - 1]) {
             cost = 0;
           } else {
             cost = 1;
           }
-          d[i][j] = Math.min(
-            d[i - 1][j] + 1,
+          d2[i][j3] = Math.min(
+            d2[i - 1][j3] + 1,
             // deletion
-            d[i][j - 1] + 1,
+            d2[i][j3 - 1] + 1,
             // insertion
-            d[i - 1][j - 1] + cost
+            d2[i - 1][j3 - 1] + cost
             // substitution
           );
-          if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) {
-            d[i][j] = Math.min(d[i][j], d[i - 2][j - 2] + 1);
+          if (i > 1 && j3 > 1 && a[i - 1] === b[j3 - 2] && a[i - 2] === b[j3 - 1]) {
+            d2[i][j3] = Math.min(d2[i][j3], d2[i - 2][j3 - 2] + 1);
           }
         }
       }
-      return d[a.length][b.length];
+      return d2[a.length][b.length];
     }
     function suggestSimilar(word, candidates) {
-      if (!candidates || candidates.length === 0)
-        return "";
+      if (!candidates || candidates.length === 0) return "";
       candidates = Array.from(new Set(candidates));
       const searchingOptions = word.startsWith("--");
       if (searchingOptions) {
@@ -894,8 +1209,7 @@ var require_suggestSimilar = __commonJS({
       let bestDistance = maxDistance;
       const minSimilarity = 0.4;
       candidates.forEach((candidate) => {
-        if (candidate.length <= 1)
-          return;
+        if (candidate.length <= 1) return;
         const distance = editDistance(word, candidate);
         const length = Math.max(word.length, candidate.length);
         const similarity = (length - distance) / length;
@@ -922,24 +1236,24 @@ var require_suggestSimilar = __commonJS({
       }
       return "";
     }
-    exports.suggestSimilar = suggestSimilar;
+    exports2.suggestSimilar = suggestSimilar;
   }
 });
 
-// node_modules/commander/lib/command.js
+// node_modules/.pnpm/commander@14.0.3/node_modules/commander/lib/command.js
 var require_command = __commonJS({
-  "node_modules/commander/lib/command.js"(exports) {
-    var EventEmitter = require("events").EventEmitter;
-    var childProcess = require("child_process");
-    var path = require("path");
-    var fs = require("fs");
-    var process2 = require("process");
+  "node_modules/.pnpm/commander@14.0.3/node_modules/commander/lib/command.js"(exports2) {
+    var EventEmitter = require("node:events").EventEmitter;
+    var childProcess = require("node:child_process");
+    var path2 = require("node:path");
+    var fs = require("node:fs");
+    var process2 = require("node:process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
     var { CommanderError: CommanderError2 } = require_error();
-    var { Help: Help2 } = require_help();
-    var { Option: Option2, splitOptionFlags, DualOptions } = require_option();
+    var { Help: Help2, stripColor } = require_help();
+    var { Option: Option2, DualOptions } = require_option();
     var { suggestSimilar } = require_suggestSimilar();
-    var Command2 = class extends EventEmitter {
+    var Command2 = class _Command extends EventEmitter {
       /**
        * Initialize a new `Command`.
        *
@@ -951,8 +1265,9 @@ var require_command = __commonJS({
         this.options = [];
         this.parent = null;
         this._allowUnknownOption = false;
-        this._allowExcessArguments = true;
-        this._args = [];
+        this._allowExcessArguments = false;
+        this.registeredArguments = [];
+        this._args = this.registeredArguments;
         this.args = [];
         this.rawArgs = [];
         this.processedArgs = [];
@@ -977,24 +1292,25 @@ var require_command = __commonJS({
         this._lifeCycleHooks = {};
         this._showHelpAfterError = false;
         this._showSuggestionAfterError = true;
+        this._savedState = null;
         this._outputConfiguration = {
           writeOut: (str) => process2.stdout.write(str),
           writeErr: (str) => process2.stderr.write(str),
+          outputError: (str, write) => write(str),
           getOutHelpWidth: () => process2.stdout.isTTY ? process2.stdout.columns : void 0,
           getErrHelpWidth: () => process2.stderr.isTTY ? process2.stderr.columns : void 0,
-          outputError: (str, write) => write(str)
+          getOutHasColors: () => useColor() ?? (process2.stdout.isTTY && process2.stdout.hasColors?.()),
+          getErrHasColors: () => useColor() ?? (process2.stderr.isTTY && process2.stderr.hasColors?.()),
+          stripColor: (str) => stripColor(str)
         };
         this._hidden = false;
-        this._hasHelpOption = true;
-        this._helpFlags = "-h, --help";
-        this._helpDescription = "display help for command";
-        this._helpShortFlag = "-h";
-        this._helpLongFlag = "--help";
+        this._helpOption = void 0;
         this._addImplicitHelpCommand = void 0;
-        this._helpCommandName = "help";
-        this._helpCommandnameAndArgs = "help [command]";
-        this._helpCommandDescription = "display help for command";
+        this._helpCommand = void 0;
         this._helpConfiguration = {};
+        this._helpGroupHeading = void 0;
+        this._defaultCommandGroup = void 0;
+        this._defaultOptionGroup = void 0;
       }
       /**
        * Copy settings that are useful to have in common across root command and subcommands.
@@ -1006,14 +1322,8 @@ var require_command = __commonJS({
        */
       copyInheritedSettings(sourceCommand) {
         this._outputConfiguration = sourceCommand._outputConfiguration;
-        this._hasHelpOption = sourceCommand._hasHelpOption;
-        this._helpFlags = sourceCommand._helpFlags;
-        this._helpDescription = sourceCommand._helpDescription;
-        this._helpShortFlag = sourceCommand._helpShortFlag;
-        this._helpLongFlag = sourceCommand._helpLongFlag;
-        this._helpCommandName = sourceCommand._helpCommandName;
-        this._helpCommandnameAndArgs = sourceCommand._helpCommandnameAndArgs;
-        this._helpCommandDescription = sourceCommand._helpCommandDescription;
+        this._helpOption = sourceCommand._helpOption;
+        this._helpCommand = sourceCommand._helpCommand;
         this._helpConfiguration = sourceCommand._helpConfiguration;
         this._exitCallback = sourceCommand._exitCallback;
         this._storeOptionsAsProperties = sourceCommand._storeOptionsAsProperties;
@@ -1024,6 +1334,17 @@ var require_command = __commonJS({
         this._showSuggestionAfterError = sourceCommand._showSuggestionAfterError;
         return this;
       }
+      /**
+       * @returns {Command[]}
+       * @private
+       */
+      _getCommandAndAncestors() {
+        const result = [];
+        for (let command = this; command; command = command.parent) {
+          result.push(command);
+        }
+        return result;
+      }
       /**
        * Define a command.
        *
@@ -1044,8 +1365,8 @@ var require_command = __commonJS({
        *   .command('stop [service]', 'stop named service, or all if no name supplied');
        *
        * @param {string} nameAndArgs - command name and arguments, args are `<required>` or `[optional]` and last may also be `variadic...`
-       * @param {Object|string} [actionOptsOrExecDesc] - configuration options (for action), or description (for executable)
-       * @param {Object} [execOpts] - configuration options (for executable)
+       * @param {(object | string)} [actionOptsOrExecDesc] - configuration options (for action), or description (for executable)
+       * @param {object} [execOpts] - configuration options (for executable)
        * @return {Command} returns new command for action handler, or `this` for executable command
        */
       command(nameAndArgs, actionOptsOrExecDesc, execOpts) {
@@ -1062,17 +1383,14 @@ var require_command = __commonJS({
           cmd.description(desc);
           cmd._executableHandler = true;
         }
-        if (opts.isDefault)
-          this._defaultCommandName = cmd._name;
+        if (opts.isDefault) this._defaultCommandName = cmd._name;
         cmd._hidden = !!(opts.noHelp || opts.hidden);
         cmd._executableFile = opts.executableFile || null;
-        if (args)
-          cmd.arguments(args);
-        this.commands.push(cmd);
+        if (args) cmd.arguments(args);
+        this._registerCommand(cmd);
         cmd.parent = this;
         cmd.copyInheritedSettings(this);
-        if (desc)
-          return this;
+        if (desc) return this;
         return cmd;
       }
       /**
@@ -1085,7 +1403,7 @@ var require_command = __commonJS({
        * @return {Command} new command
        */
       createCommand(name) {
-        return new Command2(name);
+        return new _Command(name);
       }
       /**
        * You can customise the help with a subclass of Help by overriding createHelp,
@@ -1100,12 +1418,11 @@ var require_command = __commonJS({
        * You can customise the help by overriding Help properties using configureHelp(),
        * or with a subclass of Help by overriding createHelp().
        *
-       * @param {Object} [configuration] - configuration options
-       * @return {Command|Object} `this` command for chaining, or stored configuration
+       * @param {object} [configuration] - configuration options
+       * @return {(Command | object)} `this` command for chaining, or stored configuration
        */
       configureHelp(configuration) {
-        if (configuration === void 0)
-          return this._helpConfiguration;
+        if (configuration === void 0) return this._helpConfiguration;
         this._helpConfiguration = configuration;
         return this;
       }
@@ -1115,33 +1432,38 @@ var require_command = __commonJS({
        *
        * The configuration properties are all functions:
        *
-       *     // functions to change where being written, stdout and stderr
+       *     // change how output being written, defaults to stdout and stderr
        *     writeOut(str)
        *     writeErr(str)
-       *     // matching functions to specify width for wrapping help
+       *     // change how output being written for errors, defaults to writeErr
+       *     outputError(str, write) // used for displaying errors and not used for displaying help
+       *     // specify width for wrapping help
        *     getOutHelpWidth()
        *     getErrHelpWidth()
-       *     // functions based on what is being written out
-       *     outputError(str, write) // used for displaying errors, and not used for displaying help
+       *     // color support, currently only used with Help
+       *     getOutHasColors()
+       *     getErrHasColors()
+       *     stripColor() // used to remove ANSI escape codes if output does not have colors
        *
-       * @param {Object} [configuration] - configuration options
-       * @return {Command|Object} `this` command for chaining, or stored configuration
+       * @param {object} [configuration] - configuration options
+       * @return {(Command | object)} `this` command for chaining, or stored configuration
        */
       configureOutput(configuration) {
-        if (configuration === void 0)
-          return this._outputConfiguration;
-        Object.assign(this._outputConfiguration, configuration);
+        if (configuration === void 0) return this._outputConfiguration;
+        this._outputConfiguration = {
+          ...this._outputConfiguration,
+          ...configuration
+        };
         return this;
       }
       /**
        * Display the help or a custom message after an error occurs.
        *
-       * @param {boolean|string} [displayHelp]
+       * @param {(boolean|string)} [displayHelp]
        * @return {Command} `this` command for chaining
        */
       showHelpAfterError(displayHelp = true) {
-        if (typeof displayHelp !== "string")
-          displayHelp = !!displayHelp;
+        if (typeof displayHelp !== "string") displayHelp = !!displayHelp;
         this._showHelpAfterError = displayHelp;
         return this;
       }
@@ -1161,7 +1483,7 @@ var require_command = __commonJS({
        * See .command() for creating an attached subcommand which inherits settings from its parent.
        *
        * @param {Command} cmd - new subcommand
-       * @param {Object} [opts] - configuration options
+       * @param {object} [opts] - configuration options
        * @return {Command} `this` command for chaining
        */
       addCommand(cmd, opts) {
@@ -1170,12 +1492,11 @@ var require_command = __commonJS({
 - specify the name in Command constructor or using .name()`);
         }
         opts = opts || {};
-        if (opts.isDefault)
-          this._defaultCommandName = cmd._name;
-        if (opts.noHelp || opts.hidden)
-          cmd._hidden = true;
-        this.commands.push(cmd);
+        if (opts.isDefault) this._defaultCommandName = cmd._name;
+        if (opts.noHelp || opts.hidden) cmd._hidden = true;
+        this._registerCommand(cmd);
         cmd.parent = this;
+        cmd._checkForBrokenPassThrough();
         return this;
       }
       /**
@@ -1203,16 +1524,16 @@ var require_command = __commonJS({
        *
        * @param {string} name
        * @param {string} [description]
-       * @param {Function|*} [fn] - custom argument processing function
+       * @param {(Function|*)} [parseArg] - custom argument processing function or default value
        * @param {*} [defaultValue]
        * @return {Command} `this` command for chaining
        */
-      argument(name, description, fn, defaultValue) {
+      argument(name, description, parseArg, defaultValue) {
         const argument = this.createArgument(name, description);
-        if (typeof fn === "function") {
-          argument.default(defaultValue).argParser(fn);
+        if (typeof parseArg === "function") {
+          argument.default(defaultValue).argParser(parseArg);
         } else {
-          argument.default(fn);
+          argument.default(parseArg);
         }
         this.addArgument(argument);
         return this;
@@ -1229,7 +1550,7 @@ var require_command = __commonJS({
        * @return {Command} `this` command for chaining
        */
       arguments(names) {
-        names.split(/ +/).forEach((detail) => {
+        names.trim().split(/ +/).forEach((detail) => {
           this.argument(detail);
         });
         return this;
@@ -1241,47 +1562,85 @@ var require_command = __commonJS({
        * @return {Command} `this` command for chaining
        */
       addArgument(argument) {
-        const previousArgument = this._args.slice(-1)[0];
-        if (previousArgument && previousArgument.variadic) {
-          throw new Error(`only the last argument can be variadic '${previousArgument.name()}'`);
+        const previousArgument = this.registeredArguments.slice(-1)[0];
+        if (previousArgument?.variadic) {
+          throw new Error(
+            `only the last argument can be variadic '${previousArgument.name()}'`
+          );
         }
         if (argument.required && argument.defaultValue !== void 0 && argument.parseArg === void 0) {
-          throw new Error(`a default value for a required argument is never used: '${argument.name()}'`);
+          throw new Error(
+            `a default value for a required argument is never used: '${argument.name()}'`
+          );
         }
-        this._args.push(argument);
+        this.registeredArguments.push(argument);
         return this;
       }
       /**
-       * Override default decision whether to add implicit help command.
+       * Customise or override default help command. By default a help command is automatically added if your command has subcommands.
        *
-       *    addHelpCommand() // force on
-       *    addHelpCommand(false); // force off
-       *    addHelpCommand('help [cmd]', 'display help for [cmd]'); // force on with custom details
+       * @example
+       *    program.helpCommand('help [cmd]');
+       *    program.helpCommand('help [cmd]', 'show help');
+       *    program.helpCommand(false); // suppress default help command
+       *    program.helpCommand(true); // add help command even if no subcommands
        *
+       * @param {string|boolean} enableOrNameAndArgs - enable with custom name and/or arguments, or boolean to override whether added
+       * @param {string} [description] - custom description
        * @return {Command} `this` command for chaining
        */
-      addHelpCommand(enableOrNameAndArgs, description) {
-        if (enableOrNameAndArgs === false) {
-          this._addImplicitHelpCommand = false;
-        } else {
-          this._addImplicitHelpCommand = true;
-          if (typeof enableOrNameAndArgs === "string") {
-            this._helpCommandName = enableOrNameAndArgs.split(" ")[0];
-            this._helpCommandnameAndArgs = enableOrNameAndArgs;
+      helpCommand(enableOrNameAndArgs, description) {
+        if (typeof enableOrNameAndArgs === "boolean") {
+          this._addImplicitHelpCommand = enableOrNameAndArgs;
+          if (enableOrNameAndArgs && this._defaultCommandGroup) {
+            this._initCommandGroup(this._getHelpCommand());
           }
-          this._helpCommandDescription = description || this._helpCommandDescription;
+          return this;
         }
+        const nameAndArgs = enableOrNameAndArgs ?? "help [command]";
+        const [, helpName, helpArgs] = nameAndArgs.match(/([^ ]+) *(.*)/);
+        const helpDescription = description ?? "display help for command";
+        const helpCommand = this.createCommand(helpName);
+        helpCommand.helpOption(false);
+        if (helpArgs) helpCommand.arguments(helpArgs);
+        if (helpDescription) helpCommand.description(helpDescription);
+        this._addImplicitHelpCommand = true;
+        this._helpCommand = helpCommand;
+        if (enableOrNameAndArgs || description) this._initCommandGroup(helpCommand);
         return this;
       }
       /**
-       * @return {boolean}
-       * @api private
+       * Add prepared custom help command.
+       *
+       * @param {(Command|string|boolean)} helpCommand - custom help command, or deprecated enableOrNameAndArgs as for `.helpCommand()`
+       * @param {string} [deprecatedDescription] - deprecated custom description used with custom name only
+       * @return {Command} `this` command for chaining
+       */
+      addHelpCommand(helpCommand, deprecatedDescription) {
+        if (typeof helpCommand !== "object") {
+          this.helpCommand(helpCommand, deprecatedDescription);
+          return this;
+        }
+        this._addImplicitHelpCommand = true;
+        this._helpCommand = helpCommand;
+        this._initCommandGroup(helpCommand);
+        return this;
+      }
+      /**
+       * Lazy create help command.
+       *
+       * @return {(Command|null)}
+       * @package
        */
-      _hasImplicitHelpCommand() {
-        if (this._addImplicitHelpCommand === void 0) {
-          return this.commands.length && !this._actionHandler && !this._findCommand("help");
+      _getHelpCommand() {
+        const hasImplicitHelpCommand = this._addImplicitHelpCommand ?? (this.commands.length && !this._actionHandler && !this._findCommand("help"));
+        if (hasImplicitHelpCommand) {
+          if (this._helpCommand === void 0) {
+            this.helpCommand(void 0, void 0);
+          }
+          return this._helpCommand;
         }
-        return this._addImplicitHelpCommand;
+        return null;
       }
       /**
        * Add hook for life cycle event.
@@ -1329,7 +1688,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} code an id string representing the error
        * @param {string} message human-readable description of the error
        * @return never
-       * @api private
+       * @private
        */
       _exit(exitCode, code, message) {
         if (this._exitCallback) {
@@ -1353,7 +1712,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        */
       action(fn) {
         const listener = (args) => {
-          const expectedArgsCount = this._args.length;
+          const expectedArgsCount = this.registeredArguments.length;
           const actionArgs = args.slice(0, expectedArgsCount);
           if (this._storeOptionsAsProperties) {
             actionArgs[expectedArgsCount] = this;
@@ -1379,6 +1738,67 @@ Expecting one of '${allowedValues.join("', '")}'`);
       createOption(flags, description) {
         return new Option2(flags, description);
       }
+      /**
+       * Wrap parseArgs to catch 'commander.invalidArgument'.
+       *
+       * @param {(Option | Argument)} target
+       * @param {string} value
+       * @param {*} previous
+       * @param {string} invalidArgumentMessage
+       * @private
+       */
+      _callParseArg(target, value, previous, invalidArgumentMessage) {
+        try {
+          return target.parseArg(value, previous);
+        } catch (err) {
+          if (err.code === "commander.invalidArgument") {
+            const message = `${invalidArgumentMessage} ${err.message}`;
+            this.error(message, { exitCode: err.exitCode, code: err.code });
+          }
+          throw err;
+        }
+      }
+      /**
+       * Check for option flag conflicts.
+       * Register option if no conflicts found, or throw on conflict.
+       *
+       * @param {Option} option
+       * @private
+       */
+      _registerOption(option) {
+        const matchingOption = option.short && this._findOption(option.short) || option.long && this._findOption(option.long);
+        if (matchingOption) {
+          const matchingFlag = option.long && this._findOption(option.long) ? option.long : option.short;
+          throw new Error(`Cannot add option '${option.flags}'${this._name && ` to command '${this._name}'`} due to conflicting flag '${matchingFlag}'
+-  already used by option '${matchingOption.flags}'`);
+        }
+        this._initOptionGroup(option);
+        this.options.push(option);
+      }
+      /**
+       * Check for command name and alias conflicts with existing commands.
+       * Register command if no conflicts found, or throw on conflict.
+       *
+       * @param {Command} command
+       * @private
+       */
+      _registerCommand(command) {
+        const knownBy = (cmd) => {
+          return [cmd.name()].concat(cmd.aliases());
+        };
+        const alreadyUsed = knownBy(command).find(
+          (name) => this._findCommand(name)
+        );
+        if (alreadyUsed) {
+          const existingCmd = knownBy(this._findCommand(alreadyUsed)).join("|");
+          const newCmd = knownBy(command).join("|");
+          throw new Error(
+            `cannot add command '${newCmd}' as already have command '${existingCmd}'`
+          );
+        }
+        this._initCommandGroup(command);
+        this.commands.push(command);
+      }
       /**
        * Add an option.
        *
@@ -1386,34 +1806,30 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @return {Command} `this` command for chaining
        */
       addOption(option) {
+        this._registerOption(option);
         const oname = option.name();
         const name = option.attributeName();
         if (option.negate) {
           const positiveLongFlag = option.long.replace(/^--no-/, "--");
           if (!this._findOption(positiveLongFlag)) {
-            this.setOptionValueWithSource(name, option.defaultValue === void 0 ? true : option.defaultValue, "default");
+            this.setOptionValueWithSource(
+              name,
+              option.defaultValue === void 0 ? true : option.defaultValue,
+              "default"
+            );
           }
         } else if (option.defaultValue !== void 0) {
           this.setOptionValueWithSource(name, option.defaultValue, "default");
         }
-        this.options.push(option);
         const handleOptionValue = (val, invalidValueMessage, valueSource) => {
           if (val == null && option.presetArg !== void 0) {
             val = option.presetArg;
           }
           const oldValue = this.getOptionValue(name);
           if (val !== null && option.parseArg) {
-            try {
-              val = option.parseArg(val, oldValue);
-            } catch (err) {
-              if (err.code === "commander.invalidArgument") {
-                const message = `${invalidValueMessage} ${err.message}`;
-                this.error(message, { exitCode: err.exitCode, code: err.code });
-              }
-              throw err;
-            }
+            val = this._callParseArg(option, val, oldValue, invalidValueMessage);
           } else if (val !== null && option.variadic) {
-            val = option._concatValue(val, oldValue);
+            val = option._collectValue(val, oldValue);
           }
           if (val == null) {
             if (option.negate) {
@@ -1441,11 +1857,14 @@ Expecting one of '${allowedValues.join("', '")}'`);
       /**
        * Internal implementation shared by .option() and .requiredOption()
        *
-       * @api private
+       * @return {Command} `this` command for chaining
+       * @private
        */
       _optionEx(config, flags, description, fn, defaultValue) {
         if (typeof flags === "object" && flags instanceof Option2) {
-          throw new Error("To add an Option object use addOption() instead of option() or requiredOption()");
+          throw new Error(
+            "To add an Option object use addOption() instead of option() or requiredOption()"
+          );
         }
         const option = this.createOption(flags, description);
         option.makeOptionMandatory(!!config.mandatory);
@@ -1464,71 +1883,49 @@ Expecting one of '${allowedValues.join("', '")}'`);
         return this.addOption(option);
       }
       /**
-       * Define option with `flags`, `description` and optional
-       * coercion `fn`.
+       * Define option with `flags`, `description`, and optional argument parsing function or `defaultValue` or both.
        *
-       * The `flags` string contains the short and/or long flags,
-       * separated by comma, a pipe or space. The following are all valid
-       * all will output this way when `--help` is used.
+       * The `flags` string contains the short and/or long flags, separated by comma, a pipe or space. A required
+       * option-argument is indicated by `<>` and an optional option-argument by `[]`.
        *
-       *     "-p, --pepper"
-       *     "-p|--pepper"
-       *     "-p --pepper"
+       * See the README for more details, and see also addOption() and requiredOption().
        *
        * @example
-       * // simple boolean defaulting to undefined
-       * program.option('-p, --pepper', 'add pepper');
-       *
-       * program.pepper
-       * // => undefined
-       *
-       * --pepper
-       * program.pepper
-       * // => true
-       *
-       * // simple boolean defaulting to true (unless non-negated option is also defined)
-       * program.option('-C, --no-cheese', 'remove cheese');
-       *
-       * program.cheese
-       * // => true
-       *
-       * --no-cheese
-       * program.cheese
-       * // => false
-       *
-       * // required argument
-       * program.option('-C, --chdir <path>', 'change the working directory');
-       *
-       * --chdir /tmp
-       * program.chdir
-       * // => "/tmp"
-       *
-       * // optional argument
-       * program.option('-c, --cheese [type]', 'add cheese [marble]');
+       * program
+       *     .option('-p, --pepper', 'add pepper')
+       *     .option('--pt, --pizza-type <TYPE>', 'type of pizza') // required option-argument
+       *     .option('-c, --cheese [CHEESE]', 'add extra cheese', 'mozzarella') // optional option-argument with default
+       *     .option('-t, --tip <VALUE>', 'add tip to purchase cost', parseFloat) // custom parse function
        *
        * @param {string} flags
        * @param {string} [description]
-       * @param {Function|*} [fn] - custom option processing function or default value
+       * @param {(Function|*)} [parseArg] - custom option processing function or default value
        * @param {*} [defaultValue]
        * @return {Command} `this` command for chaining
        */
-      option(flags, description, fn, defaultValue) {
-        return this._optionEx({}, flags, description, fn, defaultValue);
+      option(flags, description, parseArg, defaultValue) {
+        return this._optionEx({}, flags, description, parseArg, defaultValue);
       }
       /**
-      * Add a required option which must have a value after parsing. This usually means
-      * the option must be specified on the command line. (Otherwise the same as .option().)
-      *
-      * The `flags` string contains the short and/or long flags, separated by comma, a pipe or space.
-      *
-      * @param {string} flags
-      * @param {string} [description]
-      * @param {Function|*} [fn] - custom option processing function or default value
-      * @param {*} [defaultValue]
-      * @return {Command} `this` command for chaining
-      */
-      requiredOption(flags, description, fn, defaultValue) {
-        return this._optionEx({ mandatory: true }, flags, description, fn, defaultValue);
+       * Add a required option which must have a value after parsing. This usually means
+       * the option must be specified on the command line. (Otherwise the same as .option().)
+       *
+       * The `flags` string contains the short and/or long flags, separated by comma, a pipe or space.
+       *
+       * @param {string} flags
+       * @param {string} [description]
+       * @param {(Function|*)} [parseArg] - custom option processing function or default value
+       * @param {*} [defaultValue]
+       * @return {Command} `this` command for chaining
+       */
+      requiredOption(flags, description, parseArg, defaultValue) {
+        return this._optionEx(
+          { mandatory: true },
+          flags,
+          description,
+          parseArg,
+          defaultValue
+        );
       }
       /**
        * Alter parsing of short flags with optional values.
@@ -1538,7 +1935,8 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * program.combineFlagAndOptionalValue(true);  // `-f80` is treated like `--flag=80`, this is the default behaviour
        * program.combineFlagAndOptionalValue(false) // `-fb` is treated like `-f -b`
        *
-       * @param {Boolean} [combine=true] - if `true` or omitted, an optional value can be specified directly after the flag.
+       * @param {boolean} [combine] - if `true` or omitted, an optional value can be specified directly after the flag.
+       * @return {Command} `this` command for chaining
        */
       combineFlagAndOptionalValue(combine = true) {
         this._combineFlagAndOptionalValue = !!combine;
@@ -1547,8 +1945,8 @@ Expecting one of '${allowedValues.join("', '")}'`);
       /**
        * Allow unknown options on the command line.
        *
-       * @param {Boolean} [allowUnknown=true] - if `true` or omitted, no error will be thrown
-       * for unknown options.
+       * @param {boolean} [allowUnknown] - if `true` or omitted, no error will be thrown for unknown options.
+       * @return {Command} `this` command for chaining
        */
       allowUnknownOption(allowUnknown = true) {
         this._allowUnknownOption = !!allowUnknown;
@@ -1557,8 +1955,8 @@ Expecting one of '${allowedValues.join("', '")}'`);
       /**
        * Allow excess command-arguments on the command line. Pass false to make excess arguments an error.
        *
-       * @param {Boolean} [allowExcess=true] - if `true` or omitted, no error will be thrown
-       * for excess arguments.
+       * @param {boolean} [allowExcess] - if `true` or omitted, no error will be thrown for excess arguments.
+       * @return {Command} `this` command for chaining
        */
       allowExcessArguments(allowExcess = true) {
         this._allowExcessArguments = !!allowExcess;
@@ -1569,7 +1967,8 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * subcommands reuse the same option names, and also enables subcommands to turn on passThroughOptions.
        * The default behaviour is non-positional and global options may appear anywhere on the command line.
        *
-       * @param {Boolean} [positional=true]
+       * @param {boolean} [positional]
+       * @return {Command} `this` command for chaining
        */
       enablePositionalOptions(positional = true) {
         this._enablePositionalOptions = !!positional;
@@ -1581,35 +1980,48 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * positional options to have been enabled on the program (parent commands).
        * The default behaviour is non-positional and options may appear before or after command-arguments.
        *
-       * @param {Boolean} [passThrough=true]
-       * for unknown options.
+       * @param {boolean} [passThrough] for unknown options.
+       * @return {Command} `this` command for chaining
        */
       passThroughOptions(passThrough = true) {
         this._passThroughOptions = !!passThrough;
-        if (!!this.parent && passThrough && !this.parent._enablePositionalOptions) {
-          throw new Error("passThroughOptions can not be used without turning on enablePositionalOptions for parent command(s)");
-        }
+        this._checkForBrokenPassThrough();
         return this;
       }
       /**
-        * Whether to store option values as properties on command object,
-        * or store separately (specify false). In both cases the option values can be accessed using .opts().
-        *
-        * @param {boolean} [storeAsProperties=true]
-        * @return {Command} `this` command for chaining
-        */
+       * @private
+       */
+      _checkForBrokenPassThrough() {
+        if (this.parent && this._passThroughOptions && !this.parent._enablePositionalOptions) {
+          throw new Error(
+            `passThroughOptions cannot be used for '${this._name}' without turning on enablePositionalOptions for parent command(s)`
+          );
+        }
+      }
+      /**
+       * Whether to store option values as properties on command object,
+       * or store separately (specify false). In both cases the option values can be accessed using .opts().
+       *
+       * @param {boolean} [storeAsProperties=true]
+       * @return {Command} `this` command for chaining
+       */
       storeOptionsAsProperties(storeAsProperties = true) {
-        this._storeOptionsAsProperties = !!storeAsProperties;
         if (this.options.length) {
           throw new Error("call .storeOptionsAsProperties() before adding options");
         }
+        if (Object.keys(this._optionValues).length) {
+          throw new Error(
+            "call .storeOptionsAsProperties() before setting option values"
+          );
+        }
+        this._storeOptionsAsProperties = !!storeAsProperties;
         return this;
       }
       /**
        * Retrieve option value.
        *
        * @param {string} key
-       * @return {Object} value
+       * @return {object} value
        */
       getOptionValue(key) {
         if (this._storeOptionsAsProperties) {
@@ -1621,20 +2033,20 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * Store option value.
        *
        * @param {string} key
-       * @param {Object} value
+       * @param {object} value
        * @return {Command} `this` command for chaining
        */
       setOptionValue(key, value) {
         return this.setOptionValueWithSource(key, value, void 0);
       }
       /**
-        * Store option value and where the value came from.
-        *
-        * @param {string} key
-        * @param {Object} value
-        * @param {string} source - expected values are default/config/env/cli/implied
-        * @return {Command} `this` command for chaining
-        */
+       * Store option value and where the value came from.
+       *
+       * @param {string} key
+       * @param {object} value
+       * @param {string} source - expected values are default/config/env/cli/implied
+       * @return {Command} `this` command for chaining
+       */
       setOptionValueWithSource(key, value, source) {
         if (this._storeOptionsAsProperties) {
           this[key] = value;
@@ -1645,25 +2057,25 @@ Expecting one of '${allowedValues.join("', '")}'`);
         return this;
       }
       /**
-        * Get source of option value.
-        * Expected values are default | config | env | cli | implied
-        *
-        * @param {string} key
-        * @return {string}
-        */
+       * Get source of option value.
+       * Expected values are default | config | env | cli | implied
+       *
+       * @param {string} key
+       * @return {string}
+       */
       getOptionValueSource(key) {
         return this._optionValueSources[key];
       }
       /**
-        * Get source of option value. See also .optsWithGlobals().
-        * Expected values are default | config | env | cli | implied
-        *
-        * @param {string} key
-        * @return {string}
-        */
+       * Get source of option value. See also .optsWithGlobals().
+       * Expected values are default | config | env | cli | implied
+       *
+       * @param {string} key
+       * @return {string}
+       */
       getOptionValueSourceWithGlobals(key) {
         let source;
-        getCommandAndParents(this).forEach((cmd) => {
+        this._getCommandAndAncestors().forEach((cmd) => {
           if (cmd.getOptionValueSource(key) !== void 0) {
             source = cmd.getOptionValueSource(key);
           }
@@ -1674,18 +2086,24 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * Get user arguments from implied or explicit arguments.
        * Side-effects: set _scriptPath if args included script. Used for default program name, and subcommand searches.
        *
-       * @api private
+       * @private
        */
       _prepareUserArgs(argv, parseOptions) {
         if (argv !== void 0 && !Array.isArray(argv)) {
           throw new Error("first parameter to parse must be array or undefined");
         }
         parseOptions = parseOptions || {};
-        if (argv === void 0) {
-          argv = process2.argv;
-          if (process2.versions && process2.versions.electron) {
+        if (argv === void 0 && parseOptions.from === void 0) {
+          if (process2.versions?.electron) {
             parseOptions.from = "electron";
           }
+          const execArgv = process2.execArgv ?? [];
+          if (execArgv.includes("-e") || execArgv.includes("--eval") || execArgv.includes("-p") || execArgv.includes("--print")) {
+            parseOptions.from = "eval";
+          }
+        }
+        if (argv === void 0) {
+          argv = process2.argv;
         }
         this.rawArgs = argv.slice();
         let userArgs;
@@ -1706,8 +2124,13 @@ Expecting one of '${allowedValues.join("', '")}'`);
           case "user":
             userArgs = argv.slice(0);
             break;
+          case "eval":
+            userArgs = argv.slice(1);
+            break;
           default:
-            throw new Error(`unexpected parse option { from: '${parseOptions.from}' }`);
+            throw new Error(
+              `unexpected parse option { from: '${parseOptions.from}' }`
+            );
         }
         if (!this._name && this._scriptPath)
           this.nameFromFilename(this._scriptPath);
@@ -1717,20 +2140,27 @@ Expecting one of '${allowedValues.join("', '")}'`);
       /**
        * Parse `argv`, setting options and invoking commands when defined.
        *
-       * The default expectation is that the arguments are from node and have the application as argv[0]
-       * and the script being run in argv[1], with user parameters after that.
+       * Use parseAsync instead of parse if any of your action handlers are async.
+       *
+       * Call with no parameters to parse `process.argv`. Detects Electron and special node options like `node --eval`. Easy mode!
+       *
+       * Or call with an array of strings to parse, and optionally where the user arguments start by specifying where the arguments are `from`:
+       * - `'node'`: default, `argv[0]` is the application and `argv[1]` is the script being run, with user arguments after that
+       * - `'electron'`: `argv[0]` is the application and `argv[1]` varies depending on whether the electron application is packaged
+       * - `'user'`: just user arguments
        *
        * @example
-       * program.parse(process.argv);
-       * program.parse(); // implicitly use process.argv and auto-detect node vs electron conventions
+       * program.parse(); // parse process.argv and auto-detect electron and special node flags
+       * program.parse(process.argv); // assume argv[0] is app and argv[1] is script
        * program.parse(my-args, { from: 'user' }); // just user supplied arguments, nothing special about argv[0]
        *
        * @param {string[]} [argv] - optional, defaults to process.argv
-       * @param {Object} [parseOptions] - optionally specify style of options with from: node/user/electron
+       * @param {object} [parseOptions] - optionally specify style of options with from: node/user/electron
        * @param {string} [parseOptions.from] - where the args are from: 'node', 'user', 'electron'
        * @return {Command} `this` command for chaining
        */
       parse(argv, parseOptions) {
+        this._prepareForParse();
         const userArgs = this._prepareUserArgs(argv, parseOptions);
         this._parseCommand([], userArgs);
         return this;
@@ -1738,44 +2168,103 @@ Expecting one of '${allowedValues.join("', '")}'`);
       /**
        * Parse `argv`, setting options and invoking commands when defined.
        *
-       * Use parseAsync instead of parse if any of your action handlers are async. Returns a Promise.
+       * Call with no parameters to parse `process.argv`. Detects Electron and special node options like `node --eval`. Easy mode!
        *
-       * The default expectation is that the arguments are from node and have the application as argv[0]
-       * and the script being run in argv[1], with user parameters after that.
+       * Or call with an array of strings to parse, and optionally where the user arguments start by specifying where the arguments are `from`:
+       * - `'node'`: default, `argv[0]` is the application and `argv[1]` is the script being run, with user arguments after that
+       * - `'electron'`: `argv[0]` is the application and `argv[1]` varies depending on whether the electron application is packaged
+       * - `'user'`: just user arguments
        *
        * @example
-       * await program.parseAsync(process.argv);
-       * await program.parseAsync(); // implicitly use process.argv and auto-detect node vs electron conventions
+       * await program.parseAsync(); // parse process.argv and auto-detect electron and special node flags
+       * await program.parseAsync(process.argv); // assume argv[0] is app and argv[1] is script
        * await program.parseAsync(my-args, { from: 'user' }); // just user supplied arguments, nothing special about argv[0]
        *
        * @param {string[]} [argv]
-       * @param {Object} [parseOptions]
+       * @param {object} [parseOptions]
        * @param {string} parseOptions.from - where the args are from: 'node', 'user', 'electron'
        * @return {Promise}
        */
       async parseAsync(argv, parseOptions) {
+        this._prepareForParse();
         const userArgs = this._prepareUserArgs(argv, parseOptions);
         await this._parseCommand([], userArgs);
         return this;
       }
+      _prepareForParse() {
+        if (this._savedState === null) {
+          this.saveStateBeforeParse();
+        } else {
+          this.restoreStateBeforeParse();
+        }
+      }
+      /**
+       * Called the first time parse is called to save state and allow a restore before subsequent calls to parse.
+       * Not usually called directly, but available for subclasses to save their custom state.
+       *
+       * This is called in a lazy way. Only commands used in parsing chain will have state saved.
+       */
+      saveStateBeforeParse() {
+        this._savedState = {
+          // name is stable if supplied by author, but may be unspecified for root command and deduced during parsing
+          _name: this._name,
+          // option values before parse have default values (including false for negated options)
+          // shallow clones
+          _optionValues: { ...this._optionValues },
+          _optionValueSources: { ...this._optionValueSources }
+        };
+      }
+      /**
+       * Restore state before parse for calls after the first.
+       * Not usually called directly, but available for subclasses to save their custom state.
+       *
+       * This is called in a lazy way. Only commands used in parsing chain will have state restored.
+       */
+      restoreStateBeforeParse() {
+        if (this._storeOptionsAsProperties)
+          throw new Error(`Can not call parse again when storeOptionsAsProperties is true.
+- either make a new Command for each call to parse, or stop storing options as properties`);
+        this._name = this._savedState._name;
+        this._scriptPath = null;
+        this.rawArgs = [];
+        this._optionValues = { ...this._savedState._optionValues };
+        this._optionValueSources = { ...this._savedState._optionValueSources };
+        this.args = [];
+        this.processedArgs = [];
+      }
+      /**
+       * Throw if expected executable is missing. Add lots of help for author.
+       *
+       * @param {string} executableFile
+       * @param {string} executableDir
+       * @param {string} subcommandName
+       */
+      _checkForMissingExecutable(executableFile, executableDir, subcommandName) {
+        if (fs.existsSync(executableFile)) return;
+        const executableDirMessage = executableDir ? `searched for local subcommand relative to directory '${executableDir}'` : "no directory for search for local subcommand, use .executableDir() to supply a custom directory";
+        const executableMissing = `'${executableFile}' does not exist
+ - if '${subcommandName}' is not meant to be an executable command, remove description parameter from '.command()' and use '.description()' instead
+ - if the default executable name is not suitable, use the executableFile option to supply a custom name or path
+ - ${executableDirMessage}`;
+        throw new Error(executableMissing);
+      }
       /**
        * Execute a sub-command executable.
        *
-       * @api private
+       * @private
        */
       _executeSubCommand(subcommand, args) {
         args = args.slice();
         let launchWithNode = false;
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
-          const localBin = path.resolve(baseDir, baseName);
-          if (fs.existsSync(localBin))
-            return localBin;
-          if (sourceExt.includes(path.extname(baseName)))
-            return void 0;
-          const foundExt = sourceExt.find((ext) => fs.existsSync(`${localBin}${ext}`));
-          if (foundExt)
-            return `${localBin}${foundExt}`;
+          const localBin = path2.resolve(baseDir, baseName);
+          if (fs.existsSync(localBin)) return localBin;
+          if (sourceExt.includes(path2.extname(baseName))) return void 0;
+          const foundExt = sourceExt.find(
+            (ext) => fs.existsSync(`${localBin}${ext}`)
+          );
+          if (foundExt) return `${localBin}${foundExt}`;
           return void 0;
         }
         this._checkForMissingMandatoryOptions();
@@ -1786,22 +2275,31 @@ Expecting one of '${allowedValues.join("', '")}'`);
           let resolvedScriptPath;
           try {
             resolvedScriptPath = fs.realpathSync(this._scriptPath);
-          } catch (err) {
+          } catch {
             resolvedScriptPath = this._scriptPath;
           }
-          executableDir = path.resolve(path.dirname(resolvedScriptPath), executableDir);
+          executableDir = path2.resolve(
+            path2.dirname(resolvedScriptPath),
+            executableDir
+          );
         }
         if (executableDir) {
           let localFile = findFile(executableDir, executableFile);
           if (!localFile && !subcommand._executableFile && this._scriptPath) {
-            const legacyName = path.basename(this._scriptPath, path.extname(this._scriptPath));
+            const legacyName = path2.basename(
+              this._scriptPath,
+              path2.extname(this._scriptPath)
+            );
             if (legacyName !== this._name) {
-              localFile = findFile(executableDir, `${legacyName}-${subcommand._name}`);
+              localFile = findFile(
+                executableDir,
+                `${legacyName}-${subcommand._name}`
+              );
             }
           }
           executableFile = localFile || executableFile;
         }
-        launchWithNode = sourceExt.includes(path.extname(executableFile));
+        launchWithNode = sourceExt.includes(path2.extname(executableFile));
         let proc;
         if (process2.platform !== "win32") {
           if (launchWithNode) {
@@ -1812,6 +2310,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
             proc = childProcess.spawn(executableFile, args, { stdio: "inherit" });
           }
         } else {
+          this._checkForMissingExecutable(
+            executableFile,
+            executableDir,
+            subcommand._name
+          );
           args.unshift(executableFile);
           args = incrementNodeInspectorPort(process2.execArgv).concat(args);
           proc = childProcess.spawn(process2.execPath, args, { stdio: "inherit" });
@@ -1827,28 +2330,38 @@ Expecting one of '${allowedValues.join("', '")}'`);
           });
         }
         const exitCallback = this._exitCallback;
-        if (!exitCallback) {
-          proc.on("close", process2.exit.bind(process2));
-        } else {
-          proc.on("close", () => {
-            exitCallback(new CommanderError2(process2.exitCode || 0, "commander.executeSubCommandAsync", "(close)"));
-          });
-        }
+        proc.on("close", (code) => {
+          code = code ?? 1;
+          if (!exitCallback) {
+            process2.exit(code);
+          } else {
+            exitCallback(
+              new CommanderError2(
+                code,
+                "commander.executeSubCommandAsync",
+                "(close)"
+              )
+            );
+          }
+        });
         proc.on("error", (err) => {
           if (err.code === "ENOENT") {
-            const executableDirMessage = executableDir ? `searched for local subcommand relative to directory '${executableDir}'` : "no directory for search for local subcommand, use .executableDir() to supply a custom directory";
-            const executableMissing = `'${executableFile}' does not exist
- - if '${subcommand._name}' is not meant to be an executable command, remove description parameter from '.command()' and use '.description()' instead
- - if the default executable name is not suitable, use the executableFile option to supply a custom name or path
- - ${executableDirMessage}`;
-            throw new Error(executableMissing);
+            this._checkForMissingExecutable(
+              executableFile,
+              executableDir,
+              subcommand._name
+            );
           } else if (err.code === "EACCES") {
             throw new Error(`'${executableFile}' not executable`);
           }
           if (!exitCallback) {
             process2.exit(1);
           } else {
-            const wrappedError = new CommanderError2(1, "commander.executeSubCommandAsync", "(error)");
+            const wrappedError = new CommanderError2(
+              1,
+              "commander.executeSubCommandAsync",
+              "(error)"
+            );
             wrappedError.nestedError = err;
             exitCallback(wrappedError);
           }
@@ -1856,65 +2369,87 @@ Expecting one of '${allowedValues.join("', '")}'`);
         this.runningCommand = proc;
       }
       /**
-       * @api private
+       * @private
        */
       _dispatchSubcommand(commandName, operands, unknown) {
         const subCommand = this._findCommand(commandName);
-        if (!subCommand)
-          this.help({ error: true });
-        let hookResult;
-        hookResult = this._chainOrCallSubCommandHook(hookResult, subCommand, "preSubcommand");
-        hookResult = this._chainOrCall(hookResult, () => {
+        if (!subCommand) this.help({ error: true });
+        subCommand._prepareForParse();
+        let promiseChain;
+        promiseChain = this._chainOrCallSubCommandHook(
+          promiseChain,
+          subCommand,
+          "preSubcommand"
+        );
+        promiseChain = this._chainOrCall(promiseChain, () => {
           if (subCommand._executableHandler) {
             this._executeSubCommand(subCommand, operands.concat(unknown));
           } else {
             return subCommand._parseCommand(operands, unknown);
           }
         });
-        return hookResult;
+        return promiseChain;
+      }
+      /**
+       * Invoke help directly if possible, or dispatch if necessary.
+       * e.g. help foo
+       *
+       * @private
+       */
+      _dispatchHelpCommand(subcommandName) {
+        if (!subcommandName) {
+          this.help();
+        }
+        const subCommand = this._findCommand(subcommandName);
+        if (subCommand && !subCommand._executableHandler) {
+          subCommand.help();
+        }
+        return this._dispatchSubcommand(
+          subcommandName,
+          [],
+          [this._getHelpOption()?.long ?? this._getHelpOption()?.short ?? "--help"]
+        );
       }
       /**
-       * Check this.args against expected this._args.
+       * Check this.args against expected this.registeredArguments.
        *
-       * @api private
+       * @private
        */
       _checkNumberOfArguments() {
-        this._args.forEach((arg, i) => {
+        this.registeredArguments.forEach((arg, i) => {
           if (arg.required && this.args[i] == null) {
             this.missingArgument(arg.name());
           }
         });
-        if (this._args.length > 0 && this._args[this._args.length - 1].variadic) {
+        if (this.registeredArguments.length > 0 && this.registeredArguments[this.registeredArguments.length - 1].variadic) {
           return;
         }
-        if (this.args.length > this._args.length) {
+        if (this.args.length > this.registeredArguments.length) {
           this._excessArguments(this.args);
         }
       }
       /**
-       * Process this.args using this._args and save as this.processedArgs!
+       * Process this.args using this.registeredArguments and save as this.processedArgs!
        *
-       * @api private
+       * @private
        */
       _processArguments() {
         const myParseArg = (argument, value, previous) => {
           let parsedValue = value;
           if (value !== null && argument.parseArg) {
-            try {
-              parsedValue = argument.parseArg(value, previous);
-            } catch (err) {
-              if (err.code === "commander.invalidArgument") {
-                const message = `error: command-argument value '${value}' is invalid for argument '${argument.name()}'. ${err.message}`;
-                this.error(message, { exitCode: err.exitCode, code: err.code });
-              }
-              throw err;
-            }
+            const invalidValueMessage = `error: command-argument value '${value}' is invalid for argument '${argument.name()}'.`;
+            parsedValue = this._callParseArg(
+              argument,
+              value,
+              previous,
+              invalidValueMessage
+            );
           }
           return parsedValue;
         };
         this._checkNumberOfArguments();
         const processedArgs = [];
-        this._args.forEach((declaredArg, index) => {
+        this.registeredArguments.forEach((declaredArg, index) => {
           let value = declaredArg.defaultValue;
           if (declaredArg.variadic) {
             if (index < this.args.length) {
@@ -1940,28 +2475,28 @@ Expecting one of '${allowedValues.join("', '")}'`);
       /**
        * Once we have a promise we chain, but call synchronously until then.
        *
-       * @param {Promise|undefined} promise
+       * @param {(Promise|undefined)} promise
        * @param {Function} fn
-       * @return {Promise|undefined}
-       * @api private
+       * @return {(Promise|undefined)}
+       * @private
        */
       _chainOrCall(promise, fn) {
-        if (promise && promise.then && typeof promise.then === "function") {
+        if (promise?.then && typeof promise.then === "function") {
           return promise.then(() => fn());
         }
         return fn();
       }
       /**
        *
-       * @param {Promise|undefined} promise
+       * @param {(Promise|undefined)} promise
        * @param {string} event
-       * @return {Promise|undefined}
-       * @api private
+       * @return {(Promise|undefined)}
+       * @private
        */
       _chainOrCallHooks(promise, event) {
         let result = promise;
         const hooks = [];
-        getCommandAndParents(this).reverse().filter((cmd) => cmd._lifeCycleHooks[event] !== void 0).forEach((hookedCommand) => {
+        this._getCommandAndAncestors().reverse().filter((cmd) => cmd._lifeCycleHooks[event] !== void 0).forEach((hookedCommand) => {
           hookedCommand._lifeCycleHooks[event].forEach((callback) => {
             hooks.push({ hookedCommand, callback });
           });
@@ -1978,11 +2513,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
       }
       /**
        *
-       * @param {Promise|undefined} promise
+       * @param {(Promise|undefined)} promise
        * @param {Command} subCommand
        * @param {string} event
-       * @return {Promise|undefined}
-       * @api private
+       * @return {(Promise|undefined)}
+       * @private
        */
       _chainOrCallSubCommandHook(promise, subCommand, event) {
         let result = promise;
@@ -1999,7 +2534,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * Process arguments in context of this command.
        * Returns action result, in case it is a promise.
        *
-       * @api private
+       * @private
        */
       _parseCommand(operands, unknown) {
         const parsed = this.parseOptions(unknown);
@@ -2011,20 +2546,21 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (operands && this._findCommand(operands[0])) {
           return this._dispatchSubcommand(operands[0], operands.slice(1), unknown);
         }
-        if (this._hasImplicitHelpCommand() && operands[0] === this._helpCommandName) {
-          if (operands.length === 1) {
-            this.help();
-          }
-          return this._dispatchSubcommand(operands[1], [], [this._helpLongFlag]);
+        if (this._getHelpCommand() && operands[0] === this._getHelpCommand().name()) {
+          return this._dispatchHelpCommand(operands[1]);
         }
         if (this._defaultCommandName) {
-          outputHelpIfRequested(this, unknown);
-          return this._dispatchSubcommand(this._defaultCommandName, operands, unknown);
+          this._outputHelpIfRequested(unknown);
+          return this._dispatchSubcommand(
+            this._defaultCommandName,
+            operands,
+            unknown
+          );
         }
         if (this.commands.length && this.args.length === 0 && !this._actionHandler && !this._defaultCommandName) {
           this.help({ error: true });
         }
-        outputHelpIfRequested(this, parsed.unknown);
+        this._outputHelpIfRequested(parsed.unknown);
         this._checkForMissingMandatoryOptions();
         this._checkForConflictingOptions();
         const checkForUnknownOptions = () => {
@@ -2036,18 +2572,21 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (this._actionHandler) {
           checkForUnknownOptions();
           this._processArguments();
-          let actionResult;
-          actionResult = this._chainOrCallHooks(actionResult, "preAction");
-          actionResult = this._chainOrCall(actionResult, () => this._actionHandler(this.processedArgs));
+          let promiseChain;
+          promiseChain = this._chainOrCallHooks(promiseChain, "preAction");
+          promiseChain = this._chainOrCall(
+            promiseChain,
+            () => this._actionHandler(this.processedArgs)
+          );
           if (this.parent) {
-            actionResult = this._chainOrCall(actionResult, () => {
+            promiseChain = this._chainOrCall(promiseChain, () => {
               this.parent.emit(commandEvent, operands, unknown);
             });
           }
-          actionResult = this._chainOrCallHooks(actionResult, "postAction");
-          return actionResult;
+          promiseChain = this._chainOrCallHooks(promiseChain, "postAction");
+          return promiseChain;
         }
-        if (this.parent && this.parent.listenerCount(commandEvent)) {
+        if (this.parent?.listenerCount(commandEvent)) {
           checkForUnknownOptions();
           this._processArguments();
           this.parent.emit(commandEvent, operands, unknown);
@@ -2074,19 +2613,21 @@ Expecting one of '${allowedValues.join("', '")}'`);
       /**
        * Find matching command.
        *
-       * @api private
+       * @private
+       * @return {Command | undefined}
        */
       _findCommand(name) {
-        if (!name)
-          return void 0;
-        return this.commands.find((cmd) => cmd._name === name || cmd._aliases.includes(name));
+        if (!name) return void 0;
+        return this.commands.find(
+          (cmd) => cmd._name === name || cmd._aliases.includes(name)
+        );
       }
       /**
        * Return an option matching `arg` if any.
        *
        * @param {string} arg
        * @return {Option}
-       * @api private
+       * @package
        */
       _findOption(arg) {
         return this.options.find((option) => option.is(arg));
@@ -2095,32 +2636,30 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * Display an error message if a mandatory option does not have a value.
        * Called after checking for help flags in leaf subcommand.
        *
-       * @api private
+       * @private
        */
       _checkForMissingMandatoryOptions() {
-        for (let cmd = this; cmd; cmd = cmd.parent) {
+        this._getCommandAndAncestors().forEach((cmd) => {
           cmd.options.forEach((anOption) => {
             if (anOption.mandatory && cmd.getOptionValue(anOption.attributeName()) === void 0) {
               cmd.missingMandatoryOptionValue(anOption);
             }
           });
-        }
+        });
       }
       /**
        * Display an error message if conflicting options are used together in this.
        *
-       * @api private
+       * @private
        */
       _checkForConflictingLocalOptions() {
-        const definedNonDefaultOptions = this.options.filter(
-          (option) => {
-            const optionKey = option.attributeName();
-            if (this.getOptionValue(optionKey) === void 0) {
-              return false;
-            }
-            return this.getOptionValueSource(optionKey) !== "default";
+        const definedNonDefaultOptions = this.options.filter((option) => {
+          const optionKey = option.attributeName();
+          if (this.getOptionValue(optionKey) === void 0) {
+            return false;
           }
-        );
+          return this.getOptionValueSource(optionKey) !== "default";
+        });
         const optionsWithConflicting = definedNonDefaultOptions.filter(
           (option) => option.conflictsWith.length > 0
         );
@@ -2137,17 +2676,19 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * Display an error message if conflicting options are used together.
        * Called after checking for help flags in leaf subcommand.
        *
-       * @api private
+       * @private
        */
       _checkForConflictingOptions() {
-        for (let cmd = this; cmd; cmd = cmd.parent) {
+        this._getCommandAndAncestors().forEach((cmd) => {
           cmd._checkForConflictingLocalOptions();
-        }
+        });
       }
       /**
        * Parse options from `argv` removing known options,
        * and return argv split into operands and unknown arguments.
        *
+       * Side effects: modifies command by storing options. Does not reset state if called again.
+       *
        * Examples:
        *
        *     argv => operands, unknown
@@ -2156,27 +2697,34 @@ Expecting one of '${allowedValues.join("', '")}'`);
        *     sub --unknown uuu op => [sub], [--unknown uuu op]
        *     sub -- --unknown uuu op => [sub --unknown uuu op], []
        *
-       * @param {String[]} argv
-       * @return {{operands: String[], unknown: String[]}}
+       * @param {string[]} args
+       * @return {{operands: string[], unknown: string[]}}
        */
-      parseOptions(argv) {
+      parseOptions(args) {
         const operands = [];
         const unknown = [];
         let dest = operands;
-        const args = argv.slice();
         function maybeOption(arg) {
           return arg.length > 1 && arg[0] === "-";
         }
+        const negativeNumberArg = (arg) => {
+          if (!/^-(\d+|\d*\.\d+)(e[+-]?\d+)?$/.test(arg)) return false;
+          return !this._getCommandAndAncestors().some(
+            (cmd) => cmd.options.map((opt) => opt.short).some((short) => /^-\d$/.test(short))
+          );
+        };
         let activeVariadicOption = null;
-        while (args.length) {
-          const arg = args.shift();
+        let activeGroup = null;
+        let i = 0;
+        while (i < args.length || activeGroup) {
+          const arg = activeGroup ?? args[i++];
+          activeGroup = null;
           if (arg === "--") {
-            if (dest === unknown)
-              dest.push(arg);
-            dest.push(...args);
+            if (dest === unknown) dest.push(arg);
+            dest.push(...args.slice(i));
             break;
           }
-          if (activeVariadicOption && !maybeOption(arg)) {
+          if (activeVariadicOption && (!maybeOption(arg) || negativeNumberArg(arg))) {
             this.emit(`option:${activeVariadicOption.name()}`, arg);
             continue;
           }
@@ -2185,14 +2733,13 @@ Expecting one of '${allowedValues.join("', '")}'`);
             const option = this._findOption(arg);
             if (option) {
               if (option.required) {
-                const value = args.shift();
-                if (value === void 0)
-                  this.optionMissingArgument(option);
+                const value = args[i++];
+                if (value === void 0) this.optionMissingArgument(option);
                 this.emit(`option:${option.name()}`, value);
               } else if (option.optional) {
                 let value = null;
-                if (args.length > 0 && !maybeOption(args[0])) {
-                  value = args.shift();
+                if (i < args.length && (!maybeOption(args[i]) || negativeNumberArg(args[i]))) {
+                  value = args[i++];
                 }
                 this.emit(`option:${option.name()}`, value);
               } else {
@@ -2209,7 +2756,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
                 this.emit(`option:${option.name()}`, arg.slice(2));
               } else {
                 this.emit(`option:${option.name()}`);
-                args.unshift(`-${arg.slice(2)}`);
+                activeGroup = `-${arg.slice(2)}`;
               }
               continue;
             }
@@ -2222,31 +2769,24 @@ Expecting one of '${allowedValues.join("', '")}'`);
               continue;
             }
           }
-          if (maybeOption(arg)) {
+          if (dest === operands && maybeOption(arg) && !(this.commands.length === 0 && negativeNumberArg(arg))) {
             dest = unknown;
           }
           if ((this._enablePositionalOptions || this._passThroughOptions) && operands.length === 0 && unknown.length === 0) {
             if (this._findCommand(arg)) {
               operands.push(arg);
-              if (args.length > 0)
-                unknown.push(...args);
+              unknown.push(...args.slice(i));
               break;
-            } else if (arg === this._helpCommandName && this._hasImplicitHelpCommand()) {
-              operands.push(arg);
-              if (args.length > 0)
-                operands.push(...args);
+            } else if (this._getHelpCommand() && arg === this._getHelpCommand().name()) {
+              operands.push(arg, ...args.slice(i));
               break;
             } else if (this._defaultCommandName) {
-              unknown.push(arg);
-              if (args.length > 0)
-                unknown.push(...args);
+              unknown.push(arg, ...args.slice(i));
               break;
             }
           }
           if (this._passThroughOptions) {
-            dest.push(arg);
-            if (args.length > 0)
-              dest.push(...args);
+            dest.push(arg, ...args.slice(i));
             break;
           }
           dest.push(arg);
@@ -2256,7 +2796,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
       /**
        * Return an object containing local option values as key-value pairs.
        *
-       * @return {Object}
+       * @return {object}
        */
       opts() {
         if (this._storeOptionsAsProperties) {
@@ -2273,10 +2813,10 @@ Expecting one of '${allowedValues.join("', '")}'`);
       /**
        * Return an object containing merged local and global option values as key-value pairs.
        *
-       * @return {Object}
+       * @return {object}
        */
       optsWithGlobals() {
-        return getCommandAndParents(this).reduce(
+        return this._getCommandAndAncestors().reduce(
           (combinedOptions, cmd) => Object.assign(combinedOptions, cmd.opts()),
           {}
         );
@@ -2285,13 +2825,16 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * Display error message and exit (or call exitOverride).
        *
        * @param {string} message
-       * @param {Object} [errorOptions]
+       * @param {object} [errorOptions]
        * @param {string} [errorOptions.code] - an id string representing the error
        * @param {number} [errorOptions.exitCode] - used with process.exit
        */
       error(message, errorOptions) {
-        this._outputConfiguration.outputError(`${message}
-`, this._outputConfiguration.writeErr);
+        this._outputConfiguration.outputError(
+          `${message}
+`,
+          this._outputConfiguration.writeErr
+        );
         if (typeof this._showHelpAfterError === "string") {
           this._outputConfiguration.writeErr(`${this._showHelpAfterError}
 `);
@@ -2308,13 +2851,15 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * Apply any option related environment variables, if option does
        * not have a value from cli or client code.
        *
-       * @api private
+       * @private
        */
       _parseOptionsEnv() {
         this.options.forEach((option) => {
           if (option.envVar && option.envVar in process2.env) {
             const optionKey = option.attributeName();
-            if (this.getOptionValue(optionKey) === void 0 || ["default", "config", "env"].includes(this.getOptionValueSource(optionKey))) {
+            if (this.getOptionValue(optionKey) === void 0 || ["default", "config", "env"].includes(
+              this.getOptionValueSource(optionKey)
+            )) {
               if (option.required || option.optional) {
                 this.emit(`optionEnv:${option.name()}`, process2.env[option.envVar]);
               } else {
@@ -2327,16 +2872,25 @@ Expecting one of '${allowedValues.join("', '")}'`);
       /**
        * Apply any implied option values, if option is undefined or default value.
        *
-       * @api private
+       * @private
        */
       _parseOptionsImplied() {
         const dualHelper = new DualOptions(this.options);
         const hasCustomOptionValue = (optionKey) => {
           return this.getOptionValue(optionKey) !== void 0 && !["default", "implied"].includes(this.getOptionValueSource(optionKey));
         };
-        this.options.filter((option) => option.implied !== void 0 && hasCustomOptionValue(option.attributeName()) && dualHelper.valueFromOption(this.getOptionValue(option.attributeName()), option)).forEach((option) => {
+        this.options.filter(
+          (option) => option.implied !== void 0 && hasCustomOptionValue(option.attributeName()) && dualHelper.valueFromOption(
+            this.getOptionValue(option.attributeName()),
+            option
+          )
+        ).forEach((option) => {
           Object.keys(option.implied).filter((impliedKey) => !hasCustomOptionValue(impliedKey)).forEach((impliedKey) => {
-            this.setOptionValueWithSource(impliedKey, option.implied[impliedKey], "implied");
+            this.setOptionValueWithSource(
+              impliedKey,
+              option.implied[impliedKey],
+              "implied"
+            );
           });
         });
       }
@@ -2344,7 +2898,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * Argument `name` is missing.
        *
        * @param {string} name
-       * @api private
+       * @private
        */
       missingArgument(name) {
         const message = `error: missing required argument '${name}'`;
@@ -2354,7 +2908,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * `Option` is missing an argument.
        *
        * @param {Option} option
-       * @api private
+       * @private
        */
       optionMissingArgument(option) {
         const message = `error: option '${option.flags}' argument missing`;
@@ -2364,7 +2918,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * `Option` does not have a value, and is a mandatory option.
        *
        * @param {Option} option
-       * @api private
+       * @private
        */
       missingMandatoryOptionValue(option) {
         const message = `error: required option '${option.flags}' not specified`;
@@ -2375,14 +2929,18 @@ Expecting one of '${allowedValues.join("', '")}'`);
        *
        * @param {Option} option
        * @param {Option} conflictingOption
-       * @api private
+       * @private
        */
       _conflictingOption(option, conflictingOption) {
         const findBestOptionFromValue = (option2) => {
           const optionKey = option2.attributeName();
           const optionValue = this.getOptionValue(optionKey);
-          const negativeOption = this.options.find((target) => target.negate && optionKey === target.attributeName());
-          const positiveOption = this.options.find((target) => !target.negate && optionKey === target.attributeName());
+          const negativeOption = this.options.find(
+            (target) => target.negate && optionKey === target.attributeName()
+          );
+          const positiveOption = this.options.find(
+            (target) => !target.negate && optionKey === target.attributeName()
+          );
           if (negativeOption && (negativeOption.presetArg === void 0 && optionValue === false || negativeOption.presetArg !== void 0 && optionValue === negativeOption.presetArg)) {
             return negativeOption;
           }
@@ -2404,11 +2962,10 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * Unknown option `flag`.
        *
        * @param {string} flag
-       * @api private
+       * @private
        */
       unknownOption(flag) {
-        if (this._allowUnknownOption)
-          return;
+        if (this._allowUnknownOption) return;
         let suggestion = "";
         if (flag.startsWith("--") && this._showSuggestionAfterError) {
           let candidateFlags = [];
@@ -2427,12 +2984,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * Excess arguments, more than expected.
        *
        * @param {string[]} receivedArgs
-       * @api private
+       * @private
        */
       _excessArguments(receivedArgs) {
-        if (this._allowExcessArguments)
-          return;
-        const expected = this._args.length;
+        if (this._allowExcessArguments) return;
+        const expected = this.registeredArguments.length;
         const s = expected === 1 ? "" : "s";
         const forSubcommand = this.parent ? ` for '${this.name()}'` : "";
         const message = `error: too many arguments${forSubcommand}. Expected ${expected} argument${s} but got ${receivedArgs.length}.`;
@@ -2441,7 +2997,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
       /**
        * Unknown command.
        *
-       * @api private
+       * @private
        */
       unknownCommand() {
         const unknownName = this.args[0];
@@ -2450,8 +3006,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           const candidateNames = [];
           this.createHelp().visibleCommands(this).forEach((command) => {
             candidateNames.push(command.name());
-            if (command.alias())
-              candidateNames.push(command.alias());
+            if (command.alias()) candidateNames.push(command.alias());
           });
           suggestion = suggestSimilar(unknownName, candidateNames);
         }
@@ -2459,27 +3014,25 @@ Expecting one of '${allowedValues.join("', '")}'`);
         this.error(message, { code: "commander.unknownCommand" });
       }
       /**
-       * Set the program version to `str`.
+       * Get or set the program version.
        *
-       * This method auto-registers the "-V, --version" flag
-       * which will print the version number when passed.
+       * This method auto-registers the "-V, --version" option which will print the version number.
        *
-       * You can optionally supply the  flags and description to override the defaults.
+       * You can optionally supply the flags and description to override the defaults.
        *
-       * @param {string} str
+       * @param {string} [str]
        * @param {string} [flags]
        * @param {string} [description]
-       * @return {this | string} `this` command for chaining, or version string if no arguments
+       * @return {(this | string | undefined)} `this` command for chaining, or version string if no arguments
        */
       version(str, flags, description) {
-        if (str === void 0)
-          return this._version;
+        if (str === void 0) return this._version;
         this._version = str;
         flags = flags || "-V, --version";
         description = description || "output the version number";
         const versionOption = this.createOption(flags, description);
         this._versionOptionName = versionOption.attributeName();
-        this.options.push(versionOption);
+        this._registerOption(versionOption);
         this.on("option:" + versionOption.name(), () => {
           this._outputConfiguration.writeOut(`${str}
 `);
@@ -2491,8 +3044,8 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * Set the description.
        *
        * @param {string} [str]
-       * @param {Object} [argsDescription]
-       * @return {string|Command}
+       * @param {object} [argsDescription]
+       * @return {(string|Command)}
        */
       description(str, argsDescription) {
         if (str === void 0 && argsDescription === void 0)
@@ -2507,11 +3060,10 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * Set the summary. Used when listed as subcommand of parent.
        *
        * @param {string} [str]
-       * @return {string|Command}
+       * @return {(string|Command)}
        */
       summary(str) {
-        if (str === void 0)
-          return this._summary;
+        if (str === void 0) return this._summary;
         this._summary = str;
         return this;
       }
@@ -2521,17 +3073,23 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * You may call more than once to add multiple aliases. Only the first alias is shown in the auto-generated help.
        *
        * @param {string} [alias]
-       * @return {string|Command}
+       * @return {(string|Command)}
        */
       alias(alias) {
-        if (alias === void 0)
-          return this._aliases[0];
+        if (alias === void 0) return this._aliases[0];
         let command = this;
         if (this.commands.length !== 0 && this.commands[this.commands.length - 1]._executableHandler) {
           command = this.commands[this.commands.length - 1];
         }
         if (alias === command._name)
           throw new Error("Command alias can't be the same as its name");
+        const matchingCommand = this.parent?._findCommand(alias);
+        if (matchingCommand) {
+          const existingCmd = [matchingCommand.name()].concat(matchingCommand.aliases()).join("|");
+          throw new Error(
+            `cannot add alias '${alias}' to command '${this.name()}' as already have command '${existingCmd}'`
+          );
+        }
         command._aliases.push(alias);
         return this;
       }
@@ -2541,11 +3099,10 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * Only the first alias is shown in the auto-generated help.
        *
        * @param {string[]} [aliases]
-       * @return {string[]|Command}
+       * @return {(string[]|Command)}
        */
       aliases(aliases) {
-        if (aliases === void 0)
-          return this._aliases;
+        if (aliases === void 0) return this._aliases;
         aliases.forEach((alias) => this.alias(alias));
         return this;
       }
@@ -2553,19 +3110,18 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * Set / get the command usage `str`.
        *
        * @param {string} [str]
-       * @return {String|Command}
+       * @return {(string|Command)}
        */
       usage(str) {
         if (str === void 0) {
-          if (this._usage)
-            return this._usage;
-          const args = this._args.map((arg) => {
+          if (this._usage) return this._usage;
+          const args = this.registeredArguments.map((arg) => {
             return humanReadableArgName(arg);
           });
           return [].concat(
-            this.options.length || this._hasHelpOption ? "[options]" : [],
+            this.options.length || this._helpOption !== null ? "[options]" : [],
             this.commands.length ? "[command]" : [],
-            this._args.length ? args : []
+            this.registeredArguments.length ? args : []
           ).join(" ");
         }
         this._usage = str;
@@ -2575,14 +3131,76 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * Get or set the name of the command.
        *
        * @param {string} [str]
-       * @return {string|Command}
+       * @return {(string|Command)}
        */
       name(str) {
-        if (str === void 0)
-          return this._name;
+        if (str === void 0) return this._name;
         this._name = str;
         return this;
       }
+      /**
+       * Set/get the help group heading for this subcommand in parent command's help.
+       *
+       * @param {string} [heading]
+       * @return {Command | string}
+       */
+      helpGroup(heading) {
+        if (heading === void 0) return this._helpGroupHeading ?? "";
+        this._helpGroupHeading = heading;
+        return this;
+      }
+      /**
+       * Set/get the default help group heading for subcommands added to this command.
+       * (This does not override a group set directly on the subcommand using .helpGroup().)
+       *
+       * @example
+       * program.commandsGroup('Development Commands:);
+       * program.command('watch')...
+       * program.command('lint')...
+       * ...
+       *
+       * @param {string} [heading]
+       * @returns {Command | string}
+       */
+      commandsGroup(heading) {
+        if (heading === void 0) return this._defaultCommandGroup ?? "";
+        this._defaultCommandGroup = heading;
+        return this;
+      }
+      /**
+       * Set/get the default help group heading for options added to this command.
+       * (This does not override a group set directly on the option using .helpGroup().)
+       *
+       * @example
+       * program
+       *   .optionsGroup('Development Options:')
+       *   .option('-d, --debug', 'output extra debugging')
+       *   .option('-p, --profile', 'output profiling information')
+       *
+       * @param {string} [heading]
+       * @returns {Command | string}
+       */
+      optionsGroup(heading) {
+        if (heading === void 0) return this._defaultOptionGroup ?? "";
+        this._defaultOptionGroup = heading;
+        return this;
+      }
+      /**
+       * @param {Option} option
+       * @private
+       */
+      _initOptionGroup(option) {
+        if (this._defaultOptionGroup && !option.helpGroupHeading)
+          option.helpGroup(this._defaultOptionGroup);
+      }
+      /**
+       * @param {Command} cmd
+       * @private
+       */
+      _initCommandGroup(cmd) {
+        if (this._defaultCommandGroup && !cmd.helpGroup())
+          cmd.helpGroup(this._defaultCommandGroup);
+      }
       /**
        * Set the name of the command from script filename, such as process.argv[1],
        * or require.main.filename, or __filename.
@@ -2596,7 +3214,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @return {Command}
        */
       nameFromFilename(filename) {
-        this._name = path.basename(filename, path.extname(filename));
+        this._name = path2.basename(filename, path2.extname(filename));
         return this;
       }
       /**
@@ -2608,12 +3226,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * program.executableDir('subcommands');
        *
        * @param {string} [path]
-       * @return {string|Command}
+       * @return {(string|null|Command)}
        */
-      executableDir(path2) {
-        if (path2 === void 0)
-          return this._executableDir;
-        this._executableDir = path2;
+      executableDir(path3) {
+        if (path3 === void 0) return this._executableDir;
+        this._executableDir = path3;
         return this;
       }
       /**
@@ -2624,26 +3241,47 @@ Expecting one of '${allowedValues.join("', '")}'`);
        */
       helpInformation(contextOptions) {
         const helper = this.createHelp();
-        if (helper.helpWidth === void 0) {
-          helper.helpWidth = contextOptions && contextOptions.error ? this._outputConfiguration.getErrHelpWidth() : this._outputConfiguration.getOutHelpWidth();
-        }
-        return helper.formatHelp(this, helper);
+        const context = this._getOutputContext(contextOptions);
+        helper.prepareContext({
+          error: context.error,
+          helpWidth: context.helpWidth,
+          outputHasColors: context.hasColors
+        });
+        const text = helper.formatHelp(this, helper);
+        if (context.hasColors) return text;
+        return this._outputConfiguration.stripColor(text);
       }
       /**
-       * @api private
+       * @typedef HelpContext
+       * @type {object}
+       * @property {boolean} error
+       * @property {number} helpWidth
+       * @property {boolean} hasColors
+       * @property {function} write - includes stripColor if needed
+       *
+       * @returns {HelpContext}
+       * @private
        */
-      _getHelpContext(contextOptions) {
+      _getOutputContext(contextOptions) {
         contextOptions = contextOptions || {};
-        const context = { error: !!contextOptions.error };
-        let write;
-        if (context.error) {
-          write = (arg) => this._outputConfiguration.writeErr(arg);
+        const error = !!contextOptions.error;
+        let baseWrite;
+        let hasColors;
+        let helpWidth;
+        if (error) {
+          baseWrite = (str) => this._outputConfiguration.writeErr(str);
+          hasColors = this._outputConfiguration.getErrHasColors();
+          helpWidth = this._outputConfiguration.getErrHelpWidth();
         } else {
-          write = (arg) => this._outputConfiguration.writeOut(arg);
+          baseWrite = (str) => this._outputConfiguration.writeOut(str);
+          hasColors = this._outputConfiguration.getOutHasColors();
+          helpWidth = this._outputConfiguration.getOutHelpWidth();
         }
-        context.write = contextOptions.write || write;
-        context.command = this;
-        return context;
+        const write = (str) => {
+          if (!hasColors) str = this._outputConfiguration.stripColor(str);
+          return baseWrite(str);
+        };
+        return { error, write, hasColors, helpWidth };
       }
       /**
        * Output help information for this command.
@@ -2658,40 +3296,84 @@ Expecting one of '${allowedValues.join("', '")}'`);
           deprecatedCallback = contextOptions;
           contextOptions = void 0;
         }
-        const context = this._getHelpContext(contextOptions);
-        getCommandAndParents(this).reverse().forEach((command) => command.emit("beforeAllHelp", context));
-        this.emit("beforeHelp", context);
-        let helpInformation = this.helpInformation(context);
+        const outputContext = this._getOutputContext(contextOptions);
+        const eventContext = {
+          error: outputContext.error,
+          write: outputContext.write,
+          command: this
+        };
+        this._getCommandAndAncestors().reverse().forEach((command) => command.emit("beforeAllHelp", eventContext));
+        this.emit("beforeHelp", eventContext);
+        let helpInformation = this.helpInformation({ error: outputContext.error });
         if (deprecatedCallback) {
           helpInformation = deprecatedCallback(helpInformation);
           if (typeof helpInformation !== "string" && !Buffer.isBuffer(helpInformation)) {
             throw new Error("outputHelp callback must return a string or a Buffer");
           }
         }
-        context.write(helpInformation);
-        this.emit(this._helpLongFlag);
-        this.emit("afterHelp", context);
-        getCommandAndParents(this).forEach((command) => command.emit("afterAllHelp", context));
+        outputContext.write(helpInformation);
+        if (this._getHelpOption()?.long) {
+          this.emit(this._getHelpOption().long);
+        }
+        this.emit("afterHelp", eventContext);
+        this._getCommandAndAncestors().forEach(
+          (command) => command.emit("afterAllHelp", eventContext)
+        );
       }
       /**
-       * You can pass in flags and a description to override the help
-       * flags and help description for your command. Pass in false to
-       * disable the built-in help option.
+       * You can pass in flags and a description to customise the built-in help option.
+       * Pass in false to disable the built-in help option.
+       *
+       * @example
+       * program.helpOption('-?, --help' 'show help'); // customise
+       * program.helpOption(false); // disable
        *
-       * @param {string | boolean} [flags]
+       * @param {(string | boolean)} flags
        * @param {string} [description]
        * @return {Command} `this` command for chaining
        */
       helpOption(flags, description) {
         if (typeof flags === "boolean") {
-          this._hasHelpOption = flags;
+          if (flags) {
+            if (this._helpOption === null) this._helpOption = void 0;
+            if (this._defaultOptionGroup) {
+              this._initOptionGroup(this._getHelpOption());
+            }
+          } else {
+            this._helpOption = null;
+          }
           return this;
         }
-        this._helpFlags = flags || this._helpFlags;
-        this._helpDescription = description || this._helpDescription;
-        const helpFlags = splitOptionFlags(this._helpFlags);
-        this._helpShortFlag = helpFlags.shortFlag;
-        this._helpLongFlag = helpFlags.longFlag;
+        this._helpOption = this.createOption(
+          flags ?? "-h, --help",
+          description ?? "display help for command"
+        );
+        if (flags || description) this._initOptionGroup(this._helpOption);
+        return this;
+      }
+      /**
+       * Lazy create help option.
+       * Returns null if has been disabled with .helpOption(false).
+       *
+       * @returns {(Option | null)} the help option
+       * @package
+       */
+      _getHelpOption() {
+        if (this._helpOption === void 0) {
+          this.helpOption(void 0, void 0);
+        }
+        return this._helpOption;
+      }
+      /**
+       * Supply your own option to use for the built-in help option.
+       * This is an alternative to using helpOption() to customise the flags and description etc.
+       *
+       * @param {Option} option
+       * @return {Command} `this` command for chaining
+       */
+      addHelpOption(option) {
+        this._helpOption = option;
+        this._initOptionGroup(option);
         return this;
       }
       /**
@@ -2703,12 +3385,20 @@ Expecting one of '${allowedValues.join("', '")}'`);
        */
       help(contextOptions) {
         this.outputHelp(contextOptions);
-        let exitCode = process2.exitCode || 0;
+        let exitCode = Number(process2.exitCode ?? 0);
         if (exitCode === 0 && contextOptions && typeof contextOptions !== "function" && contextOptions.error) {
           exitCode = 1;
         }
         this._exit(exitCode, "commander.help", "(outputHelp)");
       }
+      /**
+       * // Do a little typing to coordinate emit and listener for the help text events.
+       * @typedef HelpTextEventContext
+       * @type {object}
+       * @property {boolean} error
+       * @property {Command} command
+       * @property {function} write
+       */
       /**
        * Add additional text to be displayed with the built-in help.
        *
@@ -2716,7 +3406,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * and 'beforeAll' or 'afterAll' to affect this command and all its subcommands.
        *
        * @param {string} position - before or after built-in help
-       * @param {string | Function} text - string to add, or a function returning a string
+       * @param {(string | Function)} text - string to add, or a function returning a string
        * @return {Command} `this` command for chaining
        */
       addHelpText(position, text) {
@@ -2740,14 +3430,21 @@ Expecting one of '${allowedValues.join("', '")}'`);
         });
         return this;
       }
-    };
-    function outputHelpIfRequested(cmd, args) {
-      const helpOption = cmd._hasHelpOption && args.find((arg) => arg === cmd._helpLongFlag || arg === cmd._helpShortFlag);
-      if (helpOption) {
-        cmd.outputHelp();
-        cmd._exit(0, "commander.helpDisplayed", "(outputHelp)");
+      /**
+       * Output help information if help flags specified
+       *
+       * @param {Array} args - array of options to search for help flags
+       * @private
+       */
+      _outputHelpIfRequested(args) {
+        const helpOption = this._getHelpOption();
+        const helpRequested = helpOption && args.find((arg) => helpOption.is(arg));
+        if (helpRequested) {
+          this.outputHelp();
+          this._exit(0, "commander.helpDisplayed", "(outputHelp)");
+        }
       }
-    }
+    };
     function incrementNodeInspectorPort(args) {
       return args.map((arg) => {
         if (!arg.startsWith("--inspect")) {
@@ -2777,42 +3474,809 @@ Expecting one of '${allowedValues.join("', '")}'`);
         return arg;
       });
     }
-    function getCommandAndParents(startCommand) {
-      const result = [];
-      for (let command = startCommand; command; command = command.parent) {
-        result.push(command);
-      }
-      return result;
+    function useColor() {
+      if (process2.env.NO_COLOR || process2.env.FORCE_COLOR === "0" || process2.env.FORCE_COLOR === "false")
+        return false;
+      if (process2.env.FORCE_COLOR || process2.env.CLICOLOR_FORCE !== void 0)
+        return true;
+      return void 0;
     }
-    exports.Command = Command2;
+    exports2.Command = Command2;
+    exports2.useColor = useColor;
   }
 });
 
-// node_modules/commander/index.js
+// node_modules/.pnpm/commander@14.0.3/node_modules/commander/index.js
 var require_commander = __commonJS({
-  "node_modules/commander/index.js"(exports, module2) {
+  "node_modules/.pnpm/commander@14.0.3/node_modules/commander/index.js"(exports2) {
     var { Argument: Argument2 } = require_argument();
     var { Command: Command2 } = require_command();
     var { CommanderError: CommanderError2, InvalidArgumentError: InvalidArgumentError2 } = require_error();
     var { Help: Help2 } = require_help();
     var { Option: Option2 } = require_option();
-    exports = module2.exports = new Command2();
-    exports.program = exports;
-    exports.Argument = Argument2;
-    exports.Command = Command2;
-    exports.CommanderError = CommanderError2;
-    exports.Help = Help2;
-    exports.InvalidArgumentError = InvalidArgumentError2;
-    exports.InvalidOptionArgumentError = InvalidArgumentError2;
-    exports.Option = Option2;
+    exports2.program = new Command2();
+    exports2.createCommand = (name) => new Command2(name);
+    exports2.createOption = (flags, description) => new Option2(flags, description);
+    exports2.createArgument = (name, description) => new Argument2(name, description);
+    exports2.Command = Command2;
+    exports2.Option = Option2;
+    exports2.Argument = Argument2;
+    exports2.Help = Help2;
+    exports2.CommanderError = CommanderError2;
+    exports2.InvalidArgumentError = InvalidArgumentError2;
+    exports2.InvalidOptionArgumentError = InvalidArgumentError2;
   }
 });
 
+// node_modules/.pnpm/@clack+core@1.3.0/node_modules/@clack/core/dist/index.mjs
+var import_node_process = require("node:process");
+var import_node_readline = __toESM(require("node:readline"), 1);
+
+// node_modules/.pnpm/fast-string-truncated-width@3.0.3/node_modules/fast-string-truncated-width/dist/utils.js
+var getCodePointsLength = /* @__PURE__ */ (() => {
+  const SURROGATE_PAIR_RE = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
+  return (input) => {
+    let surrogatePairsNr = 0;
+    SURROGATE_PAIR_RE.lastIndex = 0;
+    while (SURROGATE_PAIR_RE.test(input)) {
+      surrogatePairsNr += 1;
+    }
+    return input.length - surrogatePairsNr;
+  };
+})();
+var isFullWidth = (x) => {
+  return x === 12288 || x >= 65281 && x <= 65376 || x >= 65504 && x <= 65510;
+};
+var isWideNotCJKTNotEmoji = (x) => {
+  return x === 8987 || x === 9001 || x >= 12272 && x <= 12287 || x >= 12289 && x <= 12350 || x >= 12441 && x <= 12543 || x >= 12549 && x <= 12591 || x >= 12593 && x <= 12686 || x >= 12688 && x <= 12771 || x >= 12783 && x <= 12830 || x >= 12832 && x <= 12871 || x >= 12880 && x <= 19903 || x >= 65040 && x <= 65049 || x >= 65072 && x <= 65106 || x >= 65108 && x <= 65126 || x >= 65128 && x <= 65131 || x >= 127488 && x <= 127490 || x >= 127504 && x <= 127547 || x >= 127552 && x <= 127560 || x >= 131072 && x <= 196605 || x >= 196608 && x <= 262141;
+};
+
+// node_modules/.pnpm/fast-string-truncated-width@3.0.3/node_modules/fast-string-truncated-width/dist/index.js
+var ANSI_RE = /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]|\u001b\]8;[^;]*;.*?(?:\u0007|\u001b\u005c)/y;
+var CONTROL_RE = /[\x00-\x08\x0A-\x1F\x7F-\x9F]{1,1000}/y;
+var CJKT_WIDE_RE = /(?:(?![\uFF61-\uFF9F\uFF00-\uFFEF])[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}\p{Script=Tangut}]){1,1000}/yu;
+var TAB_RE = /\t{1,1000}/y;
+var EMOJI_RE = new RegExp("[\\u{1F1E6}-\\u{1F1FF}]{2}|\\u{1F3F4}[\\u{E0061}-\\u{E007A}]{2}[\\u{E0030}-\\u{E0039}\\u{E0061}-\\u{E007A}]{1,3}\\u{E007F}|(?:\\p{Emoji}\\uFE0F\\u20E3?|\\p{Emoji_Modifier_Base}\\p{Emoji_Modifier}?|\\p{Emoji_Presentation})(?:\\u200D(?:\\p{Emoji_Modifier_Base}\\p{Emoji_Modifier}?|\\p{Emoji_Presentation}|\\p{Emoji}\\uFE0F\\u20E3?))*", "yu");
+var LATIN_RE = /(?:[\x20-\x7E\xA0-\xFF](?!\uFE0F)){1,1000}/y;
+var MODIFIER_RE = new RegExp("\\p{M}+", "gu");
+var NO_TRUNCATION = { limit: Infinity, ellipsis: "" };
+var getStringTruncatedWidth = (input, truncationOptions = {}, widthOptions = {}) => {
+  const LIMIT = truncationOptions.limit ?? Infinity;
+  const ELLIPSIS = truncationOptions.ellipsis ?? "";
+  const ELLIPSIS_WIDTH = truncationOptions?.ellipsisWidth ?? (ELLIPSIS ? getStringTruncatedWidth(ELLIPSIS, NO_TRUNCATION, widthOptions).width : 0);
+  const ANSI_WIDTH = 0;
+  const CONTROL_WIDTH = widthOptions.controlWidth ?? 0;
+  const TAB_WIDTH = widthOptions.tabWidth ?? 8;
+  const EMOJI_WIDTH = widthOptions.emojiWidth ?? 2;
+  const FULL_WIDTH_WIDTH = 2;
+  const REGULAR_WIDTH = widthOptions.regularWidth ?? 1;
+  const WIDE_WIDTH = widthOptions.wideWidth ?? FULL_WIDTH_WIDTH;
+  const PARSE_BLOCKS = [
+    [LATIN_RE, REGULAR_WIDTH],
+    [ANSI_RE, ANSI_WIDTH],
+    [CONTROL_RE, CONTROL_WIDTH],
+    [TAB_RE, TAB_WIDTH],
+    [EMOJI_RE, EMOJI_WIDTH],
+    [CJKT_WIDE_RE, WIDE_WIDTH]
+  ];
+  let indexPrev = 0;
+  let index = 0;
+  let length = input.length;
+  let lengthExtra = 0;
+  let truncationEnabled = false;
+  let truncationIndex = length;
+  let truncationLimit = Math.max(0, LIMIT - ELLIPSIS_WIDTH);
+  let unmatchedStart = 0;
+  let unmatchedEnd = 0;
+  let width = 0;
+  let widthExtra = 0;
+  outer: while (true) {
+    if (unmatchedEnd > unmatchedStart || index >= length && index > indexPrev) {
+      const unmatched = input.slice(unmatchedStart, unmatchedEnd) || input.slice(indexPrev, index);
+      lengthExtra = 0;
+      for (const char of unmatched.replaceAll(MODIFIER_RE, "")) {
+        const codePoint = char.codePointAt(0) || 0;
+        if (isFullWidth(codePoint)) {
+          widthExtra = FULL_WIDTH_WIDTH;
+        } else if (isWideNotCJKTNotEmoji(codePoint)) {
+          widthExtra = WIDE_WIDTH;
+        } else {
+          widthExtra = REGULAR_WIDTH;
+        }
+        if (width + widthExtra > truncationLimit) {
+          truncationIndex = Math.min(truncationIndex, Math.max(unmatchedStart, indexPrev) + lengthExtra);
+        }
+        if (width + widthExtra > LIMIT) {
+          truncationEnabled = true;
+          break outer;
+        }
+        lengthExtra += char.length;
+        width += widthExtra;
+      }
+      unmatchedStart = unmatchedEnd = 0;
+    }
+    if (index >= length) {
+      break outer;
+    }
+    for (let i = 0, l = PARSE_BLOCKS.length; i < l; i++) {
+      const [BLOCK_RE, BLOCK_WIDTH] = PARSE_BLOCKS[i];
+      BLOCK_RE.lastIndex = index;
+      if (BLOCK_RE.test(input)) {
+        lengthExtra = BLOCK_RE === CJKT_WIDE_RE ? getCodePointsLength(input.slice(index, BLOCK_RE.lastIndex)) : BLOCK_RE === EMOJI_RE ? 1 : BLOCK_RE.lastIndex - index;
+        widthExtra = lengthExtra * BLOCK_WIDTH;
+        if (width + widthExtra > truncationLimit) {
+          truncationIndex = Math.min(truncationIndex, index + Math.floor((truncationLimit - width) / BLOCK_WIDTH));
+        }
+        if (width + widthExtra > LIMIT) {
+          truncationEnabled = true;
+          break outer;
+        }
+        width += widthExtra;
+        unmatchedStart = indexPrev;
+        unmatchedEnd = index;
+        index = indexPrev = BLOCK_RE.lastIndex;
+        continue outer;
+      }
+    }
+    index += 1;
+  }
+  return {
+    width: truncationEnabled ? truncationLimit : width,
+    index: truncationEnabled ? truncationIndex : length,
+    truncated: truncationEnabled,
+    ellipsed: truncationEnabled && LIMIT >= ELLIPSIS_WIDTH
+  };
+};
+var dist_default = getStringTruncatedWidth;
+
+// node_modules/.pnpm/fast-string-width@3.0.2/node_modules/fast-string-width/dist/index.js
+var NO_TRUNCATION2 = {
+  limit: Infinity,
+  ellipsis: "",
+  ellipsisWidth: 0
+};
+var fastStringWidth = (input, options = {}) => {
+  return dist_default(input, NO_TRUNCATION2, options).width;
+};
+var dist_default2 = fastStringWidth;
+
+// node_modules/.pnpm/fast-wrap-ansi@0.2.0/node_modules/fast-wrap-ansi/lib/main.js
+var ESC = "\x1B";
+var CSI = "\x9B";
+var END_CODE = 39;
+var ANSI_ESCAPE_BELL = "\x07";
+var ANSI_CSI = "[";
+var ANSI_OSC = "]";
+var ANSI_SGR_TERMINATOR = "m";
+var ANSI_ESCAPE_LINK = `${ANSI_OSC}8;;`;
+var GROUP_REGEX = new RegExp(`(?:\\${ANSI_CSI}(?<code>\\d+)m|\\${ANSI_ESCAPE_LINK}(?<uri>.*)${ANSI_ESCAPE_BELL})`, "y");
+var getClosingCode = (openingCode) => {
+  if (openingCode >= 30 && openingCode <= 37)
+    return 39;
+  if (openingCode >= 90 && openingCode <= 97)
+    return 39;
+  if (openingCode >= 40 && openingCode <= 47)
+    return 49;
+  if (openingCode >= 100 && openingCode <= 107)
+    return 49;
+  if (openingCode === 1 || openingCode === 2)
+    return 22;
+  if (openingCode === 3)
+    return 23;
+  if (openingCode === 4)
+    return 24;
+  if (openingCode === 7)
+    return 27;
+  if (openingCode === 8)
+    return 28;
+  if (openingCode === 9)
+    return 29;
+  if (openingCode === 0)
+    return 0;
+  return void 0;
+};
+var wrapAnsiCode = (code) => `${ESC}${ANSI_CSI}${code}${ANSI_SGR_TERMINATOR}`;
+var wrapAnsiHyperlink = (url) => `${ESC}${ANSI_ESCAPE_LINK}${url}${ANSI_ESCAPE_BELL}`;
+var wrapWord = (rows, word, columns) => {
+  const characters = word[Symbol.iterator]();
+  let isInsideEscape = false;
+  let isInsideLinkEscape = false;
+  let lastRow = rows.at(-1);
+  let visible = lastRow === void 0 ? 0 : dist_default2(lastRow);
+  let currentCharacter = characters.next();
+  let nextCharacter = characters.next();
+  let rawCharacterIndex = 0;
+  while (!currentCharacter.done) {
+    const character = currentCharacter.value;
+    const characterLength = dist_default2(character);
+    if (visible + characterLength <= columns) {
+      rows[rows.length - 1] += character;
+    } else {
+      rows.push(character);
+      visible = 0;
+    }
+    if (character === ESC || character === CSI) {
+      isInsideEscape = true;
+      isInsideLinkEscape = word.startsWith(ANSI_ESCAPE_LINK, rawCharacterIndex + 1);
+    }
+    if (isInsideEscape) {
+      if (isInsideLinkEscape) {
+        if (character === ANSI_ESCAPE_BELL) {
+          isInsideEscape = false;
+          isInsideLinkEscape = false;
+        }
+      } else if (character === ANSI_SGR_TERMINATOR) {
+        isInsideEscape = false;
+      }
+    } else {
+      visible += characterLength;
+      if (visible === columns && !nextCharacter.done) {
+        rows.push("");
+        visible = 0;
+      }
+    }
+    currentCharacter = nextCharacter;
+    nextCharacter = characters.next();
+    rawCharacterIndex += character.length;
+  }
+  lastRow = rows.at(-1);
+  if (!visible && lastRow !== void 0 && lastRow.length && rows.length > 1) {
+    rows[rows.length - 2] += rows.pop();
+  }
+};
+var stringVisibleTrimSpacesRight = (string) => {
+  const words = string.split(" ");
+  let last = words.length;
+  while (last) {
+    if (dist_default2(words[last - 1])) {
+      break;
+    }
+    last--;
+  }
+  if (last === words.length) {
+    return string;
+  }
+  return words.slice(0, last).join(" ") + words.slice(last).join("");
+};
+var exec = (string, columns, options = {}) => {
+  if (options.trim !== false && string.trim() === "") {
+    return "";
+  }
+  let returnValue = "";
+  let escapeCode;
+  let escapeUrl;
+  const words = string.split(" ");
+  let rows = [""];
+  let rowLength = 0;
+  for (let index = 0; index < words.length; index++) {
+    const word = words[index];
+    if (options.trim !== false) {
+      const row = rows.at(-1) ?? "";
+      const trimmed = row.trimStart();
+      if (row.length !== trimmed.length) {
+        rows[rows.length - 1] = trimmed;
+        rowLength = dist_default2(trimmed);
+      }
+    }
+    if (index !== 0) {
+      if (rowLength >= columns && (options.wordWrap === false || options.trim === false)) {
+        rows.push("");
+        rowLength = 0;
+      }
+      if (rowLength || options.trim === false) {
+        rows[rows.length - 1] += " ";
+        rowLength++;
+      }
+    }
+    const wordLength = dist_default2(word);
+    if (options.hard && wordLength > columns) {
+      const remainingColumns = columns - rowLength;
+      const breaksStartingThisLine = 1 + Math.floor((wordLength - remainingColumns - 1) / columns);
+      const breaksStartingNextLine = Math.floor((wordLength - 1) / columns);
+      if (breaksStartingNextLine < breaksStartingThisLine) {
+        rows.push("");
+      }
+      wrapWord(rows, word, columns);
+      rowLength = dist_default2(rows.at(-1) ?? "");
+      continue;
+    }
+    if (rowLength + wordLength > columns && rowLength && wordLength) {
+      if (options.wordWrap === false && rowLength < columns) {
+        wrapWord(rows, word, columns);
+        rowLength = dist_default2(rows.at(-1) ?? "");
+        continue;
+      }
+      rows.push("");
+      rowLength = 0;
+    }
+    if (rowLength + wordLength > columns && options.wordWrap === false) {
+      wrapWord(rows, word, columns);
+      rowLength = dist_default2(rows.at(-1) ?? "");
+      continue;
+    }
+    rows[rows.length - 1] += word;
+    rowLength += wordLength;
+  }
+  if (options.trim !== false) {
+    rows = rows.map((row) => stringVisibleTrimSpacesRight(row));
+  }
+  const preString = rows.join("\n");
+  let inSurrogate = false;
+  for (let i = 0; i < preString.length; i++) {
+    const character = preString[i];
+    returnValue += character;
+    if (!inSurrogate) {
+      inSurrogate = character >= "\uD800" && character <= "\uDBFF";
+      if (inSurrogate) {
+        continue;
+      }
+    } else {
+      inSurrogate = false;
+    }
+    if (character === ESC || character === CSI) {
+      GROUP_REGEX.lastIndex = i + 1;
+      const groupsResult = GROUP_REGEX.exec(preString);
+      const groups = groupsResult?.groups;
+      if (groups?.code !== void 0) {
+        const code = Number.parseFloat(groups.code);
+        escapeCode = code === END_CODE ? void 0 : code;
+      } else if (groups?.uri !== void 0) {
+        escapeUrl = groups.uri.length === 0 ? void 0 : groups.uri;
+      }
+    }
+    if (preString[i + 1] === "\n") {
+      if (escapeUrl) {
+        returnValue += wrapAnsiHyperlink("");
+      }
+      const closingCode = escapeCode ? getClosingCode(escapeCode) : void 0;
+      if (escapeCode && closingCode) {
+        returnValue += wrapAnsiCode(closingCode);
+      }
+    } else if (character === "\n") {
+      if (escapeCode && getClosingCode(escapeCode)) {
+        returnValue += wrapAnsiCode(escapeCode);
+      }
+      if (escapeUrl) {
+        returnValue += wrapAnsiHyperlink(escapeUrl);
+      }
+    }
+  }
+  return returnValue;
+};
+var CRLF_OR_LF = /\r?\n/;
+function wrapAnsi(string, columns, options) {
+  return String(string).normalize().split(CRLF_OR_LF).map((line) => exec(line, columns, options)).join("\n");
+}
+
+// node_modules/.pnpm/@clack+core@1.3.0/node_modules/@clack/core/dist/index.mjs
+var import_sisteransi = __toESM(require_src(), 1);
+function d(r, t, s) {
+  if (!s.some((o) => !o.disabled)) return r;
+  const e2 = r + t, i = Math.max(s.length - 1, 0), n = e2 < 0 ? i : e2 > i ? 0 : e2;
+  return s[n].disabled ? d(n, t < 0 ? -1 : 1, s) : n;
+}
+var G = ["up", "down", "left", "right", "space", "enter", "cancel"];
+var K = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"];
+var h = { actions: new Set(G), aliases: /* @__PURE__ */ new Map([["k", "up"], ["j", "down"], ["h", "left"], ["l", "right"], ["", "cancel"], ["escape", "cancel"]]), messages: { cancel: "Canceled", error: "Something went wrong" }, withGuide: true, date: { monthNames: [...K], messages: { required: "Please enter a valid date", invalidMonth: "There are only 12 months in a year", invalidDay: (r, t) => `There are only ${r} days in ${t}`, afterMin: (r) => `Date must be on or after ${r.toISOString().slice(0, 10)}`, beforeMax: (r) => `Date must be on or before ${r.toISOString().slice(0, 10)}` } } };
+function C(r, t) {
+  if (typeof r == "string") return h.aliases.get(r) === t;
+  for (const s of r) if (s !== void 0 && C(s, t)) return true;
+  return false;
+}
+function z(r, t) {
+  if (r === t) return;
+  const s = r.split(`
+`), e2 = t.split(`
+`), i = Math.max(s.length, e2.length), n = [];
+  for (let o = 0; o < i; o++) s[o] !== e2[o] && n.push(o);
+  return { lines: n, numLinesBefore: s.length, numLinesAfter: e2.length, numLines: i };
+}
+var Y = globalThis.process.platform.startsWith("win");
+var k = /* @__PURE__ */ Symbol("clack:cancel");
+function q(r) {
+  return r === k;
+}
+function w(r, t) {
+  const s = r;
+  s.isTTY && s.setRawMode(t);
+}
+var A = (r) => "columns" in r && typeof r.columns == "number" ? r.columns : 80;
+var L = (r) => "rows" in r && typeof r.rows == "number" ? r.rows : 20;
+function W(r, t, s, e2 = s, i) {
+  const n = A(r ?? import_node_process.stdout);
+  return wrapAnsi(t, n - s.length, { hard: true, trim: false }).split(`
+`).map((o, u) => {
+    const a = i ? i(o, u) : o;
+    return `${u === 0 ? e2 : s}${a}`;
+  }).join(`
+`);
+}
+var p = class {
+  input;
+  output;
+  _abortSignal;
+  rl;
+  opts;
+  _render;
+  _track = false;
+  _prevFrame = "";
+  _subscribers = /* @__PURE__ */ new Map();
+  _cursor = 0;
+  state = "initial";
+  error = "";
+  value;
+  userInput = "";
+  constructor(t, s = true) {
+    const { input: e2 = import_node_process.stdin, output: i = import_node_process.stdout, render: n, signal: o, ...u } = t;
+    this.opts = u, this.onKeypress = this.onKeypress.bind(this), this.close = this.close.bind(this), this.render = this.render.bind(this), this._render = n.bind(this), this._track = s, this._abortSignal = o, this.input = e2, this.output = i;
+  }
+  unsubscribe() {
+    this._subscribers.clear();
+  }
+  setSubscriber(t, s) {
+    const e2 = this._subscribers.get(t) ?? [];
+    e2.push(s), this._subscribers.set(t, e2);
+  }
+  on(t, s) {
+    this.setSubscriber(t, { cb: s });
+  }
+  once(t, s) {
+    this.setSubscriber(t, { cb: s, once: true });
+  }
+  emit(t, ...s) {
+    const e2 = this._subscribers.get(t) ?? [], i = [];
+    for (const n of e2) n.cb(...s), n.once && i.push(() => e2.splice(e2.indexOf(n), 1));
+    for (const n of i) n();
+  }
+  prompt() {
+    return new Promise((t) => {
+      if (this._abortSignal) {
+        if (this._abortSignal.aborted) return this.state = "cancel", this.close(), t(k);
+        this._abortSignal.addEventListener("abort", () => {
+          this.state = "cancel", this.close();
+        }, { once: true });
+      }
+      this.rl = import_node_readline.default.createInterface({ input: this.input, tabSize: 2, prompt: "", escapeCodeTimeout: 50, terminal: true }), this.rl.prompt(), this.opts.initialUserInput !== void 0 && this._setUserInput(this.opts.initialUserInput, true), this.input.on("keypress", this.onKeypress), w(this.input, true), this.output.on("resize", this.render), this.render(), this.once("submit", () => {
+        this.output.write(import_sisteransi.cursor.show), this.output.off("resize", this.render), w(this.input, false), t(this.value);
+      }), this.once("cancel", () => {
+        this.output.write(import_sisteransi.cursor.show), this.output.off("resize", this.render), w(this.input, false), t(k);
+      });
+    });
+  }
+  _isActionKey(t, s) {
+    return t === "	";
+  }
+  _shouldSubmit(t, s) {
+    return true;
+  }
+  _setValue(t) {
+    this.value = t, this.emit("value", this.value);
+  }
+  _setUserInput(t, s) {
+    this.userInput = t ?? "", this.emit("userInput", this.userInput), s && this._track && this.rl && (this.rl.write(this.userInput), this._cursor = this.rl.cursor);
+  }
+  _clearUserInput() {
+    this.rl?.write(null, { ctrl: true, name: "u" }), this._setUserInput("");
+  }
+  onKeypress(t, s) {
+    if (this._track && s.name !== "return" && (s.name && this._isActionKey(t, s) && this.rl?.write(null, { ctrl: true, name: "h" }), this._cursor = this.rl?.cursor ?? 0, this._setUserInput(this.rl?.line)), this.state === "error" && (this.state = "active"), s?.name && (!this._track && h.aliases.has(s.name) && this.emit("cursor", h.aliases.get(s.name)), h.actions.has(s.name) && this.emit("cursor", s.name)), t && (t.toLowerCase() === "y" || t.toLowerCase() === "n") && this.emit("confirm", t.toLowerCase() === "y"), this.emit("key", t?.toLowerCase(), s), s?.name === "return" && this._shouldSubmit(t, s)) {
+      if (this.opts.validate) {
+        const e2 = this.opts.validate(this.value);
+        e2 && (this.error = e2 instanceof Error ? e2.message : e2, this.state = "error", this.rl?.write(this.userInput));
+      }
+      this.state !== "error" && (this.state = "submit");
+    }
+    C([t, s?.name, s?.sequence], "cancel") && (this.state = "cancel"), (this.state === "submit" || this.state === "cancel") && this.emit("finalize"), this.render(), (this.state === "submit" || this.state === "cancel") && this.close();
+  }
+  close() {
+    this.input.unpipe(), this.input.removeListener("keypress", this.onKeypress), this.output.write(`
+`), w(this.input, false), this.rl?.close(), this.rl = void 0, this.emit(`${this.state}`, this.value), this.unsubscribe();
+  }
+  restoreCursor() {
+    const t = wrapAnsi(this._prevFrame, process.stdout.columns, { hard: true, trim: false }).split(`
+`).length - 1;
+    this.output.write(import_sisteransi.cursor.move(-999, t * -1));
+  }
+  render() {
+    const t = wrapAnsi(this._render(this) ?? "", process.stdout.columns, { hard: true, trim: false });
+    if (t !== this._prevFrame) {
+      if (this.state === "initial") this.output.write(import_sisteransi.cursor.hide);
+      else {
+        const s = z(this._prevFrame, t), e2 = L(this.output);
+        if (this.restoreCursor(), s) {
+          const i = Math.max(0, s.numLinesAfter - e2), n = Math.max(0, s.numLinesBefore - e2);
+          let o = s.lines.find((u) => u >= i);
+          if (o === void 0) {
+            this._prevFrame = t;
+            return;
+          }
+          if (s.lines.length === 1) {
+            this.output.write(import_sisteransi.cursor.move(0, o - n)), this.output.write(import_sisteransi.erase.lines(1));
+            const u = t.split(`
+`);
+            this.output.write(u[o]), this._prevFrame = t, this.output.write(import_sisteransi.cursor.move(0, u.length - o - 1));
+            return;
+          } else if (s.lines.length > 1) {
+            if (i < n) o = i;
+            else {
+              const a = o - n;
+              a > 0 && this.output.write(import_sisteransi.cursor.move(0, a));
+            }
+            this.output.write(import_sisteransi.erase.down());
+            const u = t.split(`
+`).slice(o);
+            this.output.write(u.join(`
+`)), this._prevFrame = t;
+            return;
+          }
+        }
+        this.output.write(import_sisteransi.erase.down());
+      }
+      this.output.write(t), this.state === "initial" && (this.state = "active"), this._prevFrame = t;
+    }
+  }
+};
+var X = class extends p {
+  get cursor() {
+    return this.value ? 0 : 1;
+  }
+  get _value() {
+    return this.cursor === 0;
+  }
+  constructor(t) {
+    super(t, false), this.value = !!t.initialValue, this.on("userInput", () => {
+      this.value = this._value;
+    }), this.on("confirm", (s) => {
+      this.output.write(import_sisteransi.cursor.move(0, -1)), this.value = s, this.state = "submit", this.close();
+    }), this.on("cursor", () => {
+      this.value = !this.value;
+    });
+  }
+};
+var nt = class extends p {
+  options;
+  cursor = 0;
+  get _value() {
+    return this.options[this.cursor].value;
+  }
+  get _enabledOptions() {
+    return this.options.filter((t) => t.disabled !== true);
+  }
+  toggleAll() {
+    const t = this._enabledOptions, s = this.value !== void 0 && this.value.length === t.length;
+    this.value = s ? [] : t.map((e2) => e2.value);
+  }
+  toggleInvert() {
+    const t = this.value;
+    if (!t) return;
+    const s = this._enabledOptions.filter((e2) => !t.includes(e2.value));
+    this.value = s.map((e2) => e2.value);
+  }
+  toggleValue() {
+    this.value === void 0 && (this.value = []);
+    const t = this.value.includes(this._value);
+    this.value = t ? this.value.filter((s) => s !== this._value) : [...this.value, this._value];
+  }
+  constructor(t) {
+    super(t, false), this.options = t.options, this.value = [...t.initialValues ?? []];
+    const s = Math.max(this.options.findIndex(({ value: e2 }) => e2 === t.cursorAt), 0);
+    this.cursor = this.options[s].disabled ? d(s, 1, this.options) : s, this.on("key", (e2) => {
+      e2 === "a" && this.toggleAll(), e2 === "i" && this.toggleInvert();
+    }), this.on("cursor", (e2) => {
+      switch (e2) {
+        case "left":
+        case "up":
+          this.cursor = d(this.cursor, -1, this.options);
+          break;
+        case "down":
+        case "right":
+          this.cursor = d(this.cursor, 1, this.options);
+          break;
+        case "space":
+          this.toggleValue();
+          break;
+      }
+    });
+  }
+};
+
+// node_modules/.pnpm/@clack+prompts@1.3.0/node_modules/@clack/prompts/dist/index.mjs
+var import_node_util = require("node:util");
+var import_node_process2 = __toESM(require("node:process"), 1);
+var import_sisteransi2 = __toESM(require_src(), 1);
+function te() {
+  return import_node_process2.default.platform !== "win32" ? import_node_process2.default.env.TERM !== "linux" : !!import_node_process2.default.env.CI || !!import_node_process2.default.env.WT_SESSION || !!import_node_process2.default.env.TERMINUS_SUBLIME || import_node_process2.default.env.ConEmuTask === "{cmd::Cmder}" || import_node_process2.default.env.TERM_PROGRAM === "Terminus-Sublime" || import_node_process2.default.env.TERM_PROGRAM === "vscode" || import_node_process2.default.env.TERM === "xterm-256color" || import_node_process2.default.env.TERM === "alacritty" || import_node_process2.default.env.TERMINAL_EMULATOR === "JetBrains-JediTerm";
+}
+var tt = te();
+var w2 = (t, r) => tt ? t : r;
+var _t = w2("\u25C6", "*");
+var ot2 = w2("\u25A0", "x");
+var ut2 = w2("\u25B2", "x");
+var F = w2("\u25C7", "o");
+var lt = w2("\u250C", "T");
+var $ = w2("\u2502", "|");
+var E2 = w2("\u2514", "\u2014");
+var It = w2("\u2510", "T");
+var Et = w2("\u2518", "\u2014");
+var z2 = w2("\u25CF", ">");
+var H = w2("\u25CB", " ");
+var et2 = w2("\u25FB", "[\u2022]");
+var U = w2("\u25FC", "[+]");
+var J = w2("\u25FB", "[ ]");
+var Gt = w2("\u25AA", "\u2022");
+var st = w2("\u2500", "-");
+var ct = w2("\u256E", "+");
+var xt = w2("\u251C", "+");
+var $t = w2("\u256F", "+");
+var dt = w2("\u2570", "+");
+var Ot = w2("\u256D", "+");
+var ht2 = w2("\u25CF", "\u2022");
+var pt = w2("\u25C6", "*");
+var mt = w2("\u25B2", "!");
+var gt = w2("\u25A0", "x");
+var M = (t) => {
+  switch (t) {
+    case "initial":
+    case "active":
+      return (0, import_node_util.styleText)("cyan", _t);
+    case "cancel":
+      return (0, import_node_util.styleText)("red", ot2);
+    case "error":
+      return (0, import_node_util.styleText)("yellow", ut2);
+    case "submit":
+      return (0, import_node_util.styleText)("green", F);
+  }
+};
+var yt = (t) => {
+  switch (t) {
+    case "initial":
+    case "active":
+      return (0, import_node_util.styleText)("cyan", $);
+    case "cancel":
+      return (0, import_node_util.styleText)("red", $);
+    case "error":
+      return (0, import_node_util.styleText)("yellow", $);
+    case "submit":
+      return (0, import_node_util.styleText)("green", $);
+  }
+};
+var ee = (t, r, s, i, u) => {
+  let n = r, o = 0;
+  for (let c2 = s; c2 < i; c2++) {
+    const a = t[c2];
+    if (n = n - a.length, o++, n <= u) break;
+  }
+  return { lineCount: n, removals: o };
+};
+var Y2 = ({ cursor: t, options: r, style: s, output: i = process.stdout, maxItems: u = Number.POSITIVE_INFINITY, columnPadding: n = 0, rowPadding: o = 4 }) => {
+  const c2 = A(i) - n, a = L(i), l = (0, import_node_util.styleText)("dim", "..."), d2 = Math.max(a - o, 0), y = Math.max(Math.min(u, d2), 5);
+  let p2 = 0;
+  t >= y - 3 && (p2 = Math.max(Math.min(t - y + 3, r.length - y), 0));
+  let m = y < r.length && p2 > 0, g = y < r.length && p2 + y < r.length;
+  const S2 = Math.min(p2 + y, r.length), h2 = [];
+  let f = 0;
+  m && f++, g && f++;
+  const v = p2 + (m ? 1 : 0), T = S2 - (g ? 1 : 0);
+  for (let b = v; b < T; b++) {
+    const G2 = wrapAnsi(s(r[b], b === t), c2, { hard: true, trim: false }).split(`
+`);
+    h2.push(G2), f += G2.length;
+  }
+  if (f > d2) {
+    let b = 0, G2 = 0, x = f;
+    const A2 = t - v, P = (N, D2) => ee(h2, x, N, D2, d2);
+    m ? ({ lineCount: x, removals: b } = P(0, A2), x > d2 && ({ lineCount: x, removals: G2 } = P(A2 + 1, h2.length))) : ({ lineCount: x, removals: G2 } = P(A2 + 1, h2.length), x > d2 && ({ lineCount: x, removals: b } = P(0, A2))), b > 0 && (m = true, h2.splice(0, b)), G2 > 0 && (g = true, h2.splice(h2.length - G2, G2));
+  }
+  const C2 = [];
+  m && C2.push(l);
+  for (const b of h2) for (const G2 of b) C2.push(G2);
+  return g && C2.push(l), C2;
+};
+var ue = (t) => {
+  const r = t.active ?? "Yes", s = t.inactive ?? "No";
+  return new X({ active: r, inactive: s, signal: t.signal, input: t.input, output: t.output, initialValue: t.initialValue ?? true, render() {
+    const i = t.withGuide ?? h.withGuide, u = `${M(this.state)}  `, n = i ? `${(0, import_node_util.styleText)("gray", $)}  ` : "", o = W(t.output, t.message, n, u), c2 = `${i ? `${(0, import_node_util.styleText)("gray", $)}
+` : ""}${o}
+`, a = this.value ? r : s;
+    switch (this.state) {
+      case "submit": {
+        const l = i ? `${(0, import_node_util.styleText)("gray", $)}  ` : "";
+        return `${c2}${l}${(0, import_node_util.styleText)("dim", a)}`;
+      }
+      case "cancel": {
+        const l = i ? `${(0, import_node_util.styleText)("gray", $)}  ` : "";
+        return `${c2}${l}${(0, import_node_util.styleText)(["strikethrough", "dim"], a)}${i ? `
+${(0, import_node_util.styleText)("gray", $)}` : ""}`;
+      }
+      default: {
+        const l = i ? `${(0, import_node_util.styleText)("cyan", $)}  ` : "", d2 = i ? (0, import_node_util.styleText)("cyan", E2) : "";
+        return `${c2}${l}${this.value ? `${(0, import_node_util.styleText)("green", z2)} ${r}` : `${(0, import_node_util.styleText)("dim", H)} ${(0, import_node_util.styleText)("dim", r)}`}${t.vertical ? i ? `
+${(0, import_node_util.styleText)("cyan", $)}  ` : `
+` : ` ${(0, import_node_util.styleText)("dim", "/")} `}${this.value ? `${(0, import_node_util.styleText)("dim", H)} ${(0, import_node_util.styleText)("dim", s)}` : `${(0, import_node_util.styleText)("green", z2)} ${s}`}
+${d2}
+`;
+      }
+    }
+  } }).prompt();
+};
+var me = (t = "", r) => {
+  const s = r?.output ?? process.stdout, i = r?.withGuide ?? h.withGuide ? `${(0, import_node_util.styleText)("gray", E2)}  ` : "";
+  s.write(`${i}${(0, import_node_util.styleText)("red", t)}
+
+`);
+};
+var ge = (t = "", r) => {
+  const s = r?.output ?? process.stdout, i = r?.withGuide ?? h.withGuide ? `${(0, import_node_util.styleText)("gray", lt)}  ` : "";
+  s.write(`${i}${t}
+`);
+};
+var ye = (t = "", r) => {
+  const s = r?.output ?? process.stdout, i = r?.withGuide ?? h.withGuide ? `${(0, import_node_util.styleText)("gray", $)}
+${(0, import_node_util.styleText)("gray", E2)}  ` : "";
+  s.write(`${i}${t}
+
+`);
+};
+var Q2 = (t, r) => t.split(`
+`).map((s) => r(s)).join(`
+`);
+var ve = (t) => {
+  const r = (i, u) => {
+    const n = i.label ?? String(i.value);
+    return u === "disabled" ? `${(0, import_node_util.styleText)("gray", J)} ${Q2(n, (o) => (0, import_node_util.styleText)(["strikethrough", "gray"], o))}${i.hint ? ` ${(0, import_node_util.styleText)("dim", `(${i.hint ?? "disabled"})`)}` : ""}` : u === "active" ? `${(0, import_node_util.styleText)("cyan", et2)} ${n}${i.hint ? ` ${(0, import_node_util.styleText)("dim", `(${i.hint})`)}` : ""}` : u === "selected" ? `${(0, import_node_util.styleText)("green", U)} ${Q2(n, (o) => (0, import_node_util.styleText)("dim", o))}${i.hint ? ` ${(0, import_node_util.styleText)("dim", `(${i.hint})`)}` : ""}` : u === "cancelled" ? `${Q2(n, (o) => (0, import_node_util.styleText)(["strikethrough", "dim"], o))}` : u === "active-selected" ? `${(0, import_node_util.styleText)("green", U)} ${n}${i.hint ? ` ${(0, import_node_util.styleText)("dim", `(${i.hint})`)}` : ""}` : u === "submitted" ? `${Q2(n, (o) => (0, import_node_util.styleText)("dim", o))}` : `${(0, import_node_util.styleText)("dim", J)} ${Q2(n, (o) => (0, import_node_util.styleText)("dim", o))}`;
+  }, s = t.required ?? true;
+  return new nt({ options: t.options, signal: t.signal, input: t.input, output: t.output, initialValues: t.initialValues, required: s, cursorAt: t.cursorAt, validate(i) {
+    if (s && (i === void 0 || i.length === 0)) return `Please select at least one option.
+${(0, import_node_util.styleText)("reset", (0, import_node_util.styleText)("dim", `Press ${(0, import_node_util.styleText)(["gray", "bgWhite", "inverse"], " space ")} to select, ${(0, import_node_util.styleText)("gray", (0, import_node_util.styleText)("bgWhite", (0, import_node_util.styleText)("inverse", " enter ")))} to submit`))}`;
+  }, render() {
+    const i = t.withGuide ?? h.withGuide, u = W(t.output, t.message, i ? `${yt(this.state)}  ` : "", `${M(this.state)}  `), n = `${i ? `${(0, import_node_util.styleText)("gray", $)}
+` : ""}${u}
+`, o = this.value ?? [], c2 = (a, l) => {
+      if (a.disabled) return r(a, "disabled");
+      const d2 = o.includes(a.value);
+      return l && d2 ? r(a, "active-selected") : d2 ? r(a, "selected") : r(a, l ? "active" : "inactive");
+    };
+    switch (this.state) {
+      case "submit": {
+        const a = this.options.filter(({ value: d2 }) => o.includes(d2)).map((d2) => r(d2, "submitted")).join((0, import_node_util.styleText)("dim", ", ")) || (0, import_node_util.styleText)("dim", "none"), l = W(t.output, a, i ? `${(0, import_node_util.styleText)("gray", $)}  ` : "");
+        return `${n}${l}`;
+      }
+      case "cancel": {
+        const a = this.options.filter(({ value: d2 }) => o.includes(d2)).map((d2) => r(d2, "cancelled")).join((0, import_node_util.styleText)("dim", ", "));
+        if (a.trim() === "") return `${n}${(0, import_node_util.styleText)("gray", $)}`;
+        const l = W(t.output, a, i ? `${(0, import_node_util.styleText)("gray", $)}  ` : "");
+        return `${n}${l}${i ? `
+${(0, import_node_util.styleText)("gray", $)}` : ""}`;
+      }
+      case "error": {
+        const a = i ? `${(0, import_node_util.styleText)("yellow", $)}  ` : "", l = this.error.split(`
+`).map((p2, m) => m === 0 ? `${i ? `${(0, import_node_util.styleText)("yellow", E2)}  ` : ""}${(0, import_node_util.styleText)("yellow", p2)}` : `   ${p2}`).join(`
+`), d2 = n.split(`
+`).length, y = l.split(`
+`).length + 1;
+        return `${n}${a}${Y2({ output: t.output, options: this.options, cursor: this.cursor, maxItems: t.maxItems, columnPadding: a.length, rowPadding: d2 + y, style: c2 }).join(`
+${a}`)}
+${l}
+`;
+      }
+      default: {
+        const a = i ? `${(0, import_node_util.styleText)("cyan", $)}  ` : "", l = n.split(`
+`).length, d2 = i ? 2 : 1;
+        return `${n}${a}${Y2({ output: t.output, options: this.options, cursor: this.cursor, maxItems: t.maxItems, columnPadding: a.length, rowPadding: l + d2, style: c2 }).join(`
+${a}`)}
+${i ? (0, import_node_util.styleText)("cyan", E2) : ""}
+`;
+      }
+    }
+  } }).prompt();
+};
+var Vt = { light: w2("\u2500", "-"), heavy: w2("\u2501", "="), block: w2("\u2588", "#") };
+var jt = `${(0, import_node_util.styleText)("gray", $)}  `;
+
 // src/index.ts
 var import_child_process = require("child_process");
-var import_promises = require("fs/promises");
 
-// node_modules/commander/esm.mjs
+// node_modules/.pnpm/commander@14.0.3/node_modules/commander/esm.mjs
 var import_index = __toESM(require_commander(), 1);
 var {
   program,
@@ -2829,28 +4293,53 @@ var {
   Help
 } = import_index.default;
 
+// src/index.ts
+var import_promises = require("fs/promises");
+var import_path = __toESM(require("path"));
+
 // src/eslintConfig.json
 var eslintConfig_default = {
   extends: "@bharper7/eslint-config"
 };
 
 // src/index.ts
+var DOTFILES_OWNER = "bharper77";
+var DOTFILES_REPO = "dotfiles";
+var SKILLS_PATH = ".agents/skills";
 var program2 = new Command();
 program2.command("init").option("-d, --directory <directory>", "Directory name for project").action(init);
+var skillsCmd = new Command("skills").description(
+  "Manage agent skills from dotfiles"
+);
+skillsCmd.addCommand(
+  new Command("list").description("List available skills from dotfiles").action(listSkills)
+);
+skillsCmd.addCommand(
+  new Command("add").description("Download one or more skills into .agents/skills/").argument(
+    "[skill]",
+    "Skill name to download directly (omit for interactive picker)"
+  ).action(addSkill)
+);
+program2.addCommand(skillsCmd);
 program2.parseAsync(process.argv);
 async function init(opts) {
-  exec(`mkdir ${opts.directory}`);
-  exec("mkdir src", opts.directory);
-  exec("new-item index.ts", `${opts.directory}/src`);
-  exec("git init", opts.directory);
-  exec("echo 'node_modules' 'dist' > .gitignore", opts.directory);
-  exec("npm init -y", opts.directory);
-  const packageJson = JSON.parse((await (0, import_promises.readFile)(`${opts.directory}/package.json`)).toString());
+  exec2(`mkdir ${opts.directory}`);
+  exec2("mkdir src", opts.directory);
+  exec2("new-item index.ts", `${opts.directory}/src`);
+  exec2("git init", opts.directory);
+  exec2("echo 'node_modules' 'dist' > .gitignore", opts.directory);
+  exec2("npm init -y", opts.directory);
+  const packageJson = JSON.parse(
+    (await (0, import_promises.readFile)(`${opts.directory}/package.json`)).toString()
+  );
   packageJson.scripts = {
-    "start": "node src/index.js",
-    "build": "tsc"
+    start: "node src/index.js",
+    build: "tsc"
   };
-  await (0, import_promises.writeFile)(`${opts.directory}/package.json`, JSON.stringify(packageJson, null, 2));
+  await (0, import_promises.writeFile)(
+    `${opts.directory}/package.json`,
+    JSON.stringify(packageJson, null, 2)
+  );
   const devDependencies = [
     "typescript",
     "@types/node",
@@ -2860,12 +4349,105 @@ async function init(opts) {
     "@typescript-eslint/eslint-plugin",
     "eslint-plugin-import"
   ].join(" ");
-  exec(`npm i -D ${devDependencies}`, opts.directory);
-  exec("tsc --init", opts.directory);
-  await (0, import_promises.writeFile)(`${opts.directory}/.eslintrc.json`, JSON.stringify(eslintConfig_default));
-  exec("echo 'node_modules' 'dist' > .eslintignore", opts.directory);
+  exec2(`npm i -D ${devDependencies}`, opts.directory);
+  exec2("tsc --init", opts.directory);
+  await (0, import_promises.writeFile)(
+    `${opts.directory}/.eslintrc.json`,
+    JSON.stringify(eslintConfig_default)
+  );
+  exec2("echo 'node_modules' 'dist' > .eslintignore", opts.directory);
+}
+async function listSkills() {
+  await ensureGhAuth();
+  const entries = fetchGhJson(
+    `repos/${DOTFILES_OWNER}/${DOTFILES_REPO}/contents/${SKILLS_PATH}`
+  );
+  const skills = entries.filter((e2) => e2.type === "dir").map((e2) => e2.name);
+  if (skills.length === 0) {
+    console.log("No skills found.");
+    return;
+  }
+  console.log("Available skills:");
+  for (const skill of skills) {
+    console.log(`  \u2022 ${skill}`);
+  }
+}
+async function addSkill(skill) {
+  await ensureGhAuth();
+  if (skill) {
+    await downloadSkill(skill);
+  } else {
+    const entries = fetchGhJson(
+      `repos/${DOTFILES_OWNER}/${DOTFILES_REPO}/contents/${SKILLS_PATH}`
+    );
+    const skills = entries.filter((e2) => e2.type === "dir").map((e2) => e2.name);
+    if (skills.length === 0) {
+      console.log("No skills available.");
+      return;
+    }
+    ge("brady skills add");
+    const selected = await ve({
+      message: "Select skills to download (space = toggle, enter = confirm):",
+      options: skills.map((s) => ({ value: s, label: s })),
+      required: true
+    });
+    if (q(selected)) {
+      me("Cancelled.");
+      process.exit(0);
+    }
+    const chosen = selected;
+    for (const s of chosen) {
+      await downloadSkill(s);
+    }
+    ye(`Downloaded ${chosen.length} skill(s).`);
+  }
+}
+async function ensureGhAuth() {
+  try {
+    (0, import_child_process.execSync)("gh auth status", { stdio: "pipe" });
+  } catch {
+    ge("GitHub authentication required");
+    const answer = await ue({
+      message: "You are not authenticated with GitHub CLI. Run `gh auth login` now?"
+    });
+    if (q(answer) || !answer) {
+      console.error(
+        "Error: Not authenticated. Run `gh auth login` to authenticate, then retry."
+      );
+      process.exit(1);
+    }
+    const result = (0, import_child_process.spawnSync)("gh", ["auth", "login"], {
+      stdio: "inherit",
+      shell: "powershell.exe"
+    });
+    if (result.status !== 0) {
+      console.error(
+        "Authentication failed. Run `gh auth login` to authenticate, then retry."
+      );
+      process.exit(1);
+    }
+  }
+}
+function fetchGhJson(apiPath) {
+  const output = (0, import_child_process.execSync)(`gh api ${apiPath}`, { encoding: "utf-8" });
+  return JSON.parse(output);
+}
+async function downloadSkill(skillName) {
+  const apiPath = `repos/${DOTFILES_OWNER}/${DOTFILES_REPO}/contents/${SKILLS_PATH}/${skillName}`;
+  const files = fetchGhJson(apiPath);
+  const destDir = import_path.default.join(process.cwd(), SKILLS_PATH, skillName);
+  await (0, import_promises.mkdir)(destDir, { recursive: true });
+  for (const file of files) {
+    if (file.type !== "file") continue;
+    const fileEntry = fetchGhJson(
+      `repos/${DOTFILES_OWNER}/${DOTFILES_REPO}/contents/${SKILLS_PATH}/${skillName}/${file.name}`
+    );
+    const content = Buffer.from(fileEntry.content, "base64").toString("utf-8");
+    await (0, import_promises.writeFile)(import_path.default.join(destDir, file.name), content, "utf-8");
+  }
+  console.log(`\u2713 Downloaded skill: ${skillName}`);
 }
-function exec(command, cwd) {
+function exec2(command, cwd) {
   return (0, import_child_process.execSync)(command, {
     cwd,
     shell: "powershell.exe"