claudeup 4.15.0 → 4.16.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudeup",
-  "version": "4.15.0",
+  "version": "4.16.0",
   "description": "TUI tool for managing Claude Code plugins, MCPs, and configuration",
   "type": "module",
   "main": "src/main.tsx",

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

@@ -0,0 +1,156 @@
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
+import { mkdtemp, rm, writeFile, mkdir } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { spawnSync } from "node:child_process";
+import { detectViolations } from "../services/gitignore-detector";
+import type { ResolvedManifest } from "../types/gitignore";
+
+function git(cwd: string, ...args: string[]): string {
+  // core.excludesFile=/dev/null bypasses the developer's global gitignore
+  // so the test environment doesn't leak into the result.
+  const r = spawnSync("git", ["-c", "core.excludesFile=/dev/null", ...args], {
+    cwd,
+    encoding: "utf8",
+  });
+  if (r.status !== 0) {
+    throw new Error(`git ${args.join(" ")} failed: ${r.stderr}`);
+  }
+  return r.stdout;
+}
+
+async function makeRepo(): Promise<string> {
+  const dir = await mkdtemp(join(tmpdir(), "gitig-det-"));
+  git(dir, "init", "-q");
+  git(dir, "config", "user.email", "test@test");
+  git(dir, "config", "user.name", "test");
+  return dir;
+}
+
+function manifest(rules: ResolvedManifest["rules"]): ResolvedManifest {
+  return { rules, conflicts: [] };
+}
+
+describe("detectViolations", () => {
+  let repo: string;
+
+  beforeEach(async () => {
+    repo = await makeRepo();
+  });
+
+  afterEach(async () => {
+    await rm(repo, { recursive: true, force: true });
+  });
+
+  it("returns empty for non-git directory", async () => {
+    const tmp = await mkdtemp(join(tmpdir(), "gitig-nogit-"));
+    try {
+      const r = await detectViolations(
+        tmp,
+        manifest([{ pattern: ".env", action: "ignore", source: "builtin" }]),
+      );
+      expect(r).toEqual([]);
+    } finally {
+      await rm(tmp, { recursive: true, force: true });
+    }
+  });
+
+  it("flags tracked-but-should-ignore for a tracked file", async () => {
+    await writeFile(join(repo, "secret.txt"), "x");
+    git(repo, "add", "secret.txt");
+    git(repo, "commit", "-q", "-m", "add secret");
+
+    const r = await detectViolations(
+      repo,
+      manifest([{ pattern: "secret.txt", action: "ignore", source: "project" }]),
+    );
+    expect(r.length).toBe(1);
+    expect(r[0].kind).toBe("tracked-but-should-ignore");
+    expect(r[0].severity).toBe("destructive");
+    expect(r[0].path).toBe("secret.txt");
+  });
+
+  it("flags missing-from-gitignore when path neither tracked nor in .gitignore", async () => {
+    const r = await detectViolations(
+      repo,
+      manifest([{ pattern: ".env", action: "ignore", source: "builtin" }]),
+    );
+    expect(r.length).toBe(1);
+    expect(r[0].kind).toBe("missing-from-gitignore");
+    expect(r[0].severity).toBe("safe");
+  });
+
+  it("does NOT flag missing-from-gitignore when .gitignore already covers the path", async () => {
+    await writeFile(join(repo, ".gitignore"), ".env\n");
+    const r = await detectViolations(
+      repo,
+      manifest([{ pattern: ".env", action: "ignore", source: "builtin" }]),
+    );
+    expect(r).toEqual([]);
+  });
+
+  it("flags ignored-but-should-track when track rule is excluded by .gitignore", async () => {
+    await writeFile(join(repo, ".gitignore"), ".mcp.json\n");
+    await writeFile(join(repo, ".mcp.json"), "{}");
+    const r = await detectViolations(
+      repo,
+      manifest([{ pattern: ".mcp.json", action: "track", source: "builtin" }]),
+    );
+    expect(r.length).toBe(1);
+    expect(r[0].kind).toBe("ignored-but-should-track");
+    expect(r[0].severity).toBe("destructive");
+  });
+
+  it("flags untracked-and-should-track when path exists but isn't tracked", async () => {
+    await writeFile(join(repo, ".mcp.json"), "{}");
+    const r = await detectViolations(
+      repo,
+      manifest([{ pattern: ".mcp.json", action: "track", source: "builtin" }]),
+    );
+    expect(r.length).toBe(1);
+    expect(r[0].kind).toBe("untracked-and-should-track");
+    expect(r[0].severity).toBe("destructive");
+  });
+
+  it("does NOT flag track rule when path is already tracked", async () => {
+    await writeFile(join(repo, ".mcp.json"), "{}");
+    git(repo, "add", ".mcp.json");
+    git(repo, "commit", "-q", "-m", "add mcp");
+    const r = await detectViolations(
+      repo,
+      manifest([{ pattern: ".mcp.json", action: "track", source: "builtin" }]),
+    );
+    expect(r).toEqual([]);
+  });
+
+  it("matches directory patterns against tracked subpaths", async () => {
+    await mkdir(join(repo, "ai-docs", "sessions"), { recursive: true });
+    await writeFile(join(repo, "ai-docs", "sessions", "leak.md"), "x");
+    git(repo, "add", "ai-docs/sessions/leak.md");
+    git(repo, "commit", "-q", "-m", "leak");
+
+    const r = await detectViolations(
+      repo,
+      manifest([{ pattern: "ai-docs/sessions/", action: "ignore", source: "builtin" }]),
+    );
+    expect(r.length).toBeGreaterThan(0);
+    expect(r[0].kind).toBe("tracked-but-should-ignore");
+    expect(r[0].path).toBe("ai-docs/sessions/leak.md");
+  });
+
+  it("returns no violations when manifest is satisfied", async () => {
+    await writeFile(join(repo, ".gitignore"), ".env\n");
+    await writeFile(join(repo, ".mcp.json"), "{}");
+    git(repo, "add", ".gitignore", ".mcp.json");
+    git(repo, "commit", "-q", "-m", "init");
+
+    const r = await detectViolations(
+      repo,
+      manifest([
+        { pattern: ".env", action: "ignore", source: "builtin" },
+        { pattern: ".mcp.json", action: "track", source: "builtin" },
+      ]),
+    );
+    expect(r).toEqual([]);
+  });
+});

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

