claudeup 4.15.1 → 4.16.0

package/src/services/gitignore-resolver.ts

@@ -0,0 +1,190 @@
+/**
+ * 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 type {
+  GitignoreManifest,
+  ResolvedManifest,
+  ResolvedRule,
+  ResolvedConflict,
+  Tier,
+  RuleAction,
+} from "../types/gitignore.js";
+import { BUILTIN_DEFAULTS } from "../data/gitignore-defaults.js";
+import { BUILTIN_TEMPLATES } from "../data/gitignore-templates.js";
+
+export interface ResolveOptions {
+  /** Override $HOME (test seam). */
+  homeDir?: string;
+  /** Optional logger for non-fatal warnings (malformed JSON, missing template). */
+  logger?: (msg: string) => void;
+}
+
+const TIER_ORDER: Tier[] = ["builtin", "global", "project"];
+
+export async function resolveGitignore(
+  projectCwd: string,
+  opts: ResolveOptions = {},
+): Promise<ResolvedManifest> {
+  const home = opts.homeDir ?? homedir();
+  const log = opts.logger ?? (() => {});
+
+  const tierManifests = new Map<Tier, GitignoreManifest>();
+
+  // 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: GitignoreManifest = {
+      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<
+    string,
+    { action: RuleAction; source: Tier; history: Array<{ tier: Tier; action: RuleAction }> }
+  >();
+
+  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: ResolvedRule[] = [];
+  const conflicts: ResolvedConflict[] = [];
+
+  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: Map<
+    string,
+    { action: RuleAction; source: Tier; history: Array<{ tier: Tier; action: RuleAction }> }
+  >,
+  pattern: string,
+  action: RuleAction,
+  tier: Tier,
+): void {
+  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: Array<{ tier: Tier; action: RuleAction }>,
+): boolean {
+  const actions = new Set(history.map((h) => h.action));
+  return actions.size > 1;
+}
+
+function dedupe(xs: string[]): string[] {
+  return Array.from(new Set(xs));
+}
+
+async function readManifest(
+  path: string,
+  log: (msg: string) => void,
+): Promise<GitignoreManifest | null> {
+  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: unknown): x is GitignoreManifest {
+  if (!x || typeof x !== "object") return false;
+  const m = x as Record<string, unknown>;
+  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;
+}

package/src/services/gitignore-service.js

@@ -0,0 +1,99 @@
+/**
+ * TUI-facing wrapper around the gitignore core services. Loads everything
+ * the Gitignore screen needs in one call, and exposes a small set of
+ * action helpers (apply safe fixes, apply one destructive fix, apply a
+ * built-in template).
+ */
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { resolveGitignore } from "./gitignore-resolver.js";
+import { detectViolations } from "./gitignore-detector.js";
+import { applySafeFixes as coreApplySafeFixes, applyDestructiveFix as coreApplyDestructiveFix, } from "./gitignore-fixer.js";
+import { BUILTIN_TEMPLATES } from "../data/gitignore-templates.js";
+export async function loadGitignoreState(cwd) {
+    const warnings = [];
+    const resolved = await resolveGitignore(cwd, {
+        logger: (m) => warnings.push(m),
+    });
+    const violations = await detectViolations(cwd, resolved);
+    return { resolved, violations, warnings };
+}
+export async function applyAllSafeFixes(cwd, violations) {
+    return coreApplySafeFixes(cwd, violations);
+}
+export async function applyDestructiveFix(cwd, violation) {
+    return coreApplyDestructiveFix(cwd, violation);
+}
+/**
+ * Merge a built-in template into the project manifest at .claude/gitignore.json.
+ * Conflicts (a pattern that already exists with the opposite action) are
+ * skipped and reported back to the caller.
+ */
+export async function applyTemplate(cwd, templateName) {
+    const tpl = BUILTIN_TEMPLATES[templateName];
+    if (!tpl)
+        throw new Error(`Unknown template: ${templateName}`);
+    const projectManifestPath = join(cwd, ".claude", "gitignore.json");
+    const existing = await readManifestOrEmpty(projectManifestPath);
+    const existingIgnore = new Set(existing.ignore);
+    const existingTrack = new Set(existing.track);
+    const conflicts = [];
+    const newIgnore = [];
+    const newTrack = [];
+    for (const p of tpl.ignore) {
+        if (existingTrack.has(p)) {
+            conflicts.push(p);
+            continue;
+        }
+        if (!existingIgnore.has(p)) {
+            newIgnore.push(p);
+            existingIgnore.add(p);
+        }
+    }
+    for (const p of tpl.track) {
+        if (existingIgnore.has(p)) {
+            conflicts.push(p);
+            continue;
+        }
+        if (!existingTrack.has(p)) {
+            newTrack.push(p);
+            existingTrack.add(p);
+        }
+    }
+    const merged = {
+        ignore: [...existing.ignore, ...newIgnore],
+        track: [...existing.track, ...newTrack],
+        extends: existing.extends,
+    };
+    await mkdir(dirname(projectManifestPath), { recursive: true });
+    await writeFile(projectManifestPath, JSON.stringify(merged, null, 2) + "\n");
+    return {
+        appliedTo: projectManifestPath,
+        added: { ignore: newIgnore, track: newTrack },
+        conflicts,
+    };
+}
+async function readManifestOrEmpty(path) {
+    if (!existsSync(path))
+        return { ignore: [], track: [] };
+    try {
+        const raw = await readFile(path, "utf8");
+        const parsed = JSON.parse(raw);
+        if (!isManifest(parsed))
+            return { ignore: [], track: [] };
+        return parsed;
+    }
+    catch {
+        return { ignore: [], track: [] };
+    }
+}
+function isManifest(x) {
+    if (!x || typeof x !== "object")
+        return false;
+    const m = x;
+    return (Array.isArray(m.ignore) &&
+        m.ignore.every((p) => typeof p === "string") &&
+        Array.isArray(m.track) &&
+        m.track.every((p) => typeof p === "string"));
+}

