nugit-cli 0.0.1 → 0.1.0

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

@@ -0,0 +1,166 @@
+import React, { useEffect, useMemo, useRef, useState } from "react";
+import { Box, Text, useApp, useInput, useStdout } from "ink";
+import { parseSgrMouse, enableSgrMouse, disableSgrMouse, isWheelUp, isWheelDown } from "../stack-view/sgr-mouse.js";
+
+const VIEWPORT_ROWS = 14;
+
+/**
+ * @typedef {{ kind: "header"; text: string }} HubHeader
+ * @typedef {{ kind: "repo"; fullName: string; pending: number; subtitle?: string }} HubRepo
+ * @typedef {HubHeader | HubRepo} HubLine
+ */
+
+/**
+ * @param {object} props
+ * @param {HubLine[]} props.lines
+ * @param {(fullName: string) => void} props.onPickRepo
+ */
+export function ReviewHubInk({ lines, onPickRepo }) {
+  const { exit } = useApp();
+  const { stdout } = useStdout();
+  /** @type {React.MutableRefObject<{ firstListRow: number, viewStart: number, slice: HubLine[] } | null>} */
+  const layoutRef = useRef(null);
+  /** @type {React.MutableRefObject<{ t: number, lineIdx: number } | null>} */
+  const lastClickRef = useRef(null);
+
+  useEffect(() => {
+    enableSgrMouse(stdout);
+    return () => disableSgrMouse(stdout);
+  }, [stdout]);
+
+  const repoIndices = useMemo(
+    () => lines.map((l, i) => (l.kind === "repo" ? i : -1)).filter((i) => i >= 0),
+    [lines]
+  );
+
+  const [rpos, setRpos] = useState(0);
+  const safeRpos = repoIndices.length === 0 ? 0 : Math.min(rpos, repoIndices.length - 1);
+  const idx = repoIndices.length ? repoIndices[safeRpos] : 0;
+
+  const total = lines.length;
+  const viewStart =
+    total <= VIEWPORT_ROWS
+      ? 0
+      : Math.max(0, Math.min(idx - Math.floor(VIEWPORT_ROWS / 2), total - VIEWPORT_ROWS));
+  const slice = lines.slice(viewStart, viewStart + VIEWPORT_ROWS);
+
+  useInput((input, key) => {
+    const mouse = parseSgrMouse(input);
+    if (mouse) {
+      const L = layoutRef.current;
+      if (!L) {
+        return;
+      }
+      const { row, col, button, release } = mouse;
+      if (col < 2) {
+        return;
+      }
+      if (isWheelUp(button) || isWheelDown(button)) {
+        const down = isWheelDown(button);
+        if (repoIndices.length) {
+          if (down) {
+            setRpos((p) => Math.min(p + 1, repoIndices.length - 1));
+          } else {
+            setRpos((p) => Math.max(p - 1, 0));
+          }
+        }
+        return;
+      }
+      if (release) {
+        return;
+      }
+      const local = row - L.firstListRow;
+      if (local >= 0 && local < L.slice.length) {
+        const i = L.viewStart + local;
+        const line = lines[i];
+        if (line && line.kind === "repo") {
+          const ri = repoIndices.indexOf(i);
+          if (ri >= 0) {
+            setRpos(ri);
+            const now = Date.now();
+            const prev = lastClickRef.current;
+            const dbl = prev && prev.lineIdx === i && now - prev.t < 480;
+            lastClickRef.current = { t: now, lineIdx: i };
+            if (dbl) {
+              onPickRepo(line.fullName);
+              exit();
+            }
+          }
+        }
+      }
+      return;
+    }
+
+    if (input === "q" || key.escape) {
+      exit();
+      return;
+    }
+    if (/^[1-9]$/.test(input) && repoIndices.length) {
+      const n = Number.parseInt(input, 10) - 1;
+      if (n < repoIndices.length) {
+        const lineIdx = repoIndices[n];
+        const line = lines[lineIdx];
+        if (line && line.kind === "repo") {
+          onPickRepo(line.fullName);
+          exit();
+        }
+      }
+      return;
+    }
+    if (input === "j" || key.downArrow) {
+      if (repoIndices.length) {
+        setRpos((p) => Math.min(p + 1, repoIndices.length - 1));
+      }
+      return;
+    }
+    if (input === "k" || key.upArrow) {
+      setRpos((p) => Math.max(p - 1, 0));
+      return;
+    }
+    if (key.return || input === " ") {
+      const line = lines[idx];
+      if (line && line.kind === "repo") {
+        onPickRepo(line.fullName);
+        exit();
+      }
+    }
+  });
+
+  const status =
+    total > VIEWPORT_ROWS
+      ? `Lines ${viewStart + 1}–${Math.min(viewStart + VIEWPORT_ROWS, total)} of ${total} · repo ${safeRpos + 1}/${repoIndices.length}`
+      : repoIndices.length
+        ? `Repo ${safeRpos + 1}/${repoIndices.length}`
+        : "";
+
+  const rendered = slice.map((line, localI) => {
+    const i = viewStart + localI;
+    if (line.kind === "header") {
+      return React.createElement(Text, { key: `h-${i}`, color: "magenta", bold: true }, line.text);
+    }
+    const mark = i === idx ? "▶ " : "  ";
+    const pend = line.pending > 0 ? ` · ${line.pending} review request(s)` : "";
+    const hot = line.pending > 0;
+    return React.createElement(
+      Text,
+      {
+        key: `r-${i}`,
+        color: hot ? "yellow" : "white",
+        bold: hot
+      },
+      `${mark}${line.fullName}${pend}`
+    );
+  });
+
+  const firstListRow = status ? 4 : 3;
+  layoutRef.current = { firstListRow, viewStart, slice };
+
+  return React.createElement(
+    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"),
+    status ? React.createElement(Text, { dimColor: true }, status) : null,
+    ...rendered
+  );
+}

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

