nugit-cli 0.0.1 → 0.1.0

package/src/stack-view/loading-ink.js

@@ -0,0 +1,44 @@
+import React, { useEffect, useState } from "react";
+import { Box, Text, render } from "ink";
+import { clearInkScreen } from "./terminal-fullscreen.js";
+
+const FRAMES = ["\u280b", "\u2819", "\u2839", "\u2838", "\u283c", "\u2834", "\u2826", "\u2827", "\u2807", "\u280f"];
+
+/**
+ * Full-screen loading line with a small terminal spinner (Ink has no Spinner export in v6).
+ *
+ * @param {string} message
+ * @param {() => Promise<void>} work
+ */
+export async function withStackLoadInkScreen(message, work) {
+  clearInkScreen();
+  const LoadingLine = () => {
+    const [i, setI] = useState(0);
+    useEffect(() => {
+      const t = setInterval(() => setI((n) => (n + 1) % FRAMES.length), 80);
+      return () => clearInterval(t);
+    }, []);
+    return React.createElement(
+      Box,
+      { flexDirection: "row", padding: 1 },
+      React.createElement(Text, { color: "cyan" }, FRAMES[i]),
+      React.createElement(Text, null, ` ${message}`)
+    );
+  };
+  const inst = render(React.createElement(LoadingLine));
+  try {
+    await new Promise((r) => setImmediate(r));
+    await work();
+  } finally {
+    try {
+      inst.unmount();
+    } catch {
+      /* ignore */
+    }
+    try {
+      inst.clear();
+    } catch {
+      /* ignore */
+    }
+  }
+}

package/src/stack-view/merge-alternate-pick-stacks.js

