@c-d-cc/reap 0.15.12 → 0.15.14

package/dist/cli.js

@@ -47,1845 +47,6 @@ var __export = (target, all) => {
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
-// node_modules/commander/lib/error.js
-var require_error = __commonJS((exports) => {
-  class CommanderError extends Error {
-    constructor(exitCode, code, message) {
-      super(message);
-      Error.captureStackTrace(this, this.constructor);
-      this.name = this.constructor.name;
-      this.code = code;
-      this.exitCode = exitCode;
-      this.nestedError = undefined;
-    }
-  }
-
-  class InvalidArgumentError extends CommanderError {
-    constructor(message) {
-      super(1, "commander.invalidArgument", message);
-      Error.captureStackTrace(this, this.constructor);
-      this.name = this.constructor.name;
-    }
-  }
-  exports.CommanderError = CommanderError;
-  exports.InvalidArgumentError = InvalidArgumentError;
-});
-
-// node_modules/commander/lib/argument.js
-var require_argument = __commonJS((exports) => {
-  var { InvalidArgumentError } = require_error();
-
-  class Argument {
-    constructor(name, description) {
-      this.description = description || "";
-      this.variadic = false;
-      this.parseArg = undefined;
-      this.defaultValue = undefined;
-      this.defaultValueDescription = undefined;
-      this.argChoices = undefined;
-      switch (name[0]) {
-        case "<":
-          this.required = true;
-          this._name = name.slice(1, -1);
-          break;
-        case "[":
-          this.required = false;
-          this._name = name.slice(1, -1);
-          break;
-        default:
-          this.required = true;
-          this._name = name;
-          break;
-      }
-      if (this._name.length > 3 && this._name.slice(-3) === "...") {
-        this.variadic = true;
-        this._name = this._name.slice(0, -3);
-      }
-    }
-    name() {
-      return this._name;
-    }
-    _concatValue(value, previous) {
-      if (previous === this.defaultValue || !Array.isArray(previous)) {
-        return [value];
-      }
-      return previous.concat(value);
-    }
-    default(value, description) {
-      this.defaultValue = value;
-      this.defaultValueDescription = description;
-      return this;
-    }
-    argParser(fn) {
-      this.parseArg = fn;
-      return this;
-    }
-    choices(values) {
-      this.argChoices = values.slice();
-      this.parseArg = (arg, previous) => {
-        if (!this.argChoices.includes(arg)) {
-          throw new InvalidArgumentError(`Allowed choices are ${this.argChoices.join(", ")}.`);
-        }
-        if (this.variadic) {
-          return this._concatValue(arg, previous);
-        }
-        return arg;
-      };
-      return this;
-    }
-    argRequired() {
-      this.required = true;
-      return this;
-    }
-    argOptional() {
-      this.required = false;
-      return this;
-    }
-  }
-  function humanReadableArgName(arg) {
-    const nameOutput = arg.name() + (arg.variadic === true ? "..." : "");
-    return arg.required ? "<" + nameOutput + ">" : "[" + nameOutput + "]";
-  }
-  exports.Argument = Argument;
-  exports.humanReadableArgName = humanReadableArgName;
-});
-
-// node_modules/commander/lib/help.js
-var require_help = __commonJS((exports) => {
-  var { humanReadableArgName } = require_argument();
-
-  class Help {
-    constructor() {
-      this.helpWidth = undefined;
-      this.sortSubcommands = false;
-      this.sortOptions = false;
-      this.showGlobalOptions = false;
-    }
-    visibleCommands(cmd) {
-      const visibleCommands = cmd.commands.filter((cmd2) => !cmd2._hidden);
-      const helpCommand = cmd._getHelpCommand();
-      if (helpCommand && !helpCommand._hidden) {
-        visibleCommands.push(helpCommand);
-      }
-      if (this.sortSubcommands) {
-        visibleCommands.sort((a, b) => {
-          return a.name().localeCompare(b.name());
-        });
-      }
-      return visibleCommands;
-    }
-    compareOptions(a, b) {
-      const getSortKey = (option) => {
-        return option.short ? option.short.replace(/^-/, "") : option.long.replace(/^--/, "");
-      };
-      return getSortKey(a).localeCompare(getSortKey(b));
-    }
-    visibleOptions(cmd) {
-      const visibleOptions = cmd.options.filter((option) => !option.hidden);
-      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));
-        }
-      }
-      if (this.sortOptions) {
-        visibleOptions.sort(this.compareOptions);
-      }
-      return visibleOptions;
-    }
-    visibleGlobalOptions(cmd) {
-      if (!this.showGlobalOptions)
-        return [];
-      const globalOptions = [];
-      for (let ancestorCmd = cmd.parent;ancestorCmd; ancestorCmd = ancestorCmd.parent) {
-        const visibleOptions = ancestorCmd.options.filter((option) => !option.hidden);
-        globalOptions.push(...visibleOptions);
-      }
-      if (this.sortOptions) {
-        globalOptions.sort(this.compareOptions);
-      }
-      return globalOptions;
-    }
-    visibleArguments(cmd) {
-      if (cmd._argsDescription) {
-        cmd.registeredArguments.forEach((argument) => {
-          argument.description = argument.description || cmd._argsDescription[argument.name()] || "";
-        });
-      }
-      if (cmd.registeredArguments.find((argument) => argument.description)) {
-        return cmd.registeredArguments;
-      }
-      return [];
-    }
-    subcommandTerm(cmd) {
-      const args = cmd.registeredArguments.map((arg) => humanReadableArgName(arg)).join(" ");
-      return cmd._name + (cmd._aliases[0] ? "|" + cmd._aliases[0] : "") + (cmd.options.length ? " [options]" : "") + (args ? " " + args : "");
-    }
-    optionTerm(option) {
-      return option.flags;
-    }
-    argumentTerm(argument) {
-      return argument.name();
-    }
-    longestSubcommandTermLength(cmd, helper) {
-      return helper.visibleCommands(cmd).reduce((max, command) => {
-        return Math.max(max, helper.subcommandTerm(command).length);
-      }, 0);
-    }
-    longestOptionTermLength(cmd, helper) {
-      return helper.visibleOptions(cmd).reduce((max, option) => {
-        return Math.max(max, helper.optionTerm(option).length);
-      }, 0);
-    }
-    longestGlobalOptionTermLength(cmd, helper) {
-      return helper.visibleGlobalOptions(cmd).reduce((max, option) => {
-        return Math.max(max, helper.optionTerm(option).length);
-      }, 0);
-    }
-    longestArgumentTermLength(cmd, helper) {
-      return helper.visibleArguments(cmd).reduce((max, argument) => {
-        return Math.max(max, helper.argumentTerm(argument).length);
-      }, 0);
-    }
-    commandUsage(cmd) {
-      let cmdName = cmd._name;
-      if (cmd._aliases[0]) {
-        cmdName = cmdName + "|" + cmd._aliases[0];
-      }
-      let ancestorCmdNames = "";
-      for (let ancestorCmd = cmd.parent;ancestorCmd; ancestorCmd = ancestorCmd.parent) {
-        ancestorCmdNames = ancestorCmd.name() + " " + ancestorCmdNames;
-      }
-      return ancestorCmdNames + cmdName + " " + cmd.usage();
-    }
-    commandDescription(cmd) {
-      return cmd.description();
-    }
-    subcommandDescription(cmd) {
-      return cmd.summary() || cmd.description();
-    }
-    optionDescription(option) {
-      const extraInfo = [];
-      if (option.argChoices) {
-        extraInfo.push(`choices: ${option.argChoices.map((choice) => JSON.stringify(choice)).join(", ")}`);
-      }
-      if (option.defaultValue !== undefined) {
-        const showDefault = option.required || option.optional || option.isBoolean() && typeof option.defaultValue === "boolean";
-        if (showDefault) {
-          extraInfo.push(`default: ${option.defaultValueDescription || JSON.stringify(option.defaultValue)}`);
-        }
-      }
-      if (option.presetArg !== undefined && option.optional) {
-        extraInfo.push(`preset: ${JSON.stringify(option.presetArg)}`);
-      }
-      if (option.envVar !== undefined) {
-        extraInfo.push(`env: ${option.envVar}`);
-      }
-      if (extraInfo.length > 0) {
-        return `${option.description} (${extraInfo.join(", ")})`;
-      }
-      return option.description;
-    }
-    argumentDescription(argument) {
-      const extraInfo = [];
-      if (argument.argChoices) {
-        extraInfo.push(`choices: ${argument.argChoices.map((choice) => JSON.stringify(choice)).join(", ")}`);
-      }
-      if (argument.defaultValue !== undefined) {
-        extraInfo.push(`default: ${argument.defaultValueDescription || JSON.stringify(argument.defaultValue)}`);
-      }
-      if (extraInfo.length > 0) {
-        const extraDescripton = `(${extraInfo.join(", ")})`;
-        if (argument.description) {
-          return `${argument.description} ${extraDescripton}`;
-        }
-        return extraDescripton;
-      }
-      return argument.description;
-    }
-    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;
-      }
-      function formatList(textArray) {
-        return textArray.join(`
-`).replace(/^/gm, " ".repeat(itemIndentWidth));
-      }
-      let output = [`Usage: ${helper.commandUsage(cmd)}`, ""];
-      const commandDescription = helper.commandDescription(cmd);
-      if (commandDescription.length > 0) {
-        output = output.concat([
-          helper.wrap(commandDescription, helpWidth, 0),
-          ""
-        ]);
-      }
-      const argumentList = helper.visibleArguments(cmd).map((argument) => {
-        return formatItem(helper.argumentTerm(argument), 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));
-      });
-      if (optionList.length > 0) {
-        output = output.concat(["Options:", formatList(optionList), ""]);
-      }
-      if (this.showGlobalOptions) {
-        const globalOptionList = helper.visibleGlobalOptions(cmd).map((option) => {
-          return formatItem(helper.optionTerm(option), helper.optionDescription(option));
-        });
-        if (globalOptionList.length > 0) {
-          output = output.concat([
-            "Global Options:",
-            formatList(globalOptionList),
-            ""
-          ]);
-        }
-      }
-      const commandList = helper.visibleCommands(cmd).map((cmd2) => {
-        return formatItem(helper.subcommandTerm(cmd2), helper.subcommandDescription(cmd2));
-      });
-      if (commandList.length > 0) {
-        output = output.concat(["Commands:", formatList(commandList), ""]);
-      }
-      return output.join(`
-`);
-    }
-    padWidth(cmd, helper) {
-      return Math.max(helper.longestOptionTermLength(cmd, helper), helper.longestGlobalOptionTermLength(cmd, helper), helper.longestSubcommandTermLength(cmd, helper), helper.longestArgumentTermLength(cmd, helper));
-    }
-    wrap(str, width, indent, minColumnWidth = 40) {
-      const indents = " \\f\\t\\v   -   　\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
-`, `
-`);
-      const indentString = " ".repeat(indent);
-      const zeroWidthSpace = "​";
-      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 === `
-`)
-          return "";
-        return (i > 0 ? indentString : "") + line.trimEnd();
-      }).join(`
-`);
-    }
-  }
-  exports.Help = Help;
-});
-
-// node_modules/commander/lib/option.js
-var require_option = __commonJS((exports) => {
-  var { InvalidArgumentError } = require_error();
-
-  class Option {
-    constructor(flags, description) {
-      this.flags = flags;
-      this.description = description || "";
-      this.required = flags.includes("<");
-      this.optional = flags.includes("[");
-      this.variadic = /\w\.\.\.[>\]]$/.test(flags);
-      this.mandatory = false;
-      const optionFlags = splitOptionFlags(flags);
-      this.short = optionFlags.shortFlag;
-      this.long = optionFlags.longFlag;
-      this.negate = false;
-      if (this.long) {
-        this.negate = this.long.startsWith("--no-");
-      }
-      this.defaultValue = undefined;
-      this.defaultValueDescription = undefined;
-      this.presetArg = undefined;
-      this.envVar = undefined;
-      this.parseArg = undefined;
-      this.hidden = false;
-      this.argChoices = undefined;
-      this.conflictsWith = [];
-      this.implied = undefined;
-    }
-    default(value, description) {
-      this.defaultValue = value;
-      this.defaultValueDescription = description;
-      return this;
-    }
-    preset(arg) {
-      this.presetArg = arg;
-      return this;
-    }
-    conflicts(names) {
-      this.conflictsWith = this.conflictsWith.concat(names);
-      return this;
-    }
-    implies(impliedOptionValues) {
-      let newImplied = impliedOptionValues;
-      if (typeof impliedOptionValues === "string") {
-        newImplied = { [impliedOptionValues]: true };
-      }
-      this.implied = Object.assign(this.implied || {}, newImplied);
-      return this;
-    }
-    env(name) {
-      this.envVar = name;
-      return this;
-    }
-    argParser(fn) {
-      this.parseArg = fn;
-      return this;
-    }
-    makeOptionMandatory(mandatory = true) {
-      this.mandatory = !!mandatory;
-      return this;
-    }
-    hideHelp(hide = true) {
-      this.hidden = !!hide;
-      return this;
-    }
-    _concatValue(value, previous) {
-      if (previous === this.defaultValue || !Array.isArray(previous)) {
-        return [value];
-      }
-      return previous.concat(value);
-    }
-    choices(values) {
-      this.argChoices = values.slice();
-      this.parseArg = (arg, previous) => {
-        if (!this.argChoices.includes(arg)) {
-          throw new InvalidArgumentError(`Allowed choices are ${this.argChoices.join(", ")}.`);
-        }
-        if (this.variadic) {
-          return this._concatValue(arg, previous);
-        }
-        return arg;
-      };
-      return this;
-    }
-    name() {
-      if (this.long) {
-        return this.long.replace(/^--/, "");
-      }
-      return this.short.replace(/^-/, "");
-    }
-    attributeName() {
-      return camelcase(this.name().replace(/^no-/, ""));
-    }
-    is(arg) {
-      return this.short === arg || this.long === arg;
-    }
-    isBoolean() {
-      return !this.required && !this.optional && !this.negate;
-    }
-  }
-
-  class DualOptions {
-    constructor(options) {
-      this.positiveOptions = new Map;
-      this.negativeOptions = new Map;
-      this.dualOptions = new Set;
-      options.forEach((option) => {
-        if (option.negate) {
-          this.negativeOptions.set(option.attributeName(), option);
-        } else {
-          this.positiveOptions.set(option.attributeName(), option);
-        }
-      });
-      this.negativeOptions.forEach((value, key) => {
-        if (this.positiveOptions.has(key)) {
-          this.dualOptions.add(key);
-        }
-      });
-    }
-    valueFromOption(value, option) {
-      const optionKey = option.attributeName();
-      if (!this.dualOptions.has(optionKey))
-        return true;
-      const preset = this.negativeOptions.get(optionKey).presetArg;
-      const negativeValue = preset !== undefined ? preset : false;
-      return option.negate === (negativeValue === value);
-    }
-  }
-  function camelcase(str) {
-    return str.split("-").reduce((str2, word) => {
-      return str2 + word[0].toUpperCase() + word.slice(1);
-    });
-  }
-  function splitOptionFlags(flags) {
-    let shortFlag;
-    let longFlag;
-    const flagParts = flags.split(/[ |,]+/);
-    if (flagParts.length > 1 && !/^[[<]/.test(flagParts[1]))
-      shortFlag = flagParts.shift();
-    longFlag = flagParts.shift();
-    if (!shortFlag && /^-[^-]$/.test(longFlag)) {
-      shortFlag = longFlag;
-      longFlag = undefined;
-    }
-    return { shortFlag, longFlag };
-  }
-  exports.Option = Option;
-  exports.DualOptions = DualOptions;
-});
-
-// node_modules/commander/lib/suggestSimilar.js
-var require_suggestSimilar = __commonJS((exports) => {
-  var maxDistance = 3;
-  function editDistance(a, b) {
-    if (Math.abs(a.length - b.length) > maxDistance)
-      return Math.max(a.length, b.length);
-    const d = [];
-    for (let i = 0;i <= a.length; i++) {
-      d[i] = [i];
-    }
-    for (let j = 0;j <= b.length; j++) {
-      d[0][j] = j;
-    }
-    for (let j = 1;j <= b.length; j++) {
-      for (let i = 1;i <= a.length; i++) {
-        let cost = 1;
-        if (a[i - 1] === b[j - 1]) {
-          cost = 0;
-        } else {
-          cost = 1;
-        }
-        d[i][j] = Math.min(d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1] + cost);
-        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);
-        }
-      }
-    }
-    return d[a.length][b.length];
-  }
-  function suggestSimilar(word, candidates) {
-    if (!candidates || candidates.length === 0)
-      return "";
-    candidates = Array.from(new Set(candidates));
-    const searchingOptions = word.startsWith("--");
-    if (searchingOptions) {
-      word = word.slice(2);
-      candidates = candidates.map((candidate) => candidate.slice(2));
-    }
-    let similar = [];
-    let bestDistance = maxDistance;
-    const minSimilarity = 0.4;
-    candidates.forEach((candidate) => {
-      if (candidate.length <= 1)
-        return;
-      const distance = editDistance(word, candidate);
-      const length = Math.max(word.length, candidate.length);
-      const similarity = (length - distance) / length;
-      if (similarity > minSimilarity) {
-        if (distance < bestDistance) {
-          bestDistance = distance;
-          similar = [candidate];
-        } else if (distance === bestDistance) {
-          similar.push(candidate);
-        }
-      }
-    });
-    similar.sort((a, b) => a.localeCompare(b));
-    if (searchingOptions) {
-      similar = similar.map((candidate) => `--${candidate}`);
-    }
-    if (similar.length > 1) {
-      return `
-(Did you mean one of ${similar.join(", ")}?)`;
-    }
-    if (similar.length === 1) {
-      return `
-(Did you mean ${similar[0]}?)`;
-    }
-    return "";
-  }
-  exports.suggestSimilar = suggestSimilar;
-});
-
-// node_modules/commander/lib/command.js
-var require_command = __commonJS((exports) => {
-  var EventEmitter = __require("node:events").EventEmitter;
-  var childProcess = __require("node:child_process");
-  var path = __require("node:path");
-  var fs = __require("node:fs");
-  var process2 = __require("node:process");
-  var { Argument, humanReadableArgName } = require_argument();
-  var { CommanderError } = require_error();
-  var { Help } = require_help();
-  var { Option, DualOptions } = require_option();
-  var { suggestSimilar } = require_suggestSimilar();
-
-  class Command extends EventEmitter {
-    constructor(name) {
-      super();
-      this.commands = [];
-      this.options = [];
-      this.parent = null;
-      this._allowUnknownOption = false;
-      this._allowExcessArguments = true;
-      this.registeredArguments = [];
-      this._args = this.registeredArguments;
-      this.args = [];
-      this.rawArgs = [];
-      this.processedArgs = [];
-      this._scriptPath = null;
-      this._name = name || "";
-      this._optionValues = {};
-      this._optionValueSources = {};
-      this._storeOptionsAsProperties = false;
-      this._actionHandler = null;
-      this._executableHandler = false;
-      this._executableFile = null;
-      this._executableDir = null;
-      this._defaultCommandName = null;
-      this._exitCallback = null;
-      this._aliases = [];
-      this._combineFlagAndOptionalValue = true;
-      this._description = "";
-      this._summary = "";
-      this._argsDescription = undefined;
-      this._enablePositionalOptions = false;
-      this._passThroughOptions = false;
-      this._lifeCycleHooks = {};
-      this._showHelpAfterError = false;
-      this._showSuggestionAfterError = true;
-      this._outputConfiguration = {
-        writeOut: (str) => process2.stdout.write(str),
-        writeErr: (str) => process2.stderr.write(str),
-        getOutHelpWidth: () => process2.stdout.isTTY ? process2.stdout.columns : undefined,
-        getErrHelpWidth: () => process2.stderr.isTTY ? process2.stderr.columns : undefined,
-        outputError: (str, write) => write(str)
-      };
-      this._hidden = false;
-      this._helpOption = undefined;
-      this._addImplicitHelpCommand = undefined;
-      this._helpCommand = undefined;
-      this._helpConfiguration = {};
-    }
-    copyInheritedSettings(sourceCommand) {
-      this._outputConfiguration = sourceCommand._outputConfiguration;
-      this._helpOption = sourceCommand._helpOption;
-      this._helpCommand = sourceCommand._helpCommand;
-      this._helpConfiguration = sourceCommand._helpConfiguration;
-      this._exitCallback = sourceCommand._exitCallback;
-      this._storeOptionsAsProperties = sourceCommand._storeOptionsAsProperties;
-      this._combineFlagAndOptionalValue = sourceCommand._combineFlagAndOptionalValue;
-      this._allowExcessArguments = sourceCommand._allowExcessArguments;
-      this._enablePositionalOptions = sourceCommand._enablePositionalOptions;
-      this._showHelpAfterError = sourceCommand._showHelpAfterError;
-      this._showSuggestionAfterError = sourceCommand._showSuggestionAfterError;
-      return this;
-    }
-    _getCommandAndAncestors() {
-      const result = [];
-      for (let command = this;command; command = command.parent) {
-        result.push(command);
-      }
-      return result;
-    }
-    command(nameAndArgs, actionOptsOrExecDesc, execOpts) {
-      let desc = actionOptsOrExecDesc;
-      let opts = execOpts;
-      if (typeof desc === "object" && desc !== null) {
-        opts = desc;
-        desc = null;
-      }
-      opts = opts || {};
-      const [, name, args] = nameAndArgs.match(/([^ ]+) *(.*)/);
-      const cmd = this.createCommand(name);
-      if (desc) {
-        cmd.description(desc);
-        cmd._executableHandler = true;
-      }
-      if (opts.isDefault)
-        this._defaultCommandName = cmd._name;
-      cmd._hidden = !!(opts.noHelp || opts.hidden);
-      cmd._executableFile = opts.executableFile || null;
-      if (args)
-        cmd.arguments(args);
-      this._registerCommand(cmd);
-      cmd.parent = this;
-      cmd.copyInheritedSettings(this);
-      if (desc)
-        return this;
-      return cmd;
-    }
-    createCommand(name) {
-      return new Command(name);
-    }
-    createHelp() {
-      return Object.assign(new Help, this.configureHelp());
-    }
-    configureHelp(configuration) {
-      if (configuration === undefined)
-        return this._helpConfiguration;
-      this._helpConfiguration = configuration;
-      return this;
-    }
-    configureOutput(configuration) {
-      if (configuration === undefined)
-        return this._outputConfiguration;
-      Object.assign(this._outputConfiguration, configuration);
-      return this;
-    }
-    showHelpAfterError(displayHelp = true) {
-      if (typeof displayHelp !== "string")
-        displayHelp = !!displayHelp;
-      this._showHelpAfterError = displayHelp;
-      return this;
-    }
-    showSuggestionAfterError(displaySuggestion = true) {
-      this._showSuggestionAfterError = !!displaySuggestion;
-      return this;
-    }
-    addCommand(cmd, opts) {
-      if (!cmd._name) {
-        throw new Error(`Command passed to .addCommand() must have a name
-- 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._registerCommand(cmd);
-      cmd.parent = this;
-      cmd._checkForBrokenPassThrough();
-      return this;
-    }
-    createArgument(name, description) {
-      return new Argument(name, description);
-    }
-    argument(name, description, fn, defaultValue) {
-      const argument = this.createArgument(name, description);
-      if (typeof fn === "function") {
-        argument.default(defaultValue).argParser(fn);
-      } else {
-        argument.default(fn);
-      }
-      this.addArgument(argument);
-      return this;
-    }
-    arguments(names) {
-      names.trim().split(/ +/).forEach((detail) => {
-        this.argument(detail);
-      });
-      return this;
-    }
-    addArgument(argument) {
-      const previousArgument = this.registeredArguments.slice(-1)[0];
-      if (previousArgument && previousArgument.variadic) {
-        throw new Error(`only the last argument can be variadic '${previousArgument.name()}'`);
-      }
-      if (argument.required && argument.defaultValue !== undefined && argument.parseArg === undefined) {
-        throw new Error(`a default value for a required argument is never used: '${argument.name()}'`);
-      }
-      this.registeredArguments.push(argument);
-      return this;
-    }
-    helpCommand(enableOrNameAndArgs, description) {
-      if (typeof enableOrNameAndArgs === "boolean") {
-        this._addImplicitHelpCommand = enableOrNameAndArgs;
-        return this;
-      }
-      enableOrNameAndArgs = enableOrNameAndArgs ?? "help [command]";
-      const [, helpName, helpArgs] = enableOrNameAndArgs.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;
-      return this;
-    }
-    addHelpCommand(helpCommand, deprecatedDescription) {
-      if (typeof helpCommand !== "object") {
-        this.helpCommand(helpCommand, deprecatedDescription);
-        return this;
-      }
-      this._addImplicitHelpCommand = true;
-      this._helpCommand = helpCommand;
-      return this;
-    }
-    _getHelpCommand() {
-      const hasImplicitHelpCommand = this._addImplicitHelpCommand ?? (this.commands.length && !this._actionHandler && !this._findCommand("help"));
-      if (hasImplicitHelpCommand) {
-        if (this._helpCommand === undefined) {
-          this.helpCommand(undefined, undefined);
-        }
-        return this._helpCommand;
-      }
-      return null;
-    }
-    hook(event, listener) {
-      const allowedValues = ["preSubcommand", "preAction", "postAction"];
-      if (!allowedValues.includes(event)) {
-        throw new Error(`Unexpected value for event passed to hook : '${event}'.
-Expecting one of '${allowedValues.join("', '")}'`);
-      }
-      if (this._lifeCycleHooks[event]) {
-        this._lifeCycleHooks[event].push(listener);
-      } else {
-        this._lifeCycleHooks[event] = [listener];
-      }
-      return this;
-    }
-    exitOverride(fn) {
-      if (fn) {
-        this._exitCallback = fn;
-      } else {
-        this._exitCallback = (err) => {
-          if (err.code !== "commander.executeSubCommandAsync") {
-            throw err;
-          } else {}
-        };
-      }
-      return this;
-    }
-    _exit(exitCode, code, message) {
-      if (this._exitCallback) {
-        this._exitCallback(new CommanderError(exitCode, code, message));
-      }
-      process2.exit(exitCode);
-    }
-    action(fn) {
-      const listener = (args) => {
-        const expectedArgsCount = this.registeredArguments.length;
-        const actionArgs = args.slice(0, expectedArgsCount);
-        if (this._storeOptionsAsProperties) {
-          actionArgs[expectedArgsCount] = this;
-        } else {
-          actionArgs[expectedArgsCount] = this.opts();
-        }
-        actionArgs.push(this);
-        return fn.apply(this, actionArgs);
-      };
-      this._actionHandler = listener;
-      return this;
-    }
-    createOption(flags, description) {
-      return new Option(flags, description);
-    }
-    _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;
-      }
-    }
-    _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.options.push(option);
-    }
-    _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.commands.push(command);
-    }
-    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 === undefined ? true : option.defaultValue, "default");
-        }
-      } else if (option.defaultValue !== undefined) {
-        this.setOptionValueWithSource(name, option.defaultValue, "default");
-      }
-      const handleOptionValue = (val, invalidValueMessage, valueSource) => {
-        if (val == null && option.presetArg !== undefined) {
-          val = option.presetArg;
-        }
-        const oldValue = this.getOptionValue(name);
-        if (val !== null && option.parseArg) {
-          val = this._callParseArg(option, val, oldValue, invalidValueMessage);
-        } else if (val !== null && option.variadic) {
-          val = option._concatValue(val, oldValue);
-        }
-        if (val == null) {
-          if (option.negate) {
-            val = false;
-          } else if (option.isBoolean() || option.optional) {
-            val = true;
-          } else {
-            val = "";
-          }
-        }
-        this.setOptionValueWithSource(name, val, valueSource);
-      };
-      this.on("option:" + oname, (val) => {
-        const invalidValueMessage = `error: option '${option.flags}' argument '${val}' is invalid.`;
-        handleOptionValue(val, invalidValueMessage, "cli");
-      });
-      if (option.envVar) {
-        this.on("optionEnv:" + oname, (val) => {
-          const invalidValueMessage = `error: option '${option.flags}' value '${val}' from env '${option.envVar}' is invalid.`;
-          handleOptionValue(val, invalidValueMessage, "env");
-        });
-      }
-      return this;
-    }
-    _optionEx(config, flags, description, fn, defaultValue) {
-      if (typeof flags === "object" && flags instanceof Option) {
-        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);
-      if (typeof fn === "function") {
-        option.default(defaultValue).argParser(fn);
-      } else if (fn instanceof RegExp) {
-        const regex = fn;
-        fn = (val, def) => {
-          const m = regex.exec(val);
-          return m ? m[0] : def;
-        };
-        option.default(defaultValue).argParser(fn);
-      } else {
-        option.default(fn);
-      }
-      return this.addOption(option);
-    }
-    option(flags, description, parseArg, defaultValue) {
-      return this._optionEx({}, flags, description, parseArg, defaultValue);
-    }
-    requiredOption(flags, description, parseArg, defaultValue) {
-      return this._optionEx({ mandatory: true }, flags, description, parseArg, defaultValue);
-    }
-    combineFlagAndOptionalValue(combine = true) {
-      this._combineFlagAndOptionalValue = !!combine;
-      return this;
-    }
-    allowUnknownOption(allowUnknown = true) {
-      this._allowUnknownOption = !!allowUnknown;
-      return this;
-    }
-    allowExcessArguments(allowExcess = true) {
-      this._allowExcessArguments = !!allowExcess;
-      return this;
-    }
-    enablePositionalOptions(positional = true) {
-      this._enablePositionalOptions = !!positional;
-      return this;
-    }
-    passThroughOptions(passThrough = true) {
-      this._passThroughOptions = !!passThrough;
-      this._checkForBrokenPassThrough();
-      return this;
-    }
-    _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)`);
-      }
-    }
-    storeOptionsAsProperties(storeAsProperties = true) {
-      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;
-    }
-    getOptionValue(key) {
-      if (this._storeOptionsAsProperties) {
-        return this[key];
-      }
-      return this._optionValues[key];
-    }
-    setOptionValue(key, value) {
-      return this.setOptionValueWithSource(key, value, undefined);
-    }
-    setOptionValueWithSource(key, value, source) {
-      if (this._storeOptionsAsProperties) {
-        this[key] = value;
-      } else {
-        this._optionValues[key] = value;
-      }
-      this._optionValueSources[key] = source;
-      return this;
-    }
-    getOptionValueSource(key) {
-      return this._optionValueSources[key];
-    }
-    getOptionValueSourceWithGlobals(key) {
-      let source;
-      this._getCommandAndAncestors().forEach((cmd) => {
-        if (cmd.getOptionValueSource(key) !== undefined) {
-          source = cmd.getOptionValueSource(key);
-        }
-      });
-      return source;
-    }
-    _prepareUserArgs(argv, parseOptions) {
-      if (argv !== undefined && !Array.isArray(argv)) {
-        throw new Error("first parameter to parse must be array or undefined");
-      }
-      parseOptions = parseOptions || {};
-      if (argv === undefined && parseOptions.from === undefined) {
-        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 === undefined) {
-        argv = process2.argv;
-      }
-      this.rawArgs = argv.slice();
-      let userArgs;
-      switch (parseOptions.from) {
-        case undefined:
-        case "node":
-          this._scriptPath = argv[1];
-          userArgs = argv.slice(2);
-          break;
-        case "electron":
-          if (process2.defaultApp) {
-            this._scriptPath = argv[1];
-            userArgs = argv.slice(2);
-          } else {
-            userArgs = argv.slice(1);
-          }
-          break;
-        case "user":
-          userArgs = argv.slice(0);
-          break;
-        case "eval":
-          userArgs = argv.slice(1);
-          break;
-        default:
-          throw new Error(`unexpected parse option { from: '${parseOptions.from}' }`);
-      }
-      if (!this._name && this._scriptPath)
-        this.nameFromFilename(this._scriptPath);
-      this._name = this._name || "program";
-      return userArgs;
-    }
-    parse(argv, parseOptions) {
-      const userArgs = this._prepareUserArgs(argv, parseOptions);
-      this._parseCommand([], userArgs);
-      return this;
-    }
-    async parseAsync(argv, parseOptions) {
-      const userArgs = this._prepareUserArgs(argv, parseOptions);
-      await this._parseCommand([], userArgs);
-      return this;
-    }
-    _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;
-        const foundExt = sourceExt.find((ext) => fs.existsSync(`${localBin}${ext}`));
-        if (foundExt)
-          return `${localBin}${foundExt}`;
-        return;
-      }
-      this._checkForMissingMandatoryOptions();
-      this._checkForConflictingOptions();
-      let executableFile = subcommand._executableFile || `${this._name}-${subcommand._name}`;
-      let executableDir = this._executableDir || "";
-      if (this._scriptPath) {
-        let resolvedScriptPath;
-        try {
-          resolvedScriptPath = fs.realpathSync(this._scriptPath);
-        } catch (err) {
-          resolvedScriptPath = this._scriptPath;
-        }
-        executableDir = path.resolve(path.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));
-          if (legacyName !== this._name) {
-            localFile = findFile(executableDir, `${legacyName}-${subcommand._name}`);
-          }
-        }
-        executableFile = localFile || executableFile;
-      }
-      launchWithNode = sourceExt.includes(path.extname(executableFile));
-      let proc;
-      if (process2.platform !== "win32") {
-        if (launchWithNode) {
-          args.unshift(executableFile);
-          args = incrementNodeInspectorPort(process2.execArgv).concat(args);
-          proc = childProcess.spawn(process2.argv[0], args, { stdio: "inherit" });
-        } else {
-          proc = childProcess.spawn(executableFile, args, { stdio: "inherit" });
-        }
-      } else {
-        args.unshift(executableFile);
-        args = incrementNodeInspectorPort(process2.execArgv).concat(args);
-        proc = childProcess.spawn(process2.execPath, args, { stdio: "inherit" });
-      }
-      if (!proc.killed) {
-        const signals = ["SIGUSR1", "SIGUSR2", "SIGTERM", "SIGINT", "SIGHUP"];
-        signals.forEach((signal) => {
-          process2.on(signal, () => {
-            if (proc.killed === false && proc.exitCode === null) {
-              proc.kill(signal);
-            }
-          });
-        });
-      }
-      const exitCallback = this._exitCallback;
-      proc.on("close", (code) => {
-        code = code ?? 1;
-        if (!exitCallback) {
-          process2.exit(code);
-        } else {
-          exitCallback(new CommanderError(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);
-        } else if (err.code === "EACCES") {
-          throw new Error(`'${executableFile}' not executable`);
-        }
-        if (!exitCallback) {
-          process2.exit(1);
-        } else {
-          const wrappedError = new CommanderError(1, "commander.executeSubCommandAsync", "(error)");
-          wrappedError.nestedError = err;
-          exitCallback(wrappedError);
-        }
-      });
-      this.runningCommand = proc;
-    }
-    _dispatchSubcommand(commandName, operands, unknown) {
-      const subCommand = this._findCommand(commandName);
-      if (!subCommand)
-        this.help({ error: true });
-      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 promiseChain;
-    }
-    _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"]);
-    }
-    _checkNumberOfArguments() {
-      this.registeredArguments.forEach((arg, i) => {
-        if (arg.required && this.args[i] == null) {
-          this.missingArgument(arg.name());
-        }
-      });
-      if (this.registeredArguments.length > 0 && this.registeredArguments[this.registeredArguments.length - 1].variadic) {
-        return;
-      }
-      if (this.args.length > this.registeredArguments.length) {
-        this._excessArguments(this.args);
-      }
-    }
-    _processArguments() {
-      const myParseArg = (argument, value, previous) => {
-        let parsedValue = value;
-        if (value !== null && argument.parseArg) {
-          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.registeredArguments.forEach((declaredArg, index) => {
-        let value = declaredArg.defaultValue;
-        if (declaredArg.variadic) {
-          if (index < this.args.length) {
-            value = this.args.slice(index);
-            if (declaredArg.parseArg) {
-              value = value.reduce((processed, v) => {
-                return myParseArg(declaredArg, v, processed);
-              }, declaredArg.defaultValue);
-            }
-          } else if (value === undefined) {
-            value = [];
-          }
-        } else if (index < this.args.length) {
-          value = this.args[index];
-          if (declaredArg.parseArg) {
-            value = myParseArg(declaredArg, value, declaredArg.defaultValue);
-          }
-        }
-        processedArgs[index] = value;
-      });
-      this.processedArgs = processedArgs;
-    }
-    _chainOrCall(promise, fn) {
-      if (promise && promise.then && typeof promise.then === "function") {
-        return promise.then(() => fn());
-      }
-      return fn();
-    }
-    _chainOrCallHooks(promise, event) {
-      let result = promise;
-      const hooks = [];
-      this._getCommandAndAncestors().reverse().filter((cmd) => cmd._lifeCycleHooks[event] !== undefined).forEach((hookedCommand) => {
-        hookedCommand._lifeCycleHooks[event].forEach((callback) => {
-          hooks.push({ hookedCommand, callback });
-        });
-      });
-      if (event === "postAction") {
-        hooks.reverse();
-      }
-      hooks.forEach((hookDetail) => {
-        result = this._chainOrCall(result, () => {
-          return hookDetail.callback(hookDetail.hookedCommand, this);
-        });
-      });
-      return result;
-    }
-    _chainOrCallSubCommandHook(promise, subCommand, event) {
-      let result = promise;
-      if (this._lifeCycleHooks[event] !== undefined) {
-        this._lifeCycleHooks[event].forEach((hook) => {
-          result = this._chainOrCall(result, () => {
-            return hook(this, subCommand);
-          });
-        });
-      }
-      return result;
-    }
-    _parseCommand(operands, unknown) {
-      const parsed = this.parseOptions(unknown);
-      this._parseOptionsEnv();
-      this._parseOptionsImplied();
-      operands = operands.concat(parsed.operands);
-      unknown = parsed.unknown;
-      this.args = operands.concat(unknown);
-      if (operands && this._findCommand(operands[0])) {
-        return this._dispatchSubcommand(operands[0], operands.slice(1), unknown);
-      }
-      if (this._getHelpCommand() && operands[0] === this._getHelpCommand().name()) {
-        return this._dispatchHelpCommand(operands[1]);
-      }
-      if (this._defaultCommandName) {
-        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 });
-      }
-      this._outputHelpIfRequested(parsed.unknown);
-      this._checkForMissingMandatoryOptions();
-      this._checkForConflictingOptions();
-      const checkForUnknownOptions = () => {
-        if (parsed.unknown.length > 0) {
-          this.unknownOption(parsed.unknown[0]);
-        }
-      };
-      const commandEvent = `command:${this.name()}`;
-      if (this._actionHandler) {
-        checkForUnknownOptions();
-        this._processArguments();
-        let promiseChain;
-        promiseChain = this._chainOrCallHooks(promiseChain, "preAction");
-        promiseChain = this._chainOrCall(promiseChain, () => this._actionHandler(this.processedArgs));
-        if (this.parent) {
-          promiseChain = this._chainOrCall(promiseChain, () => {
-            this.parent.emit(commandEvent, operands, unknown);
-          });
-        }
-        promiseChain = this._chainOrCallHooks(promiseChain, "postAction");
-        return promiseChain;
-      }
-      if (this.parent && this.parent.listenerCount(commandEvent)) {
-        checkForUnknownOptions();
-        this._processArguments();
-        this.parent.emit(commandEvent, operands, unknown);
-      } else if (operands.length) {
-        if (this._findCommand("*")) {
-          return this._dispatchSubcommand("*", operands, unknown);
-        }
-        if (this.listenerCount("command:*")) {
-          this.emit("command:*", operands, unknown);
-        } else if (this.commands.length) {
-          this.unknownCommand();
-        } else {
-          checkForUnknownOptions();
-          this._processArguments();
-        }
-      } else if (this.commands.length) {
-        checkForUnknownOptions();
-        this.help({ error: true });
-      } else {
-        checkForUnknownOptions();
-        this._processArguments();
-      }
-    }
-    _findCommand(name) {
-      if (!name)
-        return;
-      return this.commands.find((cmd) => cmd._name === name || cmd._aliases.includes(name));
-    }
-    _findOption(arg) {
-      return this.options.find((option) => option.is(arg));
-    }
-    _checkForMissingMandatoryOptions() {
-      this._getCommandAndAncestors().forEach((cmd) => {
-        cmd.options.forEach((anOption) => {
-          if (anOption.mandatory && cmd.getOptionValue(anOption.attributeName()) === undefined) {
-            cmd.missingMandatoryOptionValue(anOption);
-          }
-        });
-      });
-    }
-    _checkForConflictingLocalOptions() {
-      const definedNonDefaultOptions = this.options.filter((option) => {
-        const optionKey = option.attributeName();
-        if (this.getOptionValue(optionKey) === undefined) {
-          return false;
-        }
-        return this.getOptionValueSource(optionKey) !== "default";
-      });
-      const optionsWithConflicting = definedNonDefaultOptions.filter((option) => option.conflictsWith.length > 0);
-      optionsWithConflicting.forEach((option) => {
-        const conflictingAndDefined = definedNonDefaultOptions.find((defined) => option.conflictsWith.includes(defined.attributeName()));
-        if (conflictingAndDefined) {
-          this._conflictingOption(option, conflictingAndDefined);
-        }
-      });
-    }
-    _checkForConflictingOptions() {
-      this._getCommandAndAncestors().forEach((cmd) => {
-        cmd._checkForConflictingLocalOptions();
-      });
-    }
-    parseOptions(argv) {
-      const operands = [];
-      const unknown = [];
-      let dest = operands;
-      const args = argv.slice();
-      function maybeOption(arg) {
-        return arg.length > 1 && arg[0] === "-";
-      }
-      let activeVariadicOption = null;
-      while (args.length) {
-        const arg = args.shift();
-        if (arg === "--") {
-          if (dest === unknown)
-            dest.push(arg);
-          dest.push(...args);
-          break;
-        }
-        if (activeVariadicOption && !maybeOption(arg)) {
-          this.emit(`option:${activeVariadicOption.name()}`, arg);
-          continue;
-        }
-        activeVariadicOption = null;
-        if (maybeOption(arg)) {
-          const option = this._findOption(arg);
-          if (option) {
-            if (option.required) {
-              const value = args.shift();
-              if (value === undefined)
-                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();
-              }
-              this.emit(`option:${option.name()}`, value);
-            } else {
-              this.emit(`option:${option.name()}`);
-            }
-            activeVariadicOption = option.variadic ? option : null;
-            continue;
-          }
-        }
-        if (arg.length > 2 && arg[0] === "-" && arg[1] !== "-") {
-          const option = this._findOption(`-${arg[1]}`);
-          if (option) {
-            if (option.required || option.optional && this._combineFlagAndOptionalValue) {
-              this.emit(`option:${option.name()}`, arg.slice(2));
-            } else {
-              this.emit(`option:${option.name()}`);
-              args.unshift(`-${arg.slice(2)}`);
-            }
-            continue;
-          }
-        }
-        if (/^--[^=]+=/.test(arg)) {
-          const index = arg.indexOf("=");
-          const option = this._findOption(arg.slice(0, index));
-          if (option && (option.required || option.optional)) {
-            this.emit(`option:${option.name()}`, arg.slice(index + 1));
-            continue;
-          }
-        }
-        if (maybeOption(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);
-            break;
-          } else if (this._getHelpCommand() && arg === this._getHelpCommand().name()) {
-            operands.push(arg);
-            if (args.length > 0)
-              operands.push(...args);
-            break;
-          } else if (this._defaultCommandName) {
-            unknown.push(arg);
-            if (args.length > 0)
-              unknown.push(...args);
-            break;
-          }
-        }
-        if (this._passThroughOptions) {
-          dest.push(arg);
-          if (args.length > 0)
-            dest.push(...args);
-          break;
-        }
-        dest.push(arg);
-      }
-      return { operands, unknown };
-    }
-    opts() {
-      if (this._storeOptionsAsProperties) {
-        const result = {};
-        const len = this.options.length;
-        for (let i = 0;i < len; i++) {
-          const key = this.options[i].attributeName();
-          result[key] = key === this._versionOptionName ? this._version : this[key];
-        }
-        return result;
-      }
-      return this._optionValues;
-    }
-    optsWithGlobals() {
-      return this._getCommandAndAncestors().reduce((combinedOptions, cmd) => Object.assign(combinedOptions, cmd.opts()), {});
-    }
-    error(message, errorOptions) {
-      this._outputConfiguration.outputError(`${message}
-`, this._outputConfiguration.writeErr);
-      if (typeof this._showHelpAfterError === "string") {
-        this._outputConfiguration.writeErr(`${this._showHelpAfterError}
-`);
-      } else if (this._showHelpAfterError) {
-        this._outputConfiguration.writeErr(`
-`);
-        this.outputHelp({ error: true });
-      }
-      const config = errorOptions || {};
-      const exitCode = config.exitCode || 1;
-      const code = config.code || "commander.error";
-      this._exit(exitCode, code, message);
-    }
-    _parseOptionsEnv() {
-      this.options.forEach((option) => {
-        if (option.envVar && option.envVar in process2.env) {
-          const optionKey = option.attributeName();
-          if (this.getOptionValue(optionKey) === undefined || ["default", "config", "env"].includes(this.getOptionValueSource(optionKey))) {
-            if (option.required || option.optional) {
-              this.emit(`optionEnv:${option.name()}`, process2.env[option.envVar]);
-            } else {
-              this.emit(`optionEnv:${option.name()}`);
-            }
-          }
-        }
-      });
-    }
-    _parseOptionsImplied() {
-      const dualHelper = new DualOptions(this.options);
-      const hasCustomOptionValue = (optionKey) => {
-        return this.getOptionValue(optionKey) !== undefined && !["default", "implied"].includes(this.getOptionValueSource(optionKey));
-      };
-      this.options.filter((option) => option.implied !== undefined && 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");
-        });
-      });
-    }
-    missingArgument(name) {
-      const message = `error: missing required argument '${name}'`;
-      this.error(message, { code: "commander.missingArgument" });
-    }
-    optionMissingArgument(option) {
-      const message = `error: option '${option.flags}' argument missing`;
-      this.error(message, { code: "commander.optionMissingArgument" });
-    }
-    missingMandatoryOptionValue(option) {
-      const message = `error: required option '${option.flags}' not specified`;
-      this.error(message, { code: "commander.missingMandatoryOptionValue" });
-    }
-    _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());
-        if (negativeOption && (negativeOption.presetArg === undefined && optionValue === false || negativeOption.presetArg !== undefined && optionValue === negativeOption.presetArg)) {
-          return negativeOption;
-        }
-        return positiveOption || option2;
-      };
-      const getErrorMessage = (option2) => {
-        const bestOption = findBestOptionFromValue(option2);
-        const optionKey = bestOption.attributeName();
-        const source = this.getOptionValueSource(optionKey);
-        if (source === "env") {
-          return `environment variable '${bestOption.envVar}'`;
-        }
-        return `option '${bestOption.flags}'`;
-      };
-      const message = `error: ${getErrorMessage(option)} cannot be used with ${getErrorMessage(conflictingOption)}`;
-      this.error(message, { code: "commander.conflictingOption" });
-    }
-    unknownOption(flag) {
-      if (this._allowUnknownOption)
-        return;
-      let suggestion = "";
-      if (flag.startsWith("--") && this._showSuggestionAfterError) {
-        let candidateFlags = [];
-        let command = this;
-        do {
-          const moreFlags = command.createHelp().visibleOptions(command).filter((option) => option.long).map((option) => option.long);
-          candidateFlags = candidateFlags.concat(moreFlags);
-          command = command.parent;
-        } while (command && !command._enablePositionalOptions);
-        suggestion = suggestSimilar(flag, candidateFlags);
-      }
-      const message = `error: unknown option '${flag}'${suggestion}`;
-      this.error(message, { code: "commander.unknownOption" });
-    }
-    _excessArguments(receivedArgs) {
-      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}.`;
-      this.error(message, { code: "commander.excessArguments" });
-    }
-    unknownCommand() {
-      const unknownName = this.args[0];
-      let suggestion = "";
-      if (this._showSuggestionAfterError) {
-        const candidateNames = [];
-        this.createHelp().visibleCommands(this).forEach((command) => {
-          candidateNames.push(command.name());
-          if (command.alias())
-            candidateNames.push(command.alias());
-        });
-        suggestion = suggestSimilar(unknownName, candidateNames);
-      }
-      const message = `error: unknown command '${unknownName}'${suggestion}`;
-      this.error(message, { code: "commander.unknownCommand" });
-    }
-    version(str, flags, description) {
-      if (str === undefined)
-        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._registerOption(versionOption);
-      this.on("option:" + versionOption.name(), () => {
-        this._outputConfiguration.writeOut(`${str}
-`);
-        this._exit(0, "commander.version", str);
-      });
-      return this;
-    }
-    description(str, argsDescription) {
-      if (str === undefined && argsDescription === undefined)
-        return this._description;
-      this._description = str;
-      if (argsDescription) {
-        this._argsDescription = argsDescription;
-      }
-      return this;
-    }
-    summary(str) {
-      if (str === undefined)
-        return this._summary;
-      this._summary = str;
-      return this;
-    }
-    alias(alias) {
-      if (alias === undefined)
-        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;
-    }
-    aliases(aliases) {
-      if (aliases === undefined)
-        return this._aliases;
-      aliases.forEach((alias) => this.alias(alias));
-      return this;
-    }
-    usage(str) {
-      if (str === undefined) {
-        if (this._usage)
-          return this._usage;
-        const args = this.registeredArguments.map((arg) => {
-          return humanReadableArgName(arg);
-        });
-        return [].concat(this.options.length || this._helpOption !== null ? "[options]" : [], this.commands.length ? "[command]" : [], this.registeredArguments.length ? args : []).join(" ");
-      }
-      this._usage = str;
-      return this;
-    }
-    name(str) {
-      if (str === undefined)
-        return this._name;
-      this._name = str;
-      return this;
-    }
-    nameFromFilename(filename) {
-      this._name = path.basename(filename, path.extname(filename));
-      return this;
-    }
-    executableDir(path2) {
-      if (path2 === undefined)
-        return this._executableDir;
-      this._executableDir = path2;
-      return this;
-    }
-    helpInformation(contextOptions) {
-      const helper = this.createHelp();
-      if (helper.helpWidth === undefined) {
-        helper.helpWidth = contextOptions && contextOptions.error ? this._outputConfiguration.getErrHelpWidth() : this._outputConfiguration.getOutHelpWidth();
-      }
-      return helper.formatHelp(this, helper);
-    }
-    _getHelpContext(contextOptions) {
-      contextOptions = contextOptions || {};
-      const context = { error: !!contextOptions.error };
-      let write;
-      if (context.error) {
-        write = (arg) => this._outputConfiguration.writeErr(arg);
-      } else {
-        write = (arg) => this._outputConfiguration.writeOut(arg);
-      }
-      context.write = contextOptions.write || write;
-      context.command = this;
-      return context;
-    }
-    outputHelp(contextOptions) {
-      let deprecatedCallback;
-      if (typeof contextOptions === "function") {
-        deprecatedCallback = contextOptions;
-        contextOptions = undefined;
-      }
-      const context = this._getHelpContext(contextOptions);
-      this._getCommandAndAncestors().reverse().forEach((command) => command.emit("beforeAllHelp", context));
-      this.emit("beforeHelp", context);
-      let helpInformation = this.helpInformation(context);
-      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);
-      if (this._getHelpOption()?.long) {
-        this.emit(this._getHelpOption().long);
-      }
-      this.emit("afterHelp", context);
-      this._getCommandAndAncestors().forEach((command) => command.emit("afterAllHelp", context));
-    }
-    helpOption(flags, description) {
-      if (typeof flags === "boolean") {
-        if (flags) {
-          this._helpOption = this._helpOption ?? undefined;
-        } else {
-          this._helpOption = null;
-        }
-        return this;
-      }
-      flags = flags ?? "-h, --help";
-      description = description ?? "display help for command";
-      this._helpOption = this.createOption(flags, description);
-      return this;
-    }
-    _getHelpOption() {
-      if (this._helpOption === undefined) {
-        this.helpOption(undefined, undefined);
-      }
-      return this._helpOption;
-    }
-    addHelpOption(option) {
-      this._helpOption = option;
-      return this;
-    }
-    help(contextOptions) {
-      this.outputHelp(contextOptions);
-      let exitCode = process2.exitCode || 0;
-      if (exitCode === 0 && contextOptions && typeof contextOptions !== "function" && contextOptions.error) {
-        exitCode = 1;
-      }
-      this._exit(exitCode, "commander.help", "(outputHelp)");
-    }
-    addHelpText(position, text) {
-      const allowedValues = ["beforeAll", "before", "after", "afterAll"];
-      if (!allowedValues.includes(position)) {
-        throw new Error(`Unexpected value for position to addHelpText.
-Expecting one of '${allowedValues.join("', '")}'`);
-      }
-      const helpEvent = `${position}Help`;
-      this.on(helpEvent, (context) => {
-        let helpStr;
-        if (typeof text === "function") {
-          helpStr = text({ error: context.error, command: context.command });
-        } else {
-          helpStr = text;
-        }
-        if (helpStr) {
-          context.write(`${helpStr}
-`);
-        }
-      });
-      return this;
-    }
-    _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")) {
-        return arg;
-      }
-      let debugOption;
-      let debugHost = "127.0.0.1";
-      let debugPort = "9229";
-      let match;
-      if ((match = arg.match(/^(--inspect(-brk)?)$/)) !== null) {
-        debugOption = match[1];
-      } else if ((match = arg.match(/^(--inspect(-brk|-port)?)=([^:]+)$/)) !== null) {
-        debugOption = match[1];
-        if (/^\d+$/.test(match[3])) {
-          debugPort = match[3];
-        } else {
-          debugHost = match[3];
-        }
-      } else if ((match = arg.match(/^(--inspect(-brk|-port)?)=([^:]+):(\d+)$/)) !== null) {
-        debugOption = match[1];
-        debugHost = match[3];
-        debugPort = match[4];
-      }
-      if (debugOption && debugPort !== "0") {
-        return `${debugOption}=${debugHost}:${parseInt(debugPort) + 1}`;
-      }
-      return arg;
-    });
-  }
-  exports.Command = Command;
-});
-
-// node_modules/commander/index.js
-var require_commander = __commonJS((exports) => {
-  var { Argument } = require_argument();
-  var { Command } = require_command();
-  var { CommanderError, InvalidArgumentError } = require_error();
-  var { Help } = require_help();
-  var { Option } = require_option();
-  exports.program = new Command;
-  exports.createCommand = (name) => new Command(name);
-  exports.createOption = (flags, description) => new Option(flags, description);
-  exports.createArgument = (name, description) => new Argument(name, description);
-  exports.Command = Command;
-  exports.Option = Option;
-  exports.Argument = Argument;
-  exports.Help = Help;
-  exports.CommanderError = CommanderError;
-  exports.InvalidArgumentError = InvalidArgumentError;
-  exports.InvalidOptionArgumentError = InvalidArgumentError;
-});
-
 // src/core/paths.ts
 import { join, dirname } from "path";
 import { homedir } from "os";