@@ -0,0 +1,197 @@
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
+import { mkdtemp, rm, writeFile, readFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { spawnSync } from "node:child_process";
+import {
+  applySafeFixes,
+  applyDestructiveFix,
+  formatViolationSummary,
+} from "../services/gitignore-fixer";
+import type { Violation } from "../types/gitignore";
+
+function git(cwd: string, ...args: string[]): { stdout: string; status: number } {
+  const r = spawnSync("git", ["-c", "core.excludesFile=/dev/null", ...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 claudeup");
+  });
+
+  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("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-prerun.test.ts

@@ -0,0 +1,75 @@
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
+import { mkdtemp, rm, writeFile, mkdir } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { spawnSync } from "node:child_process";
+import {
+  checkGitignore,
+  formatPrerunWarning,
+} from "../services/gitignore-prerun";
+
+function git(cwd: string, ...args: string[]): void {
+  spawnSync("git", ["-c", "core.excludesFile=/dev/null", ...args], { cwd });
+}
+
+describe("checkGitignore", () => {
+  let projectDir: string;
+
+  beforeEach(async () => {
+    projectDir = await mkdtemp(join(tmpdir(), "gitig-prerun-"));
+  });
+
+  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("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-*",
+        "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 a warning string when violations exist", () => {
+    const w = formatPrerunWarning({ violationCount: 3, warnings: [] });
+    expect(w).not.toBeNull();
+    expect(w).toContain("3 gitignore");
+    expect(w).toContain("Gitignore tab");
+  });
+});

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

@@ -0,0 +1,166 @@
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
+import { mkdtemp, rm, writeFile, mkdir } 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";
+
+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);
+  });
+});