@@ -0,0 +1,223 @@
+import { githubListAllOpenPulls } from "../github-rest.js";
+import { inferPrChainsFromOpenPulls } from "../stack-infer-from-prs.js";
+import { stackTipPrNumber } from "../stack-discover.js";
+import { inferChainsToPickStacks } from "./infer-chains-to-pick-stacks.js";
+import { matchesPickerViewingStack } from "./stack-pick-sort.js";
+
+/**
+ * PR numbers from GitHub open-pull payloads (see {@link githubListAllOpenPulls}).
+ *
+ * @param {unknown[]} pulls
+ * @returns {Set<number>}
+ */
+export function openPullNumbersFromList(pulls) {
+  /** @type {Set<number>} */
+  const set = new Set();
+  if (!Array.isArray(pulls)) {
+    return set;
+  }
+  for (const raw of pulls) {
+    if (!raw || typeof raw !== "object") {
+      continue;
+    }
+    const n = /** @type {{ number?: number }} */ (raw).number;
+    if (typeof n === "number") {
+      set.add(n);
+    }
+  }
+  return set;
+}
+
+/**
+ * Remove picker rows whose tip PR is not open (tests / callers that need open-only slice).
+ *
+ * @param {unknown[]} stacks
+ * @param {Set<number>} openPullNumbers
+ * @returns {object[]}
+ */
+export function filterPickStacksToOpenTipPRs(stacks, openPullNumbers) {
+  if (!Array.isArray(stacks) || !(openPullNumbers instanceof Set)) {
+    return Array.isArray(stacks) ? /** @type {object[]} */ (stacks) : [];
+  }
+  return stacks.filter((s) => {
+    if (!s || typeof s !== "object") {
+      return false;
+    }
+    const tip = /** @type {{ tip_pr_number?: number }} */ (s).tip_pr_number;
+    return typeof tip === "number" && openPullNumbers.has(tip);
+  });
+}
+
+/**
+ * Set `picker_merged_stack` on each row: true when tip PR is not in the open-pull set.
+ *
+ * @param {object[]} merged
+ * @param {Set<number>} openPullNumbers
+ * @returns {object[]}
+ */
+export function tagPickStacksMergedState(merged, openPullNumbers) {
+  if (!Array.isArray(merged) || !(openPullNumbers instanceof Set)) {
+    return Array.isArray(merged) ? merged : [];
+  }
+  return merged.map((s) => {
+    if (!s || typeof s !== "object") {
+      return s;
+    }
+    const tip = /** @type {{ tip_pr_number?: number }} */ (s).tip_pr_number;
+    const mergedClosed = typeof tip === "number" && !openPullNumbers.has(tip);
+    return { ...s, picker_merged_stack: mergedClosed };
+  });
+}
+
+/**
+ * When GitHub list failed, show stacks as open-tab candidates (unknown state).
+ *
+ * @param {object[]} base
+ * @returns {object[]}
+ */
+export function tagPickStacksUnknownOpen(base) {
+  if (!Array.isArray(base)) {
+    return [];
+  }
+  return base.map((s) => (s && typeof s === "object" ? { ...s, picker_merged_stack: false } : s));
+}
+
+/**
+ * Prefer discovery rows (stack.json); add infer-only chains whose tip is not already listed.
+ *
+ * @param {object[]} discoveryStacks
+ * @param {object[]} inferStacks from {@link inferChainsToPickStacks}
+ */
+export function mergeDiscoveryAndInferPickStacks(discoveryStacks, inferStacks) {
+  /** @type {Map<number, object>} */
+  const byTip = new Map();
+  for (const s of discoveryStacks) {
+    if (s && typeof s === "object" && typeof /** @type {{ tip_pr_number?: number }} */ (s).tip_pr_number === "number") {
+      byTip.set(s.tip_pr_number, s);
+    }
+  }
+  for (const s of inferStacks) {
+    if (!s || typeof s !== "object" || typeof s.tip_pr_number !== "number") {
+      continue;
+    }
+    if (!byTip.has(s.tip_pr_number)) {
+      byTip.set(s.tip_pr_number, { ...s, inferredOnly: true });
+    }
+  }
+  return [...byTip.values()];
+}
+
+/**
+ * Fetch open PRs, infer chains, and merge with discovery-shaped stack rows.
+ * Rows include `picker_merged_stack` for the stack picker (Tab: open vs merged/closed).
+ *
+ * @param {string} owner
+ * @param {string} repoName
+ * @param {unknown[] | null | undefined} baseStacks
+ * @returns {Promise<{ stacks: object[], openPullNumbers: Set<number> | null }>}
+ */
+export async function augmentAlternatePickStacksWithInfer(owner, repoName, baseStacks) {
+  const base = Array.isArray(baseStacks) ? /** @type {object[]} */ (baseStacks) : [];
+  try {
+    const pulls = await githubListAllOpenPulls(owner, repoName);
+    const openNums = openPullNumbersFromList(pulls);
+    const repoFull = `${owner}/${repoName}`;
+    const chains = inferPrChainsFromOpenPulls(pulls, repoFull);
+    const inferStacks = inferChainsToPickStacks(chains, pulls);
+    const merged = mergeDiscoveryAndInferPickStacks(base, inferStacks);
+    return {
+      stacks: tagPickStacksMergedState(merged, openNums),
+      openPullNumbers: openNums
+    };
+  } catch {
+    return { stacks: tagPickStacksUnknownOpen(base), openPullNumbers: null };
+  }
+}
+
+/**
+ * Build a stack-picker row from the loaded viewer doc when discovery/infer omitted it.
+ *
+ * @param {Record<string, unknown>} doc
+ * @param {string | undefined} viewingHeadRef branch/ref used to load the doc
+ * @param {Set<number> | null | undefined} [openPullNumbers] when set, sets `picker_merged_stack`
+ */
+export function stackDocToPickStackRow(doc, viewingHeadRef, openPullNumbers) {
+  const rawPrs = Array.isArray(doc.prs) ? doc.prs : [];
+  const sorted = [...rawPrs]
+    .filter((e) => e && typeof e === "object")
+    .sort(
+      (a, b) =>
+        (/** @type {{ position?: number }} */ (a).position ?? 0) -
+        (/** @type {{ position?: number }} */ (b).position ?? 0)
+    );
+  /** @type {{ pr_number: number, position: number, head_branch?: string, title?: string }[]} */
+  const prRows = [];
+  for (const e of sorted) {
+    const o = /** @type {Record<string, unknown>} */ (e);
+    const n = o.pr_number;
+    if (typeof n !== "number") {
+      continue;
+    }
+    prRows.push({
+      pr_number: n,
+      position: typeof o.position === "number" ? o.position : prRows.length + 1,
+      head_branch: typeof o.head_branch === "string" ? o.head_branch : undefined,
+      title: typeof o.title === "string" ? o.title : undefined
+    });
+  }
+  const tip = stackTipPrNumber(doc);
+  const last = prRows.length ? prRows[prRows.length - 1] : null;
+  const tipNum = tip ?? (last ? last.pr_number : null);
+  if (tipNum == null) {
+    return null;
+  }
+  const href = typeof viewingHeadRef === "string" ? viewingHeadRef.trim() : "";
+  const tipHead =
+    href ||
+    (last && typeof last.head_branch === "string" && last.head_branch.trim()
+      ? last.head_branch.trim()
+      : "");
+  /** @type {Record<string, unknown>} */
+  const row = {
+    tip_pr_number: tipNum,
+    tip_head_branch: tipHead,
+    pr_count: prRows.length || 1,
+    created_by: String(doc.created_by || ""),
+    prs: prRows.length ? prRows : [{ pr_number: tipNum, position: 1 }],
+    tip_updated_at: "",
+    inferredFromViewerDoc: doc.inferred === true
+  };
+  if (openPullNumbers instanceof Set && typeof tipNum === "number") {
+    row.picker_merged_stack = !openPullNumbers.has(tipNum);
+  }
+  return row;
+}
+
+/**
+ * If no picker row matches the open doc, append a synthetic row so Backspace → picker can re-select it.
+ *
+ * @param {unknown[] | null} stacks
+ * @param {Record<string, unknown>} doc
+ * @param {string | undefined} ref
+ * @param {Set<number> | null | undefined} [openPullNumbers] for `picker_merged_stack` on appended row
+ * @returns {unknown[] | null}
+ */
+export function ensureDocRepresentedInPickStacks(stacks, doc, ref, openPullNumbers) {
+  if (!doc || typeof doc !== "object") {
+    return stacks;
+  }
+  const arr = Array.isArray(stacks) ? [...stacks] : [];
+  const tip = stackTipPrNumber(doc);
+  const href = typeof ref === "string" && ref.trim() ? ref.trim() : undefined;
+  if (
+    arr.some((s) => s && typeof s === "object" && matchesPickerViewingStack(s, tip, href, arr))
+  ) {
+    return arr.length ? arr : stacks;
+  }
+  const row = stackDocToPickStackRow(doc, href, openPullNumbers);
+  if (!row) {
+    return stacks;
+  }
+  arr.push(row);
+  return arr;
+}

