nugit-cli 0.0.1-alpha

package/src/github-pr-social.js

@@ -0,0 +1,126 @@
+/**
+ * GitHub PR/issue comments and reviewers (REST). Uses direct API only.
+ */
+
+import { githubRestJson } from "./github-rest.js";
+
+const PER_PAGE = 100;
+
+/**
+ * @param {string} pathNoQuery path starting with /repos/... without ?
+ */
+async function githubGetAllPages(pathNoQuery) {
+  let page = 1;
+  /** @type {unknown[]} */
+  const out = [];
+  while (true) {
+    const q = `?per_page=${PER_PAGE}&page=${page}`;
+    const chunk = await githubRestJson("GET", `${pathNoQuery}${q}`);
+    if (!Array.isArray(chunk) || chunk.length === 0) {
+      break;
+    }
+    out.push(...chunk);
+    if (chunk.length < PER_PAGE) {
+      break;
+    }
+    page += 1;
+  }
+  return out;
+}
+
+/**
+ * @param {string} owner
+ * @param {string} repo
+ * @param {number} issueNumber same as PR number on GitHub
+ */
+export async function githubListIssueComments(owner, repo, issueNumber) {
+  const o = encodeURIComponent(owner);
+  const r = encodeURIComponent(repo);
+  const n = encodeURIComponent(String(issueNumber));
+  return githubGetAllPages(`/repos/${o}/${r}/issues/${n}/comments`);
+}
+
+/**
+ * Pull review comments (line-linked).
+ * @param {string} owner
+ * @param {string} repo
+ * @param {number} pullNumber
+ */
+export async function githubListPullReviewComments(owner, repo, pullNumber) {
+  const o = encodeURIComponent(owner);
+  const r = encodeURIComponent(repo);
+  const n = encodeURIComponent(String(pullNumber));
+  return githubGetAllPages(`/repos/${o}/${r}/pulls/${n}/comments`);
+}
+
+/**
+ * Single pull review comment by id (REST).
+ * @param {string} owner
+ * @param {string} repo
+ * @param {number} commentId
+ */
+export async function githubGetPullReviewComment(owner, repo, commentId) {
+  const o = encodeURIComponent(owner);
+  const r = encodeURIComponent(repo);
+  const id = encodeURIComponent(String(commentId));
+  return githubRestJson("GET", `/repos/${o}/${r}/pulls/comments/${id}`);
+}
+
+/**
+ * @param {string} owner
+ * @param {string} repo
+ * @param {number} issueNumber
+ * @param {string} body
+ */
+export async function githubPostIssueComment(owner, repo, issueNumber, body) {
+  const o = encodeURIComponent(owner);
+  const r = encodeURIComponent(repo);
+  const n = encodeURIComponent(String(issueNumber));
+  return githubRestJson("POST", `/repos/${o}/${r}/issues/${n}/comments`, { body });
+}
+
+/**
+ * Reply in a review thread.
+ * @param {string} owner
+ * @param {string} repo
+ * @param {number} commentId root review comment id
+ * @param {string} body
+ */
+export async function githubPostPullReviewCommentReply(owner, repo, commentId, body) {
+  const o = encodeURIComponent(owner);
+  const r = encodeURIComponent(repo);
+  const id = encodeURIComponent(String(commentId));
+  return githubRestJson("POST", `/repos/${o}/${r}/pulls/comments/${id}/replies`, { body });
+}
+
+/**
+ * @param {string} owner
+ * @param {string} repo
+ * @param {number} pullNumber
+ * @param {{ reviewers?: string[], team_reviewers?: string[] }} reviewers
+ */
+export async function githubPostRequestedReviewers(owner, repo, pullNumber, reviewers) {
+  const o = encodeURIComponent(owner);
+  const r = encodeURIComponent(repo);
+  const n = encodeURIComponent(String(pullNumber));
+  const payload = {
+    reviewers: reviewers.reviewers || [],
+    team_reviewers: reviewers.team_reviewers || []
+  };
+  return githubRestJson(
+    "POST",
+    `/repos/${o}/${r}/pulls/${n}/requested_reviewers`,
+    payload
+  );
+}
+
+/**
+ * List users assignable in this repo (good reviewer candidates).
+ * @param {string} owner
+ * @param {string} repo
+ */
+export async function githubListAssignableUsers(owner, repo) {
+  const o = encodeURIComponent(owner);
+  const r = encodeURIComponent(repo);
+  return githubGetAllPages(`/repos/${o}/${r}/assignees`);
+}

