argsbarg 5.1.8 → 5.1.10

package/src/install/target-registry.ts

@@ -7,28 +7,23 @@ export { INSTALL_TARGETS } from "./targets/index.ts";
 
 export const INSTALL_ARTIFACT_KEYS: CliInstallArtifactKey[] = INSTALL_TARGETS.map((t) => t.key);
 
-export const SKILL_KEYS: CliInstallArtifactKey[] = INSTALL_TARGETS.filter(
-  (t) => t.category === "skill",
-).map((t) => t.key);
+export const SKILL_KEYS: CliInstallArtifactKey[] = INSTALL_TARGETS.filter((t) => t.category === "skill").map(
+  (t) => t.key,
+);
 
-export const MCP_KEYS: CliInstallArtifactKey[] = INSTALL_TARGETS.filter(
-  (t) => t.category === "mcp",
-).map((t) => t.key);
+export const MCP_KEYS: CliInstallArtifactKey[] = INSTALL_TARGETS.filter((t) => t.category === "mcp").map((t) => t.key);
 
 /** Maps plan action kinds to install.targets artifact keys. */
-export const ACTION_KIND_TO_ARTIFACT: Record<InstallActionKind, CliInstallArtifactKey> =
-  Object.fromEntries(INSTALL_TARGETS.map((t) => [t.actionKind, t.key])) as Record<
-    InstallActionKind,
-    CliInstallArtifactKey
-  >;
+export const ACTION_KIND_TO_ARTIFACT: Record<InstallActionKind, CliInstallArtifactKey> = Object.fromEntries(
+  INSTALL_TARGETS.map((t) => [t.actionKind, t.key]),
+) as Record<InstallActionKind, CliInstallArtifactKey>;
 
 /** Hosts with both MCP config and shell skill install targets. */
-export const AGENT_PAIRS: [CliInstallArtifactKey, CliInstallArtifactKey][] =
-  INSTALL_TARGETS.flatMap((t) =>
-    t.category === "mcp" && t.pairedKey !== undefined
-      ? [[t.key, t.pairedKey] as [CliInstallArtifactKey, CliInstallArtifactKey]]
-      : [],
-  );
+export const AGENT_PAIRS: [CliInstallArtifactKey, CliInstallArtifactKey][] = INSTALL_TARGETS.flatMap((t) =>
+  t.category === "mcp" && t.pairedKey !== undefined
+    ? [[t.key, t.pairedKey] as [CliInstallArtifactKey, CliInstallArtifactKey]]
+    : [],
+);
 
 const targetByKey = new Map(INSTALL_TARGETS.map((t) => [t.key, t]));
 
