nugit-cli 0.0.1

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "nugit-cli",
+  "version": "0.0.1",
+  "description": "CLI for stacked GitHub PRs (.nugit/stack.json)",
+  "type": "module",
+  "bin": {
+    "nugit": "src/nugit.js"
+  },
+  "files": [
+    "src"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jerrying123/nugit.git",
+    "directory": "cli"
+  },
+  "scripts": {
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "boxen": "^8.0.1",
+    "chalk": "^5.6.2",
+    "commander": "^12.1.0",
+    "ink": "^6.8.0",
+    "react": "^19.2.4"
+  },
+  "devDependencies": {
+    "vitest": "^2.1.8"
+  }
+}

package/src/api-client.js

@@ -0,0 +1,182 @@
+import {
+  githubCreatePullRequest,
+  githubGetContents,
+  githubGetPull,
+  githubGetRepoMetadata,
+  githubGetViewer,
+  githubListUserRepos,
+  githubRestJson,
+  githubSearchIssues,
+  githubListOpenPulls
+} from "./github-rest.js";
+import {
+  githubDeviceFlowPollAccessToken,
+  githubDeviceFlowRequestCode
+} from "./github-device-flow.js";
+import { resolveGithubToken } from "./auth-token.js";
+
+/** @returns {string} */
+export function getToken() {
+  return resolveGithubToken();
+}
+
+export function withAuthHeaders(headers = {}) {
+  const token = getToken();
+  if (!token) {
+    return headers;
+  }
+  return { ...headers, Authorization: `Bearer ${token}` };
+}
+
+/**
+ * Start GitHub OAuth device flow (requires GITHUB_OAUTH_CLIENT_ID).
+ */
+export async function startDeviceFlow() {
+  const clientId = process.env.GITHUB_OAUTH_CLIENT_ID;
+  if (!clientId) {
+    throw new Error(
+      "Set GITHUB_OAUTH_CLIENT_ID to your GitHub OAuth App client ID (Settings → Developer settings → OAuth Apps), or use a PAT with NUGIT_USER_TOKEN."
+    );
+  }
+  return githubDeviceFlowRequestCode(clientId, "repo read:user user:email");
+}
+
+/**
+ * Single poll for device flow. Returns token, pending, or throws.
+ * @param {string} deviceCode
+ * @param {number} [intervalSeconds] minimum wait before next poll (from GitHub or prior slow_down)
+ */
+export async function pollDeviceFlow(deviceCode, intervalSeconds = 5) {
+  const clientId = process.env.GITHUB_OAUTH_CLIENT_ID;
+  if (!clientId) {
+    throw new Error("Set GITHUB_OAUTH_CLIENT_ID");
+  }
+  const payload = await githubDeviceFlowPollAccessToken(clientId, deviceCode);
+  if (payload.access_token) {
+    return { access_token: payload.access_token, token_type: payload.token_type, scope: payload.scope };
+  }
+  if (payload.error === "authorization_pending") {
+    return { pending: true, interval: Math.max(5, intervalSeconds) };
+  }
+  if (payload.error === "slow_down") {
+    return { pending: true, interval: Math.max(5, intervalSeconds) + 5 };
+  }
+  const msg = payload.error_description || payload.error || "Device flow failed";
+  throw new Error(typeof msg === "string" ? msg : JSON.stringify(payload));
+}
+
+/**
+ * Poll until token or fatal error (for `nugit auth poll`).
+ * @param {string} deviceCode
+ * @param {number} [initialInterval] from `device_code` response `interval`
+ */
+export async function pollDeviceFlowUntilComplete(deviceCode, initialInterval = 5) {
+  let wait = Math.max(5, initialInterval);
+  for (;;) {
+    const result = await pollDeviceFlow(deviceCode, wait);
+    if (result.access_token) {
+      return result;
+    }
+    if (result.pending) {
+      wait = result.interval ?? wait;
+      await new Promise((r) => setTimeout(r, wait * 1000));
+      continue;
+    }
+    throw new Error("Unexpected device flow response");
+  }
+}
+
+/**
+ * Validate PAT via GitHub GET /user (server does not exist; token is not stored).
+ * @param {string} token
+ */
+export async function savePat(token) {
+  const user = await githubRestJson("GET", "/user", undefined, token);
+  return { access_token: token, login: user.login, id: user.id, name: user.name };
+}
+
+/**
+ * Open PRs authored by the current user (search API, paginated).
+ * @param {{ repo?: string, page?: number, perPage?: number }} [opts]
+ */
+export async function listMyPulls(opts = {}) {
+  const me = await githubGetViewer();
+  const login = me.login;
+  if (!login) {
+    throw new Error("Could not resolve GitHub login");
+  }
+  let q = `is:pr is:open author:${login}`;
+  if (opts.repo) {
+    const parts = String(opts.repo).split("/").filter(Boolean);
+    if (parts.length === 2) {
+      q = `is:pr is:open repo:${parts[0]}/${parts[1]} author:${login}`;
+    }
+  }
+  const page = opts.page != null ? Math.max(1, opts.page) : 1;
+  const perPage = opts.perPage != null ? Math.min(100, Math.max(1, opts.perPage)) : 30;
+  return githubSearchIssues(q, perPage, page);
+}
+
+/**
+ * All open PRs in a repository (REST list, paginated). Best for picking numbers for `nugit stack add`.
+ * @param {string} owner
+ * @param {string} repo
+ * @param {{ page?: number, perPage?: number }} [opts]
+ */
+export async function listOpenPullsInRepo(owner, repo, opts = {}) {
+  const page = opts.page != null ? Math.max(1, opts.page) : 1;
+  const perPage = opts.perPage != null ? Math.min(100, Math.max(1, opts.perPage)) : 30;
+  const pulls = await githubListOpenPulls(owner, repo, page, perPage);
+  const arr = Array.isArray(pulls) ? pulls : [];
+  return {
+    pulls: arr,
+    page,
+    per_page: perPage,
+    repo_full_name: `${owner}/${repo}`,
+    has_more: arr.length >= perPage
+  };
+}
+
+export async function authMe() {
+  return githubGetViewer();
+}
+
+export async function getRepoMetadata(owner, repo) {
+  return githubGetRepoMetadata(owner, repo);
+}
+
+export async function createPullRequest(owner, repo, fields) {
+  return githubCreatePullRequest(owner, repo, fields);
+}
+
+export async function getGithubContents(owner, repo, filePath, ref) {
+  return githubGetContents(owner, repo, filePath, ref);
+}
+
+export function decodeGithubFileContent(item) {
+  if (!item || item.type !== "file" || item.encoding !== "base64" || !item.content) {
+    return null;
+  }
+  return Buffer.from(item.content.replace(/\s/g, ""), "base64").toString("utf8");
+}
+
+export async function fetchRemoteStackJson(repoFullName, ref) {
+  const [owner, repo] = repoFullName.split("/");
+  if (!owner || !repo) {
+    throw new Error("repoFullName must be owner/repo");
+  }
+  const item = await getGithubContents(owner, repo, ".nugit/stack.json", ref);
+  const text = decodeGithubFileContent(item);
+  if (!text) {
+    throw new Error("Could not read .nugit/stack.json from GitHub");
+  }
+  return JSON.parse(text);
+}
+
+export async function getPull(owner, repo, number) {
+  return githubGetPull(owner, repo, number);
+}
+
+export async function listUserRepos(page = 1) {
+  return githubListUserRepos(page);
+}

