magus-cli 0.0.0-placeholder → 7.1.0

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

@@ -0,0 +1,317 @@
+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 {
+	applyDestructiveFix,
+	applySafeFixes,
+	formatViolationSummary,
+} from "../services/gitignore-fixer";
+import type { Violation } from "../types/gitignore";
+
+// `commit.gpgsign=false` is not tidiness — without it these tests HANG.
+//
+// Two tests here run `git commit` in a temp repo, which inherits the
+// developer's global config. On any machine with commit signing enabled and a
+// GUI signer (`gpg.format=ssh` pointing at 1Password's `op-ssh-sign` is the
+// common setup here), the commit blocks waiting for an approval dialog nobody
+// is watching, and both tests fail on a 5s timeout. It presents as a flake
+// because the approval is cached once granted, so the suite goes green until
+// the cache expires. `marketplace-refresh.test.ts` already guards this the same
+// way; this file did not.
+const GIT_CFG = [
+	"-c",
+	"core.excludesFile=/dev/null",
+	"-c",
+	"commit.gpgsign=false",
+	"-c",
+	"init.defaultBranch=main",
+];
+
+function git(
+	cwd: string,
+	...args: string[]
+): { stdout: string; status: number } {
+	const r = spawnSync("git", [...GIT_CFG, ...args], {
+		cwd,
+		encoding: "utf8",
+	});
+	return { stdout: r.stdout, status: r.status ?? -1 };
+}
+
+async function makeRepo(): Promise<string> {
+	const dir = await mkdtemp(join(tmpdir(), "gitig-fix-"));
+	git(dir, "init", "-q");
+	git(dir, "config", "user.email", "t@t");
+	git(dir, "config", "user.name", "t");
+	return dir;
+}
+
+describe("applySafeFixes", () => {
+	let repo: string;
+
+	beforeEach(async () => {
+		repo = await makeRepo();
+	});
+
+	afterEach(async () => {
+		await rm(repo, { recursive: true, force: true });
+	});
+
+	it("appends missing patterns to .gitignore under a header", async () => {
+		const violations: Violation[] = [
+			{
+				kind: "missing-from-gitignore",
+				path: ".env",
+				source: "builtin",
+				severity: "safe",
+			},
+			{
+				kind: "missing-from-gitignore",
+				path: ".mnemex/",
+				source: "builtin",
+				severity: "safe",
+			},
+		];
+		const r = await applySafeFixes(repo, violations);
+		expect(r.appended).toEqual([".env", ".mnemex/"]);
+		expect(r.alreadyPresent).toEqual([]);
+
+		const content = await readFile(join(repo, ".gitignore"), "utf8");
+		expect(content).toContain(".env");
+		expect(content).toContain(".mnemex/");
+		expect(content).toContain("# Added by magus");
+		expect(content).toContain("Environment files commonly contain");
+		expect(content).toContain("Local memory/index data");
+	});
+
+	it("creates .gitignore if absent", async () => {
+		const r = await applySafeFixes(repo, [
+			{
+				kind: "missing-from-gitignore",
+				path: "foo",
+				source: "builtin",
+				severity: "safe",
+			},
+		]);
+		expect(r.appended).toEqual(["foo"]);
+		const content = await readFile(join(repo, ".gitignore"), "utf8");
+		expect(content).toMatch(/foo/);
+	});
+
+	it("is idempotent — re-running does not duplicate entries", async () => {
+		const v: Violation = {
+			kind: "missing-from-gitignore",
+			path: "dup",
+			source: "builtin",
+			severity: "safe",
+		};
+		await applySafeFixes(repo, [v]);
+		const second = await applySafeFixes(repo, [v]);
+		expect(second.appended).toEqual([]);
+		expect(second.alreadyPresent).toEqual(["dup"]);
+		const content = await readFile(join(repo, ".gitignore"), "utf8");
+		expect(content.match(/^dup$/gm)?.length).toBe(1);
+	});
+
+	it("ignores destructive violations", async () => {
+		const r = await applySafeFixes(repo, [
+			{
+				kind: "tracked-but-should-ignore",
+				path: "secret",
+				source: "builtin",
+				severity: "destructive",
+			},
+		]);
+		expect(r.appended).toEqual([]);
+	});
+
+	it("preserves existing .gitignore content", async () => {
+		await writeFile(join(repo, ".gitignore"), "node_modules/\n.DS_Store\n");
+		await applySafeFixes(repo, [
+			{
+				kind: "missing-from-gitignore",
+				path: ".env",
+				source: "builtin",
+				severity: "safe",
+			},
+		]);
+		const content = await readFile(join(repo, ".gitignore"), "utf8");
+		expect(content).toContain("node_modules/");
+		expect(content).toContain(".DS_Store");
+		expect(content).toContain(".env");
+	});
+});
+
+describe("applyDestructiveFix", () => {
+	let repo: string;
+
+	beforeEach(async () => {
+		repo = await makeRepo();
+	});
+
+	afterEach(async () => {
+		await rm(repo, { recursive: true, force: true });
+	});
+
+	it("removes tracked file from index and adds to .gitignore", async () => {
+		await writeFile(join(repo, "secret"), "x");
+		git(repo, "add", "secret");
+		git(repo, "commit", "-q", "-m", "add");
+
+		const r = await applyDestructiveFix(repo, {
+			kind: "tracked-but-should-ignore",
+			path: "secret",
+			source: "builtin",
+			severity: "destructive",
+		});
+		expect(r.applied).toBe(true);
+
+		const ls = git(repo, "ls-files");
+		expect(ls.stdout.includes("secret")).toBe(false);
+		const ignore = await readFile(join(repo, ".gitignore"), "utf8");
+		expect(ignore).toContain("secret");
+	});
+
+	it("strips .gitignore line and stages file for ignored-but-should-track", async () => {
+		await writeFile(join(repo, ".mcp.json"), "{}");
+		await writeFile(join(repo, ".gitignore"), ".mcp.json\nnode_modules/\n");
+
+		const r = await applyDestructiveFix(repo, {
+			kind: "ignored-but-should-track",
+			path: ".mcp.json",
+			source: "builtin",
+			severity: "destructive",
+		});
+		expect(r.applied).toBe(true);
+
+		const ignore = await readFile(join(repo, ".gitignore"), "utf8");
+		expect(ignore).not.toMatch(/^\.mcp\.json$/m);
+		expect(ignore).toContain("node_modules/");
+
+		const ls = git(repo, "ls-files");
+		// staged but not yet committed; ls-files only shows index
+		expect(ls.stdout).toContain(".mcp.json");
+	});
+
+	it("adds unignore exceptions when a parent rule ignores a tracked path", async () => {
+		await mkdir(join(repo, ".claude"), { recursive: true });
+		await writeFile(join(repo, ".claude", "settings.json"), "{}");
+		await writeFile(join(repo, ".gitignore"), "/*\n");
+
+		const r = await applyDestructiveFix(repo, {
+			kind: "ignored-but-should-track",
+			path: ".claude/settings.json",
+			source: "builtin",
+			severity: "destructive",
+		});
+		expect(r.applied).toBe(true);
+
+		const ignore = await readFile(join(repo, ".gitignore"), "utf8");
+		expect(ignore).toContain("!/.claude/");
+		expect(ignore).toContain("!/.claude/settings.json");
+		expect(ignore).toContain("Team Claude settings should be committed");
+
+		const ls = git(repo, "ls-files");
+		expect(ls.stdout).toContain(".claude/settings.json");
+	});
+
+	it("does not fail when making an absent tracked path trackable", async () => {
+		await writeFile(join(repo, ".gitignore"), "/*\n");
+
+		const r = await applyDestructiveFix(repo, {
+			kind: "ignored-but-should-track",
+			path: "plugin.json",
+			source: "builtin",
+			severity: "destructive",
+		});
+		expect(r.applied).toBe(true);
+		expect(r.message).toContain("does not exist yet");
+
+		const ignore = await readFile(join(repo, ".gitignore"), "utf8");
+		expect(ignore).toContain("!/plugin.json");
+	});
+
+	it("uses the managed rule pattern when untracking child violations", async () => {
+		await mkdir(join(repo, "logs"), { recursive: true });
+		await writeFile(join(repo, "logs", "app.log"), "x");
+		git(repo, "add", "logs/app.log");
+		git(repo, "commit", "-q", "-m", "add log");
+
+		const r = await applyDestructiveFix(
+			repo,
+			{
+				kind: "tracked-but-should-ignore",
+				path: "logs/app.log",
+				source: "builtin",
+				severity: "destructive",
+			},
+			"logs/",
+		);
+		expect(r.applied).toBe(true);
+
+		const ignore = await readFile(join(repo, ".gitignore"), "utf8");
+		expect(ignore).toContain("logs/");
+		expect(ignore).not.toMatch(/^logs\/app\.log$/m);
+	});
+
+	it("stages an untracked file", async () => {
+		await writeFile(join(repo, ".mcp.json"), "{}");
+		const r = await applyDestructiveFix(repo, {
+			kind: "untracked-and-should-track",
+			path: ".mcp.json",
+			source: "builtin",
+			severity: "destructive",
+		});
+		expect(r.applied).toBe(true);
+		expect(git(repo, "ls-files").stdout).toContain(".mcp.json");
+	});
+});
+
+describe("formatViolationSummary", () => {
+	it("returns friendly message when empty", () => {
+		expect(formatViolationSummary([])).toMatch(/No gitignore issues/);
+	});
+
+	it("groups by kind with counts and sample paths", () => {
+		const summary = formatViolationSummary([
+			{
+				kind: "missing-from-gitignore",
+				path: "a",
+				source: "builtin",
+				severity: "safe",
+			},
+			{
+				kind: "missing-from-gitignore",
+				path: "b",
+				source: "builtin",
+				severity: "safe",
+			},
+			{
+				kind: "tracked-but-should-ignore",
+				path: "c",
+				source: "project",
+				severity: "destructive",
+			},
+		]);
+		expect(summary).toContain("missing from .gitignore: 2");
+		expect(summary).toContain("tracked but should be ignored: 1");
+		expect(summary).toContain("- a");
+		expect(summary).toContain("- c");
+	});
+
+	it("truncates long lists with `… and N more`", () => {
+		const vs: Violation[] = [];
+		for (let i = 0; i < 8; i++) {
+			vs.push({
+				kind: "missing-from-gitignore",
+				path: `p${i}`,
+				source: "builtin",
+				severity: "safe",
+			});
+		}
+		const summary = formatViolationSummary(vs);
+		expect(summary).toContain("and 3 more");
+	});
+});

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