@@ -0,0 +1,188 @@
+import React from "react";
+import { render } from "ink";
+import { authMe } from "../api-client.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
+ * @returns {Promise<Map<string, number>>}
+ */
+async function pendingReviewsByRepo(login) {
+  /** @type {Map<string, number>} */
+  const map = new Map();
+  let page = 1;
+  const maxPages = 30;
+  while (page <= maxPages) {
+    const res = await githubSearchIssues(
+      `is:open is:pr review-requested:${login}`,
+      100,
+      page
+    );
+    const items = Array.isArray(res.items) ? res.items : [];
+    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;
+      if (typeof u !== "string") continue;
+      const m = u.match(/\/repos\/([^/]+)\/([^/]+)$/);
+      if (!m) continue;
+      const full = `${m[1]}/${m[2]}`;
+      map.set(full, (map.get(full) || 0) + 1);
+    }
+    if (items.length < 100) {
+      break;
+    }
+    page += 1;
+  }
+  return map;
+}
+
+/**
+ * @param {unknown} repoObj
+ * @param {Map<string, number>} pendingMap
+ */
+function normalizeRepo(repoObj, pendingMap) {
+  if (!repoObj || typeof repoObj !== "object") return null;
+  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 ownerType = typeof owner.type === "string" ? owner.type : "User";
+  const pending = pendingMap.get(fn) || 0;
+  return { fullName: fn, ownerType, pending };
+}
+
+/**
+ * @param {{ fullName: string, ownerType: string, pending: number }[]} repos
+ */
+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);
+  });
+
+  /** @type {import("./review-hub-ink.js").HubLine[]} */
+  const lines = [];
+  let lastBucket = "";
+  for (const r of sorted) {
+    const bucket = r.ownerType === "Organization" ? "Organizations" : "Users";
+    const ownerLogin = r.fullName.split("/")[0] || "";
+    const key = `${bucket}:${ownerLogin}`;
+    if (key !== lastBucket) {
+      lastBucket = key;
+      lines.push({
+        kind: "header",
+        text: `${bucket} — ${ownerLogin}`
+      });
+    }
+    lines.push({
+      kind: "repo",
+      fullName: r.fullName,
+      pending: r.pending
+    });
+  }
+  return lines;
+}
+
+/**
+ * @param {{ noTui?: boolean, autoApply?: boolean }} opts
+ */
+export async function runReviewHub(opts) {
+  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)."
+    );
+  }
+
+  const me = await authMe();
+  const login = me && typeof me.login === "string" ? me.login : "";
+  if (!login) {
+    throw new Error("Could not resolve GitHub login for review hub.");
+  }
+
+  const [rawRepos, pendingMap] = await Promise.all([
+    githubListAllUserRepos(),
+    pendingReviewsByRepo(login)
+  ]);
+
+  const repos = [];
+  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 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;
+      }
+
+      let picked = /** @type {string | null} */ (null);
+      const { waitUntilExit } = render(
+        React.createElement(ReviewHubInk, {
+          lines,
+          onPickRepo: (fn) => {
+            picked = fn;
+          }
+        })
+      );
+      await waitUntilExit();
+      if (!picked) {
+        return;
+      }
+
+      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);
+    }
+  }
+}

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

@@ -1,8 +1,9 @@
 import React from "react";
 import { render } from "ink";
-import { getPull, createPullRequest } from "../api-client.js";
+import { authMe, getPull, createPullRequest } from "../api-client.js";
 import { githubPostIssueComment } from "../github-pr-social.js";
 import {
+  createInitialStackDoc,
   readStackFile,
   writeStackFile,
   validateStackDoc,
@@ -129,7 +130,7 @@ export async function runSplitCommand(ctx) {
 
   /** @type {Record<string, unknown> | null} */
   let docForHistory = null;
-  const doc = readStackFile(root);
+  let doc = readStackFile(root);
   if (doc) {
     validateStackDoc(doc);
     const idx = doc.prs.findIndex((p) => p.pr_number === prNumber);
@@ -151,7 +152,19 @@ export async function runSplitCommand(ctx) {
       );
     }
   } else {
-    console.error("No .nugit/stack.json — skipped local stack file update.");
+    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, {

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-discover.js

@@ -262,6 +262,13 @@ export async function discoverStacksInRepo(owner, repo, opts = {}) {
         ? tipObj.head_branch
         : meta.headRef;
 
+    const tipPull = allPulls.find((pull) => {
+      const p = pull && typeof pull === "object" ? /** @type {Record<string, unknown>} */ (pull) : {};
+      return p.number === tipPr;
+    });
+    const tipPu = tipPull && typeof tipPull === "object" ? /** @type {Record<string, unknown>} */ (tipPull) : {};
+    const tip_updated_at = typeof tipPu.updated_at === "string" ? tipPu.updated_at : "";
+
     stacks.push({
       tip_pr_number: tipPr,
       created_by: String(doc.created_by || ""),
@@ -269,8 +276,9 @@ export async function discoverStacksInRepo(owner, repo, opts = {}) {
       pr_count: prRows.length,
       prs: prRows,
       tip_head_branch: tipHeadBranch,
+      tip_updated_at,
       fetch_command: `nugit stack fetch --repo ${repoFull} --ref ${tipHeadBranch}`,
-      view_command: `nugit stack view --repo ${repoFull} --ref ${tipHeadBranch}`
+      view_command: `nugit view --repo ${repoFull} --ref ${tipHeadBranch}`
     });
   }
 

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" };
+}