argsbarg 3.4.2 → 3.5.0

package/src/install/uninstall.ts

@@ -1,16 +1,18 @@
 import { existsSync, rmSync } from "node:fs";
-import { CliProgram } from "../types.ts";
+import type { CliProgram } from "../types.ts";
 import { uninstallBinary } from "./binary.ts";
 import { uninstallCompletions } from "./completions.ts";
 import { detectInstalledArtifacts } from "./detect-installed.ts";
+import { removeCodexMcpConfig } from "./mcp-codex.ts";
 import { removeMcpConfig } from "./mcp-config.ts";
-import { InstallPaths } from "./paths.ts";
+import { detectOpenCodeMcpConfigPath, removeOpenCodeMcpConfig } from "./mcp-opencode.ts";
+import { type InstallPaths, userHome } from "./paths.ts";
 import {
+  type InstallOpts,
   wantsInstallBin,
   wantsInstallCompletions,
   wantsInstallMcp,
   wantsInstallSkill,
-  type InstallOpts,
 } from "./plan.ts";
 
 export interface UninstallAction {
@@ -111,6 +113,38 @@ export function buildUninstallPlan(
         },
       });
     }
+    if (detected.opencodeMcp) {
+      const openCodePath =
+        detectOpenCodeMcpConfigPath(userHome(), paths.mcpName) ?? paths.opencodeMcpPath;
+      actions.push({
+        summary: `opencode mcp: ${openCodePath}`,
+        message: `Removing MCP server "${paths.mcpName}" from ${openCodePath}`,
+        run: () => {
+          removeOpenCodeMcpConfig(openCodePath, paths.mcpName, dry);
+          return [openCodePath];
+        },
+      });
+    }
+    if (detected.codexMcp) {
+      actions.push({
+        summary: `codex mcp: ${paths.codexConfigPath}`,
+        message: `Removing MCP server "${paths.mcpName}" from Codex via codex mcp remove`,
+        run: () => {
+          removeCodexMcpConfig(userHome(), paths.mcpName, dry);
+          return [paths.codexConfigPath];
+        },
+      });
+    }
+    if (detected.chatGptMcp) {
+      actions.push({
+        summary: `chatgpt desktop mcp: ${paths.chatGptMcpPath}`,
+        message: `Removing MCP server "${paths.mcpName}" from ${paths.chatGptMcpPath}`,
+        run: () => {
+          removeMcpConfig(paths.chatGptMcpPath, paths.mcpName, dry);
+          return [paths.chatGptMcpPath];
+        },
+      });
+    }
   }
 
   return actions;
