nugit-cli 0.1.0 → 0.1.1

package/src/review-hub/review-hub-ink.js

@@ -14,8 +14,9 @@ const VIEWPORT_ROWS = 14;
  * @param {object} props
  * @param {HubLine[]} props.lines
  * @param {(fullName: string) => void} props.onPickRepo
+ * @param {() => void} [props.onBack] Called when user presses Backspace/Esc to go back
  */
-export function ReviewHubInk({ lines, onPickRepo }) {
+export function ReviewHubInk({ lines, onPickRepo, onBack }) {
   const { exit } = useApp();
   const { stdout } = useStdout();
   /** @type {React.MutableRefObject<{ firstListRow: number, viewStart: number, slice: HubLine[] } | null>} */
@@ -91,7 +92,9 @@ export function ReviewHubInk({ lines, onPickRepo }) {
       return;
     }
 
-    if (input === "q" || key.escape) {
+    const backKey = key.backspace || key.delete || input === "\x7f" || input === "\b";
+    if (input === "q" || key.escape || backKey) {
+      onBack?.();
       exit();
       return;
     }
@@ -159,7 +162,7 @@ export function ReviewHubInk({ lines, onPickRepo }) {
     Box,
     { flexDirection: "column", padding: 1 },
     React.createElement(Text, { color: "cyan", bold: true }, "nugit review — repositories"),
-    React.createElement(Text, { dimColor: true }, "j/k · 1-9 open · Enter/Space · click · wheel · q quit"),
+    React.createElement(Text, { dimColor: true }, "j/k · 1-9 open · Enter/Space · click · wheel · Backspace/q back"),
     status ? React.createElement(Text, { dimColor: true }, status) : null,
     ...rendered
   );

package/src/review-hub/run-review-hub.js

@@ -1,18 +1,6 @@
-import React from "react";
-import { render } from "ink";
 import { authMe } from "../api-client.js";
-import {
-  githubListAllUserRepos,
-  githubSearchIssues
-} from "../github-rest.js";
+import { githubListAllUserRepos, githubSearchIssues } from "../github-rest.js";
 import { resolveGithubToken } from "../auth-token.js";
-import { runStackViewCommand } from "../stack-view/run-stack-view.js";
-import { ReviewHubInk } from "./review-hub-ink.js";
-import { ReviewHubBackError } from "./review-hub-back.js";
-import {
-  enterAlternateScreen,
-  leaveAlternateScreen
-} from "../stack-view/terminal-fullscreen.js";
 
 /**
  * @param {string} login
@@ -30,9 +18,7 @@ async function pendingReviewsByRepo(login) {
       page
     );
     const items = Array.isArray(res.items) ? res.items : [];
-    if (items.length === 0) {
-      break;
-    }
+    if (items.length === 0) break;
     for (const it of items) {
       if (!it || typeof it !== "object") continue;
       const u = /** @type {Record<string, unknown>} */ (it).repository_url;
@@ -42,9 +28,7 @@ async function pendingReviewsByRepo(login) {
       const full = `${m[1]}/${m[2]}`;
       map.set(full, (map.get(full) || 0) + 1);
     }
-    if (items.length < 100) {
-      break;
-    }
+    if (items.length < 100) break;
     page += 1;
   }
   return map;
@@ -59,7 +43,10 @@ function normalizeRepo(repoObj, pendingMap) {
   const r = /** @type {Record<string, unknown>} */ (repoObj);
   const fn = typeof r.full_name === "string" ? r.full_name : "";
   if (!fn) return null;
-  const owner = r.owner && typeof r.owner === "object" ? /** @type {Record<string, unknown>} */ (r.owner) : {};
+  const owner =
+    r.owner && typeof r.owner === "object"
+      ? /** @type {Record<string, unknown>} */ (r.owner)
+      : {};
   const ownerType = typeof owner.type === "string" ? owner.type : "User";
   const pending = pendingMap.get(fn) || 0;
   return { fullName: fn, ownerType, pending };
@@ -67,8 +54,9 @@ function normalizeRepo(repoObj, pendingMap) {
 
 /**
  * @param {{ fullName: string, ownerType: string, pending: number }[]} repos
+ * @returns {import("./review-hub-ink.js").HubLine[]}
  */
-function buildHubLines(repos) {
+export function buildHubLines(repos) {
   const sorted = [...repos].sort((a, b) => {
     if (b.pending !== a.pending) return b.pending - a.pending;
     return a.fullName.localeCompare(b.fullName);
@@ -83,28 +71,22 @@ function buildHubLines(repos) {
     const key = `${bucket}:${ownerLogin}`;
     if (key !== lastBucket) {
       lastBucket = key;
-      lines.push({
-        kind: "header",
-        text: `${bucket} — ${ownerLogin}`
-      });
+      lines.push({ kind: "header", text: `${bucket} — ${ownerLogin}` });
     }
-    lines.push({
-      kind: "repo",
-      fullName: r.fullName,
-      pending: r.pending
-    });
+    lines.push({ kind: "repo", fullName: r.fullName, pending: r.pending });
   }
   return lines;
 }
 
 /**
- * @param {{ noTui?: boolean, autoApply?: boolean }} opts
+ * Fetch all data needed for the review hub UI.
+ * Does NOT touch the terminal or render any UI.
+ * @returns {Promise<{ login: string, lines: import("./review-hub-ink.js").HubLine[] }>}
  */
-export async function runReviewHub(opts) {
+export async function fetchReviewHubData() {
   if (!resolveGithubToken()) {
     throw new Error(
-      "GitHub token required for nugit review. Run `nugit auth login` or set NUGIT_USER_TOKEN / STACKPR_USER_TOKEN " +
-        "(PAT must allow repo access and search for review-requested PRs)."
+      "GitHub token required for the review hub. Run `nugit auth login` or set NUGIT_USER_TOKEN / STACKPR_USER_TOKEN."
     );
   }
 
@@ -119,70 +101,31 @@ export async function runReviewHub(opts) {
     pendingReviewsByRepo(login)
   ]);
 
-  const repos = [];
+  const repos = /** @type {{ fullName: string, ownerType: string, pending: number }[]} */ ([]);
   for (const r of rawRepos) {
     const n = normalizeRepo(r, pendingMap);
     if (n) repos.push(n);
   }
 
-  if (opts.noTui || !process.stdin.isTTY || !process.stdout.isTTY) {
-    for (const r of [...repos].sort((a, b) => b.pending - a.pending || a.fullName.localeCompare(b.fullName))) {
-      const p = r.pending ? `  (${r.pending} pending)` : "";
-      console.log(`${r.fullName}${p}`);
-    }
-    return;
-  }
+  const lines = buildHubLines(repos);
+  return { login, lines };
+}
 
-  const tty = process.stdin.isTTY && process.stdout.isTTY;
-  if (tty) {
-    enterAlternateScreen(process.stdout);
-  }
-  try {
-    for (;;) {
-      const lines = buildHubLines(repos);
-      if (lines.filter((l) => l.kind === "repo").length === 0) {
-        console.error("No repositories visible to this token.");
-        return;
-      }
+/**
+ * Non-TUI (scripting / CI) path: print repo list to stdout.
+ * @param {{ noTui?: boolean, autoApply?: boolean }} opts
+ */
+export async function runReviewHub(opts) {
+  const { login, lines } = await fetchReviewHubData();
+  void login;
 
-      let picked = /** @type {string | null} */ (null);
-      const { waitUntilExit } = render(
-        React.createElement(ReviewHubInk, {
-          lines,
-          onPickRepo: (fn) => {
-            picked = fn;
-          }
-        })
-      );
-      await waitUntilExit();
-      if (!picked) {
-        return;
-      }
+  const repos = lines
+    .filter((l) => l.kind === "repo")
+    .map((l) => /** @type {{ kind: "repo", fullName: string, pending: number }} */ (l));
 
-      try {
-        await runStackViewCommand({
-          repo: picked,
-          noTui: false,
-          allowBackToReviewHub: true,
-          reviewAutoapply: !!opts.autoApply,
-          reviewFetchOpts: {
-            viewerLogin: login,
-            fullReviewFetch: true
-          },
-          viewTitle: "nugit review",
-          shellMode: false
-        });
-        break;
-      } catch (e) {
-        if (e instanceof ReviewHubBackError) {
-          continue;
-        }
-        throw e;
-      }
-    }
-  } finally {
-    if (tty) {
-      leaveAlternateScreen(process.stdout);
-    }
+  for (const r of repos) {
+    const p = r.pending ? `  (${r.pending} pending)` : "";
+    console.log(`${r.fullName}${p}`);
   }
+  void opts;
 }

package/src/services/repo-branches.js

@@ -0,0 +1,151 @@
+/**
+ * Service functions for the "Branches / PRs" TUI page.
+ * Fuses local git branches with remote GitHub branches into a unified model.
+ */
+
+import { execFileSync } from "child_process";
+import { githubListAllBranches } from "../github-rest.js";
+
+/**
+ * @typedef {{ name: string, sha: string }} LocalBranch
+ * @typedef {{ name: string, sha: string }} RemoteBranch
+ * @typedef {"local_only" | "remote_only" | "in_sync" | "local_ahead" | "remote_ahead" | "diverged"} BranchStatus
+ * @typedef {{ name: string, local: LocalBranch | null, remote: RemoteBranch | null, status: BranchStatus, ahead: number, behind: number }} BranchRow
+ */
+
+/**
+ * @param {string} root  git working tree root
+ * @returns {LocalBranch[]}
+ */
+export function listLocalBranches(root) {
+  try {
+    const out = execFileSync(
+      "git",
+      ["for-each-ref", "--format=%(refname:short) %(objectname:short)", "refs/heads/"],
+      { cwd: root, encoding: "utf8", stdio: "pipe" }
+    ).trim();
+    if (!out) return [];
+    return out.split("\n").map((line) => {
+      const [name, sha] = line.trim().split(/\s+/);
+      return { name: name || "", sha: sha || "" };
+    }).filter((b) => b.name);
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * @param {string} owner
+ * @param {string} repo
+ * @returns {Promise<RemoteBranch[]>}
+ */
+export async function listRemoteBranches(owner, repo) {
+  const raw = await githubListAllBranches(owner, repo);
+  /** @type {RemoteBranch[]} */
+  const result = [];
+  for (const b of raw) {
+    if (!b || typeof b !== "object") continue;
+    const br = /** @type {Record<string, unknown>} */ (b);
+    const name = typeof br.name === "string" ? br.name : "";
+    const commit =
+      br.commit && typeof br.commit === "object"
+        ? /** @type {Record<string, unknown>} */ (br.commit)
+        : {};
+    const sha = typeof commit.sha === "string" ? commit.sha.slice(0, 12) : "";
+    if (name) result.push({ name, sha });
+  }
+  return result;
+}
+
+/**
+ * Compute ahead/behind counts between two refs using `git rev-list --left-right --count`.
+ * Returns { ahead, behind } where ahead = local commits not on remote, behind = remote commits not on local.
+ * @param {string} root
+ * @param {string} localRef  e.g. "refs/heads/feat"
+ * @param {string} remoteRef  e.g. "origin/feat"
+ * @returns {{ ahead: number, behind: number }}
+ */
+function countAheadBehind(root, localRef, remoteRef) {
+  try {
+    const out = execFileSync(
+      "git",
+      ["rev-list", "--left-right", "--count", `${remoteRef}...${localRef}`],
+      { cwd: root, encoding: "utf8", stdio: "pipe" }
+    ).trim();
+    const parts = out.split(/\s+/);
+    const behind = Number.parseInt(parts[0], 10) || 0;
+    const ahead = Number.parseInt(parts[1], 10) || 0;
+    return { ahead, behind };
+  } catch {
+    return { ahead: 0, behind: 0 };
+  }
+}
+
+/**
+ * Merge local and remote branch lists into a unified model.
+ * When a branch exists in both, compute ahead/behind using git (requires local clone).
+ *
+ * @param {LocalBranch[]} localBranches
+ * @param {RemoteBranch[]} remoteBranches
+ * @param {string | null} root  git root for ahead/behind computation (null = no local clone)
+ * @param {string} remoteName  git remote name, e.g. "origin"
+ * @returns {Promise<BranchRow[]>}
+ */
+export async function mergeBranchModel(localBranches, remoteBranches, root, remoteName = "origin") {
+  /** @type {Map<string, LocalBranch>} */
+  const localMap = new Map(localBranches.map((b) => [b.name, b]));
+  /** @type {Map<string, RemoteBranch>} */
+  const remoteMap = new Map(remoteBranches.map((b) => [b.name, b]));
+
+  /** @type {Set<string>} */
+  const allNames = new Set([...localMap.keys(), ...remoteMap.keys()]);
+
+  /** @type {BranchRow[]} */
+  const rows = [];
+
+  for (const name of allNames) {
+    const local = localMap.get(name) ?? null;
+    const remote = remoteMap.get(name) ?? null;
+
+    /** @type {BranchStatus} */
+    let status = "in_sync";
+    let ahead = 0;
+    let behind = 0;
+
+    if (local && remote) {
+      if (local.sha === remote.sha.slice(0, local.sha.length) || remote.sha === local.sha.slice(0, remote.sha.length)) {
+        status = "in_sync";
+      } else if (root) {
+        const ab = countAheadBehind(root, `refs/heads/${name}`, `${remoteName}/${name}`);
+        ahead = ab.ahead;
+        behind = ab.behind;
+        if (ahead > 0 && behind > 0) {
+          status = "diverged";
+        } else if (ahead > 0) {
+          status = "local_ahead";
+        } else if (behind > 0) {
+          status = "remote_ahead";
+        } else {
+          status = "in_sync";
+        }
+      }
+    } else if (local && !remote) {
+      status = "local_only";
+    } else if (!local && remote) {
+      status = "remote_only";
+    }
+
+    rows.push({ name, local, remote, status, ahead, behind });
+  }
+
+  // Sort: local_ahead first (actionable), then diverged, local_only, in_sync, remote_ahead, remote_only
+  const order = { local_ahead: 0, diverged: 1, local_only: 2, in_sync: 3, remote_ahead: 4, remote_only: 5 };
+  rows.sort((a, b) => {
+    const oa = order[a.status] ?? 99;
+    const ob = order[b.status] ?? 99;
+    if (oa !== ob) return oa - ob;
+    return a.name.localeCompare(b.name);
+  });
+
+  return rows;
+}

package/src/services/stack-inference.js

@@ -0,0 +1,90 @@
+/**
+ * Inference-only stack discovery service.
+ * Replaces the .nugit/stack.json scanning approach with open-PR chain analysis.
+ */
+import { githubListAllOpenPulls } from "../github-rest.js";
+import { inferPrChainsFromOpenPulls } from "../stack-infer-from-prs.js";
+import { inferChainsToPickStacks } from "../stack-view/infer-chains-to-pick-stacks.js";
+import {
+  openPullNumbersFromList,
+  tagPickStacksMergedState
+} from "../stack-view/merge-alternate-pick-stacks.js";
+import { createInferredStackDoc, parseRepoFullName } from "../nugit-stack.js";
+import { authMe } from "../api-client.js";
+
+/**
+ * Discover stacks for a repo using open-PR chain inference (no .nugit required).
+ * Returns rows in the same shape as StackPickInk expects.
+ *
+ * @param {string} owner
+ * @param {string} repoName
+ * @returns {Promise<{ stacks: object[], openPullNumbers: Set<number> }>}
+ */
+export async function discoverStacksByInference(owner, repoName) {
+  const pulls = await githubListAllOpenPulls(owner, repoName);
+  const openNums = openPullNumbersFromList(pulls);
+  const repoFull = `${owner}/${repoName}`;
+  const chains = inferPrChainsFromOpenPulls(pulls, repoFull);
+  const stacks = inferChainsToPickStacks(chains, pulls).map((s) => ({
+    ...s,
+    inferredOnly: true
+  }));
+  return {
+    stacks: tagPickStacksMergedState(stacks, openNums),
+    openPullNumbers: openNums
+  };
+}
+
+/**
+ * Build an inferred stack document from open PRs, picking the best chain or
+ * prompting the user. Returns a viewer-ready stack doc.
+ *
+ * @param {string} repoFull
+ * @param {{
+ *   preselectedChainIndex?: number,
+ *   tuiChainPick?: (chains: number[][], pulls: unknown[]) => Promise<number>
+ * }} [opts]
+ * @returns {Promise<{ doc: Record<string, unknown>, viewerLogin: string, pulls: unknown[] }>}
+ */
+export async function buildInferredViewerDoc(repoFull, opts = {}) {
+  const { owner, repo } = parseRepoFullName(repoFull);
+  const pulls = await githubListAllOpenPulls(owner, repo);
+  const chains = inferPrChainsFromOpenPulls(pulls, repoFull);
+
+  if (chains.length === 0) {
+    throw new Error(
+      `No open PR stacks found in ${repoFull}. ` +
+        "Open some PRs in a stacked chain (base of one PR = head of another) and try again."
+    );
+  }
+
+  const me = await authMe();
+  const viewerLogin = me && typeof me.login === "string" ? me.login : "viewer";
+
+  let chosen;
+  if (chains.length === 1) {
+    chosen = chains[0];
+  } else if (typeof opts.preselectedChainIndex === "number") {
+    const i = opts.preselectedChainIndex;
+    if (i < 0 || i >= chains.length) throw new Error("Invalid preselectedChainIndex.");
+    chosen = chains[i];
+  } else if (typeof opts.tuiChainPick === "function") {
+    const idx = await opts.tuiChainPick(chains, pulls);
+    if (idx === -2) {
+      const { RepoPickerBackError } = await import("../stack-view/repo-picker-back.js");
+      throw new RepoPickerBackError();
+    }
+    if (idx < 0 || idx >= chains.length) {
+      throw new Error("Stack selection cancelled.");
+    }
+    chosen = chains[idx];
+  } else {
+    chosen = chains.reduce((a, b) => (b.length > a.length ? b : a));
+  }
+
+  return {
+    doc: createInferredStackDoc(repoFull, viewerLogin, chosen),
+    viewerLogin,
+    pulls
+  };
+}

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

@@ -1,15 +1,7 @@
 import React from "react";
 import { render } from "ink";
-import { authMe, getPull, createPullRequest } from "../api-client.js";
+import { getPull, createPullRequest, authMe } from "../api-client.js";
 import { githubPostIssueComment } from "../github-pr-social.js";
-import {
-  createInitialStackDoc,
-  readStackFile,
-  writeStackFile,
-  validateStackDoc,
-  stackEntryFromGithubPull
-} from "../nugit-stack.js";
-import { appendStackHistory } from "../stack-graph.js";
 import {
   assertCleanWorkingTree,
   gitExec,
@@ -28,6 +20,7 @@ import { SplitInkApp } from "./split-ink.js";
  * @param {number} ctx.prNumber
  * @param {boolean} [ctx.dryRun]
  * @param {string} [ctx.remote]
+ * @returns {Promise<{ newPrNumbers: number[], newBranches: string[] } | null>}
  */
 export async function runSplitCommand(ctx) {
   const { root, owner, repo, prNumber, dryRun = false, remote = "origin" } = ctx;
@@ -60,12 +53,8 @@ export async function runSplitCommand(ctx) {
   const next = exitPayload.next;
   if (!next || next.type !== "confirm") {
     console.error("Split cancelled.");
-    try {
-      gitExec(root, ["checkout", baseBranch]);
-    } catch {
-      /* ignore */
-    }
-    return;
+    try { gitExec(root, ["checkout", baseBranch]); } catch { /* ignore */ }
+    return null;
   }
   const { byLayer, layerCount } = next;
   for (let L = 0; L < layerCount; L++) {
@@ -81,17 +70,10 @@ export async function runSplitCommand(ctx) {
   for (let i = 0; i < layerCount; i++) {
     const b = `${prefix}-L${i}`;
     const did = commitLayerFromPaths(
-      root,
-      remote,
-      b,
-      startRef,
-      headRef,
-      byLayer[i],
+      root, remote, b, startRef, headRef, byLayer[i],
       `nugit split: PR #${prNumber} layer ${i + 1}/${layerCount}`
     );
-    if (!did) {
-      throw new Error(`No commit produced for layer ${i}`);
-    }
+    if (!did) throw new Error(`No commit produced for layer ${i}`);
     newBranches.push(b);
     startRef = b;
   }
@@ -99,7 +81,7 @@ export async function runSplitCommand(ctx) {
   if (dryRun) {
     console.error("Dry-run: branches (not pushed):", newBranches.join(", "));
     gitExec(root, ["checkout", baseBranch]);
-    return;
+    return null;
   }
 
   for (const b of newBranches) {
@@ -110,10 +92,9 @@ export async function runSplitCommand(ctx) {
   const newPrNumbers = [];
   let prevBase = baseBranch;
   for (let i = 0; i < newBranches.length; i++) {
-    const title =
-      pull.title != null
-        ? `[split ${i + 1}/${newBranches.length}] ${pull.title}`
-        : `Split of #${prNumber} (${i + 1}/${newBranches.length})`;
+    const title = pull.title != null
+      ? `[split ${i + 1}/${newBranches.length}] ${pull.title}`
+      : `Split of #${prNumber} (${i + 1}/${newBranches.length})`;
     const created = await createPullRequest(owner, repo, {
       title,
       head: newBranches[i],
@@ -121,74 +102,18 @@ export async function runSplitCommand(ctx) {
       body: `Split from #${prNumber} (nugit split layer ${i + 1}).\n\nOriginal: ${pull.html_url || ""}`
     });
     const num = /** @type {{ number?: number }} */ (created).number;
-    if (typeof num !== "number") {
-      throw new Error("GitHub did not return PR number");
-    }
+    if (typeof num !== "number") throw new Error("GitHub did not return PR number");
     newPrNumbers.push(num);
     prevBase = newBranches[i];
   }
 
-  /** @type {Record<string, unknown> | null} */
-  let docForHistory = null;
-  let doc = readStackFile(root);
-  if (doc) {
-    validateStackDoc(doc);
-    const idx = doc.prs.findIndex((p) => p.pr_number === prNumber);
-    if (idx >= 0) {
-      doc.prs.splice(idx, 1);
-      const insertAt = idx;
-      for (let i = 0; i < newPrNumbers.length; i++) {
-        const p2 = await getPull(owner, repo, newPrNumbers[i]);
-        doc.prs.splice(insertAt + i, 0, stackEntryFromGithubPull(p2, insertAt + i));
-      }
-      for (let j = 0; j < doc.prs.length; j++) {
-        doc.prs[j].position = j;
-      }
-      writeStackFile(root, doc);
-      docForHistory = doc;
-    } else {
-      console.error(
-        `Warning: PR #${prNumber} not in .nugit/stack.json — local stack file left unchanged.`
-      );
-    }
-  } else {
-    const me = await authMe();
-    const login = me && typeof me.login === "string" ? me.login : "unknown";
-    doc = createInitialStackDoc(`${owner}/${repo}`, login);
-    doc.prs = [];
-    for (let i = 0; i < newPrNumbers.length; i++) {
-      const p2 = await getPull(owner, repo, newPrNumbers[i]);
-      doc.prs.push(stackEntryFromGithubPull(p2, i));
-    }
-    writeStackFile(root, doc);
-    docForHistory = doc;
-    console.error(
-      `Created .nugit/stack.json with ${newPrNumbers.length} PR(s) from this split (repo had no stack file).`
-    );
-  }
-
-  appendStackHistory(root, {
-    action: "split",
-    repo_full_name: `${owner}/${repo}`,
-    tip_pr_number: newPrNumbers[newPrNumbers.length - 1],
-    head_branch: newBranches[newBranches.length - 1],
-    ...(docForHistory ? { snapshot: docForHistory } : {}),
-    from_pr: prNumber,
-    new_prs: newPrNumbers
-  });
-
   await githubPostIssueComment(
-    owner,
-    repo,
-    prNumber,
+    owner, repo, prNumber,
     `This PR was split into: ${newPrNumbers.map((n) => `#${n}`).join(", ")}. You can close this PR when the new stack is ready.`
   );
 
-  try {
-    gitExec(root, ["checkout", baseBranch]);
-  } catch {
-    /* ignore */
-  }
+  try { gitExec(root, ["checkout", baseBranch]); } catch { /* ignore */ }
 
   console.error(`Split complete. New PRs: ${newPrNumbers.join(", ")}`);
+  return { newPrNumbers, newBranches };
 }

package/src/stack-view/infer-chains-to-pick-stacks.js

@@ -56,6 +56,15 @@ export function inferChainsToPickStacks(chains, pulls) {
 
     const hasLineStats = sumAdd > 0 || sumDel > 0;
 
+    // base_ref: the branch that the bottom PR (chain[0]) targets
+    const bottomPr = chain[0];
+    const bottomPull = bottomPr ? byNum.get(bottomPr) : undefined;
+    const bottomBase =
+      bottomPull && bottomPull.base && typeof bottomPull.base === "object"
+        ? /** @type {Record<string, unknown>} */ (bottomPull.base)
+        : {};
+    const base_ref = typeof bottomBase.ref === "string" ? bottomBase.ref : "";
+
     return {
       tip_pr_number: tipPr,
       tip_head_branch: tipHead,
@@ -64,6 +73,7 @@ export function inferChainsToPickStacks(chains, pulls) {
       prs: prRows,
       tip_updated_at,
       inferChainIndex,
+      base_ref,
       ...(hasLineStats ? { inferDiffAdd: sumAdd, inferDiffDel: sumDel } : {})
     };
   });