claudeup 4.17.0 → 4.18.0

package/src/ui/screens/CliToolsScreen.js

@@ -328,6 +328,11 @@ export function CliToolsScreen() {
     const installedCount = toolStatuses.filter((s) => s.installed).length;
     const updateCount = toolStatuses.filter((s) => s.hasUpdate).length;
     const statusContent = (_jsxs("text", { children: [_jsx("span", { fg: "gray", children: "Installed: " }), _jsxs("span", { fg: "cyan", children: [installedCount, "/", toolStatuses.length] }), updateCount > 0 && (_jsxs(_Fragment, { children: [_jsx("span", { fg: "gray", children: " \u2502 Updates: " }), _jsx("span", { fg: "yellow", children: updateCount })] }))] }));
-    return (_jsx(ScreenLayout, { title: "claudeup CLI Tools", currentScreen: "cli-tools", statusLine: statusContent, footerHints: "Enter:install \u2502 a:update all \u2502 c:fix conflict \u2502 r:refresh", listPanel: _jsx(ScrollableList, { items: toolStatuses, selectedIndex: cliToolsState.selectedIndex, renderItem: renderCliToolRow, maxHeight: dimensions.listPanelHeight, getKey: (status) => status.tool.name }), detailPanel: renderCliToolDetail(selectedStatus) }));
+    return (_jsx(ScreenLayout, { title: "claudeup CLI Tools", currentScreen: "cli-tools", statusLine: statusContent, footerHints: [
+            { keys: ["Enter"], label: "install" },
+            { keys: ["a"], label: "update all" },
+            { keys: ["c"], label: "fix conflict" },
+            { keys: ["r"], label: "refresh" },
+        ], listPanel: _jsx(ScrollableList, { items: toolStatuses, selectedIndex: cliToolsState.selectedIndex, renderItem: renderCliToolRow, maxHeight: dimensions.listPanelHeight, getKey: (status) => status.tool.name }), detailPanel: renderCliToolDetail(selectedStatus) }));
 }
 export default CliToolsScreen;

package/src/ui/screens/CliToolsScreen.tsx

