nugit-cli 0.0.1 → 0.1.1

package/src/stack-view/stack-pick-sort.js

@@ -0,0 +1,188 @@
+/**
+ * @param {{ tip_updated_at?: string }[]} stacks
+ * @param {number} max
+ */
+export function sortStacksByRecentActivity(stacks, max) {
+  const sorted = [...stacks].sort((a, b) => {
+    const ta = Date.parse(String(a.tip_updated_at || "")) || 0;
+    const tb = Date.parse(String(b.tip_updated_at || "")) || 0;
+    return tb - ta;
+  });
+  return sorted.slice(0, Math.max(1, max));
+}
+
+/**
+ * @param {number | null | undefined} viewingTipPrNumber
+ * @param {string | null | undefined} viewingHeadRef
+ */
+export function hasPickerViewingContext(viewingTipPrNumber, viewingHeadRef) {
+  if (viewingTipPrNumber != null) {
+    return true;
+  }
+  return typeof viewingHeadRef === "string" && viewingHeadRef.trim().length > 0;
+}
+
+/**
+ * True if stack row's tip branch or any PR head branch equals `href`.
+ *
+ * @param {{ tip_head_branch?: string, prs?: { head_branch?: string }[] }} s
+ * @param {string} href non-empty trimmed ref
+ */
+export function stackRowHeadRefMatches(s, href) {
+  if (typeof s.tip_head_branch === "string" && s.tip_head_branch.trim() === href) {
+    return true;
+  }
+  if (Array.isArray(s.prs)) {
+    return s.prs.some(
+      (p) =>
+        p &&
+        typeof p === "object" &&
+        typeof p.head_branch === "string" &&
+        p.head_branch.trim() === href
+    );
+  }
+  return false;
+}
+
+/**
+ * How many picker rows reference `href` on tip or on a PR in the chain.
+ *
+ * @param {unknown[]} stacks
+ * @param {string} href trimmed non-empty
+ */
+export function countStacksMatchingHeadRef(stacks, href) {
+  if (!href || !Array.isArray(stacks)) {
+    return 0;
+  }
+  let n = 0;
+  for (const raw of stacks) {
+    if (!raw || typeof raw !== "object") {
+      continue;
+    }
+    if (stackRowHeadRefMatches(/** @type {{ tip_head_branch?: string, prs?: unknown[] }} */ (raw), href)) {
+      n += 1;
+    }
+  }
+  return n;
+}
+
+/**
+ * Tip PR# matches row tip or appears in `prs`.
+ *
+ * @param {{ tip_pr_number: number, prs?: { pr_number?: number }[] }} s
+ * @param {number} vt
+ */
+function stackRowTipNumberMatches(s, vt) {
+  if (s.tip_pr_number === vt) {
+    return true;
+  }
+  if (Array.isArray(s.prs)) {
+    return s.prs.some((p) => p && typeof p === "object" && p.pr_number === vt);
+  }
+  return false;
+}
+
+/**
+ * Match discovery stack row to the stack currently open in the viewer (tip PR, tip branch, or any PR in chain).
+ * Pass `allStacks` (full picker list) so a unique `viewingHeadRef` wins over a stale `viewingTipPrNumber`
+ * (avoids two "open in viewer" highlights).
+ *
+ * @param {{ tip_pr_number: number, tip_head_branch?: string, prs?: { pr_number?: number, head_branch?: string }[] }} s
+ * @param {number | null | undefined} viewingTipPrNumber
+ * @param {string | null | undefined} viewingHeadRef
+ * @param {unknown[] | null | undefined} [allStacks] full list for head-ref disambiguation
+ */
+/**
+ * At most one row in `visible` should show "open in viewer" when several chains share a PR# or match loosely.
+ *
+ * @param {{ tip_pr_number: number, tip_head_branch?: string, prs?: { pr_number?: number, head_branch?: string }[] }[]} visible
+ * @param {number | null | undefined} viewingTipPrNumber
+ * @param {string | null | undefined} viewingHeadRef
+ * @param {unknown[] | null | undefined} [allStacks] match context for {@link matchesPickerViewingStack}
+ * @returns {number} index in `visible`, or -1 if none
+ */
+export function pickViewingHighlightIndex(visible, viewingTipPrNumber, viewingHeadRef, allStacks) {
+  if (!Array.isArray(visible) || visible.length === 0) {
+    return -1;
+  }
+  const ctx = Array.isArray(allStacks) && allStacks.length > 0 ? allStacks : visible;
+  /** @type {number[]} */
+  const idxs = [];
+  for (let i = 0; i < visible.length; i++) {
+    const s = visible[i];
+    if (s && typeof s === "object" && matchesPickerViewingStack(s, viewingTipPrNumber, viewingHeadRef, ctx)) {
+      idxs.push(i);
+    }
+  }
+  if (idxs.length === 0) {
+    return -1;
+  }
+  if (idxs.length === 1) {
+    return idxs[0];
+  }
+  const vt = viewingTipPrNumber;
+  if (vt != null) {
+    for (const i of idxs) {
+      const s = visible[i];
+      if (s && typeof s === "object" && /** @type {{ tip_pr_number?: number }} */ (s).tip_pr_number === vt) {
+        return i;
+      }
+    }
+  }
+  const href = typeof viewingHeadRef === "string" ? viewingHeadRef.trim() : "";
+  if (href.length > 0) {
+    for (const i of idxs) {
+      const s = visible[i];
+      if (s && typeof s === "object" && stackRowHeadRefMatches(/** @type {{ tip_head_branch?: string, prs?: unknown[] }} */ (s), href)) {
+        return i;
+      }
+    }
+  }
+  return idxs[0];
+}
+
+export function matchesPickerViewingStack(s, viewingTipPrNumber, viewingHeadRef, allStacks) {
+  const href = typeof viewingHeadRef === "string" ? viewingHeadRef.trim() : "";
+  const vt = viewingTipPrNumber;
+
+  if (href.length > 0 && Array.isArray(allStacks) && allStacks.length > 0) {
+    const c = countStacksMatchingHeadRef(allStacks, href);
+    if (c === 1) {
+      return stackRowHeadRefMatches(s, href);
+    }
+    if (c === 0) {
+      if (vt == null) {
+        return false;
+      }
+      return stackRowTipNumberMatches(s, vt);
+    }
+    if (vt != null) {
+      return stackRowTipNumberMatches(s, vt) && stackRowHeadRefMatches(s, href);
+    }
+    return stackRowHeadRefMatches(s, href);
+  }
+
+  if (vt != null && s.tip_pr_number === vt) {
+    return true;
+  }
+  if (href.length > 0 && typeof s.tip_head_branch === "string" && s.tip_head_branch.trim() === href) {
+    return true;
+  }
+  if (vt != null && Array.isArray(s.prs)) {
+    return s.prs.some((p) => p && typeof p === "object" && p.pr_number === vt);
+  }
+  return false;
+}
+
+/**
+ * Full list when returning from viewer; top 10 on first pick.
+ *
+ * @param {{ tip_updated_at?: string }[]} stacks
+ * @param {{ viewingTipPrNumber?: number | null, viewingHeadRef?: string | null }} [opts]
+ */
+export function buildPickerVisibleStacks(stacks, opts) {
+  const cap = hasPickerViewingContext(opts?.viewingTipPrNumber, opts?.viewingHeadRef)
+    ? Math.max(stacks.length, 1)
+    : 10;
+  return sortStacksByRecentActivity(stacks, cap);
+}