@@ -47,10 +42,7 @@ export function isMcpArtifactKey(key: CliInstallArtifactKey): boolean {
  * Defaults: artifactDefaults in target-effective.ts.
  * Explicit spec rejection: validateConfigureConfig in validate.ts.
  */
-export function mcpServerRequiredForArtifact(
-  key: CliInstallArtifactKey,
-  mcpServerEnabled: boolean,
-): boolean {
+export function mcpServerRequiredForArtifact(key: CliInstallArtifactKey, mcpServerEnabled: boolean): boolean {
   return !isMcpArtifactKey(key) || mcpServerEnabled;
 }
 

package/src/install/target-scope.ts

@@ -1,5 +1,5 @@
 import { resolveCapabilities } from "../capabilities.ts";
-import { appConfigInstalled } from "../config/file.ts";
+import { appConfigFileExists } from "../config/file.ts";
 import type { CliConfigureTargets, CliProgram } from "../types.ts";
 import type { InstallPaths } from "./paths.ts";
 import {
@@ -46,10 +46,7 @@ function emptyInstalledArtifacts(): InstalledArtifacts {
 }
 
 /** Detects which install artifacts are currently present. */
-export function detectInstalledArtifacts(
-  paths: InstallPaths,
-  root: CliProgram,
-): InstalledArtifacts {
+export function detectInstalledArtifacts(paths: InstallPaths, root: CliProgram): InstalledArtifacts {
   const out = emptyInstalledArtifacts();
   for (const target of INSTALL_TARGETS) {
     target.applyDetected(paths, root, out);
@@ -73,14 +70,11 @@ export function buildDetectedSnapshot(root: CliProgram, paths: InstallPaths): De
   const base = detectInstalledArtifacts(paths, root);
   return {
     ...base,
-    appConfig: root.appConfig ? appConfigInstalled(root) : false,
+    appConfig: appConfigFileExists(root),
   };
 }
 
-function targetExplicitlyConfigured(
-  user: CliConfigureTargets | undefined,
-  key: CliInstallArtifactKey,
-): boolean {
+function targetExplicitlyConfigured(user: CliConfigureTargets | undefined, key: CliInstallArtifactKey): boolean {
   return user?.[key] !== undefined;
 }
 
@@ -220,10 +214,7 @@ export function buildTargetPlanContext(
 }
 
 /** Maps detected snapshot to artifact key (for tests and legacy callers). */
-export function detectedForArtifact(
-  key: CliInstallArtifactKey,
-  detected: DetectedSnapshot,
-): boolean {
+export function detectedForArtifact(key: CliInstallArtifactKey, detected: DetectedSnapshot): boolean {
   const target = installTargetForKey(key);
   if (key === "configure") {
     return detected.appConfig ?? false;
@@ -232,20 +223,12 @@ export function detectedForArtifact(
 }
 
 /** Resolved artifact keys for `--all`, `--mcp`, and `--skill` (availability-gated). */
-export function resolveInstallTargetPreview(
-  program: CliProgram,
-  paths: InstallPaths,
-): InstallTargetPreview {
+export function resolveInstallTargetPreview(program: CliProgram, paths: InstallPaths): InstallTargetPreview {
   const effective = resolveEffectiveInstallTargets(program.configure, program);
-  const integration = resolveAgentIntegration(
-    program.configure,
-    program.mcpServer?.enabled === true,
-  );
+  const integration = resolveAgentIntegration(program.configure, program.mcpServer?.enabled === true);
 
   const keysForScope = (scope: InstallScope, mode: InstallPlanMode): CliInstallArtifactKey[] =>
-    INSTALL_ARTIFACT_KEYS.filter((key) =>
-      shouldIncludeArtifact(key, program, paths, scope, mode, effective),
-    );
+    INSTALL_ARTIFACT_KEYS.filter((key) => shouldIncludeArtifact(key, program, paths, scope, mode, effective));
 
   return {
     agentIntegration: integration,

package/src/install/target-types.ts

@@ -3,12 +3,7 @@ import type { InstallPaths } from "./paths.ts";
 
 export type { InstallTargetSpec, ResolvedInstallTarget } from "../types.ts";
 
-export type InstallPlanMode =
-  | "install-all"
-  | "install-scoped"
-  | "uninstall-all"
-  | "uninstall-scoped"
-  | "refresh";
+export type InstallPlanMode = "install-all" | "install-scoped" | "uninstall-all" | "uninstall-scoped" | "refresh";
 
 export interface InstallScope {
   all?: boolean;

package/src/install/targets/app.ts

@@ -1,6 +1,6 @@
 import type { CliProgram } from "../../types.ts";
 import { isExternallyManagedBinary } from "../binary-placement.ts";
-import { displayInstallPath, type InstallPaths } from "../paths.ts";
+import type { InstallPaths } from "../paths.ts";
 import { InstallTarget } from "../target-base.ts";
 import type {
   DetectedSnapshot,
@@ -25,7 +25,7 @@ class AppInstallTarget extends InstallTarget {
     return true;
   }
 
-  isDetected(paths: InstallPaths, root: CliProgram): boolean {
+  isDetected(_paths: InstallPaths, root: CliProgram): boolean {
     return isExternallyManagedBinary(root.key) || false;
   }
 

package/src/install/targets/opencode-mcp.ts

@@ -57,12 +57,7 @@ class OpenCodeMcpInstallTarget extends InstallTarget {
 
   preflight(ctx: TargetPlanContext): string | null {
     const entry = expectedOpenCodeMcpEntry(ctx.root);
-    return checkOpenCodeMcpConflict(
-      ctx.paths.opencodeMcpPath,
-      ctx.paths.mcpName,
-      entry,
-      !!ctx.opts.yes,
-    );
+    return checkOpenCodeMcpConflict(ctx.paths.opencodeMcpPath, ctx.paths.mcpName, entry, !!ctx.opts.yes);
   }
 
   protected buildInstallActions(ctx: TargetPlanContext): InstallAction[] {

package/src/install/targets.test.ts

@@ -95,10 +95,7 @@ describe("resolveEffectiveInstallTargets", () => {
       isArtifactInScope(
         "cursorMcp",
         scope,
-        resolveEffectiveInstallTargets(
-          { targets: { cursorMcp: true }, agentIntegration: "both" },
-          program,
-        ),
+        resolveEffectiveInstallTargets({ targets: { cursorMcp: true }, agentIntegration: "both" }, program),
         "install-scoped",
         program,
       ),
@@ -117,13 +114,9 @@ describe("resolveEffectiveInstallTargets", () => {
     };
     const effective = resolveEffectiveInstallTargets(program.configure, program);
     const scope = { mcp: true, skill: true, configure: true };
-    expect(isArtifactInScope("cursorSkill", scope, effective, "install-scoped", program)).toBe(
-      true,
-    );
+    expect(isArtifactInScope("cursorSkill", scope, effective, "install-scoped", program)).toBe(true);
     expect(isArtifactInScope("cursorMcp", scope, effective, "install-scoped", program)).toBe(true);
     expect(isArtifactInScope("configure", scope, effective, "install-scoped", program)).toBe(true);
-    expect(isArtifactInScope("claudeSkill", scope, effective, "install-scoped", program)).toBe(
-      true,
-    );
+    expect(isArtifactInScope("claudeSkill", scope, effective, "install-scoped", program)).toBe(true);
   });
 });

package/src/install/uninstall.ts

@@ -8,11 +8,7 @@ import type { InstallOpts, UninstallAction } from "./target-types.ts";
 export type { InstallActionKind, InstallOpts, UninstallAction } from "./target-types.ts";
 
 /** Builds uninstall actions for scoped targets or --all (ignores install.targets on --all). */
-export function buildUninstallPlan(
-  root: CliProgram,
-  paths: InstallPaths,
-  opts: InstallOpts,
-): UninstallAction[] {
+export function buildUninstallPlan(root: CliProgram, paths: InstallPaths, opts: InstallOpts): UninstallAction[] {
   return buildUninstallPlanFromTargets(root, paths, opts);
 }
 
@@ -24,10 +20,7 @@ export function uninstallSkillDir(dir: string, dry: boolean): string[] {
 }
 
 /** Skill directory for uninstall action summary prefix. */
-export function skillDirFromUninstallSummary(
-  summary: string,
-  paths: InstallPaths,
-): string | undefined {
+export function skillDirFromUninstallSummary(summary: string, paths: InstallPaths): string | undefined {
   const target = skillTargetForUninstallSummary(summary);
   return target?.skillDir(paths);
 }

package/src/invoke.test.ts

@@ -188,9 +188,7 @@ test("ctx.positional returns undefined for absent optional slot", async () => {
       {
         key: "x",
         description: "",
-        positionals: [
-          { name: "opt", description: "", kind: CliOptionKind.String, argMin: 0, argMax: 1 },
-        ],
+        positionals: [{ name: "opt", description: "", kind: CliOptionKind.String, argMin: 0, argMax: 1 }],
         handler: (ctx: CliContext) => {
           captured = ctx.positional("opt");
         },

package/src/mcp/bundle.ts

@@ -3,15 +3,7 @@ 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 { buildProgramUserConfig } from "../config/manifest.ts";
@@ -56,10 +48,7 @@ function defaultAuthor(bundle?: CliMcpBundleConfig): {
 }
 
 /** 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,
@@ -123,9 +112,7 @@ 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-"));
@@ -164,9 +151,7 @@ export function packMcpBundle(program: CliProgram, opts: PackMcpBundleOpts = {})
 export function runMcpBundle(program: CliProgram): void {
   const mcp = program.mcpServer;
   if (!mcp?.mcpd && !mcp?.claudePlugin) {
-    throw new Error(
-      "mcp bundle: enable mcpServer.mcpd and/or mcpServer.claudePlugin on the program root.",
-    );
+    throw new Error("mcp bundle: enable mcpServer.mcpd and/or mcpServer.claudePlugin on the program root.");
   }
 
   const lines: string[] = [];

package/src/mcp/claude.test.ts

@@ -87,9 +87,9 @@ describe("claude plugin", () => {
       execSync("unzip -o -q ../out.zip", { cwd: extract });
       const binMode = statSync(join(extract, "bin", "myapp")).mode & 0o777;
       expect(binMode & 0o111).not.toBe(0);
-      const pluginJson = JSON.parse(
-        readFileSync(join(extract, ".claude-plugin", "plugin.json"), "utf8"),
-      ) as { mcpServers: string };
+      const pluginJson = JSON.parse(readFileSync(join(extract, ".claude-plugin", "plugin.json"), "utf8")) as {
+        mcpServers: string;
+      };
       expect(pluginJson.mcpServers).toBe(".mcp.json");
     } finally {
       rmSync(work, { recursive: true, force: true });

package/src/mcp/claude.ts

@@ -58,10 +58,7 @@ export function defaultClaudePluginPaths(program: CliProgram, cwd = process.cwd(
 }
 
 /** Generates `.claude-plugin/plugin.json` object. */
-export function generatePluginManifest(
-  program: CliProgram,
-  _binaryName: string,
-): Record<string, unknown> {
+export function generatePluginManifest(program: CliProgram, _binaryName: string): Record<string, unknown> {
   const bundle = program.mcpServer?.bundle;
   const manifest: Record<string, unknown> = {
     name: pluginName(program),
@@ -78,10 +75,7 @@ export function generatePluginManifest(
 }
 
 /** Generates plugin `.mcp.json` stdio server config. */
-export function generatePluginMcpJson(
-  program: CliProgram,
-  binaryName: string,
-): Record<string, unknown> {
+export function generatePluginMcpJson(program: CliProgram, binaryName: string): Record<string, unknown> {
   const mcp: Record<string, unknown> = {
     command: `\${CLAUDE_PLUGIN_ROOT}/bin/${binaryName}`,
     args: ["mcp"],
@@ -117,12 +111,7 @@ function collectZipEntries(rootDir: string, dir = rootDir): ZipFileEntry[] {
   return entries;
 }
 
-function writePluginTree(
-  pluginRoot: string,
-  program: CliProgram,
-  binaryPath: string,
-  binaryName: string,
-): void {
+function writePluginTree(pluginRoot: string, program: CliProgram, binaryPath: string, binaryName: string): void {
   const bundle = generatePluginSkillBundle(program);
   const skillMd = applyPluginSkillHint(program, bundle.skillMd);
 
@@ -155,9 +144,7 @@ export function packClaudePlugin(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(), "claude-plugin-"));

package/src/mcp/env.ts

@@ -51,9 +51,7 @@ export function bootstrapMcpEnv(config: { shellEnv?: boolean | string }): void {
       : (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

@@ -7,12 +7,7 @@ import type { Cli } from "../cli.ts";
 import { bootstrapAppConfig } from "../config/bootstrap.ts";
 import { formatMcpMissingConfigMessage, missingRequiredConfig } from "../config/resolve.ts";
 import { buildToolCallSuccess } from "./result.ts";
-import {
-  allMcpResources,
-  collectMcpTools,
-  mcpToolCallToArgv,
-  resolveMcpServerInfo,
-} from "./tools.ts";
+import { allMcpResources, collectMcpTools, mcpToolCallToArgv, resolveMcpServerInfo } from "./tools.ts";
 
 const MCP_PROTOCOL_VERSION = "2024-11-05";
 
@@ -110,10 +105,7 @@ async function handleRequestLine(cli: Cli, 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;
       }
@@ -162,8 +154,7 @@ async function handleRequestLine(cli: Cli, 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,

package/src/mcp/tools.ts

@@ -137,11 +137,7 @@ 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[] = [];
 
@@ -222,12 +218,7 @@ export function collectMcpTools(root: CliProgram): McpToolDef[] {
   /** Walks the command tree and appends leaf tools. */
   function walk(cmd: CliNode, path: string[]): void {
     if (isCliLeaf(cmd)) {
-      if (
-        cmd.key === "completion" ||
-        cmd.key === "configure" ||
-        cmd.key === "mcp" ||
-        cmd.key === "version"
-      ) {
+      if (cmd.key === "completion" || cmd.key === "configure" || cmd.key === "mcp" || cmd.key === "version") {
         return;
       }
       if (cmd.hidden || cmd.mcpTool?.enabled === false) {

package/src/mcp.integration.test.ts

@@ -7,12 +7,7 @@ import { join } from "node:path";
 import { $ } from "bun";
 import type { CliProgram } from "./index.ts";
 import { buildToolCallSuccess } from "./mcp/result.ts";
-import {
-  collectMcpTools,
-  mcpToolCallToArgv,
-  mcpToolDescription,
-  sanitizeToolSegment,
-} from "./mcp/tools.ts";
+import { collectMcpTools, mcpToolCallToArgv, mcpToolDescription, sanitizeToolSegment } from "./mcp/tools.ts";
 import { cliSchemaExport } from "./schema.ts";
 import { mcpRequest, nestedMcpFixture, testProgram } from "./test-fixtures.ts";
 import { cliValidateProgram } from "./validate.ts";
@@ -489,10 +484,9 @@ test("minimal.ts mcp without opt-in fails", async () => {
 });
 
 test("MCP resources/list includes custom resource", async () => {
-  const responses = await mcpRequest(
-    [{ jsonrpc: "2.0", id: 10, method: "resources/list", params: {} }],
-    { script: "examples/mcp-test.ts" },
-  );
+  const responses = await mcpRequest([{ jsonrpc: "2.0", id: 10, method: "resources/list", params: {} }], {
+    script: "examples/mcp-test.ts",
+  });
   const res = responses.get(10) as { result: { resources: { uri: string }[] } };
   const uris = res.result.resources.map((r) => r.uri);
   expect(uris).toContain("mcp_test://schema");

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 });