nugit-cli 0.1.0 → 0.1.1

package/src/stack-view/run-view-entry.js

@@ -1,5 +1,4 @@
-import fs from "fs";
-import { findGitRoot, stackJsonPath } from "../nugit-stack.js";
+import { findGitRoot } from "../nugit-stack.js";
 import { runStackViewCommand } from "./run-stack-view.js";
 import { runRepoPickerFlow } from "./view-repo-picker-ink.js";
 import { RepoPickerBackError } from "./repo-picker-back.js";
@@ -25,7 +24,7 @@ async function withViewFullscreen(noTui, fn) {
 }
 
 /**
- * Resolve CLI args and open the stack viewer (local file, remote repo, or picker TUI).
+ * Resolve CLI args and open the stack viewer (remote repo by coords, repo picker, or current dir inference).
  * @param {string | undefined} repoPos
  * @param {string | undefined} refPos
  * @param {{ noTui?: boolean, repo?: string, ref?: string, file?: string, reviewAutoapply?: boolean }} opts
@@ -56,32 +55,33 @@ export async function runNugitViewEntry(repoPos, refPos, opts) {
       return;
     }
 
+    // Non-TTY with no explicit repo: infer from git remote
     const root = findGitRoot();
-    if (root && fs.existsSync(stackJsonPath(root))) {
+    let inferredRepo = null;
+    if (root) {
+      try { inferredRepo = getRepoFullNameFromGitRoot(root); } catch { inferredRepo = null; }
+    }
+    if (inferredRepo) {
       await withViewFullscreen(!!opts.noTui, () =>
-        runStackViewCommand({ noTui: opts.noTui, reviewAutoapply: opts.reviewAutoapply })
+        runStackViewCommand({ repo: inferredRepo, noTui: opts.noTui, reviewAutoapply: opts.reviewAutoapply })
       );
       return;
     }
 
     throw new Error(
-      "nugit view: pass owner/repo and optional ref, use --file, run inside a repo with .nugit/stack.json, or use a TTY for the repo picker. " +
+      "nugit view: pass owner/repo and optional ref, or run inside a git clone with a github.com remote. " +
         "Sign in with `nugit auth login` or set NUGIT_USER_TOKEN when GitHub returns 401."
     );
   }
 
-  /** @type {string | null} */
+  // TTY: use the repo picker flow (or jump straight to current dir)
   let autoRepo = null;
   if (explicitRepo) {
     autoRepo = explicitRepo;
   } else {
     const root = findGitRoot();
     if (root) {
-      try {
-        autoRepo = getRepoFullNameFromGitRoot(root);
-      } catch {
-        autoRepo = null;
-      }
+      try { autoRepo = getRepoFullNameFromGitRoot(root); } catch { autoRepo = null; }
     }
   }
 
@@ -93,9 +93,7 @@ export async function runNugitViewEntry(repoPos, refPos, opts) {
         useRepo = autoRepo;
       } else {
         const picked = await runRepoPickerFlow();
-        if (!picked) {
-          return;
-        }
+        if (!picked) return;
         useRepo = picked.repo;
       }
       firstRun = false;
@@ -109,9 +107,7 @@ export async function runNugitViewEntry(repoPos, refPos, opts) {
         });
         break;
       } catch (e) {
-        if (e instanceof RepoPickerBackError) {
-          continue;
-        }
+        if (e instanceof RepoPickerBackError) continue;
         throw e;
       }
     }

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

@@ -2,21 +2,30 @@ import React, { useLayoutEffect, useMemo, useRef, useState } from "react";
 import { Box, Text, useApp, useInput, useStdout } from "ink";
 import chalk from "chalk";
 import { buildPickerVisibleStacks, pickViewingHighlightIndex } from "./stack-pick-sort.js";
-import { buildPickStackOverviewLines } from "./stack-pick-graph.js";
-import { buildStackBranchGraphLines, discoveryPrsToGraphRows } from "./stack-branch-graph.js";
+import { buildSplitGraphPane } from "./stack-picker-graph-pane.js";
 import { stackPickTerminalLayout } from "./stack-pick-layout.js";
 
