nugit-cli 0.0.1 → 0.1.0

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

@@ -1,23 +1,98 @@
+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,
+  readStackFile,
+  validateStackDoc,
+  createInferredStackDoc
+} from "../nugit-stack.js";
 import { getRepoFullNameFromGitRoot } from "../git-info.js";
-import { discoverStacksInRepo } from "../stack-discover.js";
+import { discoverStacksInRepo, stackTipPrNumber } 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, isGithubNotFoundError } 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
+} from "./merge-alternate-pick-stacks.js";
+import { withStackLoadInkScreen } from "./loading-ink.js";
+
+/**
+ * @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;
+}
 
 function createSpinner(prefix) {
   const frames = [chalk.cyan("⠋"), chalk.cyan("⠙"), chalk.cyan("⠹"), chalk.cyan("⠸"), chalk.cyan("⠼"), chalk.cyan("⠴")];
@@ -145,18 +220,125 @@ async function promptReviewers(owner, repo, prNumber) {
   return [...new Set(chosen)];
 }
 
+/**
+ * When the viewer opens with an explicit ref (repo picker, `nugit view owner/repo`, etc.),
+ * `discoverableStacks` is never set. Populate from `.nugit/stack-index.json` or a scan so
+ * Backspace can reopen the multi-stack Ink picker.
+ *
+ * @param {string | null} root
+ * @param {string} repoFull
+ * @param {string} owner
+ * @param {string} repoName
+ * @param {unknown[] | null} current
+ * @param {boolean} tuiSession
+ * @returns {Promise<{ stacks: unknown[] | null, openPullNumbers: Set<number> | null }>}
+ */
+async function hydrateDiscoverableStacksForAlternatePicker(
+  root,
+  repoFull,
+  owner,
+  repoName,
+  current,
+  tuiSession
+) {
+  /** @type {{ stacks: unknown[] | null, openPullNumbers: Set<number> | null }} */
+  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);
+  }
+
+  if (root) {
+    const cached = tryLoadStackIndex(root, repoFull);
+    const stacks = cached && Array.isArray(cached.stacks) ? cached.stacks : null;
+    if (stacks && stacks.length > 1) {
+      return augmentAlternatePickStacksWithInfer(owner, repoName, stacks);
+    }
+  }
+
+  const discovery = getStackDiscoveryOpts();
+  if (discovery.mode === "manual") {
+    return augmentAlternatePickStacksWithInfer(owner, repoName, Array.isArray(current) ? current : []);
+  }
+
+  const full =
+    process.env.NUGIT_STACK_DISCOVERY_FULL === "1" || process.env.NUGIT_STACK_DISCOVERY_FULL === "true";
+  const spinner = createSpinner("Scanning stacks");
+  if (!tuiSession) {
+    spinner.start();
+  }
+  try {
+    const discovered = await discoverStacksInRepo(owner, repoName, {
+      maxOpenPrs: effectiveMaxOpenPrs(discovery, full),
+      enrich: false,
+      fetchConcurrency: discovery.fetchConcurrency,
+      onProgress: (m) => (!tuiSession ? spinner.update(m) : undefined)
+    });
+    if (!tuiSession) {
+      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 */
+      }
+    }
+    if (discovered.stacks_found > 1) {
+      return augmentAlternatePickStacksWithInfer(owner, repoName, discovered.stacks);
+    }
+    if (discovered.stacks_found === 1) {
+      return augmentAlternatePickStacksWithInfer(owner, repoName, discovered.stacks);
+    }
+    return augmentAlternatePickStacksWithInfer(owner, repoName, []);
+  } catch {
+    if (!tuiSession) {
+      spinner.stop("scan failed");
+    }
+    return augmentAlternatePickStacksWithInfer(owner, repoName, Array.isArray(current) ? current : []);
+  }
+}
+
 /**
  * @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 discovery / stack.json load
+ * @param {{ viewerLogin?: string, defaultBranch?: string, fullReviewFetch?: boolean }} [opts.reviewFetchOpts]
+ * @param {string} [opts.viewTitle] Ink header
+ * @param {boolean} [opts.reviewAutoapply] apply review-autoapprove.json rules once after load
+ * @param {boolean} [opts.shellMode] multi-page nugit view layout (default true for TUI)
+ * @param {boolean} [opts.allowBackToRepoPicker] inferred PR-group Ink picker: Backspace throws RepoPickerBackError (repo-picker loop only)
+ * @param {boolean} [opts.allowBackToReviewHub] stack picker Backspace throws ReviewHubBackError (review hub loop only)
  */
 export async function runStackViewCommand(opts) {
+  const tuiSession = !opts.noTui && process.stdin.isTTY && process.stdout.isTTY;
+  /** @type {unknown[] | null} Re-open stack picker (Backspace) when length > 1 */
+  let discoverableStacks = null;
+
+  if (!resolveGithubToken()) {
+    console.error(
+      chalk.dim(
+        "No NUGIT_USER_TOKEN: using unauthenticated GitHub reads (low rate limit; public repos only for API data). Set a PAT for private repos, higher limits, or posting comments."
+      )
+    );
+  }
   const root = findGitRoot();
   let repo = opts.repo;
   let ref = opts.ref;
-  if (!opts.file && !ref) {
+  let explicitDoc = opts.explicitDoc || null;
+
+  if (!explicitDoc && !opts.file && !ref) {
     let repoFull = repo || null;
     if (!repoFull && root) {
       try {
@@ -187,64 +369,279 @@ export async function runStackViewCommand(opts) {
           usedCache = true;
         }
       }
-      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)
+      const discoverOpts = {
+        maxOpenPrs: effectiveMaxOpenPrs(discovery, full),
+        enrich: false,
+        fetchConcurrency: discovery.fetchConcurrency
+      };
+      /** @type {object[]} */
+      let mergedForPick = [];
+
+      if (tuiSession) {
+        await withStackLoadInkScreen("Loading stacks…", async () => {
+          if (!discovered) {
+            discovered = await discoverStacksInRepo(owner, repoName, {
+              ...discoverOpts,
+              onProgress: undefined
+            });
+            if (root) {
+              try {
+                if (discovery.mode === "eager" || discovery.mode === "lazy") {
+                  writeStackIndex(root, discovered);
+                }
+              } catch {
+                /* ignore index write */
+              }
+            }
+          }
+          const rawStacks = discovered && Array.isArray(discovered.stacks) ? discovered.stacks : [];
+          const aug = await augmentAlternatePickStacksWithInfer(owner, repoName, rawStacks);
+          mergedForPick = aug.stacks;
         });
-        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);
+      } else {
+        if (!discovered) {
+          const spinner = createSpinner("Scanning stacks");
+          spinner.start();
+          discovered = await discoverStacksInRepo(owner, repoName, {
+            ...discoverOpts,
+            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 */
             }
-          } 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."));
         }
-      } else if (usedCache) {
-        console.error(chalk.dim("Using .nugit/stack-index.json — set NUGIT_STACK_DISCOVERY_FULL=1 to rescan GitHub."));
+        const rawStacks = discovered && Array.isArray(discovered.stacks) ? discovered.stacks : [];
+        const aug = await augmentAlternatePickStacksWithInfer(owner, repoName, rawStacks);
+        mergedForPick = aug.stacks;
       }
-      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) (PR heads with .nugit/stack.json + inferred same-repo chains)`
+              )
+          );
+          console.log("");
+          for (const s of mergedForPick) {
+            const tag =
+              s && typeof s === "object" && /** @type {{ inferredOnly?: boolean }} */ (s).inferredOnly
+                ? chalk.dim(" (inferred)")
+                : "";
+            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)}${tag}`
+            );
+          }
+          console.log("");
+          console.log(chalk.dim("Re-run with a TTY to pick interactively, or pass --ref to a stack tip branch."));
           return;
         }
