claudeup 6.2.1 → 6.3.2

package/src/__tests__/plugin-manager-fallback.test.ts

@@ -1,18 +1,25 @@
-import { describe, it, expect, beforeEach, afterAll, beforeAll } from "bun:test";
+import {
+	afterAll,
+	beforeAll,
+	beforeEach,
+	describe,
+	expect,
+	it,
+} from "bun:test";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import {
-  clearMarketplaceCache,
-  fetchMarketplacePlugins,
-  getMarketplaceFetchFailures,
-  resolveMarketplacePlugins,
-} from "../services/marketplace-fetcher";
 import { resetGitHubBudget } from "../services/github-budget";
 import type {
-  LocalMarketplace,
-  LocalMarketplacePlugin,
+	LocalMarketplace,
+	LocalMarketplacePlugin,
 } from "../services/local-marketplace";
+import {
+	clearMarketplaceCache,
+	fetchMarketplacePlugins,
+	getMarketplaceFetchFailures,
+	resolveMarketplacePlugins,
+} from "../services/marketplace-fetcher";
 
 /**
  * Point the marketplace-clone lookup at an EMPTY temp directory.
@@ -27,15 +34,16 @@ let prevConfigDir: string | undefined;
 let emptyConfigDir: string;
 
 beforeAll(() => {
-  emptyConfigDir = fs.mkdtempSync(path.join(os.tmpdir(), "mp-fallback-"));
-  prevConfigDir = process.env.CLAUDE_CONFIG_DIR;
-  process.env.CLAUDE_CONFIG_DIR = emptyConfigDir;
+	emptyConfigDir = fs.mkdtempSync(path.join(os.tmpdir(), "mp-fallback-"));
+	prevConfigDir = process.env.CLAUDE_CONFIG_DIR;
+	process.env.CLAUDE_CONFIG_DIR = emptyConfigDir;
 });
 
 afterAll(() => {
-  if (prevConfigDir === undefined) delete process.env.CLAUDE_CONFIG_DIR;
-  else process.env.CLAUDE_CONFIG_DIR = prevConfigDir;
-  fs.rmSync(emptyConfigDir, { recursive: true, force: true });
+	// biome-ignore lint/performance/noDelete: assigning undefined to process.env stores the string "undefined"; only delete unsets the variable
+	if (prevConfigDir === undefined) delete process.env.CLAUDE_CONFIG_DIR;
+	else process.env.CLAUDE_CONFIG_DIR = prevConfigDir;
+	fs.rmSync(emptyConfigDir, { recursive: true, force: true });
 });
 
 /**
@@ -52,136 +60,136 @@ afterAll(() => {
  */
 
 function buildLocalMarketplace(
-  name: string,
-  plugins: LocalMarketplacePlugin[],
+	name: string,
+	plugins: LocalMarketplacePlugin[],
 ): LocalMarketplace {
-  return { name, description: "", plugins };
+	return { name, description: "", plugins };
 }
 
 describe("resolveMarketplacePlugins — offline fallback", () => {
-  beforeEach(() => {
-    // Session-level cache could otherwise carry over a previous test's
-    // successful fetch and short-circuit the fallback path.
-    clearMarketplaceCache();
-    // The per-host cooldown is deliberately NOT cleared by clearMarketplaceCache
-    // — it reflects GitHub's state, not ours — so a 429 in one test would
-    // otherwise gate every fetch in the next for the full backoff.
-    resetGitHubBudget();
-  });
+	beforeEach(() => {
+		// Session-level cache could otherwise carry over a previous test's
+		// successful fetch and short-circuit the fallback path.
+		clearMarketplaceCache();
+		// The per-host cooldown is deliberately NOT cleared by clearMarketplaceCache
+		// — it reflects GitHub's state, not ours — so a 429 in one test would
+		// otherwise gate every fetch in the next for the full backoff.
+		resetGitHubBudget();
+	});
 
-  it("falls back to the local cache when the remote fetch returns empty", async () => {
-    const local = new Map<string, LocalMarketplace>([
-      [
-        "magus",
-        buildLocalMarketplace("magus", [
-          {
-            name: "code-analysis",
-            version: "5.3.0",
-            description: "Codebase investigation tools",
-            category: "development",
-            author: { name: "Jack Rudenko" },
-          },
-          {
-            name: "dev",
-            version: "2.7.0",
-            description: "Dev workflow",
-          },
-        ]),
-      ],
-    ]);
+	it("falls back to the local cache when the remote fetch returns empty", async () => {
+		const local = new Map<string, LocalMarketplace>([
+			[
+				"magus",
+				buildLocalMarketplace("magus", [
+					{
+						name: "code-analysis",
+						version: "5.3.0",
+						description: "Codebase investigation tools",
+						category: "development",
+						author: { name: "Jack Rudenko" },
+					},
+					{
+						name: "dev",
+						version: "2.7.0",
+						description: "Dev workflow",
+					},
+				]),
+			],
+		]);
 
-    // An invalid repo string short-circuits `fetchMarketplacePlugins` to
-    // `[]` without any network call, simulating the offline case.
-    const resolved = await resolveMarketplacePlugins(
-      "magus",
-      "not a valid repo string",
-      local,
-    );
+		// An invalid repo string short-circuits `fetchMarketplacePlugins` to
+		// `[]` without any network call, simulating the offline case.
+		const resolved = await resolveMarketplacePlugins(
+			"magus",
+			"not a valid repo string",
+			local,
+		);
 
-    expect(resolved.plugins).toHaveLength(2);
-    expect(resolved.plugins.map((p) => p.name).sort()).toEqual([
-      "code-analysis",
-      "dev",
-    ]);
-    const codeAnalysis = resolved.plugins.find(
-      (p) => p.name === "code-analysis",
-    );
-    expect(codeAnalysis?.version).toBe("5.3.0");
-    expect(codeAnalysis?.description).toBe("Codebase investigation tools");
-    expect(codeAnalysis?.category).toBe("development");
-    expect(codeAnalysis?.author?.name).toBe("Jack Rudenko");
-  });
+		expect(resolved.plugins).toHaveLength(2);
+		expect(resolved.plugins.map((p) => p.name).sort()).toEqual([
+			"code-analysis",
+			"dev",
+		]);
+		const codeAnalysis = resolved.plugins.find(
+			(p) => p.name === "code-analysis",
+		);
+		expect(codeAnalysis?.version).toBe("5.3.0");
+		expect(codeAnalysis?.description).toBe("Codebase investigation tools");
+		expect(codeAnalysis?.category).toBe("development");
+		expect(codeAnalysis?.author?.name).toBe("Jack Rudenko");
+	});
 
-  it("labels the fallback answer as local-clone, not remote", async () => {
-    // The regression this guards: the fallback plugins were returned in the
-    // same shape as a successful remote fetch, so the caller compared installed
-    // versions against a clone nothing refreshes and reported "up to date".
-    // The source must travel with the data.
-    const local = new Map<string, LocalMarketplace>([
-      [
-        "magus",
-        buildLocalMarketplace("magus", [
-          { name: "terminal", version: "4.1.4", description: "" },
-        ]),
-      ],
-    ]);
-    const resolved = await resolveMarketplacePlugins(
-      "magus",
-      "not a valid repo string",
-      local,
-    );
+	it("labels the fallback answer as local-clone, not remote", async () => {
+		// The regression this guards: the fallback plugins were returned in the
+		// same shape as a successful remote fetch, so the caller compared installed
+		// versions against a clone nothing refreshes and reported "up to date".
+		// The source must travel with the data.
+		const local = new Map<string, LocalMarketplace>([
+			[
+				"magus",
+				buildLocalMarketplace("magus", [
+					{ name: "terminal", version: "4.1.4", description: "" },
+				]),
+			],
+		]);
+		const resolved = await resolveMarketplacePlugins(
+			"magus",
+			"not a valid repo string",
+			local,
+		);
 
-    expect(resolved.source).toBe("local-clone");
-    expect(resolved.failure).toBeDefined();
-    expect(resolved.failure?.kind).toBe("invalid-repo");
-    expect(resolved.failure?.marketplace).toBe("magus");
-  });
+		expect(resolved.source).toBe("local-clone");
+		expect(resolved.failure).toBeDefined();
+		expect(resolved.failure?.kind).toBe("invalid-repo");
+		expect(resolved.failure?.marketplace).toBe("magus");
+	});
 
-  it("returns empty when both remote and cache are empty", async () => {
-    const local = new Map<string, LocalMarketplace>();
-    const resolved = await resolveMarketplacePlugins(
-      "magus",
-      "not a valid repo string",
-      local,
-    );
-    expect(resolved.plugins).toEqual([]);
-    expect(resolved.source).toBe("none");
-    expect(resolved.failure).toBeDefined();
-  });
+	it("returns empty when both remote and cache are empty", async () => {
+		const local = new Map<string, LocalMarketplace>();
+		const resolved = await resolveMarketplacePlugins(
+			"magus",
+			"not a valid repo string",
+			local,
+		);
+		expect(resolved.plugins).toEqual([]);
+		expect(resolved.source).toBe("none");
+		expect(resolved.failure).toBeDefined();
+	});
 
-  it("returns empty when remote fails AND cache exists but has no plugins", async () => {
-    const local = new Map<string, LocalMarketplace>([
-      ["magus", buildLocalMarketplace("magus", [])],
-    ]);
-    const resolved = await resolveMarketplacePlugins(
-      "magus",
-      "not a valid repo string",
-      local,
-    );
-    expect(resolved.plugins).toEqual([]);
-    expect(resolved.source).toBe("none");
-  });
+	it("returns empty when remote fails AND cache exists but has no plugins", async () => {
+		const local = new Map<string, LocalMarketplace>([
+			["magus", buildLocalMarketplace("magus", [])],
+		]);
+		const resolved = await resolveMarketplacePlugins(
+			"magus",
+			"not a valid repo string",
+			local,
+		);
+		expect(resolved.plugins).toEqual([]);
+		expect(resolved.source).toBe("none");
+	});
 
-  it("does not consult the cache when the remote returns plugins", async () => {
-    // We can't easily exercise the success branch without a live network,
-    // but we can verify that a cache entry for a DIFFERENT marketplace
-    // doesn't bleed into the requested one.
-    const local = new Map<string, LocalMarketplace>([
-      [
-        "other-marketplace",
-        buildLocalMarketplace("other-marketplace", [
-          { name: "should-not-leak", version: "0.0.1", description: "" },
-        ]),
-      ],
-    ]);
-    const resolved = await resolveMarketplacePlugins(
-      "magus",
-      "not a valid repo string",
-      local,
-    );
-    expect(resolved.plugins).toEqual([]);
-    expect(resolved.source).toBe("none");
-  });
+	it("does not consult the cache when the remote returns plugins", async () => {
+		// We can't easily exercise the success branch without a live network,
+		// but we can verify that a cache entry for a DIFFERENT marketplace
+		// doesn't bleed into the requested one.
+		const local = new Map<string, LocalMarketplace>([
+			[
+				"other-marketplace",
+				buildLocalMarketplace("other-marketplace", [
+					{ name: "should-not-leak", version: "0.0.1", description: "" },
+				]),
+			],
+		]);
+		const resolved = await resolveMarketplacePlugins(
+			"magus",
+			"not a valid repo string",
+			local,
+		);
+		expect(resolved.plugins).toEqual([]);
+		expect(resolved.source).toBe("none");
+	});
 });
 
 /**
@@ -192,121 +200,123 @@ describe("resolveMarketplacePlugins — offline fallback", () => {
  * to guess, and all of them guessed "fine".
  */
 describe("fetchMarketplacePlugins — failures are values", () => {
-  beforeEach(() => {
-    clearMarketplaceCache();
-    resetGitHubBudget();
-  });
+	beforeEach(() => {
+		clearMarketplaceCache();
+		resetGitHubBudget();
+	});
 
-  it("classifies a rate limit distinctly from a network problem", async () => {
-    const original = globalThis.fetch;
-    globalThis.fetch = (async () =>
-      new Response("rate limited", {
-        status: 429,
-        statusText: "Too Many Requests",
-      })) as typeof globalThis.fetch;
-    try {
-      const result = await fetchMarketplacePlugins("magus", "MadAppGang/magus");
-      expect(result.plugins).toEqual([]);
-      expect(result.failure?.kind).toBe("rate-limited");
-      expect(result.failure?.httpStatus).toBe(429);
-      expect(result.failure?.detail).toContain("rate limit");
-    } finally {
-      globalThis.fetch = original;
-    }
-  });
+	it("classifies a rate limit distinctly from a network problem", async () => {
+		const original = globalThis.fetch;
+		globalThis.fetch = (async () =>
+			new Response("rate limited", {
+				status: 429,
+				statusText: "Too Many Requests",
+			})) as typeof globalThis.fetch;
+		try {
+			const result = await fetchMarketplacePlugins("magus", "MadAppGang/magus");
+			expect(result.plugins).toEqual([]);
+			expect(result.failure?.kind).toBe("rate-limited");
+			expect(result.failure?.httpStatus).toBe(429);
+			expect(result.failure?.detail).toContain("rate limit");
+		} finally {
+			globalThis.fetch = original;
+		}
+	});
 
-  it("records the failure so the UI can report it without re-fetching", async () => {
-    const original = globalThis.fetch;
-    let calls = 0;
-    globalThis.fetch = (async () => {
-      calls++;
-      return new Response("nope", { status: 500, statusText: "Server Error" });
-    }) as typeof globalThis.fetch;
-    try {
-      await fetchMarketplacePlugins("magus", "MadAppGang/magus");
+	it("records the failure so the UI can report it without re-fetching", async () => {
+		const original = globalThis.fetch;
+		let calls = 0;
+		globalThis.fetch = (async () => {
+			calls++;
+			return new Response("nope", { status: 500, statusText: "Server Error" });
+		}) as typeof globalThis.fetch;
+		try {
+			await fetchMarketplacePlugins("magus", "MadAppGang/magus");
 
-      const failures = getMarketplaceFetchFailures();
-      expect(failures.map((f) => f.marketplace)).toContain("magus");
-      expect(failures.find((f) => f.marketplace === "magus")?.kind).toBe("http");
+			const failures = getMarketplaceFetchFailures();
+			expect(failures.map((f) => f.marketplace)).toContain("magus");
+			expect(failures.find((f) => f.marketplace === "magus")?.kind).toBe(
+				"http",
+			);
 
-      // Second call must be served from the negative cache. Re-attempting on
-      // every screen mount is what cost 30-45s of "Loading..." per tab switch.
-      await fetchMarketplacePlugins("magus", "MadAppGang/magus");
-      expect(calls).toBe(1);
-    } finally {
-      globalThis.fetch = original;
-    }
-  });
+			// Second call must be served from the negative cache. Re-attempting on
+			// every screen mount is what cost 30-45s of "Loading..." per tab switch.
+			await fetchMarketplacePlugins("magus", "MadAppGang/magus");
+			expect(calls).toBe(1);
+		} finally {
+			globalThis.fetch = original;
+		}
+	});
 
-  it("reports no failures when the fetch succeeds", async () => {
-    const original = globalThis.fetch;
-    globalThis.fetch = (async () =>
-      Response.json({
-        metadata: { version: "9.0.3" },
-        plugins: [{ name: "terminal", version: "4.1.6" }],
-      })) as typeof globalThis.fetch;
-    try {
-      const result = await fetchMarketplacePlugins("magus", "MadAppGang/magus");
-      expect(result.failure).toBeUndefined();
-      expect(result.plugins).toHaveLength(1);
-      expect(getMarketplaceFetchFailures()).toEqual([]);
-    } finally {
-      globalThis.fetch = original;
-    }
-  });
+	it("reports no failures when the fetch succeeds", async () => {
+		const original = globalThis.fetch;
+		globalThis.fetch = (async () =>
+			Response.json({
+				metadata: { version: "9.0.3" },
+				plugins: [{ name: "terminal", version: "4.1.6" }],
+			})) as typeof globalThis.fetch;
+		try {
+			const result = await fetchMarketplacePlugins("magus", "MadAppGang/magus");
+			expect(result.failure).toBeUndefined();
+			expect(result.plugins).toHaveLength(1);
+			expect(getMarketplaceFetchFailures()).toEqual([]);
+		} finally {
+			globalThis.fetch = original;
+		}
+	});
 
-  it("does not send a request while the rate-limit window is still open", async () => {
-    // Deliberate: an explicit refresh clears OUR caches but not GitHub's limit.
-    // Retrying inside a known window cannot succeed, and on some endpoints a
-    // rejected request extends the penalty — so the screen waits and counts down
-    // instead. `clearMarketplaceCache()` must not be a way around that.
-    const original = globalThis.fetch;
-    let calls = 0;
-    globalThis.fetch = (async () => {
-      calls++;
-      return new Response("nope", { status: 429 });
-    }) as typeof globalThis.fetch;
-    try {
-      await fetchMarketplacePlugins("magus", "MadAppGang/magus");
-      expect(calls).toBe(1);
+	it("does not send a request while the rate-limit window is still open", async () => {
+		// Deliberate: an explicit refresh clears OUR caches but not GitHub's limit.
+		// Retrying inside a known window cannot succeed, and on some endpoints a
+		// rejected request extends the penalty — so the screen waits and counts down
+		// instead. `clearMarketplaceCache()` must not be a way around that.
+		const original = globalThis.fetch;
+		let calls = 0;
+		globalThis.fetch = (async () => {
+			calls++;
+			return new Response("nope", { status: 429 });
+		}) as typeof globalThis.fetch;
+		try {
+			await fetchMarketplacePlugins("magus", "MadAppGang/magus");
+			expect(calls).toBe(1);
 
-      clearMarketplaceCache();
-      const second = await fetchMarketplacePlugins("magus", "MadAppGang/magus");
+			clearMarketplaceCache();
+			const second = await fetchMarketplacePlugins("magus", "MadAppGang/magus");
 
-      expect(calls).toBe(1); // no second request went out
-      expect(second.failure?.kind).toBe("rate-limited");
-      expect(second.failure?.retryAt).toBeGreaterThan(Date.now());
-    } finally {
-      globalThis.fetch = original;
-    }
-  });
+			expect(calls).toBe(1); // no second request went out
+			expect(second.failure?.kind).toBe("rate-limited");
+			expect(second.failure?.retryAt).toBeGreaterThan(Date.now());
+		} finally {
+			globalThis.fetch = original;
+		}
+	});
 
-  it("clears the recorded failure once the window passes and the fetch succeeds", async () => {
-    const original = globalThis.fetch;
-    globalThis.fetch = (async () =>
-      new Response("nope", { status: 429 })) as typeof globalThis.fetch;
-    try {
-      await fetchMarketplacePlugins("magus", "MadAppGang/magus");
-      expect(getMarketplaceFetchFailures()).toHaveLength(1);
+	it("clears the recorded failure once the window passes and the fetch succeeds", async () => {
+		const original = globalThis.fetch;
+		globalThis.fetch = (async () =>
+			new Response("nope", { status: 429 })) as typeof globalThis.fetch;
+		try {
+			await fetchMarketplacePlugins("magus", "MadAppGang/magus");
+			expect(getMarketplaceFetchFailures()).toHaveLength(1);
 
-      // The cooldown expiring is what unblocks the retry — this stands in for the
-      // clock reaching `retryAt`, which is when the screen refetches by itself.
-      resetGitHubBudget();
-      clearMarketplaceCache();
-      globalThis.fetch = (async () =>
-        Response.json({
-          plugins: [{ name: "terminal", version: "4.2.0" }],
-        })) as typeof globalThis.fetch;
+			// The cooldown expiring is what unblocks the retry — this stands in for the
+			// clock reaching `retryAt`, which is when the screen refetches by itself.
+			resetGitHubBudget();
+			clearMarketplaceCache();
+			globalThis.fetch = (async () =>
+				Response.json({
+					plugins: [{ name: "terminal", version: "4.2.0" }],
+				})) as typeof globalThis.fetch;
 
-      const recovered = await fetchMarketplacePlugins(
-        "magus",
-        "MadAppGang/magus",
-      );
-      expect(recovered.failure).toBeUndefined();
-      expect(recovered.plugins).toHaveLength(1);
-      expect(getMarketplaceFetchFailures()).toEqual([]);
-    } finally {
-      globalThis.fetch = original;
-    }
-  });
+			const recovered = await fetchMarketplacePlugins(
+				"magus",
+				"MadAppGang/magus",
+			);
+			expect(recovered.failure).toBeUndefined();
+			expect(recovered.plugins).toHaveLength(1);
+			expect(getMarketplaceFetchFailures()).toEqual([]);
+		} finally {
+			globalThis.fetch = original;
+		}
+	});
 });