package/src/stack-view/stack-picker-graph-pane.js

@@ -0,0 +1,118 @@
+import chalk from "chalk";
+
+/**
+ * Build ASCII railroad graph lines for the split-pane stack picker left column.
+ *
+ * Structure (tip-first per stack, dots connected by explicit vertical lines):
+ *
+ *   main                   ← base_ref label
+ *   │
+ *   ├─● feat/tip           ← fork row: tip PR (selected: yellow, others: dim)
+ *   │ │                    ← connecting line between consecutive PR nodes
+ *   │ ● feat/base          ← cont row: bottom PR
+ *   │
+ *   ├─◯ feat/b-tip         ← another stack (dim)
+ *   └─◯ feat/c             ← last stack (dim)
+ *
+ * The branch `│` connector at col 3 runs through all PR nodes of the same
+ * stack so dots appear visually linked. The trunk `│` at col 1 connects
+ * stacks back to the base branch.
+ *
+ * @param {Array<{
+ *   tip_pr_number: number,
+ *   tip_head_branch?: string,
+ *   pr_count?: number,
+ *   base_ref?: string,
+ *   prs?: Array<{ pr_number: number, head_branch?: string, title?: string }>
+ * }>} stacks
+ * @param {number} selectedIndex  cursor (0-based into stacks)
+ * @param {number} paneW          total character width of the left column
+ * @param {number} paneH          total character height (rows) available
+ * @returns {string[]}            exactly paneH lines
+ */
+export function buildSplitGraphPane(stacks, selectedIndex, paneW, paneH) {
+  if (!stacks.length) {
+    return Array.from({ length: paneH }, () => "");
+  }
+
+  const n = stacks.length;
+  const baseRef = (stacks[0]?.base_ref || "main").slice(0, paneW - 2);
+
+  /** @type {string[]} */
+  const rows = [];
+
+  // Header: base branch label + initial trunk
+  rows.push(chalk.dim.gray(` ${baseRef}`));
+  rows.push(chalk.dim.gray(" │"));
+
+  // Available rows for all stacks (min 3 per stack for fork+conn+node)
+  const available = Math.max(n * 3, paneH - 2);
+  const rowsPerStack = Math.max(3, Math.floor(available / n));
+
+  const labelW = Math.max(4, paneW - 6);
+
+  for (let si = 0; si < n; si++) {
+    const stack = stacks[si];
+    const sel = si === selectedIndex;
+    const isLast = si === n - 1;
+
+    // PRs ordered tip-first (tip = highest = top of branch in graph)
+    const rawPrs = Array.isArray(stack.prs) && stack.prs.length > 0
+      ? [...stack.prs].reverse()
+      : [{ pr_number: stack.tip_pr_number, head_branch: stack.tip_head_branch }];
+
+    const forkPrefix = isLast ? " └─" : " ├─"; // 3 chars; node lands at col 3
+    const trunkCont  = isLast ? "   " : " │ "; // 3 chars; keeps trunk + branch lane aligned
+
+    // Color helpers
+    const nodeChar   = sel ? chalk.yellow("●") : chalk.dim.gray("○");
+    const connChar   = sel ? chalk.yellow("│") : chalk.dim.gray("│");
+    const forkCol    = sel ? chalk.yellow      : chalk.dim.gray;
+    const labelCol   = sel ? chalk.yellowBright : chalk.dim.gray;
+
+    /** @param {number} idx index into reversed prs array */
+    const getLabel = (idx) => {
+      const pr = rawPrs[idx];
+      if (!pr) return "";
+      const name = typeof pr.head_branch === "string" && pr.head_branch
+        ? pr.head_branch
+        : `#${pr.pr_number}`;
+      return name.slice(0, labelW);
+    };
+
+    let pushed = 0; // rows pushed for this stack
+
+    // Fork row (tip PR)
+    if (rows.length < paneH) {
+      rows.push(forkCol(forkPrefix) + nodeChar + " " + labelCol(getLabel(0)));
+      pushed++;
+    }
+
+    // Additional PR nodes, each preceded by an explicit connecting line
+    let prIdx = 1;
+    while (prIdx < rawPrs.length && pushed < rowsPerStack - 1 && rows.length < paneH) {
+      // Connecting vertical line between previous node and this one
+      if (pushed < rowsPerStack - 1 && rows.length < paneH) {
+        rows.push(chalk.dim.gray(trunkCont) + connChar);
+        pushed++;
+      }
+      // PR node
+      if (pushed < rowsPerStack && rows.length < paneH) {
+        const nd = sel ? chalk.yellow("●") : chalk.dim.gray("○");
+        rows.push(chalk.dim.gray(trunkCont) + nd + " " + labelCol(getLabel(prIdx)));
+        pushed++;
+        prIdx++;
+      }
+    }
+
+    // Padding rows: trunk continues between stacks; last stack pads with empty
+    while (pushed < rowsPerStack && rows.length < paneH) {
+      rows.push(isLast ? "" : chalk.dim.gray(" │"));
+      pushed++;
+    }
+  }
+
+  // Fill remaining rows to exactly paneH
+  while (rows.length < paneH) rows.push("");
+  return rows.slice(0, paneH);
+}