@@ -417,7 +417,12 @@ export function CliToolsScreen() {
 			title="claudeup CLI Tools"
 			currentScreen="cli-tools"
 			statusLine={statusContent}
-			footerHints="Enter:install │ a:update all │ c:fix conflict │ r:refresh"
+			footerHints={[
+				{ keys: ["Enter"], label: "install" },
+				{ keys: ["a"], label: "update all" },
+				{ keys: ["c"], label: "fix conflict" },
+				{ keys: ["r"], label: "refresh" },
+			]}
 			listPanel={
 				<ScrollableList
 					items={toolStatuses}

package/src/ui/screens/EnvVarsScreen.js

@@ -140,7 +140,12 @@ export function SettingsScreen() {
         ? Array.from(settings.values.data.values()).filter((v) => v.user !== undefined || v.project !== undefined).length
         : 0;
     const statusContent = (_jsxs("text", { children: [_jsx("span", { fg: "gray", children: "Settings: " }), _jsxs("span", { fg: "cyan", children: [totalSet, " configured"] }), _jsx("span", { fg: "gray", children: " \u2502 u:user p:project" })] }));
-    return (_jsx(ScreenLayout, { title: "claudeup Settings", currentScreen: "settings", statusLine: statusContent, footerHints: "\u2191\u2193:nav \u2502 u:user scope \u2502 p:project scope \u2502 Enter:project", listPanel: settings.values.status !== "success" ? (_jsx("text", { fg: "gray", children: settings.values.status === "loading"
+    return (_jsx(ScreenLayout, { title: "claudeup Settings", currentScreen: "settings", statusLine: statusContent, footerHints: [
+            { keys: ["↑", "↓"], label: "nav" },
+            { keys: ["u"], label: "user scope" },
+            { keys: ["p"], label: "project scope" },
+            { keys: ["Enter"], label: "project" },
+        ], listPanel: settings.values.status !== "success" ? (_jsx("text", { fg: "gray", children: settings.values.status === "loading"
                 ? "Loading..."
                 : "Error loading settings" })) : (_jsx(ScrollableList, { items: listItems, selectedIndex: settings.selectedIndex, renderItem: renderSettingRow, maxHeight: dimensions.listPanelHeight })), detailPanel: renderDetail() }));
 }

package/src/ui/screens/EnvVarsScreen.tsx

@@ -185,7 +185,12 @@ export function SettingsScreen() {
 			title="claudeup Settings"
 			currentScreen="settings"
 			statusLine={statusContent}
-			footerHints="↑↓:nav │ u:user scope │ p:project scope │ Enter:project"
+			footerHints={[
+				{ keys: ["↑", "↓"], label: "nav" },
+				{ keys: ["u"], label: "user scope" },
+				{ keys: ["p"], label: "project scope" },
+				{ keys: ["Enter"], label: "project" },
+			]}
 			listPanel={
 				settings.values.status !== "success" ? (
 					<text fg="gray">

package/src/ui/screens/GitignoreScreen.js

@@ -1,15 +1,29 @@
 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 { appendFileSync } from "node:fs";
+import { useRenderer } from "@opentui/react";
 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 { loadGitignoreState, applyDestructiveFix, ensureProjectManifestForEdit, applyTemplate, } from "../../services/gitignore-service.js";
 import { BUILTIN_TEMPLATES } from "../../data/gitignore-templates.js";
-import { renderRuleRow } from "../renderers/gitignoreRenderers.js";
+import { getGitignoreRuleReason } from "../../data/gitignore-reasons.js";
+import { renderRuleRow, } from "../renderers/gitignoreRenderers.js";
+// Clean rows are grouped by the manifest that defined them. Order = display
+// order, top to bottom. "Default" is the user-facing name for the built-in
+// rules. Each label names where you'd go to change that group's rules.
+const SOURCE_ORDER = ["project", "global", "profile", "builtin"];
+const SOURCE_LABELS = {
+    project: "Project · .claude/gitignore.json",
+    global: "Global · ~/.claude/gitignore.json",
+    profile: "Profile",
+    builtin: "Default · built into claudeup",
+};
 export function GitignoreScreen() {
     const { state } = useApp();
     const modal = useModal();
+    const renderer = useRenderer();
     const cwd = state.projectPath;
     const [data, setData] = useState(null);
     const [loading, setLoading] = useState(true);
@@ -32,30 +46,37 @@ export function GitignoreScreen() {
     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.
+    // Build the managed list: every desired gitignore rule, with all matching
+    // violations grouped under the rule that owns them.
     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 };
+            const violations = data.violations.filter((v) => violationMatchesRule(rule, v));
+            return { rule, violations };
         });
+        // Display order = flat index order (the keyboard handler walks this array),
+        // so the on-screen layout must match this sort exactly:
+        //   1. violations first (most violations first)
+        //   2. then clean rows grouped by source manifest (SOURCE_ORDER)
+        //   3. alphabetical within each group
+        const sourceRank = (tier) => {
+            const i = SOURCE_ORDER.indexOf(tier);
+            return i === -1 ? SOURCE_ORDER.length : i;
+        };
         return annotated.sort((a, b) => {
-            const aBad = a.violation ? 0 : 1;
-            const bBad = b.violation ? 0 : 1;
-            if (aBad !== bBad)
-                return aBad - bBad;
+            const aViol = a.violations.length > 0;
+            const bViol = b.violations.length > 0;
+            if (aViol !== bViol)
+                return aViol ? -1 : 1;
+            if (aViol && bViol && a.violations.length !== b.violations.length) {
+                return b.violations.length - a.violations.length;
+            }
+            if (!aViol) {
+                const sr = sourceRank(a.rule.source) - sourceRank(b.rule.source);
+                if (sr !== 0)
+                    return sr;
+            }
             return a.rule.pattern.localeCompare(b.rule.pattern);
         });
     }, [data]);
@@ -66,41 +87,76 @@ export function GitignoreScreen() {
         }
     }, [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;
+    const ignoreRuleCount = data?.resolved.rules.filter((rule) => rule.action === "ignore").length ?? 0;
+    const trackRuleCount = data?.resolved.rules.filter((rule) => rule.action === "track").length ?? 0;
+    const toFixCount = data?.violations.length ?? 0;
+    // Group rows for display while preserving each row's flat index in `rows`
+    // (the keyboard handler walks `rows` by index, so the highlight must track
+    // the original index, not the position within a rendered group).
+    const indexed = rows.map((row, index) => ({ row, index }));
+    const toFixRows = indexed.filter((r) => r.row.violations.length > 0);
+    // Clean rows grouped by which manifest defined them. Sections render only
+    // when non-empty, so e.g. the Profile group stays hidden until profiles
+    // actually contribute rules.
+    const cleanIndexed = indexed.filter((r) => r.row.violations.length === 0);
+    const sourceGroups = SOURCE_ORDER.map((tier) => ({
+        tier,
+        label: SOURCE_LABELS[tier],
+        items: cleanIndexed.filter((r) => r.row.rule.source === tier),
+    })).filter((g) => g.items.length > 0);
+    const cleanCount = cleanIndexed.length;
     // ── 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)
+    // Fix every out-of-sync row. Iterates the grouped rows (not the flat
+    // violation list) so each .gitignore entry uses the rule's pattern/glob,
+    // not one specific path under it — same association handleApplyOne relies on.
+    const handleFixAll = useCallback(async () => {
+        if (!data || toFixRows.length === 0)
             return;
-        const v = selectedRow.violation;
-        if (v.severity === "safe") {
-            await handleApplySafe();
+        try {
+            const messages = [];
+            const failures = [];
+            for (const { row } of toFixRows) {
+                for (const v of row.violations) {
+                    const r = await applyDestructiveFix(cwd, v, row.rule.pattern);
+                    (r.applied ? messages : failures).push(r.message);
+                }
+            }
+            await reload();
+            if (failures.length > 0) {
+                await modal.message("Some fixes didn't apply", [...failures, ...messages].join("\n"), "error");
+            }
+        }
+        catch (err) {
+            await modal.message("Fix failed", err instanceof Error ? err.message : String(err), "error");
+        }
+    }, [cwd, data, toFixRows, reload, modal]);
+    // Fix just the highlighted row.
+    const handleFixOne = useCallback(async () => {
+        if (!selectedRow) {
+            await modal.message("No row selected", "Use ↑↓ to highlight a row that needs fixing, then press f.", "info");
             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)
+        if (selectedRow.violations.length === 0) {
+            await modal.message("Nothing to fix", `${selectedRow.rule.pattern} already matches. f only applies to rows that need fixing.`, "info");
             return;
+        }
         try {
-            const result = await applyDestructiveFix(cwd, v);
-            await modal.message(result.applied ? "Fix applied" : "Fix failed", result.message, result.applied ? "success" : "error");
+            const results = [];
+            for (const v of selectedRow.violations) {
+                results.push(await applyDestructiveFix(cwd, v, selectedRow.rule.pattern));
+            }
+            const failed = results.filter((r) => !r.applied);
+            await reload();
+            // Success is silent — the reload removes the fixed row. Only surface a
+            // modal when something didn't apply.
+            if (failed.length > 0) {
+                await modal.message("Some fixes didn't apply", results.map((r) => r.message).join("\n"), "error");
+            }
         }
         catch (err) {
             await modal.message("Fix failed", err instanceof Error ? err.message : String(err), "error");
         }
-        await reload();
-    }, [selectedRow, handleApplySafe, modal, cwd, reload]);
+    }, [selectedRow, modal, cwd, reload]);
     const handleApplyTemplate = useCallback(async () => {
         const names = Object.keys(BUILTIN_TEMPLATES);
         if (names.length === 0) {
@@ -125,16 +181,32 @@ export function GitignoreScreen() {
         await reload();
     }, [cwd, modal, reload]);
     const handleEditManifest = useCallback(async () => {
-        const projectManifest = `${cwd}/.claude/gitignore.json`;
+        const current = data ?? await loadGitignoreState(cwd);
+        const projectManifest = await ensureProjectManifestForEdit(cwd, current.resolved);
         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());
-        });
+        renderer.suspend();
+        try {
+            await new Promise((resolveEdit) => {
+                const child = spawn(editor, [projectManifest], { stdio: "inherit" });
+                child.on("exit", () => resolveEdit());
+                child.on("error", () => resolveEdit());
+            });
+        }
+        finally {
+            renderer.resume();
+        }
         await reload();
-    }, [cwd, reload]);
+        renderer.requestRender();
+    }, [cwd, data, reload, renderer]);
     useKeyboardHandler((input, key) => {
+        if (process.env.CLAUDEUP_DEBUG_KEYS === "1") {
+            try {
+                appendFileSync("/tmp/claudeup-keys.log", `${new Date().toISOString()} screen=gitignore input=${JSON.stringify(input)} name=${JSON.stringify(key.name)} shift=${key.shift} ctrl=${key.ctrl} meta=${key.meta}\n`);
+            }
+            catch {
+                // best-effort logging — never break the UI
+            }
+        }
         if (state.modal)
             return;
         if (input === "j" || key.downArrow) {
@@ -145,12 +217,13 @@ export function GitignoreScreen() {
             setSelectedIdx((i) => Math.max(i - 1, 0));
             return;
         }
-        if (input === "f") {
-            void handleApplySafe();
+        // F = fix everything out of sync; f = fix just the selected row.
+        if (input === "F" || (input === "f" && key.shift)) {
+            void handleFixAll();
             return;
         }
-        if (input === "F") {
-            void handleApplySelected();
+        if (input === "f") {
+            void handleFixOne();
             return;
         }
         if (input === "t") {
@@ -166,62 +239,90 @@ export function GitignoreScreen() {
         }
     });
     // ── 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 summary = data
+        ? renderSummary(rows.length, ignoreRuleCount, trackRuleCount, toFixCount)
+        : 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." })) : (_jsxs("box", { flexDirection: "column", children: [toFixRows.length > 0 && (_jsxs("box", { flexDirection: "column", children: [_jsx("text", { fg: "red", children: `Needs fixing (${toFixRows.length})` }), toFixRows
+                        .slice(0, 100)
+                        .map(({ row, index }) => renderRuleRow(row, index === selectedIdx)), _jsx("text", { children: " " })] })), _jsx("text", { fg: "gray", children: `Managed items (${cleanCount})` }), sourceGroups.map((group, gi) => (_jsxs("box", { flexDirection: "column", children: [gi > 0 && _jsx("text", { children: " " }), _jsx("text", { fg: "gray", children: `  ${group.label}` }), group.items.map(({ row, index }) => renderRuleRow(row, index === selectedIdx))] }, group.tier)))] }));
     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"}`