package/src/services/gitignore-service.ts

@@ -0,0 +1,142 @@
+/**
+ * TUI-facing wrapper around the gitignore core services. Loads everything
+ * the Gitignore screen needs in one call, and exposes a small set of
+ * action helpers (apply safe fixes, apply one destructive fix, apply a
+ * built-in template).
+ */
+
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { resolveGitignore } from "./gitignore-resolver.js";
+import { detectViolations } from "./gitignore-detector.js";
+import {
+  applySafeFixes as coreApplySafeFixes,
+  applyDestructiveFix as coreApplyDestructiveFix,
+  type SafeFixResult,
+  type DestructiveFixResult,
+} from "./gitignore-fixer.js";
+import { BUILTIN_TEMPLATES } from "../data/gitignore-templates.js";
+import type {
+  GitignoreManifest,
+  ResolvedManifest,
+  Violation,
+} from "../types/gitignore.js";
+
+export interface GitignoreState {
+  resolved: ResolvedManifest;
+  violations: Violation[];
+  /** Logger lines from resolution (malformed JSON, missing template, etc). */
+  warnings: string[];
+}
+
+export async function loadGitignoreState(cwd: string): Promise<GitignoreState> {
+  const warnings: string[] = [];
+  const resolved = await resolveGitignore(cwd, {
+    logger: (m) => warnings.push(m),
+  });
+  const violations = await detectViolations(cwd, resolved);
+  return { resolved, violations, warnings };
+}
+
+export async function applyAllSafeFixes(
+  cwd: string,
+  violations: Violation[],
+): Promise<SafeFixResult> {
+  return coreApplySafeFixes(cwd, violations);
+}
+
+export async function applyDestructiveFix(
+  cwd: string,
+  violation: Violation,
+): Promise<DestructiveFixResult> {
+  return coreApplyDestructiveFix(cwd, violation);
+}
+
+export interface ApplyTemplateResult {
+  appliedTo: string;
+  added: { ignore: string[]; track: string[] };
+  conflicts: string[];
+}
+
+/**
+ * Merge a built-in template into the project manifest at .claude/gitignore.json.
+ * Conflicts (a pattern that already exists with the opposite action) are
+ * skipped and reported back to the caller.
+ */
+export async function applyTemplate(
+  cwd: string,
+  templateName: string,
+): Promise<ApplyTemplateResult> {
+  const tpl = BUILTIN_TEMPLATES[templateName];
+  if (!tpl) throw new Error(`Unknown template: ${templateName}`);
+
+  const projectManifestPath = join(cwd, ".claude", "gitignore.json");
+  const existing = await readManifestOrEmpty(projectManifestPath);
+
+  const existingIgnore = new Set(existing.ignore);
+  const existingTrack = new Set(existing.track);
+
+  const conflicts: string[] = [];
+  const newIgnore: string[] = [];
+  const newTrack: string[] = [];
+
+  for (const p of tpl.ignore) {
+    if (existingTrack.has(p)) {
+      conflicts.push(p);
+      continue;
+    }
+    if (!existingIgnore.has(p)) {
+      newIgnore.push(p);
+      existingIgnore.add(p);
+    }
+  }
+  for (const p of tpl.track) {
+    if (existingIgnore.has(p)) {
+      conflicts.push(p);
+      continue;
+    }
+    if (!existingTrack.has(p)) {
+      newTrack.push(p);
+      existingTrack.add(p);
+    }
+  }
+
+  const merged: GitignoreManifest = {
+    ignore: [...existing.ignore, ...newIgnore],
+    track: [...existing.track, ...newTrack],
+    extends: existing.extends,
+  };
+
+  await mkdir(dirname(projectManifestPath), { recursive: true });
+  await writeFile(projectManifestPath, JSON.stringify(merged, null, 2) + "\n");
+
+  return {
+    appliedTo: projectManifestPath,
+    added: { ignore: newIgnore, track: newTrack },
+    conflicts,
+  };
+}
+
+async function readManifestOrEmpty(path: string): Promise<GitignoreManifest> {
+  if (!existsSync(path)) return { ignore: [], track: [] };
+  try {
+    const raw = await readFile(path, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!isManifest(parsed)) return { ignore: [], track: [] };
+    return parsed;
+  } catch {
+    return { ignore: [], track: [] };
+  }
+}
+
+function isManifest(x: unknown): x is GitignoreManifest {
+  if (!x || typeof x !== "object") return false;
+  const m = x as Record<string, unknown>;
+  return (
+    Array.isArray(m.ignore) &&
+    m.ignore.every((p) => typeof p === "string") &&
+    Array.isArray(m.track) &&
+    m.track.every((p) => typeof p === "string")
+  );
+}

