Add regression tests then fix fifth round of Copilot review comments

Tests added first (src/render.test.ts) as regression guards for the three
tui.ts-level state bugs — they exercise the pure functions involved and
document the correct behavior that the tui.ts fixes must preserve:

- isCursorVisible: stale scrollOffset > cursor (result of filter shrinking
  rows without clamping scrollOffset) always returns false, confirming the
  cursor is above the viewport and scrollOffset must be clamped
- buildRows + isCursorVisible: invalid regex after toggle produces 0 rows;
  cursor at former position is out-of-range and must be re-clamped to 0
  (Math.min(cursor, Math.max(0, rows.length - 1)))
- renderGroups: sticky repo header (\u25b2) is NOT shown when cursor is on a repo
  row even when scrollOffset > 0 (only shown on extract rows whose repo row
  has scrolled above the viewport)

Fixes (src/tui.ts):

1. stickyHeaderLines condition in getViewportHeight(): change
   \`scrollOffset > 0 ? 1 : 0\` to \`scrollOffset > 0 && cursor >= scrollOffset ? 1 : 0\`
   so the viewport is only shrunk by one when a sticky header will actually
   be rendered by renderGroups, preventing premature scroll-stop on repo rows.

2. scrollOffset not clamped after filter reduces rows: add
   \`scrollOffset = Math.min(scrollOffset, cursor)\` after cursor clamping in
   Ctrl+W/Alt+Backspace, Backspace, Del, and printable-char (paste) handlers.
   Without this, a previously-scrolled viewport could remain beyond the end
   of the shrunken row list, producing an empty groups area with no recovery.

3. Tab toggle (filterRegex) did not rebuild rows or clamp cursor/scrollOffset:
   after \`filterRegex = !filterRegex\`, now calls buildRows and applies the
   same clamping as all other filter-state-changing handlers.

See PR #65

Author: shouze

src/render.test.ts

@@ -421,6 +421,25 @@ describe("isCursorVisible", () => {
     const rows = buildRows(groups);
     expect(isCursorVisible(rows, groups, 0, 0, 10)).toBe(true);
   });
+
+  it("returns false when scrollOffset is stale (greater than cursor after filter shrinks rows)", () => {
+    // Regression guard for Bug 2: in filter-mode edit handlers (Backspace, Del,
+    // word-delete, paste) tui.ts clamps `cursor` to the new rows length but does
+    // NOT clamp `scrollOffset`. When the filter reduces rows, cursor is clamped
+    // down but scrollOffset can remain larger than cursor, causing the cursor to
+    // appear "above the viewport" — isCursorVisible returns false and the while
+    // loop `while (scrollOffset < cursor ...)` never runs (already false), so the
+    // tui gets stuck showing an empty groups area.
+    //
+    // Scenario: 4 rows, user was at cursor=3, scrollOffset=2. Filter reduces rows
+    // to 2. Cursor clamped to 1. scrollOffset NOT clamped → still 2 > cursor=1.
+    const groups = [makeGroup("org/repo", ["a.ts", "b.ts", "c.ts"], false)];
+    const rows = buildRows(groups); // [repo, ext0, ext1, ext2]
+    // cursor=1 but scrollOffset=2: cursor is *above* the viewport window
+    expect(isCursorVisible(rows, groups, 1, 2, 10)).toBe(false);
+    // The fix: clamp scrollOffset = Math.min(scrollOffset, cursor) = Math.min(2,1) = 1
+    expect(isCursorVisible(rows, groups, 1, 1, 10)).toBe(true);
+  });
 });
 
 // ─── buildSummaryFull ──────────────────────────────────────────────────────────────
@@ -593,6 +612,27 @@ describe("renderGroups", () => {
     expect(stripped).toContain("org/repoA"); // repo name shown in sticky line
   });
 
+  it("does NOT show sticky repo header when cursor is on a repo row (even with scrollOffset > 0)", () => {
+    // Regression guard for Bug 1: getViewportHeight() in tui.ts used to subtract
+    // a sticky-header line whenever scrollOffset > 0, but renderGroups only shows
+    // the sticky header when the cursor is on an *extract* row whose repo header
+    // has scrolled above the viewport. When cursor is on a repo row, no sticky
+    // header is emitted and the subtracted line makes isCursorVisible() return
+    // false prematurely (the cursor appears invisible one step too early).
+    //
+    // rows: [repo(0), ext(0,0), repo(1), ext(1,0)]
+    // cursor=2 (repo1), scrollOffset=1 → repo(0) < scrollOffset, but cursor is on
+    // repo(1), not an extract → sticky header must NOT be shown.
+    const groups = [
+      makeGroup("org/repoA", ["a.ts"], false),
+      makeGroup("org/repoB", ["b.ts"], false),
+    ];
+    const rows = buildRows(groups);
+    const out = renderGroups(groups, 2, rows, 40, 1, "q", "org");
+    const stripped = out.replace(/\x1b\[[0-9;]*m/g, "");
+    expect(stripped).not.toContain("▲");
+  });
+
   it("stops rendering rows when viewport is filled (overflow break)", () => {
     // Extract rows with fragments have h=2; with termHeight=9 viewportHeight=2
     // row0(repo,h=1): fits. row1(ext,h=2): 1+2=3 > 2 AND usedLines=1>0 → break
@@ -1061,6 +1101,34 @@ describe("buildRows (filterTarget + filterRegex)", () => {
     const extracts = rows.filter((r) => r.type === "extract");
     expect(extracts.length).toBe(0);
   });
+
+  it("toggling regex to invalid pattern collapses rows to 0 — cursor must be clamped (regression guard for Bug 3)", () => {
+    // Regression guard for Bug 3: the Tab key in tui.ts toggles filterRegex but
+    // did not rebuild rows or clamp cursor/scrollOffset afterward. When the new
+    // regex is invalid (or simply more restrictive), the row list shrinks. If
+    // cursor was pointing at a now-removed row, isCursorVisible returns false yet
+    // the scroll-adjust while-loop doesn't fire (cursor is already 0 or the
+    // condition `scrollOffset < cursor` is already false), leaving cursor
+    // pointing at an invalid index — renderGroups skips the cursor highlight.
+    //
+    // The fix: after `filterRegex = !filterRegex`, rebuild rows and clamp:
+    //   const newRows = buildRows(groups, filterInput, filterTarget, filterRegex);
+    //   cursor = Math.min(cursor, Math.max(0, newRows.length - 1));
+    //   scrollOffset = Math.min(scrollOffset, cursor);
+    const groups = [makeGroup("org/repo", ["src/foo.ts", "src/bar.ts"], false)];
+    // Before toggle: regex=false, pattern="src" → 2 extract rows visible
+    const rowsBefore = buildRows(groups, "src", "path", false);
+    expect(rowsBefore.filter((r) => r.type === "extract")).toHaveLength(2);
+    let cursor = 2; // cursor on second extract
+    // After toggle to regex=true with an invalid pattern:
+    const rowsAfter = buildRows(groups, "[invalid", "path", true);
+    expect(rowsAfter).toHaveLength(0); // invalid regex → no matches, no rows
+    // isCursorVisible with stale cursor (still 2, rows=[]) must return false
+    expect(isCursorVisible(rowsAfter, groups, cursor, 0, 10)).toBe(false);
+    // The required clamp:
+    cursor = Math.min(cursor, Math.max(0, rowsAfter.length - 1));
+    expect(cursor).toBe(0);
+  });
 });
 
 // ─── buildFilterStats — filterTarget + filterRegex ───────────────────────────

src/tui.ts

@@ -93,9 +93,12 @@ export async function runInteractive(
     let barLines = 0;
     if (filterMode) barLines = 2;
     else if (filterPath || filterTarget !== "path" || filterRegex) barLines = 1;
-    // When scrolled past the top, renderGroups shows a sticky repo header
-    // that consumes one additional line from the available viewport.
-    const stickyHeaderLines = scrollOffset > 0 ? 1 : 0;
+    // When scrolled past the top and the cursor is within the visible window,
+    // renderGroups may show a sticky repo header that consumes one extra line.
+    // Mirror the condition precisely: sticky only appears when the cursor row is
+    // an extract whose repo row has scrolled above the viewport (repoRowIndex <
+    // scrollOffset). `cursor >= scrollOffset` is the necessary pre-condition.
+    const stickyHeaderLines = scrollOffset > 0 && cursor >= scrollOffset ? 1 : 0;
     return termHeight - 6 - barLines - stickyHeaderLines;
   };
 
@@ -175,8 +178,12 @@ export async function runInteractive(
         cursor = Math.min(cursor, Math.max(0, newRows.length - 1));
         scrollOffset = Math.min(scrollOffset, cursor);
       } else if (key === KEY_TAB) {
-        // Tab — toggle regex mode
+        // Tab — toggle regex mode; rebuilds rows immediately and clamps
+        // cursor/scrollOffset so the current position stays valid.
         filterRegex = !filterRegex;
+        const newRows = buildRows(groups, filterInput, filterTarget, filterRegex);
+        cursor = Math.min(cursor, Math.max(0, newRows.length - 1));
+        scrollOffset = Math.min(scrollOffset, cursor);
         scheduleStatsUpdate();
       } else if (key === ANSI_ARROW_LEFT) {
         // ← — move cursor left
@@ -203,19 +210,22 @@ export async function runInteractive(
         filterCursor = newPos;
         const newRows = buildRows(groups, filterInput, filterTarget, filterRegex);
         cursor = Math.min(cursor, Math.max(0, newRows.length - 1));
+        scrollOffset = Math.min(scrollOffset, cursor);
         scheduleStatsUpdate();
       } else if ((key === "\x7f" || key === "\b") && filterCursor > 0) {
         // Backspace — delete char before cursor
         filterInput = filterInput.slice(0, filterCursor - 1) + filterInput.slice(filterCursor);
         filterCursor--;
-        const newRows = buildRows(groups, filterInput, filterTarget, filterRegex);
-        cursor = Math.min(cursor, Math.max(0, newRows.length - 1));
+        const newRows2 = buildRows(groups, filterInput, filterTarget, filterRegex);
+        cursor = Math.min(cursor, Math.max(0, newRows2.length - 1));
+        scrollOffset = Math.min(scrollOffset, cursor);
         scheduleStatsUpdate();
       } else if (key === KEY_DELETE && filterCursor < filterInput.length) {
         // Del — delete char at cursor
         filterInput = filterInput.slice(0, filterCursor) + filterInput.slice(filterCursor + 1);
-        const newRows = buildRows(groups, filterInput, filterTarget, filterRegex);
-        cursor = Math.min(cursor, Math.max(0, newRows.length - 1));
+        const newRows3 = buildRows(groups, filterInput, filterTarget, filterRegex);
+        cursor = Math.min(cursor, Math.max(0, newRows3.length - 1));
+        scrollOffset = Math.min(scrollOffset, cursor);
         scheduleStatsUpdate();
       } else if (key === KEY_SHIFT_TAB) {
         // Shift+Tab — cycle filter target (path → content → repo → path)
@@ -243,6 +253,7 @@ export async function runInteractive(
           filterCursor += printable.length;
           const newRows = buildRows(groups, filterInput, filterTarget, filterRegex);
           cursor = Math.min(cursor, Math.max(0, newRows.length - 1));
+          scrollOffset = Math.min(scrollOffset, cursor);
           scheduleStatsUpdate();
         }
       }