claudeup 4.15.1 → 4.16.0

package/src/services/gitignore-fixer.js

@@ -0,0 +1,171 @@
+/**
+ * Apply fixes for gitignore violations. Two flavors:
+ *
+ *   - `applySafeFixes`: additive — appends missing patterns to .gitignore
+ *     under a "# Added by claudeup" header. Idempotent (re-running is a no-op
+ *     because patterns are already present).
+ *
+ *   - `applyDestructiveFix`: index-mutating — runs `git rm --cached <path>`
+ *     for tracked-but-should-ignore, `git add <path>` (after stripping
+ *     gitignore lines) for ignored-but-should-track / untracked-and-should-track.
+ *     Each call handles ONE violation; the caller is responsible for confirming
+ *     each one with the user.
+ *
+ * `formatViolationSummary` is a pure helper for prerun warning + TUI.
+ */
+import { readFile, writeFile, appendFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { spawn } from "node:child_process";
+const CLAUDEUP_HEADER = "# Added by claudeup";
+export async function applySafeFixes(cwd, violations) {
+    const safe = violations.filter((v) => v.severity === "safe" && v.kind === "missing-from-gitignore");
+    if (safe.length === 0) {
+        return { appended: [], alreadyPresent: [] };
+    }
+    const gitignorePath = join(cwd, ".gitignore");
+    const existing = existsSync(gitignorePath)
+        ? await readFile(gitignorePath, "utf8")
+        : "";
+    const lines = new Set(existing.split("\n").map((l) => l.trim()).filter(Boolean));
+    const appended = [];
+    const alreadyPresent = [];
+    for (const v of safe) {
+        if (lines.has(v.path)) {
+            alreadyPresent.push(v.path);
+        }
+        else {
+            appended.push(v.path);
+            lines.add(v.path);
+        }
+    }
+    if (appended.length === 0)
+        return { appended, alreadyPresent };
+    const block = [
+        "",
+        CLAUDEUP_HEADER,
+        ...appended,
+        "",
+    ].join("\n");
+    if (existing.length > 0 && !existing.endsWith("\n")) {
+        await appendFile(gitignorePath, "\n" + block);
+    }
+    else {
+        await appendFile(gitignorePath, block);
+    }
+    return { appended, alreadyPresent };
+}
+export async function applyDestructiveFix(cwd, violation) {
+    switch (violation.kind) {
+        case "tracked-but-should-ignore": {
+            await runGit(["rm", "--cached", "--", violation.path], cwd);
+            // Then make sure .gitignore has the entry so it stays out
+            await appendIfMissing(cwd, violation.path);
+            return {
+                applied: true,
+                message: `Removed ${violation.path} from index and added to .gitignore`,
+            };
+        }
+        case "ignored-but-should-track": {
+            await stripGitignoreLine(cwd, violation.path);
+            try {
+                await runGit(["add", "--", violation.path], cwd);
+            }
+            catch (err) {
+                return {
+                    applied: false,
+                    message: `Removed .gitignore line but git add failed: ${err instanceof Error ? err.message : String(err)}`,
+                };
+            }
+            return {
+                applied: true,
+                message: `Removed .gitignore line and staged ${violation.path}`,
+            };
+        }
+        case "untracked-and-should-track": {
+            await runGit(["add", "--", violation.path], cwd);
+            return { applied: true, message: `Staged ${violation.path}` };
+        }
+        case "missing-from-gitignore": {
+            // Treat as a safe append for symmetry — caller can route through here too.
+            await appendIfMissing(cwd, violation.path);
+            return { applied: true, message: `Added ${violation.path} to .gitignore` };
+        }
+    }
+}
+export function formatViolationSummary(violations) {
+    if (violations.length === 0)
+        return "No gitignore issues detected.";
+    const byKind = new Map();
+    for (const v of violations) {
+        const arr = byKind.get(v.kind) ?? [];
+        arr.push(v);
+        byKind.set(v.kind, arr);
+    }
+    const labels = {
+        "tracked-but-should-ignore": "tracked but should be ignored",
+        "ignored-but-should-track": "ignored but should be tracked",
+        "untracked-and-should-track": "exist but not tracked (should be)",
+        "missing-from-gitignore": "missing from .gitignore",
+    };
+    const lines = [];
+    for (const [kind, vs] of byKind.entries()) {
+        lines.push(`  ${labels[kind]}: ${vs.length}`);
+        for (const v of vs.slice(0, 5)) {
+            lines.push(`    - ${v.path}`);
+        }
+        if (vs.length > 5)
+            lines.push(`    … and ${vs.length - 5} more`);
+    }
+    return lines.join("\n");
+}
+async function appendIfMissing(cwd, pattern) {
+    const gitignorePath = join(cwd, ".gitignore");
+    const existing = existsSync(gitignorePath)
+        ? await readFile(gitignorePath, "utf8")
+        : "";
+    const lines = existing.split("\n").map((l) => l.trim());
+    if (lines.includes(pattern))
+        return;
+    const block = (existing.length > 0 && !existing.endsWith("\n") ? "\n" : "") +
+        `${CLAUDEUP_HEADER}\n${pattern}\n`;
+    await appendFile(gitignorePath, block);
+}
+async function stripGitignoreLine(cwd, pattern) {
+    const gitignorePath = join(cwd, ".gitignore");
+    if (!existsSync(gitignorePath))
+        return;
+    const content = await readFile(gitignorePath, "utf8");
+    const filtered = content
+        .split("\n")
+        .filter((line) => line.trim() !== pattern)
+        .join("\n");
+    if (filtered !== content) {
+        await writeFile(gitignorePath, filtered);
+    }
+}
+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));
+        });
+    });
+}