package/src/types/gitignore.js

@@ -0,0 +1,6 @@
+/**
+ * Types for the gitignore manager: a three-tier (built-in → global → project)
+ * manifest system that declares which paths must be ignored and which must
+ * stay tracked. Last-wins on conflict across tiers; intra-tier conflicts throw.
+ */
+export {};

package/src/types/gitignore.ts

@@ -0,0 +1,68 @@
+/**
+ * Types for the gitignore manager: a three-tier (built-in → global → project)
+ * manifest system that declares which paths must be ignored and which must
+ * stay tracked. Last-wins on conflict across tiers; intra-tier conflicts throw.
+ */
+
+export type RuleAction = "ignore" | "track";
+
+export type Tier = "builtin" | "global" | "project";
+
+/** A user-authored manifest, deserialized from JSON. */
+export interface GitignoreManifest {
+  /** Paths or globs that must be excluded from git. */
+  ignore: string[];
+  /** Paths that must remain tracked even if a parent is in ignore. */
+  track: string[];
+  /** Optional template names to merge in (e.g. "common-dev"). */
+  extends?: string[];
+}
+
+/** A single rule after tier resolution. */
+export interface ResolvedRule {
+  pattern: string;
+  action: RuleAction;
+  source: Tier;
+}
+
+/** When two tiers disagree on a pattern, the higher-precedence tier wins. */
+export interface ResolvedConflict {
+  pattern: string;
+  winner: Tier;
+  losers: Array<{ tier: Tier; action: RuleAction }>;
+}
+
+export interface ResolvedManifest {
+  rules: ResolvedRule[];
+  conflicts: ResolvedConflict[];
+}
+
+/**
+ * Categorized violation state. The detector inspects the working tree against
+ * the resolved manifest and emits one of these per offending path.
+ *
+ * - tracked-but-should-ignore: path is in git index, manifest says ignore
+ * - ignored-but-should-track:  path matches .gitignore, manifest says track
+ * - untracked-and-should-track: path exists but neither tracked nor ignored;
+ *                                manifest says it should be tracked
+ * - missing-from-gitignore:    path is in manifest.ignore but no .gitignore line
+ *                                covers it (and the path isn't currently tracked)
+ */
+export type ViolationKind =
+  | "tracked-but-should-ignore"
+  | "ignored-but-should-track"
+  | "untracked-and-should-track"
+  | "missing-from-gitignore";
+
+export interface Violation {
+  kind: ViolationKind;
+  path: string;
+  /** Which tier asserted the rule that's being violated. */
+  source: Tier;
+  /**
+   * "safe"        — fix is purely additive (append a .gitignore line)
+   * "destructive" — fix mutates git index (`git rm --cached`, `git add`,
+   *                  removing existing .gitignore lines)
+   */
+  severity: "safe" | "destructive";
+}

package/src/ui/App.js

@@ -5,7 +5,10 @@ import fs from "node:fs";
 import { AppProvider, useApp, useNavigation, useModal, } from "./state/AppContext.js";
 import { DimensionsProvider, useDimensions, } from "./state/DimensionsContext.js";
 import { ModalContainer } from "./components/modals/index.js";
-import { PluginsScreen, McpScreen, McpRegistryScreen, SettingsScreen, CliToolsScreen, ModelSelectorScreen, ProfilesScreen, SkillsScreen, } from "./screens/index.js";
+import { PluginsScreen, McpScreen, McpRegistryScreen, SettingsScreen, CliToolsScreen, ModelSelectorScreen, ProfilesScreen, SkillsScreen, GitignoreScreen, } from "./screens/index.js";
+import { checkGitignore } from "../services/gitignore-prerun.js";
+import { loadGitignoreState, applyAllSafeFixes, } from "../services/gitignore-service.js";
+import { useGitignoreModal } from "./hooks/useGitignoreModal.js";
 import { repairAllMarketplaces } from "../services/local-marketplace.js";
 import { migrateMarketplaceRename, recoverMarketplaceSettings, } from "../services/claude-settings.js";
 import { autoAddMissingMarketplaces } from "../services/marketplace-sync.js";
