nugit-cli 0.0.1 → 0.1.1

package/src/stack-view/view-tui-sequential.js

@@ -0,0 +1,126 @@
+import React from "react";
+import { render } from "ink";
+import { StackPickInk } from "./stack-pick-ink.js";
+import { inferChainsToPickStacks } from "./infer-chains-to-pick-stacks.js";
+import { clearInkScreen } from "./terminal-fullscreen.js";
+
+/** Resolved by {@link pickStackIndexWithInk} when Backspace requests the repo picker (allowBackToRepo only). */
+export const STACK_PICK_BACK_TO_REPO = Symbol("STACK_PICK_BACK_TO_REPO");
+
+/**
+ * @param {object} args
+ * @param {{ tip_pr_number: number, tip_head_branch: string, pr_count: number, created_by: string, prs: unknown[], tip_updated_at?: string, inferChainIndex?: number, inferDiffAdd?: number, inferDiffDel?: number }[]} args.stacks
+ * @param {string} [args.title]
+ * @param {boolean} [args.allowBackToRepo]
+ * @param {number | null | undefined} [args.viewingTipPrNumber]
+ * @param {string | null | undefined} [args.viewingHeadRef]
+ * @returns {Promise<(typeof args.stacks)[0] | null | typeof STACK_PICK_BACK_TO_REPO>}
+ */
+function runStackPickInkOnce({
+  stacks,
+  title = "Choose stack to view",
+  allowBackToRepo = false,
+  /** When true with {@link allowBackToRepo}, Esc and q also return to repo (repo-picker loop only). */
+  escapeToRepo = false,
+  viewingTipPrNumber,
+  viewingHeadRef
+}) {
+  clearInkScreen();
+  return new Promise((resolve) => {
+    let settled = false;
+    const inst = render(
+      React.createElement(StackPickInk, {
+        stacks,
+        title,
+        viewingTipPrNumber,
+        viewingHeadRef,
+        escapeToRepo: escapeToRepo === true,
+        onPick: (picked) => {
+          if (!settled) {
+            settled = true;
+            try {
+              inst.clear();
+            } catch {
+              /* ignore */
+            }
+            resolve(picked);
+          }
+        },
+        onRequestBack:
+          allowBackToRepo === true
+            ? () => {
+                if (!settled) {
+                  settled = true;
+                  try {
+                    inst.clear();
+                  } catch {
+                    /* ignore */
+                  }
+                  resolve(STACK_PICK_BACK_TO_REPO);
+                }
+              }
+            : undefined
+      })
+    );
+    void inst.waitUntilExit().then(() => {
+      try {
+        inst.clear();
+      } catch {
+        /* ignore */
+      }
+      if (!settled) {
+        settled = true;
+        resolve(null);
+      }
+    });
+  });
+}
+
+/**
+ * @param {{ tip_pr_number: number, tip_head_branch: string, pr_count: number, created_by: string, prs: unknown[], tip_updated_at?: string }[]} stacks
+ * @param {{ allowBackToRepo?: boolean, escapeToRepo?: boolean, viewingTipPrNumber?: number | null, viewingHeadRef?: string | null }} [opts]
+ * @returns {Promise<(typeof stacks)[0] | null | typeof STACK_PICK_BACK_TO_REPO>}
+ */
+export async function pickStackIndexWithInk(stacks, opts) {
+  return runStackPickInkOnce({
+    stacks,
+    title: "Choose stack to view",
+    allowBackToRepo: opts?.allowBackToRepo === true,
+    escapeToRepo: opts?.escapeToRepo === true,
+    viewingTipPrNumber: opts?.viewingTipPrNumber,
+    viewingHeadRef: opts?.viewingHeadRef
+  });
+}
+
+/**
+ * @param {number[][]} chains bottom → tip PR numbers per chain
+ * @param {unknown[]} pulls GitHub pull objects (same list used to build chains)
+ * @param {{ allowBackToRepo?: boolean }} [opts] Backspace resolves -2 for repo-picker loop
+ * @returns {Promise<number>} chain index, or -1 for q / cancel (use largest stack), or -2 back to repo
+ */
+export async function pickInferChainIndexWithInk(chains, pulls, opts) {
+  const stacks = inferChainsToPickStacks(chains, pulls);
+  const r = await runStackPickInkOnce({
+    stacks,
+    title: "Choose stack to view",
+    allowBackToRepo: opts?.allowBackToRepo === true,
+    escapeToRepo: opts?.allowBackToRepo === true
+  });
+  if (r === STACK_PICK_BACK_TO_REPO) {
+    return -2;
+  }
+  if (r == null) {
+    return -1;
+  }
+  if (typeof r.inferChainIndex === "number") {
+    return r.inferChainIndex;
+  }
+  const tip = typeof r.tip_pr_number === "number" ? r.tip_pr_number : null;
+  if (tip != null) {
+    const fi = chains.findIndex((c) => Array.isArray(c) && c.length > 0 && c[c.length - 1] === tip);
+    if (fi >= 0) {
+      return fi;
+    }
+  }
+  return -1;
+}

