nugit-cli 0.0.1 → 0.1.1

package/src/tui/router.js

@@ -0,0 +1,40 @@
+/**
+ * FSM router for the nugit TUI.
+ *
+ * States:
+ *   home        → opening screen: cwd view, review hub, remote search, quit
+ *   loading     → full-screen loading animation (transient between states)
+ *   repo_search → GitHub repo search (pick a remote repo to view)
+ *   review_hub  → review hub repo list
+ *   viewer      → stack viewer (entered after a repo + stack is resolved)
+ *   split_flow  → split TUI (entered from within viewer)
+ *
+ * Transitions are driven by a simple async loop in run-tui.js. Each state
+ * returns a "next state" descriptor; the router applies loading + clear
+ * between major screen transitions automatically.
+ */
+
+/**
+ * @typedef {"home" | "repo_search" | "review_hub" | "viewer" | "done"} TuiState
+ *
+ * @typedef {{ state: TuiState, repo?: string, ref?: string }} RouterCtx
+ */
+
+/**
+ * Initial router context.
+ * @returns {RouterCtx}
+ */
+export function createRouterCtx() {
+  return { state: "home" };
+}
+
+/**
+ * Transition to a new state, returning an updated context.
+ * @param {RouterCtx} ctx
+ * @param {TuiState} next
+ * @param {Partial<RouterCtx>} [extra]
+ * @returns {RouterCtx}
+ */
+export function transition(ctx, next, extra = {}) {
+  return { ...ctx, state: next, ...extra };
+}

package/src/tui/run-tui.js

