claudeup 6.2.1 → 6.3.0

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

@@ -1,12 +1,12 @@
-import { describe, it, expect, beforeEach, afterEach } from "bun:test";
-import { mkdtemp, rm, writeFile, readFile, mkdir } 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 {
-  applySafeFixes,
-  applyDestructiveFix,
-  formatViolationSummary,
+	applyDestructiveFix,
+	applySafeFixes,
+	formatViolationSummary,
 } from "../services/gitignore-fixer";
 import type { Violation } from "../types/gitignore";
 
@@ -21,259 +21,297 @@ import type { Violation } from "../types/gitignore";
 // 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",
+	"-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 };
+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;
+	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 claudeup");
-    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");
-  });
+	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 claudeup");
+		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");
-  });
+	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");
-  });
+	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");
+	});
 });