package/src/tui/pages/home.js

@@ -0,0 +1,122 @@
+/**
+ * Home page — the first screen shown when `nugit` is run bare on a TTY.
+ *
+ * Keys:
+ *   Enter / c   → current directory (view stack in current git repo)
+ *   s / /       → review hub (repos with pending reviews)
+ *   o           → open remote (search GitHub for a repo)
+ *   q / Esc     → quit
+ */
+import React, { useEffect, useRef, useState } from "react";
+import { Box, Text, useApp, useInput, render, useStdout } from "ink";
+import chalk from "chalk";
+import {
+  parseSgrMouse,
+  enableSgrMouse,
+  disableSgrMouse
+} from "../../stack-view/sgr-mouse.js";
+import { getRepoFullNameFromGitRoot } from "../../git-info.js";
+import { findGitRoot } from "../../nugit-stack.js";
+import { clearInkScreen } from "../../utilities/terminal.js";
+
+/**
+ * @typedef {"cwd" | "review" | "search" | "quit"} HomeAction
+ */
+
+/**
+ * Render the home page and resolve with the user's choice.
+ * @returns {Promise<HomeAction>}
+ */
+export async function runHomePage() {
+  clearInkScreen();
+  const result = { action: /** @type {HomeAction} */ ("quit") };
+  const { waitUntilExit } = render(React.createElement(HomeApp, { result }));
+  await waitUntilExit();
+  return result.action;
+}
+
+/**
+ * @param {{ result: { action: HomeAction } }} props
+ */
+function HomeApp({ result }) {
+  const { exit } = useApp();
+  const { stdout } = useStdout();
+
+  useEffect(() => {
+    enableSgrMouse(stdout);
+    return () => disableSgrMouse(stdout);
+  }, [stdout]);
+
+  const root = findGitRoot();
+  let cwdRepo = null;
+  if (root) {
+    try { cwdRepo = getRepoFullNameFromGitRoot(root); } catch { cwdRepo = null; }
+  }
+
+  const finish = (action) => {
+    result.action = action;
+    exit();
+  };
+
+  useInput((input, key) => {
+    const mouse = parseSgrMouse(input);
+    if (mouse) return;
+
+    if (key.escape || input === "q" || key.backspace || key.delete) {
+      finish("quit");
+      return;
+    }
+    if ((key.return || input === "c") && cwdRepo) {
+      finish("cwd");
+      return;
+    }
+    if (input === "s" || input === "/") {
+      finish("review");
+      return;
+    }
+    if (input === "o") {
+      finish("search");
+      return;
+    }
+  });
+
+  return React.createElement(
+    Box,
+    { flexDirection: "column", padding: 1, gap: 0 },
+    React.createElement(
+      Text,
+      { color: "cyan", bold: true },
+      "nugit"
+    ),
+    React.createElement(Text, null, ""),
+    cwdRepo
+      ? React.createElement(
+          Text,
+          null,
+          chalk.whiteBright("Enter"),
+          `  view this directory: ${chalk.bold(cwdRepo)}`
+        )
+      : React.createElement(
+          Text,
+          { dimColor: true },
+          "Enter  (no github.com remote — navigate to a repo with [o])"
+        ),
+    React.createElement(
+      Text,
+      null,
+      chalk.whiteBright("[s]"),
+      "    review hub — repos with pending reviews"
+    ),
+    React.createElement(
+      Text,
+      null,
+      chalk.whiteBright("[o]"),
+      "    open remote — search GitHub for any repo"
+    ),
+    React.createElement(
+      Text,
+      { dimColor: true },
+      "[q]    quit"
+    )
+  );
+}