@@ -120,5 +154,5 @@ export function buildUninstallPlan(
 export function uninstallSkillDir(dir: string, dry: boolean): string[] {
   if (!existsSync(dir)) return [];
   if (!dry) rmSync(dir, { recursive: true, force: true });
-  return [dir + "/"];
+  return [`${dir}/`];
 }

package/src/install/update.test.ts

@@ -1,7 +1,7 @@
-import { expect, test, beforeEach, afterEach } from "bun:test";
+import { afterEach, beforeEach, expect, test } from "bun:test";
 import { chmodSync, existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
 import { tmpdir } from "node:os";
+import { join } from "node:path";
 import { cliPresentationRoot } from "../builtins/presentation.ts";
 import { cliInvoke } from "../index.ts";
 import type { CliProgram, CliUpdateArtifact } from "../types.ts";

package/src/install/update.ts

@@ -7,7 +7,9 @@ import { installErr } from "./status.ts";
 export async function cliUpdate(root: CliProgram): Promise<never> {
   const hook = root.install?.updateGetLatest;
   if (!hook) {
-    installErr("install --update is not configured. Set install.updateGetLatest on the program root.");
+    installErr(
+      "install --update is not configured. Set install.updateGetLatest on the program root.",
+    );
     process.exit(1);
   }
 

package/src/invoke.ts

@@ -4,12 +4,12 @@ It parses argv against the user schema, captures stdout/stderr, and patches
 process.exit so MCP tool calls can run handlers repeatedly.
 */
 
-import { CliContext } from "./context.ts";
+import { format } from "node:util";
 import { builtinInterceptRoot, dispatchBuiltin } from "./builtins/dispatch.ts";
 import { cliParseRoot, cliPresentationRoot } from "./builtins/presentation.ts";
-import { parse, postParseValidate, ParseKind } from "./parse.ts";
+import { CliContext } from "./context.ts";
+import { ParseKind, parse, postParseValidate } from "./parse.ts";
 import { type CliNode, type CliProgram, type CliRouter, isCliLeaf, isCliRouter } from "./types.ts";
-import { format } from "node:util";
 
 /** Outcome of a non-exiting CLI invocation. */
 export type CliInvokeKind = "ok" | "help" | "error";
@@ -159,21 +159,24 @@ export async function cliInvoke(root: CliProgram, argv: string[]): Promise<CliIn
   }) as typeof process.stderr.write;
 
   console.log = (...args: unknown[]) => {
-    stdout += format(...args) + "\n";
+    stdout += `${format(...args)}\n`;
   };
   console.info = (...args: unknown[]) => {
-    stdout += format(...args) + "\n";
+    stdout += `${format(...args)}\n`;
   };
   console.warn = (...args: unknown[]) => {
-    stderr += format(...args) + "\n";
+    stderr += `${format(...args)}\n`;
   };
   console.error = (...args: unknown[]) => {
-    stderr += format(...args) + "\n";
+    stderr += `${format(...args)}\n`;
   };
 
   try {
     if (pr.kind === ParseKind.Ok) {
-      await dispatchBuiltin(root, pr, { isLeafCompletionIntercept, parseRoot: completionParseRoot });
+      await dispatchBuiltin(root, pr, {
+        isLeafCompletionIntercept,
+        parseRoot: completionParseRoot,
+      });
     }
 
     await Promise.resolve(handler(ctx));
@@ -191,7 +194,7 @@ export async function cliInvoke(root: CliProgram, argv: string[]): Promise<CliIn
         kind: "error",
         exitCode: 1,
         stdout,
-        stderr: err.message + "\n",
+        stderr: `${err.message}\n`,
         errorMsg: err.message,
       };
     }

package/src/mcp/bundle.ts

@@ -3,11 +3,19 @@ Packs a CLI program into an MCP Bundle (`.mcpb`) for Claude Desktop.
 Expects `dist/<program.key>` as the compiled binary input.
 */
 
-import { cpSync, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import {
+  cpSync,
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
 import { tmpdir } from "node:os";
 import { basename, join, resolve } from "node:path";
-import { collectMcpTools, mcpServerId } from "./tools.ts";
 import type { CliMcpBundleConfig, CliProgram } from "../types.ts";
+import { collectMcpTools, mcpServerId } from "./tools.ts";
 
 const MANIFEST_VERSION = "0.3";
 const DIST_DIR = "dist";
@@ -51,7 +59,11 @@ function buildUserConfig(program: CliProgram): Record<string, unknown> | undefin
   }
   const out: Record<string, unknown> = {};
   for (const name of envVars) {
-    const key = name.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_|_$/g, "") || "env_var";
+    const key =
+      name
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "_")
+        .replace(/^_|_$/g, "") || "env_var";
     out[key] = {
       type: "string",
       title: name,
@@ -64,12 +76,19 @@ function buildUserConfig(program: CliProgram): Record<string, unknown> | undefin
 }
 
 /** Default author when `mcpServer.bundle.author` is unset. */
