claudeup 6.2.0 → 6.3.0

package/src/__tests__/gitignore-service.test.ts

@@ -1,135 +1,137 @@
-import { describe, it, expect, beforeEach, afterEach } from "bun:test";
-import { mkdtemp, rm, writeFile, mkdir, readFile } from "node:fs/promises";
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
+import { spawnSync } from "node:child_process";
+import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { spawnSync } from "node:child_process";
 import {
-  loadGitignoreState,
-  applyTemplate,
-  ensureProjectManifestForEdit,
+	applyTemplate,
+	ensureProjectManifestForEdit,
+	loadGitignoreState,
 } from "../services/gitignore-service";
 
 function git(cwd: string, ...args: string[]): void {
-  spawnSync("git", ["-c", "core.excludesFile=/dev/null", ...args], { cwd });
+	spawnSync("git", ["-c", "core.excludesFile=/dev/null", ...args], { cwd });
 }
 
 describe("loadGitignoreState", () => {
-  let projectDir: string;
-
-  beforeEach(async () => {
-    projectDir = await mkdtemp(join(tmpdir(), "gitig-svc-"));
-  });
-
-  afterEach(async () => {
-    await rm(projectDir, { recursive: true, force: true });
-  });
-
-  it("returns resolved manifest + violations + warnings", async () => {
-    git(projectDir, "init", "-q");
-    const s = await loadGitignoreState(projectDir);
-    expect(s.resolved).toBeDefined();
-    expect(Array.isArray(s.resolved.rules)).toBe(true);
-    expect(Array.isArray(s.violations)).toBe(true);
-    expect(Array.isArray(s.warnings)).toBe(true);
-  });
+	let projectDir: string;
+
+	beforeEach(async () => {
+		projectDir = await mkdtemp(join(tmpdir(), "gitig-svc-"));
+	});
+
+	afterEach(async () => {
+		await rm(projectDir, { recursive: true, force: true });
+	});
+
+	it("returns resolved manifest + violations + warnings", async () => {
+		git(projectDir, "init", "-q");
+		const s = await loadGitignoreState(projectDir);
+		expect(s.resolved).toBeDefined();
+		expect(Array.isArray(s.resolved.rules)).toBe(true);
+		expect(Array.isArray(s.violations)).toBe(true);
+		expect(Array.isArray(s.warnings)).toBe(true);
+	});
 });
 
 describe("applyTemplate", () => {
-  let projectDir: string;
-
-  beforeEach(async () => {
-    projectDir = await mkdtemp(join(tmpdir(), "gitig-tpl-"));
-    await mkdir(join(projectDir, ".claude"), { recursive: true });
-  });
-
-  afterEach(async () => {
-    await rm(projectDir, { recursive: true, force: true });
-  });
-
-  it("creates project manifest and merges template entries", async () => {
-    const r = await applyTemplate(projectDir, "common-dev");
-    expect(r.added.ignore).toContain("node_modules/");
-    expect(r.added.ignore).toContain(".env");
-    expect(r.conflicts).toEqual([]);
-
-    const written = JSON.parse(
-      await readFile(join(projectDir, ".claude", "gitignore.json"), "utf8"),
-    );
-    expect(written.ignore).toContain("node_modules/");
-  });
-
-  it("does not duplicate entries on second apply", async () => {
-    await applyTemplate(projectDir, "common-dev");
-    const r2 = await applyTemplate(projectDir, "common-dev");
-    expect(r2.added.ignore).toEqual([]);
-    expect(r2.added.track).toEqual([]);
-
-    const written = JSON.parse(
-      await readFile(join(projectDir, ".claude", "gitignore.json"), "utf8"),
-    );
-    const occurrences = written.ignore.filter((p: string) => p === "node_modules/").length;
-    expect(occurrences).toBe(1);
-  });
-
-  it("reports conflicts when an existing pattern would flip action", async () => {
-    await writeFile(
-      join(projectDir, ".claude", "gitignore.json"),
-      JSON.stringify({ ignore: [], track: ["node_modules/"] }),
-    );
-    const r = await applyTemplate(projectDir, "common-dev");
-    expect(r.conflicts).toContain("node_modules/");
-    // node_modules/ should NOT have been added to ignore
-    const written = JSON.parse(
-      await readFile(join(projectDir, ".claude", "gitignore.json"), "utf8"),
-    );
-    expect(written.ignore).not.toContain("node_modules/");
-    expect(written.track).toContain("node_modules/");
-  });
-
-  it("throws on unknown template name", async () => {
-    await expect(applyTemplate(projectDir, "does-not-exist")).rejects.toThrow(
-      /Unknown template/,
-    );
-  });
+	let projectDir: string;
+
+	beforeEach(async () => {
+		projectDir = await mkdtemp(join(tmpdir(), "gitig-tpl-"));
+		await mkdir(join(projectDir, ".claude"), { recursive: true });
+	});
+
+	afterEach(async () => {
+		await rm(projectDir, { recursive: true, force: true });
+	});
+
+	it("creates project manifest and merges template entries", async () => {
+		const r = await applyTemplate(projectDir, "common-dev");
+		expect(r.added.ignore).toContain("node_modules/");
+		expect(r.added.ignore).toContain(".env");
+		expect(r.conflicts).toEqual([]);
+
+		const written = JSON.parse(
+			await readFile(join(projectDir, ".claude", "gitignore.json"), "utf8"),
+		);
+		expect(written.ignore).toContain("node_modules/");
+	});
+
+	it("does not duplicate entries on second apply", async () => {
+		await applyTemplate(projectDir, "common-dev");
+		const r2 = await applyTemplate(projectDir, "common-dev");
+		expect(r2.added.ignore).toEqual([]);
+		expect(r2.added.track).toEqual([]);
+
+		const written = JSON.parse(
+			await readFile(join(projectDir, ".claude", "gitignore.json"), "utf8"),
+		);
+		const occurrences = written.ignore.filter(
+			(p: string) => p === "node_modules/",
+		).length;
+		expect(occurrences).toBe(1);
+	});
+
+	it("reports conflicts when an existing pattern would flip action", async () => {
+		await writeFile(
+			join(projectDir, ".claude", "gitignore.json"),
+			JSON.stringify({ ignore: [], track: ["node_modules/"] }),
+		);
+		const r = await applyTemplate(projectDir, "common-dev");
+		expect(r.conflicts).toContain("node_modules/");
+		// node_modules/ should NOT have been added to ignore
+		const written = JSON.parse(
+			await readFile(join(projectDir, ".claude", "gitignore.json"), "utf8"),
+		);
+		expect(written.ignore).not.toContain("node_modules/");
+		expect(written.track).toContain("node_modules/");
+	});
+
+	it("throws on unknown template name", async () => {
+		await expect(applyTemplate(projectDir, "does-not-exist")).rejects.toThrow(
+			/Unknown template/,
+		);
+	});
 });
 
 describe("ensureProjectManifestForEdit", () => {
-  let projectDir: string;
-
-  beforeEach(async () => {
-    projectDir = await mkdtemp(join(tmpdir(), "gitig-edit-"));
-  });
-
-  afterEach(async () => {
-    await rm(projectDir, { recursive: true, force: true });
-  });
-
-  it("creates an editable project manifest from resolved rules", async () => {
-    const path = await ensureProjectManifestForEdit(projectDir, {
-      rules: [
-        { pattern: ".env", action: "ignore", source: "builtin" },
-        { pattern: ".mcp.json", action: "track", source: "builtin" },
-      ],
-      conflicts: [],
-    });
-
-    expect(path).toBe(join(projectDir, ".claude", "gitignore.json"));
-    const written = JSON.parse(await readFile(path, "utf8"));
-    expect(written.ignore).toEqual([".env"]);
-    expect(written.track).toEqual([".mcp.json"]);
-  });
-
-  it("keeps an existing non-empty project manifest", async () => {
-    const path = join(projectDir, ".claude", "gitignore.json");
-    await mkdir(join(projectDir, ".claude"), { recursive: true });
-    await writeFile(path, JSON.stringify({ ignore: ["custom"], track: [] }));
-
-    await ensureProjectManifestForEdit(projectDir, {
-      rules: [{ pattern: ".env", action: "ignore", source: "builtin" }],
-      conflicts: [],
-    });
-
-    const written = JSON.parse(await readFile(path, "utf8"));
-    expect(written.ignore).toEqual(["custom"]);
-  });
+	let projectDir: string;
+
+	beforeEach(async () => {
+		projectDir = await mkdtemp(join(tmpdir(), "gitig-edit-"));
+	});
+
+	afterEach(async () => {
+		await rm(projectDir, { recursive: true, force: true });
+	});
+
+	it("creates an editable project manifest from resolved rules", async () => {
+		const path = await ensureProjectManifestForEdit(projectDir, {
+			rules: [
+				{ pattern: ".env", action: "ignore", source: "builtin" },
+				{ pattern: ".mcp.json", action: "track", source: "builtin" },
+			],
+			conflicts: [],
+		});
+
+		expect(path).toBe(join(projectDir, ".claude", "gitignore.json"));
+		const written = JSON.parse(await readFile(path, "utf8"));
+		expect(written.ignore).toEqual([".env"]);
+		expect(written.track).toEqual([".mcp.json"]);
+	});
+
+	it("keeps an existing non-empty project manifest", async () => {
+		const path = join(projectDir, ".claude", "gitignore.json");
+		await mkdir(join(projectDir, ".claude"), { recursive: true });
+		await writeFile(path, JSON.stringify({ ignore: ["custom"], track: [] }));
+
+		await ensureProjectManifestForEdit(projectDir, {
+			rules: [{ pattern: ".env", action: "ignore", source: "builtin" }],
+			conflicts: [],
+		});
+
+		const written = JSON.parse(await readFile(path, "utf8"));
+		expect(written.ignore).toEqual(["custom"]);
+	});
 });