package/src/__tests__/plugin-requires.test.ts

@@ -92,11 +92,19 @@ describe("parsePluginRequires — setup block (the established convention)", ()
 	test.each([
 		[
 			"github.com/MadAppGang/tmux-mcp@v1.7.1",
-			{ name: "tmux-mcp", module: "github.com/MadAppGang/tmux-mcp", version: "v1.7.1" },
+			{
+				name: "tmux-mcp",
+				module: "github.com/MadAppGang/tmux-mcp",
+				version: "v1.7.1",
+			},
 		],
 		[
 			"github.com/MadAppGang/tmux-mcp/v2",
-			{ name: "tmux-mcp", module: "github.com/MadAppGang/tmux-mcp/v2", version: undefined },
+			{
+				name: "tmux-mcp",
+				module: "github.com/MadAppGang/tmux-mcp/v2",
+				version: undefined,
+			},
 		],
 		[
 			"github.com/x/v2tool@v1.0.0",
@@ -105,7 +113,11 @@ describe("parsePluginRequires — setup block (the established convention)", ()
 	])("go spec %s → name/module/version", (spec, expected) => {
 		const r = parsePluginRequires({ setup: { go: [spec] } });
 		expect(
-			r.bin!.map((b) => ({ name: b.name, module: b.module, version: b.version })),
+			r.bin!.map((b) => ({
+				name: b.name,
+				module: b.module,
+				version: b.version,
+			})),
 		).toEqual([expected]);
 	});
 
@@ -132,7 +144,9 @@ describe("parsePluginRequires — setup block (the established convention)", ()
 	test("explicit requires.bin overrides a setup entry of the same name", () => {
 		const r = parsePluginRequires({
 			setup: { required: ["tmux"] }, // → brew
-			requires: { bin: [{ name: "tmux", via: "go", module: "example.com/tmux" }] },
+			requires: {
+				bin: [{ name: "tmux", via: "go", module: "example.com/tmux" }],
+			},
 		});
 		const tmux = r.bin!.find((b) => b.name === "tmux")!;
 		expect(tmux.via).toBe("go"); // requires.bin won

package/src/__tests__/plugin-setup.test.ts

@@ -6,15 +6,15 @@
  * and `required` setup keys.
  */
 
-import { describe, it, expect, mock, beforeEach, afterEach } from "bun:test";
-import { mkdtemp, mkdir, writeFile, chmod, rm } from "node:fs/promises";
+import { afterEach, beforeEach, describe, expect, it, mock } from "bun:test";
+import * as actualChildProcess from "node:child_process";
+import { chmod, mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import path from "node:path";
 // Real modules captured before the mock.module() overrides, so the mocks spread
 // the full surface instead of stripping exports (e.g. resolveExecutable) that
 // bun's global, non-restored mock.module would otherwise remove for later files.
 import * as actualCommandUtils from "../utils/command-utils.js";
-import * as actualChildProcess from "node:child_process";
 
 // ---------------------------------------------------------------------------
 // Mocks — must be set up BEFORE any import from plugin-setup
@@ -120,9 +120,9 @@ describe("extractGoBinaryName", () => {
 	});
 
 	it("handles module with nested path and version", () => {
-		expect(
-			extractGoBinaryName("github.com/org/repo/cmd/mycli@v2.0.0"),
-		).toBe("mycli");
+		expect(extractGoBinaryName("github.com/org/repo/cmd/mycli@v2.0.0")).toBe(
+			"mycli",
+		);
 	});
 
 	it("handles empty string gracefully", () => {
@@ -367,9 +367,9 @@ describe("checkMissingDeps — go packages", () => {
 
 describe("extractGoVersion", () => {
 	it("returns the pinned version", () => {
-		expect(
-			extractGoVersion("github.com/MadAppGang/tmux-mcp@v1.6.2"),
-		).toBe("v1.6.2");
+		expect(extractGoVersion("github.com/MadAppGang/tmux-mcp@v1.6.2")).toBe(
+			"v1.6.2",
+		);
 	});
 	it("returns null for @latest (a moving target)", () => {
 		expect(
@@ -380,9 +380,9 @@ describe("extractGoVersion", () => {
 		expect(extractGoVersion("github.com/user/tool")).toBeNull();
 	});
 	it("reads the pin behind a /v2 module path", () => {
-		expect(
-			extractGoVersion("github.com/MadAppGang/tmux-mcp/v2@v2.0.0"),
-		).toBe("v2.0.0");
+		expect(extractGoVersion("github.com/MadAppGang/tmux-mcp/v2@v2.0.0")).toBe(
+			"v2.0.0",
+		);
 	});
 	it("a /v2 module path with no pin is unpinned, not pinned to v2", () => {
 		expect(extractGoVersion("github.com/MadAppGang/tmux-mcp/v2")).toBeNull();