claudeup 4.15.1 → 4.17.0

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

package/src/ui/screens/GitignoreScreen.tsx

@@ -0,0 +1,364 @@
+import React, { 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,
+  type GitignoreState,
+} from "../../services/gitignore-service.js";
+import { BUILTIN_TEMPLATES } from "../../data/gitignore-templates.js";
+import { renderRuleRow, type RuleRow } from "../renderers/gitignoreRenderers.js";
+import type { ResolvedRule, Violation } from "../../types/gitignore.js";
+
+export function GitignoreScreen() {
+  const { state } = useApp();
+  const modal = useModal();
+  const cwd = state.projectPath;
+
+  const [data, setData] = useState<GitignoreState | null>(null);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<string | null>(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: RuleRow[] = useMemo(() => {
+    if (!data) return [];
+    const violationByPattern = new Map<string, Violation>();
+    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: RuleRow[] = 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<void>((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 ? (
+    <text fg="gray">Loading...</text>
+  ) : error ? (
+    <text fg="red">Error: {error}</text>
+  ) : rows.length === 0 ? (
+    <text fg="gray">No rules resolved.</text>
+  ) : (
+    <box flexDirection="column">
+      {rows.slice(0, 200).map((row, i) => renderRuleRow(row, i === selectedIdx))}
+    </box>
+  );
+
+  const listPanel = (
+    <box flexDirection="column">
+      {summary}
+      <text>{" "}</text>
+      {listBody}
+    </box>
+  );
+
+  const detailPanel = renderDetail(selectedRow, data?.warnings ?? []);
+
+  const subtitle = data
+    ? violationCount === 0
+      ? "all clean"
+      : `${violationCount} violation${violationCount === 1 ? "" : "s"}`
+    : "";
+
+  return (
+    <ScreenLayout
+      title="Gitignore Manager"
+      subtitle={subtitle}
+      currentScreen="gitignore"
+      footerHints="↑↓ move  f fix-all-safe  F fix-this  t tpl  e edit  r reload"
+      listPanel={listPanel}
+      detailPanel={detailPanel}
+    />
+  );
+}
+
+function findPrefixMatch(
+  rule: ResolvedRule,
+  violations: Violation[],
+): Violation | undefined {
+  // 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: number,
+  safe: number,
+  destructive: number,
+): React.ReactNode {
+  if (violations === 0) {
+    return <text fg="green">✓ All rules satisfied — nothing to fix.</text>;
+  }
+
+  return (
+    <text>
+      <span fg="white">{`${violations} violation${violations === 1 ? "" : "s"} `}</span>
+      <span fg="gray">{`(`}</span>
+      {safe > 0 && <span fg="yellow">{`${safe} safe`}</span>}
+      {safe > 0 && destructive > 0 && <span fg="gray">{`, `}</span>}
+      {destructive > 0 && <span fg="red">{`${destructive} destructive`}</span>}
+      <span fg="gray">{`)`}</span>
+    </text>
+  );
+}
+
+function renderDetail(
+  row: RuleRow | undefined,
+  warnings: string[],
+): React.ReactNode {
+  if (!row) {
+    return (
+      <box flexDirection="column">
+        <text fg="gray">No rule selected.</text>
+        {warnings.length > 0 && (
+          <box flexDirection="column" marginTop={1}>
+            <text fg="yellow">Warnings:</text>
+            {warnings.map((w, i) => (
+              <text fg="gray" key={i}>{w}</text>
+            ))}
+          </box>
+        )}
+      </box>
+    );
+  }
+
+  const { rule, violation } = row;
+
+  if (!violation) {
+    // Rule is satisfied — show what it enforces and where it came from
+    return (
+      <box flexDirection="column">
+        <text fg="white"><strong>{rule.pattern}</strong></text>
+        <text>{" "}</text>
+        <text fg="green">{`✓ ${rule.action === "ignore" ? "Ignored" : "Tracked"} as required.`}</text>
+        <text>{" "}</text>
+        <text fg="gray">{`Rule from ${rule.source} tier.`}</text>
+      </box>
+    );
+  }
+
+  // Rule is violated — explain and show the action
+  return (
+    <box flexDirection="column">
+      <text fg="white"><strong>{violation.path}</strong></text>
+      <text>{" "}</text>
+      <text fg="white">{describeKind(violation.kind)}</text>
+      <text>{" "}</text>
+      <text fg="gray">{`Rule from ${rule.source} tier.`}</text>
+      <text fg={violation.severity === "safe" ? "yellow" : "red"}>
+        {violation.severity === "safe"
+          ? "Safe — only appends to .gitignore."
+          : "Destructive — mutates the git index."}
+      </text>
+      <text>{" "}</text>
+      <text fg="cyan">{actionHint(violation.kind)}</text>
+    </box>
+  );
+}
+
+function describeKind(kind: Violation["kind"]): string {
+  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: Violation["kind"]): string {
+  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.";
+  }
+}

package/src/ui/screens/index.js

@@ -6,3 +6,4 @@ export { CliToolsScreen } from "./CliToolsScreen.js";
 export { ModelSelectorScreen } from "./ModelSelectorScreen.js";
 export { ProfilesScreen } from "./ProfilesScreen.js";
 export { SkillsScreen } from "./SkillsScreen.js";
+export { GitignoreScreen } from "./GitignoreScreen.js";

package/src/ui/screens/index.ts

@@ -6,3 +6,4 @@ export { CliToolsScreen } from "./CliToolsScreen.js";
 export { ModelSelectorScreen } from "./ModelSelectorScreen.js";
 export { ProfilesScreen } from "./ProfilesScreen.js";
 export { SkillsScreen } from "./SkillsScreen.js";
+export { GitignoreScreen } from "./GitignoreScreen.js";

package/src/ui/state/types.ts

@@ -20,7 +20,8 @@ export type Screen =
 	| "cli-tools"
 	| "model-selector"
 	| "profiles"
-	| "skills";
+	| "skills"
+	| "gitignore";
 
 export type Route =
 	| { screen: "plugins" }
@@ -30,7 +31,8 @@ export type Route =
 	| { screen: "cli-tools" }
 	| { screen: "model-selector" }
 	| { screen: "profiles" }
-	| { screen: "skills" };
+	| { screen: "skills" }
+	| { screen: "gitignore" };
 
 // ============================================================================
 // Async Data Types