package/src/__tests__/go-module.test.ts

@@ -0,0 +1,43 @@
+/**
+ * goBinaryName: the one rule for turning a Go module path into the binary
+ * `go install` produces. Both consumers (plugin-setup's Go path and
+ * plugin-requires' `setup.go` branch) are tested through their own surfaces;
+ * this file pins the rule itself.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { goBinaryName } from "../utils/go-module.js";
+
+describe("goBinaryName", () => {
+	test("takes the last segment of a v0/v1 module path", () => {
+		expect(goBinaryName("github.com/MadAppGang/tmux-mcp")).toBe("tmux-mcp");
+	});
+
+	test("strips a trailing /v2 major-version suffix before taking the name", () => {
+		expect(goBinaryName("github.com/MadAppGang/tmux-mcp/v2")).toBe("tmux-mcp");
+	});
+
+	test("strips multi-digit suffixes (/v10, /v42)", () => {
+		expect(goBinaryName("github.com/x/tool/v10")).toBe("tool");
+		expect(goBinaryName("github.com/x/tool/v42")).toBe("tool");
+	});
+
+	test("a segment that merely starts with v2 is a name, not a suffix", () => {
+		expect(goBinaryName("github.com/x/v2tool")).toBe("v2tool");
+	});
+
+	test("v0 and v1 are never path suffixes, so they stay as names", () => {
+		// Nobody names a binary this, but the rule must not invent an exception.
+		expect(goBinaryName("github.com/x/v1")).toBe("v1");
+		expect(goBinaryName("github.com/x/v0")).toBe("v0");
+	});
+
+	test("a suffix in the middle of the path is not trailing and is kept", () => {
+		expect(goBinaryName("github.com/x/repo/v2/cmd/cli")).toBe("cli");
+	});
+
+	test("single-segment and empty inputs pass through", () => {
+		expect(goBinaryName("mytool")).toBe("mytool");
+		expect(goBinaryName("")).toBe("");
+	});
+});

package/src/__tests__/install-command.test.ts

@@ -18,9 +18,7 @@ import { runInstallCommand } from "../cli/install.js";
 
 let logs: string[];
 let errs: string[];
-// biome-ignore lint/suspicious/noExplicitAny: saved console refs
 let origLog: any;
-// biome-ignore lint/suspicious/noExplicitAny: saved console refs
 let origErr: any;
 beforeEach(() => {
 	logs = [];
@@ -69,7 +67,9 @@ describe("runInstallCommand — early-return paths", () => {
 	test("unknown profile → exit 1", async () => {
 		dir = await project({
 			version: 2,
-			profiles: { frontend: { name: "Frontend", plugins: { "dev@magus": "latest" } } },
+			profiles: {
+				frontend: { name: "Frontend", plugins: { "dev@magus": "latest" } },
+			},
 		});
 		expect(await runInstallCommand(["ghost", "--check"], dir)).toBe(1);
 	});

package/src/__tests__/install-plan.test.ts

@@ -22,9 +22,7 @@ function closure(overrides: Partial<ResolvedClosure> = {}): ResolvedClosure {
 	};
 }
 
-function registry(
-	plugins: Record<string, string[]>,
-): InstalledPluginsRegistry {
+function registry(plugins: Record<string, string[]>): InstalledPluginsRegistry {
 	const out: InstalledPluginsRegistry = { version: 2, plugins: {} };
 	for (const [id, versions] of Object.entries(plugins)) {
 		out.plugins[id] = versions.map((v) => ({
@@ -41,12 +39,16 @@ function registry(
 describe("computeVersionDrift", () => {
 	test("no drift when installed matches the pin", () => {
 		const c = closure({ plugins: { "dev@magus": "2.9.0" } });
-		expect(computeVersionDrift(c, registry({ "dev@magus": ["2.9.0"] }))).toEqual([]);
+		expect(
+			computeVersionDrift(c, registry({ "dev@magus": ["2.9.0"] })),
+		).toEqual([]);
 	});
 
 	test("'latest' pins are never drift-checked", () => {
 		const c = closure({ plugins: { "dev@magus": "latest" } });
-		expect(computeVersionDrift(c, registry({ "dev@magus": ["1.0.0"] }))).toEqual([]);
+		expect(
+			computeVersionDrift(c, registry({ "dev@magus": ["1.0.0"] })),
+		).toEqual([]);
 	});
 
 	test("flags a mismatch, reporting the highest installed version", () => {
@@ -75,7 +77,9 @@ describe("computeEnvStatus", () => {
 		});
 		const status = computeEnvStatus(c, { SET_VAR: "x", OPT: "" });
 		expect(status.missingRequired).toEqual(["FIGMA_TOKEN"]);
-		expect(status.required.find((e) => e.name === "SET_VAR")!.present).toBe(true);
+		expect(status.required.find((e) => e.name === "SET_VAR")!.present).toBe(
+			true,
+		);
 		// empty string counts as missing
 		expect(status.optional[0]!.present).toBe(false);
 	});
@@ -86,7 +90,9 @@ describe("summarizeClosure", () => {
 		const c = closure({
 			marketplaces: { magus: { source: "github", repo: "MadAppGang/magus" } },
 			plugins: { "dev@magus": "latest", "terminal@magus": "4.1.0" },
-			bins: [{ name: "claudish", via: "bun", version: "1.2.0", sources: ["x"] }],
+			bins: [
+				{ name: "claudish", via: "bun", version: "1.2.0", sources: ["x"] },
+			],
 			env: { required: ["FIGMA_TOKEN"], optional: [] },
 		});
 		const lines = summarizeClosure(c);

package/src/__tests__/manifest.test.ts

@@ -46,9 +46,14 @@ describe("migrateToV2", () => {
 	});
 
 	test("strictVersions is carried through as a boolean", () => {
-		expect(migrateToV2({ version: 2, strictVersions: true, profiles: {} }).strictVersions).toBe(true);
+		expect(
+			migrateToV2({ version: 2, strictVersions: true, profiles: {} })
+				.strictVersions,
+		).toBe(true);
 		// Omitted (not written as false) to keep a committed manifest minimal.
-		expect(migrateToV2({ version: 2, profiles: {} }).strictVersions).toBeUndefined();
+		expect(
+			migrateToV2({ version: 2, profiles: {} }).strictVersions,
+		).toBeUndefined();
 	});
 });
 
@@ -94,8 +99,12 @@ describe("validateManifest", () => {
 				},
 			},
 		});
-		expect(errors.some((e) => e.path === "profiles.p.marketplaces.m")).toBe(true);
-		expect(errors.some((e) => e.path.startsWith("profiles.p.skills"))).toBe(true);
+		expect(errors.some((e) => e.path === "profiles.p.marketplaces.m")).toBe(
+			true,
+		);
+		expect(errors.some((e) => e.path.startsWith("profiles.p.skills"))).toBe(
+			true,
+		);
 	});
 });
 
@@ -119,7 +128,9 @@ describe("readManifest / writeManifest", () => {
 			profiles: { p: { name: "P", plugins: { "dev@magus": "1.0.0" } } },
 		};
 		await writeManifest(manifest, dir);
-		expect(await fs.pathExists(join(dir, ".claude", "profiles.json"))).toBe(true);
+		expect(await fs.pathExists(join(dir, ".claude", "profiles.json"))).toBe(
+			true,
+		);
 		expect(await readManifest(dir)).toEqual(manifest);
 	});
 

package/src/__tests__/markdown-renderer.test.ts

@@ -8,7 +8,6 @@ import { renderMarkdown } from "../ui/renderers/markdownRenderer.js";
  */
 
 /** Flatten a rendered node tree to the text a reader would see. */