package/src/services/gitignore-fixer.ts

@@ -0,0 +1,198 @@
+/**
+ * Apply fixes for gitignore violations. Two flavors:
+ *
+ *   - `applySafeFixes`: additive — appends missing patterns to .gitignore
+ *     under a "# Added by claudeup" header. Idempotent (re-running is a no-op
+ *     because patterns are already present).
+ *
+ *   - `applyDestructiveFix`: index-mutating — runs `git rm --cached <path>`
+ *     for tracked-but-should-ignore, `git add <path>` (after stripping
+ *     gitignore lines) for ignored-but-should-track / untracked-and-should-track.
+ *     Each call handles ONE violation; the caller is responsible for confirming
+ *     each one with the user.
+ *
+ * `formatViolationSummary` is a pure helper for prerun warning + TUI.
+ */
+
+import { readFile, writeFile, appendFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { spawn } from "node:child_process";
+import type { Violation } from "../types/gitignore.js";
+
+const CLAUDEUP_HEADER = "# Added by claudeup";
+
+export interface SafeFixResult {
+  appended: string[];
+  alreadyPresent: string[];
+}
+
+export async function applySafeFixes(
+  cwd: string,
+  violations: Violation[],
+): Promise<SafeFixResult> {
+  const safe = violations.filter(
+    (v) => v.severity === "safe" && v.kind === "missing-from-gitignore",
+  );
+  if (safe.length === 0) {
+    return { appended: [], alreadyPresent: [] };
+  }
+
+  const gitignorePath = join(cwd, ".gitignore");
+  const existing = existsSync(gitignorePath)
+    ? await readFile(gitignorePath, "utf8")
+    : "";
+  const lines = new Set(
+    existing.split("\n").map((l) => l.trim()).filter(Boolean),
+  );
+
+  const appended: string[] = [];
+  const alreadyPresent: string[] = [];
+  for (const v of safe) {
+    if (lines.has(v.path)) {
+      alreadyPresent.push(v.path);
+    } else {
+      appended.push(v.path);
+      lines.add(v.path);
+    }
+  }
+
+  if (appended.length === 0) return { appended, alreadyPresent };
+
+  const block = [
+    "",
+    CLAUDEUP_HEADER,
+    ...appended,
+    "",
+  ].join("\n");
+
+  if (existing.length > 0 && !existing.endsWith("\n")) {
+    await appendFile(gitignorePath, "\n" + block);
+  } else {
+    await appendFile(gitignorePath, block);
+  }
+
+  return { appended, alreadyPresent };
+}
+
+export interface DestructiveFixResult {
+  applied: boolean;
+  message: string;
+}
+
+export async function applyDestructiveFix(
+  cwd: string,
+  violation: Violation,
+): Promise<DestructiveFixResult> {
+  switch (violation.kind) {
+    case "tracked-but-should-ignore": {
+      await runGit(["rm", "--cached", "--", violation.path], cwd);
+      // Then make sure .gitignore has the entry so it stays out
+      await appendIfMissing(cwd, violation.path);
+      return {
+        applied: true,
+        message: `Removed ${violation.path} from index and added to .gitignore`,
+      };
+    }
+    case "ignored-but-should-track": {
+      await stripGitignoreLine(cwd, violation.path);
+      try {
+        await runGit(["add", "--", violation.path], cwd);
+      } catch (err) {
+        return {
+          applied: false,
+          message: `Removed .gitignore line but git add failed: ${
+            err instanceof Error ? err.message : String(err)
+          }`,
+        };
+      }
+      return {
+        applied: true,
+        message: `Removed .gitignore line and staged ${violation.path}`,
+      };
+    }
+    case "untracked-and-should-track": {
+      await runGit(["add", "--", violation.path], cwd);
+      return { applied: true, message: `Staged ${violation.path}` };
+    }
+    case "missing-from-gitignore": {
+      // Treat as a safe append for symmetry — caller can route through here too.
+      await appendIfMissing(cwd, violation.path);
+      return { applied: true, message: `Added ${violation.path} to .gitignore` };
+    }
+  }
+}
+
+export function formatViolationSummary(violations: Violation[]): string {
+  if (violations.length === 0) return "No gitignore issues detected.";
+
+  const byKind = new Map<string, Violation[]>();
+  for (const v of violations) {
+    const arr = byKind.get(v.kind) ?? [];
+    arr.push(v);
+    byKind.set(v.kind, arr);
+  }
+
+  const labels: Record<Violation["kind"], string> = {
+    "tracked-but-should-ignore": "tracked but should be ignored",
+    "ignored-but-should-track":  "ignored but should be tracked",
+    "untracked-and-should-track":"exist but not tracked (should be)",
+    "missing-from-gitignore":    "missing from .gitignore",
+  };
+
+  const lines: string[] = [];
+  for (const [kind, vs] of byKind.entries()) {
+    lines.push(`  ${labels[kind as Violation["kind"]]}: ${vs.length}`);
+    for (const v of vs.slice(0, 5)) {
+      lines.push(`    - ${v.path}`);
+    }
+    if (vs.length > 5) lines.push(`    … and ${vs.length - 5} more`);
+  }
+  return lines.join("\n");
+}
+
+async function appendIfMissing(cwd: string, pattern: string): Promise<void> {
+  const gitignorePath = join(cwd, ".gitignore");
+  const existing = existsSync(gitignorePath)
+    ? await readFile(gitignorePath, "utf8")
+    : "";
+  const lines = existing.split("\n").map((l) => l.trim());
+  if (lines.includes(pattern)) return;
+  const block = (existing.length > 0 && !existing.endsWith("\n") ? "\n" : "") +
+    `${CLAUDEUP_HEADER}\n${pattern}\n`;
+  await appendFile(gitignorePath, block);
+}
+
+async function stripGitignoreLine(cwd: string, pattern: string): Promise<void> {
+  const gitignorePath = join(cwd, ".gitignore");
+  if (!existsSync(gitignorePath)) return;
+  const content = await readFile(gitignorePath, "utf8");
+  const filtered = content
+    .split("\n")
+    .filter((line) => line.trim() !== pattern)
+    .join("\n");
+  if (filtered !== content) {
+    await writeFile(gitignorePath, filtered);
+  }
+}
+
+class GitError extends Error {
+  constructor(public code: number, public stderr: string) {
+    super(`git exited ${code}: ${stderr}`);
+  }
+}
+
+function runGit(args: string[], cwd: string): Promise<string> {
+  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));
+    });
+  });
+}