-        const idx = await pickDiscoveredStackIndex(discovered.stacks);
-        if (idx < 0) {
+        const useInkPick =
+          !opts.noTui && process.stdin.isTTY && process.stdout.isTTY;
+        discoverableStacks = mergedForPick;
+        /** @type {{ tip_head_branch: string } | null} */
+        let pickedStack = null;
+        if (useInkPick) {
+          const hasBack = !!(opts.allowBackToRepoPicker || opts.allowBackToReviewHub);
+          pickedStack = await pickStackIndexWithInk(mergedForPick, {
+            allowBackToRepo: hasBack,
+            escapeToRepo: hasBack
+          });
+          if (pickedStack === STACK_PICK_BACK_TO_REPO) {
+            if (opts.allowBackToReviewHub) {
+              throw new ReviewHubBackError();
+            }
+            if (opts.allowBackToRepoPicker) {
+              throw new RepoPickerBackError();
+            }
+            console.error(
+              chalk.dim("Backspace: repo list is only available when you start with `nugit view` (no args) from a TTY.")
+            );
+            return;
+          }
+        } else {
+          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];
+        }
+        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;
+        if (pickedStack.inferredOnly || pickedStack.inferredFromViewerDoc) {
+          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 selected stack tip: ${repo}@${ref}`);
+        }
+      } else if (mergedForPick.length === 1) {
         repo = repoFull;
-        ref = discovered.stacks[0].tip_head_branch;
-        console.error(`Viewing discovered stack tip: ${repo}@${ref}`);
+        const only = /** @type {{ tip_head_branch: string, inferredOnly?: boolean, inferredFromViewerDoc?: boolean, created_by?: string, prs?: { pr_number: number, position?: number }[] }} */ (mergedForPick[0]);
+        ref = only.tip_head_branch;
+        discoverableStacks = mergedForPick;
+        if (only.inferredOnly || only.inferredFromViewerDoc) {
+          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}`);
+        }
+      }
+    }
+  }
+
+  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";
+  }
+
+  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;
+    validateStackDoc(doc);
+  } else {
+    try {
+      const loaded = await loadStackDocForView({
+        root,
+        repo,
+        ref,
+        file: opts.file
+      });
+      doc = loaded.doc;
+    } catch (e) {
+      const canInfer =
+        repo &&
+        ref &&
+        !opts.file &&
+        resolveGithubToken() &&
+        isGithubNotFoundError(e);
+      if (!canInfer) {
+        throw e;
       }
+      if (!tuiSession) {
+        console.error(
+          chalk.dim(
+            "No .nugit/stack.json on that ref — inferring stack from open PRs (same-repo). " +
+              "Use an explicit --ref to a branch that has stack.json if this is wrong."
+          )
+        );
+      }
+      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");
+    if (!tuiSession) {
+      loadSpinner.start();
+    }
+    await loadRowsOnce();
+    if (!tuiSession) {
+      loadSpinner.stop(`loaded ${rows.length} PR(s)`);
     }
   }
 
-  let { doc } = await loadStackDocForView({
+  const repoFullStr = String(doc.repo_full_name || "");
+  const hydrated = await hydrateDiscoverableStacksForAlternatePicker(
     root,
-    repo,
+    repoFullStr,
+    owner,
+    repoName,
+    discoverableStacks,
+    tuiSession
+  );
+  discoverableStacks = ensureDocRepresentedInPickStacks(
+    hydrated.stacks,
+    /** @type {Record<string, unknown>} */ (doc),
     ref,
-    file: opts.file
-  });
-
-  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)`);
+    hydrated.openPullNumbers
+  );
 
   if (opts.noTui) {
     renderStaticStackView(rows);
@@ -253,9 +650,21 @@ 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.
@@ -280,7 +689,7 @@ export async function runStackViewCommand(opts) {
         }
         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)}`);