package/src/stack-view/terminal-fullscreen.js

@@ -0,0 +1,7 @@
+// Re-exported from cli/src/utilities/terminal.js — import from there for new code.
+export {
+  isAlternateScreenDisabled,
+  enterAlternateScreen,
+  leaveAlternateScreen,
+  clearInkScreen
+} from "../utilities/terminal.js";

package/src/stack-view/tree-ascii.js

@@ -0,0 +1,73 @@
+/**
+ * Build navigable ASCII tree rows from GitHub flat git/trees entries (sorted paths).
+ * @param {{ path: string, type: string }[]} entries
+ * @returns {{ text: string, path: string | null, isFile: boolean }[]}
+ */
+export function buildAsciiTreeRows(entries) {
+  if (!entries.length) {
+    return [];
+  }
+
+  /** @typedef {{ children: Map<string, Node>, isFile: boolean, fullPath: string }} Node */
+  /** @type {Map<string, Node>} */
+  const root = new Map();
+
+  /**
+   * @param {Map<string, Node>} level
+   * @param {string[]} parts
+   * @param {boolean} isBlob
+   * @param {string} fullPath
+   */
+  function ensurePath(level, parts, isBlob, fullPath) {
+    if (parts.length === 0) return;
+    const [head, ...rest] = parts;
+    if (!level.has(head)) {
+      level.set(head, { children: new Map(), isFile: false, fullPath: "" });
+    }
+    const n = /** @type {Node} */ (level.get(head));
+    if (rest.length === 0) {
+      n.isFile = isBlob;
+      n.fullPath = fullPath;
+    } else {
+      ensurePath(n.children, rest, isBlob, fullPath);
+    }
+  }
+
+  for (const e of entries) {
+    const parts = e.path.split("/").filter(Boolean);
+    if (parts.length === 0) continue;
+    const isBlob = e.type === "blob";
+    ensurePath(root, parts, isBlob, e.path);
+  }
+
+  /** @type {{ text: string, path: string | null, isFile: boolean }[]} */
+  const out = [];
+
+  /**
+   * @param {Map<string, Node>} nodeMap
+   * @param {string} prefix
+   */
+  function walk(nodeMap, prefix) {
+    const keys = [...nodeMap.keys()].sort((a, b) => a.localeCompare(b));
+    keys.forEach((key, i) => {
+      const last = i === keys.length - 1;
+      const node = /** @type {Node} */ (nodeMap.get(key));
+      // Box-drawing: ├── / └── (tee and corner) + │ continuation
+      const branch = last ? "\u2514\u2500\u2500 " : "\u251c\u2500\u2500 ";
+      const name = node.isFile ? key : `${key}/`;
+      const line = prefix + branch + name;
+      out.push({
+        text: line,
+        path: node.isFile ? node.fullPath : null,
+        isFile: node.isFile
+      });
+      if (node.children.size > 0) {
+        const ext = last ? "    " : "\u2502   ";
+        walk(node.children, prefix + ext);
+      }
+    });
+  }
+
+  walk(root, "");
+  return out;
+}