-// biome-ignore lint/suspicious/noExplicitAny: walking opaque element trees
 function textOf(node: any): string {
 	if (node === null || node === undefined || typeof node === "boolean") {
 		return "";

package/src/__tests__/marketplace-badge.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test } from "bun:test";
-import { buildPluginBrowserItems } from "../ui/adapters/pluginsAdapter.js";
 import type { Marketplace } from "../types/index.js";
+import { buildPluginBrowserItems } from "../ui/adapters/pluginsAdapter.js";
 
 /**
  * The marketplace category badge is the line users read on every claudeup launch,
@@ -9,111 +9,132 @@ import type { Marketplace } from "../types/index.js";
  */
 
 const mp = (over: Partial<Marketplace> & { name: string }): Marketplace => ({
-  displayName: over.displayName ?? over.name,
-  source: { source: "github", repo: `someone/${over.name}` },
-  description: "",
-  ...over,
+	displayName: over.displayName ?? over.name,
+	source: { source: "github", repo: `someone/${over.name}` },
+	description: "",
+	...over,
 });
 
 /** Badge for a marketplace when it has plugins and is expanded. */
 function badgeFor(marketplace: Marketplace): string | undefined {
-  const items = buildPluginBrowserItems({
-    marketplaces: [marketplace],
-    plugins: [
-      {
-        id: `demo@${marketplace.name}`,
-        name: "demo",
-        marketplace: marketplace.name,
-        // Only the fields the adapter groups on matter here.
-      } as never,
-    ],
-    collapsedMarketplaces: new Set(),
-  });
-  const category = items.find((i) => i.kind === "category");
-  return category && "badge" in category ? category.badge : undefined;
+	const items = buildPluginBrowserItems({
+		marketplaces: [marketplace],
+		plugins: [
+			{
+				id: `demo@${marketplace.name}`,
+				name: "demo",
+				marketplace: marketplace.name,
+				// Only the fields the adapter groups on matter here.
+			} as never,
+		],
+		collapsedMarketplaces: new Set(),
+	});
+	const category = items.find((i) => i.kind === "category");
+	return category && "badge" in category ? category.badge : undefined;
 }
 
 /** Tone for a marketplace when it has plugins and is expanded. */
 function toneFor(marketplace: Marketplace): string | undefined {
-  const items = buildPluginBrowserItems({
-    marketplaces: [marketplace],
-    plugins: [
-      { id: `demo@${marketplace.name}`, name: "demo", marketplace: marketplace.name } as never,
-    ],
-    collapsedMarketplaces: new Set(),
-  });
-  const category = items.find((i) => i.kind === "category");
-  return category && "tone" in category ? category.tone : undefined;
+	const items = buildPluginBrowserItems({
+		marketplaces: [marketplace],
+		plugins: [
+			{
+				id: `demo@${marketplace.name}`,
+				name: "demo",
+				marketplace: marketplace.name,
+			} as never,
+		],
+		collapsedMarketplaces: new Set(),
+	});
+	const category = items.find((i) => i.kind === "category");
+	return category && "tone" in category ? category.tone : undefined;
 }
 
 describe("marketplace category badge", () => {
-  test("the byline uses a low-key tone, not an attention-grabbing one", () => {
-    // It is a signature, not a status. Green reads as "action succeeded" and
-    // competes with the plugin rows for attention.
-    expect(
-      toneFor(mp({ name: "magus", source: { source: "github", repo: "MadAppGang/magus" } })),
-    ).toBe("byline");
+	test("the byline uses a low-key tone, not an attention-grabbing one", () => {
+		// It is a signature, not a status. Green reads as "action succeeded" and
+		// competes with the plugin rows for attention.
+		expect(
+			toneFor(
+				mp({
+					name: "magus",
+					source: { source: "github", repo: "MadAppGang/magus" },
+				}),
+			),
+		).toBe("byline");
 
-    // A third-party marketplace still uses the green "Added" status tone.
-    expect(
-      toneFor(
-        mp({ name: "sp", source: { source: "github", repo: "obra/superpowers-marketplace" } }),
-      ),
-    ).toBe("green");
-  });
+		// A third-party marketplace still uses the green "Added" status tone.
+		expect(
+			toneFor(
+				mp({
+					name: "sp",
+					source: { source: "github", repo: "obra/superpowers-marketplace" },
+				}),
+			),
+		).toBe("green");
+	});
 
-  test("MadAppGang marketplaces carry the byline instead of a generic label", () => {
-    for (const name of ["magus", "magus-marketing", "magus-alpha"]) {
-      const badge = badgeFor(
-        mp({ name, source: { source: "github", repo: `MadAppGang/${name}` } }),
-      );
-      expect(badge).toBe("by MadAppGang");
-    }
-  });
+	test("MadAppGang marketplaces carry the byline instead of a generic label", () => {
+		for (const name of ["magus", "magus-marketing", "magus-alpha"]) {
+			const badge = badgeFor(
+				mp({ name, source: { source: "github", repo: `MadAppGang/${name}` } }),
+			);
+			expect(badge).toBe("by MadAppGang");
+		}
+	});
 
-  test("owner match is case-insensitive", () => {
-    // The npm/GitHub casing of the org has varied in config; don't depend on it.
-    const badge = badgeFor(
-      mp({ name: "magus", source: { source: "github", repo: "madappgang/magus" } }),
-    );
-    expect(badge).toBe("by MadAppGang");
-  });
+	test("owner match is case-insensitive", () => {
+		// The npm/GitHub casing of the org has varied in config; don't depend on it.
+		const badge = badgeFor(
+			mp({
+				name: "magus",
+				source: { source: "github", repo: "madappgang/magus" },
+			}),
+		);
+		expect(badge).toBe("by MadAppGang");
+	});
 
-  test("someone else's marketplace does NOT claim the byline", () => {
-    const badge = badgeFor(
-      mp({
-        name: "superpowers-marketplace",
-        source: { source: "github", repo: "obra/superpowers-marketplace" },
-      }),
-    );
-    expect(badge).toBe("✓ Added");
-  });
+	test("someone else's marketplace does NOT claim the byline", () => {
+		const badge = badgeFor(
+			mp({
+				name: "superpowers-marketplace",
+				source: { source: "github", repo: "obra/superpowers-marketplace" },
+			}),
+		);
+		expect(badge).toBe("✓ Added");
+	});
 
-  test("a repo merely containing 'madappgang' downstream does not match", () => {
-    // Guards against a substring check — only the owner segment counts.
-    const badge = badgeFor(
-      mp({ name: "impostor", source: { source: "github", repo: "evil/madappgang-magus" } }),
-    );
-    expect(badge).toBe("✓ Added");
-  });
+	test("a repo merely containing 'madappgang' downstream does not match", () => {
+		// Guards against a substring check — only the owner segment counts.
+		const badge = badgeFor(
+			mp({
+				name: "impostor",
+				source: { source: "github", repo: "evil/madappgang-magus" },
+			}),
+		);
+		expect(badge).toBe("✓ Added");
+	});
 
-  test("Official and Deprecated still take precedence", () => {
-    expect(
-      badgeFor(
-        mp({
-          name: "claude-plugins-official",
-          source: { source: "github", repo: "anthropics/claude-plugins-official" },
-        }),
-      ),
-    ).toBe("★ Official");
+	test("Official and Deprecated still take precedence", () => {
+		expect(
+			badgeFor(
+				mp({
+					name: "claude-plugins-official",
+					source: {
+						source: "github",
+						repo: "anthropics/claude-plugins-official",
+					},
+				}),
+			),
+		).toBe("★ Official");
 
-    expect(
-      badgeFor(
-        mp({
-          name: "claude-code-plugins",
-          source: { source: "github", repo: "anthropics/claude-code" },
-        }),
-      ),
-    ).toBe("⚠ Deprecated");
-  });
+		expect(
+			badgeFor(
+				mp({
+					name: "claude-code-plugins",
+					source: { source: "github", repo: "anthropics/claude-code" },
+				}),
+			),
+		).toBe("⚠ Deprecated");
+	});
 });