claudeup 4.15.0 → 4.16.0

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;
+}

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";
+}