@@ -40,6 +43,8 @@ function Router() {
             return _jsx(ProfilesScreen, {});
         case "skills":
             return _jsx(SkillsScreen, {});
+        case "gitignore":
+            return _jsx(GitignoreScreen, {});
         default:
             return _jsx(PluginsScreen, {});
     }
@@ -81,7 +86,7 @@ function GlobalKeyHandler({ onDebugToggle, onExit, }) {
         // Don't handle keys when modal is open or searching
         if (state.modal || state.isSearching)
             return;
-        // Global navigation shortcuts (1-5) - include mcp-registry as it's a sub-screen of mcp
+        // Global navigation shortcuts (1-7) - include mcp-registry as it's a sub-screen of mcp
         const isTopLevel = [
             "plugins",
             "mcp",
@@ -91,6 +96,7 @@ function GlobalKeyHandler({ onDebugToggle, onExit, }) {
             "model-selector",
             "profiles",
             "skills",
+            "gitignore",
         ].includes(state.currentRoute.screen);
         if (isTopLevel) {
             if (input === "1")
@@ -105,6 +111,8 @@ function GlobalKeyHandler({ onDebugToggle, onExit, }) {
                 navigateToScreen("profiles");
             else if (input === "6")
                 navigateToScreen("cli-tools");
+            else if (input === "7")
+                navigateToScreen("gitignore");
             // Tab navigation cycling
             if (key.tab) {
                 const screens = [
@@ -114,6 +122,7 @@ function GlobalKeyHandler({ onDebugToggle, onExit, }) {
                     "settings",
                     "profiles",
                     "cli-tools",
+                    "gitignore",
                 ];
                 const currentIndex = screens.indexOf(state.currentRoute.screen);
                 if (currentIndex !== -1) {
@@ -148,7 +157,7 @@ function GlobalKeyHandler({ onDebugToggle, onExit, }) {
   ?             This help
 
 Quick Navigation
-  1  Plugins      4  Settings
+  1  Plugins      4  Settings    7  Gitignore
   2  Skills       5  Profiles
   3  MCP Servers  6  CLI Tools
 
@@ -193,6 +202,8 @@ function AppContent({ onExit }) {
     const [recoveryReport, setRecoveryReport] = useState(null);
     const [mismatchData, setMismatchData] = useState(null);
     const mismatchModal = useMismatchModal();
+    const [gitignoreData, setGitignoreData] = useState(null);
+    const gitignoreModal = useGitignoreModal();
     // Check for updates on startup (non-blocking)
     useEffect(() => {
         checkForUpdates()
@@ -213,6 +224,23 @@ function AppContent({ onExit }) {
         mismatchModal.show(mismatchData);
         setMismatchData(null);
     }, [mismatchData, mismatchModal]);
+    // Show gitignore modal — wait for the modal slot to be free so we don't
+    // stomp on the mismatch modal that may have just been shown.
+    useEffect(() => {
+        if (!gitignoreData)
+            return;
+        if (state.modal)
+            return;
+        gitignoreModal.show({
+            violationCount: gitignoreData.violationCount,
+            safeCount: gitignoreData.safeCount,
+            onFixSafe: async () => {
+                const s = await loadGitignoreState(state.projectPath);
+                await applyAllSafeFixes(state.projectPath, s.violations);
+            },
+        });
+        setGitignoreData(null);
+    }, [gitignoreData, gitignoreModal, state.modal, state.projectPath]);
     // Auto-refresh marketplaces on startup
     useEffect(() => {
         const noRefresh = process.argv.includes("--no-refresh");
@@ -277,6 +305,22 @@ function AppContent({ onExit }) {
             }
         })
             .catch(() => { }); // non-fatal
+        // Check for gitignore manifest violations and surface a popup if any.
+        // Loads twice (once for count, once when user picks "fix safe") because
+        // the second load happens after edits — keeps detection cheap on startup.
+        (async () => {
+            try {
+                const result = await checkGitignore(process.cwd());
+                if (result.violationCount > 0) {
+                    const s = await loadGitignoreState(process.cwd());
+                    const safeCount = s.violations.filter((v) => v.severity === "safe").length;
+                    setGitignoreData({ violationCount: result.violationCount, safeCount });
+                }
+            }
+            catch {
+                // non-fatal
+            }
+        })();
         repairAllMarketplaces()
             .then(async () => {
             dispatch({ type: "HIDE_PROGRESS" });