nugit-cli 0.0.1-alpha

package/src/open-browser.js

@@ -0,0 +1,21 @@
+import { spawn } from "child_process";
+
+/**
+ * Open a URL in the default browser (best-effort; no-op failure is ok for headless).
+ * @param {string} url
+ */
+export function openInBrowser(url) {
+  const platform = process.platform;
+  if (platform === "darwin") {
+    const c = spawn("open", [url], { detached: true, stdio: "ignore" });
+    c.unref();
+    return;
+  }
+  if (platform === "win32") {
+    const c = spawn("cmd", ["/c", "start", "", url], { detached: true, stdio: "ignore" });
+    c.unref();
+    return;
+  }
+  const c = spawn("xdg-open", [url], { detached: true, stdio: "ignore" });
+  c.unref();
+}

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

@@ -0,0 +1,181 @@
+import React from "react";
+import { render } from "ink";
+import { getPull, createPullRequest } 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,
+  gitFetchRefs,
+  listChangedFilesBetween,
+  commitLayerFromPaths,
+  gitPushBranch
+} from "./split-git.js";
+import { SplitInkApp } from "./split-ink.js";
+
+/**
+ * @param {object} ctx
+ * @param {string} ctx.root
+ * @param {string} ctx.owner
+ * @param {string} ctx.repo
+ * @param {number} ctx.prNumber
+ * @param {boolean} [ctx.dryRun]
+ * @param {string} [ctx.remote]
+ */
+export async function runSplitCommand(ctx) {
+  const { root, owner, repo, prNumber, dryRun = false, remote = "origin" } = ctx;
+  assertCleanWorkingTree(root);
+  const pull = await getPull(owner, repo, prNumber);
+  const headRepo =
+    pull.head && typeof pull.head === "object" && pull.head.repo && typeof pull.head.repo === "object"
+      ? String(pull.head.repo.full_name || "")
+      : "";
+  const here = `${owner}/${repo}`.toLowerCase();
+  if (headRepo && headRepo.toLowerCase() !== here) {
+    throw new Error(
+      `nugit split does not support fork PRs in v1 (head repo ${headRepo}; expected ${owner}/${repo})`
+    );
+  }
+  const baseBranch = pull.base.ref;
+  const headBranch = pull.head.ref;
+  gitFetchRefs(root, remote, baseBranch, headBranch);
+  const baseRef = `${remote}/${baseBranch}`;
+  const headRef = `${remote}/${headBranch}`;
+  const files = listChangedFilesBetween(root, baseRef, headRef);
+  if (!files.length) {
+    throw new Error("No file changes between merge-base of base and head");
+  }
+
+  const exitPayload = { next: null };
+  const { waitUntilExit } = render(React.createElement(SplitInkApp, { files, exitPayload }));
+  await waitUntilExit();
+
+  const next = exitPayload.next;
+  if (!next || next.type !== "confirm") {
+    console.error("Split cancelled.");
+    try {
+      gitExec(root, ["checkout", baseBranch]);
+    } catch {
+      /* ignore */
+    }
+    return;
+  }
+  const { byLayer, layerCount } = next;
+  for (let L = 0; L < layerCount; L++) {
+    if (!byLayer[L]?.length) {
+      throw new Error(`Layer ${L} has no files — assign every changed file to a layer`);
+    }
+  }
+
+  const prefix = `nugit-split/pr-${prNumber}`;
+  /** @type {string[]} */
+  const newBranches = [];
+  let startRef = baseRef;
+  for (let i = 0; i < layerCount; i++) {
+    const b = `${prefix}-L${i}`;
+    const did = commitLayerFromPaths(
+      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}`);
+    }
+    newBranches.push(b);
+    startRef = b;
+  }
+
+  if (dryRun) {
+    console.error("Dry-run: branches (not pushed):", newBranches.join(", "));
+    gitExec(root, ["checkout", baseBranch]);
+    return;
+  }
+
+  for (const b of newBranches) {
+    gitPushBranch(root, remote, b);
+  }
+
+  /** @type {number[]} */
+  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 created = await createPullRequest(owner, repo, {
+      title,
+      head: newBranches[i],
+      base: prevBase,
+      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");
+    }
+    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,
+    `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 */
+  }
+
+  console.error(`Split complete. New PRs: ${newPrNumbers.join(", ")}`);
+}

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