package/src/github-rest.js

@@ -0,0 +1,212 @@
+/**
+ * Call GitHub's REST API directly (no StackPR/nugit FastAPI proxy).
+ * Direct GitHub REST for the nugit CLI (PAT / OAuth token).
+ */
+
+import { resolveGithubToken } from "./auth-token.js";
+
+const GITHUB_API_BASE = (
+  process.env.GITHUB_API_URL || "https://api.github.com"
+).replace(/\/$/, "");
+
+export function getGithubPat() {
+  return resolveGithubToken();
+}
+
+/** @deprecated All GitHub calls are direct; proxy env vars are ignored. */
+export function useDirectGithub() {
+  return true;
+}
+
+/**
+ * @param {string} method
+ * @param {string} path API path starting with /
+ * @param {Record<string, unknown> | undefined} jsonBody
+ * @param {string} [tokenOverride] PAT for this call only (e.g. `nugit auth pat --token`)
+ */
+export async function githubRestJson(method, path, jsonBody, tokenOverride) {
+  const token = tokenOverride ?? getGithubPat();
+  if (!token) {
+    throw new Error(
+      "Set NUGIT_USER_TOKEN or STACKPR_USER_TOKEN (GitHub PAT or OAuth token with repo scope)"
+    );
+  }
+  const headers = {
+    Authorization: `Bearer ${token}`,
+    Accept: "application/vnd.github+json",
+    "X-GitHub-Api-Version": "2022-11-28"
+  };
+  if (jsonBody !== undefined) {
+    headers["Content-Type"] = "application/json";
+  }
+  const response = await fetch(`${GITHUB_API_BASE}${path}`, {
+    method,
+    headers,
+    body: jsonBody !== undefined ? JSON.stringify(jsonBody) : undefined
+  });
+  const text = await response.text();
+  let payload = {};
+  try {
+    payload = text ? JSON.parse(text) : {};
+  } catch {
+    payload = { message: text };
+  }
+  if (!response.ok) {
+    const msg =
+      payload.message ||
+      payload.detail ||
+      `GitHub API ${response.status}: ${response.statusText}`;
+    throw new Error(typeof msg === "string" ? msg : JSON.stringify(payload));
+  }
+  return payload;
+}
+
+export async function githubGetViewer() {
+  return githubRestJson("GET", "/user");
+}
+
+/**
+ * @param {string} owner
+ * @param {string} repo
+ */
+export async function githubGetRepoMetadata(owner, repo) {
+  return githubRestJson(
+    "GET",
+    `/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}`
+  );
+}
+
+/**
+ * @param {string} owner
+ * @param {string} repo
+ * @param {string} filePath e.g. ".nugit/stack.json"
+ * @param {string} [ref]
+ */
+export async function githubGetContents(owner, repo, filePath, ref) {
+  const pathSeg = filePath
+    .split("/")
+    .filter(Boolean)
+    .map(encodeURIComponent)
+    .join("/");
+  const q = ref ? `?ref=${encodeURIComponent(ref)}` : "";
+  return githubRestJson(
+    "GET",
+    `/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/contents/${pathSeg}${q}`
+  );
+}
+
+/**
+ * @param {string} owner
+ * @param {string} repo
+ * @param {number} number
+ */
+export async function githubGetPull(owner, repo, number) {
+  return githubRestJson(
+    "GET",
+    `/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/pulls/${number}`
+  );
+}
+
+/**
+ * List changed files for a pull request (single page up to 100 files).
+ * @param {string} owner
+ * @param {string} repo
+ * @param {number} number
+ */
+export async function githubListPullFiles(owner, repo, number) {
+  return githubRestJson(
+    "GET",
+    `/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/pulls/${encodeURIComponent(
+      String(number)
+    )}/files?per_page=100&page=1`
+  );
+}
+
+/**
+ * @param {string} owner
+ * @param {string} repo
+ * @param {{ title: string, head: string, base: string, body?: string, draft?: boolean }} fields
+ */
+export async function githubCreatePullRequest(owner, repo, fields) {
+  const payload = {
+    title: fields.title,
+    head: fields.head,
+    base: fields.base,
+    draft: !!fields.draft
+  };
+  if (fields.body) {
+    payload.body = fields.body;
+  }
+  return githubRestJson(
+    "POST",
+    `/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/pulls`,
+    payload
+  );
+}
+
+/**
+ * @param {number} page
+ */
+export async function githubListUserRepos(page = 1) {
+  return githubRestJson(
+    "GET",
+    `/user/repos?page=${encodeURIComponent(String(page))}&per_page=30`
+  );
+}
+
+/**
+ * Search issues (includes PRs). `q` is GitHub search query syntax.
+ * @param {string} q
+ * @param {number} [perPage] max 100
+ * @param {number} [page] 1-based
+ */
+export async function githubSearchIssues(q, perPage = 30, page = 1) {
+  const pp = Math.min(100, Math.max(1, perPage));
+  const p = Math.max(1, page);
+  const query = new URLSearchParams({
+    q,
+    per_page: String(pp),
+    page: String(p),
+    sort: "updated",
+    order: "desc"
+  });
+  return githubRestJson("GET", `/search/issues?${query.toString()}`);
+}
+
+/**
+ * Open pull requests in a repository (paginated). Prefer this over search for “all open PRs”.
+ * @param {string} owner
+ * @param {string} repo
+ * @param {number} [page] 1-based
+ * @param {number} [perPage] max 100
+ */
+export async function githubListOpenPulls(owner, repo, page = 1, perPage = 30) {
+  const pp = Math.min(100, Math.max(1, perPage));
+  const p = Math.max(1, page);
+  return githubRestJson(
+    "GET",
+    `/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/pulls?state=open&page=${p}&per_page=${pp}`
+  );
+}
+
+/**
+ * @param {string} owner
+ * @param {string} repo
+ * @param {string} path file path
+ * @param {string} ref branch or sha
+ */
+export async function githubGetBlobText(owner, repo, path, ref) {
+  const pathSeg = path
+    .split("/")
+    .filter(Boolean)
+    .map(encodeURIComponent)
+    .join("/");
+  const item = await githubRestJson(
+    "GET",
+    `/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/contents/${pathSeg}?ref=${encodeURIComponent(ref)}`
+  );
+  if (!item || item.type !== "file" || item.encoding !== "base64" || !item.content) {
+    return null;
+  }
+  return Buffer.from(String(item.content).replace(/\s/g, ""), "base64").toString("utf8");
+}

