nugit-cli 0.0.1 → 0.1.1

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

@@ -1,23 +1,52 @@
+import fs from "fs";
 import React from "react";
 import { render } from "ink";
 import chalk from "chalk";
+import { resolveGithubToken } from "../auth-token.js";
 import {
   githubListAssignableUsers,
   githubPostIssueComment,
+  githubPostPullReview,
   githubPostPullReviewCommentReply,
-  githubPostRequestedReviewers
+  githubPostRequestedReviewers,
+  githubPostPullReviewLineComment
 } from "../github-pr-social.js";
-import { findGitRoot, parseRepoFullName, readStackFile } from "../nugit-stack.js";
+import {
+  findGitRoot,
+  parseRepoFullName,
+  createInferredStackDoc
+} from "../nugit-stack.js";
 import { getRepoFullNameFromGitRoot } from "../git-info.js";
-import { discoverStacksInRepo } from "../stack-discover.js";
-import { getStackDiscoveryOpts, effectiveMaxOpenPrs } from "../stack-discovery-config.js";
-import { tryLoadStackIndex, writeStackIndex } from "../stack-graph.js";
-import { formatStacksListHuman } from "../cli-output.js";
 import { fetchStackPrDetails } from "./fetch-pr-data.js";
-import { loadStackDocForView } from "./loader.js";
+import { inferStackDocForRemoteView } from "./remote-infer-doc.js";
+import { getRepoMetadata } from "../api-client.js";
 import { StackInkApp, createExitPayload } from "./ink-app.js";
 import { renderStaticStackView } from "./static-render.js";
 import { questionLine } from "./prompt-line.js";