@@ -0,0 +1,88 @@
+import { execFileSync } from "child_process";
+
+/**
+ * @param {string} root
+ * @param {string[]} args
+ * @param {{ stdio?: string }} [io]
+ */
+export function gitExec(root, args, io) {
+  try {
+    return execFileSync("git", args, {
+      cwd: root,
+      encoding: "utf8",
+      stdio: io?.stdio || "pipe",
+      maxBuffer: 20 * 1024 * 1024
+    }).trim();
+  } catch (e) {
+    const err = /** @type {{ stderr?: Buffer, stdout?: Buffer, message?: string }} */ (e);
+    const msg =
+      (err.stderr && err.stderr.toString()) ||
+      (err.stdout && err.stdout.toString()) ||
+      err.message ||
+      String(e);
+    throw new Error(msg.trim().slice(0, 800));
+  }
+}
+
+/**
+ * @param {string} root
+ * @param {string} remote
+ * @param {string} baseBranch
+ * @param {string} headBranch
+ */
+export function gitFetchRefs(root, remote, baseBranch, headBranch) {
+  gitExec(root, ["fetch", remote, baseBranch, headBranch], { stdio: "pipe" });
+}
+
+/**
+ * @param {string} root
+ * @param {string} baseRef e.g. origin/main
+ * @param {string} headRef e.g. origin/feat
+ */
+export function listChangedFilesBetween(root, baseRef, headRef) {
+  const out = gitExec(root, ["diff", "--name-only", `${baseRef}...${headRef}`]);
+  return out.split("\n").map((s) => s.trim()).filter(Boolean);
+}
+
+/**
+ * @param {string} root
+ */
+export function assertCleanWorkingTree(root) {
+  const st = gitExec(root, ["status", "--porcelain"]);
+  if (st) {
+    throw new Error("Working tree is not clean; commit or stash before nugit split.");
+  }
+}
+
+/**
+ * @param {string} root
+ * @param {string} remote
+ * @param {string} branchName local branch to create
+ * @param {string} startRef branch or commit to start from
+ * @param {string} headRef where to checkout paths from (e.g. origin/feat)
+ * @param {string[]} paths
+ * @param {string} message
+ */
+export function commitLayerFromPaths(root, remote, branchName, startRef, headRef, paths, message) {
+  const uniq = [...new Set(paths)].filter(Boolean);
+  gitExec(root, ["checkout", "-B", branchName, startRef]);
+  if (uniq.length) {
+    gitExec(root, ["checkout", headRef, "--", ...uniq]);
+  }
+  gitExec(root, ["add", "-A"]);
+  const st = gitExec(root, ["status", "--porcelain"]);
+  if (!st) {
+    return false;
+  }
+  gitExec(root, ["commit", "-m", message]);
+  return true;
+}
+
+/**
+ * @param {string} root
+ * @param {string} remote
+ * @param {string} branchName
+ */
+export function gitPushBranch(root, remote, branchName) {
+  gitExec(root, ["push", "-u", remote, branchName], { stdio: "inherit" });
+}

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