@@ -0,0 +1,193 @@
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { BUILTIN_DEFAULTS } from "../data/gitignore-defaults";
+import { resolveGitignore } from "../services/gitignore-resolver";
+
+describe("resolveGitignore", () => {
+	let projectDir: string;
+	let homeDir: string;
+
+	beforeEach(async () => {
+		projectDir = await mkdtemp(join(tmpdir(), "gitig-proj-"));
+		homeDir = await mkdtemp(join(tmpdir(), "gitig-home-"));
+		await mkdir(join(projectDir, ".claude"), { recursive: true });
+		await mkdir(join(homeDir, ".claude"), { recursive: true });
+	});
+
+	afterEach(async () => {
+		await rm(projectDir, { recursive: true, force: true });
+		await rm(homeDir, { recursive: true, force: true });
+	});
+
+	it("returns built-in defaults when no global or project manifest exists", async () => {
+		const r = await resolveGitignore(projectDir, { homeDir });
+		expect(r.conflicts).toEqual([]);
+		const ignored = r.rules
+			.filter((x) => x.action === "ignore")
+			.map((x) => x.pattern);
+		for (const p of BUILTIN_DEFAULTS.ignore) {
+			expect(ignored).toContain(p);
+		}
+		const tracked = r.rules
+			.filter((x) => x.action === "track")
+			.map((x) => x.pattern);
+		for (const p of BUILTIN_DEFAULTS.track) {
+			expect(tracked).toContain(p);
+		}
+		for (const rule of r.rules) {
+			expect(rule.source).toBe("builtin");
+		}
+	});
+
+	it("project tier overrides global tier", async () => {
+		await writeFile(
+			join(homeDir, ".claude", "gitignore.json"),
+			JSON.stringify({ ignore: [".env"], track: [] }),
+		);
+		await writeFile(
+			join(projectDir, ".claude", "gitignore.json"),
+			JSON.stringify({ ignore: [], track: [".env"] }),
+		);
+
+		const r = await resolveGitignore(projectDir, { homeDir });
+		const env = r.rules.find((x) => x.pattern === ".env");
+		expect(env?.action).toBe("track");
+		expect(env?.source).toBe("project");
+		expect(r.conflicts.find((c) => c.pattern === ".env")?.winner).toBe(
+			"project",
+		);
+	});
+
+	it("global tier overrides built-in", async () => {
+		await writeFile(
+			join(homeDir, ".claude", "gitignore.json"),
+			JSON.stringify({ ignore: [], track: [".claude/settings.local.json"] }),
+		);
+		const r = await resolveGitignore(projectDir, { homeDir });
+		const rule = r.rules.find(
+			(x) => x.pattern === ".claude/settings.local.json",
+		);
+		expect(rule?.action).toBe("track");
+		expect(rule?.source).toBe("global");
+	});
+
+	it("expands `extends: ['common-dev']` into the tier's rules", async () => {
+		await writeFile(
+			join(projectDir, ".claude", "gitignore.json"),
+			JSON.stringify({ ignore: [], track: [], extends: ["common-dev"] }),
+		);
+		const r = await resolveGitignore(projectDir, { homeDir });
+		const ignored = r.rules
+			.filter((x) => x.action === "ignore")
+			.map((x) => x.pattern);
+		expect(ignored).toContain("node_modules/");
+		expect(ignored).toContain(".env");
+		expect(ignored).toContain(".DS_Store");
+		// Template rules carry the project source since they merged into project tier
+		const nodeMods = r.rules.find((x) => x.pattern === "node_modules/");
+		expect(nodeMods?.source).toBe("project");
+	});
+
+	it("logs and skips unknown templates", async () => {
+		await writeFile(
+			join(projectDir, ".claude", "gitignore.json"),
+			JSON.stringify({ ignore: [], track: [], extends: ["does-not-exist"] }),
+		);
+		const messages: string[] = [];
+		const r = await resolveGitignore(projectDir, {
+			homeDir,
+			logger: (m) => messages.push(m),
+		});
+		expect(messages.some((m) => m.includes("does-not-exist"))).toBe(true);
+		// Should still return built-in defaults
+		expect(r.rules.length).toBeGreaterThan(0);
+	});
+
+	it("throws on intra-tier conflict", async () => {
+		await writeFile(
+			join(projectDir, ".claude", "gitignore.json"),
+			JSON.stringify({ ignore: ["foo"], track: ["foo"] }),
+		);
+		await expect(resolveGitignore(projectDir, { homeDir })).rejects.toThrow(
+			/Intra-tier conflict/,
+		);
+	});
+
+	it("ignores malformed manifest JSON without throwing", async () => {
+		await writeFile(join(projectDir, ".claude", "gitignore.json"), "{not json");
+		const messages: string[] = [];
+		const r = await resolveGitignore(projectDir, {
+			homeDir,
+			logger: (m) => messages.push(m),
+		});
+		expect(messages.some((m) => /failed to read/.test(m))).toBe(true);
+		// Falls back to built-in
+		expect(r.rules.find((x) => x.pattern === ".mnemex/")?.source).toBe(
+			"builtin",
+		);
+	});
+
+	it("ignores manifest with wrong shape without throwing", async () => {
+		await writeFile(
+			join(projectDir, ".claude", "gitignore.json"),
+			JSON.stringify({ ignore: "not-array" }),
+		);
+		const messages: string[] = [];
+		const r = await resolveGitignore(projectDir, {
+			homeDir,
+			logger: (m) => messages.push(m),
+		});
+		expect(messages.some((m) => /not a valid manifest/.test(m))).toBe(true);
+		expect(r.rules.length).toBeGreaterThan(0);
+	});
+
+	it("dedupes patterns within a tier", async () => {
+		await writeFile(
+			join(projectDir, ".claude", "gitignore.json"),
+			JSON.stringify({ ignore: ["foo", "foo", "bar"], track: [] }),
+		);
+		const r = await resolveGitignore(projectDir, { homeDir });
+		const fooRules = r.rules.filter((x) => x.pattern === "foo");
+		expect(fooRules.length).toBe(1);
+	});
+
+	it("does not mark same-action overrides as conflicts", async () => {
+		await writeFile(
+			join(homeDir, ".claude", "gitignore.json"),
+			JSON.stringify({ ignore: [".env"], track: [] }),
+		);
+		await writeFile(
+			join(projectDir, ".claude", "gitignore.json"),
+			JSON.stringify({ ignore: [".env"], track: [] }),
+		);
+		const r = await resolveGitignore(projectDir, { homeDir });
+		expect(r.conflicts.find((c) => c.pattern === ".env")).toBeUndefined();
+	});
+
+	it("records conflict losers across multiple tiers", async () => {
+		// built-in ignores .claude/settings.local.json; global tracks it; project ignores it again
+		await writeFile(
+			join(homeDir, ".claude", "gitignore.json"),
+			JSON.stringify({ ignore: [], track: [".claude/settings.local.json"] }),
+		);
+		await writeFile(
+			join(projectDir, ".claude", "gitignore.json"),
+			JSON.stringify({ ignore: [".claude/settings.local.json"], track: [] }),
+		);
+		const r = await resolveGitignore(projectDir, { homeDir });
+		const winner = r.rules.find(
+			(x) => x.pattern === ".claude/settings.local.json",
+		);
+		expect(winner?.action).toBe("ignore");
+		expect(winner?.source).toBe("project");
+		const conflict = r.conflicts.find(
+			(c) => c.pattern === ".claude/settings.local.json",
+		);
+		expect(conflict?.winner).toBe("project");
+		expect(
+			conflict?.losers.some((l) => l.tier === "global" && l.action === "track"),
+		).toBe(true);
+	});
+});

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

@@ -0,0 +1,137 @@
+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 {
+	applyTemplate,
+	ensureProjectManifestForEdit,
+	loadGitignoreState,
+} from "../services/gitignore-service";
+
+function git(cwd: string, ...args: string[]): void {
+	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);
+	});
+});
+
+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/,
+		);
+	});
+});
+
+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"]);
+	});
+});

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("");
+	});
+});