@@ -10230,7 +8391,7 @@ function checkLatestVersion() {
   }
 }
 function getCurrentVersion() {
-  return "0.15.12";
+  return "0.15.14";
 }
 function formatVersionLine(current, skipCheck) {
   if (skipCheck) {
@@ -12443,7 +10604,7 @@ async function execute17(paths) {
   const gm = new GenerationManager(paths);
   const state = await gm.current();
   const configContent = await readTextFile(paths.config);
-  const installedVersion = "0.15.12";
+  const installedVersion = "0.15.14";
   const autoUpdate = configContent?.match(/autoUpdate:\s*(true|false)/)?.[1] === "true";
   const versionDisplay = formatVersionLine(installedVersion, !autoUpdate);
   const rawLang = detectLanguage(configContent);
@@ -14171,7 +12332,7 @@ async function execute30(paths) {
   const lines = [
     `REAP Configuration (${paths.config})`,
     "",
-    `  version:         ${"0.15.12"} (package)`,
+    `  version:         ${"0.15.14"} (package)`,
     `  project:         ${config.project}`,
     `  entryMode:       ${config.entryMode}`,
     `  strict:          ${config.strict ?? false}`,
@@ -14477,7 +12638,7 @@ async function runCommand(command, phase, argv = []) {
     try {
       const config = await ConfigManager.read(paths);
       if (config.autoIssueReport) {
-        const version = "0.15.12";
+        const version = "0.15.14";
         const errMsg = err instanceof Error ? err.message : String(err);
         const title = `[auto] reap run ${command}: ${errMsg.slice(0, 80)}`;
         const body = [
@@ -14531,21 +12692,692 @@ var init_run = __esm(() => {
   };
 });
 
-// node_modules/commander/esm.mjs
-var import__ = __toESM(require_commander(), 1);
-var {
-  program,
-  createCommand,
-  createArgument,
-  createOption,
-  CommanderError,
-  InvalidArgumentError,
-  InvalidOptionArgumentError,
-  Command,
-  Argument,
-  Option,
-  Help
-} = import__.default;
+// src/libs/cli.ts
+function parseOptionFlags(flags) {
+  const parts = flags.split(/,\s*/);
+  let short;
+  let long = "";
+  let boolean = true;
+  let required = false;
+  let variadic = false;
+  let argName;
+  let negate = false;
+  for (const part of parts) {
+    const trimmed = part.trim();
+    if (trimmed.startsWith("--")) {
+      const match = trimmed.match(/^(--\S+)\s*(.*)$/);
+      if (match) {
+        long = match[1];
+        const valuePart = match[2].trim();
+        if (valuePart) {
+          boolean = false;
+          if (valuePart.startsWith("<")) {
+            required = true;
+            argName = valuePart.replace(/[<>]/g, "").replace(/\.{3}$/, "");
+            variadic = valuePart.includes("...");
+          } else if (valuePart.startsWith("[")) {
+            required = false;
+            argName = valuePart.replace(/[\[\]]/g, "").replace(/\.{3}$/, "");
+            variadic = valuePart.includes("...");
+          }
+        }
+      }
+    } else if (trimmed.startsWith("-")) {
+      const match = trimmed.match(/^(-\S)\s*(.*)$/);
+      if (match) {
+        short = match[1];
+        const valuePart = match[2].trim();
+        if (valuePart && !long) {
+          boolean = false;
+          if (valuePart.startsWith("<")) {
+            required = true;
+            argName = valuePart.replace(/[<>]/g, "").replace(/\.{3}$/, "");
+            variadic = valuePart.includes("...");
+          } else if (valuePart.startsWith("[")) {
+            required = false;
+            argName = valuePart.replace(/[\[\]]/g, "").replace(/\.{3}$/, "");
+            variadic = valuePart.includes("...");
+          }
+        }
+      }
+    }
+  }
+  if (long.startsWith("--no-")) {
+    negate = true;
+    boolean = true;
+  }
+  return { short, long, boolean, required, variadic, argName, negate };
+}
+function optionAttributeName(long) {
+  let name = long.replace(/^--/, "").replace(/^no-/, "");
+  return name.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+}
+function parseArgumentSyntax(syntax) {
+  const trimmed = syntax.trim();
+  let required = false;
+  let variadic = false;
+  let name = trimmed;
+  if (trimmed.startsWith("<") && trimmed.endsWith(">")) {
+    required = true;
+    name = trimmed.slice(1, -1);
+  } else if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+    required = false;
+    name = trimmed.slice(1, -1);
+  }
+  if (name.endsWith("...")) {
+    variadic = true;
+    name = name.slice(0, -3);
+  }
+  return { name, required, variadic };
+}
+
+class Command {
+  _name = "";
+  _description = "";
+  _version = "";
+  _versionFlags = "-V, --version";
+  _aliases = [];
+  _options = [];
+  _arguments = [];
+  _commands = [];
+  _actionHandler;
+  _parent;
+  _allowUnknown = false;
+  _passthrough = false;
+  _helpOption = {
+    flags: "-h, --help",
+    description: "display help for command"
+  };
+  _preActionHooks = [];
+  _postActionHooks = [];
+  _showHelpAfterError = false;
+  _configureOutput;
+  _exitCallback;
+  _exitOverride = false;
+  _executableHandler = false;
+  _defaultCommandName;
+  _addHelpCommand;
+  _hidden = false;
+  _combineFlagAndOptionalValue = true;
+  _rawArgs = [];
+  constructor(name) {
+    if (name)
+      this._name = name;
+  }
+  name(str) {
+    if (str === undefined)
+      return this._name;
+    this._name = str;
+    return this;
+  }
+  description(str) {
+    if (str === undefined)
+      return this._description;
+    this._description = str;
+    return this;
+  }
+  version(str, flags, _description) {
+    if (str === undefined)
+      return this._version;
+    this._version = str;
+    if (flags)
+      this._versionFlags = flags;
+    return this;
+  }
+  alias(name) {
+    this._aliases.push(name);
+    return this;
+  }
+  aliases(names) {
+    names.forEach((n) => this._aliases.push(n));
+    return this;
+  }
+  command(nameAndArgs, descOrOpts, opts) {
+    const parts = nameAndArgs.trim().split(/\s+/);
+    const cmdName = parts[0];
+    const argDefs = parts.slice(1);
+    if (typeof descOrOpts === "string") {
+      const sub2 = new Command(cmdName);
+      sub2._description = descOrOpts;
+      sub2._executableHandler = true;
+      sub2._parent = this;
+      if (opts?.hidden)
+        sub2._hidden = true;
+      if (opts?.isDefault)
+        this._defaultCommandName = cmdName;
+      for (const argStr of argDefs) {
+        const argDef = parseArgumentSyntax(argStr);
+        sub2._arguments.push({ ...argDef, description: "", defaultValue: undefined });
+      }
+      this._commands.push(sub2);
+      return this;
+    }
+    const sub = new Command(cmdName);
+    sub._parent = this;
+    if (descOrOpts?.hidden)
+      sub._hidden = true;
+    if (descOrOpts?.isDefault)
+      this._defaultCommandName = cmdName;
+    for (const argStr of argDefs) {
+      const argDef = parseArgumentSyntax(argStr);
+      sub._arguments.push({ ...argDef, description: "", defaultValue: undefined });
+    }
+    this._commands.push(sub);
+    return sub;
+  }
+  addCommand(cmd, opts) {
+    cmd._parent = this;
+    if (opts?.hidden)
+      cmd._hidden = true;
+    if (opts?.isDefault)
+      this._defaultCommandName = cmd._name;
+    this._commands.push(cmd);
+    return this;
+  }
+  argument(syntax, description, defaultValue) {
+    const argDef = parseArgumentSyntax(syntax);
+    this._arguments.push({
+      ...argDef,
+      description: description ?? "",
+      defaultValue
+    });
+    return this;
+  }
+  arguments(syntax) {
+    const parts = syntax.trim().split(/\s+/);
+    for (const part of parts) {
+      this.argument(part);
+    }
+    return this;
+  }
+  option(flags, description, defaultValue) {
+    const parsed = parseOptionFlags(flags);
+    this._options.push({
+      ...parsed,
+      description: description ?? "",
+      required: parsed.required,
+      defaultValue,
+      negate: parsed.negate
+    });
+    return this;
+  }
+  requiredOption(flags, description, defaultValue) {
+    const parsed = parseOptionFlags(flags);
+    this._options.push({
+      ...parsed,
+      description: description ?? "",
+      required: true,
+      defaultValue,
+      negate: parsed.negate
+    });
+    return this;
+  }
+  addOption(opt) {
+    this._options.push(opt);
+    return this;
+  }
+  action(fn) {
+    this._actionHandler = fn;
+    return this;
+  }
+  allowUnknownOption(allow = true) {
+    this._allowUnknown = allow;
+    return this;
+  }
+  allowExcessArguments(_allow = true) {
+    return this;
+  }
+  enablePositionalOptions(_enable = true) {
+    return this;
+  }
+  passThroughOptions(passthrough = true) {
+    this._passthrough = passthrough;
+    return this;
+  }
+  storeOptionsAsProperties(_store = true) {
+    return this;
+  }
+  combineFlagAndOptionalValue(combine = true) {
+    this._combineFlagAndOptionalValue = combine;
+    return this;
+  }
+  helpOption(flags, description) {
+    if (flags === false) {
+      this._helpOption = false;
+    } else {
+      this._helpOption = { flags, description: description ?? "display help for command" };
+    }
+    return this;
+  }
+  addHelpText(_position, _text) {
+    return this;
+  }
+  addHelpCommand(enable) {
+    if (typeof enable === "boolean") {
+      this._addHelpCommand = enable;
+    } else {
+      this._addHelpCommand = true;
+    }
+    return this;
+  }
+  showHelpAfterError(show = true) {
+    this._showHelpAfterError = show;
+    return this;
+  }
+  showSuggestionAfterError(_show = true) {
+    return this;
+  }
+  configureOutput(config) {
+    this._configureOutput = config;
+    return this;
+  }
+  exitOverride(fn) {
+    this._exitOverride = true;
+    if (fn)
+      this._exitCallback = (_code, err) => {
+        if (err)
+          fn(err);
+      };
+    return this;
+  }
+  hook(event, fn) {
+    if (event === "preAction")
+      this._preActionHooks.push(fn);
+    else
+      this._postActionHooks.push(fn);
+    return this;
+  }
+  hidden(hide = true) {
+    this._hidden = hide;
+    return this;
+  }
+  get args() {
+    return this._rawArgs;
+  }
+  get commands() {
+    return this._commands;
+  }
+  get parent() {
+    return this._parent;
+  }
+  opts() {
+    return this._parsedOptions;
+  }
+  getOptionValue(key) {
+    return this._parsedOptions?.[key];
+  }
+  setOptionValue(key, value) {
+    this._parsedOptions[key] = value;
+    return this;
+  }
+  _parsedOptions = {};
+  parse(argv, opts) {
+    const args = argv ?? process.argv;
+    const from = opts?.from ?? "node";
+    const userArgs = from === "user" ? args : args.slice(2);
+    this._parseArgs(userArgs);
+    return this;
+  }
+  parseAsync(argv, opts) {
+    const args = argv ?? process.argv;
+    const from = opts?.from ?? "node";
+    const userArgs = from === "user" ? args : args.slice(2);
+    return this._parseArgs(userArgs, true);
+  }
+  _parseArgs(argv, async = false) {
+    this._parsedOptions = {};
+    this._rawArgs = [];
+    for (const opt of this._options) {
+      if (opt.defaultValue !== undefined) {
+        const key = optionAttributeName(opt.long);
+        this._parsedOptions[key] = opt.defaultValue;
+      }
+      if (opt.negate) {
+        const key = optionAttributeName(opt.long);
+        this._parsedOptions[key] = true;
+      }
+    }
+    const firstNonFlag = argv.find((a) => !a.startsWith("-"));
+    if (firstNonFlag) {
+      const sub = this._findCommand(firstNonFlag);
+      if (sub) {
+        const idx = argv.indexOf(firstNonFlag);
+        const subArgv = [...argv.slice(0, idx), ...argv.slice(idx + 1)];
+        if (async) {
+          return sub._parseArgs(subArgv, true);
+        }
+        sub._parseArgs(subArgv);
+        return this;
+      }
+    }
+    if (this._version) {
+      const vParsed = parseOptionFlags(this._versionFlags);
+      if (argv.includes(vParsed.long) || vParsed.short && argv.includes(vParsed.short)) {
+        this._writeOut(`${this._version}
+`);
+        this._exit(0);
+        return this;
+      }
+    }
+    if (this._helpOption && this._checkHelp(argv)) {
+      this.outputHelp();
+      this._exit(0);
+      return this;
+    }
+    if (!firstNonFlag) {
+      if (this._defaultCommandName) {
+        const defaultCmd = this._findCommand(this._defaultCommandName);
+        if (defaultCmd) {
+          if (async) {
+            return defaultCmd._parseArgs(argv, true);
+          }
+          defaultCmd._parseArgs(argv);
+          return this;
+        }
+      }
+    }
+    const positionals = [];
+    const unknowns = [];
+    let i = 0;
+    while (i < argv.length) {
+      const arg = argv[i];
+      if (arg === "--") {
+        positionals.push(...argv.slice(i + 1));
+        break;
+      }
+      if (arg.startsWith("--")) {
+        const eqIdx = arg.indexOf("=");
+        const flag = eqIdx !== -1 ? arg.slice(0, eqIdx) : arg;
+        const opt = this._findOption(flag);
+        if (opt) {
+          const key = optionAttributeName(opt.long);
+          if (opt.negate) {
+            this._parsedOptions[key] = false;
+          } else if (opt.boolean) {
+            this._parsedOptions[key] = true;
+          } else if (eqIdx !== -1) {
+            const val = arg.slice(eqIdx + 1);
+            this._parsedOptions[key] = opt.variadic ? [...this._parsedOptions[key] ?? [], val] : val;
+          } else {
+            i++;
+            if (i >= argv.length) {
+              this._writeErr(`error: option '${flag}' argument missing
+`);
+              this._exit(1);
+              return this;
+            }
+            const val = argv[i];
+            if (opt.variadic) {
+              const arr = this._parsedOptions[key] ?? [];
+              arr.push(val);
+              this._parsedOptions[key] = arr;
+              while (i + 1 < argv.length && !argv[i + 1].startsWith("-")) {
+                i++;
+                arr.push(argv[i]);
+              }
+            } else {
+              this._parsedOptions[key] = val;
+            }
+          }
+        } else if (this._allowUnknown) {
+          unknowns.push(arg);
+          if (eqIdx === -1 && i + 1 < argv.length && !argv[i + 1].startsWith("-")) {
+            i++;
+            unknowns.push(argv[i]);
+          }
+        } else {
+          this._writeErr(`error: unknown option '${arg}'
+`);
+          if (this._showHelpAfterError)
+            this.outputHelp();
+          this._exit(1);
+          return this;
+        }
+      } else if (arg.startsWith("-") && arg.length > 1 && !arg.startsWith("-")) {
+        const chars = arg.slice(1);
+        for (let j = 0;j < chars.length; j++) {
+          const flag = `-${chars[j]}`;
+          const opt = this._findOption(flag);
+          if (opt) {
+            const key = optionAttributeName(opt.long);
+            if (opt.boolean) {
+              if (opt.negate) {
+                this._parsedOptions[key] = false;
+              } else {
+                this._parsedOptions[key] = true;
+              }
+            } else {
+              const rest = chars.slice(j + 1);
+              if (rest && this._combineFlagAndOptionalValue) {
+                this._parsedOptions[key] = rest;
+              } else if (rest) {
+                this._parsedOptions[key] = rest;
+              } else {
+                i++;
+                if (i >= argv.length) {
+                  this._writeErr(`error: option '${flag}' argument missing
+`);
+                  this._exit(1);
+                  return this;
+                }
+                this._parsedOptions[key] = argv[i];
+              }
+              break;
+            }
+          } else if (this._allowUnknown) {
+            unknowns.push(flag);
+          } else {
+            this._writeErr(`error: unknown option '${flag}'
+`);
+            if (this._showHelpAfterError)
+              this.outputHelp();
+            this._exit(1);
+            return this;
+          }
+        }
+      } else {
+        positionals.push(arg);
+        if (this._passthrough) {
+          positionals.push(...argv.slice(i + 1));
+          break;
+        }
+      }
+      i++;
+    }
+    for (const opt of this._options) {
+      if (opt.choices) {
+        const key = optionAttributeName(opt.long);
+        const val = this._parsedOptions[key];
+        if (val !== undefined && !opt.choices.includes(String(val))) {
+          this._writeErr(`error: option '${opt.long}' must be one of: ${opt.choices.join(", ")} (received '${val}')
+`);
+          this._exit(1);
+          return this;
+        }
+      }
+    }
+    for (const opt of this._options) {
+      if (opt.envVar) {
+        const key = optionAttributeName(opt.long);
+        if (this._parsedOptions[key] === undefined && process.env[opt.envVar] !== undefined) {
+          this._parsedOptions[key] = opt.boolean ? process.env[opt.envVar] !== "0" && process.env[opt.envVar] !== "false" : process.env[opt.envVar];
+        }
+      }
+    }
+    this._rawArgs = [...positionals, ...unknowns];
+    const argValues = [];
+    for (let ai = 0;ai < this._arguments.length; ai++) {
+      const argDef = this._arguments[ai];
+      if (argDef.variadic) {
+        argValues.push(positionals.slice(ai));
+        break;
+      } else if (ai < positionals.length) {
+        argValues.push(positionals[ai]);
+      } else if (argDef.defaultValue !== undefined) {
+        argValues.push(argDef.defaultValue);
+      } else {
+        argValues.push(undefined);
+      }
+    }
+    if (this._actionHandler) {
+      const actionArgs = [...argValues, this._parsedOptions, this];
+      if (async) {
+        return (async () => {
+          for (const hook of this._preActionHooks)
+            await hook(this._parent ?? this, this);
+          await this._actionHandler(...actionArgs);
+          for (const hook of this._postActionHooks)
+            await hook(this._parent ?? this, this);
+          return this;
+        })();
+      }
+      const result = (async () => {
+        for (const hook of this._preActionHooks)
+          await hook(this._parent ?? this, this);
+        await this._actionHandler(...actionArgs);
+        for (const hook of this._postActionHooks)
+          await hook(this._parent ?? this, this);
+      })();
+      result.catch((err) => {
+        this._writeErr(`${err.message}
+`);
+        this._exit(1);
+      });
+    }
+    return this;
+  }
+  outputHelp() {
+    this._writeOut(this.helpInformation());
+  }
+  helpInformation() {
+    const lines = [];
+    const usage = this._buildUsage();
+    lines.push(`Usage: ${usage}`, "");
+    if (this._description) {
+      lines.push(this._description, "");
+    }
+    const visibleArgs = this._arguments.filter((a) => a.description);
+    if (visibleArgs.length > 0) {
+      lines.push("Arguments:");
+      const maxLen = Math.max(...visibleArgs.map((a) => a.name.length));
+      for (const arg of visibleArgs) {
+        const pad = " ".repeat(maxLen - arg.name.length + 2);
+        const def = arg.defaultValue !== undefined ? ` (default: ${JSON.stringify(arg.defaultValue)})` : "";
+        lines.push(`  ${arg.name}${pad}${arg.description}${def}`);
+      }
+      lines.push("");
+    }
+    const visibleOpts = [...this._options];
+    if (this._helpOption) {
+      visibleOpts.push({
+        ...parseOptionFlags(this._helpOption.flags),
+        description: this._helpOption.description,
+        required: false,
+        defaultValue: undefined,
+        negate: false
+      });
+    }
+    if (this._version) {
+      const vParsed = parseOptionFlags(this._versionFlags);
+      visibleOpts.push({
+        ...vParsed,
+        description: "output the version number",
+        required: false,
+        defaultValue: undefined,
+        negate: false
+      });
+    }
+    if (visibleOpts.length > 0) {
+      lines.push("Options:");
+      const formatted = visibleOpts.map((o) => {
+        const flags = [o.short, o.long].filter(Boolean).join(", ");
+        const arg = o.argName ? o.required ? ` <${o.argName}${o.variadic ? "..." : ""}>` : ` [${o.argName}${o.variadic ? "..." : ""}]` : "";
+        return { label: `${flags}${arg}`, desc: o.description, def: o.defaultValue };
+      });
+      const maxLen = Math.max(...formatted.map((f) => f.label.length));
+      for (const f of formatted) {
+        const pad = " ".repeat(maxLen - f.label.length + 2);
+        const def = f.def !== undefined ? ` (default: ${JSON.stringify(f.def)})` : "";
+        lines.push(`  ${f.label}${pad}${f.desc}${def}`);
+      }
+      lines.push("");
+    }
+    const visibleCmds = this._commands.filter((c) => !c._hidden);
+    if (visibleCmds.length > 0) {
+      lines.push("Commands:");
+      const formatted = visibleCmds.map((c) => {
+        const aliases = c._aliases.length > 0 ? `|${c._aliases.join("|")}` : "";
+        return { label: `${c._name}${aliases}`, desc: c._description };
+      });
+      const maxLen = Math.max(...formatted.map((f) => f.label.length));
+      for (const f of formatted) {
+        const pad = " ".repeat(maxLen - f.label.length + 2);
+        lines.push(`  ${f.label}${pad}${f.desc}`);
+      }
+      lines.push("");
+    }
+    return lines.join(`
+`);
+  }
+  help(cb) {
+    let text = this.helpInformation();
+    if (cb)
+      text = cb(text);
+    this._writeOut(text);
+    this._exit(0);
+  }
+  _buildUsage() {
+    const parts = [];
+    const chain = [];
+    let cmd = this;
+    while (cmd) {
+      chain.unshift(cmd);
+      cmd = cmd._parent;
+    }
+    parts.push(chain.map((c) => c._name).filter(Boolean).join(" "));
+    if (this._options.length > 0)
+      parts.push("[options]");
+    if (this._commands.length > 0)
+      parts.push("[command]");
+    for (const arg of this._arguments) {
+      if (arg.required) {
+        parts.push(`<${arg.name}${arg.variadic ? "..." : ""}>`);
+      } else {
+        parts.push(`[${arg.name}${arg.variadic ? "..." : ""}]`);
+      }
+    }
+    return parts.join(" ");
+  }
+  _findCommand(name) {
+    return this._commands.find((c) => c._name === name || c._aliases.includes(name));
+  }
+  _findOption(flag) {
+    return this._options.find((o) => o.long === flag || o.short === flag);
+  }
+  _checkHelp(argv) {
+    if (!this._helpOption)
+      return false;
+    const parsed = parseOptionFlags(this._helpOption.flags);
+    return argv.includes(parsed.long) || parsed.short !== undefined && argv.includes(parsed.short);
+  }
+  _writeOut(str) {
+    (this._configureOutput?.writeOut ?? process.stdout.write.bind(process.stdout))(str);
+  }
+  _writeErr(str) {
+    (this._configureOutput?.writeErr ?? process.stderr.write.bind(process.stderr))(str);
+  }
+  _exit(code, error) {
+    if (this._exitOverride || this._exitCallback) {
+      const err = error ?? new Error(`process exit with code ${code}`);
+      if (this._exitCallback) {
+        this._exitCallback(code, err);
+      }
+      throw err;
+    }
+    process.exit(code);
+  }
+}
+var program = new Command;
 
 // src/cli/index.ts
 import { createInterface } from "readline";
@@ -16127,12 +14959,54 @@ function selfUpgrade() {
     if (installed === latest) {
       return { upgraded: false };
     }
+    const minVersion = queryAutoUpdateMinVersion();
+    if (minVersion && !semverGte(installed, minVersion)) {
+      return {
+        upgraded: false,
+        blocked: true,
+        from: installed,
+        to: latest,
+        reason: `Breaking change: v${installed} -> v${latest}. Run '/reap.update' to upgrade manually. See https://reap.cc/docs/release-notes`
+      };
+    }
     execSync3("npm update -g @c-d-cc/reap", { encoding: "utf-8", timeout: 60000, stdio: "pipe" });
     return { upgraded: true, from: installed, to: latest };
   } catch {
     return { upgraded: false };
   }
 }
+function semverGte(a, b) {
+  const pa = a.split(".").map(Number);
+  const pb = b.split(".").map(Number);
+  for (let i = 0;i < 3; i++) {
+    if ((pa[i] ?? 0) > (pb[i] ?? 0))
+      return true;
+    if ((pa[i] ?? 0) < (pb[i] ?? 0))
+      return false;
+  }
+  return true;
+}
+function forceUpgrade(to) {
+  try {
+    const installed = execSync3("reap --version", { encoding: "utf-8", timeout: 5000 }).trim();
+    execSync3(`npm install -g @c-d-cc/reap@${to}`, { encoding: "utf-8", timeout: 60000, stdio: "pipe" });
+    return { upgraded: true, from: installed, to };
+  } catch {
+    return { upgraded: false };
+  }
+}
+function queryAutoUpdateMinVersion() {
+  try {
+    const result = execSync3("npm view @c-d-cc/reap reap.autoUpdateMinVersion", {
+      encoding: "utf-8",
+      timeout: 1e4,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return result.trim() || null;
+  } catch {
+    return null;
+  }
+}
 async function updateProject(projectRoot, dryRun = false) {
   const paths = new ReapPaths(projectRoot);
   const result = { updated: [], skipped: [], removed: [] };
@@ -16427,7 +15301,7 @@ async function getStatus(projectRoot) {
   const totalCompleted = await mgr.countAllCompleted();
   const integrityResult = await checkIntegrity(paths);
   return {
-    version: "0.15.12",
+    version: "0.15.14",
     project: config.project,
     entryMode: config.entryMode,
     lastSyncedGeneration: config.lastSyncedGeneration,
@@ -16750,7 +15624,7 @@ init_fs();
 init_version();
 init_config();
 import { join as join34 } from "path";
-program.name("reap").description("REAP — Recursive Evolutionary Autonomous Pipeline").version("0.15.12");
+program.name("reap").description("REAP — Recursive Evolutionary Autonomous Pipeline").version("0.15.14");
 program.command("init").description("Initialize a new REAP project (Genesis)").argument("[project-name]", "Project name (defaults to current directory name)").option("-m, --mode <mode>", "Entry mode: greenfield, migration, adoption", "greenfield").option("-p, --preset <preset>", "Bootstrap with a genome preset (e.g., bun-hono-react)").action(async (projectName, options) => {
   try {
     const cwd = process.cwd();
@@ -16807,7 +15681,7 @@ program.command("status").description("Show current project and Generation statu
     const paths = new ReapPaths(cwd);
     const config = await ConfigManager.read(paths);
     const skipCheck = config.autoUpdate === false;
-    const installedVersion = "0.15.12";
+    const installedVersion = "0.15.14";
     const versionLine = formatVersionLine(installedVersion, skipCheck);
     console.log(`${versionLine} | Project: ${status.project} (${status.entryMode})`);
     console.log(`Completed Generations: ${status.totalGenerations}`);
@@ -16879,8 +15753,29 @@ program.command("fix").description("Diagnose and repair .reap/ directory structu
 });
 program.command("update").description("Upgrade REAP package and sync slash commands, templates, and hooks").option("--dry-run", "Show changes without applying them").action(async (options) => {
   try {
-    const upgrade = !options.dryRun ? selfUpgrade() : { upgraded: false };
-    if (upgrade.upgraded) {
+    let upgrade = !options.dryRun ? selfUpgrade() : { upgraded: false };
+    if (upgrade.blocked) {
+      console.log(`
+⚠ Breaking change detected: v${upgrade.from} → v${upgrade.to}`);
+      console.log(`  This update contains breaking changes that may require manual migration.`);
+      console.log(`  See release notes: https://reap.cc/docs/release-notes
+`);
+      const rl = createInterface({ input: process.stdin, output: process.stdout });
+      const answer = await new Promise((resolve) => {
+        rl.question("  Proceed with update? (y/N) ", resolve);
+      });
+      rl.close();
+      if (answer.toLowerCase() === "y" || answer.toLowerCase() === "yes") {
+        upgrade = forceUpgrade(upgrade.to);
+        if (upgrade.upgraded) {
+          console.log(`Upgraded: v${upgrade.from} → v${upgrade.to}`);
+        } else {
+          console.log("Upgrade failed. Try manually: npm install -g @c-d-cc/reap@latest");
+        }
+      } else {
+        console.log("Update skipped.");
+      }
+    } else if (upgrade.upgraded) {
       console.log(`Upgraded: v${upgrade.from} → v${upgrade.to}`);
     }
     const result = await updateProject(process.cwd(), options.dryRun ?? false);