package/src/services/gitignore-prerun.js

@@ -0,0 +1,46 @@
+/**
+ * Prerunner integration for the gitignore manager.
+ *
+ * Called from `prerunner/index.ts` (Step 0.9) on every claudeup invocation.
+ * Resolves the manifest, runs detection, and prints a concise warning when
+ * violations exist. Does NOT auto-apply fixes — the user must open the
+ * Gitignore tab and confirm. This mirrors the plugin-version-mismatch flow
+ * where prerun *warns* and the TUI provides the interactive fix dialog.
+ */
+import { resolveGitignore } from "./gitignore-resolver.js";
+import { detectViolations } from "./gitignore-detector.js";
+import { formatViolationSummary } from "./gitignore-fixer.js";
+export async function checkGitignore(cwd) {
+    const warnings = [];
+    try {
+        const resolved = await resolveGitignore(cwd, {
+            logger: (m) => warnings.push(m),
+        });
+        const violations = await detectViolations(cwd, resolved);
+        return {
+            violationCount: violations.length,
+            warnings,
+        };
+    }
+    catch (err) {
+        warnings.push(`[gitignore] check failed: ${err instanceof Error ? err.message : String(err)}`);
+        return { violationCount: 0, warnings };
+    }
+}
+/**
+ * One-line summary suitable for prerun stderr. Returns null when there's
+ * nothing to warn about.
+ */
+export function formatPrerunWarning(result) {
+    if (result.violationCount === 0)
+        return null;
+    return `⚠ ${result.violationCount} gitignore issue(s) detected. Run: claudeup → Gitignore tab to review and fix`;
+}
+/**
+ * Verbose multi-line summary, used by the Gitignore tab when the user wants
+ * to know what's wrong before deciding what to do.
+ */
+export async function describeViolations(cwd, violations) {
+    void cwd;
+    return formatViolationSummary(violations);
+}

