claudeup 4.15.1 → 4.16.0

package/src/ui/App.tsx

@@ -21,8 +21,15 @@ import {
 	ModelSelectorScreen,
 	ProfilesScreen,
 	SkillsScreen,
+	GitignoreScreen,
 } from "./screens/index.js";
 import type { Screen } from "./state/types.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,
@@ -70,6 +77,8 @@ function Router() {
 			return <ProfilesScreen />;
 		case "skills":
 			return <SkillsScreen />;
+		case "gitignore":
+			return <GitignoreScreen />;
 		default:
 			return <PluginsScreen />;
 	}
@@ -120,7 +129,7 @@ function GlobalKeyHandler({
 		// 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",
@@ -130,6 +139,7 @@ function GlobalKeyHandler({
 			"model-selector",
 			"profiles",
 			"skills",
+			"gitignore",
 		].includes(state.currentRoute.screen);
 
 		if (isTopLevel) {
@@ -139,6 +149,7 @@ function GlobalKeyHandler({
 			else if (input === "4") navigateToScreen("settings");
 			else if (input === "5") navigateToScreen("profiles");
 			else if (input === "6") navigateToScreen("cli-tools");
+			else if (input === "7") navigateToScreen("gitignore");
 
 			// Tab navigation cycling
 			if (key.tab) {
@@ -149,6 +160,7 @@ function GlobalKeyHandler({
 					"settings",
 					"profiles",
 					"cli-tools",
+					"gitignore",
 				];
 				const currentIndex = screens.indexOf(
 					state.currentRoute.screen as Screen,
@@ -187,7 +199,7 @@ function GlobalKeyHandler({
   ?             This help
 
 Quick Navigation
-  1  Plugins      4  Settings
+  1  Plugins      4  Settings    7  Gitignore
   2  Skills       5  Profiles
   3  MCP Servers  6  CLI Tools
 
@@ -319,6 +331,11 @@ function AppContent({ onExit }: AppContentProps) {
 	const [recoveryReport, setRecoveryReport] = useState<string | null>(null);
 	const [mismatchData, setMismatchData] = useState<VersionMismatchInfo[] | null>(null);
 	const mismatchModal = useMismatchModal();
+	const [gitignoreData, setGitignoreData] = useState<{
+		violationCount: number;
+		safeCount: number;
+	} | null>(null);
+	const gitignoreModal = useGitignoreModal();
 
 	// Check for updates on startup (non-blocking)
 	useEffect(() => {
@@ -341,6 +358,22 @@ function AppContent({ onExit }: AppContentProps) {
 		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");
@@ -409,6 +442,22 @@ function AppContent({ onExit }: AppContentProps) {
 			})
 			.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" });

package/src/ui/components/TabBar.js

@@ -6,6 +6,7 @@ const TABS = [
     { key: "4", label: "Settings", screen: "settings" },
     { key: "5", label: "Profiles", screen: "profiles" },
     { key: "6", label: "CLI", screen: "cli-tools" },
+    { key: "7", label: "Gitignore", screen: "gitignore" },
 ];
 export function TabBar({ currentScreen }) {
     return (_jsx("box", { flexDirection: "row", gap: 0, children: TABS.map((tab, index) => {

package/src/ui/components/TabBar.tsx

@@ -14,6 +14,7 @@ const TABS: Tab[] = [
 	{ key: "4", label: "Settings", screen: "settings" },
 	{ key: "5", label: "Profiles", screen: "profiles" },
 	{ key: "6", label: "CLI", screen: "cli-tools" },
+	{ key: "7", label: "Gitignore", screen: "gitignore" },
 ];
 
 interface TabBarProps {

package/src/ui/hooks/useGitignoreModal.js

@@ -0,0 +1,75 @@
+import { useCallback } from "react";
+import { useApp, useNavigation } from "../state/AppContext.js";
+export function buildGitignoreModal(args) {
+    const { violationCount, safeCount, onFixSafe, onOpenTab, onDismiss } = args;
+    const options = [
+        {
+            label: safeCount > 0
+                ? `Append ${safeCount} safe entr${safeCount === 1 ? "y" : "ies"} to .gitignore`
+                : "(no safe-fixable entries)",
+            value: "fix-safe",
+        },
+        {
+            label: "Open Gitignore tab to review",
+            value: "open-tab",
+        },
+        {
+            label: "Dismiss",
+            value: "dismiss",
+        },
+    ];
+    return {
+        type: "select",
+        title: "Gitignore violations detected",
+        message: `Found ${violationCount} issue(s) where the resolved gitignore manifest ` +
+            `disagrees with your working tree.\n\n` +
+            `Safe fixes append to .gitignore (no index mutation). Destructive fixes ` +
+            `(\`git rm --cached\`, removing .gitignore lines) must be applied one at ` +
+            `a time from the Gitignore tab.`,
+        options,
+        onSelect: (value) => {
+            if (value === "fix-safe")
+                onFixSafe();
+            else if (value === "open-tab")
+                onOpenTab();
+            else
+                onDismiss();
+        },
+        onCancel: onDismiss,
+    };
+}
+export function useGitignoreModal() {
+    const { dispatch } = useApp();
+    const { navigateToScreen } = useNavigation();
+    const show = useCallback((args) => {
+        if (args.violationCount === 0)
+            return;
+        const dismiss = () => dispatch({ type: "HIDE_MODAL" });
+        const modal = buildGitignoreModal({
+            violationCount: args.violationCount,
+            safeCount: args.safeCount,
+            onFixSafe: () => {
+                dispatch({ type: "HIDE_MODAL" });
+                void Promise.resolve(args.onFixSafe()).catch((err) => {
+                    dispatch({
+                        type: "SHOW_MODAL",
+                        modal: {
+                            type: "message",
+                            title: "Safe fixes failed",
+                            message: err instanceof Error ? err.message : String(err),
+                            variant: "error",
+                            onDismiss: dismiss,
+                        },
+                    });
+                });
+            },
+            onOpenTab: () => {
+                dispatch({ type: "HIDE_MODAL" });
+                navigateToScreen("gitignore");
+            },
+            onDismiss: dismiss,
+        });
+        dispatch({ type: "SHOW_MODAL", modal });
+    }, [dispatch, navigateToScreen]);
+    return { show };
+}

package/src/ui/hooks/useGitignoreModal.ts

@@ -0,0 +1,97 @@
+import { useCallback } from "react";
+import { useApp, useNavigation } from "../state/AppContext.js";
+import type { ModalState } from "../state/types.js";
+
+/**
+ * Startup gitignore-violation modal. Mirrors `useMismatchModal` so the
+ * two flows feel identical to the user — claudeup launches, detects
+ * a problem, asks "fix safe entries / open the tab / dismiss".
+ *
+ * Pure builder is exported separately for tests.
+ */
+
+export interface BuildModalArgs {
+  violationCount: number;
+  safeCount: number;
+  onFixSafe: () => void;
+  onOpenTab: () => void;
+  onDismiss: () => void;
+}
+
+export function buildGitignoreModal(args: BuildModalArgs): ModalState {
+  const { violationCount, safeCount, onFixSafe, onOpenTab, onDismiss } = args;
+  const options = [
+    {
+      label:
+        safeCount > 0
+          ? `Append ${safeCount} safe entr${safeCount === 1 ? "y" : "ies"} to .gitignore`
+          : "(no safe-fixable entries)",
+      value: "fix-safe",
+    },
+    {
+      label: "Open Gitignore tab to review",
+      value: "open-tab",
+    },
+    {
+      label: "Dismiss",
+      value: "dismiss",
+    },
+  ];
+  return {
+    type: "select",
+    title: "Gitignore violations detected",
+    message:
+      `Found ${violationCount} issue(s) where the resolved gitignore manifest ` +
+      `disagrees with your working tree.\n\n` +
+      `Safe fixes append to .gitignore (no index mutation). Destructive fixes ` +
+      `(\`git rm --cached\`, removing .gitignore lines) must be applied one at ` +
+      `a time from the Gitignore tab.`,
+    options,
+    onSelect: (value: string) => {
+      if (value === "fix-safe") onFixSafe();
+      else if (value === "open-tab") onOpenTab();
+      else onDismiss();
+    },
+    onCancel: onDismiss,
+  };
+}
+
+export function useGitignoreModal() {
+  const { dispatch } = useApp();
+  const { navigateToScreen } = useNavigation();
+
+  const show = useCallback(
+    (args: { violationCount: number; safeCount: number; onFixSafe: () => Promise<void> | void }) => {
+      if (args.violationCount === 0) return;
+      const dismiss = () => dispatch({ type: "HIDE_MODAL" });
+      const modal = buildGitignoreModal({
+        violationCount: args.violationCount,
+        safeCount: args.safeCount,
+        onFixSafe: () => {
+          dispatch({ type: "HIDE_MODAL" });
+          void Promise.resolve(args.onFixSafe()).catch((err) => {
+            dispatch({
+              type: "SHOW_MODAL",
+              modal: {
+                type: "message",
+                title: "Safe fixes failed",
+                message: err instanceof Error ? err.message : String(err),
+                variant: "error",
+                onDismiss: dismiss,
+              },
+            });
+          });
+        },
+        onOpenTab: () => {
+          dispatch({ type: "HIDE_MODAL" });
+          navigateToScreen("gitignore");
+        },
+        onDismiss: dismiss,
+      });
+      dispatch({ type: "SHOW_MODAL", modal });
+    },
+    [dispatch, navigateToScreen],
+  );
+
+  return { show };
+}

package/src/ui/renderers/gitignoreRenderers.js

@@ -0,0 +1,33 @@
+import { jsx as _jsx, jsxs as _jsxs } from "@opentui/react/jsx-runtime";
+const SELECTION_BG = "#7e57c2";
+const SELECTION_FG = "white";
+// Layout: "  X Verb    path" — 2 (gutter) + 2 (status) + 7 (verb) + 4 (gap)
+// = 15 prefix chars. On a 38-col panel inner width that leaves 23 chars for
+// the path; truncate at 22 to keep 1 col safety margin (OpenTUI <text>
+// reserves a second line if the rendered string equals the inner width).
+const MAX_PATH_LEN = 22;
+function truncatePath(p) {
+    return p.length > MAX_PATH_LEN ? p.slice(0, MAX_PATH_LEN - 1) + "…" : p;
+}
+export function renderRuleRow(row, isSelected) {
+    const { rule, violation } = row;
+    const path = truncatePath(rule.pattern);
+    const key = `${rule.action}:${rule.pattern}`;
+    // Layout: status-glyph (2) + verb (7) + 2 spaces + path
+    // OK rule: ✓ Ignore  path
+    // Violated:! Track   path
+    const verb = rule.action === "ignore" ? "Ignore " : "Track  ";
+    if (!violation) {
+        // Clean rule — muted, just confirmation
+        if (isSelected) {
+            return (_jsx("text", { bg: SELECTION_BG, fg: SELECTION_FG, children: `▶ ✓ ${verb}  ${path}` }, key));
+        }
+        return (_jsxs("text", { children: [_jsx("span", { fg: "green", children: `  ✓ ` }), _jsx("span", { fg: "gray", children: `${verb}  ${path}` })] }, key));
+    }
+    // Violated rule — color encodes severity of the fix
+    const sevColor = violation.severity === "safe" ? "yellow" : "red";
+    if (isSelected) {
+        return (_jsx("text", { bg: SELECTION_BG, fg: SELECTION_FG, children: `▶ ! ${verb}  ${path}` }, key));
+    }
+    return (_jsxs("text", { children: [_jsx("span", { fg: sevColor, children: `  ! ` }), _jsx("span", { fg: "white", children: `${verb}  ${path}` })] }, key));
+}

package/src/ui/renderers/gitignoreRenderers.tsx

@@ -0,0 +1,70 @@
+import React from "react";
+import type { ResolvedRule, Violation } from "../../types/gitignore.js";
+
+/**
+ * A unified row for the Gitignore screen — represents one resolved rule,
+ * optionally annotated with the violation it has against the working tree.
+ */
+export interface RuleRow {
+  rule: ResolvedRule;
+  violation?: Violation;
+}
+
+const SELECTION_BG = "#7e57c2";
+const SELECTION_FG = "white";
+
+// Layout: "  X Verb    path" — 2 (gutter) + 2 (status) + 7 (verb) + 4 (gap)
+// = 15 prefix chars. On a 38-col panel inner width that leaves 23 chars for
+// the path; truncate at 22 to keep 1 col safety margin (OpenTUI <text>
+// reserves a second line if the rendered string equals the inner width).
+const MAX_PATH_LEN = 22;
+
+function truncatePath(p: string): string {
+  return p.length > MAX_PATH_LEN ? p.slice(0, MAX_PATH_LEN - 1) + "…" : p;
+}
+
+export function renderRuleRow(row: RuleRow, isSelected: boolean): React.ReactNode {
+  const { rule, violation } = row;
+  const path = truncatePath(rule.pattern);
+  const key = `${rule.action}:${rule.pattern}`;
+
+  // Layout: status-glyph (2) + verb (7) + 2 spaces + path
+  // OK rule: ✓ Ignore  path
+  // Violated:! Track   path
+
+  const verb = rule.action === "ignore" ? "Ignore " : "Track  ";
+
+  if (!violation) {
+    // Clean rule — muted, just confirmation
+    if (isSelected) {
+      return (
+        <text key={key} bg={SELECTION_BG} fg={SELECTION_FG}>
+          {`▶ ✓ ${verb}  ${path}`}
+        </text>
+      );
+    }
+    return (
+      <text key={key}>
+        <span fg="green">{`  ✓ `}</span>
+        <span fg="gray">{`${verb}  ${path}`}</span>
+      </text>
+    );
+  }
+
+  // Violated rule — color encodes severity of the fix
+  const sevColor = violation.severity === "safe" ? "yellow" : "red";
+
+  if (isSelected) {
+    return (
+      <text key={key} bg={SELECTION_BG} fg={SELECTION_FG}>
+        {`▶ ! ${verb}  ${path}`}
+      </text>
+    );
+  }
+  return (
+    <text key={key}>
+      <span fg={sevColor}>{`  ! `}</span>
+      <span fg="white">{`${verb}  ${path}`}</span>
+    </text>
+  );
+}

package/src/ui/screens/GitignoreScreen.js

@@ -0,0 +1,227 @@
+import { jsx as _jsx, jsxs as _jsxs } from "@opentui/react/jsx-runtime";
+import { useEffect, useState, useCallback, useMemo } from "react";
+import { spawn } from "node:child_process";
+import { useApp, useModal } from "../state/AppContext.js";
+import { useKeyboardHandler } from "../hooks/useKeyboardHandler.js";
+import { ScreenLayout } from "../components/layout/index.js";
+import { loadGitignoreState, applyAllSafeFixes, applyDestructiveFix, applyTemplate, } from "../../services/gitignore-service.js";
+import { BUILTIN_TEMPLATES } from "../../data/gitignore-templates.js";
+import { renderRuleRow } from "../renderers/gitignoreRenderers.js";
+export function GitignoreScreen() {
+    const { state } = useApp();
+    const modal = useModal();
+    const cwd = state.projectPath;
+    const [data, setData] = useState(null);
+    const [loading, setLoading] = useState(true);
+    const [error, setError] = useState(null);
+    const [selectedIdx, setSelectedIdx] = useState(0);
+    const reload = useCallback(async () => {
+        setLoading(true);
+        setError(null);
+        try {
+            const s = await loadGitignoreState(cwd);
+            setData(s);
+        }
+        catch (err) {
+            setError(err instanceof Error ? err.message : String(err));
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [cwd]);
+    useEffect(() => {
+        void reload();
+    }, [reload]);
+    // Build the unified row list: every rule, sorted with violations first so
+    // problems are visible at the top of the list without scrolling.
+    const rows = useMemo(() => {
+        if (!data)
+            return [];
+        const violationByPattern = new Map();
+        for (const v of data.violations) {
+            // A violation's `path` is the rule's pattern for ignored-but-should-track
+            // and missing-from-gitignore; for tracked-but-should-ignore it's the
+            // actual tracked file under a directory rule. Index by rule pattern by
+            // matching either path or its prefix.
+            // Simplest: index by path; lookup will try exact then prefix.
+            violationByPattern.set(v.path, v);
+        }
+        const annotated = data.resolved.rules.map((rule) => {
+            const v = violationByPattern.get(rule.pattern) ??
+                findPrefixMatch(rule, data.violations);
+            return { rule, violation: v };
+        });
+        return annotated.sort((a, b) => {
+            const aBad = a.violation ? 0 : 1;
+            const bBad = b.violation ? 0 : 1;
+            if (aBad !== bBad)
+                return aBad - bBad;
+            return a.rule.pattern.localeCompare(b.rule.pattern);
+        });
+    }, [data]);
+    // Clamp selection when rows shrink.
+    useEffect(() => {
+        if (selectedIdx >= rows.length) {
+            setSelectedIdx(Math.max(0, rows.length - 1));
+        }
+    }, [rows.length, selectedIdx]);
+    const selectedRow = rows[selectedIdx];
+    const violationCount = data?.violations.length ?? 0;
+    const safeCount = data?.violations.filter((v) => v.severity === "safe").length ?? 0;
+    const destructiveCount = violationCount - safeCount;
+    // ── Action handlers ───────────────────────────────────────────────────
+    const handleApplySafe = useCallback(async () => {
+        if (!data || safeCount === 0)
+            return;
+        const r = await applyAllSafeFixes(cwd, data.violations);
+        await modal.message("Applied safe fixes", `Appended ${r.appended.length} pattern(s) to .gitignore.${r.alreadyPresent.length > 0
+            ? `\n\n${r.alreadyPresent.length} pattern(s) were already present.`
+            : ""}`, "success");
+        await reload();
+    }, [cwd, data, safeCount, modal, reload]);
+    const handleApplySelected = useCallback(async () => {
+        if (!selectedRow?.violation)
+            return;
+        const v = selectedRow.violation;
+        if (v.severity === "safe") {
+            await handleApplySafe();
+            return;
+        }
+        const confirmed = await modal.confirm("Apply destructive fix?", `${v.kind} on ${v.path}\n\n` +
+            `This mutates the git index (e.g. \`git rm --cached\` or \`git add\`).\n` +
+            `You can review the change with \`git status\` afterwards.`);
+        if (!confirmed)
+            return;
+        try {
+            const result = await applyDestructiveFix(cwd, v);
+            await modal.message(result.applied ? "Fix applied" : "Fix failed", result.message, result.applied ? "success" : "error");
+        }
+        catch (err) {
+            await modal.message("Fix failed", err instanceof Error ? err.message : String(err), "error");
+        }
+        await reload();
+    }, [selectedRow, handleApplySafe, modal, cwd, reload]);
+    const handleApplyTemplate = useCallback(async () => {
+        const names = Object.keys(BUILTIN_TEMPLATES);
+        if (names.length === 0) {
+            await modal.message("No templates", "No built-in templates available.", "info");
+            return;
+        }
+        const selected = await modal.select("Apply template", "Merge the template into the project manifest at .claude/gitignore.json.", names.map((n) => ({ label: n, value: n })));
+        if (!selected)
+            return;
+        try {
+            const r = await applyTemplate(cwd, selected);
+            const conflictNote = r.conflicts.length > 0
+                ? `\n\nSkipped due to conflicts: ${r.conflicts.join(", ")}`
+                : "";
+            await modal.message("Template applied", `Wrote ${r.appliedTo}\n\n` +
+                `Added ${r.added.ignore.length} ignore + ${r.added.track.length} track entries.` +
+                conflictNote, "success");
+        }
+        catch (err) {
+            await modal.message("Template failed", err instanceof Error ? err.message : String(err), "error");
+        }
+        await reload();
+    }, [cwd, modal, reload]);
+    const handleEditManifest = useCallback(async () => {
+        const projectManifest = `${cwd}/.claude/gitignore.json`;
+        const editor = process.env.EDITOR ?? process.env.VISUAL ?? "vi";
+        await new Promise((resolveEdit) => {
+            const child = spawn(editor, [projectManifest], { stdio: "inherit" });
+            child.on("exit", () => resolveEdit());
+            child.on("error", () => resolveEdit());
+        });
+        await reload();
+    }, [cwd, reload]);
+    useKeyboardHandler((input, key) => {
+        if (state.modal)
+            return;
+        if (input === "j" || key.downArrow) {
+            setSelectedIdx((i) => Math.min(i + 1, Math.max(0, rows.length - 1)));
+            return;
+        }
+        if (input === "k" || key.upArrow) {
+            setSelectedIdx((i) => Math.max(i - 1, 0));
+            return;
+        }
+        if (input === "f") {
+            void handleApplySafe();
+            return;
+        }
+        if (input === "F") {
+            void handleApplySelected();
+            return;
+        }
+        if (input === "t") {
+            void handleApplyTemplate();
+            return;
+        }
+        if (input === "e") {
+            void handleEditManifest();
+            return;
+        }
+        if (input === "r") {
+            void reload();
+        }
+    });
+    // ── Rendering ─────────────────────────────────────────────────────────
+    const summary = data ? renderSummary(violationCount, safeCount, destructiveCount) : null;
+    const listBody = loading ? (_jsx("text", { fg: "gray", children: "Loading..." })) : error ? (_jsxs("text", { fg: "red", children: ["Error: ", error] })) : rows.length === 0 ? (_jsx("text", { fg: "gray", children: "No rules resolved." })) : (_jsx("box", { flexDirection: "column", children: rows.slice(0, 200).map((row, i) => renderRuleRow(row, i === selectedIdx)) }));
+    const listPanel = (_jsxs("box", { flexDirection: "column", children: [summary, _jsx("text", { children: " " }), listBody] }));
+    const detailPanel = renderDetail(selectedRow, data?.warnings ?? []);
+    const subtitle = data
+        ? violationCount === 0
+            ? "all clean"
+            : `${violationCount} violation${violationCount === 1 ? "" : "s"}`
+        : "";
+    return (_jsx(ScreenLayout, { title: "Gitignore Manager", subtitle: subtitle, currentScreen: "gitignore", footerHints: "\u2191\u2193 move  f fix-all-safe  F fix-this  t tpl  e edit  r reload", listPanel: listPanel, detailPanel: detailPanel }));
+}
+function findPrefixMatch(rule, violations) {
+    // A directory rule like "ai-docs/sessions/" can have a violation on a child
+    // path like "ai-docs/sessions/leak.md". Match by path-startsWith-pattern.
+    if (!rule.pattern.endsWith("/") && !rule.pattern.includes("*"))
+        return undefined;
+    const prefix = rule.pattern.replace(/\*+$/, "");
+    return violations.find((v) => v.path.startsWith(prefix));
+}
+function renderSummary(violations, safe, destructive) {
+    if (violations === 0) {
+        return _jsx("text", { fg: "green", children: "\u2713 All rules satisfied \u2014 nothing to fix." });
+    }
+    return (_jsxs("text", { children: [_jsx("span", { fg: "white", children: `${violations} violation${violations === 1 ? "" : "s"} ` }), _jsx("span", { fg: "gray", children: `(` }), safe > 0 && _jsx("span", { fg: "yellow", children: `${safe} safe` }), safe > 0 && destructive > 0 && _jsx("span", { fg: "gray", children: `, ` }), destructive > 0 && _jsx("span", { fg: "red", children: `${destructive} destructive` }), _jsx("span", { fg: "gray", children: `)` })] }));
+}
+function renderDetail(row, warnings) {
+    if (!row) {
+        return (_jsxs("box", { flexDirection: "column", children: [_jsx("text", { fg: "gray", children: "No rule selected." }), warnings.length > 0 && (_jsxs("box", { flexDirection: "column", marginTop: 1, children: [_jsx("text", { fg: "yellow", children: "Warnings:" }), warnings.map((w, i) => (_jsx("text", { fg: "gray", children: w }, i)))] }))] }));
+    }
+    const { rule, violation } = row;
+    if (!violation) {
+        // Rule is satisfied — show what it enforces and where it came from
+        return (_jsxs("box", { flexDirection: "column", children: [_jsx("text", { fg: "white", children: _jsx("strong", { children: rule.pattern }) }), _jsx("text", { children: " " }), _jsx("text", { fg: "green", children: `✓ ${rule.action === "ignore" ? "Ignored" : "Tracked"} as required.` }), _jsx("text", { children: " " }), _jsx("text", { fg: "gray", children: `Rule from ${rule.source} tier.` })] }));
+    }
+    // Rule is violated — explain and show the action
+    return (_jsxs("box", { flexDirection: "column", children: [_jsx("text", { fg: "white", children: _jsx("strong", { children: violation.path }) }), _jsx("text", { children: " " }), _jsx("text", { fg: "white", children: describeKind(violation.kind) }), _jsx("text", { children: " " }), _jsx("text", { fg: "gray", children: `Rule from ${rule.source} tier.` }), _jsx("text", { fg: violation.severity === "safe" ? "yellow" : "red", children: violation.severity === "safe"
+                    ? "Safe — only appends to .gitignore."
+                    : "Destructive — mutates the git index." }), _jsx("text", { children: " " }), _jsx("text", { fg: "cyan", children: actionHint(violation.kind) })] }));
+}
+function describeKind(kind) {
+    switch (kind) {
+        case "tracked-but-should-ignore": return "This file is in the git index but the manifest says it should be ignored.";
+        case "ignored-but-should-track": return "Your .gitignore excludes this path but the manifest says it should be tracked.";
+        case "untracked-and-should-track": return "This path exists on disk but git doesn't track it; the manifest says it should.";
+        case "missing-from-gitignore": return "The manifest says ignore this path, but it's not in any .gitignore line.";
+    }
+}
+function actionHint(kind) {
+    switch (kind) {
+        case "tracked-but-should-ignore":
+            return "[F] runs `git rm --cached` and appends a .gitignore entry.";
+        case "ignored-but-should-track":
+            return "[F] removes the matching .gitignore line and runs `git add`.";
+        case "untracked-and-should-track":
+            return "[F] runs `git add` to stage the path.";
+        case "missing-from-gitignore":
+            return "[f] appends this and every other safe entry to .gitignore.";
+    }
+}