sv 0.6.11 → 0.6.13

package/dist/bin.js

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
-import { g as getDefaultExportFromCjs$2, a as commonjsGlobal, b as be, t as templates, c as create$1 } from './main-UNazaUHM.js';
+import { g as getDefaultExportFromCjs$2, a as commonjsGlobal, t as templates, c as create$1 } from './main-UNazaUHM.js';
 import require$$0 from 'node:events';
-import require$$1, { execSync } from 'node:child_process';
+import require$$1, { exec, execSync } from 'node:child_process';
 import path from 'node:path';
 import fs from 'node:fs';
 import process$1 from 'node:process';
-import { u as up$1, d as dedent, p as parseJson, a as parseScript, b as imports, c as common, e as exports$1, o as object$1, v as variables, _ as _function, f as parseSvelte, g as array$1, w as walk$1, k as kit, h as addFromString, E as Element, j as index, l as parseHtml, m as parseHtml$1, A as AtRule, n as parseCss, q as pc, r as intro, s as outro, t as log$1, x as cancel, y as box, z as multiselect, B as isCancel, C as confirm, D as createWorkspace, F as setupAddons, G as note, H as select, I as text, J as packageManagerPrompt, K as applyAddons, L as installDependencies, M as formatFiles, N as spinner, O as getHighlighter, P as detectSync, Q as getUserAgent, R as resolveCommand, S as group, T as from } from './install-Bj_yXcZX.js';
+import { u as up$1, d as dedent, p as parseJson, a as parseScript, b as imports, c as common, e as exports$1, o as object$1, v as variables, _ as _function, f as parseSvelte, g as array$1, w as walk$1, k as kit, h as addFromString, E as Element, j as index, l as parseHtml, m as parseHtml$1, A as AtRule, n as parseCss, q as pc, r as intro, s as outro, t as log$1, x as cancel, y as box, z as multiselect, B as isCancel, C as confirm, D as createWorkspace, F as setupAddons, G as note, H as select, I as text, J as packageManagerPrompt, K as applyAddons, L as installDependencies, M as formatFiles, N as spinner, O as getHighlighter, P as detectSync, Q as getUserAgent, R as resolveCommand, S as group, T as from } from './install-DJcXCdFP.js';
 import 'node:readline';
 import 'node:tty';
 import { createGunzip } from 'node:zlib';
@@ -14,6 +14,7 @@ import { pipeline } from 'node:stream/promises';
 import require$$5 from 'events';
 import require$$1$1 from 'fs';
 import require$$1$1$1 from 'path';
+import { promisify } from 'node:util';
 import 'node:module';
 import 'child_process';
 import 'process';
@@ -24,7 +25,7 @@ import 'url';
 import 'node:fs/promises';
 
 var name = "sv";
-var version = "0.6.11";
+var version = "0.6.13";
 var type = "module";
 var description = "A CLI for creating and updating SvelteKit projects";
 var license = "MIT";
