argsbarg 5.1.7 → 5.1.9

package/src/install/target-base.ts

@@ -46,11 +46,7 @@ export abstract class InstallTarget {
 
   protected abstract isDetectedFromSnapshot(detected: DetectedSnapshot): boolean;
 
-  statusLine(
-    paths: InstallPaths,
-    root: CliProgram,
-    detected: InstalledArtifacts,
-  ): string | undefined {
+  statusLine(paths: InstallPaths, root: CliProgram, detected: InstalledArtifacts): string | undefined {
     if (!this.isDetectedFromInstalled(detected)) return undefined;
     return this.formatStatusLine(paths, root);
   }
@@ -78,12 +74,7 @@ export abstract class InstallTarget {
 
   protected abstract buildUninstallActions(ctx: TargetPlanContext): UninstallAction[];
 
-  contributeStatus(
-    paths: InstallPaths,
-    root: CliProgram,
-    detected: InstalledArtifacts,
-    status: InstallStatus,
-  ): void {
+  contributeStatus(paths: InstallPaths, root: CliProgram, detected: InstalledArtifacts, status: InstallStatus): void {
     const line = this.statusLine(paths, root, detected);
     if (!line) return;
     this.assignStatusLine(status, line);

package/src/install/target-detect.ts

@@ -7,11 +7,7 @@ export { buildDetectedSnapshot, detectInstalledArtifacts } from "./target-scope.
 export type { InstalledArtifacts, InstallStatus } from "./target-types.ts";
 
 /** Builds a status inventory from detected artifacts. */
-export function buildInstallStatus(
-  paths: InstallPaths,
-  detected: InstalledArtifacts,
-  root: CliProgram,
-): InstallStatus {
+export function buildInstallStatus(paths: InstallPaths, detected: InstalledArtifacts, root: CliProgram): InstallStatus {
   const status: InstallStatus = {};
   for (const target of INSTALL_TARGETS) {
     target.contributeStatus(paths, root, detected, status);

package/src/install/target-effective.ts

@@ -19,10 +19,7 @@ export type { InstallTargetSpec, ResolvedInstallTarget } from "../types.ts";
 
 export type { InstallPlanMode, InstallScope } from "./target-types.ts";
 
-export function resolveAgentIntegration(
-  configure?: CliConfigureConfig,
-  mcpEnabled = false,
-): InstallAgentIntegration {
+export function resolveAgentIntegration(configure?: CliConfigureConfig, mcpEnabled = false): InstallAgentIntegration {
   return configure?.agentIntegration ?? (mcpEnabled ? "mcp" : "skill");
 }
 
@@ -95,10 +92,7 @@ export function resolveEffectiveInstallTargets(
   const user = configure?.targets;
   const out = {} as Record<CliInstallArtifactKey, { enabled: boolean; includedInAll: boolean }>;
   for (const key of INSTALL_ARTIFACT_KEYS) {
-    out[key] = resolveInstallTargetSpec(
-      user?.[key],
-      artifactDefaults(key, integration, mcpEnabled),
-    );
+    out[key] = resolveInstallTargetSpec(user?.[key], artifactDefaults(key, integration, mcpEnabled));
   }
   applyAgentPairDedupe(out, user, integration);
   return out;
@@ -132,10 +126,6 @@ export function resolveInstallPlanMode(opts: {
 }
 
 /** @deprecated Use target registry. */
-export function isInstallTargetAvailable(
-  key: CliInstallArtifactKey,
-  root: CliProgram,
-  paths: InstallPaths,
-): boolean {
+export function isInstallTargetAvailable(key: CliInstallArtifactKey, root: CliProgram, paths: InstallPaths): boolean {
   return installTargetForKey(key)?.isAvailable(root, paths) ?? false;
 }

package/src/install/target-mcp-cli.ts

@@ -1,10 +1,5 @@
 import type { CliProgram } from "../types.ts";
-import {
-  checkCodexMcpConflict,
-  codexMcpHasServer,
-  mergeCodexMcpConfig,
-  removeCodexMcpConfig,
-} from "./mcp-codex.ts";
+import { checkCodexMcpConflict, codexMcpHasServer, mergeCodexMcpConfig, removeCodexMcpConfig } from "./mcp-codex.ts";
 import { expectedMcpEntry } from "./mcp-config.ts";
 import {
   checkOpenclawMcpConflict,
@@ -37,20 +32,9 @@ export interface McpCliHostSpec {
   hasServer: (home: string, name: string) => boolean;
   installMessage: string;
   uninstallMessage: string;
-  merge: (
-    home: string,
-    name: string,
-    entry: ReturnType<typeof expectedMcpEntry>,
-    dry: boolean,
-    yes: boolean,
-  ) => string;
+  merge: (home: string, name: string, entry: ReturnType<typeof expectedMcpEntry>, dry: boolean, yes: boolean) => string;
   remove: (home: string, name: string, dry: boolean) => void;
-  preflight: (
-    home: string,
-    name: string,
-    entry: ReturnType<typeof expectedMcpEntry>,
-    yes: boolean,
-  ) => string | null;
+  preflight: (home: string, name: string, entry: ReturnType<typeof expectedMcpEntry>, yes: boolean) => string | null;
 }
 
 /** MCP host registered via an external CLI (codex, openclaw). */
@@ -108,13 +92,7 @@ export class McpCliInstallTarget extends InstallTarget {
         summary: `${this.spec.label}: ${displayInstallPath(configPath)}`,
         message: this.spec.installMessage.replace("{name}", ctx.paths.mcpName),
         run: () => {
-          const written = this.spec.merge(
-            userHome(),
-            ctx.paths.mcpName,
-            entry,
-            ctx.dry,
-            !!ctx.opts.yes,
-          );
+          const written = this.spec.merge(userHome(), ctx.paths.mcpName, entry, ctx.dry, !!ctx.opts.yes);
           return [written];
         },
       },

package/src/install/target-mcp-json.ts

@@ -25,14 +25,8 @@ export interface McpJsonHostSpec {
   label: string;
   pairedSkillKey?: CliInstallArtifactKey;
   configPath: (paths: InstallPaths) => string;
-  detectedKey: keyof Pick<
-    InstalledArtifacts,
-    "cursorMcp" | "claudeMcp" | "claudeDesktopMcp" | "chatGptMcp"
-  >;
-  statusField: keyof Pick<
-    InstallStatus,
-    "cursorMcp" | "claudeMcp" | "claudeDesktopMcp" | "chatGptMcp"
-  >;
+  detectedKey: keyof Pick<InstalledArtifacts, "cursorMcp" | "claudeMcp" | "claudeDesktopMcp" | "chatGptMcp">;
+  statusField: keyof Pick<InstallStatus, "cursorMcp" | "claudeMcp" | "claudeDesktopMcp" | "chatGptMcp">;
   isAvailable: (root: CliProgram, paths: InstallPaths) => boolean;
   /** Append server name to status line (default false). */
   statusIncludesServer?: boolean;
@@ -89,12 +83,7 @@ export class McpJsonInstallTarget extends InstallTarget {
 
   preflight(ctx: TargetPlanContext): string | null {
     const entry = expectedMcpEntry(ctx.root);
-    return checkMcpConflict(
-      this.spec.configPath(ctx.paths),
-      ctx.paths.mcpName,
-      entry,
-      !!ctx.opts.yes,
-    );
+    return checkMcpConflict(this.spec.configPath(ctx.paths), ctx.paths.mcpName, entry, !!ctx.opts.yes);
   }
 
   protected buildInstallActions(ctx: TargetPlanContext): InstallAction[] {

package/src/install/target-plan-build.ts

@@ -7,11 +7,7 @@ import { buildDetectedSnapshot, buildTargetPlanContext } from "./target-scope.ts
 import type { InstallAction, InstallOpts, UninstallAction } from "./target-types.ts";
 
 /** Builds install actions for normal mode (--all / scoped targets). */
-export function buildInstallPlanFromTargets(
-  root: CliProgram,
-  paths: InstallPaths,
-  opts: InstallOpts,
-): InstallAction[] {
+export function buildInstallPlanFromTargets(root: CliProgram, paths: InstallPaths, opts: InstallOpts): InstallAction[] {
   const detected = buildDetectedSnapshot(root, paths);
   const ctx = buildTargetPlanContext(root, paths, opts, detected);
 

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