claudeup 4.15.0 → 4.16.0

package/src/services/gitignore-detector.ts

@@ -0,0 +1,157 @@
+/**
+ * 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";
+import type { ResolvedManifest, Violation } from "../types/gitignore.js";
+
+export async function detectViolations(
+  cwd: string,
+  resolved: ResolvedManifest,
+): Promise<Violation[]> {
+  if (!(await isGitRepo(cwd))) return [];
+
+  const violations: Violation[] = [];
+  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: string, tracked: Set<string>): string[] {
+  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: string): Promise<boolean> {
+  try {
+    await runGit(["rev-parse", "--is-inside-work-tree"], cwd);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function listTrackedFiles(cwd: string): Promise<string[]> {
+  try {
+    const out = await runGit(["ls-files"], cwd);
+    return out.split("\n").map((l) => l.trim()).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+async function pathIsIgnored(cwd: string, path: string): Promise<boolean> {
+  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 {
+  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-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);
+}