package/src/stack-view/patch-preview-merge.js

@@ -0,0 +1,108 @@
+/**
+ * Build a single scrollable view: file text with deletions (from patch) and
+ * additions/context aligned to the PR blob, so we do not duplicate a separate diff pane.
+ *
+ * @param {string} blobText
+ * @param {string} patchText unified diff (may contain multiple files)
+ * @param {string} filePath path in repo (e.g. src/a.ts)
+ * @returns {{ text: string, kind: "add" | "del" | "ctx" }[] | null}
+ */
+export function buildMergedPreviewFromPatch(blobText, patchText, filePath) {
+  if (!blobText || !patchText || !filePath) return null;
+  const section = extractPatchSectionForFile(patchText, filePath);
+  if (!section) return null;
+
+  const blobLines = blobText.split(/\r\n|\r|\n/);
+  let bi = 0;
+  /** @type {{ text: string, kind: "add" | "del" | "ctx" }[]} */
+  const out = [];
+  const lines = section.split(/\n/);
+  let inHunk = false;
+
+  for (const line of lines) {
+    if (line.startsWith("@@")) {
+      inHunk = true;
+      continue;
+    }
+    if (line.startsWith("\\")) continue;
+    if (!inHunk) continue;
+    if (line.length === 0) continue;
+    const c = line[0];
+    const rest = line.slice(1);
+    if (c === "+") {
+      const text = blobLines[bi] !== undefined ? blobLines[bi] : rest;
+      out.push({ text, kind: "add" });
+      bi += 1;
+    } else if (c === " ") {
+      const text = blobLines[bi] !== undefined ? blobLines[bi] : rest;
+      out.push({ text, kind: "ctx" });
+      bi += 1;
+    } else if (c === "-") {
+      out.push({ text: rest, kind: "del" });
+    }
+  }
+
+  while (bi < blobLines.length) {
+    out.push({ text: blobLines[bi], kind: "ctx" });
+    bi += 1;
+  }
+
+  return out.length > 0 ? out : null;
+}
+
+/**
+ * @param {string} patchText
+ * @param {string} filePath
+ * @returns {string | null}
+ */
+function extractPatchSectionForFile(patchText, filePath) {
+  const norm = normalizePath(filePath);
+  const blocks = patchText.split(/^diff --git /m);
+  for (let b = 1; b < blocks.length; b++) {
+    const block = "diff --git " + blocks[b];
+    const head = block.slice(0, Math.min(block.length, 800));
+    if (blockIncludesPath(head, norm)) {
+      return block.trimEnd();
+    }
+  }
+  if (blocks.length === 1 && patchText.includes("@@")) {
+    if (patchTextIncludesFilePath(patchText, norm)) {
+      return patchText.trimEnd();
+    }
+  }
+  return null;
+}
+
+/**
+ * @param {string} p
+ */
+function normalizePath(p) {
+  return p.replace(/^a\//, "").replace(/^b\//, "").replace(/\\/g, "/");
+}
+
+/**
+ * @param {string} head start of diff block
+ * @param {string} norm
+ */
+function blockIncludesPath(head, norm) {
+  const patterns = [
+    `b/${norm}`,
+    `b/${norm}\t`,
+    `b/${norm}\n`,
+    `/${norm}`,
+    ` ${norm}`
+  ];
+  return patterns.some((x) => head.includes(x));
+}
+
+/**
+ * @param {string} patchText
+ * @param {string} norm
+ */
+function patchTextIncludesFilePath(patchText, norm) {
+  return (
+    patchText.includes(`+++ b/${norm}`) ||
+    patchText.includes(`--- a/${norm}`) ||
+    patchText.includes(`+++ b/${norm}\t`)
+  );
+}

package/src/stack-view/remote-infer-doc.js

@@ -0,0 +1,93 @@
+import chalk from "chalk";
+import { authMe } from "../api-client.js";
+import { githubListAllOpenPulls } from "../github-rest.js";
+import { parseRepoFullName, createInferredStackDoc } from "../nugit-stack.js";
+import { inferPrChainsFromOpenPulls } from "../stack-infer-from-prs.js";
+import { questionLine } from "./prompt-line.js";
+import { RepoPickerBackError } from "./repo-picker-back.js";
+
+/**
+ * Open PR groups inferrable as a stack (for TUI pickers).
+ * @param {string} repoFull
+ * @returns {Promise<number[][]>}
+ */
+export async function listOpenPrChainGroups(repoFull) {
+  const { owner, repo } = parseRepoFullName(repoFull);
+  const pulls = await githubListAllOpenPulls(owner, repo);
+  return inferPrChainsFromOpenPulls(pulls, repoFull);
+}
+
+/**
+ * @param {unknown} e
+ */
+export function isGithubNotFoundError(e) {
+  const s = String(/** @type {{ message?: string }} */ (e)?.message || e);
+  return /not found/i.test(s) || /\b404\b/.test(s);
+}
+
+/**
+ * When `.nugit/stack.json` is missing on the remote ref, build a viewer doc from open PRs (same-repo inference).
+ * @param {string} repoFull
+ * @param {{ interactivePick?: boolean, preselectedChainIndex?: number, tuiChainPick?: (chains: number[][], pulls: unknown[]) => Promise<number> }} [opts]
+ */
+export async function inferStackDocForRemoteView(repoFull, opts = {}) {
+  const interactive = opts.interactivePick !== false && process.stdin.isTTY;
+  const me = await authMe();
+  const login = me && typeof me.login === "string" ? me.login : "viewer";
+  const { owner, repo } = parseRepoFullName(repoFull);
+  const pulls = await githubListAllOpenPulls(owner, repo);
+  const chains = inferPrChainsFromOpenPulls(pulls, repoFull);
+
+  if (chains.length === 0) {
+    throw new Error(
+      `No .nugit/stack.json on that ref, and no inferrable same-repo open PR stack in ${repoFull}. ` +
+        `Try a branch that contains .nugit/stack.json (often the stack tip), or use \`nugit review\`.`
+    );
+  }
+
+  /** @type {number[]} */
+  let chosen;
+  if (chains.length === 1) {
+    chosen = chains[0];
+  } else if (typeof opts.preselectedChainIndex === "number" && Number.isInteger(opts.preselectedChainIndex)) {
+    const i = opts.preselectedChainIndex;
+    if (i < 0 || i >= chains.length) {
+      throw new Error("Invalid preselectedChainIndex for inferred stack.");
+    }
+    chosen = chains[i];
+  } else if (typeof opts.tuiChainPick === "function") {
+    const idx = await opts.tuiChainPick(chains, pulls);
+    if (idx === -2) {
+      throw new RepoPickerBackError();
+    }
+    if (idx === -1) {
+      throw new Error("Stack group selection cancelled.");
+    }
+    if (typeof idx === "number" && idx >= 0 && idx < chains.length) {
+      chosen = chains[idx];
+    } else {
+      throw new Error("Invalid stack group selection.");
+    }
+  } else if (interactive) {
+    console.error(chalk.bold.cyan(`No stack.json on default ref — inferred ${chains.length} open PR group(s):`));
+    for (let i = 0; i < chains.length; i++) {
+      const c = chains[i];
+      const label = c.length > 1 ? `stack ${c.join(" → ")}` : `PR #${c[0]}`;
+      console.error(`  ${chalk.yellow("[" + (i + 1) + "]")} ${label}`);
+    }
+    const ans = String(await questionLine(chalk.green("Select group (empty = use largest stack): "))).trim();
+    if (ans) {
+      const n = Number.parseInt(ans, 10);
+      if (!Number.isInteger(n) || n < 1 || n > chains.length) {
+        throw new Error("Invalid selection.");
+      }
+      chosen = chains[n - 1];
+    } else {
+      chosen = chains.reduce((a, b) => (b.length > a.length ? b : a));
+    }
+  } else {
+    chosen = chains.reduce((a, b) => (b.length > a.length ? b : a));
+  }
+
+  return { doc: createInferredStackDoc(repoFull, login, chosen), viewerLogin: login };
+}

package/src/stack-view/repo-picker-back.js

@@ -0,0 +1,10 @@
+/**
+ * Thrown when the user chooses Backspace from the inferred PR-group picker
+ * to return to the repository selection TUI (`nugit view` repo picker flow only).
+ */
+export class RepoPickerBackError extends Error {
+  constructor() {
+    super("Back to repository picker");
+    this.name = "RepoPickerBackError";
+  }
+}