package/src/services/gitignore-prerun.ts

@@ -0,0 +1,59 @@
+/**
+ * Prerunner integration for the gitignore manager.
+ *
+ * Called from `prerunner/index.ts` (Step 0.9) on every claudeup invocation.
+ * Resolves the manifest, runs detection, and prints a concise warning when
+ * violations exist. Does NOT auto-apply fixes — the user must open the
+ * Gitignore tab and confirm. This mirrors the plugin-version-mismatch flow
+ * where prerun *warns* and the TUI provides the interactive fix dialog.
+ */
+
+import { resolveGitignore } from "./gitignore-resolver.js";
+import { detectViolations } from "./gitignore-detector.js";
+import { formatViolationSummary } from "./gitignore-fixer.js";
+import type { Violation } from "../types/gitignore.js";
+
+export interface PrerunResult {
+  violationCount: number;
+  warnings: string[];
+}
+
+export async function checkGitignore(cwd: string): Promise<PrerunResult> {
+  const warnings: string[] = [];
+  try {
+    const resolved = await resolveGitignore(cwd, {
+      logger: (m) => warnings.push(m),
+    });
+    const violations = await detectViolations(cwd, resolved);
+    return {
+      violationCount: violations.length,
+      warnings,
+    };
+  } catch (err) {
+    warnings.push(
+      `[gitignore] check failed: ${err instanceof Error ? err.message : String(err)}`,
+    );
+    return { violationCount: 0, warnings };
+  }
+}
+
+/**
+ * One-line summary suitable for prerun stderr. Returns null when there's
+ * nothing to warn about.
+ */
+export function formatPrerunWarning(result: PrerunResult): string | null {
+  if (result.violationCount === 0) return null;
+  return `⚠ ${result.violationCount} gitignore issue(s) detected. Run: claudeup → Gitignore tab to review and fix`;
+}
+
+/**
+ * Verbose multi-line summary, used by the Gitignore tab when the user wants
+ * to know what's wrong before deciding what to do.
+ */
+export async function describeViolations(
+  cwd: string,
+  violations: Violation[],
+): Promise<string> {
+  void cwd;
+  return formatViolationSummary(violations);
+}

package/src/services/gitignore-resolver.js