package/src/stack-view/view-md-plain.js

@@ -0,0 +1,23 @@
+/**
+ * Very small markdown → readable plain text for TUI PR bodies (no new deps).
+ * @param {string} md
+ * @returns {string}
+ */
+export function markdownToPlainLines(md) {
+  if (!md || typeof md !== "string") {
+    return "";
+  }
+  let s = md.replace(/\r\n/g, "\n");
+  s = s.replace(/```[\s\S]*?```/g, (block) => {
+    const inner = block.replace(/^```\w*\n?/, "").replace(/```$/, "");
+    return "\n" + inner.trim() + "\n";
+  });
+  s = s.replace(/^#{1,6}\s+/gm, "");
+  s = s.replace(/^\s*[-*+]\s+/gm, "• ");
+  s = s.replace(/`([^`]+)`/g, "$1");
+  s = s.replace(/\*\*([^*]+)\*\*/g, "$1");
+  s = s.replace(/\*([^*]+)\*/g, "$1");
+  s = s.replace(/\[([^\]]+)\]\([^)]+\)/g, "$1");
+  s = s.replace(/\n{3,}/g, "\n\n");
+  return s.trim();
+}

package/src/stack-view/view-repo-picker-ink.js

@@ -0,0 +1,293 @@
+import React, { useEffect, useRef, useState } from "react";
+import { Box, Text, useApp, useInput, render, useStdout } from "ink";
+import chalk from "chalk";
+import { parseSgrMouse, enableSgrMouse, disableSgrMouse, isWheelUp, isWheelDown } from "./sgr-mouse.js";
+import { getRepoMetadata, searchRepositories } from "../api-client.js";
+import { getRepoFullNameFromGitRoot } from "../git-info.js";
+import { findGitRoot, parseRepoFullName } from "../nugit-stack.js";
+import { clearInkScreen } from "./terminal-fullscreen.js";
+
+/**
+ * @typedef {{ repo: string, ref: string }} PickedRepoRef
+ */
+
+/**
+ * Ink TUI: pick owner/repo; ref is the GitHub default branch unless you use CLI args.
+ * @returns {Promise<PickedRepoRef>}
+ */
+/**
+ * @returns {Promise<PickedRepoRef | null>}
+ */
+export async function runRepoPickerFlow() {
+  const exitPayload = /** @type {{ result: PickedRepoRef | null }} */ ({ result: null });
+  clearInkScreen();
+  const { waitUntilExit } = render(React.createElement(ViewRepoPickerApp, { exitPayload }));
+  await waitUntilExit();
+  return exitPayload.result;
+}
+
+export async function renderViewRepoPicker() {
+  const r = await runRepoPickerFlow();
+  if (!r) {
+    throw new Error("Cancelled.");
+  }
+  return r;
+}
+
+/**
+ * @param {{ exitPayload: { result: PickedRepoRef | null } }} props
+ */
+function ViewRepoPickerApp({ exitPayload }) {
+  const { exit } = useApp();
+  const { stdout } = useStdout();
+  /** @type {React.MutableRefObject<{ firstHitRow: number, viewStart: number, windowLen: number } | null>} */
+  const resultsLayoutRef = useRef(null);
+  /** @type {React.MutableRefObject<{ t: number, idx: number } | null>} */
+  const lastResultsClickRef = useRef(null);
+
+  useEffect(() => {
+    enableSgrMouse(stdout);
+    return () => disableSgrMouse(stdout);
+  }, [stdout]);
+
+  const root = findGitRoot();
+  let cwdRepo = null;
+  if (root) {
+    try {
+      cwdRepo = getRepoFullNameFromGitRoot(root);
+    } catch {
+      cwdRepo = null;
+    }
+  }
+
+  /** @type {'home' | 'search' | 'results'} */
+  const [step, setStep] = useState("home");
+  const [searchLine, setSearchLine] = useState("");
+  const [err, setErr] = useState(/** @type {string | null} */ (null));
+  const [loading, setLoading] = useState(false);
+  /** @type {{ full_name: string, description?: string }[]} */
+  const [hits, setHits] = useState([]);
+  const [cursor, setCursor] = useState(0);
+
+  const finishWith = async (repoFull) => {
+    setLoading(true);
+    setErr(null);
+    try {
+      const { owner, repo } = parseRepoFullName(repoFull);
+      const meta = await getRepoMetadata(owner, repo);
+      const ref = meta.default_branch || "main";
+      exitPayload.result = { repo: repoFull, ref };
+      exit();
+    } catch (e) {
+      setErr(String(/** @type {{ message?: string }} */ (e)?.message || e));
+      setLoading(false);
+    }
+  };
+
+  const currentHit = hits.length ? hits[Math.min(cursor, hits.length - 1)] : null;
+
+  useInput((input, key) => {
+    if (loading) return;
+
+    const mouse = parseSgrMouse(input);
+    if (mouse && step === "results" && hits.length) {
+      const L = resultsLayoutRef.current;
+      if (!L) {
+        return;
+      }
+      const { row, col, button, release } = mouse;
+      if (col < 2) {
+        return;
+      }
+      if (isWheelUp(button) || isWheelDown(button)) {
+        if (isWheelDown(button)) {
+          setCursor((c) => Math.min(c + 1, Math.max(0, hits.length - 1)));
+        } else {
+          setCursor((c) => Math.max(c - 1, 0));
+        }
+        return;
+      }
+      if (release) {
+        return;
+      }
+      const local = row - L.firstHitRow;
+      if (local >= 0 && local < L.windowLen) {
+        const i = L.viewStart + local;
+        setCursor(i);
+        const hit = hits[i];
+        if (hit) {
+          const now = Date.now();
+          const prev = lastResultsClickRef.current;
+          const dbl = prev && prev.idx === i && now - prev.t < 480;
+          lastResultsClickRef.current = { t: now, idx: i };
+          if (dbl) {
+            void finishWith(hit.full_name);
+          }
+        }
+      }
+      return;
+    }
+
+    if (key.escape || input === "q") {
+      exitPayload.result = null;
+      exit();
+      return;
+    }
+
+    if (step === "home") {
+      const homeBack =
+        key.backspace || key.delete || input === "\x7f" || input === "\b";
+      if (homeBack) {
+        exitPayload.result = null;
+        exit();
+        return;
+      }
+      if (key.return && cwdRepo) {
+        void finishWith(cwdRepo);
+        return;
+      }
+      if (input === "s" || input === "/") {
+        setStep("search");
+        setSearchLine("");
+        setErr(null);
+      }
+      return;
+    }
+
+    if (step === "search") {
+      if (key.return) {
+        const q = searchLine.trim();
+        if (!q) {
+          setErr("Enter a search query (e.g. user:octocat or a project name).");
+          return;
+        }
+        setLoading(true);
+        setErr(null);
+        searchRepositories(q, 15, 1)
+          .then((data) => {
+            const items = Array.isArray(data.items) ? data.items : [];
+            const mapped = items
+              .map((it) =>
+                it && typeof it === "object" && typeof it.full_name === "string"
+                  ? { full_name: it.full_name, description: String(it.description || "").slice(0, 72) }
+                  : null
+              )
+              .filter(Boolean);
+            setHits(/** @type {{ full_name: string, description?: string }[]} */ (mapped));
+            setCursor(0);
+            setStep("results");
+            if (!mapped.length) {
+              setErr("No repositories matched.");
+            }
+          })
+          .catch((e) => {
+            setErr(String(e?.message || e));
+            setStep("search");
+          })
+          .finally(() => setLoading(false));
+        return;
+      }
+      if (key.backspace || key.delete) {
+        setSearchLine((s) => s.slice(0, -1));
+        return;
+      }
+      if (input && !key.ctrl && !key.meta) {
+        setSearchLine((s) => s + input);
+      }
+      return;
+    }
+
+    if (step === "results") {
+      if (/^[1-9]$/.test(input) && hits.length) {
+        const n = Number.parseInt(input, 10) - 1;
+        if (n < hits.length) {
+          void finishWith(hits[n].full_name);
+        }
+        return;
+      }
+      if (input === "j" || key.downArrow) {
+        setCursor((c) => Math.min(c + 1, Math.max(0, hits.length - 1)));
+        return;
+      }
+      if (input === "k" || key.upArrow) {
+        setCursor((c) => Math.max(c - 1, 0));
+        return;
+      }
+      if ((key.return || input === " ") && currentHit) {
+        void finishWith(currentHit.full_name);
+        return;
+      }
+      if (input === "b") {
+        setStep("search");
+        setErr(null);
+      }
+    }
+  });
+
+  if (step === "home") {
+    return React.createElement(
+      Box,
+      { flexDirection: "column", padding: 1 },
+      React.createElement(Text, { color: "cyan", bold: true }, "nugit view — choose repository"),
+      cwdRepo
+        ? React.createElement(
+            Text,
+            null,
+            chalk.whiteBright("Enter "),
+            `this directory: ${chalk.bold(cwdRepo)}`
+          )
+        : React.createElement(Text, { dimColor: true }, "(no github.com remote — pick [s] to search)"),
+      React.createElement(Text, null, chalk.gray("[s] or [/] "), "Search GitHub by user, name, or query"),
+      React.createElement(Text, { dimColor: true }, "Backspace or [q] quit"),
+      err ? React.createElement(Text, { color: "red" }, err) : null,
+      loading ? React.createElement(Text, null, chalk.yellow("Loading…")) : null
+    );
+  }
+
+  if (step === "search") {
+    return React.createElement(
+      Box,
+      { flexDirection: "column", padding: 1 },
+      React.createElement(Text, { color: "cyan", bold: true }, "Search repositories"),
+      React.createElement(Text, { dimColor: true }, "Enter = search · Esc = cancel"),
+      React.createElement(Text, null, chalk.bold("> "), searchLine || chalk.dim("(query)")),
+      err ? React.createElement(Text, { color: "red" }, err) : null,
+      loading ? React.createElement(Text, null, chalk.yellow("Searching…")) : null
+    );
+  }
+
+  const VIEW = 12;
+  const n = hits.length;
+  const viewStart =
+    n <= VIEW ? 0 : Math.max(0, Math.min(cursor - Math.floor(VIEW / 2), n - VIEW));
+  const windowHits = hits.slice(viewStart, viewStart + VIEW);
+  const firstHitRow = 2 + (n > VIEW ? 1 : 0);
+  resultsLayoutRef.current = { firstHitRow, viewStart, windowLen: windowHits.length };
+
+  return React.createElement(
+    Box,
+    { flexDirection: "column", padding: 1 },
+    React.createElement(
+      Text,
+      { color: "cyan", bold: true },
+      "Results — j/k · 1-9 open · Enter/Space · dbl-click · wheel · b back"
+    ),
+    n > VIEW
+      ? React.createElement(
+          Text,
+          { dimColor: true },
+          `Showing ${viewStart + 1}–${Math.min(viewStart + VIEW, n)} of ${n}`
+        )
+      : null,
+    ...windowHits.map((h, localI) => {
+      const i = viewStart + localI;
+      return React.createElement(
+        Text,
+        { key: `${h.full_name}-${i}` },
+        `${i === cursor ? "▶ " : "  "}${h.full_name} ${chalk.dim(h.description || "")}`
+      );
+    }),
+    err && !hits.length ? React.createElement(Text, { color: "yellow" }, err) : null,
+    loading ? React.createElement(Text, null, chalk.yellow("Opening…")) : null
+  );
+}