package/src/tui/pages/repo-actions.js

@@ -0,0 +1,81 @@
+/**
+ * Repo Actions page — shown after a repo has been chosen, before entering the viewer.
+ *
+ * Keys:
+ *   Enter / s   → Review stacks (stack picker + viewer)
+ *   b           → Branches / PRs
+ *   Backspace   → go back
+ *   q / Esc     → go back
+ */
+import React from "react";
+import { Box, Text, useApp, useInput, render } from "ink";
+import chalk from "chalk";
+import { clearInkScreen } from "../../utilities/terminal.js";
+
+/**
+ * @typedef {"stacks" | "branches" | "back"} RepoAction
+ */
+
+/**
+ * @param {{ repo: string }} opts
+ * @returns {Promise<RepoAction>}
+ */
+export async function runRepoActionsPage({ repo }) {
+  clearInkScreen();
+  const result = { action: /** @type {RepoAction} */ ("back") };
+  const { waitUntilExit } = render(
+    React.createElement(RepoActionsApp, { repo, result })
+  );
+  await waitUntilExit();
+  return result.action;
+}
+
+/**
+ * @param {{ repo: string, result: { action: RepoAction } }} props
+ */
+function RepoActionsApp({ repo, result }) {
+  const { exit } = useApp();
+
+  const finish = (/** @type {RepoAction} */ action) => {
+    result.action = action;
+    exit();
+  };
+
+  useInput((input, key) => {
+    const backKey = key.backspace || key.delete || input === "\x7f" || input === "\b";
+    if (backKey || input === "q" || key.escape) {
+      finish("back");
+      return;
+    }
+    if (key.return || input === "s") {
+      finish("stacks");
+      return;
+    }
+    if (input === "b") {
+      finish("branches");
+      return;
+    }
+  });
+
+  return React.createElement(
+    Box,
+    { flexDirection: "column", padding: 1, gap: 0 },
+    React.createElement(Text, { color: "cyan", bold: true }, "nugit"),
+    React.createElement(Text, { dimColor: true }, repo),
+    React.createElement(Text, {}, ""),
+    React.createElement(
+      Text,
+      {},
+      chalk.whiteBright("Enter"),
+      "  Review stacks — browse and approve stacked PRs"
+    ),
+    React.createElement(
+      Text,
+      {},
+      chalk.whiteBright("[b]"),
+      "    Branches / PRs — list, push, and open PRs for branches"
+    ),
+    React.createElement(Text, {}, ""),
+    React.createElement(Text, { dimColor: true }, "Backspace / [q]  back")
+  );
+}

package/src/tui/pages/repo-branches.js