package/src/auth-token.js

@@ -0,0 +1,14 @@
+import { readStoredGithubToken } from "./token-store.js";
+
+/**
+ * PAT / OAuth token for GitHub API: env first, then saved device-flow file.
+ * @returns {string}
+ */
+export function resolveGithubToken() {
+  return (
+    process.env.NUGIT_USER_TOKEN ||
+    process.env.STACKPR_USER_TOKEN ||
+    readStoredGithubToken() ||
+    ""
+  );
+}

package/src/cli-output.js

@@ -0,0 +1,228 @@
+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));
+}

package/src/git-info.js

@@ -0,0 +1,60 @@
+import { execSync } from "child_process";
+
+/**
+ * @param {string} gitRoot
+ * @param {string} [remote]
+ * @returns {string | null}
+ */
+export function getGitRemoteUrl(gitRoot, remote = "origin") {
+  try {
+    return execSync(`git remote get-url ${remote}`, {
+      cwd: gitRoot,
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "ignore"]
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Parse owner/repo from common GitHub remote URL shapes.
+ * @param {string | null | undefined} url
+ * @returns {string | null} "owner/repo"
+ */
+export function parseGithubRepoFromRemote(url) {
+  if (!url || typeof url !== "string") {
+    return null;
+  }
+  const u = url.trim();
+  let m = u.match(/^git@github\.com:([^/]+)\/(.+?)(?:\.git)?$/i);
+  if (m) {
+    return `${m[1]}/${m[2]}`;
+  }
+  m = u.match(/^https?:\/\/github\.com\/([^/]+)\/(.+?)(?:\.git)?\/?$/i);
+  if (m) {
+    return `${m[1]}/${m[2]}`;
+  }
+  m = u.match(/^ssh:\/\/git@github\.com\/([^/]+)\/(.+?)(?:\.git)?\/?$/i);
+  if (m) {
+    return `${m[1]}/${m[2]}`;
+  }
+  return null;
+}
+
+/**
+ * @param {string} gitRoot
+ * @param {string} [remote]
+ * @returns {string} owner/repo
+ */
+export function getRepoFullNameFromGitRoot(gitRoot, remote = "origin") {
+  const url = getGitRemoteUrl(gitRoot, remote);
+  const full = parseGithubRepoFromRemote(url);
+  if (!full) {
+    throw new Error(
+      `Could not parse GitHub owner/repo from git remote "${remote}" URL: ${url || "(none)"}. ` +
+        `Use --repo owner/repo or set origin to a github.com remote.`
+    );
+  }
+  return full;
+}

package/src/github-device-flow.js

@@ -0,0 +1,64 @@
+/**
+ * GitHub OAuth device flow (no backend). Requires GITHUB_OAUTH_CLIENT_ID.
+ * @see https://docs.github.com/en/apps/oauth-apps/building-oauth-apps/authorizing-oauth-apps#device-flow
+ */
+
+/**
+ * @param {string} clientId
+ * @param {string} scope space-separated
+ */
+export async function githubDeviceFlowRequestCode(clientId, scope) {
+  const response = await fetch("https://github.com/login/device/code", {
+    method: "POST",
+    headers: {
+      Accept: "application/json",
+      "Content-Type": "application/x-www-form-urlencoded"
+    },
+    body: new URLSearchParams({
+      client_id: clientId,
+      scope
+    })
+  });
+  const text = await response.text();
+  let payload = {};
+  try {
+    payload = text ? JSON.parse(text) : {};
+  } catch {
+    payload = { message: text };
+  }
+  if (!response.ok) {
+    const msg = payload.error_description || payload.error || payload.message || `HTTP ${response.status}`;
+    throw new Error(typeof msg === "string" ? msg : JSON.stringify(payload));
+  }
+  return payload;
+}
+
+/**
+ * @param {string} clientId
+ * @param {string} deviceCode
+ */
+export async function githubDeviceFlowPollAccessToken(clientId, deviceCode) {
+  const response = await fetch("https://github.com/login/oauth/access_token", {
+    method: "POST",
+    headers: {
+      Accept: "application/json",
+      "Content-Type": "application/x-www-form-urlencoded"
+    },
+    body: new URLSearchParams({
+      client_id: clientId,
+      device_code: deviceCode,
+      grant_type: "urn:ietf:params:oauth:grant-type:device_code"
+    })
+  });
+  const text = await response.text();
+  let payload = {};
+  try {
+    payload = text ? JSON.parse(text) : {};
+  } catch {
+    payload = { message: text, error: "parse_error" };
+  }
+  if (!response.ok && !payload.error) {
+    payload.error = `http_${response.status}`;
+  }
+  return payload;
+}