nugit-cli 0.0.1 → 0.1.1

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

@@ -0,0 +1,95 @@
+import fs from "fs";
+import path from "path";
+import { getConfigPath } from "../user-config.js";
+
+/**
+ * @typedef {{ owner: string, repo: string, head_ref_glob?: string, default_branch_only?: boolean }} AutoapproveRule
+ * @typedef {{ rules?: AutoapproveRule[], version?: number }} AutoapproveConfig
+ */
+
+/**
+ * @returns {AutoapproveConfig | null}
+ */
+export function loadReviewAutoapproveConfig() {
+  const base = path.dirname(getConfigPath());
+  const p = path.join(base, "review-autoapprove.json");
+  if (!fs.existsSync(p)) {
+    return null;
+  }
+  try {
+    const raw = fs.readFileSync(p, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * @param {AutoapproveRule} rule
+ * @param {string} owner
+ * @param {string} repo
+ * @param {string} headRef
+ */
+function matchRule(rule, owner, repo, headRef) {
+  if (String(rule.owner) !== owner || String(rule.repo) !== repo) {
+    return false;
+  }
+  const glob = rule.head_ref_glob;
+  if (glob) {
+    const re = new RegExp(
+      "^" +
+        String(glob)
+          .replace(/[.+^${}()|[\]\\]/g, "\\$&")
+          .replace(/\*/g, ".*") +
+        "$"
+    );
+    if (!re.test(headRef)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+/**
+ * @param {AutoapproveConfig | null} cfg
+ * @param {string} owner
+ * @param {string} repo
+ * @param {string} headRef
+ */
+export function isRepoHeadAutoapproveEligible(cfg, owner, repo, headRef) {
+  if (!cfg || !Array.isArray(cfg.rules)) {
+    return false;
+  }
+  return cfg.rules.some((r) => r && matchRule(r, owner, repo, headRef));
+}
+
+/**
+ * Heuristic: commits between base and head look like merge-only from default branch (best-effort).
+ * @param {Record<string, unknown>} comparePayload from githubCompareRefs
+ * @param {string} defaultBranch
+ */
+export function compareLooksLikeMainMergesOnly(comparePayload, defaultBranch) {
+  const commits = Array.isArray(comparePayload.commits) ? comparePayload.commits : [];
+  if (commits.length === 0) {
+    return true;
+  }
+  const safeDefault = String(defaultBranch || "main");
+  for (const c of commits) {
+    if (!c || typeof c !== "object") continue;
+    const commit = /** @type {Record<string, unknown>} */ (c).commit;
+    const msg =
+      commit && typeof commit === "object"
+        ? String(/** @type {Record<string, unknown>} */ (commit).message || "").split("\n")[0]
+        : "";
+    const mergePat = new RegExp(`^Merge branch ['"]?${safeDefault}['"]?`, "i");
+    const ghMerge = /^Merge pull request #\d+ from /i;
+    if (mergePat.test(msg) || ghMerge.test(msg)) {
+      continue;
+    }
+    if (/^Merge branch/i.test(msg) || /^Merge remote-tracking branch/i.test(msg)) {
+      continue;
+    }
+    return false;
+  }
+  return true;
+}

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

@@ -0,0 +1,10 @@
+/**
+ * Thrown when the user presses Backspace / Esc from the stack picker
+ * to return to the review-hub repository list (`nugit review` only).
+ */
+export class ReviewHubBackError extends Error {
+  constructor() {
+    super("Back to review hub");
+    this.name = "ReviewHubBackError";
+  }
+}

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

@@ -0,0 +1,169 @@
+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
+ * @param {() => void} [props.onBack] Called when user presses Backspace/Esc to go back
+ */
+export function ReviewHubInk({ lines, onPickRepo, onBack }) {
+  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;
+    }
+
+    const backKey = key.backspace || key.delete || input === "\x7f" || input === "\b";
+    if (input === "q" || key.escape || backKey) {
+      onBack?.();
+      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 · Backspace/q back"),
+    status ? React.createElement(Text, { dimColor: true }, status) : null,
+    ...rendered
+  );
+}

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

@@ -0,0 +1,131 @@
+import { authMe } from "../api-client.js";
+import { githubListAllUserRepos, githubSearchIssues } from "../github-rest.js";
+import { resolveGithubToken } from "../auth-token.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
+ * @returns {import("./review-hub-ink.js").HubLine[]}
+ */
+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);
+  });
+
+  /** @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;
+}
+
+/**
+ * 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 fetchReviewHubData() {
+  if (!resolveGithubToken()) {
+    throw new Error(
+      "GitHub token required for the review hub. Run `nugit auth login` or set NUGIT_USER_TOKEN / STACKPR_USER_TOKEN."
+    );
+  }
+
+  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 = /** @type {{ fullName: string, ownerType: string, pending: number }[]} */ ([]);
+  for (const r of rawRepos) {
+    const n = normalizeRepo(r, pendingMap);
+    if (n) repos.push(n);
+  }
+
+  const lines = buildHubLines(repos);
+  return { login, lines };
+}
+
+/**
+ * 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;
+
+  const repos = lines
+    .filter((l) => l.kind === "repo")
+    .map((l) => /** @type {{ kind: "repo", fullName: string, pending: number }} */ (l));
+
+  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
+  };
+}