+import {
+  loadReviewAutoapproveConfig,
+  isRepoHeadAutoapproveEligible
+} from "../review-hub/review-autoapprove.js";
+import {
+  pickStackIndexWithInk,
+  pickInferChainIndexWithInk,
+  STACK_PICK_BACK_TO_REPO
+} from "./view-tui-sequential.js";
+import { clearInkScreen } from "./terminal-fullscreen.js";
+import { RepoPickerBackError } from "./repo-picker-back.js";
+import { ReviewHubBackError } from "../review-hub/review-hub-back.js";
+import {
+  augmentAlternatePickStacksWithInfer,
+  ensureDocRepresentedInPickStacks,
+  stackDocToPickStackRow
+} from "./merge-alternate-pick-stacks.js";
+import { stackTipPrNumber } from "./merge-alternate-pick-stacks.js";
+import { withStackLoadInkScreen } from "./loading-ink.js";
+import { discoverStacksByInference } from "../services/stack-inference.js";
+
+// ---------------------------------------------------------------------------
+// Spinner helper (stderr, non-TUI)
+// ---------------------------------------------------------------------------
 
 function createSpinner(prefix) {
   const frames = [chalk.cyan("⠋"), chalk.cyan("⠙"), chalk.cyan("⠹"), chalk.cyan("⠸"), chalk.cyan("⠼"), chalk.cyan("⠴")];
@@ -25,13 +54,9 @@ function createSpinner(prefix) {
   let msg = "starting...";
   let timer = null;
   return {
-    update(nextMsg) {
-      msg = nextMsg || msg;
-    },
+    update(nextMsg) { msg = nextMsg || msg; },
     start() {
-      if (!process.stderr.isTTY) {
-        return;
-      }
+      if (!process.stderr.isTTY) return;
       timer = setInterval(() => {
         const frame = frames[i % frames.length];
         i += 1;
@@ -40,24 +65,20 @@ function createSpinner(prefix) {
     },
     stop(finalMsg) {
       if (!process.stderr.isTTY) {
-        if (finalMsg) {
-          console.error(`${prefix} ${finalMsg}`);
-        }
+        if (finalMsg) console.error(`${prefix} ${finalMsg}`);
         return;
       }
-      if (timer) {
-        clearInterval(timer);
-      }
+      if (timer) clearInterval(timer);
       const done = finalMsg ? `${chalk.bold(prefix)} ${chalk.green(finalMsg)}` : "";
       process.stderr.write(`\r${done}${" ".repeat(30)}\n`);
     }
   };
 }
 
-/**
- * @param {{ tip_pr_number: number, tip_head_branch: string, pr_count: number, created_by: string }[]} stacks
- * @returns {Promise<number>}
- */
+// ---------------------------------------------------------------------------
+// Non-TUI stack picker (stdin prompt fallback)
+// ---------------------------------------------------------------------------
+
 async function pickDiscoveredStackIndex(stacks) {
   const stackTree = (s) => {
     const prs = Array.isArray(s.prs) ? s.prs : [];
@@ -84,26 +105,18 @@ async function pickDiscoveredStackIndex(stacks) {
       );
       console.error(stackTree(s));
     }
-    const ans = String(
-      await questionLine(chalk.green("Select stack number (empty=cancel): "))
-    ).trim();
-    if (!ans) {
-      return -1;
-    }
+    const ans = String(await questionLine(chalk.green("Select stack number (empty=cancel): "))).trim();
+    if (!ans) return -1;
     const n = Number.parseInt(ans, 10);
-    if (Number.isInteger(n) && n >= 1 && n <= stacks.length) {
-      return n - 1;
-    }
+    if (Number.isInteger(n) && n >= 1 && n <= stacks.length) return n - 1;
     console.error("Invalid choice.");
   }
 }
 
-/**
- * @param {string} owner
- * @param {string} repo
- * @param {number} prNumber
- * @returns {Promise<string[]>}
- */
+// ---------------------------------------------------------------------------
+// Reviewer prompt
+// ---------------------------------------------------------------------------
+
 async function promptReviewers(owner, repo, prNumber) {
   let candidates = [];
   const spin = createSpinner("Loading reviewers");
@@ -111,9 +124,7 @@ async function promptReviewers(owner, repo, prNumber) {
   try {
     const users = await githubListAssignableUsers(owner, repo);
     candidates = Array.isArray(users)
-      ? users
-          .map((u) => (u && typeof u === "object" ? String(u.login || "") : ""))
-          .filter(Boolean)
+      ? users.map((u) => (u && typeof u === "object" ? String(u.login || "") : "")).filter(Boolean)
       : [];
   } catch {
     candidates = [];
@@ -129,10 +140,7 @@ async function promptReviewers(owner, repo, prNumber) {
     console.error(chalk.yellow("No assignable users listed by GitHub. You can still type logins."));
   }
   const raw = await questionLine(chalk.green("Assign Reviewers (empty=cancel): "));
-  const parts = raw
-    .split(",")
-    .map((s) => s.trim())
-    .filter(Boolean);
+  const parts = raw.split(",").map((s) => s.trim()).filter(Boolean);
   const chosen = [];
   for (const p of parts) {
     const n = Number.parseInt(p, 10);
@@ -145,106 +153,292 @@ async function promptReviewers(owner, repo, prNumber) {
   return [...new Set(chosen)];
 }
 
+// ---------------------------------------------------------------------------
+// Auto-approve helper
+// ---------------------------------------------------------------------------
+
+/**
+ * @param {string} owner
+ * @param {string} repoName
+ * @param {Record<string, unknown>} doc
+ * @param {{ viewerLogin?: string, defaultBranch?: string, fullReviewFetch?: boolean }} mergedReviewFetch
+ * @param {boolean} [reviewAutoapply]
+ */
+export async function fetchStackRowsWithAutoapply(owner, repoName, doc, mergedReviewFetch, reviewAutoapply) {
+  let rows = await fetchStackPrDetails(owner, repoName, doc.prs, 6, mergedReviewFetch);
+
+  if (reviewAutoapply && resolveGithubToken() && mergedReviewFetch.viewerLogin) {
+    const cfg = loadReviewAutoapproveConfig();
+    if (cfg) {
+      let approvedAny = false;
+      for (const row of rows) {
+        if (row.error || !row.pull) continue;
+        const head = row.pull.head && typeof row.pull.head === "object" ? row.pull.head : {};
+        const headRef = typeof head.ref === "string" ? head.ref : "";
+        if (!isRepoHeadAutoapproveEligible(cfg, owner, repoName, headRef)) continue;
+        const m = row.viewerReviewMeta;
+        if (!m?.staleApproval || m.riskyChangeAfterApproval) continue;
+        const ms = row.pull.mergeable_state;
+        if (ms && ms !== "clean" && ms !== "unstable") continue;
+        try {
+          await githubPostPullReview(owner, repoName, row.entry.pr_number, {
+            event: "APPROVE",
+            body: "nugit auto-approve: merge-only delta (review-autoapprove.json)"
+          });
+          approvedAny = true;
+        } catch { /* ignore per-PR */ }
+      }
+      if (approvedAny) {
+        rows = await fetchStackPrDetails(owner, repoName, doc.prs, 6, mergedReviewFetch);
+      }
+    }
+  }
+  return rows;
+}
+
+// ---------------------------------------------------------------------------
+// Alternate stack picker hydration (inference-only — no stack-index.json)
+// ---------------------------------------------------------------------------
+
+/**
+ * Ensure the alternate picker has discoverable stacks; uses inference only.
+ */
+async function hydrateDiscoverableStacks(repoFull, owner, repoName, current, tuiSession) {
+  const wrap = (stacks, openPullNumbers = null) => ({ stacks, openPullNumbers });
+
+  if (!repoFull || !resolveGithubToken()) return wrap(current);
+  if (current && Array.isArray(current) && current.length > 1) {
+    return augmentAlternatePickStacksWithInfer(owner, repoName, current);
+  }
+
+  const spinner = createSpinner("Scanning stacks");
+  if (!tuiSession) spinner.start();
+  try {
+    const { stacks, openPullNumbers } = await discoverStacksByInference(owner, repoName);
+    if (!tuiSession) {
+      spinner.stop(`found ${stacks.length} stack(s)`);
+    }
+    return { stacks, openPullNumbers };
+  } catch {
+    if (!tuiSession) spinner.stop("scan failed");
+    return augmentAlternatePickStacksWithInfer(owner, repoName, Array.isArray(current) ? current : []);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Main entry
+// ---------------------------------------------------------------------------
+
 /**
  * @param {object} opts
  * @param {boolean} [opts.noTui]
  * @param {string} [opts.repo]
  * @param {string} [opts.ref]
  * @param {string} [opts.file]
+ * @param {Record<string, unknown>} [opts.explicitDoc] skip inference / load
+ * @param {{ viewerLogin?: string, defaultBranch?: string, fullReviewFetch?: boolean }} [opts.reviewFetchOpts]
+ * @param {string} [opts.viewTitle]
+ * @param {boolean} [opts.reviewAutoapply]
+ * @param {boolean} [opts.shellMode]
+ * @param {boolean} [opts.allowBackToRepoPicker]
+ * @param {boolean} [opts.allowBackToReviewHub]
  */
 export async function runStackViewCommand(opts) {
+  const tuiSession = !opts.noTui && process.stdin.isTTY && process.stdout.isTTY;
+  /** @type {unknown[] | null} */
+  let discoverableStacks = null;
+
+  if (!resolveGithubToken()) {
+    console.error(
+      chalk.dim(
+        "No NUGIT_USER_TOKEN: using unauthenticated GitHub reads (low rate limit; public repos only). " +
+          "Set a PAT or run `nugit auth login` for private repos and higher limits."
+      )
+    );
+  }
+
   const root = findGitRoot();
   let repo = opts.repo;
   let ref = opts.ref;
-  if (!opts.file && !ref) {
+  let explicitDoc = opts.explicitDoc || null;
+
+  // If no explicit doc/file and no ref, discover stacks by inference
+  if (!explicitDoc && !opts.file) {
     let repoFull = repo || null;
     if (!repoFull && root) {
-      try {
-        repoFull = getRepoFullNameFromGitRoot(root);
-      } catch {
-        repoFull = null;
-      }
+      try { repoFull = getRepoFullNameFromGitRoot(root); } catch { repoFull = null; }
     }
     if (repoFull) {
-      const { owner, repo: repoName } = parseRepoFullName(repoFull);
-      const discovery = getStackDiscoveryOpts();
-      const full =
-        process.env.NUGIT_STACK_DISCOVERY_FULL === "1" || process.env.NUGIT_STACK_DISCOVERY_FULL === "true";
-      let discovered = null;
-      let usedCache = false;
-      if (discovery.mode === "manual" && root) {
-        discovered = tryLoadStackIndex(root, repoFull);
-        if (!discovered) {
-          throw new Error(
-            'Stack discovery mode is "manual". Run `nugit stack index` first or pass --repo/--ref explicitly.'
-          );
-        }
-        usedCache = true;
-      } else if (discovery.mode === "lazy" && root && !full) {
-        const cached = tryLoadStackIndex(root, repoFull);
-        if (cached) {
-          discovered = cached;
-          usedCache = true;
-        }
+      const { owner: discO, repo: discR } = parseRepoFullName(repoFull);
+      /** @type {object[]} */
+      let mergedForPick = [];
+
+      const doDiscover = async () => {
+        const { stacks } = await discoverStacksByInference(discO, discR);
+        mergedForPick = stacks;
+      };
+
+      if (tuiSession) {
+        await withStackLoadInkScreen("Loading stacks…", doDiscover);
+      } else {
+        const sp = createSpinner("Scanning stacks");
+        sp.start();
+        await doDiscover();
+        sp.stop(`found ${mergedForPick.length} stack(s)`);
       }
-      if (!discovered) {
-        const spinner = createSpinner("Scanning stacks");
-        spinner.start();
-        discovered = await discoverStacksInRepo(owner, repoName, {
-          maxOpenPrs: effectiveMaxOpenPrs(discovery, full),
-          enrich: false,
-          fetchConcurrency: discovery.fetchConcurrency,
-          onProgress: (m) => spinner.update(m)
-        });
-        spinner.stop(
-          `found ${discovered.stacks_found} stack(s) across ${discovered.scanned_open_prs} open PR(s)`
-        );
-        if (root) {
-          try {
-            if (discovery.mode === "eager" || discovery.mode === "lazy") {
-              writeStackIndex(root, discovered);
-            }
-          } catch {
-            /* ignore index write */
-          }
-        }
-      } else if (usedCache) {
-        console.error(chalk.dim("Using .nugit/stack-index.json — set NUGIT_STACK_DISCOVERY_FULL=1 to rescan GitHub."));
+
+      if (mergedForPick.length === 0 && !ref) {
+        throw new Error(`No open PR stacks found in ${repoFull}. Open some stacked PRs and try again.`);
       }
-      if (discovered.stacks_found > 1) {
+
+      if (mergedForPick.length > 1) {
         if (opts.noTui) {
-          console.log(formatStacksListHuman(discovered));
+          console.log(chalk.bold.cyan(`Stacks in ${repoFull}`) + chalk.dim(` · ${mergedForPick.length} candidate(s) (inferred from open PR chains)`));
+          console.log("");
+          for (const s of mergedForPick) {
+            const row = /** @type {{ tip_pr_number: number, pr_count: number, tip_head_branch: string }} */ (s);
+            console.log(`  ${chalk.yellow("tip #" + row.tip_pr_number)} · ${row.pr_count} PR(s) · ${chalk.magenta(row.tip_head_branch)}`);
+          }
+          console.log("");
+          console.log(chalk.dim("Re-run with a TTY to pick interactively, or pass --repo/--ref to open a specific stack."));
+          return;
+        }
+
+        discoverableStacks = mergedForPick;
+        const hasBack = !!(opts.allowBackToRepoPicker || opts.allowBackToReviewHub);
+        const picked = tuiSession
+          ? await pickStackIndexWithInk(mergedForPick, { allowBackToRepo: hasBack, escapeToRepo: hasBack })
+          : null;
+
+        if (picked === STACK_PICK_BACK_TO_REPO) {
+          if (opts.allowBackToReviewHub) throw new ReviewHubBackError();
+          if (opts.allowBackToRepoPicker) throw new RepoPickerBackError();
           return;
         }
-        const idx = await pickDiscoveredStackIndex(discovered.stacks);
-        if (idx < 0) {
+
+        let pickedStack;
+        if (!tuiSession) {
+          const idx = await pickDiscoveredStackIndex(
+            /** @type {{ tip_head_branch: string, tip_pr_number: number, pr_count: number, created_by: string, prs: unknown[] }[]} */ (
+              mergedForPick
+            )
+          );
+          if (idx < 0) { console.error("Cancelled."); return; }
+          pickedStack = mergedForPick[idx];
+        } else {
+          pickedStack = picked;
+        }
+
+        if (!pickedStack) {
+          if (opts.allowBackToReviewHub) throw new ReviewHubBackError();
+          if (opts.allowBackToRepoPicker) throw new RepoPickerBackError();
           console.error("Cancelled.");
           return;
         }
+
         repo = repoFull;
-        ref = discovered.stacks[idx].tip_head_branch;
-        console.error(`Viewing selected stack tip: ${repo}@${ref}`);
-      }
-      if (discovered.stacks_found === 1) {
+        ref = pickedStack.tip_head_branch;
+        const prNums = Array.isArray(pickedStack.prs)
+          ? pickedStack.prs
+              .filter((p) => p && typeof p === "object" && typeof p.pr_number === "number")
+              .sort((a, b) => (a.position ?? 0) - (b.position ?? 0))
+              .map((p) => p.pr_number)
+          : [];
+        if (prNums.length > 0) {
+          explicitDoc = createInferredStackDoc(repoFull, String(pickedStack.created_by || ""), prNums);
+        }
+        if (!tuiSession) console.error(`Viewing stack tip: ${repo}@${ref}`);
+
+      } else if (mergedForPick.length === 1) {
+        const only = /** @type {{ tip_head_branch: string, created_by?: string, prs?: { pr_number: number, position?: number }[] }} */ (mergedForPick[0]);
         repo = repoFull;
-        ref = discovered.stacks[0].tip_head_branch;
-        console.error(`Viewing discovered stack tip: ${repo}@${ref}`);
+        ref = only.tip_head_branch;
+        discoverableStacks = mergedForPick;
+        const prNums = Array.isArray(only.prs)
+          ? only.prs
+              .filter((p) => p && typeof p === "object" && typeof p.pr_number === "number")
+              .sort((a, b) => (a.position ?? 0) - (b.position ?? 0))
+              .map((p) => p.pr_number)
+          : [];
+        if (prNums.length > 0) {
+          explicitDoc = createInferredStackDoc(repoFull, String(only.created_by || ""), prNums);
+        }
+        if (!tuiSession) console.error(`Viewing stack tip: ${repo}@${ref}`);
       }
     }
   }
 
-  let { doc } = await loadStackDocForView({
-    root,
-    repo,
-    ref,
-    file: opts.file
-  });
+  // Resolve default branch if needed
+  if (!ref && repo && !explicitDoc) {
+    const { owner: dbO, repo: dbR } = parseRepoFullName(repo);
+    const dbMeta = await getRepoMetadata(dbO, dbR);
+    ref = typeof dbMeta.default_branch === "string" ? dbMeta.default_branch : "main";
+  }
 
-  const { owner, repo: repoName } = parseRepoFullName(doc.repo_full_name);
-  const loadSpinner = createSpinner("Loading stack");
-  loadSpinner.start();
-  let rows = await fetchStackPrDetails(owner, repoName, doc.prs);
-  loadSpinner.stop(`loaded ${rows.length} PR(s)`);
+  if (explicitDoc && repo && !opts.reviewFetchOpts?.defaultBranch) {
+    try {
+      const { owner: dbO, repo: dbR } = parseRepoFullName(repo);
+      const dbMeta = await getRepoMetadata(dbO, dbR);
+      const db = typeof dbMeta.default_branch === "string" ? dbMeta.default_branch : "main";
+      opts = { ...opts, reviewFetchOpts: { ...(opts.reviewFetchOpts || {}), defaultBranch: db } };
+    } catch { /* non-critical */ }
+  }
+
+  let doc;
+  /** @type {{ viewerLogin?: string, defaultBranch?: string, fullReviewFetch?: boolean }} */
+  let mergedReviewFetch = { ...(opts.reviewFetchOpts || {}) };
+
+  if (explicitDoc) {
+    doc = explicitDoc;
+  } else if (opts.file) {
+    const raw = fs.readFileSync(opts.file, "utf8");
+    doc = JSON.parse(raw);
+  } else {
+    // Inference: no explicit doc, repo must be set
+    if (!repo) {
+      throw new Error("Cannot load stack: no repo specified. Pass --repo owner/repo or run inside a git clone.");
+    }
+    const useInkInfer = !opts.noTui && process.stdin.isTTY && process.stdout.isTTY;
+    const { doc: inferred, viewerLogin } = await inferStackDocForRemoteView(repo, {
+      interactivePick: !opts.noTui,
+      tuiChainPick: useInkInfer
+        ? (ch, pl) => pickInferChainIndexWithInk(ch, pl, { allowBackToRepo: !!(opts.allowBackToRepoPicker || opts.allowBackToReviewHub) })
+        : undefined
+    });
+    doc = inferred;
+    const { owner: oInf, repo: rInf } = parseRepoFullName(doc.repo_full_name);
+    const meta = await getRepoMetadata(oInf, rInf);
+    const defaultBranch = typeof meta.default_branch === "string" ? meta.default_branch : "main";
+    mergedReviewFetch = {
+      ...mergedReviewFetch,
+      viewerLogin: mergedReviewFetch?.viewerLogin || viewerLogin,
+      defaultBranch: mergedReviewFetch?.defaultBranch || defaultBranch,
+      fullReviewFetch: mergedReviewFetch?.fullReviewFetch ?? true
+    };
+  }
+
+  let { owner, repo: repoName } = parseRepoFullName(doc.repo_full_name);
+  let rows;
+  const loadRowsOnce = async () => {
+    rows = await fetchStackRowsWithAutoapply(owner, repoName, doc, mergedReviewFetch, !!opts.reviewAutoapply);
+  };
+  if (tuiSession) {
+    await withStackLoadInkScreen("Loading stack…", loadRowsOnce);
+  } else {
+    const loadSpinner = createSpinner("Loading stack");
+    loadSpinner.start();
+    await loadRowsOnce();
+    loadSpinner.stop(`loaded ${rows.length} PR(s)`);
+  }
+
+  const repoFullStr = String(doc.repo_full_name || "");
+  const hydrated = await hydrateDiscoverableStacks(repoFullStr, owner, repoName, discoverableStacks, tuiSession);
+  discoverableStacks = ensureDocRepresentedInPickStacks(
+    hydrated.stacks,
+    /** @type {Record<string, unknown>} */ (doc),
+    ref,
+    hydrated.openPullNumbers
+  );
 
   if (opts.noTui) {
     renderStaticStackView(rows);
@@ -253,34 +447,51 @@ export async function runStackViewCommand(opts) {
 
   let running = true;
   while (running) {
+    if (tuiSession) clearInkScreen();
     const exitPayload = createExitPayload();
     const { waitUntilExit } = render(
-      React.createElement(StackInkApp, { rows, exitPayload })
+      React.createElement(StackInkApp, {
+        rows,
+        exitPayload,
+        viewTitle: opts.viewTitle || "nugit view",
+        browseOwner: owner,
+        browseRepo: repoName,
+        repoFullName: String(doc.repo_full_name || ""),
+        shellMode: opts.shellMode !== false,
+        alternateStacks: discoverableStacks
+      })
     );
     await waitUntilExit();
-    // Give terminal mode a short moment to settle before readline prompts.
     await new Promise((r) => setTimeout(r, 25));
 
     const next = exitPayload.next;
-    if (!next || next.type === "quit") {
-      running = false;
-      break;
-    }
+    if (!next || next.type === "quit") { running = false; break; }
 
     if (next.type === "issue_comment") {
       try {
         const body = await questionLine(`New issue comment on PR #${next.prNumber} (empty=cancel): `);
         if (body.trim()) {
-          await githubPostIssueComment(
-            owner,
-            repoName,
-            /** @type {number} */ (next.prNumber),
-            body.trim()
-          );
+          await githubPostIssueComment(owner, repoName, /** @type {number} */ (next.prNumber), body.trim());
         }
         const refresh = createSpinner("Refreshing stack");
         refresh.start();
-        rows = await fetchStackPrDetails(owner, repoName, doc.prs);
+        rows = await fetchStackPrDetails(owner, repoName, doc.prs, 6, mergedReviewFetch);
+        refresh.stop(`loaded ${rows.length} PR(s)`);
+      } catch (e) {
+        console.error(`Action failed: ${String(e?.message || e)}`);
+      }
+      continue;
+    }
+
+    if (next.type === "review_approve") {
+      try {
+        await githubPostPullReview(owner, repoName, /** @type {number} */ (next.prNumber), {
+          event: "APPROVE",
+          body: typeof next.body === "string" ? next.body : ""
+        });
+        const refresh = createSpinner("Refreshing stack");
+        refresh.start();
+        rows = await fetchStackPrDetails(owner, repoName, doc.prs, 6, mergedReviewFetch);
         refresh.stop(`loaded ${rows.length} PR(s)`);
       } catch (e) {
         console.error(`Action failed: ${String(e?.message || e)}`);
@@ -290,18 +501,13 @@ export async function runStackViewCommand(opts) {
 
     if (next.type === "review_reply") {
       try {
-        const body = await questionLine(`Reply in review thread (empty=cancel): `);
+        const body = await questionLine("Reply in review thread (empty=cancel): ");
         if (body.trim()) {
-          await githubPostPullReviewCommentReply(
-            owner,
-            repoName,
-            /** @type {number} */ (next.commentId),
-            body.trim()
-          );
+          await githubPostPullReviewCommentReply(owner, repoName, /** @type {number} */ (next.commentId), body.trim());
         }
         const refresh = createSpinner("Refreshing stack");
         refresh.start();
-        rows = await fetchStackPrDetails(owner, repoName, doc.prs);
+        rows = await fetchStackPrDetails(owner, repoName, doc.prs, 6, mergedReviewFetch);
         refresh.stop(`loaded ${rows.length} PR(s)`);
       } catch (e) {
         console.error(`Action failed: ${String(e?.message || e)}`);
@@ -313,13 +519,11 @@ export async function runStackViewCommand(opts) {
       try {
         const logins = await promptReviewers(owner, repoName, /** @type {number} */ (next.prNumber));
         if (logins.length) {
-          await githubPostRequestedReviewers(owner, repoName, /** @type {number} */ (next.prNumber), {
-            reviewers: logins
-          });
+          await githubPostRequestedReviewers(owner, repoName, /** @type {number} */ (next.prNumber), { reviewers: logins });
         }
         const refresh = createSpinner("Refreshing stack");
         refresh.start();
-        rows = await fetchStackPrDetails(owner, repoName, doc.prs);
+        rows = await fetchStackPrDetails(owner, repoName, doc.prs, 6, mergedReviewFetch);
         refresh.stop(`loaded ${rows.length} PR(s)`);
       } catch (e) {
         console.error(`Action failed: ${String(e?.message || e)}`);
@@ -327,38 +531,192 @@ export async function runStackViewCommand(opts) {
       continue;
     }
 
+    if (next.type === "pull_review_line_comment") {
+      try {
+        const { diffLineToGitHub } = await import("./diff-line-map.js");
+        const prNum = /** @type {number} */ (next.prNumber);
+        const filePath = String(next.path || "");
+        const commitId = String(next.commitId || "");
+        const patchIdx = typeof next.patchLineIndex === "number" ? next.patchLineIndex : -1;
+        const prRow = rows.find((r) => r.entry.pr_number === prNum);
+        const fileObj = Array.isArray(prRow?.files) ? prRow.files.find((f) => f && String(f.filename) === filePath) : null;
+        const pLines = fileObj && typeof fileObj.patch === "string" ? String(fileObj.patch).split("\n") : [];
+        const mapped = pLines.length > 0 && patchIdx >= 0 ? diffLineToGitHub(pLines, patchIdx) : null;
+        if (!mapped) {
+          console.error(chalk.yellow("Cannot comment on this line (header or unmappable)."));
+        } else {
+          const body = await questionLine(`Comment on ${filePath}:${mapped.line} (${mapped.side}) (empty=cancel): `);
+          if (body.trim()) {
+            await githubPostPullReviewLineComment(owner, repoName, prNum, {
+              body: body.trim(), commit_id: commitId, path: filePath, line: mapped.line, side: mapped.side
+            });
+          }
+          const refresh = createSpinner("Refreshing stack");
+          refresh.start();
+          rows = await fetchStackPrDetails(owner, repoName, doc.prs, 6, mergedReviewFetch);
+          refresh.stop(`loaded ${rows.length} PR(s)`);
+        }
+      } catch (e) {
+        console.error(`Action failed: ${String(e?.message || e)}`);
+      }
+      continue;
+    }
+
+    if (next.type === "pick_stack") {
+      const repoFullForPick = String(doc.repo_full_name || "");
+      const hydratedPick = await hydrateDiscoverableStacks(repoFullForPick, owner, repoName, discoverableStacks, tuiSession);
+      discoverableStacks = ensureDocRepresentedInPickStacks(
+        hydratedPick.stacks,
+        /** @type {Record<string, unknown>} */ (doc),
+        ref,
+        hydratedPick.openPullNumbers
+      );
+      if (!discoverableStacks || discoverableStacks.length < 2) continue;
+
+      const viewingTip = stackTipPrNumber(doc);
+      const viewingHeadRef = typeof ref === "string" && ref.trim() ? ref.trim() : undefined;
+      const hasBackFromViewer = !!(opts.allowBackToRepoPicker || opts.allowBackToReviewHub);
+      const picked = await pickStackIndexWithInk(
+        /** @type {{ tip_head_branch: string, tip_pr_number: number }[]} */ (discoverableStacks),
+        { allowBackToRepo: hasBackFromViewer, escapeToRepo: hasBackFromViewer, viewingTipPrNumber: viewingTip ?? undefined, viewingHeadRef }
+      );
+      if (picked === STACK_PICK_BACK_TO_REPO) {
+        if (opts.allowBackToReviewHub) throw new ReviewHubBackError();
+        if (opts.allowBackToRepoPicker) throw new RepoPickerBackError();
+        continue;
+      }
+      if (!picked) continue;
+
+      ref = picked.tip_head_branch;
+      const prNums = Array.isArray(picked.prs)
+        ? picked.prs.filter((p) => p && typeof p === "object" && typeof p.pr_number === "number").sort((a, b) => (a.position ?? 0) - (b.position ?? 0)).map((p) => p.pr_number)
+        : [];
+      const pickedDoc = prNums.length > 0
+        ? createInferredStackDoc(String(doc.repo_full_name || `${owner}/${repoName}`), String(picked.created_by || ""), prNums)
+        : null;
+
+      try {
+        const reloadStack = async () => {
+          if (pickedDoc) {
+            doc = pickedDoc;
+          } else {
+            const { doc: inferred } = await inferStackDocForRemoteView(`${owner}/${repoName}`, { preselectedChainIndex: 0 });
+            doc = inferred;
+          }
+          const { owner: oPick, repo: rPick } = parseRepoFullName(doc.repo_full_name);
+          rows = await fetchStackRowsWithAutoapply(oPick, rPick, doc, mergedReviewFetch, !!opts.reviewAutoapply);
+          owner = oPick;
+          repoName = rPick;
+        };
+        if (tuiSession) {
+          await withStackLoadInkScreen("Loading stack…", reloadStack);
+        } else {
+          await reloadStack();
+        }
+      } catch (e) {
+        console.error(`Could not load stack: ${String(e?.message || e)}`);
+      }
+      continue;
+    }
+
     if (next.type === "refresh") {
       const refresh = createSpinner("Refreshing stack");
       refresh.start();
-      rows = await fetchStackPrDetails(owner, repoName, doc.prs);
+      rows = await fetchStackPrDetails(owner, repoName, doc.prs, 6, mergedReviewFetch);
       refresh.stop(`loaded ${rows.length} PR(s)`);
       continue;
     }
 
+    if (next.type === "submit_review") {
+      try {
+        await githubPostPullReview(owner, repoName, /** @type {number} */ (next.prNumber), {
+          event: String(next.event || "COMMENT"),
+          body: typeof next.body === "string" ? next.body : ""
+        });
+        const refresh = createSpinner("Refreshing stack");
+        refresh.start();
+        rows = await fetchStackPrDetails(owner, repoName, doc.prs, 6, mergedReviewFetch);
+        refresh.stop(`loaded ${rows.length} PR(s)`);
+      } catch (e) {
+        console.error(`Review submit failed: ${String(e?.message || e)}`);
+      }
+      continue;
+    }
+
+    if (next.type === "submit_review_changes") {
+      try {
+        const body = await questionLine("Request changes — comment (required, empty=cancel): ");
+        if (body.trim()) {
+          await githubPostPullReview(owner, repoName, /** @type {number} */ (next.prNumber), {
+            event: "REQUEST_CHANGES",
+            body: body.trim()
+          });
+          const refresh = createSpinner("Refreshing stack");
+          refresh.start();
+          rows = await fetchStackPrDetails(owner, repoName, doc.prs, 6, mergedReviewFetch);
+          refresh.stop(`loaded ${rows.length} PR(s)`);
+        }
+      } catch (e) {
+        console.error(`Review submit failed: ${String(e?.message || e)}`);
+      }
+      continue;
+    }
+
+    if (next.type === "materialize_clone") {
+      try {
+        const { execFileSync } = await import("child_process");
+        const os = await import("os");
+        const path = await import("path");
+        const tok = resolveGithubToken();
+        const prRow = rows.find((r) => r.entry.pr_number === next.prNumber);
+        const pull = prRow?.pull;
+        const head = pull?.head && typeof pull.head === "object" ? pull.head : {};
+        const headRef = typeof head.ref === "string" ? head.ref : "";
+        const hr = head.repo && typeof head.repo === "object" ? head.repo : {};
+        const cloneUrl = typeof hr.clone_url === "string" ? hr.clone_url : "";
+        if (!cloneUrl || !headRef) throw new Error("Missing clone URL or head ref");
+        const safeName = `${owner}-${repoName}-${headRef}`.replace(/[^a-zA-Z0-9._-]+/g, "_");
+        const dest = path.join(os.tmpdir(), `nugit-review-${safeName}`);
+        const url = tok && cloneUrl.startsWith("https://")
+          ? cloneUrl.replace("https://", `https://x-access-token:${tok}@`)
+          : cloneUrl;
+        if (fs.existsSync(dest)) {
+          console.error(chalk.yellow(`Directory exists, skipping clone: ${dest}`));
+        } else {
+          execFileSync("git", ["clone", "--depth", "1", "--branch", headRef, url, dest], { stdio: "inherit" });
+          console.error(chalk.green(`Cloned to ${dest}`));
+        }
+      } catch (e) {
+        console.error(`Clone failed: ${String(e?.message || e)}`);
+      }
+      continue;
+    }
+
     if (next.type === "split") {
       try {
         const r = findGitRoot();
-        if (!r) {
-          throw new Error("Not inside a git repository");
-        }
+        if (!r) throw new Error("Not inside a git repository");
         const { runSplitCommand } = await import("../split-view/run-split.js");
-        await runSplitCommand({
+        const splitResult = await runSplitCommand({
           root: r,
           owner,
           repo: repoName,
           prNumber: /** @type {number} */ (next.prNumber),
           dryRun: false
         });
-        const refreshed = readStackFile(r);
-        if (refreshed) {
-          doc = refreshed;
+        // Refresh viewer doc with the new inferred stack (post-split)
+        if (splitResult?.newPrNumbers?.length) {
+          const { authMe } = await import("../api-client.js");
+          const me = await authMe();
+          const login = me && typeof me.login === "string" ? me.login : "viewer";
+          doc = createInferredStackDoc(`${owner}/${repoName}`, login, splitResult.newPrNumbers);
         }
         const reload = createSpinner("Reloading stack");
         reload.start();
-        rows = await fetchStackPrDetails(owner, repoName, doc.prs);
+        rows = await fetchStackPrDetails(owner, repoName, doc.prs, 6, mergedReviewFetch);
         reload.stop(`loaded ${rows.length} PR(s)`);
       } catch (e) {
-        console.error(`Split failed: ${String(/** @type {{ message?: string }} */ (e)?.message || e)}`);
+        console.error(`Split failed: ${String(e?.message || e)}`);
       }
       continue;
     }