@@ -0,0 +1,104 @@
+import React, { useMemo, useState } from "react";
+import { Box, Text, useApp, useInput } from "ink";
+import chalk from "chalk";
+
+/**
+ * @param {object} props
+ * @param {string[]} props.files
+ * @param {{ next: null | Record<string, unknown> }} props.exitPayload
+ */
+export function SplitInkApp({ files, exitPayload }) {
+  const { exit } = useApp();
+  const [fileIdx, setFileIdx] = useState(0);
+  const [layerCount, setLayerCount] = useState(2);
+  const [assign, setAssign] = useState(() => {
+    /** @type {Record<string, number>} */
+    const a = {};
+    for (const f of files) {
+      a[f] = 0;
+    }
+    return a;
+  });
+
+  const safeIdx = files.length ? Math.min(fileIdx, files.length - 1) : 0;
+  const current = files[safeIdx] || "";
+
+  const byLayer = useMemo(() => {
+    /** @type {string[][]} */
+    const buckets = Array.from({ length: layerCount }, () => []);
+    for (const f of files) {
+      const L = Math.min(layerCount - 1, Math.max(0, assign[f] ?? 0));
+      buckets[L].push(f);
+    }
+    return buckets;
+  }, [files, assign, layerCount]);
+
+  useInput((input, key) => {
+    if (input === "q" || key.escape) {
+      exitPayload.next = { type: "cancel" };
+      exit();
+      return;
+    }
+    if (input === "c") {
+      exitPayload.next = {
+        type: "confirm",
+        layerCount,
+        assignment: { ...assign },
+        byLayer
+      };
+      exit();
+      return;
+    }
+    if (input === "j" || key.downArrow) {
+      setFileIdx((i) => Math.min(i + 1, Math.max(0, files.length - 1)));
+      return;
+    }
+    if (input === "k" || key.upArrow) {
+      setFileIdx((i) => Math.max(i - 1, 0));
+      return;
+    }
+    if (input === "+" || input === "=") {
+      setLayerCount((n) => Math.min(9, n + 1));
+      return;
+    }
+    if (input === "-") {
+      setLayerCount((n) => Math.max(2, n - 1));
+      return;
+    }
+    const d = Number.parseInt(input, 10);
+    if (Number.isInteger(d) && d >= 0 && d < layerCount && current) {
+      setAssign((prev) => ({ ...prev, [current]: d }));
+    }
+  });
+
+  if (!files.length) {
+    return React.createElement(Text, { color: "red" }, "No files to split.");
+  }
+
+  return React.createElement(
+    Box,
+    { flexDirection: "column", padding: 1 },
+    React.createElement(Text, { color: "cyan", bold: true }, "nugit split"),
+    React.createElement(
+      Text,
+      { dimColor: true },
+      `Layers: ${layerCount}  (+/-)  |  assign file to layer 0–${layerCount - 1} (digit)  |  c confirm  |  q cancel`
+    ),
+    React.createElement(Text, { marginTop: 1 }, chalk.bold("Files:")),
+    ...files.slice(0, 18).map((f, i) =>
+      React.createElement(
+        Text,
+        { key: f },
+        `${i === safeIdx ? "▶" : " "} [L${assign[f] ?? 0}] ${f.slice(0, 72)}`
+      )
+    ),
+    React.createElement(Text, { marginTop: 1, color: "magenta" }, "Preview by layer:"),
+    ...byLayer.map((bucket, li) =>
+      React.createElement(
+        Text,
+        { key: String(li) },
+        chalk.yellow(`L${li}: `) + chalk.dim(bucket.join(", ").slice(0, 100) || "(empty)")
+      )
+    )
+  );
+}

package/src/stack-discover.js

