claudeup 4.15.1 → 4.17.0

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

@@ -0,0 +1,93 @@
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
+import { mkdtemp, rm, writeFile, mkdir, readFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { spawnSync } from "node:child_process";
+import {
+  loadGitignoreState,
+  applyTemplate,
+} 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/,
+    );
+  });
+});

package/src/__tests__/useGitignoreModal.test.ts

@@ -0,0 +1,71 @@
+import { describe, it, expect } from "bun:test";
+import { buildGitignoreModal } from "../ui/hooks/useGitignoreModal";
+
+describe("buildGitignoreModal", () => {
+  it("builds a select modal with three options", () => {
+    let dismissed = false;
+    let fixed = false;
+    let opened = false;
+    const modal = buildGitignoreModal({
+      violationCount: 5,
+      safeCount: 3,
+      onFixSafe: () => { fixed = true; },
+      onOpenTab: () => { opened = true; },
+      onDismiss: () => { dismissed = true; },
+    });
+    expect(modal.type).toBe("select");
+    if (modal.type !== "select") throw new Error("type guard");
+    expect(modal.options.length).toBe(3);
+    expect(modal.options[0].value).toBe("fix-safe");
+    expect(modal.options[1].value).toBe("open-tab");
+    expect(modal.options[2].value).toBe("dismiss");
+    expect(modal.options[0].label).toContain("3");
+
+    modal.onSelect("fix-safe");
+    expect(fixed).toBe(true);
+
+    modal.onSelect("open-tab");
+    expect(opened).toBe(true);
+
+    modal.onSelect("dismiss");
+    expect(dismissed).toBe(true);
+  });
+
+  it("shows '(no safe-fixable entries)' label when safeCount is 0", () => {
+    const modal = buildGitignoreModal({
+      violationCount: 2,
+      safeCount: 0,
+      onFixSafe: () => {},
+      onOpenTab: () => {},
+      onDismiss: () => {},
+    });
+    if (modal.type !== "select") throw new Error("type guard");
+    expect(modal.options[0].label).toContain("no safe-fixable");
+  });
+
+  it("includes violation count in the message", () => {
+    const modal = buildGitignoreModal({
+      violationCount: 7,
+      safeCount: 2,
+      onFixSafe: () => {},
+      onOpenTab: () => {},
+      onDismiss: () => {},
+    });
+    if (modal.type !== "select") throw new Error("type guard");
+    expect(modal.message).toContain("7");
+  });
+
+  it("calls onCancel as dismiss", () => {
+    let dismissed = false;
+    const modal = buildGitignoreModal({
+      violationCount: 1,
+      safeCount: 0,
+      onFixSafe: () => {},
+      onOpenTab: () => {},
+      onDismiss: () => { dismissed = true; },
+    });
+    if (modal.type !== "select") throw new Error("type guard");
+    modal.onCancel();
+    expect(dismissed).toBe(true);
+  });
+});

package/src/data/gitignore-defaults.js

@@ -0,0 +1,24 @@
+/**
+ * Conservative built-in defaults. These ship inside claudeup and apply to
+ * every project unless overridden by a global or project manifest. Kept narrow
+ * on purpose — broader patterns (node_modules, .env, .DS_Store, …) live in the
+ * "common-dev" template which users opt into via `extends`.
+ */
+export const BUILTIN_DEFAULTS = {
+    ignore: [
+        ".claude/settings.local.json",
+        ".claude/scheduled_tasks.lock",
+        ".claude/cache/",
+        ".claude/.statusline-worktree-*",
+        "ai-docs/sessions/",
+        ".mnemex/",
+        ".claudemem/",
+        "gtd/sessions/",
+        ".agents/",
+    ],
+    track: [
+        ".claude/settings.json",
+        ".mcp.json",
+        "plugin.json",
+    ],
+};

package/src/data/gitignore-defaults.ts

@@ -0,0 +1,26 @@
+import type { GitignoreManifest } from "../types/gitignore.js";
+
+/**
+ * Conservative built-in defaults. These ship inside claudeup and apply to
+ * every project unless overridden by a global or project manifest. Kept narrow
+ * on purpose — broader patterns (node_modules, .env, .DS_Store, …) live in the
+ * "common-dev" template which users opt into via `extends`.
+ */
+export const BUILTIN_DEFAULTS: GitignoreManifest = {
+  ignore: [
+    ".claude/settings.local.json",
+    ".claude/scheduled_tasks.lock",
+    ".claude/cache/",
+    ".claude/.statusline-worktree-*",
+    "ai-docs/sessions/",
+    ".mnemex/",
+    ".claudemem/",
+    "gtd/sessions/",
+    ".agents/",
+  ],
+  track: [
+    ".claude/settings.json",
+    ".mcp.json",
+    "plugin.json",
+  ],
+};

