argsbarg 5.1.8 → 5.1.9

package/src/parse.test.ts

@@ -12,12 +12,7 @@ import { cliPresentationRoot } from "./builtins/presentation.ts";
 import { cliHelpRender } from "./help.ts";
 import { Cli, CliFallbackMode, CliOptionKind, type CliProgram } from "./index.ts";
 import { applyShellEnv } from "./mcp/env.ts";
-import {
-  allMcpResources,
-  collectMcpTools,
-  mcpToolCallToArgv,
-  resolveMcpSchemaUri,
-} from "./mcp/tools.ts";
+import { allMcpResources, collectMcpTools, mcpToolCallToArgv, resolveMcpSchemaUri } from "./mcp/tools.ts";
 import { ParseKind, parse, postParseValidate } from "./parse.ts";
 import { cliSchemaJson } from "./schema.ts";
 import { generatePluginSkillBundle, generateSkillBundle } from "./skill/generate.ts";
@@ -338,10 +333,7 @@ test("trailing options include parent-scoped flags", () => {
     ],
   });
   cliValidateProgram(root);
-  const pr = postParseValidate(
-    root,
-    parse(root, ["group", "leaf", "-u", "alice", "./file", "--json"]),
-  );
+  const pr = postParseValidate(root, parse(root, ["group", "leaf", "-u", "alice", "./file", "--json"]));
   expect(pr.kind).toBe(ParseKind.Ok);
   expect(pr.path).toEqual(["group", "leaf"]);
   expect(pr.args).toEqual(["./file"]);
@@ -415,10 +407,7 @@ test("stops parsing options at --", () => {
     ],
   });
   cliValidateProgram(root);
-  const pr = postParseValidate(
-    root,
-    parse(root, ["x", "--name", "pat", "--", "--name", "bob", "-x"]),
-  );
+  const pr = postParseValidate(root, parse(root, ["x", "--name", "pat", "--", "--name", "bob", "-x"]));
   expect(pr.kind).toBe(ParseKind.Ok);
   expect(pr.opts.name).toBe("pat");
   expect(pr.args).toEqual(["--name", "bob", "-x"]);