@@ -61,7 +62,7 @@ var devDependencies = {
 	"@types/degit": "^2.8.6",
 	"@types/ps-tree": "^1.1.6",
 	"@types/tar-fs": "^2.0.4",
-	commander: "^12.1.0",
+	commander: "^13.0.0",
 	degit: "^2.8.4",
 	empathic: "^1.0.0",
 	"package-manager-detector": "^0.2.7",
@@ -331,11 +332,24 @@ function requireHelp () {
 	class Help {
 	  constructor() {
 	    this.helpWidth = undefined;
+	    this.minWidthToWrap = 40;
 	    this.sortSubcommands = false;
 	    this.sortOptions = false;
 	    this.showGlobalOptions = false;
 	  }
 
+	  /**
+	   * prepareContext is called by Commander after applying overrides from `Command.configureHelp()`
+	   * and just before calling `formatHelp()`.
+	   *
+	   * Commander just uses the helpWidth and the rest is provided for optional use by more complex subclasses.
+	   *
+	   * @param {{ error?: boolean, helpWidth?: number, outputHasColors?: boolean }} contextOptions
+	   */
+	  prepareContext(contextOptions) {
+	    this.helpWidth = this.helpWidth ?? contextOptions.helpWidth ?? 80;
+	  }
+
 	  /**
 	   * Get an array of the visible subcommands. Includes a placeholder for the implicit help command, if there is one.
 	   *
@@ -510,7 +524,12 @@ function requireHelp () {
 
 	  longestSubcommandTermLength(cmd, helper) {
 	    return helper.visibleCommands(cmd).reduce((max, command) => {
-	      return Math.max(max, helper.subcommandTerm(command).length);
+	      return Math.max(
+	        max,
+	        this.displayWidth(
+	          helper.styleSubcommandTerm(helper.subcommandTerm(command)),
+	        ),
+	      );
 	    }, 0);
 	  }
 
@@ -524,7 +543,10 @@ function requireHelp () {
 
 	  longestOptionTermLength(cmd, helper) {
 	    return helper.visibleOptions(cmd).reduce((max, option) => {
-	      return Math.max(max, helper.optionTerm(option).length);
+	      return Math.max(
+	        max,
+	        this.displayWidth(helper.styleOptionTerm(helper.optionTerm(option))),
+	      );
 	    }, 0);
 	  }
 
@@ -538,7 +560,10 @@ function requireHelp () {
 
 	  longestGlobalOptionTermLength(cmd, helper) {
 	    return helper.visibleGlobalOptions(cmd).reduce((max, option) => {
-	      return Math.max(max, helper.optionTerm(option).length);
+	      return Math.max(
+	        max,
+	        this.displayWidth(helper.styleOptionTerm(helper.optionTerm(option))),
+	      );
 	    }, 0);
 	  }
 
@@ -552,7 +577,12 @@ function requireHelp () {
 
 	  longestArgumentTermLength(cmd, helper) {
 	    return helper.visibleArguments(cmd).reduce((max, argument) => {
-	      return Math.max(max, helper.argumentTerm(argument).length);
+	      return Math.max(
+	        max,
+	        this.displayWidth(
+	          helper.styleArgumentTerm(helper.argumentTerm(argument)),
+	        ),
+	      );
 	    }, 0);
 	  }
 
@@ -669,11 +699,11 @@ function requireHelp () {
 	      );
 	    }
 	    if (extraInfo.length > 0) {
-	      const extraDescripton = `(${extraInfo.join(', ')})`;
+	      const extraDescription = `(${extraInfo.join(', ')})`;
 	      if (argument.description) {
-	        return `${argument.description} ${extraDescripton}`;
+	        return `${argument.description} ${extraDescription}`;
 	      }
-	      return extraDescripton;
+	      return extraDescription;
 	    }
 	    return argument.description;
 	  }
@@ -688,71 +718,73 @@ function requireHelp () {
 
 	  formatHelp(cmd, helper) {
 	    const termWidth = helper.padWidth(cmd, helper);
-	    const helpWidth = helper.helpWidth || 80;
-	    const itemIndentWidth = 2;
-	    const itemSeparatorWidth = 2; // between term and description
-	    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('\n').replace(/^/gm, ' '.repeat(itemIndentWidth));
+	    const helpWidth = helper.helpWidth ?? 80; // in case prepareContext() was not called
+
+	    function callFormatItem(term, description) {
+	      return helper.formatItem(term, termWidth, description, helper);
 	    }
 
 	    // Usage
-	    let output = [`Usage: ${helper.commandUsage(cmd)}`, ''];
+	    let output = [
+	      `${helper.styleTitle('Usage:')} ${helper.styleUsage(helper.commandUsage(cmd))}`,
+	      '',
+	    ];
 
 	    // Description
 	    const commandDescription = helper.commandDescription(cmd);
 	    if (commandDescription.length > 0) {
 	      output = output.concat([
-	        helper.wrap(commandDescription, helpWidth, 0),
+	        helper.boxWrap(
+	          helper.styleCommandDescription(commandDescription),
+	          helpWidth,
+	        ),
 	        '',
 	      ]);
 	    }
 
 	    // Arguments
 	    const argumentList = helper.visibleArguments(cmd).map((argument) => {
-	      return formatItem(
-	        helper.argumentTerm(argument),
-	        helper.argumentDescription(argument),
+	      return callFormatItem(
+	        helper.styleArgumentTerm(helper.argumentTerm(argument)),
+	        helper.styleArgumentDescription(helper.argumentDescription(argument)),
 	      );
 	    });
 	    if (argumentList.length > 0) {
-	      output = output.concat(['Arguments:', formatList(argumentList), '']);
+	      output = output.concat([
+	        helper.styleTitle('Arguments:'),
+	        ...argumentList,
+	        '',
+	      ]);
 	    }
 
 	    // Options
 	    const optionList = helper.visibleOptions(cmd).map((option) => {
-	      return formatItem(
-	        helper.optionTerm(option),
-	        helper.optionDescription(option),
+	      return callFormatItem(
+	        helper.styleOptionTerm(helper.optionTerm(option)),
+	        helper.styleOptionDescription(helper.optionDescription(option)),
 	      );
 	    });
 	    if (optionList.length > 0) {
-	      output = output.concat(['Options:', formatList(optionList), '']);
+	      output = output.concat([
+	        helper.styleTitle('Options:'),
+	        ...optionList,
+	        '',
+	      ]);
 	    }
 
-	    if (this.showGlobalOptions) {
+	    if (helper.showGlobalOptions) {
 	      const globalOptionList = helper
 	        .visibleGlobalOptions(cmd)
 	        .map((option) => {
-	          return formatItem(
-	            helper.optionTerm(option),
-	            helper.optionDescription(option),
+	          return callFormatItem(
+	            helper.styleOptionTerm(helper.optionTerm(option)),
+	            helper.styleOptionDescription(helper.optionDescription(option)),
 	          );
 	        });
 	      if (globalOptionList.length > 0) {
 	        output = output.concat([
-	          'Global Options:',
-	          formatList(globalOptionList),
+	          helper.styleTitle('Global Options:'),
+	          ...globalOptionList,
 	          '',
 	        ]);
 	      }
@@ -760,18 +792,103 @@ function requireHelp () {
 
 	    // Commands
 	    const commandList = helper.visibleCommands(cmd).map((cmd) => {
-	      return formatItem(
-	        helper.subcommandTerm(cmd),
-	        helper.subcommandDescription(cmd),
+	      return callFormatItem(
+	        helper.styleSubcommandTerm(helper.subcommandTerm(cmd)),
+	        helper.styleSubcommandDescription(helper.subcommandDescription(cmd)),
 	      );
 	    });
 	    if (commandList.length > 0) {
-	      output = output.concat(['Commands:', formatList(commandList), '']);
+	      output = output.concat([
+	        helper.styleTitle('Commands:'),
+	        ...commandList,
+	        '',
+	      ]);
 	    }
 
 	    return output.join('\n');
 	  }
 
+	  /**
+	   * Return display width of string, ignoring ANSI escape sequences. Used in padding and wrapping calculations.
+	   *
+	   * @param {string} str
+	   * @returns {number}
+	   */
+	  displayWidth(str) {
+	    return stripColor(str).length;
+	  }
+
+	  /**
+	   * Style the title for displaying in the help. Called with 'Usage:', 'Options:', etc.
+	   *
+	   * @param {string} str
+	   * @returns {string}
+	   */
+	  styleTitle(str) {
+	    return str;
+	  }
+
+	  styleUsage(str) {
+	    // Usage has lots of parts the user might like to color separately! Assume default usage string which is formed like:
+	    //    command subcommand [options] [command] <foo> [bar]
+	    return str
+	      .split(' ')
+	      .map((word) => {
+	        if (word === '[options]') return this.styleOptionText(word);
+	        if (word === '[command]') return this.styleSubcommandText(word);
+	        if (word[0] === '[' || word[0] === '<')
+	          return this.styleArgumentText(word);
+	        return this.styleCommandText(word); // Restrict to initial words?
+	      })
+	      .join(' ');
+	  }
+	  styleCommandDescription(str) {
+	    return this.styleDescriptionText(str);
+	  }
+	  styleOptionDescription(str) {
+	    return this.styleDescriptionText(str);
+	  }
+	  styleSubcommandDescription(str) {
+	    return this.styleDescriptionText(str);
+	  }
+	  styleArgumentDescription(str) {
+	    return this.styleDescriptionText(str);
+	  }
+	  styleDescriptionText(str) {
+	    return str;
+	  }
+	  styleOptionTerm(str) {
+	    return this.styleOptionText(str);
+	  }
+	  styleSubcommandTerm(str) {
+	    // This is very like usage with lots of parts! Assume default string which is formed like:
+	    //    subcommand [options] <foo> [bar]
+	    return str
+	      .split(' ')
+	      .map((word) => {
+	        if (word === '[options]') return this.styleOptionText(word);
+	        if (word[0] === '[' || word[0] === '<')
+	          return this.styleArgumentText(word);
+	        return this.styleSubcommandText(word); // Restrict to initial words?
+	      })
+	      .join(' ');
+	  }
+	  styleArgumentTerm(str) {
+	    return this.styleArgumentText(str);
+	  }
+	  styleOptionText(str) {
+	    return str;
+	  }
+	  styleArgumentText(str) {
+	    return str;
+	  }
+	  styleSubcommandText(str) {
+	    return str;
+	  }
+	  styleCommandText(str) {
+	    return str;
+	  }
+
 	  /**
 	   * Calculate the pad width from the maximum term length.
 	   *
@@ -790,53 +907,126 @@ function requireHelp () {
 	  }
 
 	  /**
-	   * Wrap the given string to width characters per line, with lines after the first indented.
-	   * Do not wrap if insufficient room for wrapping (minColumnWidth), or string is manually formatted.
+	   * Detect manually wrapped and indented strings by checking for line break followed by whitespace.
 	   *
 	   * @param {string} str
-	   * @param {number} width
-	   * @param {number} indent
-	   * @param {number} [minColumnWidth=40]
-	   * @return {string}
+	   * @returns {boolean}
+	   */
+	  preformatted(str) {
+	    return /\n[^\S\r\n]/.test(str);
+	  }
+
+	  /**
+	   * Format the "item", which consists of a term and description. Pad the term and wrap the description, indenting the following lines.
 	   *
+	   * So "TTT", 5, "DDD DDDD DD DDD" might be formatted for this.helpWidth=17 like so:
+	   *   TTT  DDD DDDD
+	   *        DD DDD
+	   *
+	   * @param {string} term
+	   * @param {number} termWidth
+	   * @param {string} description
+	   * @param {Help} helper
+	   * @returns {string}
 	   */
+	  formatItem(term, termWidth, description, helper) {
+	    const itemIndent = 2;
+	    const itemIndentStr = ' '.repeat(itemIndent);
+	    if (!description) return itemIndentStr + term;
 
-	  wrap(str, width, indent, minColumnWidth = 40) {
-	    // Full \s characters, minus the linefeeds.
-	    const indents =
-	      ' \\f\\t\\v\u00a0\u1680\u2000-\u200a\u202f\u205f\u3000\ufeff';
-	    // Detect manually wrapped and indented strings by searching for line break followed by spaces.
-	    const manualIndent = new RegExp(`[\\n][${indents}]+`);
-	    if (str.match(manualIndent)) return str;
-	    // Do not wrap if not enough room for a wrapped column of text (as could end up with a word per line).
-	    const columnWidth = width - indent;
-	    if (columnWidth < minColumnWidth) return str;
-
-	    const leadingStr = str.slice(0, indent);
-	    const columnText = str.slice(indent).replace('\r\n', '\n');
-	    const indentString = ' '.repeat(indent);
-	    const zeroWidthSpace = '\u200B';
-	    const breaks = `\\s${zeroWidthSpace}`;
-	    // Match line end (so empty lines don't collapse),
-	    // or as much text as will fit in column, or excess text up to first break.
-	    const regex = new RegExp(
-	      `\n|.{1,${columnWidth - 1}}([${breaks}]|$)|[^${breaks}]+?([${breaks}]|$)`,
-	      'g',
+	    // Pad the term out to a consistent width, so descriptions are aligned.
+	    const paddedTerm = term.padEnd(
+	      termWidth + term.length - helper.displayWidth(term),
 	    );
-	    const lines = columnText.match(regex) || [];
+
+	    // Format the description.
+	    const spacerWidth = 2; // between term and description
+	    const helpWidth = this.helpWidth ?? 80; // in case prepareContext() was not called
+	    const remainingWidth = helpWidth - termWidth - spacerWidth - itemIndent;
+	    let formattedDescription;
+	    if (
+	      remainingWidth < this.minWidthToWrap ||
+	      helper.preformatted(description)
+	    ) {
+	      formattedDescription = description;
+	    } else {
+	      const wrappedDescription = helper.boxWrap(description, remainingWidth);
+	      formattedDescription = wrappedDescription.replace(
+	        /\n/g,
+	        '\n' + ' '.repeat(termWidth + spacerWidth),
+	      );
+	    }
+
+	    // Construct and overall indent.
 	    return (
-	      leadingStr +
-	      lines
-	        .map((line, i) => {
-	          if (line === '\n') return ''; // preserve empty lines
-	          return (i > 0 ? indentString : '') + line.trimEnd();
-	        })
-	        .join('\n')
+	      itemIndentStr +
+	      paddedTerm +
+	      ' '.repeat(spacerWidth) +
+	      formattedDescription.replace(/\n/g, `\n${itemIndentStr}`)
 	    );
 	  }
+
+	  /**
+	   * Wrap a string at whitespace, preserving existing line breaks.
+	   * Wrapping is skipped if the width is less than `minWidthToWrap`.
+	   *
+	   * @param {string} str
+	   * @param {number} width
+	   * @returns {string}
+	   */
+	  boxWrap(str, width) {
+	    if (width < this.minWidthToWrap) return str;
+
+	    const rawLines = str.split(/\r\n|\n/);
+	    // split up text by whitespace
+	    const chunkPattern = /[\s]*[^\s]+/g;
+	    const wrappedLines = [];
+	    rawLines.forEach((line) => {
+	      const chunks = line.match(chunkPattern);
+	      if (chunks === null) {
+	        wrappedLines.push('');
+	        return;
+	      }
+
+	      let sumChunks = [chunks.shift()];
+	      let sumWidth = this.displayWidth(sumChunks[0]);
+	      chunks.forEach((chunk) => {
+	        const visibleWidth = this.displayWidth(chunk);
+	        // Accumulate chunks while they fit into width.
+	        if (sumWidth + visibleWidth <= width) {
+	          sumChunks.push(chunk);
+	          sumWidth += visibleWidth;
+	          return;
+	        }
+	        wrappedLines.push(sumChunks.join(''));
+
+	        const nextChunk = chunk.trimStart(); // trim space at line break
+	        sumChunks = [nextChunk];
+	        sumWidth = this.displayWidth(nextChunk);
+	      });
+	      wrappedLines.push(sumChunks.join(''));
+	    });
+
+	    return wrappedLines.join('\n');
+	  }
+	}
+
+	/**
+	 * Strip style ANSI escape sequences from the string. In particular, SGR (Select Graphic Rendition) codes.
+	 *
+	 * @param {string} str
+	 * @returns {string}
+	 * @package
+	 */
+
+	function stripColor(str) {
+	  // eslint-disable-next-line no-control-regex
+	  const sgrPattern = /\x1b\[\d*(;\d*)*m/g;
+	  return str.replace(sgrPattern, '');
 	}
 
 	help.Help = Help;
+	help.stripColor = stripColor;
 	return help;
 }
 
@@ -1056,13 +1246,16 @@ function requireOption () {
 
 	  /**
 	   * Return option name, in a camelcase format that can be used
-	   * as a object attribute key.
+	   * as an object attribute key.
 	   *
 	   * @return {string}
 	   */
 
 	  attributeName() {
-	    return camelcase(this.name().replace(/^no-/, ''));
+	    if (this.negate) {
+	      return camelcase(this.name().replace(/^no-/, ''));
+	    }
+	    return camelcase(this.name());
 	  }
 
 	  /**
@@ -1161,17 +1354,32 @@ function requireOption () {
 	function splitOptionFlags(flags) {
 	  let shortFlag;
 	  let longFlag;
-	  // Use original very loose parsing to maintain backwards compatibility for now,
-	  // which allowed for example unintended `-sw, --short-word` [sic].
-	  const flagParts = flags.split(/[ |,]+/);
-	  if (flagParts.length > 1 && !/^[[<]/.test(flagParts[1]))
-	    shortFlag = flagParts.shift();
-	  longFlag = flagParts.shift();
-	  // Add support for lone short flag without significantly changing parsing!
-	  if (!shortFlag && /^-[^-]$/.test(longFlag)) {
-	    shortFlag = longFlag;
-	    longFlag = undefined;
-	  }
+	  // short flag, single dash and single character
+	  const shortFlagExp = /^-[^-]$/;
+	  // long flag, double dash and at least one character
+	  const longFlagExp = /^--[^-]/;
+
+	  const flagParts = flags.split(/[ |,]+/).concat('guard');
+	  if (shortFlagExp.test(flagParts[0])) shortFlag = flagParts.shift();
+	  if (longFlagExp.test(flagParts[0])) longFlag = flagParts.shift();
+
+	  // Check for some unsupported flags that people try.
+	  if (/^-[^-][^-]/.test(flagParts[0]))
+	    throw new Error(
+	      `invalid Option flags, short option is dash and single character: '${flags}'`,
+	    );
+	  if (shortFlag && shortFlagExp.test(flagParts[0]))
+	    throw new Error(
+	      `invalid Option flags, more than one short flag: '${flags}'`,
+	    );
+	  if (longFlag && longFlagExp.test(flagParts[0]))
+	    throw new Error(
+	      `invalid Option flags, more than one long flag: '${flags}'`,
+	    );
+	  // Generic error if failed to find a flag or an unexpected flag left over.
+	  if (!(shortFlag || longFlag) || flagParts[0].startsWith('-'))
+	    throw new Error(`invalid Option flags: '${flags}'`);
+
 	  return { shortFlag, longFlag };
 	}
 
@@ -1304,7 +1512,7 @@ function requireCommand () {
 
 	const { Argument, humanReadableArgName } = requireArgument();
 	const { CommanderError } = requireError();
-	const { Help } = requireHelp();
+	const { Help, stripColor } = requireHelp();
 	const { Option, DualOptions } = requireOption();
 	const { suggestSimilar } = requireSuggestSimilar();
 
@@ -1323,7 +1531,7 @@ function requireCommand () {
 	    this.options = [];
 	    this.parent = null;
 	    this._allowUnknownOption = false;
-	    this._allowExcessArguments = true;
+	    this._allowExcessArguments = false;
 	    /** @type {Argument[]} */
 	    this.registeredArguments = [];
 	    this._args = this.registeredArguments; // deprecated old name
@@ -1353,16 +1561,22 @@ function requireCommand () {
 	    /** @type {(boolean | string)} */
 	    this._showHelpAfterError = false;
 	    this._showSuggestionAfterError = true;
+	    this._savedState = null; // used in save/restoreStateBeforeParse
 
-	    // see .configureOutput() for docs
+	    // see configureOutput() for docs
 	    this._outputConfiguration = {
 	      writeOut: (str) => process.stdout.write(str),
 	      writeErr: (str) => process.stderr.write(str),
+	      outputError: (str, write) => write(str),
 	      getOutHelpWidth: () =>
 	        process.stdout.isTTY ? process.stdout.columns : undefined,
 	      getErrHelpWidth: () =>
 	        process.stderr.isTTY ? process.stderr.columns : undefined,
-	      outputError: (str, write) => write(str),
+	      getOutHasColors: () =>
+	        useColor() ?? (process.stdout.isTTY && process.stdout.hasColors?.()),
+	      getErrHasColors: () =>
+	        useColor() ?? (process.stderr.isTTY && process.stderr.hasColors?.()),
+	      stripColor: (str) => stripColor(str),
 	    };
 
 	    this._hidden = false;
@@ -1511,14 +1725,18 @@ function requireCommand () {
 	   *
 	   * The configuration properties are all functions:
 	   *
-	   *     // functions to change where being written, stdout and stderr
+	   *     // change how output being written, defaults to stdout and stderr
 	   *     writeOut(str)
 	   *     writeErr(str)
-	   *     // matching functions to specify width for wrapping help
+	   *     // change how output being written for errors, defaults to writeErr
+	   *     outputError(str, write) // used for displaying errors and not used for displaying help
+	   *     // specify width for wrapping help
 	   *     getOutHelpWidth()
 	   *     getErrHelpWidth()
-	   *     // functions based on what is being written out
-	   *     outputError(str, write) // used for displaying errors, and not used for displaying help
+	   *     // color support, currently only used with Help
+	   *     getOutHasColors()
+	   *     getErrHasColors()
+	   *     stripColor() // used to remove ANSI escape codes if output does not have colors
 	   *
 	   * @param {object} [configuration] - configuration options
 	   * @return {(Command | object)} `this` command for chaining, or stored configuration
@@ -2356,6 +2574,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
 	   */
 
 	  parse(argv, parseOptions) {
+	    this._prepareForParse();
 	    const userArgs = this._prepareUserArgs(argv, parseOptions);
 	    this._parseCommand([], userArgs);
 
@@ -2384,12 +2603,82 @@ Expecting one of '${allowedValues.join("', '")}'`);
 	   */
 
 	  async parseAsync(argv, parseOptions) {
+	    this._prepareForParse();
 	    const userArgs = this._prepareUserArgs(argv, parseOptions);
 	    await this._parseCommand([], userArgs);
 
 	    return this;
 	  }
 
+	  _prepareForParse() {
+	    if (this._savedState === null) {
+	      this.saveStateBeforeParse();
+	    } else {
+	      this.restoreStateBeforeParse();
+	    }
+	  }
+
+	  /**
+	   * Called the first time parse is called to save state and allow a restore before subsequent calls to parse.
+	   * Not usually called directly, but available for subclasses to save their custom state.
+	   *
+	   * This is called in a lazy way. Only commands used in parsing chain will have state saved.
+	   */
+	  saveStateBeforeParse() {
+	    this._savedState = {
+	      // name is stable if supplied by author, but may be unspecified for root command and deduced during parsing
+	      _name: this._name,
+	      // option values before parse have default values (including false for negated options)
+	      // shallow clones
+	      _optionValues: { ...this._optionValues },
+	      _optionValueSources: { ...this._optionValueSources },
+	    };
+	  }
+
+	  /**
+	   * Restore state before parse for calls after the first.
+	   * Not usually called directly, but available for subclasses to save their custom state.
+	   *
+	   * This is called in a lazy way. Only commands used in parsing chain will have state restored.
+	   */
+	  restoreStateBeforeParse() {
+	    if (this._storeOptionsAsProperties)
+	      throw new Error(`Can not call parse again when storeOptionsAsProperties is true.
+- either make a new Command for each call to parse, or stop storing options as properties`);
+
+	    // clear state from _prepareUserArgs
+	    this._name = this._savedState._name;
+	    this._scriptPath = null;
+	    this.rawArgs = [];
+	    // clear state from setOptionValueWithSource
+	    this._optionValues = { ...this._savedState._optionValues };
+	    this._optionValueSources = { ...this._savedState._optionValueSources };
+	    // clear state from _parseCommand
+	    this.args = [];
+	    // clear state from _processArguments
+	    this.processedArgs = [];
+	  }
+
+	  /**
+	   * Throw if expected executable is missing. Add lots of help for author.
+	   *
+	   * @param {string} executableFile
+	   * @param {string} executableDir
+	   * @param {string} subcommandName
+	   */
+	  _checkForMissingExecutable(executableFile, executableDir, subcommandName) {
+	    if (fs$1.existsSync(executableFile)) return;
+
+	    const executableDirMessage = executableDir
+	      ? `searched for local subcommand relative to directory '${executableDir}'`
+	      : 'no directory for search for local subcommand, use .executableDir() to supply a custom directory';
+	    const executableMissing = `'${executableFile}' does not exist
+ - if '${subcommandName}' is not meant to be an executable command, remove description parameter from '.command()' and use '.description()' instead
+ - if the default executable name is not suitable, use the executableFile option to supply a custom name or path
+ - ${executableDirMessage}`;
+	    throw new Error(executableMissing);
+	  }
+
 	  /**
 	   * Execute a sub-command executable.
 	   *
@@ -2430,7 +2719,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
 	      let resolvedScriptPath; // resolve possible symlink for installed npm binary
 	      try {
 	        resolvedScriptPath = fs$1.realpathSync(this._scriptPath);
-	      } catch (err) {
+	      } catch {
 	        resolvedScriptPath = this._scriptPath;
 	      }
 	      executableDir = path$1.resolve(
@@ -2473,6 +2762,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
 	        proc = childProcess.spawn(executableFile, args, { stdio: 'inherit' });
 	      }
 	    } else {
+	      this._checkForMissingExecutable(
+	        executableFile,
+	        executableDir,
+	        subcommand._name,
+	      );
 	      args.unshift(executableFile);
 	      // add executable arguments to spawn
 	      args = incrementNodeInspectorPort(process.execArgv).concat(args);
@@ -2511,14 +2805,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
 	    proc.on('error', (err) => {
 	      // @ts-ignore: because err.code is an unknown property
 	      if (err.code === 'ENOENT') {
-	        const executableDirMessage = executableDir
-	          ? `searched for local subcommand relative to directory '${executableDir}'`
-	          : 'no directory for search for local subcommand, use .executableDir() to supply a custom directory';
-	        const executableMissing = `'${executableFile}' does not exist
- - if '${subcommand._name}' is not meant to be an executable command, remove description parameter from '.command()' and use '.description()' instead
- - if the default executable name is not suitable, use the executableFile option to supply a custom name or path
- - ${executableDirMessage}`;
-	        throw new Error(executableMissing);
+	        this._checkForMissingExecutable(
+	          executableFile,
+	          executableDir,
+	          subcommand._name,
+	        );
 	        // @ts-ignore: because err.code is an unknown property
 	      } else if (err.code === 'EACCES') {
 	        throw new Error(`'${executableFile}' not executable`);
@@ -2548,6 +2839,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
 	    const subCommand = this._findCommand(commandName);
 	    if (!subCommand) this.help({ error: true });
 
+	    subCommand._prepareForParse();
 	    let promiseChain;
 	    promiseChain = this._chainOrCallSubCommandHook(
 	      promiseChain,
@@ -2925,6 +3217,8 @@ Expecting one of '${allowedValues.join("', '")}'`);
 	   * Parse options from `argv` removing known options,
 	   * and return argv split into operands and unknown arguments.
 	   *
+	   * Side effects: modifies command by storing options. Does not reset state if called again.
+	   *
 	   * Examples:
 	   *
 	   *     argv => operands, unknown
@@ -3550,31 +3844,49 @@ Expecting one of '${allowedValues.join("', '")}'`);
 
 	  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);
+	    const context = this._getOutputContext(contextOptions);
+	    helper.prepareContext({
+	      error: context.error,
+	      helpWidth: context.helpWidth,
+	      outputHasColors: context.hasColors,
+	    });
+	    const text = helper.formatHelp(this, helper);
+	    if (context.hasColors) return text;
+	    return this._outputConfiguration.stripColor(text);
 	  }
 
 	  /**
+	   * @typedef HelpContext
+	   * @type {object}
+	   * @property {boolean} error
+	   * @property {number} helpWidth
+	   * @property {boolean} hasColors
+	   * @property {function} write - includes stripColor if needed
+	   *
+	   * @returns {HelpContext}
 	   * @private
 	   */
 
-	  _getHelpContext(contextOptions) {
+	  _getOutputContext(contextOptions) {
 	    contextOptions = contextOptions || {};
-	    const context = { error: !!contextOptions.error };
-	    let write;
-	    if (context.error) {
-	      write = (arg) => this._outputConfiguration.writeErr(arg);
+	    const error = !!contextOptions.error;
+	    let baseWrite;
+	    let hasColors;
+	    let helpWidth;
+	    if (error) {
+	      baseWrite = (str) => this._outputConfiguration.writeErr(str);
+	      hasColors = this._outputConfiguration.getErrHasColors();
+	      helpWidth = this._outputConfiguration.getErrHelpWidth();
 	    } else {
-	      write = (arg) => this._outputConfiguration.writeOut(arg);
+	      baseWrite = (str) => this._outputConfiguration.writeOut(str);
+	      hasColors = this._outputConfiguration.getOutHasColors();
+	      helpWidth = this._outputConfiguration.getOutHelpWidth();
 	    }
-	    context.write = contextOptions.write || write;
-	    context.command = this;
-	    return context;
+	    const write = (str) => {
+	      if (!hasColors) str = this._outputConfiguration.stripColor(str);
+	      return baseWrite(str);
+	    };
+	    return { error, write, hasColors, helpWidth };
 	  }
 
 	  /**
@@ -3591,14 +3903,21 @@ Expecting one of '${allowedValues.join("', '")}'`);
 	      deprecatedCallback = contextOptions;
 	      contextOptions = undefined;
 	    }
-	    const context = this._getHelpContext(contextOptions);
+
+	    const outputContext = this._getOutputContext(contextOptions);
+	    /** @type {HelpTextEventContext} */
+	    const eventContext = {
+	      error: outputContext.error,
+	      write: outputContext.write,
+	      command: this,
+	    };
 
 	    this._getCommandAndAncestors()
 	      .reverse()
-	      .forEach((command) => command.emit('beforeAllHelp', context));
-	    this.emit('beforeHelp', context);
+	      .forEach((command) => command.emit('beforeAllHelp', eventContext));
+	    this.emit('beforeHelp', eventContext);
 
-	    let helpInformation = this.helpInformation(context);
+	    let helpInformation = this.helpInformation({ error: outputContext.error });
 	    if (deprecatedCallback) {
 	      helpInformation = deprecatedCallback(helpInformation);
 	      if (
@@ -3608,14 +3927,14 @@ Expecting one of '${allowedValues.join("', '")}'`);
 	        throw new Error('outputHelp callback must return a string or a Buffer');
 	      }
 	    }
-	    context.write(helpInformation);
+	    outputContext.write(helpInformation);
 
 	    if (this._getHelpOption()?.long) {
 	      this.emit(this._getHelpOption().long); // deprecated
 	    }
-	    this.emit('afterHelp', context);
+	    this.emit('afterHelp', eventContext);
 	    this._getCommandAndAncestors().forEach((command) =>
-	      command.emit('afterAllHelp', context),
+	      command.emit('afterAllHelp', eventContext),
 	    );
 	  }
 
@@ -3635,6 +3954,8 @@ Expecting one of '${allowedValues.join("', '")}'`);
 	  helpOption(flags, description) {
 	    // Support disabling built-in help option.
 	    if (typeof flags === 'boolean') {
+	      // true is not an expected value. Do something sensible but no unit-test.
+	      // istanbul ignore if
 	      if (flags) {
 	        this._helpOption = this._helpOption ?? undefined; // preserve existing option
 	      } else {
@@ -3688,7 +4009,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
 
 	  help(contextOptions) {
 	    this.outputHelp(contextOptions);
-	    let exitCode = process.exitCode || 0;
+	    let exitCode = Number(process.exitCode ?? 0); // process.exitCode does allow a string or an integer, but we prefer just a number
 	    if (
 	      exitCode === 0 &&
 	      contextOptions &&
@@ -3701,6 +4022,15 @@ Expecting one of '${allowedValues.join("', '")}'`);
 	    this._exit(exitCode, 'commander.help', '(outputHelp)');
 	  }
 
+	  /**
+	   * // Do a little typing to coordinate emit and listener for the help text events.
+	   * @typedef HelpTextEventContext
+	   * @type {object}
+	   * @property {boolean} error
+	   * @property {Command} command
+	   * @property {function} write
+	   */
+
 	  /**
 	   * Add additional text to be displayed with the built-in help.
 	   *
@@ -3711,14 +4041,16 @@ Expecting one of '${allowedValues.join("', '")}'`);
 	   * @param {(string | Function)} text - string to add, or a function returning a string
 	   * @return {Command} `this` command for chaining
 	   */
+
 	  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) => {
+	    this.on(helpEvent, (/** @type {HelpTextEventContext} */ context) => {
 	      let helpStr;
 	      if (typeof text === 'function') {
 	        helpStr = text({ error: context.error, command: context.command });
@@ -3802,7 +4134,36 @@ Expecting one of '${allowedValues.join("', '")}'`);
 	  });
 	}
 
+	/**
+	 * @returns {boolean | undefined}
+	 * @package
+	 */
+	function useColor() {
+	  // Test for common conventions.
+	  // NB: the observed behaviour is in combination with how author adds color! For example:
+	  //   - we do not test NODE_DISABLE_COLORS, but util:styletext does
+	  //   - we do test NO_COLOR, but Chalk does not
+	  //
+	  // References:
+	  // https://no-color.org
+	  // https://bixense.com/clicolors/
+	  // https://github.com/nodejs/node/blob/0a00217a5f67ef4a22384cfc80eb6dd9a917fdc1/lib/internal/tty.js#L109
+	  // https://github.com/chalk/supports-color/blob/c214314a14bcb174b12b3014b2b0a8de375029ae/index.js#L33
+	  // (https://force-color.org recent web page from 2023, does not match major javascript implementations)
+
+	  if (
+	    process.env.NO_COLOR ||
+	    process.env.FORCE_COLOR === '0' ||
+	    process.env.FORCE_COLOR === 'false'
+	  )
+	    return false;
+	  if (process.env.FORCE_COLOR || process.env.CLICOLOR_FORCE !== undefined)
+	    return true;
+	  return undefined;
+	}
+
 	command.Command = Command;
+	command.useColor = useColor; // exporting for tests
 	return command;
 }
 
@@ -4948,18 +5309,18 @@ var drizzle = defineAddon({
   },
   run: ({ sv, typescript, options: options2, kit }) => {
     const ext = typescript ? "ts" : "js";
-    sv.dependency("drizzle-orm", "^0.33.0");
-    sv.devDependency("drizzle-kit", "^0.22.0");
-    if (options2.mysql === "mysql2") sv.dependency("mysql2", "^3.11.0");
-    if (options2.mysql === "planetscale") sv.dependency("@planetscale/database", "^1.18.0");
-    if (options2.postgresql === "neon") sv.dependency("@neondatabase/serverless", "^0.9.4");
-    if (options2.postgresql === "postgres.js") sv.dependency("postgres", "^3.4.4");
+    sv.dependency("drizzle-orm", "^0.38.4");
+    sv.devDependency("drizzle-kit", "^0.30.2");
+    if (options2.mysql === "mysql2") sv.dependency("mysql2", "^3.12.0");
+    if (options2.mysql === "planetscale") sv.dependency("@planetscale/database", "^1.19.0");
+    if (options2.postgresql === "neon") sv.dependency("@neondatabase/serverless", "^0.10.4");
+    if (options2.postgresql === "postgres.js") sv.dependency("postgres", "^3.4.5");
     if (options2.sqlite === "better-sqlite3") {
-      sv.dependency("better-sqlite3", "^11.1.2");
-      sv.devDependency("@types/better-sqlite3", "^7.6.11");
+      sv.dependency("better-sqlite3", "^11.8.0");
+      sv.devDependency("@types/better-sqlite3", "^7.6.12");
     }
     if (options2.sqlite === "libsql" || options2.sqlite === "turso")
-      sv.dependency("@libsql/client", "^0.9.0");
+      sv.dependency("@libsql/client", "^0.14.0");
     sv.file(".env", (content) => generateEnvFileContent(content, options2));
     sv.file(".env.example", (content) => generateEnvFileContent(content, options2));
     if (options2.docker && (options2.mysql === "mysql2" || options2.postgresql === "postgres.js")) {
@@ -5027,7 +5388,6 @@ var drizzle = defineAddon({
       if (exportDefault.type !== "CallExpression") return content;
       const objExpression = exportDefault.arguments?.[0];
       if (!objExpression || objExpression.type !== "ObjectExpression") return content;
-      const driver = options2.sqlite === "turso" ? common.createLiteral("turso") : void 0;
       const authToken = options2.sqlite === "turso" ? common.expressionFromString("process.env.DATABASE_AUTH_TOKEN") : void 0;
       object$1.properties(objExpression, {
         schema: common.createLiteral(`./src/lib/server/db/schema.${typescript ? "ts" : "js"}`),
@@ -5036,11 +5396,11 @@ var drizzle = defineAddon({
           authToken
         }),
         verbose: { type: "BooleanLiteral", value: true },
-        strict: { type: "BooleanLiteral", value: true },
-        driver
+        strict: { type: "BooleanLiteral", value: true }
       });
+      const dialect = options2.sqlite === "turso" ? "turso" : options2.database;
       object$1.overrideProperties(objExpression, {
-        dialect: common.createLiteral(options2.database)
+        dialect: common.createLiteral(dialect)
       });
       if (options2.database !== "sqlite") object$1.removeProperty(objExpression, "driver");
       return generateCode();
@@ -5271,13 +5631,13 @@ var eslint = defineAddon({
   options: {},
   run: ({ sv, typescript, dependencyVersion }) => {
     const prettierInstalled = Boolean(dependencyVersion("prettier"));
-    sv.devDependency("eslint", "^9.7.0");
-    sv.devDependency("@eslint/compat", "^1.2.3");
-    sv.devDependency("globals", "^15.0.0");
-    sv.devDependency("eslint-plugin-svelte", "^2.36.0");
-    sv.devDependency("@eslint/js", "^9.17.0");
-    if (typescript) sv.devDependency("typescript-eslint", "^8.0.0");
-    if (prettierInstalled) sv.devDependency("eslint-config-prettier", "^9.1.0");
+    sv.devDependency("eslint", "^9.18.0");
+    sv.devDependency("@eslint/compat", "^1.2.5");
+    sv.devDependency("globals", "^15.14.0");
+    sv.devDependency("eslint-plugin-svelte", "^2.46.1");
+    sv.devDependency("@eslint/js", "^9.18.0");
+    if (typescript) sv.devDependency("typescript-eslint", "^8.20.0");
+    if (prettierInstalled) sv.devDependency("eslint-config-prettier", "^10.0.1");
     sv.file("package.json", (content) => {
       const { data, generateCode } = parseJson(content);
       data.scripts ?? (data.scripts = {});
@@ -5368,11 +5728,11 @@ var eslint = defineAddon({
 });
 
 const adapters = [
-  { id: "node", package: "@sveltejs/adapter-node", version: "^5.2.9" },
-  { id: "static", package: "@sveltejs/adapter-static", version: "^3.0.6" },
-  { id: "vercel", package: "@sveltejs/adapter-vercel", version: "^5.5.0" },
-  { id: "cloudflare-pages", package: "@sveltejs/adapter-cloudflare", version: "^4.8.0" },
-  { id: "cloudflare-workers", package: "@sveltejs/adapter-cloudflare-workers", version: "^2.6.0" },
+  { id: "node", package: "@sveltejs/adapter-node", version: "^5.2.11" },
+  { id: "static", package: "@sveltejs/adapter-static", version: "^3.0.8" },
+  { id: "vercel", package: "@sveltejs/adapter-vercel", version: "^5.5.2" },
+  { id: "cloudflare-pages", package: "@sveltejs/adapter-cloudflare", version: "^5.0.1" },
+  { id: "cloudflare-workers", package: "@sveltejs/adapter-cloudflare-workers", version: "^2.7.0" },
   { id: "netlify", package: "@sveltejs/adapter-netlify", version: "^4.4.0" }
 ];
 const options$4 = defineAddonOptions({
@@ -6820,7 +7180,7 @@ var lucia = defineAddon({
     sv.dependency("@oslojs/crypto", "^1.0.1");
     sv.dependency("@oslojs/encoding", "^1.1.0");
     if (options2.demo) {
-      sv.dependency("@node-rs/argon2", "^1.1.0");
+      sv.dependency("@node-rs/argon2", "^2.0.2");
     }
     sv.file(`drizzle.config.${ext}`, (content) => {
       const { ast, generateCode } = parseScript(content);
@@ -7375,7 +7735,7 @@ var mdsvex = defineAddon({
   homepage: "https://mdsvex.pngwn.io",
   options: {},
   run: ({ sv }) => {
-    sv.devDependency("mdsvex", "^0.11.2");
+    sv.devDependency("mdsvex", "^0.12.3");
     sv.file("svelte.config.js", (content) => {
       const { ast, generateCode } = parseScript(content);
       imports.addNamed(ast, "mdsvex", { mdsvex: "mdsvex" });
@@ -7476,7 +7836,7 @@ var paraglide = defineAddon({
     const ext = typescript ? "ts" : "js";
     if (!kit$1) throw new Error("SvelteKit is required");
     const paraglideOutDir = "src/lib/paraglide";
-    sv.dependency("@inlang/paraglide-sveltekit", "^0.11.1");
+    sv.dependency("@inlang/paraglide-sveltekit", "^0.15.5");
     sv.file("project.inlang/settings.json", (content) => {
       if (content) return content;
       const { data, generateCode } = parseJson(content);
@@ -7678,7 +8038,7 @@ var playwright = defineAddon({
   options: {},
   run: ({ sv, typescript }) => {
     const ext = typescript ? "ts" : "js";
-    sv.devDependency("@playwright/test", "^1.45.3");
+    sv.devDependency("@playwright/test", "^1.49.1");
     sv.file("package.json", (content) => {
       const { data, generateCode } = parseJson(content);
       data.scripts ?? (data.scripts = {});
@@ -7736,8 +8096,8 @@ var prettier = defineAddon({
   homepage: "https://prettier.io",
   options: {},
   run: ({ sv, dependencyVersion }) => {
-    sv.devDependency("prettier", "^3.3.2");
-    sv.devDependency("prettier-plugin-svelte", "^3.2.6");
+    sv.devDependency("prettier", "^3.4.2");
+    sv.devDependency("prettier-plugin-svelte", "^3.3.3");
     sv.file(".prettierignore", (content) => {
       if (content) return content;
       return dedent`
@@ -7792,7 +8152,7 @@ var prettier = defineAddon({
       );
     }
     if (eslintInstalled) {
-      sv.devDependency("eslint-config-prettier", "^9.1.0");
+      sv.devDependency("eslint-config-prettier", "^10.0.1");
       sv.file("eslint.config.js", addEslintConfigPrettier);
     }
   }
@@ -7831,13 +8191,13 @@ const plugins = [
   {
     id: "typography",
     package: "@tailwindcss/typography",
-    version: "^0.5.15",
+    version: "^0.5.16",
     identifier: "typography"
   },
   {
     id: "forms",
     package: "@tailwindcss/forms",
-    version: "^0.5.9",
+    version: "^0.5.10",
     identifier: "forms"
   },
   {
@@ -7864,12 +8224,12 @@ var tailwindcss = defineAddon({
   run: ({ sv, options: options2, typescript, kit, dependencyVersion }) => {
     const ext = typescript ? "ts" : "js";
     const prettierInstalled = Boolean(dependencyVersion("prettier"));
-    sv.devDependency("tailwindcss", "^3.4.9");
+    sv.devDependency("tailwindcss", "^3.4.17");
     sv.devDependency("autoprefixer", "^10.4.20");
-    if (prettierInstalled) sv.devDependency("prettier-plugin-tailwindcss", "^0.6.5");
+    if (prettierInstalled) sv.devDependency("prettier-plugin-tailwindcss", "^0.6.10");
     for (const plugin of plugins) {
       if (!options2.plugins.includes(plugin.id)) continue;
-      sv.dependency(plugin.package, plugin.version);
+      sv.devDependency(plugin.package, plugin.version);
     }
     sv.file(`tailwind.config.${ext}`, (content) => {
       const { ast, generateCode } = parseScript(content);
@@ -7969,7 +8329,7 @@ var vitest = defineAddon({
   options: {},
   run: ({ sv, typescript }) => {
     const ext = typescript ? "ts" : "js";
-    sv.devDependency("vitest", "^2.0.4");
+    sv.devDependency("vitest", "^2.1.8");
     sv.file("package.json", (content) => {
       const { data, generateCode } = parseJson(content);
       data.scripts ?? (data.scripts = {});
@@ -8114,7 +8474,13 @@ const helpConfig = {
       return `--[no-]${longFlag.slice(2)}`;
     }
     return option.flags;
-  }
+  },
+  styleTitle: (str) => pc.underline(str),
+  styleCommandText: (str) => pc.red(str),
+  styleDescriptionText: (str) => pc.gray(str),
+  styleOptionText: (str) => pc.white(str),
+  styleArgumentText: (str) => pc.white(str),
+  styleSubcommandText: (str) => pc.red(str)
 };
 function formatDescription(arg) {
   let output = arg.description;
@@ -11727,9 +12093,9 @@ function getGlobalPreconditions(cwd, addons, addonSetupResult) {
         name: "clean working directory",
         run: async () => {
           try {
-            const { stdout } = await be("git", ["status", "--short"], {
-              nodeOptions: { cwd },
-              throwOnError: true
+            const asyncExec = promisify(exec);
+            const { stdout } = await asyncExec("git status --short", {
+              cwd
             });
             if (stdout) {
               return { success: false, message: "Found modified files" };