package/src/data/gitignore-templates.js

@@ -0,0 +1,21 @@
+/**
+ * Opt-in templates a user manifest can pull in via `extends`. Kept separate
+ * from BUILTIN_DEFAULTS so the active baseline stays minimal — these only
+ * apply when explicitly requested.
+ */
+export const BUILTIN_TEMPLATES = {
+    "common-dev": {
+        ignore: [
+            "node_modules/",
+            ".env",
+            ".env.local",
+            ".DS_Store",
+            "dist/",
+            "build/",
+            "*.log",
+            "coverage/",
+            ".cache/",
+        ],
+        track: [],
+    },
+};

package/src/data/gitignore-templates.ts

@@ -0,0 +1,25 @@
+import type { GitignoreManifest } from "../types/gitignore.js";
+
+/**
+ * Opt-in templates a user manifest can pull in via `extends`. Kept separate
+ * from BUILTIN_DEFAULTS so the active baseline stays minimal — these only
+ * apply when explicitly requested.
+ */
+export const BUILTIN_TEMPLATES: Record<string, GitignoreManifest> = {
+  "common-dev": {
+    ignore: [
+      "node_modules/",
+      ".env",
+      ".env.local",
+      ".DS_Store",
+      "dist/",
+      "build/",
+      "*.log",
+      "coverage/",
+      ".cache/",
+    ],
+    track: [],
+  },
+};
+
+export type BuiltinTemplateName = keyof typeof BUILTIN_TEMPLATES;

package/src/data/marketplaces.js

@@ -41,6 +41,15 @@ export const defaultMarketplaces = [
         description: "Official Anthropic-managed directory of high quality Claude Code plugins",
         official: true,
     },
+    {
+        name: "superpowers",
+        displayName: "Superpowers",
+        source: {
+            source: "github",
+            repo: "obra/superpowers",
+        },
+        description: "Jesse Vincent's agentic skills framework and software development methodology",
+    },
     {
         name: "claude-code-plugins",
         displayName: "Anthropic Deprecated",
@@ -50,6 +59,7 @@ export const defaultMarketplaces = [
         },
         description: "Legacy demo plugins from Anthropic (deprecated - use Official instead)",
         official: true,
+        deprecated: true,
     },
 ];
 export function getMarketplaceByName(name) {
@@ -93,6 +103,7 @@ export function getAllMarketplaces(localMarketplaces) {
                 description: defaultMp?.description || local.description || "",
                 official: defaultMp?.official ?? repo.toLowerCase().includes("anthropics/"),
                 featured: defaultMp?.featured,
+                deprecated: defaultMp?.deprecated,
             });
         }
     }
@@ -105,7 +116,7 @@ export function getAllMarketplaces(localMarketplaces) {
                 seenRepos.add(repo);
         }
     }
-    // Sort: Magus first, then alphabetically
+    // Sort: Magus first, deprecated last, then alphabetically
     return Array.from(all.values()).sort((a, b) => {
         // Magus (MadAppGang) always first
         const aIsMag = a.source.repo?.toLowerCase().includes("madappgang/");
@@ -114,6 +125,11 @@ export function getAllMarketplaces(localMarketplaces) {
             return -1;
         if (!aIsMag && bIsMag)
             return 1;
+        // Deprecated entries always last
+        if (a.deprecated && !b.deprecated)
+            return 1;
+        if (!a.deprecated && b.deprecated)
+            return -1;
         // Then alphabetically by display name
         return (a.displayName || a.name).localeCompare(b.displayName || b.name);
     });

package/src/data/marketplaces.ts

@@ -49,6 +49,16 @@ export const defaultMarketplaces: Marketplace[] = [
 			"Official Anthropic-managed directory of high quality Claude Code plugins",
 		official: true,
 	},
+	{
+		name: "superpowers",
+		displayName: "Superpowers",
+		source: {
+			source: "github",
+			repo: "obra/superpowers",
+		},
+		description:
+			"Jesse Vincent's agentic skills framework and software development methodology",
+	},
 	{
 		name: "claude-code-plugins",
 		displayName: "Anthropic Deprecated",
@@ -59,6 +69,7 @@ export const defaultMarketplaces: Marketplace[] = [
 		description:
 			"Legacy demo plugins from Anthropic (deprecated - use Official instead)",
 		official: true,
+		deprecated: true,
 	},
 ];
 
@@ -113,6 +124,7 @@ export function getAllMarketplaces(
 				official:
 					defaultMp?.official ?? repo.toLowerCase().includes("anthropics/"),
 				featured: defaultMp?.featured,
+				deprecated: defaultMp?.deprecated,
 			});
 		}
 	}