@@ -0,0 +1,143 @@
+/**
+ * Three-tier gitignore manifest resolver.
+ *
+ * Precedence (lowest → highest, last-wins):
+ *   1. Built-in defaults (shipped with claudeup)
+ *   2. Global manifest at ~/.claude/gitignore.json (team-level, manually shared)
+ *   3. Project manifest at <cwd>/.claude/gitignore.json
+ *
+ * `extends` references are resolved against BUILTIN_TEMPLATES. Within a single
+ * tier, the same pattern cannot appear in both `ignore` and `track` — that
+ * throws. Across tiers, the higher-precedence tier wins; losers are recorded
+ * in `conflicts` so the TUI can show "global says ignore .env, project
+ * overrides to track."
+ */
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { existsSync } from "node:fs";
+import { BUILTIN_DEFAULTS } from "../data/gitignore-defaults.js";
+import { BUILTIN_TEMPLATES } from "../data/gitignore-templates.js";
+const TIER_ORDER = ["builtin", "global", "project"];
+export async function resolveGitignore(projectCwd, opts = {}) {
+    const home = opts.homeDir ?? homedir();
+    const log = opts.logger ?? (() => { });
+    const tierManifests = new Map();
+    // 1. Built-in (always present)
+    tierManifests.set("builtin", BUILTIN_DEFAULTS);
+    // 2. Global ~/.claude/gitignore.json
+    const globalPath = join(home, ".claude", "gitignore.json");
+    const globalManifest = await readManifest(globalPath, log);
+    if (globalManifest)
+        tierManifests.set("global", globalManifest);
+    // 3. Project .claude/gitignore.json
+    const projectPath = join(projectCwd, ".claude", "gitignore.json");
+    const projectManifest = await readManifest(projectPath, log);
+    if (projectManifest)
+        tierManifests.set("project", projectManifest);
+    // Apply `extends` for each tier (templates count as part of their tier)
+    for (const tier of TIER_ORDER) {
+        const m = tierManifests.get(tier);
+        if (!m?.extends?.length)
+            continue;
+        const merged = {
+            ignore: [...m.ignore],
+            track: [...m.track],
+        };
+        for (const tplName of m.extends) {
+            const tpl = BUILTIN_TEMPLATES[tplName];
+            if (!tpl) {
+                log(`[gitignore] unknown template "${tplName}" in ${tier} manifest`);
+                continue;
+            }
+            merged.ignore.push(...tpl.ignore);
+            merged.track.push(...tpl.track);
+        }
+        tierManifests.set(tier, merged);
+    }
+    // Validate intra-tier consistency
+    for (const [tier, m] of tierManifests.entries()) {
+        const ig = new Set(m.ignore);
+        for (const t of m.track) {
+            if (ig.has(t)) {
+                throw new Error(`Intra-tier conflict in ${tier} manifest: "${t}" is in both ignore and track`);
+            }
+        }
+    }
+    // Merge across tiers — last-wins, track conflicts
+    const ruleByPattern = new Map();
+    for (const tier of TIER_ORDER) {
+        const m = tierManifests.get(tier);
+        if (!m)
+            continue;
+        for (const p of dedupe(m.ignore)) {
+            pushRule(ruleByPattern, p, "ignore", tier);
+        }
+        for (const p of dedupe(m.track)) {
+            pushRule(ruleByPattern, p, "track", tier);
+        }
+    }
+    const rules = [];
+    const conflicts = [];
+    for (const [pattern, entry] of ruleByPattern.entries()) {
+        rules.push({ pattern, action: entry.action, source: entry.source });
+        const losers = entry.history.filter((h) => h.tier !== entry.source || h.action !== entry.action);
+        if (losers.length > 0 && hasActionDisagreement(entry.history)) {
+            conflicts.push({
+                pattern,
+                winner: entry.source,
+                losers: losers.filter((l) => l.action !== entry.action),
+            });
+        }
+    }
+    return { rules, conflicts };
+}
+function pushRule(map, pattern, action, tier) {
+    const existing = map.get(pattern);
+    if (existing) {
+        existing.history.push({ tier, action });
+        existing.action = action;
+        existing.source = tier;
+    }
+    else {
+        map.set(pattern, { action, source: tier, history: [{ tier, action }] });
+    }
+}
+function hasActionDisagreement(history) {
+    const actions = new Set(history.map((h) => h.action));
+    return actions.size > 1;
+}
+function dedupe(xs) {
+    return Array.from(new Set(xs));
+}
+async function readManifest(path, log) {
+    if (!existsSync(path))
+        return null;
+    try {
+        const raw = await readFile(path, "utf8");
+        const parsed = JSON.parse(raw);
+        if (!isManifest(parsed)) {
+            log(`[gitignore] ${path} is not a valid manifest (expected { ignore: string[], track: string[] })`);
+            return null;
+        }
+        return parsed;
+    }
+    catch (err) {
+        log(`[gitignore] failed to read ${path}: ${err instanceof Error ? err.message : String(err)}`);
+        return null;
+    }
+}
+function isManifest(x) {
+    if (!x || typeof x !== "object")
+        return false;
+    const m = x;
+    if (!Array.isArray(m.ignore) || !m.ignore.every((p) => typeof p === "string"))
+        return false;
+    if (!Array.isArray(m.track) || !m.track.every((p) => typeof p === "string"))
+        return false;
+    if (m.extends !== undefined) {
+        if (!Array.isArray(m.extends) || !m.extends.every((p) => typeof p === "string"))
+            return false;
+    }
+    return true;
+}