nugit-cli 0.0.1 → 0.1.1

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

@@ -1,14 +1,7 @@
 import React from "react";
 import { render } from "ink";
-import { getPull, createPullRequest } from "../api-client.js";
+import { getPull, createPullRequest, authMe } from "../api-client.js";
 import { githubPostIssueComment } from "../github-pr-social.js";
-import {
-  readStackFile,
-  writeStackFile,
-  validateStackDoc,
-  stackEntryFromGithubPull
-} from "../nugit-stack.js";
-import { appendStackHistory } from "../stack-graph.js";
 import {
   assertCleanWorkingTree,
   gitExec,
@@ -27,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;
@@ -59,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++) {
@@ -80,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;
   }
@@ -98,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) {
@@ -109,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],
@@ -120,62 +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;
-  const 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 {
-    console.error("No .nugit/stack.json — skipped local stack file update.");
-  }
-
-  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/split-view/split-ink.js

@@ -39,7 +39,7 @@ export function SplitInkApp({ files, exitPayload }) {
       exit();
       return;
     }
-    if (input === "c") {
+    if (input === "c" || key.return || input === " ") {
       exitPayload.next = {
         type: "confirm",
         layerCount,
@@ -82,7 +82,7 @@ export function SplitInkApp({ files, exitPayload }) {
     React.createElement(
       Text,
       { dimColor: true },
-      `Layers: ${layerCount}  (+/-)  |  assign file to layer 0–${layerCount - 1} (digit)  |  c confirm  |  q cancel`
+      `Layers: ${layerCount}  (+/-)  |  assign file to layer 0–${layerCount - 1} (digit)  |  c / Enter / Space confirm  |  q cancel`
     ),
     React.createElement(Text, { marginTop: 1 }, chalk.bold("Files:")),
     ...files.slice(0, 18).map((f, i) =>

package/src/stack-infer-from-prs.js

@@ -0,0 +1,71 @@
+/**
+ * Infer linear stacked PR chains from open pulls using base.ref === other.head.ref (same-repo v1).
+ * @param {unknown[]} pulls GitHub pull objects (open).
+ * @param {string} repoFullName e.g. "owner/repo" — heads must match this repo (fork PRs skipped).
+ * @returns {number[][]} Chains ordered bottom → top (PR numbers).
+ */
+export function inferPrChainsFromOpenPulls(pulls, repoFullName) {
+  /** @type {{ number: number, headRef: string, baseRef: string }[]} */
+  const prs = [];
+  for (const raw of pulls) {
+    if (!raw || typeof raw !== "object") continue;
+    const p = /** @type {Record<string, unknown>} */ (raw);
+    const num = p.number;
+    const head = p.head && typeof p.head === "object" ? /** @type {Record<string, unknown>} */ (p.head) : {};
+    const base = p.base && typeof p.base === "object" ? /** @type {Record<string, unknown>} */ (p.base) : {};
+    const headRef = typeof head.ref === "string" ? head.ref : "";
+    const baseRef = typeof base.ref === "string" ? base.ref : "";
+    const headRepo =
+      head.repo && typeof head.repo === "object"
+        ? String(/** @type {Record<string, unknown>} */ (head.repo).full_name || "")
+        : "";
+    if (typeof num !== "number" || !headRef) continue;
+    if (headRepo && headRepo !== repoFullName) continue;
+    prs.push({ number: num, headRef, baseRef });
+  }
+
+  /** child PR# -> parent PR# below (parent.head === child.base) */
+  const parentBelow = new Map();
+  /** parent PR# -> child PR# above */
+  const childAbove = new Map();
+  for (const x of prs) {
+    const below = prs.find((p) => p.headRef === x.baseRef);
+    if (below && below.number !== x.number) {
+      parentBelow.set(x.number, below.number);
+      childAbove.set(below.number, x.number);
+    }
+  }
+
+  const bottoms = prs.filter((p) => !parentBelow.has(p.number));
+  /** @type {number[][]} */
+  const chains = [];
+  for (const b of bottoms) {
+    const chain = [];
+    let cur = /** @type {number | null} */ (b.number);
+    const vis = new Set();
+    while (cur != null && !vis.has(cur)) {
+      vis.add(cur);
+      chain.push(cur);
+      const next = childAbove.get(cur);
+      cur = next !== undefined ? next : null;
+    }
+    if (chain.length) {
+      chains.push(chain);
+    }
+  }
+
+  const inChain = new Set(chains.flat());
+  for (const p of prs) {
+    if (!inChain.has(p.number)) {
+      chains.push([p.number]);
+    }
+  }
+
+  chains.sort((a, b) => {
+    const ta = a[a.length - 1] ?? 0;
+    const tb = b[b.length - 1] ?? 0;
+    if (ta !== tb) return ta - tb;
+    return (a[0] ?? 0) - (b[0] ?? 0);
+  });
+  return chains;
+}

package/src/stack-view/diff-line-map.js

@@ -0,0 +1,62 @@
+/**
+ * Map a 0-based index in a unified diff (patch) line array to the GitHub
+ * pull-request review comment `line` and `side` fields.
+ *
+ * GitHub's `line` is the **1-based** line number in the *final* (RIGHT) or
+ * *original* (LEFT) file at that position in the hunk.  Context lines map to
+ * RIGHT/line in the new file.  `+` lines map to RIGHT.  `-` lines map to LEFT.
+ *
+ * Header lines (`@@`, `---`, `+++`) are not commentable — returns null.
+ *
+ * @param {string[]} patchLines  the `patch` string split by `\n`
+ * @param {number} idx  0-based index into `patchLines`
+ * @returns {{ line: number, side: "LEFT" | "RIGHT" } | null}
+ */
+export function diffLineToGitHub(patchLines, idx) {
+  if (idx < 0 || idx >= patchLines.length) {
+    return null;
+  }
+  const target = patchLines[idx];
+  if (
+    target.startsWith("@@") ||
+    target.startsWith("--- ") ||
+    target.startsWith("+++ ") ||
+    target.startsWith("diff ")
+  ) {
+    return null;
+  }
+
+  let oldLine = 0;
+  let newLine = 0;
+
+  for (let i = 0; i <= idx; i++) {
+    const ln = patchLines[i];
+    if (ln.startsWith("@@")) {
+      const m = ln.match(/@@ -(\d+)(?:,\d+)? \+(\d+)/);
+      if (m) {
+        oldLine = Number(m[1]);
+        newLine = Number(m[2]);
+      }
+      continue;
+    }
+    if (ln.startsWith("--- ") || ln.startsWith("+++ ") || ln.startsWith("diff ")) {
+      continue;
+    }
+    if (i === idx) {
+      break;
+    }
+    if (ln.startsWith("+")) {
+      newLine++;
+    } else if (ln.startsWith("-")) {
+      oldLine++;
+    } else {
+      oldLine++;
+      newLine++;
+    }
+  }
+
+  if (target.startsWith("-")) {
+    return { line: oldLine, side: "LEFT" };
+  }
+  return { line: newLine, side: "RIGHT" };
+}

package/src/stack-view/fetch-pr-data.js

@@ -1,4 +1,11 @@
-import { githubGetPull, githubListPullFiles, githubRestJson } from "../github-rest.js";
+import {
+  githubGetPull,
+  githubListPullFiles,
+  githubRestJson,
+  githubCompareRefs
+} from "../github-rest.js";
+import { githubListPullReviewsAll } from "../github-pr-social.js";
+import { compareLooksLikeMainMergesOnly } from "../review-hub/review-autoapprove.js";
 
 /**
  * @param {unknown[]} items
@@ -80,35 +87,127 @@ function summarizeReviewState(reviews) {
   return "none";
 }
 
+/**
+ * @param {string} owner
+ * @param {string} repo
+ * @param {unknown[]} reviews
+ * @param {string} viewerLogin
+ * @param {string} headSha
+ * @param {string} defaultBranch
+ */
+async function buildViewerReviewMeta(owner, repo, reviews, viewerLogin, headSha, defaultBranch) {
+  /** @type {{ staleApproval: boolean, lastApprovalCommit: string | null, headSha: string, dismissedReview: boolean, riskyChangeAfterApproval: boolean | null, commitsSinceApproval: number }} */
+  const meta = {
+    staleApproval: false,
+    lastApprovalCommit: null,
+    headSha,
+    dismissedReview: false,
+    riskyChangeAfterApproval: null,
+    commitsSinceApproval: 0
+  };
+  if (!viewerLogin || !headSha) {
+    return meta;
+  }
+  for (const rv of reviews) {
+    if (!rv || typeof rv !== "object") continue;
+    const r = /** @type {Record<string, unknown>} */ (rv);
+    const user = r.user && typeof r.user === "object" ? /** @type {Record<string, unknown>} */ (r.user) : {};
+    const login = typeof user.login === "string" ? user.login : "";
+    if (login !== viewerLogin) continue;
+    const state = typeof r.state === "string" ? r.state.toUpperCase() : "";
+    if (state === "DISMISSED") {
+      meta.dismissedReview = true;
+    }
+  }
+  let lastApprovalCommit = null;
+  for (let i = reviews.length - 1; i >= 0; i--) {
+    const rv = reviews[i];
+    if (!rv || typeof rv !== "object") continue;
+    const r = /** @type {Record<string, unknown>} */ (rv);
+    const user = r.user && typeof r.user === "object" ? /** @type {Record<string, unknown>} */ (r.user) : {};
+    const login = typeof user.login === "string" ? user.login : "";
+    if (login !== viewerLogin) continue;
+    const state = typeof r.state === "string" ? r.state.toUpperCase() : "";
+    if (state === "APPROVED" && typeof r.commit_id === "string") {
+      lastApprovalCommit = r.commit_id;
+      break;
+    }
+  }
+  meta.lastApprovalCommit = lastApprovalCommit;
+  if (lastApprovalCommit && lastApprovalCommit !== headSha) {
+    meta.staleApproval = true;
+    try {
+      const cmp = await githubCompareRefs(owner, repo, lastApprovalCommit, headSha);
+      const total = typeof cmp.total_commits === "number" ? cmp.total_commits : 0;
+      meta.commitsSinceApproval = total;
+      const mergeOnly = compareLooksLikeMainMergesOnly(
+        /** @type {Record<string, unknown>} */ (cmp),
+        defaultBranch
+      );
+      meta.riskyChangeAfterApproval = !mergeOnly;
+    } catch {
+      meta.riskyChangeAfterApproval = true;
+    }
+  }
+  return meta;
+}
+
 /**
  * @param {string} owner
  * @param {string} repo
  * @param {Array<{ pr_number: number, position: number, head_branch?: string, base_branch?: string }>} prEntries
  * @param {number} [concurrency]
+ * @param {{ viewerLogin?: string, defaultBranch?: string, fullReviewFetch?: boolean }} [fetchOpts]
  */
-export async function fetchStackPrDetails(owner, repo, prEntries, concurrency = 6) {
+export async function fetchStackPrDetails(owner, repo, prEntries, concurrency = 6, fetchOpts = {}) {
+  const viewerLogin = fetchOpts.viewerLogin || "";
+  const defaultBranch = fetchOpts.defaultBranch || "main";
+  const fullFetch = !!fetchOpts.fullReviewFetch || !!viewerLogin;
+
   const sorted = [...prEntries].sort((a, b) => a.position - b.position);
   return mapInBatches(sorted, concurrency, async (entry) => {
     const n = entry.pr_number;
     try {
       const pull = await githubGetPull(owner, repo, n);
+      const headSha =
+        pull && typeof pull === "object" && pull.head && typeof pull.head === "object"
+          ? String(/** @type {Record<string, unknown>} */ (pull.head).sha || "")
+          : "";
+
       const [issueRes, reviewRes, filesRes, reviewsRes] = await Promise.allSettled([
         githubListIssueCommentsFirstPage(owner, repo, n),
         githubListPullReviewCommentsFirstPage(owner, repo, n),
         githubListPullFiles(owner, repo, n),
-        githubListPullReviewsFirstPage(owner, repo, n)
+        fullFetch
+          ? githubListPullReviewsAll(owner, repo, n)
+          : githubListPullReviewsFirstPage(owner, repo, n)
       ]);
       const issueComments = issueRes.status === "fulfilled" ? issueRes.value : [];
       const reviewComments = reviewRes.status === "fulfilled" ? reviewRes.value : [];
       const files = filesRes.status === "fulfilled" ? filesRes.value : [];
       const reviews = reviewsRes.status === "fulfilled" ? reviewsRes.value : [];
+      const reviewList = Array.isArray(reviews) ? reviews : [];
+
+      let viewerReviewMeta = null;
+      if (viewerLogin && headSha) {
+        viewerReviewMeta = await buildViewerReviewMeta(
+          owner,
+          repo,
+          reviewList,
+          viewerLogin,
+          headSha,
+          defaultBranch
+        );
+      }
+
       return {
         entry,
         pull,
         issueComments,
         reviewComments,
         files: Array.isArray(files) ? files : [],
-        reviewSummary: summarizeReviewState(reviews),
+        reviewSummary: summarizeReviewState(reviewList),
+        viewerReviewMeta,
         error: null
       };
     } catch (e) {
@@ -119,6 +218,7 @@ export async function fetchStackPrDetails(owner, repo, prEntries, concurrency =
         reviewComments: [],
         files: [],
         reviewSummary: "none",
+        viewerReviewMeta: null,
         error: String(/** @type {Error} */ (e).message || e)
       };
     }

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

@@ -0,0 +1,80 @@
+/**
+ * Build StackPickInk-shaped entries from inferred PR chains (bottom → tip) and GitHub pull payloads.
+ *
+ * @param {number[][]} chains
+ * @param {unknown[]} pulls
+ * @returns {object[]}
+ */
+export function inferChainsToPickStacks(chains, pulls) {
+  /** @type {Map<number, Record<string, unknown>>} */
+  const byNum = new Map();
+  for (const raw of pulls) {
+    if (!raw || typeof raw !== "object") continue;
+    const p = /** @type {Record<string, unknown>} */ (raw);
+    const num = p.number;
+    if (typeof num !== "number") continue;
+    byNum.set(num, p);
+  }
+
+  return chains.map((chain, inferChainIndex) => {
+    /** @type {{ pr_number: number, position: number, head_branch?: string, title?: string, additions?: number, deletions?: number }[]} */
+    const prRows = [];
+    let sumAdd = 0;
+    let sumDel = 0;
+    for (let i = 0; i < chain.length; i++) {
+      const prn = chain[i];
+      const pull = byNum.get(prn);
+      const head =
+        pull && pull.head && typeof pull.head === "object"
+          ? /** @type {Record<string, unknown>} */ (pull.head)
+          : {};
+      const ref = typeof head.ref === "string" ? head.ref : "";
+      const add = pull && typeof pull.additions === "number" ? pull.additions : 0;
+      const del = pull && typeof pull.deletions === "number" ? pull.deletions : 0;
+      sumAdd += add;
+      sumDel += del;
+      prRows.push({
+        pr_number: prn,
+        position: i,
+        head_branch: ref,
+        title: pull && typeof pull.title === "string" ? pull.title : undefined,
+        additions: add,
+        deletions: del
+      });
+    }
+
+    const tipPr = chain[chain.length - 1];
+    const tipPull = tipPr ? byNum.get(tipPr) : undefined;
+    const tipHead = prRows.length ? String(prRows[prRows.length - 1].head_branch || "") : "";
+    const tip_updated_at =
+      tipPull && typeof tipPull.updated_at === "string" ? tipPull.updated_at : "";
+    const user =
+      tipPull && tipPull.user && typeof tipPull.user === "object"
+        ? /** @type {Record<string, unknown>} */ (tipPull.user)
+        : {};
+    const login = typeof user.login === "string" ? user.login : "";
+
+    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,
+      pr_count: chain.length,
+      created_by: login,
+      prs: prRows,
+      tip_updated_at,
+      inferChainIndex,
+      base_ref,
+      ...(hasLineStats ? { inferDiffAdd: sumAdd, inferDiffDel: sumDel } : {})
+    };
+  });
+}