-const PICKER_GRAPH_MAX = 12;
+/** Minimum terminal width to show the split-pane graph; narrower terminals fall back to text list. */
+const SPLIT_MIN_COLS = 64;
+const GRAPH_W = 30;
+
+// ─── Visual design constants ──────────────────────────────────────────────────
+// Cursor (hover) box: round yellow border.
+// Viewing (open in viewer) box: round cyan border, nested inside cursor box
+// when they are the same item — creating a concentric inset effect.
+// Default text: white (not gray) so content is legible at a glance.
+// Dim / secondary metadata: dimColor true (author, hint lines).
+// ─────────────────────────────────────────────────────────────────────────────
 
 /**
  * @param {object} props
- * @param {{ tip_pr_number: number, tip_head_branch: string, pr_count: number, created_by: string, prs: { pr_number: number, title?: string, head_branch?: string }[], tip_updated_at?: string, inferChainIndex?: number, inferDiffAdd?: number, inferDiffDel?: number, picker_merged_stack?: boolean }[]} props.stacks
+ * @param {{ tip_pr_number: number, tip_head_branch: string, pr_count: number, created_by: string, prs: { pr_number: number, title?: string, head_branch?: string }[], tip_updated_at?: string, inferChainIndex?: number, inferDiffAdd?: number, inferDiffDel?: number, picker_merged_stack?: boolean, base_ref?: string }[]} props.stacks
  * @param {(stack: (typeof props.stacks)[0] | null) => void} props.onPick
  * @param {string} [props.title]
- * @param {() => void} [props.onRequestBack] Backspace: return to repo picker (infer flow only)
- * @param {boolean} [props.escapeToRepo] when true with onRequestBack, Esc and q also go to repo (repo-picker loop)
- * @param {number | null | undefined} [props.viewingTipPrNumber] tip PR# of the stack currently open in the viewer
- * @param {string | null | undefined} [props.viewingHeadRef] tip branch ref for matching inferred / discovery rows
+ * @param {() => void} [props.onRequestBack]
+ * @param {boolean} [props.escapeToRepo]
+ * @param {number | null | undefined} [props.viewingTipPrNumber]
+ * @param {string | null | undefined} [props.viewingHeadRef]
  */
 export function StackPickInk({
   stacks,
@@ -30,6 +39,7 @@ export function StackPickInk({
   const { exit } = useApp();
   const { stdout } = useStdout();
   const { cols, innerW } = stackPickTerminalLayout(stdout?.columns);
+  const ttyRows = stdout?.rows ?? 24;
 
   const openRows = useMemo(
     () => stacks.filter((s) => s && typeof s === "object" && s.picker_merged_stack !== true),
@@ -67,7 +77,6 @@ export function StackPickInk({
     const vis = buildPickerVisibleStacks(act, { viewingTipPrNumber, viewingHeadRef });
     const hi = pickViewingHighlightIndex(vis, viewingTipPrNumber, viewingHeadRef, all);
     setCursor(hi >= 0 ? hi : 0);
-    // Only snap when switching tabs or viewer match context — not on every stacks[] identity churn (would break j/k).
   }, [pickerSection, viewingTipPrNumber, viewingHeadRef]);
 
   const visibleRef = useRef(visible);
@@ -85,14 +94,14 @@ export function StackPickInk({
   const sectionLabel =
     pickerSection === "open"
       ? chalk.green("Open stacks")
-      : chalk.gray.dim("Merged / closed (tip PR not open)");
+      : chalk.dim("Merged / closed");
   const backHint =
     onRequestBack && escapeToRepo
       ? " · Esc/Backspace/q: repo list"
       : onRequestBack
-        ? " · Backspace: repo list · Esc/q: cancel"
+        ? " · Backspace: back · Esc/q: cancel"
         : " · Esc/q: cancel";
-  const hintLine = `${sectionLabel}${chalk.reset("")} · Tab: switch · Showing ${visible.length} of ${activeRows.length} in tab (${openRows.length} open / ${closedRows.length} merged) · j/k · 1-9 · Enter${backHint}`;
+  const hintLine = `${sectionLabel}${chalk.reset("")} · Tab · j/k · 1-9 · Enter${backHint}`;
 
   useInput((input, key) => {
     const backKey = key.backspace || key.delete || input === "\x7f" || input === "\b";
@@ -112,19 +121,13 @@ export function StackPickInk({
     }
     if (key.tab) {
       setPickerSection((sec) => {
-        if (sec === "open") {
-          return closedRows.length > 0 ? "closed" : "open";
-        }
+        if (sec === "open") return closedRows.length > 0 ? "closed" : "open";
         return openRows.length > 0 ? "open" : "closed";
       });
       return;
     }
     if (input === "j" || key.downArrow) {
-      setCursor((c) => {
-        const vis = visibleRef.current;
-        const max = Math.max(0, vis.length - 1);
-        return Math.min(c + 1, max);
-      });
+      setCursor((c) => Math.min(c + 1, Math.max(0, visibleRef.current.length - 1)));
       return;
     }
     if (input === "k" || key.upArrow) {
@@ -133,138 +136,173 @@ export function StackPickInk({
     }
     if (/^[1-9]$/.test(input)) {
       const n = Number.parseInt(input, 10) - 1;
-      const vis = visibleRef.current;
-      if (n < vis.length) {
-        onPick(vis[n] ?? null);
+      if (n < visibleRef.current.length) {
+        onPick(visibleRef.current[n] ?? null);
         exit();
       }
       return;
     }
     if (key.return || input === " ") {
       const vis = visibleRef.current;
-      if (vis.length === 0) {
-        return;
-      }
-      const i = Math.min(Math.max(0, safeRef.current), vis.length - 1);
-      onPick(vis[i] ?? null);
+      if (!vis.length) return;
+      onPick(vis[Math.min(Math.max(0, safeRef.current), vis.length - 1)] ?? null);
       exit();
     }
   });
 
-  const overview = buildPickStackOverviewLines(visible, safe, innerW, viewingTipPrNumber, viewingHeadRef, stacks);
+  const useSplitPane = cols >= SPLIT_MIN_COLS && visible.length > 0;
+  const paneH = Math.max(4, ttyRows - 4);
+  const listW = Math.max(20, innerW - GRAPH_W - 2);
 
   const emptyTab =
     visible.length === 0
-      ? React.createElement(
-          Text,
-          { color: "gray", dimColor: true },
-          "No stacks in this tab — press Tab to switch."
-        )
+      ? React.createElement(Text, { dimColor: true }, "No stacks in this tab — press Tab to switch.")
       : null;
 
+  if (useSplitPane) {
+    const graphLines = buildSplitGraphPane(visible, safe, GRAPH_W, paneH);
+
+    return React.createElement(
+      Box,
+      { flexDirection: "column", width: cols },
+      React.createElement(Text, { color: "cyan", bold: true }, title),
+      React.createElement(Text, { dimColor: true }, hintLine),
+      React.createElement(
+        Box,
+        { flexDirection: "row", marginTop: 1 },
+        // Left: graph pane
+        React.createElement(
+          Box,
+          { flexDirection: "column", width: GRAPH_W, flexShrink: 0 },
+          ...graphLines.map((ln, i) => React.createElement(Text, { key: `gp-${i}` }, ln))
+        ),
+        // Right: stack list with bordered cards
+        React.createElement(
+          Box,
+          { flexDirection: "column", flexGrow: 1, width: listW },
+          emptyTab,
+          ...visible.map((s, i) => buildStackCard(s, i, {
+            sel: i === safe,
+            isViewing: viewingHighlightIdx >= 0 && i === viewingHighlightIdx,
+            listW,
+            inferTag: s && (s.inferredOnly || s.inferredFromViewerDoc)
+          }))
+        )
+      )
+    );
+  }
+
+  // Narrow terminal fallback: full-width stacked cards
   return React.createElement(
     Box,
     { flexDirection: "column", padding: 1, width: cols },
     React.createElement(Text, { color: "cyan", bold: true }, title),
-    React.createElement(Text, { color: "gray" }, hintLine),
-    React.createElement(
-      Box,
-      { flexDirection: "column", marginY: 1, width: cols },
-      ...overview.map((ln, i) => React.createElement(Text, { key: `ov-${i}` }, ln))
-    ),
+    React.createElement(Text, { dimColor: true }, hintLine),
     emptyTab,
-    ...visible.map((s, i) => {
-      const sel = i === safe;
-      const isViewing = viewingHighlightIdx >= 0 && i === viewingHighlightIdx;
-      const mark = sel ? "\u25b6 " : "  ";
-      const inferTag =
-        s && typeof s === "object" && (s.inferredOnly || s.inferredFromViewerDoc)
-          ? chalk.dim(" (inferred)")
-          : "";
-      const head =
-        chalk.white(mark) +
-        chalk.yellow("[" + (i + 1) + "]") +
-        " " +
-        (sel ? chalk.yellowBright("tip #" + s.tip_pr_number) : chalk.white("tip #" + s.tip_pr_number)) +
-        inferTag;
-      const graphRows = discoveryPrsToGraphRows(s);
-      const tipIdx = graphRows.length ? graphRows.length - 1 : 0;
-      const graphW = Math.max(10, innerW - 4);
-      const graphMuted = !sel && !isViewing;
-      const graphLines =
-        graphRows.length === 0
-          ? []
-          : buildStackBranchGraphLines(graphRows, tipIdx, PICKER_GRAPH_MAX, graphW, {
-              muted: graphMuted,
-              fullBranchNames: true
-            });
-
-      /** @type {import('react').ReactNode[]} */
-      const diffBlock =
-        typeof s.inferDiffAdd === "number" || typeof s.inferDiffDel === "number"
-          ? [
-              React.createElement(
-                Text,
-                { key: "diff", color: sel ? "white" : "gray" },
-                `${chalk.dim("Lines: ")}${chalk.green("+" + (s.inferDiffAdd ?? 0))} ${chalk.red("-" + (s.inferDiffDel ?? 0))}`
-              )
-            ]
-          : [];
-
-      let core = React.createElement(
-        Box,
-        { flexDirection: "column" },
-        React.createElement(Text, { key: "head" }, head),
-        React.createElement(Text, { key: "pc", color: sel ? "white" : "gray" }, `PR count: ${s.pr_count}`),
-        ...diffBlock,
-        React.createElement(Text, { key: "br", color: sel ? "cyan" : "gray" }, `branch ${s.tip_head_branch}`),
-        React.createElement(Text, { key: "by", color: "gray" }, `by ${s.created_by}`),
-        React.createElement(Text, { key: "lbl", color: sel ? "white" : "gray", dimColor: !sel }, "Branch"),
-        ...graphLines.map((ln, gi) => React.createElement(Text, { key: `br-${gi}` }, ln))
-      );
-
-      if (isViewing) {
-        core = React.createElement(
-          Box,
-          {
-            borderStyle: "round",
-            borderColor: "cyan",
-            paddingLeft: 1,
-            paddingRight: 1,
-            paddingTop: 1,
-            paddingBottom: 1,
-            flexDirection: "column"
-          },
-          React.createElement(Text, { key: "open", color: "cyan" }, "  Open in viewer"),
-          core
-        );
-      }
+    ...visible.map((s, i) => buildStackCard(s, i, {
+      sel: i === safe,
+      isViewing: viewingHighlightIdx >= 0 && i === viewingHighlightIdx,
+      listW: innerW - 4,
+      inferTag: s && (s.inferredOnly || s.inferredFromViewerDoc)
+    }))
+  );
+}
 
-      if (sel) {
-        core = React.createElement(
-          Box,
-          {
-            borderStyle: "round",
-            borderColor: "yellow",
-            paddingLeft: 1,
-            paddingRight: 1,
-            paddingTop: 1,
-            paddingBottom: 1,
-            flexDirection: "column"
-          },
-          core
-        );
-      }
+// ─── Stack card builder ───────────────────────────────────────────────────────
 
-      return React.createElement(
-        Box,
-        {
-          key: String(s.tip_pr_number) + "-" + i,
-          flexDirection: "column",
-          marginBottom: 1
-        },
-        core
-      );
-    })
+/**
+ * Build a single stack entry with optional bordered boxes.
+ *
+ * Visual states:
+ *  - Cursor (hover):      round yellow border (selector box)
+ *  - Viewing (in viewer): round cyan border (viewing indicator box)
+ *  - Both (same item):    yellow outer + cyan inner — concentric inset effect
+ *  - Plain (neither):     no border, white text
+ *
+ * @param {object} s stack row
+ * @param {number} i index
+ * @param {{ sel: boolean, isViewing: boolean, listW: number, inferTag: any }} opts
+ */
+function buildStackCard(s, i, { sel, isViewing, listW }) {
+  const mark = sel ? "▶ " : "  ";
+  const maxLabelW = Math.max(8, listW - 6);
+
+  const inferred = s && (s.inferredOnly || s.inferredFromViewerDoc);
+  const inferSuffix = inferred ? chalk.dim(" *") : "";
+
+  const pcLabel = `${s.pr_count ?? 1} PR${(s.pr_count ?? 1) === 1 ? "" : "s"}`;
+  const diffPart =
+    typeof s.inferDiffAdd === "number"
+      ? ` ${chalk.green("+" + s.inferDiffAdd)} ${chalk.red("-" + (s.inferDiffDel ?? 0))}`
+      : "";
+
+  // Header: marker + index + tip PR number + PR count
+  const headerColor = sel ? "yellow" : isViewing ? "cyan" : "white";
+  const header = React.createElement(
+    Text,
+    { color: headerColor, bold: sel },
+    `${mark}[${i + 1}] #${s.tip_pr_number}`,
+    inferSuffix,
+    ` · ${pcLabel}`,
+    diffPart
+  );
+
+  // Per-PR branch name lines (tip → base)
+  const prLines = Array.isArray(s.prs) && s.prs.length > 0
+    ? [...s.prs].reverse()
+    : [{ pr_number: s.tip_pr_number, head_branch: s.tip_head_branch }];
+
+  const prNameNodes = prLines.map((pr, j) => {
+    const name = typeof pr.head_branch === "string" && pr.head_branch
+      ? pr.head_branch
+      : `#${pr.pr_number}`;
+    const truncated = name.slice(0, maxLabelW);
+    return React.createElement(
+      Text,
+      { key: `pr-${j}`, color: sel ? "yellow" : isViewing ? "cyan" : "white" },
+      `   ${truncated}`
+    );
+  });
+
+  // Author line (dim / secondary)
+  const authorNode = s.created_by
+    ? React.createElement(
+        Text,
+        { key: "author", dimColor: true },
+        `   by ${s.created_by}`
+      )
+    : null;
+
+  // Content box (no border here — borders are added as wrappers below)
+  let content = React.createElement(
+    Box,
+    { flexDirection: "column", paddingX: 1 },
+    header,
+    ...prNameNodes,
+    authorNode
+  );
+
+  // Apply viewing indicator (cyan) box — inner
+  if (isViewing) {
+    content = React.createElement(
+      Box,
+      { borderStyle: "round", borderColor: "cyan", flexDirection: "column" },
+      content
+    );
+  }
+
+  // Apply cursor (selector) box — outer yellow; wraps the cyan box when both active
+  if (sel) {
+    content = React.createElement(
+      Box,
+      { borderStyle: "round", borderColor: "yellow", flexDirection: "column" },
+      content
+    );
+  }
+
+  return React.createElement(
+    Box,
+    { key: `${s.tip_pr_number}-${i}`, flexDirection: "column", marginBottom: 1 },
+    content
   );
 }

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

@@ -1,45 +1,7 @@
-/**
- * Alternate screen buffer for a cleaner fullscreen TUI.
- * Disable with NUGIT_NO_FULLSCREEN=1 if your terminal misbehaves.
- */
-
-/**
- * @returns {boolean}
- */
-export function isAlternateScreenDisabled() {
-  const v = process.env.NUGIT_NO_FULLSCREEN;
-  return v === "1" || v === "true";
-}
-
-/**
- * @param {import('node:stream').Writable | undefined} stdout
- */
-export function enterAlternateScreen(stdout) {
-  if (!stdout?.isTTY || isAlternateScreenDisabled()) {
-    return;
-  }
-  stdout.write("\x1b[?1049h\x1b[2J\x1b[H");
-}
-
-/**
- * @param {import('node:stream').Writable | undefined} stdout
- */
-export function leaveAlternateScreen(stdout) {
-  if (!stdout?.isTTY || isAlternateScreenDisabled()) {
-    return;
-  }
-  stdout.write("\x1b[?1049l");
-}
-
-/**
- * Erase and home the cursor on the TTY Ink uses (stdout). Use before mounting a new Ink tree
- * so a previous fullscreen app does not leave ghost lines (e.g. shell footer over stack picker).
- *
- * @param {import('node:stream').Writable} [out] defaults to process.stdout
- */
-export function clearInkScreen(out = process.stdout) {
-  if (!out?.isTTY || isAlternateScreenDisabled()) {
-    return;
-  }
-  out.write("\x1b[2J\x1b[H");
-}
+// Re-exported from cli/src/utilities/terminal.js — import from there for new code.
+export {
+  isAlternateScreenDisabled,
+  enterAlternateScreen,
+  leaveAlternateScreen,
+  clearInkScreen
+} from "../utilities/terminal.js";