+        ? toFixCount === 0
+            ? `${rows.length} managed`
+            : `${toFixCount} to fix`
         : "";
-    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 }));
+    return (_jsx(ScreenLayout, { title: "Managed Git State", subtitle: subtitle, currentScreen: "gitignore", footerHints: [
+            { keys: ["↑", "↓"], label: "move" },
+            { keys: ["f"], label: "fix selected" },
+            { keys: ["F"], label: "fix all" },
+            { keys: ["t"], label: "template" },
+            { keys: ["e"], label: "edit" },
+            { keys: ["r"], label: "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.
+function violationMatchesRule(rule, violation) {
+    if (violation.path === rule.pattern)
+        return true;
     if (!rule.pattern.endsWith("/") && !rule.pattern.includes("*"))
-        return undefined;
+        return false;
     const prefix = rule.pattern.replace(/\*+$/, "");
-    return violations.find((v) => v.path.startsWith(prefix));
+    return violation.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 renderSummary(rules, ignoreRules, trackRules, toFix) {
+    return (_jsxs("box", { flexDirection: "column", children: [_jsx("text", { children: _jsx("span", { fg: "white", children: `${rules} managed item${rules === 1 ? "" : "s"}` }) }), _jsx("text", { children: _jsx("span", { fg: "gray", children: `${ignoreRules} ignored  ${trackRules} tracked` }) }), toFix === 0 ? (_jsx("text", { fg: "green", children: "Everything matches \u2014 nothing to fix." })) : (_jsx("text", { fg: "yellow", children: `${toFix} need${toFix === 1 ? "s" : ""} fixing — f one, F all` }))] }));
 }
 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.` })] }));
+    const { rule, violations } = row;
+    const reason = getGitignoreRuleReason(rule.action, rule.pattern);
+    const setIn = sourceName(rule.source);
+    if (violations.length === 0) {
+        return (_jsxs("box", { flexDirection: "column", children: [_jsx("text", { fg: "white", children: _jsx("strong", { children: rule.pattern }) }), _jsx("text", { children: " " }), _jsx("text", { fg: "green", children: `✓ Already ${rule.action === "ignore" ? "ignored" : "tracked"} — nothing to do.` }), _jsx("text", { children: " " }), _jsx("text", { fg: "gray", children: reason }), _jsx("text", { children: " " }), _jsx("text", { fg: "gray", children: `Set in: ${setIn}` }), renderWarnings(warnings)] }));
+    }
+    return (_jsxs("box", { flexDirection: "column", children: [_jsx("text", { fg: "white", children: _jsx("strong", { children: rule.pattern }) }), _jsx("text", { children: " " }), _jsxs("text", { children: [_jsx("span", { fg: "gray", children: "Should be: " }), _jsx("span", { fg: "white", children: rule.action === "ignore" ? "ignored by git" : "tracked by git" })] }), _jsx("text", { fg: "gray", children: reason }), _jsx("text", { fg: "gray", children: `Set in: ${setIn}` }), _jsx("text", { children: " " }), _jsx("text", { fg: "yellow", children: `Needs fixing (${violations.length}):` }), violations.map((v, i) => (_jsxs("box", { flexDirection: "column", marginTop: i === 0 ? 0 : 1, children: [_jsx("text", { fg: "white", children: v.path }), _jsx("text", { fg: "gray", children: describeKind(v.kind) }), _jsx("text", { fg: v.severity === "safe" ? "cyan" : "red", children: actionHint(v.kind) })] }, `${v.kind}:${v.path}:${i}`))), renderWarnings(warnings)] }));
+}
+/** Friendly, where-to-change-it name for a rule's source manifest. */
+function sourceName(source) {
+    switch (source) {
+        case "project":
+            return "Project (.claude/gitignore.json)";
+        case "global":
+            return "Global (~/.claude/gitignore.json)";
+        case "profile":
+            return "Profile";
+        case "builtin":
+            return "Default (built into claudeup)";
     }
-    // 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.";
+        case "tracked-but-should-ignore":
+            return "Git is tracking it, but it should be ignored.";
+        case "ignored-but-should-track":
+            return "A .gitignore rule hides it, but it should be in git.";
+        case "untracked-and-should-track":
+            return "It's on disk but git isn't tracking it yet.";
+        case "missing-from-gitignore":
+            return "It should be ignored, but nothing in .gitignore covers it.";
     }
 }
 function actionHint(kind) {
     switch (kind) {
         case "tracked-but-should-ignore":
-            return "[F] runs `git rm --cached` and appends a .gitignore entry.";
+            return "Press f to stop tracking it and add it to .gitignore.";
         case "ignored-but-should-track":
-            return "[F] removes the matching .gitignore line and runs `git add`.";
+            return "Press f to remove the .gitignore line and add it to git.";
         case "untracked-and-should-track":
-            return "[F] runs `git add` to stage the path.";
+            return "Press f to add it to git.";
         case "missing-from-gitignore":
-            return "[f] appends this and every other safe entry to .gitignore.";
+            return "Press f to add it to .gitignore (F to fix all).";
     }
 }
+function renderWarnings(warnings) {
+    if (warnings.length === 0)
+        return null;
+    return (_jsxs("box", { flexDirection: "column", marginTop: 1, children: [_jsx("text", { fg: "yellow", children: "Warnings:" }), warnings.map((w, i) => (_jsx("text", { fg: "gray", children: w }, i)))] }));
+}