nugit-cli 0.1.0 → 0.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nugit-cli",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "CLI for stacked GitHub PRs (.nugit/stack.json)",
   "type": "module",
   "bin": {

package/src/api-client.js

@@ -159,18 +159,6 @@ export function decodeGithubFileContent(item) {
   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);

package/src/github-rest.js

@@ -245,6 +245,41 @@ export async function githubSearchRepositories(q, perPage = 20, page = 1) {
   return githubRestJson("GET", `/search/repositories?${query.toString()}`);
 }
 
+/**
+ * List branches in a repository (one page).
+ * @param {string} owner
+ * @param {string} repo
+ * @param {number} [page] 1-based
+ * @param {number} [perPage] max 100
+ */
+export async function githubListBranches(owner, repo, page = 1, perPage = 100) {
+  const pp = Math.min(100, Math.max(1, perPage));
+  const p = Math.max(1, page);
+  return githubRestJson(
+    "GET",
+    `/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/branches?page=${p}&per_page=${pp}`
+  );
+}
+
+/**
+ * @param {string} owner
+ * @param {string} repo
+ * @returns {Promise<unknown[]>}
+ */
+export async function githubListAllBranches(owner, repo) {
+  /** @type {unknown[]} */
+  const all = [];
+  let page = 1;
+  for (;;) {
+    const chunk = await githubListBranches(owner, repo, page, 100);
+    if (!Array.isArray(chunk) || chunk.length === 0) break;
+    all.push(...chunk);
+    if (chunk.length < 100) break;
+    page += 1;
+  }
+  return all;
+}
+
 export async function githubSearchIssues(q, perPage = 30, page = 1) {
   const pp = Math.min(100, Math.max(1, perPage));
   const p = Math.max(1, page);

package/src/nugit-config.js

@@ -0,0 +1,84 @@
+/**
+ * Config-related actions for the `nugit config` and `nugit env` commands.
+ * Extracted from the former nugit-start.js.
+ */
+import fs from "fs";
+import path from "path";
+import {
+  expandUserPath,
+  getConfigPath,
+  inferMonorepoRootFromCli,
+  readUserConfig,
+  writeUserConfig,
+  buildStartEnv
+} from "./user-config.js";
+
+/**
+ * @param {object} opts
+ * @param {string} [opts.installRoot]
+ * @param {string} [opts.envFile]
+ * @param {string} [opts.workingDirectory]
+ */
+export function runConfigInit(opts) {
+  const root = path.resolve(expandUserPath(opts.installRoot || inferMonorepoRootFromCli()));
+  const defaultEnv = path.join(root, ".env");
+  const envFile = expandUserPath(opts.envFile || defaultEnv);
+  const cfg = { installRoot: root, envFile };
+  if (opts.workingDirectory) cfg.workingDirectory = expandUserPath(opts.workingDirectory);
+  writeUserConfig(cfg);
+  console.error(`Wrote ${getConfigPath()}`);
+  console.error(`  installRoot: ${root}`);
+  console.error(`  envFile: ${envFile}`);
+  if (!fs.existsSync(envFile)) {
+    console.error("  (env file does not exist yet — create it or run: nugit config set env-file <path>)");
+  }
+  if (cfg.workingDirectory) console.error(`  workingDirectory: ${cfg.workingDirectory}`);
+}
+
+export function runConfigShow() {
+  console.log(JSON.stringify(readUserConfig(), null, 2));
+}
+
+/**
+ * @param {string} key
+ * @param {string} value
+ */
+export function runConfigSet(key, value) {
+  const c = readUserConfig();
+  const k = key.toLowerCase().replace(/_/g, "-");
+  if (k === "install-root") {
+    c.installRoot = path.resolve(expandUserPath(value));
+  } else if (k === "env-file") {
+    c.envFile = expandUserPath(value);
+  } else if (k === "working-directory" || k === "cwd") {
+    c.workingDirectory = expandUserPath(value);
+  } else {
+    throw new Error(`Unknown key "${key}". Use: install-root | env-file | working-directory`);
+  }
+  writeUserConfig(c);
+  console.error(`Updated ${getConfigPath()}`);
+}
+
+/**
+ * @param {"bash" | "fish"} shell
+ */
+export function runEnvExport(shell) {
+  const cfg = readUserConfig();
+  let env;
+  try {
+    env = buildStartEnv(cfg);
+  } catch (e) {
+    console.error(String(e?.message || e));
+    process.exit(1);
+  }
+  const entries = Object.entries(env);
+  if (shell === "fish") {
+    for (const [k, v] of entries) {
+      if (v !== undefined) console.log(`set -gx ${k} ${JSON.stringify(v)};`);
+    }
+  } else {
+    for (const [k, v] of entries) {
+      if (v !== undefined) console.log(`export ${k}=${JSON.stringify(v)}`);
+    }
+  }
+}

package/src/nugit-stack.js

@@ -1,8 +1,8 @@
-import fs from "fs";
-import path from "path";
 import { execSync } from "child_process";
 
-const STACK_REL = path.join(".nugit", "stack.json");
+/**
+ * Core stack document helpers — no file I/O, no .nugit paths.
+ */
 
 export function findGitRoot(cwd = process.cwd()) {
   try {
@@ -17,191 +17,12 @@ export function findGitRoot(cwd = process.cwd()) {
   }
 }
 
-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 parseRepoFullName(s) {
+  const parts = s.split("/").filter(Boolean);
+  if (parts.length !== 2) {
+    throw new Error("repo must be owner/repo");
   }
-}
-
-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");
+  return { owner: parts[0], repo: parts[1] };
 }
 
 /**
@@ -224,86 +45,28 @@ export function createInferredStackDoc(repoFullName, createdBy, prNumbersBottomT
   };
 }
 
-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
+ * Basic validation for a stack document (viewer-side; not strict .nugit format).
+ * @param {unknown} doc
  */
-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";
+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);
   }
-  return {
-    pr_number: pull.number,
-    position,
-    head_branch: head.ref || "",
-    base_branch: base.ref || "",
-    head_sha: head.sha || "",
-    base_sha: base.sha || "",
-    status
-  };
+  return true;
 }