@@ -0,0 +1,284 @@
+import { githubListOpenPulls } from "./github-rest.js";
+import { getGithubContents, decodeGithubFileContent, getPull } from "./api-client.js";
+import { validateStackDoc } from "./nugit-stack.js";
+
+/**
+ * Stack tip PR # from layer.tip, else top entry by position in doc.prs.
+ * @param {Record<string, unknown>} doc
+ * @returns {number | null}
+ */
+export function stackTipPrNumber(doc) {
+  const layer = doc.layer;
+  if (layer && typeof layer === "object") {
+    const tip = /** @type {{ tip?: { pr_number?: number } }} */ (layer).tip;
+    if (tip && typeof tip === "object" && typeof tip.pr_number === "number" && tip.pr_number >= 1) {
+      return tip.pr_number;
+    }
+  }
+  const prs = Array.isArray(doc.prs) ? doc.prs : [];
+  if (!prs.length) {
+    return null;
+  }
+  const sorted = [...prs].sort(
+    (a, b) =>
+      (/** @type {{ position?: number }} */ (a).position ?? 0) -
+      (/** @type {{ position?: number }} */ (b).position ?? 0)
+  );
+  const top = sorted[sorted.length - 1];
+  const n = top && typeof top === "object" ? /** @type {{ pr_number?: number }} */ (top).pr_number : undefined;
+  return typeof n === "number" && n >= 1 ? n : null;
+}
+
+/**
+ * @param {Record<string, unknown>} doc
+ * @param {string} owner
+ * @param {string} repo
+ */
+export function docRepoMatches(doc, owner, repo) {
+  const full = String(doc.repo_full_name || "").toLowerCase();
+  return full === `${owner}/${repo}`.toLowerCase();
+}
+
+/**
+ * @template T
+ * @param {T[]} items
+ * @param {number} concurrency
+ * @param {(item: T, index: number) => Promise<void>} fn
+ */
+async function forEachPool(items, concurrency, fn) {
+  let idx = 0;
+  const workers = Array.from({ length: Math.min(concurrency, items.length) }, async () => {
+    for (;;) {
+      const i = idx++;
+      if (i >= items.length) {
+        return;
+      }
+      await fn(items[i], i);
+    }
+  });
+  await Promise.all(workers);
+}
+
+/**
+ * @param {string} owner
+ * @param {string} repo
+ * @param {string} ref
+ * @returns {Promise<Record<string, unknown> | null>}
+ */
+async function tryLoadStackDocAtRef(owner, repo, ref) {
+  try {
+    const item = await getGithubContents(owner, repo, ".nugit/stack.json", ref);
+    const text = decodeGithubFileContent(item);
+    if (!text) {
+      return null;
+    }
+    const doc = JSON.parse(text);
+    validateStackDoc(doc);
+    if (!docRepoMatches(doc, owner, repo)) {
+      return null;
+    }
+    return /** @type {Record<string, unknown>} */ (doc);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * If this is a propagated prefix, try to load the full tip stack doc.
+ * @param {string} owner
+ * @param {string} repo
+ * @param {Record<string, unknown>} doc
+ */
+async function maybeExpandPrefixDoc(owner, repo, doc) {
+  const layer = doc.layer && typeof doc.layer === "object" ? /** @type {Record<string, unknown>} */ (doc.layer) : null;
+  if (!layer) {
+    return doc;
+  }
+  const stackSize = layer.stack_size;
+  const prs = Array.isArray(doc.prs) ? doc.prs : [];
+  const tip = layer.tip && typeof layer.tip === "object" ? /** @type {Record<string, unknown>} */ (layer.tip) : null;
+  const tipHead = tip && typeof tip.head_branch === "string" ? tip.head_branch.trim() : "";
+  if (
+    typeof stackSize !== "number" ||
+    !Number.isFinite(stackSize) ||
+    stackSize <= prs.length ||
+    !tipHead
+  ) {
+    return doc;
+  }
+  const full = await tryLoadStackDocAtRef(owner, repo, tipHead);
+  if (!full) {
+    return doc;
+  }
+  const fullPrs = Array.isArray(full.prs) ? full.prs : [];
+  return fullPrs.length > prs.length ? full : doc;
+}
+
+/**
+ * Scan open PRs; any head with committed `.nugit/stack.json` counts. Deduplicate by stack tip PR # (layer.tip or top of prs).
+ *
+ * @param {string} owner
+ * @param {string} repo
+ * @param {{
+ *   maxOpenPrs?: number,
+ *   listPerPage?: number,
+ *   enrich?: boolean,
+ *   fetchConcurrency?: number,
+ *   onProgress?: (msg: string) => void
+ * }} [opts]
+ */
+export async function discoverStacksInRepo(owner, repo, opts = {}) {
+  const maxOpenPrs = opts.maxOpenPrs ?? 500;
+  const listPerPage = Math.min(100, Math.max(1, opts.listPerPage ?? 100));
+  const fetchConc = Math.max(1, Math.min(32, opts.fetchConcurrency ?? 8));
+  const enrich = opts.enrich !== false;
+  const onProgress = typeof opts.onProgress === "function" ? opts.onProgress : null;
+
+  /** @type {unknown[]} */
+  const allPulls = [];
+  let page = 1;
+  let truncated = false;
+  for (;;) {
+    if (maxOpenPrs > 0 && allPulls.length >= maxOpenPrs) {
+      truncated = true;
+      break;
+    }
+    const pulls = await githubListOpenPulls(owner, repo, page, listPerPage);
+    if (!Array.isArray(pulls) || pulls.length === 0) {
+      break;
+    }
+    for (const p of pulls) {
+      if (maxOpenPrs > 0 && allPulls.length >= maxOpenPrs) {
+        truncated = true;
+        break;
+      }
+      allPulls.push(p);
+    }
+    if (truncated) {
+      break;
+    }
+    if (onProgress) {
+      onProgress(`listed open PRs: ${allPulls.length}`);
+    }
+    if (pulls.length < listPerPage) {
+      break;
+    }
+    page += 1;
+  }
+
+  /** @type {({ doc: Record<string, unknown>, discoveredFromPr: number, headRef: string } | null)[]} */
+  const rowSlots = Array(allPulls.length).fill(null);
+
+  let checkedHeads = 0;
+  await forEachPool(allPulls, fetchConc, async (pull, i) => {
+    const p = pull && typeof pull === "object" ? /** @type {Record<string, unknown>} */ (pull) : {};
+    const head = p.head && typeof p.head === "object" ? /** @type {Record<string, unknown>} */ (p.head) : {};
+    const ref = typeof head.ref === "string" ? head.ref : "";
+    const num = p.number;
+    if (!ref || typeof num !== "number") {
+      return;
+    }
+    const doc = await tryLoadStackDocAtRef(owner, repo, ref);
+    checkedHeads += 1;
+    if (onProgress && (checkedHeads % 10 === 0 || checkedHeads === allPulls.length)) {
+      onProgress(`checked stack.json on PR heads: ${checkedHeads}/${allPulls.length}`);
+    }
+    if (!doc) {
+      return;
+    }
+    rowSlots[i] = { doc, discoveredFromPr: num, headRef: ref };
+  });
+
+  const found = rowSlots.filter(Boolean);
+  /** @type {Map<number, { doc: Record<string, unknown>, discoveredFromPr: number, headRef: string }>} */
+  const byTip = new Map();
+
+  for (const row of found) {
+    if (!row) {
+      continue;
+    }
+    const expandedDoc = await maybeExpandPrefixDoc(owner, repo, row.doc);
+    const tip = stackTipPrNumber(expandedDoc);
+    if (tip == null) {
+      continue;
+    }
+    const prev = byTip.get(tip);
+    const score = Array.isArray(expandedDoc.prs) ? expandedDoc.prs.length : 0;
+    const prevScore = prev ? (Array.isArray(prev.doc.prs) ? prev.doc.prs.length : 0) : -1;
+    if (!prev || score > prevScore || (score === prevScore && row.discoveredFromPr === tip)) {
+      byTip.set(tip, {
+        doc: expandedDoc,
+        discoveredFromPr: row.discoveredFromPr,
+        headRef: row.headRef
+      });
+    }
+  }
+
+  const repoFull = `${owner}/${repo}`;
+  /** @type {import("./stack-discover.js").DiscoveredStack[]} */
+  const stacks = [];
+
+  for (const [tipPr, meta] of [...byTip.entries()].sort((a, b) => a[0] - b[0])) {
+    const doc = meta.doc;
+    const prs = Array.isArray(doc.prs) ? doc.prs : [];
+    const sorted = [...prs].sort(
+      (a, b) =>
+        (/** @type {{ position?: number }} */ (a).position ?? 0) -
+        (/** @type {{ position?: number }} */ (b).position ?? 0)
+    );
+
+    /** @type {{ pr_number: number, position: number, title?: string, html_url?: string, head_branch?: string }[]} */
+    let prRows = sorted.map((entry) => {
+      const e = entry && typeof entry === "object" ? /** @type {Record<string, unknown>} */ (entry) : {};
+      return {
+        pr_number: /** @type {number} */ (e.pr_number),
+        position: /** @type {number} */ (e.position),
+        head_branch: typeof e.head_branch === "string" ? e.head_branch : undefined
+      };
+    });
+
+    if (enrich) {
+      if (onProgress) {
+        onProgress(`loading PR titles for stack tip #${tipPr}`);
+      }
+      await forEachPool(prRows, fetchConc, async (row) => {
+        try {
+          const g = await getPull(owner, repo, row.pr_number);
+          row.title = typeof g.title === "string" ? g.title : undefined;
+          row.html_url = typeof g.html_url === "string" ? g.html_url : undefined;
+        } catch {
+          /* keep without title */
+        }
+      });
+    }
+
+    const tipEntry = sorted.find((e) => {
+      const o = e && typeof e === "object" ? /** @type {{ pr_number?: number }} */ (e) : {};
+      return o.pr_number === tipPr;
+    });
+    const tipObj = tipEntry && typeof tipEntry === "object" ? /** @type {Record<string, unknown>} */ (tipEntry) : {};
+    const tipHeadBranch =
+      typeof tipObj.head_branch === "string"
+        ? tipObj.head_branch
+        : meta.headRef;
+
+    stacks.push({
+      tip_pr_number: tipPr,
+      created_by: String(doc.created_by || ""),
+      discovered_from_pr: meta.discoveredFromPr,
+      pr_count: prRows.length,
+      prs: prRows,
+      tip_head_branch: tipHeadBranch,
+      fetch_command: `nugit stack fetch --repo ${repoFull} --ref ${tipHeadBranch}`,
+      view_command: `nugit stack view --repo ${repoFull} --ref ${tipHeadBranch}`
+    });
+  }
+
+  return {
+    repo_full_name: repoFull,
+    scanned_open_prs: allPulls.length,
+    open_prs_truncated: truncated,
+    stacks_found: stacks.length,
+    stacks
+  };
+}