@tscircuit/cli 0.1.130 → 0.1.132

package/README.md

@@ -39,9 +39,9 @@ Options:
   -h, --help                 display help for command
 
 Commands:
-  init [directory]           Initialize a new TSCircuit project in the
-                             specified directory (or current directory if none
-                             is provided)
+  init [directory]           Initialize a new TSCircuit project in the specified
+                             directory (or current directory if none is
+                             provided)
   dev [options] [file]       Start development server for a package
   clone [options] <package>  Clone a package from the registry
   push [options] [file]      Save snippet code to Registry API

package/dist/main.js

@@ -139,10 +139,14 @@ var require_help = __commonJS((exports2) => {
   class Help {
     constructor() {
       this.helpWidth = undefined;
+      this.minWidthToWrap = 40;
       this.sortSubcommands = false;
       this.sortOptions = false;
       this.showGlobalOptions = false;
     }
+    prepareContext(contextOptions) {
+      this.helpWidth = this.helpWidth ?? contextOptions.helpWidth ?? 80;
+    }
     visibleCommands(cmd) {
       const visibleCommands = cmd.commands.filter((cmd2) => !cmd2._hidden);
       const helpCommand = cmd._getHelpCommand();
@@ -217,22 +221,22 @@ var require_help = __commonJS((exports2) => {
     }
     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);
     }
     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);
     }
     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);
     }
     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);
     }
     commandUsage(cmd) {
@@ -270,7 +274,11 @@ var require_help = __commonJS((exports2) => {
         extraInfo.push(`env: ${option.envVar}`);
       }
       if (extraInfo.length > 0) {
-        return `${option.description} (${extraInfo.join(", ")})`;
+        const extraDescription = `(${extraInfo.join(", ")})`;
+        if (option.description) {
+          return `${option.description} ${extraDescription}`;
+        }
+        return extraDescription;
       }
       return option.description;
     }
@@ -283,102 +291,202 @@ var require_help = __commonJS((exports2) => {
         extraInfo.push(`default: ${argument.defaultValueDescription || JSON.stringify(argument.defaultValue)}`);
       }
       if (extraInfo.length > 0) {
-        const extraDescripton = `(${extraInfo.join(", ")})`;
+        const extraDescription = `(${extraInfo.join(", ")})`;
         if (argument.description) {
-          return `${argument.description} ${extraDescripton}`;
+          return `${argument.description} ${extraDescription}`;
         }
-        return extraDescripton;
+        return extraDescription;
       }
       return argument.description;
     }
+    formatItemList(heading, items, helper) {
+      if (items.length === 0)
+        return [];
+      return [helper.styleTitle(heading), ...items, ""];
+    }
+    groupItems(unsortedItems, visibleItems, getGroup) {
+      const result = new Map;
+      unsortedItems.forEach((item) => {
+        const group = getGroup(item);
+        if (!result.has(group))
+          result.set(group, []);
+      });
+      visibleItems.forEach((item) => {
+        const group = getGroup(item);
+        if (!result.has(group)) {
+          result.set(group, []);
+        }
+        result.get(group).push(item);
+      });
+      return result;
+    }
     formatHelp(cmd, helper) {
       const termWidth = helper.padWidth(cmd, helper);
-      const helpWidth = helper.helpWidth || 80;
-      const itemIndentWidth = 2;
-      const itemSeparatorWidth = 2;
-      function formatItem(term, description) {
-        if (description) {
-          const fullText = `${term.padEnd(termWidth + itemSeparatorWidth)}${description}`;
-          return helper.wrap(fullText, helpWidth - itemIndentWidth, termWidth + itemSeparatorWidth);
-        }
-        return term;
+      const helpWidth = helper.helpWidth ?? 80;
+      function callFormatItem(term, description) {
+        return helper.formatItem(term, termWidth, description, helper);
       }
-      function formatList(textArray) {
-        return textArray.join(`
-`).replace(/^/gm, " ".repeat(itemIndentWidth));
-      }
-      let output = [`Usage: ${helper.commandUsage(cmd)}`, ""];
+      let output = [
+        `${helper.styleTitle("Usage:")} ${helper.styleUsage(helper.commandUsage(cmd))}`,
+        ""
+      ];
       const commandDescription = helper.commandDescription(cmd);
       if (commandDescription.length > 0) {
         output = output.concat([
-          helper.wrap(commandDescription, helpWidth, 0),
+          helper.boxWrap(helper.styleCommandDescription(commandDescription), helpWidth),
           ""
         ]);
       }
       const argumentList = helper.visibleArguments(cmd).map((argument) => {
-        return formatItem(helper.argumentTerm(argument), helper.argumentDescription(argument));
+        return callFormatItem(helper.styleArgumentTerm(helper.argumentTerm(argument)), helper.styleArgumentDescription(helper.argumentDescription(argument)));
       });
-      if (argumentList.length > 0) {
-        output = output.concat(["Arguments:", formatList(argumentList), ""]);
-      }
-      const optionList = helper.visibleOptions(cmd).map((option) => {
-        return formatItem(helper.optionTerm(option), helper.optionDescription(option));
+      output = output.concat(this.formatItemList("Arguments:", argumentList, helper));
+      const optionGroups = this.groupItems(cmd.options, helper.visibleOptions(cmd), (option) => option.helpGroupHeading ?? "Options:");
+      optionGroups.forEach((options, group) => {
+        const optionList = options.map((option) => {
+          return callFormatItem(helper.styleOptionTerm(helper.optionTerm(option)), helper.styleOptionDescription(helper.optionDescription(option)));
+        });
+        output = output.concat(this.formatItemList(group, optionList, helper));
       });
-      if (optionList.length > 0) {
-        output = output.concat(["Options:", formatList(optionList), ""]);
-      }
-      if (this.showGlobalOptions) {
+      if (helper.showGlobalOptions) {
         const globalOptionList = helper.visibleGlobalOptions(cmd).map((option) => {
-          return formatItem(helper.optionTerm(option), helper.optionDescription(option));
+          return callFormatItem(helper.styleOptionTerm(helper.optionTerm(option)), helper.styleOptionDescription(helper.optionDescription(option)));
         });
-        if (globalOptionList.length > 0) {
-          output = output.concat([
-            "Global Options:",
-            formatList(globalOptionList),
-            ""
-          ]);
-        }
+        output = output.concat(this.formatItemList("Global Options:", globalOptionList, helper));
       }
-      const commandList = helper.visibleCommands(cmd).map((cmd2) => {
-        return formatItem(helper.subcommandTerm(cmd2), helper.subcommandDescription(cmd2));
+      const commandGroups = this.groupItems(cmd.commands, helper.visibleCommands(cmd), (sub) => sub.helpGroup() || "Commands:");
+      commandGroups.forEach((commands, group) => {
+        const commandList = commands.map((sub) => {
+          return callFormatItem(helper.styleSubcommandTerm(helper.subcommandTerm(sub)), helper.styleSubcommandDescription(helper.subcommandDescription(sub)));
+        });
+        output = output.concat(this.formatItemList(group, commandList, helper));
       });
-      if (commandList.length > 0) {
-        output = output.concat(["Commands:", formatList(commandList), ""]);
-      }
       return output.join(`
 `);
     }
+    displayWidth(str) {
+      return stripColor(str).length;
+    }
+    styleTitle(str) {
+      return str;
+    }
+    styleUsage(str) {
+      return str.split(" ").map((word) => {
+        if (word === "[options]")
+          return this.styleOptionText(word);
+        if (word === "[command]")
+          return this.styleSubcommandText(word);
+        if (word[0] === "[" || word[0] === "<")
+          return this.styleArgumentText(word);
+        return this.styleCommandText(word);
+      }).join(" ");
+    }
+    styleCommandDescription(str) {
+      return this.styleDescriptionText(str);
+    }
+    styleOptionDescription(str) {
+      return this.styleDescriptionText(str);
+    }
+    styleSubcommandDescription(str) {
+      return this.styleDescriptionText(str);
+    }
+    styleArgumentDescription(str) {
+      return this.styleDescriptionText(str);
+    }
+    styleDescriptionText(str) {
+      return str;
+    }
+    styleOptionTerm(str) {
+      return this.styleOptionText(str);
+    }
+    styleSubcommandTerm(str) {
+      return str.split(" ").map((word) => {
+        if (word === "[options]")
+          return this.styleOptionText(word);
+        if (word[0] === "[" || word[0] === "<")
+          return this.styleArgumentText(word);
+        return this.styleSubcommandText(word);
+      }).join(" ");
+    }
+    styleArgumentTerm(str) {
+      return this.styleArgumentText(str);
+    }
+    styleOptionText(str) {
+      return str;
+    }
+    styleArgumentText(str) {
+      return str;
+    }
+    styleSubcommandText(str) {
+      return str;
+    }
+    styleCommandText(str) {
+      return str;
+    }
     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)
+    preformatted(str) {
+      return /\n[^\S\r\n]/.test(str);
+    }
+    formatItem(term, termWidth, description, helper) {
+      const itemIndent = 2;
+      const itemIndentStr = " ".repeat(itemIndent);
+      if (!description)
+        return itemIndentStr + term;
+      const paddedTerm = term.padEnd(termWidth + term.length - helper.displayWidth(term));
+      const spacerWidth = 2;
+      const helpWidth = this.helpWidth ?? 80;
+      const remainingWidth = helpWidth - termWidth - spacerWidth - itemIndent;
+      let formattedDescription;
+      if (remainingWidth < this.minWidthToWrap || helper.preformatted(description)) {
+        formattedDescription = description;
+      } else {
+        const wrappedDescription = helper.boxWrap(description, remainingWidth);
+        formattedDescription = wrappedDescription.replace(/\n/g, `
+` + " ".repeat(termWidth + spacerWidth));
+      }
+      return itemIndentStr + paddedTerm + " ".repeat(spacerWidth) + formattedDescription.replace(/\n/g, `
+${itemIndentStr}`);
+    }
+    boxWrap(str, width) {
+      if (width < this.minWidthToWrap)
         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(`
+      const rawLines = str.split(/\r\n|\n/);
+      const chunkPattern = /[\s]*[^\s]+/g;
+      const wrappedLines = [];
+      rawLines.forEach((line) => {
+        const chunks = line.match(chunkPattern);
+        if (chunks === null) {
+          wrappedLines.push("");
+          return;
+        }
+        let sumChunks = [chunks.shift()];
+        let sumWidth = this.displayWidth(sumChunks[0]);
+        chunks.forEach((chunk) => {
+          const visibleWidth = this.displayWidth(chunk);
+          if (sumWidth + visibleWidth <= width) {
+            sumChunks.push(chunk);
+            sumWidth += visibleWidth;
+            return;
+          }
+          wrappedLines.push(sumChunks.join(""));
+          const nextChunk = chunk.trimStart();
+          sumChunks = [nextChunk];
+          sumWidth = this.displayWidth(nextChunk);
+        });
+        wrappedLines.push(sumChunks.join(""));
+      });
+      return wrappedLines.join(`
 `);
     }
   }
+  function stripColor(str) {
+    const sgrPattern = /\x1b\[\d*(;\d*)*m/g;
+    return str.replace(sgrPattern, "");
+  }
   exports2.Help = Help;
+  exports2.stripColor = stripColor;
 });
 
 // node_modules/commander/lib/option.js
@@ -409,6 +517,7 @@ var require_option = __commonJS((exports2) => {
       this.argChoices = undefined;
       this.conflictsWith = [];
       this.implied = undefined;
+      this.helpGroupHeading = undefined;
     }
     default(value2, description) {
       this.defaultValue = value2;
@@ -473,7 +582,14 @@ var require_option = __commonJS((exports2) => {
       return this.short.replace(/^-/, "");
     }
     attributeName() {
-      return camelcase(this.name().replace(/^no-/, ""));
+      if (this.negate) {
+        return camelcase(this.name().replace(/^no-/, ""));
+      }
+      return camelcase(this.name());
+    }
+    helpGroup(heading) {
+      this.helpGroupHeading = heading;
+      return this;
     }
     is(arg) {
       return this.short === arg || this.long === arg;
@@ -518,14 +634,38 @@ var require_option = __commonJS((exports2) => {
   function splitOptionFlags(flags) {
     let shortFlag;
     let longFlag;
-    const flagParts = flags.split(/[ |,]+/);
-    if (flagParts.length > 1 && !/^[[<]/.test(flagParts[1]))
+    const shortFlagExp = /^-[^-]$/;
+    const longFlagExp = /^--[^-]/;
+    const flagParts = flags.split(/[ |,]+/).concat("guard");
+    if (shortFlagExp.test(flagParts[0]))
       shortFlag = flagParts.shift();
-    longFlag = flagParts.shift();
-    if (!shortFlag && /^-[^-]$/.test(longFlag)) {
+    if (longFlagExp.test(flagParts[0]))
+      longFlag = flagParts.shift();
+    if (!shortFlag && shortFlagExp.test(flagParts[0]))
+      shortFlag = flagParts.shift();
+    if (!shortFlag && longFlagExp.test(flagParts[0])) {
       shortFlag = longFlag;
-      longFlag = undefined;
-    }
+      longFlag = flagParts.shift();
+    }
+    if (flagParts[0].startsWith("-")) {
+      const unsupportedFlag = flagParts[0];
+      const baseError = `option creation failed due to '${unsupportedFlag}' in option flags '${flags}'`;
+      if (/^-[^-][^-]/.test(unsupportedFlag))
+        throw new Error(`${baseError}
+- a short flag is a single dash and a single character
+  - either use a single dash and a single character (for a short flag)
+  - or use a double dash for a long option (and can have two, like '--ws, --workspace')`);
+      if (shortFlagExp.test(unsupportedFlag))
+        throw new Error(`${baseError}
+- too many short flags`);
+      if (longFlagExp.test(unsupportedFlag))
+        throw new Error(`${baseError}
+- too many long flags`);
+      throw new Error(`${baseError}
+- unrecognised flag format`);
+    }
+    if (shortFlag === undefined && longFlag === undefined)
+      throw new Error(`option creation failed due to no flags found in '${flags}'.`);
     return { shortFlag, longFlag };
   }
   exports2.Option = Option;
@@ -614,7 +754,7 @@ var require_command = __commonJS((exports2) => {
   var process2 = __require("node:process");
   var { Argument, humanReadableArgName } = require_argument();
   var { CommanderError } = require_error();
-  var { Help } = require_help();
+  var { Help, stripColor } = require_help();
   var { Option, DualOptions } = require_option();
   var { suggestSimilar } = require_suggestSimilar();
 
@@ -625,7 +765,7 @@ var require_command = __commonJS((exports2) => {
       this.options = [];
       this.parent = null;
       this._allowUnknownOption = false;
-      this._allowExcessArguments = true;
+      this._allowExcessArguments = false;
       this.registeredArguments = [];
       this._args = this.registeredArguments;
       this.args = [];
@@ -652,18 +792,25 @@ var require_command = __commonJS((exports2) => {
       this._lifeCycleHooks = {};
       this._showHelpAfterError = false;
       this._showSuggestionAfterError = true;
+      this._savedState = null;
       this._outputConfiguration = {
         writeOut: (str) => process2.stdout.write(str),
         writeErr: (str) => process2.stderr.write(str),
+        outputError: (str, write) => write(str),
         getOutHelpWidth: () => process2.stdout.isTTY ? process2.stdout.columns : undefined,
         getErrHelpWidth: () => process2.stderr.isTTY ? process2.stderr.columns : undefined,
-        outputError: (str, write) => write(str)
+        getOutHasColors: () => useColor() ?? (process2.stdout.isTTY && process2.stdout.hasColors?.()),
+        getErrHasColors: () => useColor() ?? (process2.stderr.isTTY && process2.stderr.hasColors?.()),
+        stripColor: (str) => stripColor(str)
       };
       this._hidden = false;
       this._helpOption = undefined;
       this._addImplicitHelpCommand = undefined;
       this._helpCommand = undefined;
       this._helpConfiguration = {};
+      this._helpGroupHeading = undefined;
+      this._defaultCommandGroup = undefined;
+      this._defaultOptionGroup = undefined;
     }
     copyInheritedSettings(sourceCommand) {
       this._outputConfiguration = sourceCommand._outputConfiguration;
@@ -728,7 +875,7 @@ var require_command = __commonJS((exports2) => {
     configureOutput(configuration) {
       if (configuration === undefined)
         return this._outputConfiguration;
-      Object.assign(this._outputConfiguration, configuration);
+      this._outputConfiguration = Object.assign({}, this._outputConfiguration, configuration);
       return this;
     }
     showHelpAfterError(displayHelp = true) {
@@ -759,12 +906,12 @@ var require_command = __commonJS((exports2) => {
     createArgument(name, description) {
       return new Argument(name, description);
     }
-    argument(name, description, fn, defaultValue) {
+    argument(name, description, parseArg, defaultValue) {
       const argument = this.createArgument(name, description);
-      if (typeof fn === "function") {
-        argument.default(defaultValue).argParser(fn);
+      if (typeof parseArg === "function") {
+        argument.default(defaultValue).argParser(parseArg);
       } else {
-        argument.default(fn);
+        argument.default(parseArg);
       }
       this.addArgument(argument);
       return this;
@@ -789,10 +936,13 @@ var require_command = __commonJS((exports2) => {
     helpCommand(enableOrNameAndArgs, description) {
       if (typeof enableOrNameAndArgs === "boolean") {
         this._addImplicitHelpCommand = enableOrNameAndArgs;
+        if (enableOrNameAndArgs && this._defaultCommandGroup) {
+          this._initCommandGroup(this._getHelpCommand());
+        }
         return this;
       }
-      enableOrNameAndArgs = enableOrNameAndArgs ?? "help [command]";
-      const [, helpName, helpArgs] = enableOrNameAndArgs.match(/([^ ]+) *(.*)/);
+      const nameAndArgs = enableOrNameAndArgs ?? "help [command]";
+      const [, helpName, helpArgs] = nameAndArgs.match(/([^ ]+) *(.*)/);
       const helpDescription = description ?? "display help for command";
       const helpCommand = this.createCommand(helpName);
       helpCommand.helpOption(false);
@@ -802,6 +952,8 @@ var require_command = __commonJS((exports2) => {
         helpCommand.description(helpDescription);
       this._addImplicitHelpCommand = true;
       this._helpCommand = helpCommand;
+      if (enableOrNameAndArgs || description)
+        this._initCommandGroup(helpCommand);
       return this;
     }
     addHelpCommand(helpCommand, deprecatedDescription) {
@@ -811,6 +963,7 @@ var require_command = __commonJS((exports2) => {
       }
       this._addImplicitHelpCommand = true;
       this._helpCommand = helpCommand;
+      this._initCommandGroup(helpCommand);
       return this;
     }
     _getHelpCommand() {
@@ -890,6 +1043,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         throw new Error(`Cannot add option '${option.flags}'${this._name && ` to command '${this._name}'`} due to conflicting flag '${matchingFlag}'
 -  already used by option '${matchingOption.flags}'`);
       }
+      this._initOptionGroup(option);
       this.options.push(option);
     }
     _registerCommand(command) {
@@ -902,6 +1056,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         const newCmd = knownBy(command).join("|");
         throw new Error(`cannot add command '${newCmd}' as already have command '${existingCmd}'`);
       }
+      this._initCommandGroup(command);
       this.commands.push(command);
     }
     addOption(option) {
@@ -1089,15 +1244,53 @@ Expecting one of '${allowedValues.join("', '")}'`);
       return userArgs;
     }
     parse(argv, parseOptions) {
+      this._prepareForParse();
       const userArgs = this._prepareUserArgs(argv, parseOptions);
       this._parseCommand([], userArgs);
       return this;
     }
     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();
+      }
+    }
+    saveStateBeforeParse() {
+      this._savedState = {
+        _name: this._name,
+        _optionValues: { ...this._optionValues },
+        _optionValueSources: { ...this._optionValueSources }
+      };
+    }
+    restoreStateBeforeParse() {
+      if (this._storeOptionsAsProperties)
+        throw new Error(`Can not call parse again when storeOptionsAsProperties is true.
+- either make a new Command for each call to parse, or stop storing options as properties`);
+      this._name = this._savedState._name;
+      this._scriptPath = null;
+      this.rawArgs = [];
+      this._optionValues = { ...this._savedState._optionValues };
+      this._optionValueSources = { ...this._savedState._optionValueSources };
+      this.args = [];
+      this.processedArgs = [];
+    }
+    _checkForMissingExecutable(executableFile, executableDir, subcommandName) {
+      if (fs.existsSync(executableFile))
+        return;
+      const executableDirMessage = executableDir ? `searched for local subcommand relative to directory '${executableDir}'` : "no directory for search for local subcommand, use .executableDir() to supply a custom directory";
+      const executableMissing = `'${executableFile}' does not exist
+ - if '${subcommandName}' is not meant to be an executable command, remove description parameter from '.command()' and use '.description()' instead
+ - if the default executable name is not suitable, use the executableFile option to supply a custom name or path
+ - ${executableDirMessage}`;
+      throw new Error(executableMissing);
+    }
     _executeSubCommand(subcommand, args) {
       args = args.slice();
       let launchWithNode = false;
@@ -1121,7 +1314,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         let resolvedScriptPath;
         try {
           resolvedScriptPath = fs.realpathSync(this._scriptPath);
-        } catch (err) {
+        } catch {
           resolvedScriptPath = this._scriptPath;
         }
         executableDir = path.resolve(path.dirname(resolvedScriptPath), executableDir);
@@ -1147,6 +1340,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           proc = childProcess.spawn(executableFile, args, { stdio: "inherit" });
         }
       } else {
+        this._checkForMissingExecutable(executableFile, executableDir, subcommand._name);
         args.unshift(executableFile);
         args = incrementNodeInspectorPort(process2.execArgv).concat(args);
         proc = childProcess.spawn(process2.execPath, args, { stdio: "inherit" });
@@ -1172,12 +1366,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
       });
       proc.on("error", (err) => {
         if (err.code === "ENOENT") {
-          const executableDirMessage = executableDir ? `searched for local subcommand relative to directory '${executableDir}'` : "no directory for search for local subcommand, use .executableDir() to supply a custom directory";
-          const executableMissing = `'${executableFile}' does not exist
- - if '${subcommand._name}' is not meant to be an executable command, remove description parameter from '.command()' and use '.description()' instead
- - if the default executable name is not suitable, use the executableFile option to supply a custom name or path
- - ${executableDirMessage}`;
-          throw new Error(executableMissing);
+          this._checkForMissingExecutable(executableFile, executableDir, subcommand._name);
         } else if (err.code === "EACCES") {
           throw new Error(`'${executableFile}' not executable`);
         }
@@ -1195,6 +1384,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, subCommand, "preSubcommand");
       promiseChain = this._chainOrCall(promiseChain, () => {
@@ -1411,6 +1601,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
       function maybeOption(arg) {
         return arg.length > 1 && arg[0] === "-";
       }
+      const negativeNumberArg = (arg) => {
+        if (!/^-\d*\.?\d+(e[+-]?\d+)?$/.test(arg))
+          return false;
+        return !this._getCommandAndAncestors().some((cmd) => cmd.options.map((opt) => opt.short).some((short) => /^-\d$/.test(short)));
+      };
       let activeVariadicOption = null;
       while (args.length) {
         const arg = args.shift();
@@ -1420,7 +1615,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           dest.push(...args);
           break;
         }
-        if (activeVariadicOption && !maybeOption(arg)) {
+        if (activeVariadicOption && (!maybeOption(arg) || negativeNumberArg(arg))) {
           this.emit(`option:${activeVariadicOption.name()}`, arg);
           continue;
         }
@@ -1435,7 +1630,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
               this.emit(`option:${option.name()}`, value2);
             } else if (option.optional) {
               let value2 = null;
-              if (args.length > 0 && !maybeOption(args[0])) {
+              if (args.length > 0 && (!maybeOption(args[0]) || negativeNumberArg(args[0]))) {
                 value2 = args.shift();
               }
               this.emit(`option:${option.name()}`, value2);
@@ -1466,7 +1661,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
             continue;
           }
         }
-        if (maybeOption(arg)) {
+        if (dest === operands && maybeOption(arg) && !(this.commands.length === 0 && negativeNumberArg(arg))) {
           dest = unknown;
         }
         if ((this._enablePositionalOptions || this._passThroughOptions) && operands.length === 0 && unknown.length === 0) {
@@ -1701,6 +1896,32 @@ Expecting one of '${allowedValues.join("', '")}'`);
       this._name = str;
       return this;
     }
+    helpGroup(heading) {
+      if (heading === undefined)
+        return this._helpGroupHeading ?? "";
+      this._helpGroupHeading = heading;
+      return this;
+    }
+    commandsGroup(heading) {
+      if (heading === undefined)
+        return this._defaultCommandGroup ?? "";
+      this._defaultCommandGroup = heading;
+      return this;
+    }
+    optionsGroup(heading) {
+      if (heading === undefined)
+        return this._defaultOptionGroup ?? "";
+      this._defaultOptionGroup = heading;
+      return this;
+    }
+    _initOptionGroup(option) {
+      if (this._defaultOptionGroup && !option.helpGroupHeading)
+        option.helpGroup(this._defaultOptionGroup);
+    }
+    _initCommandGroup(cmd) {
+      if (this._defaultCommandGroup && !cmd.helpGroup())
+        cmd.helpGroup(this._defaultCommandGroup);
+    }
     nameFromFilename(filename) {
       this._name = path.basename(filename, path.extname(filename));
       return this;
@@ -1713,23 +1934,38 @@ 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);
     }
-    _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 };
     }
     outputHelp(contextOptions) {
       let deprecatedCallback;
@@ -1737,35 +1973,44 @@ Expecting one of '${allowedValues.join("', '")}'`);
         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);
+      const outputContext = this._getOutputContext(contextOptions);
+      const eventContext = {
+        error: outputContext.error,
+        write: outputContext.write,
+        command: this
+      };
+      this._getCommandAndAncestors().reverse().forEach((command) => command.emit("beforeAllHelp", eventContext));
+      this.emit("beforeHelp", eventContext);
+      let helpInformation = this.helpInformation({ error: outputContext.error });
       if (deprecatedCallback) {
         helpInformation = deprecatedCallback(helpInformation);
         if (typeof helpInformation !== "string" && !Buffer.isBuffer(helpInformation)) {
           throw new Error("outputHelp callback must return a string or a Buffer");
         }
       }
-      context.write(helpInformation);
+      outputContext.write(helpInformation);
       if (this._getHelpOption()?.long) {
         this.emit(this._getHelpOption().long);
       }
-      this.emit("afterHelp", context);
-      this._getCommandAndAncestors().forEach((command) => command.emit("afterAllHelp", context));
+      this.emit("afterHelp", eventContext);
+      this._getCommandAndAncestors().forEach((command) => command.emit("afterAllHelp", eventContext));
     }
     helpOption(flags, description) {
       if (typeof flags === "boolean") {
         if (flags) {
-          this._helpOption = this._helpOption ?? undefined;
+          if (this._helpOption === null)
+            this._helpOption = undefined;
+          if (this._defaultOptionGroup) {
+            this._initOptionGroup(this._getHelpOption());
+          }
         } else {
           this._helpOption = null;
         }
         return this;
       }
-      flags = flags ?? "-h, --help";
-      description = description ?? "display help for command";
-      this._helpOption = this.createOption(flags, description);
+      this._helpOption = this.createOption(flags ?? "-h, --help", description ?? "display help for command");
+      if (flags || description)
+        this._initOptionGroup(this._helpOption);
       return this;
     }
     _getHelpOption() {
@@ -1776,11 +2021,12 @@ Expecting one of '${allowedValues.join("', '")}'`);
     }
     addHelpOption(option) {
       this._helpOption = option;
+      this._initOptionGroup(option);
       return this;
     }
     help(contextOptions) {
       this.outputHelp(contextOptions);
-      let exitCode = process2.exitCode || 0;
+      let exitCode = Number(process2.exitCode ?? 0);
       if (exitCode === 0 && contextOptions && typeof contextOptions !== "function" && contextOptions.error) {
         exitCode = 1;
       }
@@ -1845,7 +2091,15 @@ Expecting one of '${allowedValues.join("', '")}'`);
       return arg;
     });
   }
+  function useColor() {
+    if (process2.env.NO_COLOR || process2.env.FORCE_COLOR === "0" || process2.env.FORCE_COLOR === "false")
+      return false;
+    if (process2.env.FORCE_COLOR || process2.env.CLICOLOR_FORCE !== undefined)
+      return true;
+    return;
+  }
   exports2.Command = Command;
+  exports2.useColor = useColor;
 });
 
 // node_modules/commander/index.js