@@ -0,0 +1,259 @@
+/**
+ * Branches / PRs page — list local + remote branches for a repo, with actions:
+ *   Enter / p   → push local branch to remote (when local_ahead or diverged)
+ *   Enter / c   → create PR (opens gh pr create or browser compare URL)
+ *   o           → open compare URL in browser
+ *   j / k       → move cursor
+ *   Backspace / q → go back
+ */
+import React, { useEffect, useRef, useState } from "react";
+import { Box, Text, useApp, useInput, render } from "ink";
+import chalk from "chalk";
+import { execFileSync, spawnSync } from "child_process";
+import { clearInkScreen } from "../../utilities/terminal.js";
+import { openUrl } from "../../stack-view/open-url.js";
+import {
+  listLocalBranches,
+  listRemoteBranches,
+  mergeBranchModel
+} from "../../services/repo-branches.js";
+import { findGitRoot } from "../../nugit-stack.js";
+import { getRepoFullNameFromGitRoot } from "../../git-info.js";
+import { parseRepoFullName } from "../../nugit-stack.js";
+
+/**
+ * @param {{ repo: string }} opts
+ * @returns {Promise<void>}
+ */
+export async function runRepoBranchesPage({ repo }) {
+  clearInkScreen();
+  const { waitUntilExit } = render(
+    React.createElement(RepoBranchesApp, { repo })
+  );
+  await waitUntilExit();
+}
+
+/**
+ * @param {{ repo: string }} props
+ */
+function RepoBranchesApp({ repo }) {
+  const { exit } = useApp();
+  const { owner, repo: repoName } = parseRepoFullName(repo);
+
+  const [loading, setLoading] = useState(true);
+  const [err, setErr] = useState(/** @type {string | null} */ (null));
+  const [rows, setRows] = useState(/** @type {import("../../services/repo-branches.js").BranchRow[]} */ ([]));
+  const [cursor, setCursor] = useState(0);
+  const [action, setAction] = useState(/** @type {string | null} */ (null));
+  const [actionErr, setActionErr] = useState(/** @type {string | null} */ (null));
+
+  // Resolve local git root (may not match repo if user launched from a different dir)
+  const localRoot = (() => {
+    const root = findGitRoot();
+    if (!root) return null;
+    try {
+      const remoteRepo = getRepoFullNameFromGitRoot(root);
+      return remoteRepo === repo ? root : null;
+    } catch {
+      return null;
+    }
+  })();
+
+  const rowsRef = useRef(rows);
+  rowsRef.current = rows;
+
+  const loadBranches = () => {
+    setLoading(true);
+    setErr(null);
+    setActionErr(null);
+
+    const local = localRoot ? listLocalBranches(localRoot) : [];
+    listRemoteBranches(owner, repoName)
+      .then((remote) => mergeBranchModel(local, remote, localRoot))
+      .then((merged) => {
+        setRows(merged);
+        setCursor(0);
+      })
+      .catch((e) => setErr(String(e?.message || e)))
+      .finally(() => setLoading(false));
+  };
+
+  useEffect(() => {
+    loadBranches();
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+
+  useInput((input, key) => {
+    if (loading) return;
+    const backKey = key.backspace || key.delete || input === "\x7f" || input === "\b";
+    if (backKey || input === "q" || key.escape) {
+      exit();
+      return;
+    }
+    if (input === "j" || key.downArrow) {
+      setCursor((c) => Math.min(c + 1, Math.max(0, rowsRef.current.length - 1)));
+      return;
+    }
+    if (input === "k" || key.upArrow) {
+      setCursor((c) => Math.max(c - 1, 0));
+      return;
+    }
+    if (input === "r") {
+      loadBranches();
+      return;
+    }
+
+    const row = rowsRef.current[cursor];
+    if (!row) return;
+
+    // Push local → remote
+    if (input === "p" && localRoot && (row.status === "local_ahead" || row.status === "local_only" || row.status === "diverged")) {
+      setAction(`Pushing ${row.name}…`);
+      setActionErr(null);
+      try {
+        spawnSync("git", ["push", "origin", row.name], {
+          cwd: localRoot,
+          stdio: "pipe"
+        });
+        setAction(null);
+        loadBranches();
+      } catch (e) {
+        setActionErr(String(/** @type {{ message?: string }} */ (e)?.message || e));
+        setAction(null);
+      }
+      return;
+    }
+
+    // Create PR via gh CLI or browser
+    if (key.return || input === "c") {
+      if (row.status === "remote_only" || row.status === "in_sync" || row.status === "remote_ahead") {
+        // Branch is on remote — open compare URL
+        const compareUrl = `https://github.com/${repo}/compare/${encodeURIComponent(row.name)}`;
+        openUrl(compareUrl);
+        setAction(`Opened compare URL for ${row.name}`);
+        setTimeout(() => setAction(null), 2000);
+      } else if (row.status === "local_only" || row.status === "local_ahead") {
+        if (!localRoot) {
+          setActionErr("No local clone found for push/create PR.");
+          return;
+        }
+        // Try gh pr create, fall back to browser
+        const ghResult = spawnSync("gh", ["pr", "create", "--head", row.name, "--fill"], {
+          cwd: localRoot,
+          encoding: "utf8",
+          stdio: "pipe"
+        });
+        if (ghResult.status === 0) {
+          setAction(`PR created via gh for ${row.name}`);
+          setTimeout(() => { setAction(null); loadBranches(); }, 2000);
+        } else {
+          const compareUrl = `https://github.com/${repo}/compare/${encodeURIComponent(row.name)}`;
+          openUrl(compareUrl);
+          setAction(`Opened compare URL for ${row.name} (gh not available)`);
+          setTimeout(() => setAction(null), 2000);
+        }
+      }
+      return;
+    }
+
+    // Open compare URL in browser
+    if (input === "o") {
+      const compareUrl = `https://github.com/${repo}/compare/${encodeURIComponent(row.name)}`;
+      openUrl(compareUrl);
+      setAction(`Opened compare URL for ${row.name}`);
+      setTimeout(() => setAction(null), 2000);
+      return;
+    }
+  });
+
+  const safeRow = rows.length ? rows[Math.min(cursor, rows.length - 1)] : null;
+
+  /** @param {import("../../services/repo-branches.js").BranchStatus} status */
+  function statusBadge(status) {
+    switch (status) {
+      case "local_ahead": return chalk.green("↑ local ahead");
+      case "remote_ahead": return chalk.yellow("↓ remote ahead");
+      case "diverged": return chalk.red("⇅ diverged");
+      case "local_only": return chalk.cyan("local only");
+      case "remote_only": return chalk.gray("remote only");
+      case "in_sync": return chalk.dim("in sync");
+      default: return "";
+    }
+  }
+
+  const VIEWPORT = 14;
+  const n = rows.length;
+  const viewStart =
+    n <= VIEWPORT ? 0 : Math.max(0, Math.min(cursor - Math.floor(VIEWPORT / 2), n - VIEWPORT));
+  const viewSlice = rows.slice(viewStart, viewStart + VIEWPORT);
+
+  /** @param {import("../../services/repo-branches.js").BranchRow} row */
+  function rowActions(row) {
+    const parts = [];
+    if (
+      localRoot &&
+      (row.status === "local_ahead" || row.status === "local_only" || row.status === "diverged")
+    ) {
+      parts.push("[p] push");
+    }
+    if (row.status !== "in_sync") {
+      parts.push("[Enter/c] create PR");
+    }
+    parts.push("[o] compare");
+    return chalk.dim(parts.join(" · "));
+  }
+
+  return React.createElement(
+    Box,
+    { flexDirection: "column", padding: 1 },
+    React.createElement(
+      Text,
+      { color: "cyan", bold: true },
+      `Branches / PRs — ${repo}`
+    ),
+    React.createElement(
+      Text,
+      { dimColor: true },
+      `j/k navigate · [r] refresh · Backspace/q back${localRoot ? " · [p] push" : " (no local clone)"}${" · [Enter/c] create PR · [o] compare"}`
+    ),
+    loading
+      ? React.createElement(Text, { color: "yellow" }, "Loading branches…")
+      : err
+        ? React.createElement(Text, { color: "red" }, err)
+        : React.createElement(
+            Box,
+            { flexDirection: "column", marginTop: 1 },
+            n === 0
+              ? React.createElement(Text, { dimColor: true }, "No branches found.")
+              : viewSlice.map((row, localI) => {
+                  const i = viewStart + localI;
+                  const sel = i === cursor;
+                  const mark = sel ? "▶ " : "  ";
+                  const nameColor = sel ? chalk.yellowBright : chalk.white;
+                  const aheadBehind =
+                    row.ahead || row.behind
+                      ? chalk.dim(` (${row.ahead}↑ ${row.behind}↓)`)
+                      : "";
+
+                  return React.createElement(
+                    Box,
+                    { key: row.name, flexDirection: "column", marginBottom: sel ? 1 : 0 },
+                    React.createElement(
+                      Text,
+                      {},
+                      mark,
+                      nameColor(row.name),
+                      " ",
+                      statusBadge(row.status),
+                      aheadBehind
+                    ),
+                    sel
+                      ? React.createElement(Text, {}, "   ", rowActions(row))
+                      : null
+                  );
+                })
+          ),
+    action ? React.createElement(Text, { color: "green" }, action) : null,
+    actionErr ? React.createElement(Text, { color: "red" }, actionErr) : null
+  );
+}