@@ -505,9 +494,7 @@ test("presence option cannot be required", () => {
 test("leaf completion help prints correctly", async () => {
   // Test the fix where `completion zsh -h` on a leaf root was incorrectly ignored.
   // We run this as a subprocess so we don't accidentally exit the test runner.
-  const { stdout, stderr, exitCode } = await $`bun run examples/minimal.ts completion zsh -h`
-    .nothrow()
-    .quiet();
+  const { stdout, stderr, exitCode } = await $`bun run examples/minimal.ts completion zsh -h`.nothrow().quiet();
   const out = stdout.toString();
   expect(exitCode).toBe(0);
   expect(out).toContain("Show help for this command.");
@@ -517,9 +504,7 @@ test("leaf completion help prints correctly", async () => {
 
 /** Docs schema exports JSON for nested CLIs. */
 test("docs schema exports JSON for nested CLIs", async () => {
-  const { stdout, stderr, exitCode } = await $`bun run examples/nested.ts docs schema`
-    .nothrow()
-    .quiet();
+  const { stdout, stderr, exitCode } = await $`bun run examples/nested.ts docs schema`.nothrow().quiet();
   expect(exitCode).toBe(0);
   expect(stderr.toString()).toBe("");
 
@@ -543,11 +528,7 @@ test("docs schema exports JSON for leaf roots", async () => {
   expect(schema.key).toBe("minimal.ts");
   expect(schema.positionals[0].name).toBe("name");
   expect(schema.options[0].name).toBe("verbose");
-  expect(schema.commands.map((c: { key: string }) => c.key)).toEqual([
-    "version",
-    "configure",
-    "docs",
-  ]);
+  expect(schema.commands.map((c: { key: string }) => c.key)).toEqual(["version", "configure", "docs"]);
 });
 
 test("version builtin prints program version", async () => {
@@ -956,9 +937,7 @@ test("Enum completions list choices in bash script", () => {
       {
         key: "run",
         description: "",
-        options: [
-          { name: "mode", description: "m", kind: CliOptionKind.Enum, choices: ["dev", "prod"] },
-        ],
+        options: [{ name: "mode", description: "m", kind: CliOptionKind.Enum, choices: ["dev", "prod"] }],
         handler: () => {},
       },
     ],
@@ -1047,9 +1026,7 @@ test("cliValidateProgram rejects invalid nested fallbackCommand", () => {
       },
     ],
   });
-  expect(() => cliValidateProgram(root)).toThrow(
-    /fallbackCommand 'missing' is not a child of 'docs'/,
-  );
+  expect(() => cliValidateProgram(root)).toThrow(/fallbackCommand 'missing' is not a child of 'docs'/);
 });
 
 test("cliValidateProgram accepts nested fallbackCommand when child exists", () => {
@@ -1279,9 +1256,7 @@ test("cliSkillInstall claude target uses .claude/skills", () => {
   try {
     const files = cliSkillInstall(nestedMcpFixture, "claude", { rimraf: true });
     expect(files.some((f) => f.includes(".claude/skills/nested_ts/"))).toBe(true);
-    expect(readFileSync(join(cwd, ".claude", "skills", "nested_ts", "SKILL.md"), "utf8")).toContain(
-      "Claude Code",
-    );
+    expect(readFileSync(join(cwd, ".claude", "skills", "nested_ts", "SKILL.md"), "utf8")).toContain("Claude Code");
   } finally {
     process.chdir(prev);
     rmSync(cwd, { recursive: true, force: true });

package/src/parse.ts

@@ -204,8 +204,7 @@ function consumeOptions(
           report: { err: null, stoppedOnUnknown: true, sawDoubleDash: false },
           nextIndex: idx,
         };
-      if (err)
-        return { report: { err, stoppedOnUnknown: false, sawDoubleDash: false }, nextIndex: idx };
+      if (err) return { report: { err, stoppedOnUnknown: false, sawDoubleDash: false }, nextIndex: idx };
     } else {
       const err = consumeShort(tok);
       if (err === "")
@@ -213,8 +212,7 @@ function consumeOptions(
           report: { err: null, stoppedOnUnknown: true, sawDoubleDash: false },
           nextIndex: idx,
         };
-      if (err)
-        return { report: { err, stoppedOnUnknown: false, sawDoubleDash: false }, nextIndex: idx };
+      if (err) return { report: { err, stoppedOnUnknown: false, sawDoubleDash: false }, nextIndex: idx };
     }
   }
 
@@ -317,11 +315,7 @@ function finishLeaf(
       }
     }
     if (count < argMin) {
-      return errorResult(
-        `Expected at least ${argMin} argument(s) for ${p.name}, got ${count}`,
-        path,
-        [],
-      );
+      return errorResult(`Expected at least ${argMin} argument(s) for ${p.name}, got ${count}`, path, []);
     }
   }
 
@@ -360,11 +354,7 @@ function finishLeaf(
 // ── Main Parser ───────────────────────────────────────────────────────────────
 
 /** Builds a user-error parse result; `path` defaults to `errorHelpPath`. */
-function errorResult(
-  errorMsg: string,
-  errorHelpPath: string[] = [],
-  path: string[] = errorHelpPath,
-): ParseResult {
+function errorResult(errorMsg: string, errorHelpPath: string[] = [], path: string[] = errorHelpPath): ParseResult {
   return {
     kind: ParseKind.Error,
     path,
@@ -466,9 +456,7 @@ export function parse(root: CliNode, argv: string[]): ParseResult {
         node = findChild(root.commands, cmdName);
         if (!node) {
           return errorResult(
-            forcePositionals
-              ? `Expected subcommand but got positional: ${cmdName}`
-              : `Unknown command: ${cmdName}`,
+            forcePositionals ? `Expected subcommand but got positional: ${cmdName}` : `Unknown command: ${cmdName}`,
             path,
             [],
           );
@@ -504,10 +492,7 @@ export function parse(root: CliNode, argv: string[]): ParseResult {
       if (isCliRouter(current) && current.commands.length > 0) {
         const fb = current.fallbackCommand;
         const fm = current.fallbackMode ?? CliFallbackMode.MissingOnly;
-        if (
-          fb !== undefined &&
-          (fm === CliFallbackMode.MissingOnly || fm === CliFallbackMode.MissingOrUnknown)
-        ) {
+        if (fb !== undefined && (fm === CliFallbackMode.MissingOnly || fm === CliFallbackMode.MissingOrUnknown)) {
           const fbNode = findChild(current.commands, fb);
           if (fbNode) {
             path.push(fb);
@@ -520,15 +505,7 @@ export function parse(root: CliNode, argv: string[]): ParseResult {
       if (!isCliLeaf(current)) {
         return helpResult(path, false);
       }
-      return finishLeaf(
-        current,
-        i,
-        argv,
-        path,
-        opts,
-        collectOptionDefs(root, path),
-        forcePositionals,
-      );
+      return finishLeaf(current, i, argv, path, opts, collectOptionDefs(root, path), forcePositionals);
     }
 
     const tok = argv[i];
@@ -550,8 +527,7 @@ export function parse(root: CliNode, argv: string[]): ParseResult {
       const fb = current.fallbackCommand;
       const fm = current.fallbackMode ?? CliFallbackMode.MissingOnly;
       const canRouteUnknown =
-        fb !== undefined &&
-        (fm === CliFallbackMode.MissingOrUnknown || fm === CliFallbackMode.UnknownOnly);
+        fb !== undefined && (fm === CliFallbackMode.MissingOrUnknown || fm === CliFallbackMode.UnknownOnly);
 
       if (canRouteUnknown && fb !== undefined) {
         const fbNode = findChild(current.commands, fb);
@@ -563,9 +539,7 @@ export function parse(root: CliNode, argv: string[]): ParseResult {
       }
 
       return errorResult(
-        forcePositionals
-          ? `Expected subcommand but got positional: ${tok}`
-          : `Unknown subcommand: ${tok}`,
+        forcePositionals ? `Expected subcommand but got positional: ${tok}` : `Unknown subcommand: ${tok}`,
         path,
       );
     }
@@ -573,15 +547,7 @@ export function parse(root: CliNode, argv: string[]): ParseResult {
     if (!isCliLeaf(current)) {
       return helpResult(path, false);
     }
-    return finishLeaf(
-      current,
-      i,
-      argv,
-      path,
-      opts,
-      collectOptionDefs(root, path),
-      forcePositionals,
-    );
+    return finishLeaf(current, i, argv, path, opts, collectOptionDefs(root, path), forcePositionals);
   }
 }
 

package/src/schema.ts

@@ -5,13 +5,7 @@ This module serializes the CLI schema tree to JSON for machine-readable introspe
 import { type CliSchemaExport, exportPresentationBuiltins } from "./builtins/export.ts";
 import { cliResolveNotes } from "./help.ts";
 import { visibleOptions } from "./hidden.ts";
-import {
-  type CliNode,
-  type CliProgram,
-  isCliLeaf,
-  isCliRouter,
-  leafOutputSchema,
-} from "./types.ts";
+import { type CliNode, type CliProgram, isCliLeaf, isCliRouter, leafOutputSchema } from "./types.ts";
 
 const RESERVED = new Set(["completion", "configure", "docs", "mcp", "version"]);
 
@@ -55,9 +49,7 @@ function exportCommand(cmd: CliNode, root: CliProgram): CliSchemaExport | null {
 
   const children = isCliRouter(cmd) ? cmd.commands.filter((ch) => !RESERVED.has(ch.key)) : [];
   if (children.length > 0) {
-    out.commands = children
-      .map((ch) => exportCommand(ch, root))
-      .filter((ch): ch is CliSchemaExport => ch !== null);
+    out.commands = children.map((ch) => exportCommand(ch, root)).filter((ch): ch is CliSchemaExport => ch !== null);
   }
 
   return out;

package/src/skill/hint.ts

@@ -9,11 +9,7 @@ export function generatedFileHtmlComment(source: string): string {
 }
 
 /** Prepends a hint, or inserts after frontmatter when requested. */
-export function insertGeneratedHint(
-  content: string,
-  hint: string,
-  options?: { afterFrontmatter?: boolean },
-): string {
+export function insertGeneratedHint(content: string, hint: string, options?: { afterFrontmatter?: boolean }): string {
   if (options?.afterFrontmatter) {
     const match = content.match(MARKDOWN_FRONTMATTER_RE);
     if (match) {

package/src/skill/install.ts

@@ -30,11 +30,7 @@ function resolveSkillDir(target: SkillTarget, dirName: string, global: boolean):
 }
 
 /** Writes SKILL.md and reference.md; returns changed file paths. */
-export function cliSkillInstall(
-  root: CliProgram,
-  target: SkillTarget,
-  opts: SkillInstallOpts,
-): string[] {
+export function cliSkillInstall(root: CliProgram, target: SkillTarget, opts: SkillInstallOpts): string[] {
   const bundle = generateSkillBundle(root, target);
   const { skillMd, referenceMd } = applySkillInstallHints(root, bundle.skillMd, bundle.referenceMd);
   const dir = resolveSkillDir(target, bundle.dirName, opts.global ?? false);

package/src/test-fixtures.ts

@@ -1,9 +1,7 @@
 import type { CliProgram } from "./types.ts";
 import { CliFallbackMode, CliOptionKind } from "./types.ts";
 
-export function testProgram(
-  prog: Record<string, unknown> & { key: string; description: string },
-): CliProgram {
+export function testProgram(prog: Record<string, unknown> & { key: string; description: string }): CliProgram {
   return { version: "0.0.0", ...prog } as CliProgram;
 }
 

package/src/validate.ts

@@ -29,15 +29,11 @@ function validateDocsConfig(docs: import("./types.ts").CliDocsConfig): void {
   }
   for (const reserved of DOCS_BUILTIN_TOPIC_KEYS) {
     if (reserved in docs.topics) {
-      throw new CliSchemaValidationError(
-        `docs.topics key '${reserved}' is reserved for the docs built-in`,
-      );
+      throw new CliSchemaValidationError(`docs.topics key '${reserved}' is reserved for the docs built-in`);
     }
   }
   if (docs.defaultTopic !== undefined && !(docs.defaultTopic in docs.topics)) {
-    throw new CliSchemaValidationError(
-      `docs.defaultTopic '${docs.defaultTopic}' is not a key in docs.topics`,
-    );
+    throw new CliSchemaValidationError(`docs.defaultTopic '${docs.defaultTopic}' is not a key in docs.topics`);
   }
   for (const key of keys) {
     const text = docs.topics[key]?.text;
@@ -57,18 +53,14 @@ function validateConfigBlock(appConfigBlock: import("./types.ts").CliAppConfig):
   const envNames = new Set<string>();
   for (const [key, entry] of Object.entries(entries)) {
     if (key.length === 0) {
-      throw new CliSchemaValidationError(
-        "program.appConfig.entries keys must be non-empty strings",
-      );
+      throw new CliSchemaValidationError("program.appConfig.entries keys must be non-empty strings");
     }
     if (entry === undefined || typeof entry !== "object") {
       throw new CliSchemaValidationError(`program.appConfig.entries['${key}'] must be an object`);
     }
     const description = entry.description;
     if (typeof description !== "string" || description.trim().length === 0) {
-      throw new CliSchemaValidationError(
-        `program.appConfig.entries['${key}'].description must be a non-empty string`,
-      );
+      throw new CliSchemaValidationError(`program.appConfig.entries['${key}'].description must be a non-empty string`);
     }
     if (entry.env !== undefined) {
       if (typeof entry.env !== "string" || entry.env.length === 0) {
@@ -82,9 +74,7 @@ function validateConfigBlock(appConfigBlock: import("./types.ts").CliAppConfig):
       envNames.add(entry.env);
     }
     if (entry.resolve !== undefined && typeof entry.resolve !== "function") {
-      throw new CliSchemaValidationError(
-        `program.appConfig.entries['${key}'].resolve must be a function when set`,
-      );
+      throw new CliSchemaValidationError(`program.appConfig.entries['${key}'].resolve must be a function when set`);
     }
   }
 
@@ -98,9 +88,7 @@ function validateConfigBlock(appConfigBlock: import("./types.ts").CliAppConfig):
     const properties = jsonSchema.properties;
     if (properties !== undefined) {
       if (typeof properties !== "object" || properties === null || Array.isArray(properties)) {
-        throw new CliSchemaValidationError(
-          "program.appConfig.jsonSchema.properties must be an object when set",
-        );
+        throw new CliSchemaValidationError("program.appConfig.jsonSchema.properties must be an object when set");
       }
       for (const key of Object.keys(entries)) {
         if (!(key in properties)) {
@@ -133,9 +121,7 @@ function validateConfigureConfig(program: CliProgram): void {
   if (!configure) return;
 
   if ("prefix" in configure) {
-    throw new CliSchemaValidationError(
-      "configure.prefix removed; app binary installs via Homebrew",
-    );
+    throw new CliSchemaValidationError("configure.prefix removed; app binary installs via Homebrew");
   }
 
   if (!configure.targets) return;
@@ -178,10 +164,7 @@ function validateConfigureConfig(program: CliProgram): void {
   }
 
   for (const mcpKey of MCP_KEYS) {
-    if (
-      !mcpServerRequiredForArtifact(mcpKey, mcpEnabled) &&
-      installTargetExplicitTruthy(targets[mcpKey])
-    ) {
+    if (!mcpServerRequiredForArtifact(mcpKey, mcpEnabled) && installTargetExplicitTruthy(targets[mcpKey])) {
       throw new CliSchemaValidationError(`configure.targets.${mcpKey} requires mcpServer.enabled`);
     }
   }
@@ -194,15 +177,11 @@ export function cliValidateProgram(program: CliProgram): void {
   }
 
   if (program.mcpServer !== undefined && program.mcpServer.enabled !== true) {
-    throw new CliSchemaValidationError(
-      "mcpServer requires enabled: true; omit mcpServer to disable MCP",
-    );
+    throw new CliSchemaValidationError("mcpServer requires enabled: true; omit mcpServer to disable MCP");
   }
 
   if (program.docs !== undefined && program.docs.enabled !== true) {
-    throw new CliSchemaValidationError(
-      "docs requires enabled: true; omit docs to disable bundled documentation",
-    );
+    throw new CliSchemaValidationError("docs requires enabled: true; omit docs to disable bundled documentation");
   }
 
   if (program.docs?.enabled === true) {
@@ -235,24 +214,16 @@ function walkNode(node: CliNode, program: CliProgram, isRoot: boolean): void {
   if (!isRoot) {
     const rogue = node as CliProgram;
     if (rogue.mcpServer !== undefined) {
-      throw new CliSchemaValidationError(
-        `mcpServer is only supported on the program root (not on ${node.key})`,
-      );
+      throw new CliSchemaValidationError(`mcpServer is only supported on the program root (not on ${node.key})`);
     }
     if (rogue.configure !== undefined) {
-      throw new CliSchemaValidationError(
-        `configure is only supported on the program root (not on ${node.key})`,
-      );
+      throw new CliSchemaValidationError(`configure is only supported on the program root (not on ${node.key})`);
     }
     if (rogue.docs !== undefined) {
-      throw new CliSchemaValidationError(
-        `docs is only supported on the program root (not on ${node.key})`,
-      );
+      throw new CliSchemaValidationError(`docs is only supported on the program root (not on ${node.key})`);
     }
     if (rogue.appConfig !== undefined) {
-      throw new CliSchemaValidationError(
-        `appConfig is only supported on the program root (not on ${node.key})`,
-      );
+      throw new CliSchemaValidationError(`appConfig is only supported on the program root (not on ${node.key})`);
     }
   }
 
@@ -266,20 +237,13 @@ function walkNode(node: CliNode, program: CliProgram, isRoot: boolean): void {
       throw new CliSchemaValidationError("Set outputSchema on the leaf only, not under mcpTool");
     }
     const resolved = outputSchema ?? legacyOutputSchema;
-    if (
-      resolved !== undefined &&
-      (typeof resolved !== "object" || resolved === null || Array.isArray(resolved))
-    ) {
-      throw new CliSchemaValidationError(
-        "outputSchema must be a JSON Schema object (not null or an array)",
-      );
+    if (resolved !== undefined && (typeof resolved !== "object" || resolved === null || Array.isArray(resolved))) {
+      throw new CliSchemaValidationError("outputSchema must be a JSON Schema object (not null or an array)");
     }
   } else {
     const rogue = node as unknown as CliLeaf;
     if (rogue.mcpTool !== undefined) {
-      throw new CliSchemaValidationError(
-        `mcpTool is only supported on leaf commands (not on ${node.key})`,
-      );
+      throw new CliSchemaValidationError(`mcpTool is only supported on leaf commands (not on ${node.key})`);
     }
   }
 
@@ -290,9 +254,7 @@ function walkNode(node: CliNode, program: CliProgram, isRoot: boolean): void {
     for (const uri of uris) {
       if (reserved.has(uri)) {
         const kind = uri === schemaUri ? "built-in schema resource" : "auto docs topic resource";
-        throw new CliSchemaValidationError(
-          `mcpServer.resources URI '${uri}' conflicts with ${kind}`,
-        );
+        throw new CliSchemaValidationError(`mcpServer.resources URI '${uri}' conflicts with ${kind}`);
       }
     }
     if (new Set(uris).size !== uris.length) {
@@ -316,9 +278,7 @@ function walkNode(node: CliNode, program: CliProgram, isRoot: boolean): void {
     if (node.fallbackCommand !== undefined) {
       const valid = node.commands.find((c) => c.key === node.fallbackCommand);
       if (!valid) {
-        throw new CliSchemaValidationError(
-          `fallbackCommand '${node.fallbackCommand}' is not a child of '${node.key}'`,
-        );
+        throw new CliSchemaValidationError(`fallbackCommand '${node.fallbackCommand}' is not a child of '${node.key}'`);
       }
     }
 
@@ -336,21 +296,15 @@ function validateOptions(scopeKey: string, options: import("./types.ts").CliOpti
   const seenShorts = new Set<string>();
   for (const opt of options) {
     if (opt.required && opt.kind === CliOptionKind.Presence) {
-      throw new CliSchemaValidationError(
-        `Presence option cannot be required: ${scopeKey}/${opt.name}`,
-      );
+      throw new CliSchemaValidationError(`Presence option cannot be required: ${scopeKey}/${opt.name}`);
     }
 
     if (opt.shortName !== undefined) {
       if (opt.shortName === "h") {
-        throw new CliSchemaValidationError(
-          `Short alias -h is reserved for help: ${scopeKey}/${opt.name}`,
-        );
+        throw new CliSchemaValidationError(`Short alias -h is reserved for help: ${scopeKey}/${opt.name}`);
       }
       if (seenShorts.has(opt.shortName)) {
-        throw new CliSchemaValidationError(
-          `Duplicate short alias -${opt.shortName} in scope ${scopeKey}`,
-        );
+        throw new CliSchemaValidationError(`Duplicate short alias -${opt.shortName} in scope ${scopeKey}`);
       }
       seenShorts.add(opt.shortName);
     }
@@ -362,9 +316,7 @@ function validateOptions(scopeKey: string, options: import("./types.ts").CliOpti
         );
       }
       if (new Set(opt.choices).size !== opt.choices.length) {
-        throw new CliSchemaValidationError(
-          `Option '${opt.name}' on '${scopeKey}': Enum choices must be distinct`,
-        );
+        throw new CliSchemaValidationError(`Option '${opt.name}' on '${scopeKey}': Enum choices must be distinct`);
       }
       for (const choice of opt.choices) {
         if (choice.length === 0) {
@@ -374,9 +326,7 @@ function validateOptions(scopeKey: string, options: import("./types.ts").CliOpti
         }
       }
     } else if (opt.choices !== undefined) {
-      throw new CliSchemaValidationError(
-        `Option '${opt.name}' on '${scopeKey}': choices is only valid for Enum kind`,
-      );
+      throw new CliSchemaValidationError(`Option '${opt.name}' on '${scopeKey}': choices is only valid for Enum kind`);
     }
 
     if (opt.format !== undefined || opt.pattern !== undefined || opt.default !== undefined) {
@@ -398,9 +348,7 @@ function validateOptionValueMetadata(scopeKey: string, opt: import("./types.ts")
   }
 
   if (opt.format !== undefined && opt.pattern !== undefined) {
-    throw new CliSchemaValidationError(
-      `Option ${label}: format and pattern are mutually exclusive`,
-    );
+    throw new CliSchemaValidationError(`Option ${label}: format and pattern are mutually exclusive`);
   }
 
   if (opt.format !== undefined) {
@@ -433,15 +381,10 @@ function validateOptionValueMetadata(scopeKey: string, opt: import("./types.ts")
   }
 }
 
-function validatePositionals(
-  scopeKey: string,
-  positionals: import("./types.ts").CliPositional[],
-): void {
+function validatePositionals(scopeKey: string, positionals: import("./types.ts").CliPositional[]): void {
   for (const p of positionals) {
     if (p.argMin !== undefined && p.argMin < 0) {
-      throw new CliSchemaValidationError(
-        `argMin must be >= 0 for positional ${scopeKey}/${p.name}`,
-      );
+      throw new CliSchemaValidationError(`argMin must be >= 0 for positional ${scopeKey}/${p.name}`);
     }
     if (p.argMax !== undefined && p.argMax < 0) {
       throw new CliSchemaValidationError(
@@ -450,9 +393,7 @@ function validatePositionals(
     }
     const { argMin = 1, argMax = 1 } = p;
     if (argMax > 0 && argMin > argMax) {
-      throw new CliSchemaValidationError(
-        `argMin must not exceed argMax for positional ${scopeKey}/${p.name}`,
-      );
+      throw new CliSchemaValidationError(`argMin must not exceed argMax for positional ${scopeKey}/${p.name}`);
     }
   }
 
@@ -473,9 +414,7 @@ function validatePositionals(
     }
     const { argMax = 1 } = positional;
     if (argMax === 0 && idx + 1 < positionals.length) {
-      throw new CliSchemaValidationError(
-        `Unlimited positional (argMax == 0) must be last in scope ${scopeKey}`,
-      );
+      throw new CliSchemaValidationError(`Unlimited positional (argMax == 0) must be last in scope ${scopeKey}`);
     }
   }
 }