@@ -301,7 +710,7 @@ export async function runStackViewCommand(opts) {
         }
         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)}`);
@@ -319,7 +728,7 @@ export async function runStackViewCommand(opts) {
         }
         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,14 +736,240 @@ 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 hydratedPick = await hydrateDiscoverableStacksForAlternatePicker(
+        root,
+        String(doc.repo_full_name || ""),
+        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 != null ? viewingTip : undefined,
+          viewingHeadRef
+        }
+      );
+      if (picked === STACK_PICK_BACK_TO_REPO) {
+        if (opts.allowBackToReviewHub) {
+          throw new ReviewHubBackError();
+        }
+        if (opts.allowBackToRepoPicker) {
+          throw new RepoPickerBackError();
+        }
+        console.error(
+          chalk.dim("Backspace: repo list is only available when you start with `nugit view` (no args) from a TTY.")
+        );
+        continue;
+      }
+      if (!picked) {
+        continue;
+      }
+      ref = picked.tip_head_branch;
+      const pickedIsInferred = !!(picked.inferredOnly || picked.inferredFromViewerDoc);
+      let pickedDoc = null;
+      if (pickedIsInferred && Array.isArray(picked.prs)) {
+        const prNums = 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);
+        if (prNums.length > 0) {
+          pickedDoc = createInferredStackDoc(
+            String(doc.repo_full_name || `${owner}/${repoName}`),
+            String(picked.created_by || ""),
+            prNums
+          );
+        }
+      }
+      try {
+        if (tuiSession) {
+          await withStackLoadInkScreen("Loading stack…", async () => {
+            if (pickedDoc) {
+              doc = pickedDoc;
+            } else {
+              const loaded = await loadStackDocForView({
+                root,
+                repo,
+                ref,
+                file: opts.file
+              });
+              doc = loaded.doc;
+            }
+            const { owner: oPick, repo: rPick } = parseRepoFullName(doc.repo_full_name);
+            rows = await fetchStackRowsWithAutoapply(
+              oPick,
+              rPick,
+              doc,
+              mergedReviewFetch,
+              !!opts.reviewAutoapply
+            );
+            owner = oPick;
+            repoName = rPick;
+          });
+        } else {
+          if (pickedDoc) {
+            doc = pickedDoc;
+          } else {
+            const loaded = await loadStackDocForView({
+              root,
+              repo,
+              ref,
+              file: opts.file
+            });
+            doc = loaded.doc;
+          }
+          const { owner: oPick, repo: rPick } = parseRepoFullName(doc.repo_full_name);
+          const reloadPick = createSpinner("Loading stack");
+          reloadPick.start();
+          rows = await fetchStackRowsWithAutoapply(
+            oPick,
+            rPick,
+            doc,
+            mergedReviewFetch,
+            !!opts.reviewAutoapply
+          );
+          reloadPick.stop(`loaded ${rows.length} PR(s)`);
+          owner = oPick;
+          repoName = rPick;
+        }
+      } catch (e) {
+        console.error(`Could not load stack: ${String(/** @type {{ message?: string }} */ (e)?.message || e)}`);
+        continue;
+      }
+      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(/** @type {{ message?: 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(/** @type {{ message?: 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(/** @type {{ message?: string }} */ (e)?.message || e)}`);
+      }
+      continue;
+    }
+
     if (next.type === "split") {
       try {
         const r = findGitRoot();
@@ -355,7 +990,7 @@ export async function runStackViewCommand(opts) {
         }
         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)}`);