@@ -0,0 +1,281 @@
+/**
+ * Main TUI entry point.
+ *
+ * Manages navigation via an explicit navStack so that Backspace always returns
+ * to the immediately previous page. The alternate screen is owned exclusively
+ * here — individual pages never enter/leave it.
+ *
+ * navStack entry shapes:
+ *   { screen: "home" }
+ *   { screen: "review_hub" }
+ *   { screen: "repo_search" }
+ *   { screen: "repo_actions", repo: string, ref?: string, viewerLogin?: string }
+ *   { screen: "viewer",       repo: string, ref?: string, viewerLogin?: string }
+ *   { screen: "branches",     repo: string }
+ */
+import React from "react";
+import { render } from "ink";
+import {
+  enterAlternateScreen,
+  leaveAlternateScreen,
+  clearInkScreen
+} from "../utilities/terminal.js";
+import { withLoadingScreen } from "../utilities/loading.js";
+import { runHomePage } from "./pages/home.js";
+
+/**
+ * @typedef {{ screen: "home" }} HomeEntry
+ * @typedef {{ screen: "review_hub" }} ReviewHubEntry
+ * @typedef {{ screen: "repo_search" }} RepoSearchEntry
+ * @typedef {{ screen: "repo_actions", repo: string, ref?: string, viewerLogin?: string }} RepoActionsEntry
+ * @typedef {{ screen: "viewer",       repo: string, ref?: string, viewerLogin?: string }} ViewerEntry
+ * @typedef {{ screen: "branches",     repo: string }} BranchesEntry
+ * @typedef {HomeEntry | ReviewHubEntry | RepoSearchEntry | RepoActionsEntry | ViewerEntry | BranchesEntry} NavEntry
+ */
+
+/**
+ * @typedef {{ startAt?: "home" | "review_hub", startRepo?: string, startRef?: string }} TuiOpts
+ */
+
+/**
+ * Run the full TUI loop until the user quits.
+ * @param {TuiOpts} [opts]
+ */
+export async function runNugitTui(opts = {}) {
+  enterAlternateScreen(process.stdout);
+  try {
+    await _navLoop(opts);
+  } finally {
+    leaveAlternateScreen(process.stdout);
+  }
+}
+
+/** @param {TuiOpts} opts */
+async function _navLoop(opts) {
+  /** @type {NavEntry[]} */
+  let navStack;
+
+  if (opts.startRepo) {
+    navStack = [
+      { screen: "home" },
+      { screen: "repo_actions", repo: opts.startRepo, ref: opts.startRef }
+    ];
+  } else if (opts.startAt === "review_hub") {
+    navStack = [{ screen: "home" }, { screen: "review_hub" }];
+  } else {
+    navStack = [{ screen: "home" }];
+  }
+
+  while (navStack.length > 0) {
+    const current = navStack[navStack.length - 1];
+
+    if (current.screen === "home") {
+      clearInkScreen();
+      const action = await runHomePage();
+      if (action === "quit") {
+        navStack = [];
+        continue;
+      }
+      if (action === "cwd") {
+        // Resolve CWD repo immediately; push repo_actions if found
+        const repoEntry = await _resolveCwdRepo();
+        if (repoEntry) {
+          navStack.push({ screen: "repo_actions", repo: repoEntry.repo, ref: repoEntry.ref });
+        }
+        // If not found, runHomePage already showed the disabled hint; just re-show home
+        continue;
+      }
+      if (action === "review") {
+        navStack.push({ screen: "review_hub" });
+        continue;
+      }
+      if (action === "search") {
+        navStack.push({ screen: "repo_search" });
+        continue;
+      }
+      navStack = [];
+      continue;
+    }
+
+    if (current.screen === "review_hub") {
+      const result = await _runReviewHubScreen();
+      if (result.kind === "quit" || result.kind === "back") {
+        navStack.pop();
+        continue;
+      }
+      if (result.kind === "pick") {
+        navStack.push({
+          screen: "repo_actions",
+          repo: result.repo,
+          viewerLogin: result.viewerLogin
+        });
+        continue;
+      }
+      navStack.pop();
+      continue;
+    }
+
+    if (current.screen === "repo_search") {
+      clearInkScreen();
+      const { runRepoPickerFlow } = await import("../stack-view/view-repo-picker-ink.js");
+      const picked = await runRepoPickerFlow();
+      if (!picked) {
+        // Cancelled (null) → back
+        navStack.pop();
+        continue;
+      }
+      navStack.push({ screen: "repo_actions", repo: picked.repo, ref: picked.ref });
+      continue;
+    }
+
+    if (current.screen === "repo_actions") {
+      const { runRepoActionsPage } = await import("./pages/repo-actions.js");
+      const action = await runRepoActionsPage({ repo: current.repo });
+      if (action === "back") {
+        navStack.pop();
+        continue;
+      }
+      if (action === "stacks") {
+        navStack.push({
+          screen: "viewer",
+          repo: current.repo,
+          ref: current.ref,
+          viewerLogin: current.viewerLogin
+        });
+        continue;
+      }
+      if (action === "branches") {
+        navStack.push({ screen: "branches", repo: current.repo });
+        continue;
+      }
+      navStack.pop();
+      continue;
+    }
+
+    if (current.screen === "viewer") {
+      let repo = current.repo;
+
+      if (!repo) {
+        const repoEntry = await _resolveCwdRepo();
+        if (!repoEntry) {
+          navStack.pop();
+          continue;
+        }
+        repo = repoEntry.repo;
+      }
+
+      try {
+        const { runStackViewCommand } = await import("../stack-view/run-stack-view.js");
+        const { RepoPickerBackError } = await import("../stack-view/repo-picker-back.js");
+        try {
+          await runStackViewCommand({
+            repo,
+            ref: current.ref,
+            noTui: false,
+            shellMode: true,
+            allowBackToRepoPicker: true,
+            ...(current.viewerLogin
+              ? {
+                  reviewFetchOpts: { viewerLogin: current.viewerLogin, fullReviewFetch: true }
+                }
+              : {})
+          });
+        } catch (e) {
+          if (!(e instanceof RepoPickerBackError)) throw e;
+          // Back from stack picker → go back to repo_actions
+        }
+      } catch (e) {
+        // Non-back error: surface it then pop
+        console.error(String(/** @type {{ message?: string }} */ (e)?.message || e));
+      }
+      navStack.pop();
+      continue;
+    }
+
+    if (current.screen === "branches") {
+      const { runRepoBranchesPage } = await import("./pages/repo-branches.js");
+      await runRepoBranchesPage({ repo: current.repo });
+      navStack.pop();
+      continue;
+    }
+
+    // Unknown screen — bail
+    navStack.pop();
+  }
+}
+
+/**
+ * Resolve the current directory's GitHub repo (owner/repo + default branch).
+ * Returns null if not in a git repo or no GitHub remote found.
+ * @returns {Promise<{ repo: string, ref: string } | null>}
+ */
+async function _resolveCwdRepo() {
+  try {
+    const { findGitRoot } = await import("../nugit-stack.js");
+    const { getRepoFullNameFromGitRoot } = await import("../git-info.js");
+    const { getRepoMetadata } = await import("../api-client.js");
+    const { parseRepoFullName } = await import("../nugit-stack.js");
+
+    const root = findGitRoot();
+    if (!root) return null;
+    const repoFull = getRepoFullNameFromGitRoot(root);
+    const { owner, repo } = parseRepoFullName(repoFull);
+    const meta = await getRepoMetadata(owner, repo);
+    const ref = (meta && typeof meta.default_branch === "string" ? meta.default_branch : null) || "main";
+    return { repo: repoFull, ref };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Fetch review hub data and render the ReviewHubInk UI.
+ * @returns {Promise<{ kind: "back" | "quit" } | { kind: "pick", repo: string, viewerLogin: string }>}
+ */
+async function _runReviewHubScreen() {
+  const { fetchReviewHubData } = await import("../review-hub/run-review-hub.js");
+  const { ReviewHubInk } = await import("../review-hub/review-hub-ink.js");
+
+  let hubData = /** @type {{ login: string, lines: import("../review-hub/review-hub-ink.js").HubLine[] } | null} */ (null);
+  try {
+    await withLoadingScreen("Loading repositories…", async () => {
+      hubData = await fetchReviewHubData();
+    });
+  } catch (e) {
+    console.error(String(/** @type {{ message?: string }} */ (e)?.message || e));
+    return { kind: "back" };
+  }
+
+  if (!hubData) return { kind: "back" };
+
+  const lines = hubData.lines;
+  const login = hubData.login;
+
+  if (!lines.filter((l) => l.kind === "repo").length) {
+    console.error("No repositories visible to this token.");
+    return { kind: "back" };
+  }
+
+  clearInkScreen();
+
+  const result = { kind: /** @type {"back" | "quit" | "pick"} */ ("back"), repo: "", viewerLogin: "" };
+  const { waitUntilExit } = render(
+    React.createElement(ReviewHubInk, {
+      lines,
+      onPickRepo: (fullName) => {
+        result.kind = "pick";
+        result.repo = fullName;
+        result.viewerLogin = login;
+      },
+      onBack: () => {
+        result.kind = "back";
+      }
+    })
+  );
+  await waitUntilExit();
+
+  if (result.kind === "pick") {
+    return { kind: "pick", repo: result.repo, viewerLogin: result.viewerLogin };
+  }
+  return { kind: result.kind === "quit" ? "quit" : "back" };
+}

package/src/utilities/loading.js

@@ -0,0 +1,37 @@
+import React, { useEffect, useState } from "react";
+import { Box, Text, render } from "ink";
+import { clearInkScreen } from "./terminal.js";
+
+const FRAMES = ["\u280b", "\u2819", "\u2839", "\u2838", "\u283c", "\u2834", "\u2826", "\u2827", "\u2807", "\u280f"];
+
+/**
+ * Full-screen loading animation with a braille spinner.
+ * Mounts, runs `work()`, then unmounts cleanly.
+ *
+ * @param {string} message
+ * @param {() => Promise<void>} work
+ */
+export async function withLoadingScreen(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/utilities/terminal.js

@@ -0,0 +1,31 @@
+/**
+ * Terminal I/O helpers for the nugit TUI.
+ * Disable alternate screen with NUGIT_NO_FULLSCREEN=1 if your terminal misbehaves.
+ */
+
+export function isAlternateScreenDisabled() {
+  const v = process.env.NUGIT_NO_FULLSCREEN;
+  return v === "1" || v === "true";
+}
+
+/** @param {import('node:stream').Writable | undefined} stdout */
+export function enterAlternateScreen(stdout) {
+  if (!stdout?.isTTY || isAlternateScreenDisabled()) return;
+  stdout.write("\x1b[?1049h\x1b[2J\x1b[H");
+}
+
+/** @param {import('node:stream').Writable | undefined} stdout */
+export function leaveAlternateScreen(stdout) {
+  if (!stdout?.isTTY || isAlternateScreenDisabled()) return;
+  stdout.write("\x1b[?1049l");
+}
+
+/**
+ * Erase and home the cursor. Call before mounting a new Ink tree so previous
+ * content doesn't leave ghost lines.
+ * @param {import('node:stream').Writable} [out]
+ */
+export function clearInkScreen(out = process.stdout) {
+  if (!out?.isTTY || isAlternateScreenDisabled()) return;
+  out.write("\x1b[2J\x1b[H");
+}

package/src/cli-output.js

@@ -1,228 +0,0 @@
-import chalk from "chalk";
-import boxen from "boxen";
-
-/**
- * @param {unknown} data
- */
-export function printJson(data) {
-  console.log(JSON.stringify(data, null, 2));
-}
-
-/**
- * @param {unknown} data
- * @param {boolean} asJson
- */
-export function out(data, asJson) {
-  if (asJson) {
-    printJson(data);
-  }
-}
-
-/** @param {Record<string, unknown>} me */
-export function formatWhoamiHuman(me) {
-  const login = me.login ?? "?";
-  const name = me.name ? ` (${me.name})` : "";
-  const id = me.id != null ? chalk.dim(` id ${me.id}`) : "";
-  return `${chalk.bold(login)}${name}${id}`;
-}
-
-/**
- * @param {{ total_count?: number, items?: unknown[] }} search
- * @param {{ page?: number, perPage?: number }} [pag]
- */
-export function formatPrSearchHuman(search, pag) {
-  const items = Array.isArray(search.items) ? search.items : [];
-  const lines = [];
-  const page = pag?.page ?? 1;
-  const perPage = pag?.perPage ?? 30;
-  const total = search.total_count;
-  lines.push(
-    chalk.bold.cyan(
-      `Open PRs you authored (page ${page}, ${items.length} on this page${total != null ? ` · ${total} total` : ""})`
-    )
-  );
-  lines.push("");
-  for (const it of items) {
-    const o = it && typeof it === "object" ? /** @type {Record<string, unknown>} */ (it) : {};
-    const num = o.number;
-    const title = String(o.title || "");
-    const html = o.html_url ? String(o.html_url) : "";
-    const repo = o.repository_url ? String(o.repository_url).replace("https://api.github.com/repos/", "") : "";
-    lines.push(
-      `  ${chalk.bold("#" + num)}  ${chalk.dim(repo)}  ${title.slice(0, 72)}${title.length > 72 ? "…" : ""}`
-    );
-    if (html) {
-      lines.push(`       ${chalk.blue.underline(html)}`);
-    }
-  }
-  const mayHaveMore =
-    total != null ? page * perPage < total : items.length >= perPage;
-  if (mayHaveMore && items.length > 0) {
-    lines.push("");
-    lines.push(chalk.dim(`Next page: ${chalk.bold(`nugit prs list --mine --page ${page + 1}`)}`));
-  }
-  lines.push("");
-  lines.push(chalk.dim("Use PR # with: nugit stack add --pr <n> [more #…] (bottom → top)"));
-  return lines.join("\n");
-}
-
-/**
- * @param {{ pulls: unknown[], page: number, per_page: number, repo_full_name: string, has_more: boolean }} payload
- */
-export function formatOpenPullsHuman(payload) {
-  const pulls = Array.isArray(payload.pulls) ? payload.pulls : [];
-  const lines = [];
-  lines.push(
-    chalk.bold.cyan(
-      `Open PRs in ${payload.repo_full_name} (page ${payload.page}, ${pulls.length} shown, ${payload.per_page}/page)`
-    )
-  );
-  lines.push("");
-  for (const pr of pulls) {
-    const p = pr && typeof pr === "object" ? /** @type {Record<string, unknown>} */ (pr) : {};
-    const head = p.head && typeof p.head === "object" ? /** @type {{ ref?: string }} */ (p.head) : {};
-    const base = p.base && typeof p.base === "object" ? /** @type {{ ref?: string }} */ (p.base) : {};
-    const user = p.user && typeof p.user === "object" ? /** @type {{ login?: string }} */ (p.user) : {};
-    const num = p.number;
-    const title = String(p.title || "");
-    const branch = `${head.ref || "?"} ← ${base.ref || "?"}`;
-    lines.push(
-      `  ${chalk.bold("#" + num)}  ${chalk.dim(branch)}  ${chalk.dim(user.login || "")}  ${title.slice(0, 56)}${title.length > 56 ? "…" : ""}`
-    );
-    if (p.html_url) {
-      lines.push(`       ${chalk.blue.underline(String(p.html_url))}`);
-    }
-  }
-  if (pulls.length === 0) {
-    lines.push(chalk.dim("  (no open PRs on this page)"));
-  }
-  if (payload.has_more) {
-    lines.push("");
-    lines.push(chalk.dim(`Next page: ${chalk.bold(`nugit prs list --page ${payload.page + 1}`)}`));
-  }
-  lines.push("");
-  const nums = pulls.map((pr) => (/** @type {{ number?: number }} */ (pr).number)).filter((n) => n != null);
-  if (nums.length) {
-    lines.push(chalk.dim(`Stack (bottom→top): ${chalk.bold(`nugit stack add --pr ${nums.join(" ")}`)}`));
-  }
-  return boxen(lines.join("\n"), { padding: 1, borderStyle: "round", borderColor: "cyan" });
-}
-
-/**
- * @param {Record<string, unknown>} doc
- */
-export function formatStackDocHuman(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)
-  );
-  const lines = [];
-  lines.push(chalk.bold.cyan(".nugit/stack.json"));
-  lines.push(chalk.dim(`repo ${doc.repo_full_name} · by ${doc.created_by}`));
-  lines.push("");
-  for (let i = 0; i < sorted.length; i++) {
-    const p = sorted[i];
-    const e = p && typeof p === "object" ? /** @type {Record<string, unknown>} */ (p) : {};
-    lines.push(`  ${chalk.bold("#" + e.pr_number)}  pos ${e.position}  ${e.head_branch || ""} ← ${e.base_branch || ""}`);
-  }
-  if (sorted.length === 0) {
-    lines.push(chalk.dim("  (no PRs — use nugit stack add)"));
-  }
-  return boxen(lines.join("\n"), { padding: 1, borderStyle: "round", borderColor: "cyan" });
-}
-
-/**
- * @param {Record<string, unknown>} doc
- * @param {Array<Record<string, unknown>>} enrichedPrs
- */
-export function formatStackEnrichHuman(doc, enrichedPrs) {
-  const lines = [];
-  lines.push(chalk.bold.cyan("Stack (with GitHub titles)"));
-  lines.push(chalk.dim(String(doc.repo_full_name)));
-  lines.push("");
-  for (const row of enrichedPrs) {
-    const err = row.error;
-    if (err) {
-      lines.push(`  ${chalk.yellow("PR #" + row.pr_number)}  ${chalk.red(String(err))}`);
-      continue;
-    }
-    const title = String(row.title || "");
-    const url = row.html_url ? String(row.html_url) : "";
-    lines.push(`  ${chalk.bold("PR #" + row.pr_number)}  ${title}`);
-    if (url) {
-      lines.push(`       ${chalk.blue.underline(url)}`);
-    }
-  }
-  return boxen(lines.join("\n"), { padding: 1, borderStyle: "round", borderColor: "cyan" });
-}
-
-/**
- * @param {{
- *   repo_full_name: string,
- *   scanned_open_prs: number,
- *   open_prs_truncated: boolean,
- *   stacks_found: number,
- *   stacks: Array<{
- *     tip_pr_number: number,
- *     created_by: string,
- *     pr_count: number,
- *     prs: Array<{ pr_number: number, position?: number, title?: string, html_url?: string }>,
- *     tip_head_branch: string,
- *     fetch_command: string,
- *     view_command: string
- *   }>
- * }} payload
- */
-export function formatStacksListHuman(payload) {
-  const lines = [];
-  lines.push(
-    chalk.bold.cyan(`Stacks in ${payload.repo_full_name}`) +
-      chalk.dim(
-        ` · scanned ${payload.scanned_open_prs} open PR(s)${payload.open_prs_truncated ? " (truncated — increase --max-open-prs)" : ""}`
-      )
-  );
-  lines.push(chalk.dim(`Found ${payload.stacks_found} stack(s) with .nugit/stack.json on a PR head`));
-  lines.push("");
-  if (payload.stacks.length === 0) {
-    lines.push(chalk.dim("  (none — stacks appear after authors commit stack.json on stacked branches)"));
-    return lines.join("\n");
-  }
-  for (const s of payload.stacks) {
-    lines.push(chalk.bold(`Tip PR #${s.tip_pr_number}`) + chalk.dim(` · ${s.pr_count} PR(s) · by ${s.created_by}`));
-    lines.push(chalk.dim(`  branch ${s.tip_head_branch}`));
-    for (const p of s.prs) {
-      const raw = p.title != null ? String(p.title) : "";
-      const tit = raw.length > 72 ? `${raw.slice(0, 71)}…` : raw;
-      lines.push(
-        `    ${chalk.bold("#" + p.pr_number)}${tit ? chalk.dim("  " + tit) : ""}`
-      );
-      if (p.html_url) {
-        lines.push(`      ${chalk.blue.underline(String(p.html_url))}`);
-      }
-    }
-    lines.push(chalk.dim(`  → ${s.view_command}`));
-    lines.push("");
-  }
-  return lines.join("\n").trimEnd() + "\n";
-}
-
-/** @param {Record<string, unknown>} created */
-export function formatPrCreatedHuman(created) {
-  const num = created.number;
-  const url = created.html_url ? String(created.html_url) : "";
-  return [
-    chalk.green("Opened pull request"),
-    chalk.bold(`#${num}`),
-    url ? chalk.blue.underline(url) : ""
-  ]
-    .filter(Boolean)
-    .join(" ");
-}
-
-/** @param {Record<string, unknown>} result pat validation */
-export function formatPatOkHuman(result) {
-  const login = result.login ?? "?";
-  return chalk.green("PAT OK — GitHub login ") + chalk.bold(String(login));
-}