@@ -441915,7 +442169,7 @@ var getGlobalDepsInstallCommand = (packageManager, deps) => {
 import { execSync as execSync2 } from "node:child_process";
 var import_semver2 = __toESM2(require_semver2(), 1);
 // package.json
-var version = "0.1.129";
+var version = "0.1.131";
 var package_default = {
   name: "@tscircuit/cli",
   version,
@@ -441939,7 +442193,7 @@ var package_default = {
     chokidar: "4.0.1",
     "circuit-json-to-readable-netlist": "^0.0.9",
     "circuit-to-svg": "^0.0.152",
-    commander: "^12.1.0",
+    commander: "^14.0.0",
     conf: "^13.1.0",
     configstore: "^7.0.0",
     cosmiconfig: "^9.0.0",
@@ -496017,6 +496271,10 @@ var registerRemove = (program3) => {
 };
 
 // cli/build/register.ts
+import path25 from "node:path";
+import fs25 from "node:fs";
+
+// cli/build/build-file.ts
 import path23 from "node:path";
 import fs23 from "node:fs";
 
@@ -496042,46 +496300,112 @@ function analyzeCircuitJson(circuitJson) {
   return { errors, warnings };
 }
 
-// cli/build/register.ts
-var registerBuild = (program3) => {
-  program3.command("build").description("Run tscircuit eval and output circuit json").argument("[file]", "Path to the entry file").option("--ignore-errors", "Do not exit with code 1 on errors").option("--ignore-warnings", "Do not log warnings").action(async (file, options) => {
-    const entrypoint = await getEntrypoint({ filePath: file });
-    if (!entrypoint)
-      return process.exit(1);
-    const projectDir = path23.dirname(entrypoint);
-    const distDir = path23.join(projectDir, "dist");
-    const outputPath = path23.join(distDir, "circuit.json");
-    fs23.mkdirSync(distDir, { recursive: true });
-    try {
-      const result = await generateCircuitJson({ filePath: entrypoint });
-      fs23.writeFileSync(outputPath, JSON.stringify(result.circuitJson, null, 2));
-      console.log(`Circuit JSON written to ${path23.relative(projectDir, outputPath)}`);
-      const { errors, warnings } = analyzeCircuitJson(result.circuitJson);
-      if (!options?.ignoreWarnings) {
-        for (const warn of warnings) {
-          const msg = warn.message || JSON.stringify(warn);
-          console.log(kleur_default.yellow(msg));
-        }
+// cli/build/build-file.ts
+var buildFile = async (input, output, projectDir, options) => {
+  try {
+    const result = await generateCircuitJson({ filePath: input });
+    fs23.mkdirSync(path23.dirname(output), { recursive: true });
+    fs23.writeFileSync(output, JSON.stringify(result.circuitJson, null, 2));
+    console.log(`Circuit JSON written to ${path23.relative(projectDir, output)}`);
+    const { errors, warnings } = analyzeCircuitJson(result.circuitJson);
+    if (!options?.ignoreWarnings) {
+      for (const warn of warnings) {
+        const msg = warn.message || JSON.stringify(warn);
+        console.log(kleur_default.yellow(msg));
       }
-      if (!options?.ignoreErrors) {
-        for (const err of errors) {
-          const msg = err.message || JSON.stringify(err);
-          console.error(kleur_default.red(msg));
-        }
+    }
+    if (!options?.ignoreErrors) {
+      for (const err of errors) {
+        const msg = err.message || JSON.stringify(err);
+        console.error(kleur_default.red(msg));
       }
-      if (errors.length > 0 && !options?.ignoreErrors) {
-        return process.exit(1);
+    }
+    return errors.length === 0;
+  } catch (err) {
+    console.error(`Build failed: ${err}`);
+    return false;
+  }
+};
+
+// cli/build/get-build-entrypoints.ts
+import fs24 from "node:fs";
+import path24 from "node:path";
+async function getBuildEntrypoints({
+  fileOrDir,
+  rootDir = process.cwd()
+}) {
+  const resolvedRoot = path24.resolve(rootDir);
+  if (fileOrDir) {
+    const resolved = path24.resolve(resolvedRoot, fileOrDir);
+    if (fs24.existsSync(resolved) && fs24.statSync(resolved).isDirectory()) {
+      const projectDir2 = resolved;
+      const circuitFiles2 = [];
+      const mainEntrypoint2 = await getEntrypoint({
+        projectDir: projectDir2,
+        onError: () => {}
+      });
+      const files2 = globbySync("**/*.circuit.tsx", {
+        cwd: projectDir2,
+        ignore: DEFAULT_IGNORED_PATTERNS
+      });
+      for (const f of files2) {
+        circuitFiles2.push(path24.join(projectDir2, f));
       }
-    } catch (err) {
-      console.error(`Build failed: ${err}`);
-      return process.exit(1);
+      return {
+        projectDir: projectDir2,
+        mainEntrypoint: mainEntrypoint2 || undefined,
+        circuitFiles: circuitFiles2
+      };
+    }
+    return { projectDir: path24.dirname(resolved), circuitFiles: [resolved] };
+  }
+  const projectDir = resolvedRoot;
+  const circuitFiles = [];
+  const mainEntrypoint = await getEntrypoint({ projectDir, onError: () => {} });
+  const files = globbySync("**/*.circuit.tsx", {
+    cwd: projectDir,
+    ignore: DEFAULT_IGNORED_PATTERNS
+  });
+  for (const f of files) {
+    circuitFiles.push(path24.join(projectDir, f));
+  }
+  return {
+    projectDir,
+    mainEntrypoint: mainEntrypoint || undefined,
+    circuitFiles
+  };
+}
+
+// cli/build/register.ts
+var registerBuild = (program3) => {
+  program3.command("build").description("Run tscircuit eval and output circuit json").argument("[file]", "Path to the entry file").option("--ignore-errors", "Do not exit with code 1 on errors").option("--ignore-warnings", "Do not log warnings").action(async (file, options) => {
+    const { projectDir, mainEntrypoint, circuitFiles } = await getBuildEntrypoints({ fileOrDir: file });
+    const distDir = path25.join(projectDir, "dist");
+    fs25.mkdirSync(distDir, { recursive: true });
+    let hasErrors = false;
+    if (mainEntrypoint) {
+      const outputPath = path25.join(distDir, "circuit.json");
+      const ok = await buildFile(mainEntrypoint, outputPath, projectDir, options);
+      if (!ok)
+        hasErrors = true;
+    }
+    for (const filePath of circuitFiles) {
+      const relative6 = path25.relative(projectDir, filePath);
+      const isCircuit = filePath.endsWith(".circuit.tsx");
+      const outputPath = isCircuit ? path25.join(distDir, relative6.replace(/\.circuit\.tsx$/, ""), "circuit.json") : path25.join(distDir, "circuit.json");
+      const ok = await buildFile(filePath, outputPath, projectDir, options);
+      if (!ok)
+        hasErrors = true;
+    }
+    if (hasErrors && !options?.ignoreErrors) {
+      process.exit(1);
     }
   });
 };
 
 // lib/shared/snapshot-project.ts
-import fs24 from "node:fs";
-import path24 from "node:path";
+import fs26 from "node:fs";
+import path26 from "node:path";
 init_dist6();
 
 // node_modules/circuit-json-to-simple-3d/dist/index.js
@@ -496735,7 +497059,7 @@ var snapshotProject = async ({
     ...ignored.map(normalizeIgnorePattern)
   ];
   const boardFiles = globbySync("**/*.board.tsx", { cwd: projectDir, ignore });
-  let files = boardFiles.map((f) => path24.join(projectDir, f));
+  let files = boardFiles.map((f) => path26.join(projectDir, f));
   if (files.length === 0) {
     const entry = await getEntrypoint({
       projectDir,
@@ -496752,9 +497076,9 @@ var snapshotProject = async ({
     const pcbSvg = convertCircuitJsonToPcbSvg(circuitJson);
     const schSvg = convertCircuitJsonToSchematicSvg(circuitJson);
     const svg3d = threeD ? await convertCircuitJsonToSimple3dSvg(circuitJson) : null;
-    const snapDir = path24.join(path24.dirname(file), "__snapshots__");
-    fs24.mkdirSync(snapDir, { recursive: true });
-    const base = path24.basename(file).replace(/\.tsx$/, "");
+    const snapDir = path26.join(path26.dirname(file), "__snapshots__");
+    fs26.mkdirSync(snapDir, { recursive: true });
+    const base = path26.basename(file).replace(/\.tsx$/, "");
     const snapshotPairs = [
       ["pcb", pcbSvg],
       ["schematic", schSvg]
@@ -496763,11 +497087,11 @@ var snapshotProject = async ({
       snapshotPairs.push(["3d", svg3d]);
     }
     for (const [type, svg] of snapshotPairs) {
-      const snapPath = path24.join(snapDir, `${base}-${type}.snap.svg`);
-      if (update || !fs24.existsSync(snapPath)) {
-        fs24.writeFileSync(snapPath, svg);
+      const snapPath = path26.join(snapDir, `${base}-${type}.snap.svg`);
+      if (update || !fs26.existsSync(snapPath)) {
+        fs26.writeFileSync(snapPath, svg);
       } else {
-        const existing = fs24.readFileSync(snapPath, "utf-8");
+        const existing = fs26.readFileSync(snapPath, "utf-8");
         if (existing !== svg)
           mismatches.push(snapPath);
       }
@@ -496801,11 +497125,22 @@ var registerSnapshot = (program3) => {
 };
 
 // lib/shared/setup-github-actions.ts
-import fs25 from "node:fs";
-import path25 from "node:path";
+import fs27 from "node:fs";
+import path27 from "node:path";
 var setupGithubActions = (projectDir = process.cwd()) => {
-  const workflowsDir = path25.join(projectDir, ".github", "workflows");
-  fs25.mkdirSync(workflowsDir, { recursive: true });
+  const findGitRoot = (startDir) => {
+    let dir = path27.resolve(startDir);
+    while (dir !== path27.parse(dir).root) {
+      if (fs27.existsSync(path27.join(dir, ".git"))) {
+        return dir;
+      }
+      dir = path27.dirname(dir);
+    }
+    return null;
+  };
+  const gitRoot = findGitRoot(projectDir) ?? projectDir;
+  const workflowsDir = path27.join(gitRoot, ".github", "workflows");
+  fs27.mkdirSync(workflowsDir, { recursive: true });
   const buildWorkflow = `name: tscircuit Build
 
 on:
@@ -496844,8 +497179,8 @@ jobs:
           git commit -m "Update snapshots" || echo "No changes to commit"
           git push
 `;
-  writeFileIfNotExists(path25.join(workflowsDir, "tscircuit-build.yml"), buildWorkflow);
-  writeFileIfNotExists(path25.join(workflowsDir, "tscircuit-snapshot.yml"), snapshotWorkflow);
+  writeFileIfNotExists(path27.join(workflowsDir, "tscircuit-build.yml"), buildWorkflow);
+  writeFileIfNotExists(path27.join(workflowsDir, "tscircuit-snapshot.yml"), snapshotWorkflow);
 };
 
 // cli/setup/register.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tscircuit/cli",
-  "version": "0.1.130",
+  "version": "0.1.132",
   "main": "dist/main.js",
   "devDependencies": {
     "@babel/standalone": "^7.26.9",
@@ -21,7 +21,7 @@
     "chokidar": "4.0.1",
     "circuit-json-to-readable-netlist": "^0.0.9",
     "circuit-to-svg": "^0.0.152",
-    "commander": "^12.1.0",
+    "commander": "^14.0.0",
     "conf": "^13.1.0",
     "configstore": "^7.0.0",
     "cosmiconfig": "^9.0.0",