claudeup 6.2.1 → 6.3.0

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

@@ -1,76 +1,76 @@
-import { describe, it, expect, beforeEach, afterEach } from "bun:test";
-import { mkdtemp, rm, writeFile, mkdir } from "node:fs/promises";
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
+import { spawnSync } from "node:child_process";
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { spawnSync } from "node:child_process";
 import {
-  checkGitignore,
-  formatPrerunWarning,
+	checkGitignore,
+	formatPrerunWarning,
 } from "../services/gitignore-prerun";
 
 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("checkGitignore", () => {
-  let projectDir: string;
+	let projectDir: string;
 
-  beforeEach(async () => {
-    projectDir = await mkdtemp(join(tmpdir(), "gitig-prerun-"));
-  });
+	beforeEach(async () => {
+		projectDir = await mkdtemp(join(tmpdir(), "gitig-prerun-"));
+	});
 
-  afterEach(async () => {
-    await rm(projectDir, { recursive: true, force: true });
-  });
+	afterEach(async () => {
+		await rm(projectDir, { recursive: true, force: true });
+	});
 
-  it("returns 0 violations for non-git directory", async () => {
-    const r = await checkGitignore(projectDir);
-    expect(r.violationCount).toBe(0);
-  });
+	it("returns 0 violations for non-git directory", async () => {
+		const r = await checkGitignore(projectDir);
+		expect(r.violationCount).toBe(0);
+	});
 
-  it("flags missing built-in patterns inside a fresh git repo", async () => {
-    git(projectDir, "init", "-q");
-    const r = await checkGitignore(projectDir);
-    // BUILTIN_DEFAULTS includes ".mnemex/" etc. — none are tracked, none in
-    // .gitignore, so each one becomes "missing-from-gitignore".
-    expect(r.violationCount).toBeGreaterThan(0);
-  });
+	it("flags missing built-in patterns inside a fresh git repo", async () => {
+		git(projectDir, "init", "-q");
+		const r = await checkGitignore(projectDir);
+		// BUILTIN_DEFAULTS includes ".mnemex/" etc. — none are tracked, none in
+		// .gitignore, so each one becomes "missing-from-gitignore".
+		expect(r.violationCount).toBeGreaterThan(0);
+	});
 
-  it("returns 0 when .gitignore covers all built-in patterns and tracked files match track rules", async () => {
-    git(projectDir, "init", "-q");
-    git(projectDir, "config", "user.email", "t@t");
-    git(projectDir, "config", "user.name", "t");
-    // Suppress all built-in ignore rules
-    await writeFile(
-      join(projectDir, ".gitignore"),
-      [
-        ".claude/settings.local.json",
-        ".claude/scheduled_tasks.lock",
-        ".claude/cache/",
-        ".claude/.statusline-worktree-*",
-        ".claude/_profiles/",
-        "ai-docs/sessions/",
-        ".mnemex/",
-        ".claudemem/",
-        "gtd/sessions/",
-        ".agents/",
-      ].join("\n") + "\n",
-    );
-    // Tracked files don't have to exist for the absent-track-path case to be ignored
-    const r = await checkGitignore(projectDir);
-    expect(r.violationCount).toBe(0);
-  });
+	it("returns 0 when .gitignore covers all built-in patterns and tracked files match track rules", async () => {
+		git(projectDir, "init", "-q");
+		git(projectDir, "config", "user.email", "t@t");
+		git(projectDir, "config", "user.name", "t");
+		// Suppress all built-in ignore rules
+		await writeFile(
+			join(projectDir, ".gitignore"),
+			`${[
+				".claude/settings.local.json",
+				".claude/scheduled_tasks.lock",
+				".claude/cache/",
+				".claude/.statusline-worktree-*",
+				".claude/_profiles/",
+				"ai-docs/sessions/",
+				".mnemex/",
+				".claudemem/",
+				"gtd/sessions/",
+				".agents/",
+			].join("\n")}\n`,
+		);
+		// Tracked files don't have to exist for the absent-track-path case to be ignored
+		const r = await checkGitignore(projectDir);
+		expect(r.violationCount).toBe(0);
+	});
 });
 
 describe("formatPrerunWarning", () => {
-  it("returns null when no violations", () => {
-    expect(formatPrerunWarning({ violationCount: 0, warnings: [] })).toBeNull();
-  });
+	it("returns null when no violations", () => {
+		expect(formatPrerunWarning({ violationCount: 0, warnings: [] })).toBeNull();
+	});
 
-  it("returns a warning string when violations exist", () => {
-    const w = formatPrerunWarning({ violationCount: 3, warnings: [] });
-    expect(w).not.toBeNull();
-    expect(w).toContain("3 git state");
-    expect(w).toContain("Git State tab");
-  });
+	it("returns a warning string when violations exist", () => {
+		const w = formatPrerunWarning({ violationCount: 3, warnings: [] });
+		expect(w).not.toBeNull();
+		expect(w).toContain("3 git state");
+		expect(w).toContain("Git State tab");
+	});
 });

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

@@ -1,166 +1,193 @@
-import { describe, it, expect, beforeEach, afterEach } from "bun:test";
-import { mkdtemp, rm, writeFile, mkdir } from "node:fs/promises";
+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 { resolveGitignore } from "../services/gitignore-resolver";
 import { BUILTIN_DEFAULTS } from "../data/gitignore-defaults";
+import { resolveGitignore } from "../services/gitignore-resolver";
 
 describe("resolveGitignore", () => {
-  let projectDir: string;
-  let homeDir: string;
+	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 });
-  });
+	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 });
-  });
+	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("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"] }),
-    );
+	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");
-  });
+		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("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("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("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("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 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("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("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("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);
-  });
+	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);
+	});
 });