@@ -126,13 +138,16 @@ export function getAllMarketplaces(
 		}
 	}
 
-	// Sort: Magus first, then alphabetically
+	// Sort: Magus first, deprecated last, then alphabetically
 	return Array.from(all.values()).sort((a, b) => {
 		// Magus (MadAppGang) always first
 		const aIsMag = a.source.repo?.toLowerCase().includes("madappgang/");
 		const bIsMag = b.source.repo?.toLowerCase().includes("madappgang/");
 		if (aIsMag && !bIsMag) return -1;
 		if (!aIsMag && bIsMag) return 1;
+		// Deprecated entries always last
+		if (a.deprecated && !b.deprecated) return 1;
+		if (!a.deprecated && b.deprecated) return -1;
 		// Then alphabetically by display name
 		return (a.displayName || a.name).localeCompare(b.displayName || b.name);
 	});

package/src/prerunner/index.js

@@ -8,6 +8,7 @@ import { recoverMarketplaceSettings, migrateMarketplaceRename, cleanupExtraKnown
 import { checkPluginVersionMismatches, formatMismatchWarning, } from "../services/plugin-version-check.js";
 import { updatePlugin, isClaudeAvailable } from "../services/claude-cli.js";
 import { autoAddMissingMarketplaces } from "../services/marketplace-sync.js";
+import { checkGitignore, formatPrerunWarning as formatGitignoreWarning, } from "../services/gitignore-prerun.js";
 const CONTINUITY_PLUGIN_SENTINEL = "tmux-claude-continuity";
 const CONTINUITY_PLUGIN_SCRIPT = path.join(os.homedir(), ".tmux", "plugins", "tmux-claude-continuity", "scripts", "on_session_start.sh");
 /**
@@ -139,6 +140,22 @@ export async function prerunClaude(claudeArgs, options = {}) {
         catch {
             // Non-fatal: mismatch detection is best-effort
         }
+        // STEP 0.9: Detect gitignore manifest violations. Warn-only here — the
+        // fix dialog lives in the TUI Gitignore tab, mirroring the plugin
+        // version-mismatch flow (since destructive fixes need user confirmation).
+        try {
+            const cwd = process.cwd();
+            const result = await checkGitignore(cwd);
+            const warning = formatGitignoreWarning(result);
+            if (warning) {
+                console.warn("");
+                console.warn(warning);
+                console.warn("");
+            }
+        }
+        catch {
+            // Non-fatal: gitignore detection is best-effort
+        }
         // STEP 1: Check if we should update (time-based cache, or forced)
         const shouldUpdate = options.force || (await cache.shouldCheckForUpdates());
         if (options.force) {

package/src/prerunner/index.ts

@@ -22,6 +22,10 @@ import {
 } from "../services/plugin-version-check.js";
 import { updatePlugin, isClaudeAvailable } from "../services/claude-cli.js";
 import { autoAddMissingMarketplaces } from "../services/marketplace-sync.js";
+import {
+	checkGitignore,
+	formatPrerunWarning as formatGitignoreWarning,
+} from "../services/gitignore-prerun.js";
 
 export interface PrerunOptions {
 	force?: boolean; // Bypass cache and force update check
@@ -194,6 +198,22 @@ export async function prerunClaude(
 			// Non-fatal: mismatch detection is best-effort
 		}
 
+		// STEP 0.9: Detect gitignore manifest violations. Warn-only here — the
+		// fix dialog lives in the TUI Gitignore tab, mirroring the plugin
+		// version-mismatch flow (since destructive fixes need user confirmation).
+		try {
+			const cwd = process.cwd();
+			const result = await checkGitignore(cwd);
+			const warning = formatGitignoreWarning(result);
+			if (warning) {
+				console.warn("");
+				console.warn(warning);
+				console.warn("");
+			}
+		} catch {
+			// Non-fatal: gitignore detection is best-effort
+		}
+
 		// STEP 1: Check if we should update (time-based cache, or forced)
 		const shouldUpdate = options.force || (await cache.shouldCheckForUpdates());
 

package/src/services/gitignore-detector.js

@@ -0,0 +1,155 @@
+/**
+ * Detect violations of the resolved gitignore manifest against a working
+ * tree. Emits one Violation per offending path.
+ *
+ * Strategy:
+ *   - For ignore rules: ask `git ls-files` whether the path (or anything
+ *     under it for directory-style rules) is currently tracked. If so,
+ *     it's "tracked-but-should-ignore" (destructive). Then check whether
+ *     the existing .gitignore covers the path; if not, that's
+ *     "missing-from-gitignore" (safe additive fix).
+ *   - For track rules: ask `git check-ignore` whether the path is being
+ *     excluded by the current .gitignore. If yes, "ignored-but-should-track"
+ *     (destructive — must remove the .gitignore line). If the path exists
+ *     on disk but isn't tracked and isn't ignored, "untracked-and-should-track".
+ *
+ * Glob expansion is intentionally limited: we treat patterns as literals
+ * with directory-suffix awareness ("foo/" matches anything under foo/).
+ * Full gitignore-syntax glob expansion is deferred — git itself handles
+ * the heavy lifting via ls-files / check-ignore.
+ */
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+export async function detectViolations(cwd, resolved) {
+    if (!(await isGitRepo(cwd)))
+        return [];
+    const violations = [];
+    const trackedFiles = await listTrackedFiles(cwd);
+    const trackedSet = new Set(trackedFiles);
+    for (const rule of resolved.rules) {
+        if (rule.action === "ignore") {
+            const tracked = matchesTrackedFile(rule.pattern, trackedSet);
+            if (tracked.length > 0) {
+                for (const path of tracked) {
+                    violations.push({
+                        kind: "tracked-but-should-ignore",
+                        path,
+                        source: rule.source,
+                        severity: "destructive",
+                    });
+                }
+            }
+            else {
+                // Not tracked — check if .gitignore covers it. If not, suggest
+                // a safe additive fix (append to .gitignore).
+                const ignored = await pathIsIgnored(cwd, rule.pattern);
+                if (!ignored) {
+                    violations.push({
+                        kind: "missing-from-gitignore",
+                        path: rule.pattern,
+                        source: rule.source,
+                        severity: "safe",
+                    });
+                }
+            }
+        }
+        else {
+            // action === "track"
+            const ignored = await pathIsIgnored(cwd, rule.pattern);
+            if (ignored) {
+                violations.push({
+                    kind: "ignored-but-should-track",
+                    path: rule.pattern,
+                    source: rule.source,
+                    severity: "destructive",
+                });
+                continue;
+            }
+            const isTracked = trackedSet.has(rule.pattern);
+            const existsOnDisk = existsSync(join(cwd, rule.pattern));
+            if (existsOnDisk && !isTracked) {
+                violations.push({
+                    kind: "untracked-and-should-track",
+                    path: rule.pattern,
+                    source: rule.source,
+                    severity: "destructive",
+                });
+            }
+        }
+    }
+    return violations;
+}
+/**
+ * Match a pattern against the tracked-files set. Directory-style patterns
+ * (trailing "/") match every tracked path under that prefix.
+ */
+function matchesTrackedFile(pattern, tracked) {
+    if (pattern.endsWith("/")) {
+        const prefix = pattern;
+        return Array.from(tracked).filter((p) => p.startsWith(prefix));
+    }
+    if (pattern.includes("*")) {
+        // Very limited literal-prefix glob handling. Full expansion is git's job.
+        const star = pattern.indexOf("*");
+        const prefix = pattern.slice(0, star);
+        return Array.from(tracked).filter((p) => p.startsWith(prefix));
+    }
+    return tracked.has(pattern) ? [pattern] : [];
+}
+async function isGitRepo(cwd) {
+    try {
+        await runGit(["rev-parse", "--is-inside-work-tree"], cwd);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function listTrackedFiles(cwd) {
+    try {
+        const out = await runGit(["ls-files"], cwd);
+        return out.split("\n").map((l) => l.trim()).filter(Boolean);
+    }
+    catch {
+        return [];
+    }
+}
+async function pathIsIgnored(cwd, path) {
+    try {
+        // git check-ignore exits 0 when path IS ignored, 1 when NOT, >1 on error.
+        await runGit(["check-ignore", "--quiet", "--", path], cwd);
+        return true;
+    }
+    catch (err) {
+        // exit code 1 = not ignored (expected), anything else swallowed.
+        if (err instanceof GitError && err.code === 1)
+            return false;
+        return false;
+    }
+}
+class GitError extends Error {
+    code;
+    stderr;
+    constructor(code, stderr) {
+        super(`git exited ${code}: ${stderr}`);
+        this.code = code;
+        this.stderr = stderr;
+    }
+}
+function runGit(args, cwd) {
+    return new Promise((resolve, reject) => {
+        const proc = spawn("git", args, { cwd });
+        let stdout = "";
+        let stderr = "";
+        proc.stdout.on("data", (b) => { stdout += b.toString(); });
+        proc.stderr.on("data", (b) => { stderr += b.toString(); });
+        proc.on("error", reject);
+        proc.on("close", (code) => {
+            if (code === 0)
+                resolve(stdout);
+            else
+                reject(new GitError(code ?? -1, stderr));
+        });
+    });
+}