package/src/nugit-stack.js

@@ -0,0 +1,289 @@
+import fs from "fs";
+import path from "path";
+import { execSync } from "child_process";
+
+const STACK_REL = path.join(".nugit", "stack.json");
+
+export function findGitRoot(cwd = process.cwd()) {
+  try {
+    const out = execSync("git rev-parse --show-toplevel", {
+      cwd,
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "ignore"]
+    }).trim();
+    return out || null;
+  } catch {
+    return null;
+  }
+}
+
+export function stackJsonPath(root) {
+  return path.join(root, STACK_REL);
+}
+
+export function readStackFile(root) {
+  const p = stackJsonPath(root);
+  if (!fs.existsSync(p)) {
+    return null;
+  }
+  const raw = fs.readFileSync(p, "utf8");
+  return JSON.parse(raw);
+}
+
+export function validateStackDoc(doc) {
+  if (!doc || typeof doc !== "object") {
+    throw new Error("Invalid stack document");
+  }
+  if (doc.version !== 1) {
+    throw new Error("version must be 1");
+  }
+  if (!doc.repo_full_name || typeof doc.repo_full_name !== "string") {
+    throw new Error("repo_full_name is required");
+  }
+  if (!doc.created_by || typeof doc.created_by !== "string") {
+    throw new Error("created_by is required");
+  }
+  if (!Array.isArray(doc.prs)) {
+    throw new Error("prs must be an array");
+  }
+  const seenN = new Set();
+  const seenP = new Set();
+  for (let i = 0; i < doc.prs.length; i++) {
+    const pr = doc.prs[i];
+    if (!pr || typeof pr !== "object") {
+      throw new Error(`prs[${i}] invalid`);
+    }
+    const n = pr.pr_number;
+    const pos = pr.position;
+    if (typeof n !== "number" || typeof pos !== "number") {
+      throw new Error(`prs[${i}]: pr_number and position required`);
+    }
+    if (seenN.has(n)) {
+      throw new Error(`duplicate pr_number ${n}`);
+    }
+    if (seenP.has(pos)) {
+      throw new Error(`duplicate position ${pos}`);
+    }
+    seenN.add(n);
+    seenP.add(pos);
+  }
+  validateOptionalLayer(doc);
+  return true;
+}
+
+/**
+ * @param {unknown} p
+ * @param {string} label
+ * @param {boolean} allowBranch
+ */
+function validateLayerPointer(p, label, allowBranch) {
+  if (p == null || typeof p !== "object") {
+    throw new Error(`${label} must be an object`);
+  }
+  const o = /** @type {Record<string, unknown>} */ (p);
+  const t = o.type;
+  if (t === "branch") {
+    if (!allowBranch) {
+      throw new Error(`${label}: type "branch" not allowed here`);
+    }
+    if (typeof o.ref !== "string") {
+      throw new Error(`${label}: branch ref must be a string`);
+    }
+    return;
+  }
+  if (t === "stack_pr") {
+    if (typeof o.pr_number !== "number" || !Number.isInteger(o.pr_number) || o.pr_number < 1) {
+      throw new Error(`${label}: stack_pr pr_number invalid`);
+    }
+    if (typeof o.head_branch !== "string") {
+      throw new Error(`${label}: stack_pr head_branch must be a string`);
+    }
+    return;
+  }
+  throw new Error(`${label}: type must be "branch" or "stack_pr"`);
+}
+
+/**
+ * @param {unknown} tip
+ */
+function validateLayerTip(tip) {
+  if (tip == null || typeof tip !== "object") {
+    throw new Error("layer.tip must be an object when present");
+  }
+  const t = /** @type {Record<string, unknown>} */ (tip);
+  if (typeof t.pr_number !== "number" || !Number.isInteger(t.pr_number) || t.pr_number < 1) {
+    throw new Error("layer.tip.pr_number must be a positive integer");
+  }
+  if (typeof t.head_branch !== "string") {
+    throw new Error("layer.tip.head_branch must be a string");
+  }
+}
+
+/**
+ * @param {unknown} layer
+ * @param {number} prsLength
+ * @param {unknown[]} [prs] entries for prefix / position checks
+ */
+export function validateLayerShape(layer, prsLength, prs) {
+  if (layer == null || typeof layer !== "object") {
+    throw new Error("layer must be an object");
+  }
+  const L = /** @type {Record<string, unknown>} */ (layer);
+  if (typeof L.position !== "number" || !Number.isInteger(L.position) || L.position < 0) {
+    throw new Error("layer.position must be a non-negative integer");
+  }
+  if (typeof L.stack_size !== "number" || !Number.isInteger(L.stack_size) || L.stack_size < 1) {
+    throw new Error("layer.stack_size must be a positive integer");
+  }
+  const hasTip = "tip" in L && L.tip !== undefined && L.tip !== null;
+  if (hasTip) {
+    validateLayerTip(L.tip);
+    if (L.stack_size < prsLength) {
+      throw new Error(`layer.stack_size (${L.stack_size}) must be >= prs.length (${prsLength})`);
+    }
+    if (prsLength !== L.position + 1) {
+      throw new Error(
+        `with layer.tip, prs must be a bottom-up prefix: prs.length (${prsLength}) === layer.position + 1 (${L.position + 1})`
+      );
+    }
+    if (prs && Array.isArray(prs) && prs.length > 0) {
+      const sorted = [...prs].sort(
+        (a, b) =>
+          (/** @type {{ position?: number }} */ (a).position ?? 0) -
+          (/** @type {{ position?: number }} */ (b).position ?? 0)
+      );
+      const last = sorted[sorted.length - 1];
+      const lp = last && typeof last === "object" ? /** @type {{ position?: number }} */ (last).position : undefined;
+      if (lp !== L.position) {
+        throw new Error("last pr in prs must have position === layer.position");
+      }
+      const want = new Set();
+      for (let i = 0; i <= L.position; i++) {
+        want.add(i);
+      }
+      const have = new Set(sorted.map((p) => (p && typeof p === "object" ? p.position : -1)));
+      if (want.size !== have.size || [...want].some((x) => !have.has(x))) {
+        throw new Error("prs positions must be contiguous 0..layer.position");
+      }
+    }
+  } else if (L.stack_size !== prsLength) {
+    throw new Error(
+      `without layer.tip, layer.stack_size (${L.stack_size}) must equal prs.length (${prsLength})`
+    );
+  }
+  validateLayerPointer(L.below, "layer.below", true);
+  if (L.above !== null) {
+    validateLayerPointer(L.above, "layer.above", false);
+  }
+}
+
+/**
+ * @param {Record<string, unknown>} doc
+ */
+export function validateOptionalLayer(doc) {
+  if (!("layer" in doc) || doc.layer === undefined) {
+    return;
+  }
+  if (!Array.isArray(doc.prs)) {
+    return;
+  }
+  validateLayerShape(doc.layer, doc.prs.length, doc.prs);
+  const L = /** @type {Record<string, unknown>} */ (doc.layer);
+  const positions = new Set(
+    doc.prs.map((p) => (p && typeof p === "object" ? /** @type {{ position?: number }} */ (p).position : undefined))
+  );
+  if (!positions.has(L.position)) {
+    throw new Error("layer.position must match one of prs[].position values");
+  }
+}
+
+export function writeStackFile(root, doc) {
+  validateStackDoc(doc);
+  const dir = path.join(root, ".nugit");
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(stackJsonPath(root), JSON.stringify(doc, null, 2) + "\n");
+}
+
+export function createInitialStackDoc(repoFullName, createdBy) {
+  return {
+    version: 1,
+    repo_full_name: repoFullName,
+    created_by: createdBy,
+    prs: [],
+    resolution_contexts: []
+  };
+}
+
+export function parseRepoFullName(s) {
+  const parts = s.split("/").filter(Boolean);
+  if (parts.length !== 2) {
+    throw new Error("repo must be owner/repo");
+  }
+  return { owner: parts[0], repo: parts[1] };
+}
+
+/** Next position after current max, or 0 if empty. */
+export function nextStackPosition(prs) {
+  if (!prs || !prs.length) {
+    return 0;
+  }
+  return Math.max(...prs.map((p) => p.position)) + 1;
+}
+
+/**
+ * Normalize `nugit stack add --pr` values (variadic and/or comma-separated).
+ * @param {string | string[] | undefined} optsPr
+ * @returns {number[]}
+ */
+export function parseStackAddPrNumbers(optsPr) {
+  const raw = optsPr == null ? [] : Array.isArray(optsPr) ? optsPr : [optsPr];
+  const tokens = [];
+  for (const r of raw) {
+    for (const part of String(r).split(/[\s,]+/)) {
+      const t = part.trim();
+      if (t) {
+        tokens.push(t);
+      }
+    }
+  }
+  if (tokens.length === 0) {
+    throw new Error("Pass at least one PR number: --pr <n> [n...]");
+  }
+  const nums = tokens.map((t) => Number.parseInt(t, 10));
+  for (let i = 0; i < nums.length; i++) {
+    if (!Number.isFinite(nums[i]) || nums[i] < 1) {
+      throw new Error(`Invalid PR number: ${tokens[i]}`);
+    }
+  }
+  const seen = new Set();
+  for (const n of nums) {
+    if (seen.has(n)) {
+      throw new Error(`Duplicate PR #${n} in --pr list`);
+    }
+    seen.add(n);
+  }
+  return nums;
+}
+
+/**
+ * Build a stack PR entry from GitHub GET /pulls/{n} JSON.
+ * @param {Record<string, unknown>} pull
+ * @param {number} position
+ */
+export function stackEntryFromGithubPull(pull, position) {
+  const head = pull.head && typeof pull.head === "object" ? pull.head : {};
+  const base = pull.base && typeof pull.base === "object" ? pull.base : {};
+  let status = "open";
+  if (pull.state === "closed") {
+    status = pull.merged ? "merged" : "closed";
+  }
+  return {
+    pr_number: pull.number,
+    position,
+    head_branch: head.ref || "",
+    base_branch: base.ref || "",
+    head_sha: head.sha || "",
+    base_sha: base.sha || "",
+    status
+  };
+}