-function defaultAuthor(bundle?: CliMcpBundleConfig): { name: string; email?: string; url?: string } {
+function defaultAuthor(bundle?: CliMcpBundleConfig): {
+  name: string;
+  email?: string;
+  url?: string;
+} {
   return bundle?.author ?? { name: "Unknown" };
 }
 
 /** Generates MCPB `manifest.json` object from program schema and MCP tools. */
-export function generateMcpManifest(program: CliProgram, binaryName: string): Record<string, unknown> {
+export function generateMcpManifest(
+  program: CliProgram,
+  binaryName: string,
+): Record<string, unknown> {
   const bundle = program.mcpServer?.bundle;
   const tools = collectMcpTools(program).map((t) => ({
     name: t.name,
@@ -119,7 +138,11 @@ export function generateMcpManifest(program: CliProgram, binaryName: string): Re
 function crc32(data: Buffer): number {
   let crc = 0xffffffff;
   for (let i = 0; i < data.length; i++) {
-    crc ^= data[i]!;
+    const byte = data[i];
+    if (byte === undefined) {
+      continue;
+    }
+    crc ^= byte;
     for (let j = 0; j < 8; j++) {
       crc = (crc >>> 1) ^ (crc & 1 ? 0xedb88320 : 0);
     }
@@ -208,7 +231,9 @@ export function packMcpBundle(program: CliProgram, opts: PackMcpBundleOpts = {})
   const binaryName = basename(binaryPath);
 
   if (!existsSync(binaryPath)) {
-    throw new Error(`Binary not found: ${binaryPath}. Build with compile first (expected dist/${program.key}).`);
+    throw new Error(
+      `Binary not found: ${binaryPath}. Build with compile first (expected dist/${program.key}).`,
+    );
   }
 
   const staging = mkdtempSync(join(tmpdir(), "mcpb-"));
@@ -218,7 +243,10 @@ export function packMcpBundle(program: CliProgram, opts: PackMcpBundleOpts = {})
 
     const manifest = generateMcpManifest(program, binaryName);
     const files: { name: string; data: Buffer }[] = [
-      { name: "manifest.json", data: Buffer.from(`${JSON.stringify(manifest, null, 2)}\n`, "utf8") },
+      {
+        name: "manifest.json",
+        data: Buffer.from(`${JSON.stringify(manifest, null, 2)}\n`, "utf8"),
+      },
       { name: binaryName, data: readFileSync(stagedBinary) },
     ];
 

package/src/mcp/env.ts

@@ -2,8 +2,8 @@
 This module bootstraps process.env for MCP servers from login shell and .env files.
 */
 
-import { readFileSync } from "node:fs";
 import { spawnSync } from "node:child_process";
+import { readFileSync } from "node:fs";
 
 /** Parses `env` stdout from a login shell into a key/value map. */
 export function captureShellEnv(shell: string): Record<string, string> {
@@ -42,9 +42,7 @@ export function applyShellEnv(env: Record<string, string>): void {
 
 /** Loads a .env file into process.env (always overwrites). Warns on stderr if missing. */
 export function loadEnvFile(envFile: string): void {
-  const resolved = envFile.startsWith("~")
-    ? envFile.replace("~", process.env.HOME ?? "")
-    : envFile;
+  const resolved = envFile.startsWith("~") ? envFile.replace("~", process.env.HOME ?? "") : envFile;
   let text: string;
   try {
     text = readFileSync(resolved, "utf8");
@@ -63,10 +61,7 @@ export function loadEnvFile(envFile: string): void {
     }
     const key = trimmed.slice(0, eq).trim();
     let val = trimmed.slice(eq + 1).trim();
-    if (
-      (val.startsWith('"') && val.endsWith('"')) ||
-      (val.startsWith("'") && val.endsWith("'"))
-    ) {
+    if ((val.startsWith('"') && val.endsWith('"')) || (val.startsWith("'") && val.endsWith("'"))) {
       val = val.slice(1, -1);
     }
     if (key) {
@@ -76,10 +71,7 @@ export function loadEnvFile(envFile: string): void {
 }
 
 /** Applies mcpServer shellEnv and envFile bootstrap in order. */
-export function bootstrapMcpEnv(config: {
-  shellEnv?: boolean | string;
-  envFile?: string;
-}): void {
+export function bootstrapMcpEnv(config: { shellEnv?: boolean | string; envFile?: string }): void {
   const shellEnvCfg = config.shellEnv;
   if (shellEnvCfg) {
     const shell =
@@ -88,7 +80,9 @@ export function bootstrapMcpEnv(config: {
         : (process.env.SHELL ?? (process.platform === "darwin" ? "/bin/zsh" : "/bin/bash"));
     const captured = captureShellEnv(shell);
     if (Object.keys(captured).length === 0) {
-      process.stderr.write(`[argsbarg] shellEnv: failed to capture shell environment from ${shell}\n`);
+      process.stderr.write(
+        `[argsbarg] shellEnv: failed to capture shell environment from ${shell}\n`,
+      );
     } else {
       applyShellEnv(captured);
     }

package/src/mcp/server.ts

@@ -4,7 +4,7 @@ resources, and ping. Responses are newline-delimited JSON on stdout only.
 */
 
 import { cliInvoke } from "../invoke.ts";
-import { CliProgram } from "../types.ts";
+import type { CliProgram } from "../types.ts";
 import { buildToolCallSuccess } from "./result.ts";
 import {
   allMcpResources,
@@ -25,7 +25,7 @@ interface JsonRpcRequest {
 
 /** Writes a JSON-RPC response line to stdout. */
 function writeResponse(msg: Record<string, unknown>): void {
-  process.stdout.write(JSON.stringify(msg) + "\n");
+  process.stdout.write(`${JSON.stringify(msg)}\n`);
 }
 
 /** Writes a JSON-RPC error response. */
@@ -108,7 +108,10 @@ async function handleRequestLine(root: CliProgram, line: string): Promise<void>
         return;
       }
       const rawArgs = params.arguments;
-      if (rawArgs !== undefined && (typeof rawArgs !== "object" || rawArgs === null || Array.isArray(rawArgs))) {
+      if (
+        rawArgs !== undefined &&
+        (typeof rawArgs !== "object" || rawArgs === null || Array.isArray(rawArgs))
+      ) {
         writeError(id, -32602, "Invalid params: arguments must be an object");
         return;
       }
@@ -151,7 +154,8 @@ async function handleRequestLine(root: CliProgram, line: string): Promise<void>
         });
         return;
       }
-      const errText = invokeResult.stderr.trim() || invokeResult.errorMsg || `Exit code ${invokeResult.exitCode}`;
+      const errText =
+        invokeResult.stderr.trim() || invokeResult.errorMsg || `Exit code ${invokeResult.exitCode}`;
       writeResponse({
         jsonrpc: "2.0",
         id,
@@ -222,14 +226,16 @@ export async function mcpServeStdioLoop(root: CliProgram): Promise<void> {
   let buffer = "";
   for await (const chunk of Bun.stdin.stream()) {
     buffer += new TextDecoder().decode(chunk);
-    let nl: number;
-    while ((nl = buffer.indexOf("\n")) !== -1) {
+    let nl = buffer.indexOf("\n");
+    while (nl !== -1) {
       const line = buffer.slice(0, nl).trim();
       buffer = buffer.slice(nl + 1);
       if (line.length === 0) {
+        nl = buffer.indexOf("\n");
         continue;
       }
       await handleRequestLine(root, line);
+      nl = buffer.indexOf("\n");
     }
   }
   const trailing = buffer.trim();

package/src/mcp/tools.ts

@@ -4,10 +4,19 @@ flat JSON tool arguments into argv for cliInvoke.
 */
 
 import { cliResolveNotes } from "../help.ts";
-import { collectOptionDefs } from "../parse.ts";
 import { visibleOptions } from "../hidden.ts";
+import { collectOptionDefs } from "../parse.ts";
 import { cliSchemaJson } from "../schema.ts";
-import { CliProgram, CliLeaf, CliNode, CliOption, CliOptionKind, CliPositional, isCliLeaf, isCliRouter, leafOutputSchema } from "../types.ts";
+import {
+  type CliLeaf,
+  type CliNode,
+  type CliOption,
+  CliOptionKind,
+  type CliPositional,
+  type CliProgram,
+  isCliLeaf,
+  leafOutputSchema,
+} from "../types.ts";
 
 /** Default URI pattern for the CLI schema MCP resource (`<mcpId>://schema`). */
 export function defaultMcpSchemaUri(mcpId: string): string {
@@ -80,7 +89,11 @@ function positionalProperty(p: CliPositional): Record<string, unknown> {
 }
 
 /** Builds inputSchema for a leaf command. */
-function buildInputSchema(root: CliProgram, path: string[], leaf: CliLeaf): Record<string, unknown> {
+function buildInputSchema(
+  root: CliProgram,
+  path: string[],
+  leaf: CliLeaf,
+): Record<string, unknown> {
   const properties: Record<string, unknown> = {};
   const required: string[] = [];
 
@@ -252,7 +265,10 @@ export function mcpToolCallToArgv(
         items = raw.map(String);
       } else if (typeof raw === "string") {
         items = raw.includes(",")
-          ? raw.split(",").map((s) => s.trim()).filter(Boolean)
+          ? raw
+              .split(",")
+              .map((s) => s.trim())
+              .filter(Boolean)
           : raw.trim()
             ? [raw.trim()]
             : [];

package/src/mcp.ts

@@ -2,9 +2,9 @@
 This module starts the ArgsBarg MCP stdio server for opt-in program roots.
 */
 
-import { mcpServeStdioLoop } from "./mcp/server.ts";
 import { bootstrapMcpEnv } from "./mcp/env.ts";
-import { CliProgram } from "./types.ts";
+import { mcpServeStdioLoop } from "./mcp/server.ts";
+import type { CliProgram } from "./types.ts";
 
 /**
  * Runs the MCP JSON-RPC server on stdin/stdout until stdin closes, then exits.
@@ -19,7 +19,7 @@ export async function cliMcpServeStdio(root: CliProgram): Promise<never> {
     process.exit(0);
   } catch (err) {
     if (err instanceof Error) {
-      process.stderr.write(err.message + "\n");
+      process.stderr.write(`${err.message}\n`);
     } else {
       process.stderr.write("MCP server error.\n");
     }

package/src/parse.ts

@@ -7,12 +7,11 @@ It keeps handler dispatch and help on one parser so the CLI behavior stays consi
 across every entry path.
 */
 
-import { CliContext } from "./context.ts";
 import {
-  type CliLeaf,
-  CliNode,
   CliFallbackMode,
-  CliOption,
+  type CliLeaf,
+  type CliNode,
+  type CliOption,
   CliOptionKind,
   isCliLeaf,
   isCliRouter,
@@ -191,17 +190,30 @@ function consumeOptions(
 
     if (tok === "--") {
       idx += 1;
-      return { report: { err: null, stoppedOnUnknown: false, sawDoubleDash: true }, nextIndex: idx };
+      return {
+        report: { err: null, stoppedOnUnknown: false, sawDoubleDash: true },
+        nextIndex: idx,
+      };
     }
 
     if (tok.startsWith("--")) {
       const err = consumeLong(tok);
-      if (err === "") return { 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: null, stoppedOnUnknown: true, sawDoubleDash: false },
+          nextIndex: idx,
+        };
+      if (err)
+        return { report: { err, stoppedOnUnknown: false, sawDoubleDash: false }, nextIndex: idx };
     } else {
       const err = consumeShort(tok);
-      if (err === "") return { 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: null, stoppedOnUnknown: true, sawDoubleDash: false },
+          nextIndex: idx,
+        };
+      if (err)
+        return { report: { err, stoppedOnUnknown: false, sawDoubleDash: false }, nextIndex: idx };
     }
   }
 
@@ -212,7 +224,7 @@ function consumeOptions(
 
 /** Merges option defs from the program root along the routed command path. */
 export function collectOptionDefs(root: CliNode, path: string[]): CliOption[] {
-  let defs = [...(root.options ?? [])];
+  const defs = [...(root.options ?? [])];
   let node: CliNode = root;
 
   for (const seg of path) {
@@ -343,7 +355,16 @@ function finishLeaf(
     }
   }
 
-  return { kind: ParseKind.Ok, path, opts, args, helpExplicit: false, helpPath: [], errorMsg: "", errorHelpPath: [] };
+  return {
+    kind: ParseKind.Ok,
+    path,
+    opts,
+    args,
+    helpExplicit: false,
+    helpPath: [],
+    errorMsg: "",
+    errorHelpPath: [],
+  };
 }
 
 // ── Main Parser ───────────────────────────────────────────────────────────────
@@ -414,7 +435,16 @@ export function parse(root: CliNode, argv: string[]): ParseResult {
       cmdName = root.fallbackCommand;
       node = findChild(root.commands, cmdName);
       if (!node) {
-        return { kind: ParseKind.Error, path: [], opts: {}, args: [], helpExplicit: false, helpPath: [], errorMsg: `Unknown command: ${cmdName}`, errorHelpPath: path };
+        return {
+          kind: ParseKind.Error,
+          path: [],
+          opts: {},
+          args: [],
+          helpExplicit: false,
+          helpPath: [],
+          errorMsg: `Unknown command: ${cmdName}`,
+          errorHelpPath: path,
+        };
       }
     } else {
       return helpResult([], false);
@@ -428,16 +458,26 @@ export function parse(root: CliNode, argv: string[]): ParseResult {
       i += 1;
       node = childPick;
     } else {
+      const fallbackCommand = root.fallbackCommand;
       const canRouteUnknown =
-        root.fallbackCommand !== undefined &&
+        fallbackCommand !== undefined &&
         ((root.fallbackMode ?? CliFallbackMode.MissingOnly) === CliFallbackMode.MissingOrUnknown ||
           (root.fallbackMode ?? CliFallbackMode.MissingOnly) === CliFallbackMode.UnknownOnly);
 
       if (canRouteUnknown) {
-        cmdName = root.fallbackCommand!;
+        cmdName = fallbackCommand;
         node = findChild(root.commands, cmdName);
         if (!node) {
-          return { kind: ParseKind.Error, path: [], opts: {}, args: [], helpExplicit: false, helpPath: [], errorMsg: `Unknown command: ${cmdName}`, errorHelpPath: path };
+          return {
+            kind: ParseKind.Error,
+            path: [],
+            opts: {},
+            args: [],
+            helpExplicit: false,
+            helpPath: [],
+            errorMsg: `Unknown command: ${cmdName}`,
+            errorHelpPath: path,
+          };
         }
       } else {
         cmdName = peek;
@@ -451,7 +491,9 @@ export function parse(root: CliNode, argv: string[]): ParseResult {
             args: [],
             helpExplicit: false,
             helpPath: [],
-            errorMsg: forcePositionals ? `Expected subcommand but got positional: ${cmdName}` : `Unknown command: ${cmdName}`,
+            errorMsg: forcePositionals
+              ? `Expected subcommand but got positional: ${cmdName}`
+              : `Unknown command: ${cmdName}`,
             errorHelpPath: path,
           };
         }
@@ -460,7 +502,19 @@ export function parse(root: CliNode, argv: string[]): ParseResult {
   }
 
   path.push(cmdName);
-  let current = node!;
+  if (!node) {
+    return {
+      kind: ParseKind.Error,
+      path,
+      opts: {},
+      args: [],
+      helpExplicit: false,
+      helpPath: [],
+      errorMsg: `Unknown command: ${cmdName}`,
+      errorHelpPath: path,
+    };
+  }
+  let current = node;
 
   // Walk the command tree
   while (true) {
@@ -508,7 +562,15 @@ 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];
@@ -542,10 +604,10 @@ export function parse(root: CliNode, argv: string[]): ParseResult {
         fb !== undefined &&
         (fm === CliFallbackMode.MissingOrUnknown || fm === CliFallbackMode.UnknownOnly);
 
-      if (canRouteUnknown) {
-        const fbNode = findChild(current.commands, fb!);
+      if (canRouteUnknown && fb !== undefined) {
+        const fbNode = findChild(current.commands, fb);
         if (fbNode) {
-          path.push(fb!);
+          path.push(fb);
           current = fbNode;
           continue;
         }
@@ -558,7 +620,9 @@ export function parse(root: CliNode, argv: string[]): ParseResult {
         args: [],
         helpExplicit: false,
         helpPath: [],
-        errorMsg: forcePositionals ? `Expected subcommand but got positional: ${tok}` : `Unknown subcommand: ${tok}`,
+        errorMsg: forcePositionals
+          ? `Expected subcommand but got positional: ${tok}`
+          : `Unknown subcommand: ${tok}`,
         errorHelpPath: path,
       };
     }
@@ -566,7 +630,15 @@ 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,
+    );
   }
 }
 
@@ -578,7 +650,7 @@ export function parse(root: CliNode, argv: string[]): ParseResult {
 export function postParseValidate(root: CliNode, pr: ParseResult): ParseResult {
   if (pr.kind !== ParseKind.Ok) return pr;
 
-  let defs = [...(root.options ?? [])];
+  const defs = [...(root.options ?? [])];
   let node: CliNode = root;
 
   for (const seg of pr.path) {