gh-stack 0.7.1 → 0.10.0

package/src/lib/chain.ts

@@ -4,7 +4,7 @@
 // auto-create/register a stack from a bare set of local branches so the
 // end state is always stack registered + branches pushed + PRs created).
 import * as git from "./git.ts";
-import { findStackForBranch } from "./metadata.ts";
+import { findStackForBranch, getOrderedBranches, stackBase } from "./metadata.ts";
 import type { StackMetadata, Branch } from "../types.ts";
 
 /**
@@ -55,7 +55,8 @@ export async function detectBranchChain(currentBranch: string, trunk: string): P
 
 export interface StackResolution {
   stackName: string;
-  chain: string[]; // trunk→current order
+  base: string; // effective base of the resulting stack (for display)
+  chain: string[]; // resulting stack's branches, base→tip (for display)
   created: boolean; // true if a brand-new stack was created
   addedBranches: string[]; // branches newly registered into the stack
 }
@@ -67,74 +68,106 @@ export interface StackResolution {
  * effects).
  *
  * Behavior:
- *   - Detects the chain trunk→current.
- *   - If any branch in the chain already belongs to a stack, reconciles
- *     into that existing stack (adds only the missing branches).
- *   - Otherwise creates a new stack named after the current branch
- *     (auto-suffixed if that name is taken).
- *   - Registers missing branches with correct parent links (chain[0]'s
- *     parent is trunk; each subsequent branch's parent is the prior one).
+ *   - Detects the ancestry chain trunk→current.
+ *   - Finds the NEAREST tracked ancestor of `branch`. If one exists, adopts
+ *     the untracked tail above it into that ancestor's stack — stopping at
+ *     that stack's boundary. This is what lets a stack with a non-main base
+ *     (one stacked on top of another stack) keep accepting new branches: the
+ *     walk never crosses into the parent stack, so it can't mistake a clean
+ *     stacked-on-a-stack layout for an ambiguous multi-stack chain. (#11)
+ *   - Otherwise creates a new stack rooted at `trunk`, named after the current
+ *     branch (auto-suffixed if that name is taken). (#7)
  *
- * Throws if the chain spans more than one existing stack (ambiguous).
+ * Throws only if the untracked tail genuinely interleaves another stack's
+ * branches — which a clean stacked-on-a-stack layout never does.
  */
 export async function resolveOrCreateStack(
   meta: StackMetadata,
   branch: string,
   trunk: string,
 ): Promise<StackResolution> {
-  const chain = await detectBranchChain(branch, trunk);
-
-  // Which existing stacks (if any) already own branches in this chain?
-  const owningStacks = new Set<string>();
-  for (const b of chain) {
-    const owner = findStackForBranch(meta, b);
-    if (owner) owningStacks.add(owner);
+  const fullChain = await detectBranchChain(branch, trunk); // trunk→current
+
+  // Walk from just below `branch` downward; the first tracked ancestor is the
+  // attachment point. Everything above it (up to `branch`) is the untracked
+  // tail we adopt — by definition not tracked, since this is the *nearest*
+  // tracked ancestor.
+  let anchorIndex = -1;
+  let anchorStack: string | null = null;
+  for (let i = fullChain.length - 2; i >= 0; i--) {
+    const owner = findStackForBranch(meta, fullChain[i]!);
+    if (owner) {
+      anchorIndex = i;
+      anchorStack = owner;
+      break;
+    }
   }
 
-  if (owningStacks.size > 1) {
-    throw new Error(
-      `Branches in this chain span multiple stacks (${[...owningStacks].join(
-        ", ",
-      )}). Resolve manually with gh-stack init / delete.`,
-    );
-  }
+  if (anchorStack) {
+    const stack = meta.stacks[anchorStack]!;
+    const tail = fullChain.slice(anchorIndex); // [anchor, ...untracked..., current]
+    const addedBranches: string[] = [];
+
+    for (let i = 1; i < tail.length; i++) {
+      const name = tail[i]!;
+      const parent = tail[i - 1]!;
+
+      // Safety net: a clean stacked-on-a-stack layout never trips this, but if
+      // the tail somehow already belongs to a different stack, it's genuinely
+      // ambiguous — refuse rather than silently move branches between stacks.
+      const existingOwner = findStackForBranch(meta, name);
+      if (existingOwner && existingOwner !== anchorStack) {
+        throw new Error(
+          `Branches in this chain span multiple stacks (${anchorStack}, ${existingOwner}). Resolve manually with gh-stack init / delete.`,
+        );
+      }
 
-  let stackName: string;
-  let created = false;
-
-  if (owningStacks.size === 1) {
-    // Reconcile into the existing stack
-    stackName = [...owningStacks][0]!;
-  } else {
-    // Create a new stack named after the current branch (auto-suffix on clash)
-    stackName = branch;
-    let n = 2;
-    while (meta.stacks[stackName]) {
-      stackName = `${branch}-${n++}`;
+      if (stack.branches[name]) continue; // already tracked — leave as-is
+      stack.branches[name] = { parent };
+      stack.last_branch = name;
+      addedBranches.push(name);
     }
-    meta.stacks[stackName] = {
-      description: "",
-      last_branch: null,
-      branches: {},
+
+    return {
+      stackName: anchorStack,
+      base: stackBase(stack),
+      chain: getOrderedBranches(stack),
+      created: false,
+      addedBranches,
     };
-    meta.current_stack = stackName;
-    created = true;
   }
 
+  // No tracked ancestor — create a new stack rooted at trunk.
+  let stackName = branch;
+  let n = 2;
+  while (meta.stacks[stackName]) {
+    stackName = `${branch}-${n++}`;
+  }
+  meta.stacks[stackName] = {
+    description: "",
+    last_branch: null,
+    branches: {},
+    base: trunk,
+  };
+  meta.current_stack = stackName;
+
   const stack = meta.stacks[stackName]!;
   const addedBranches: string[] = [];
-
-  // Register missing branches with correct parent links.
-  for (let i = 0; i < chain.length; i++) {
-    const name = chain[i]!;
-    if (stack.branches[name]) continue; // already tracked — leave as-is
-
-    const parent = i === 0 ? trunk : chain[i - 1]!;
+  for (let i = 0; i < fullChain.length; i++) {
+    const name = fullChain[i]!;
+    if (stack.branches[name]) continue;
+    const parent = i === 0 ? trunk : fullChain[i - 1]!;
     const branchData: Branch = { parent };
     stack.branches[name] = branchData;
     stack.last_branch = name;
     addedBranches.push(name);
   }
 
-  return { stackName, chain, created, addedBranches };
+  return {
+    stackName,
+    base: trunk,
+    chain: getOrderedBranches(stack),
+    created: true,
+    addedBranches,
+  };
 }

package/src/lib/git.ts

@@ -138,6 +138,17 @@ export async function forcePushWithLease(branch?: string): Promise<boolean> {
   }
 }
 
+/**
+ * Push a stacked branch's ref to origin, setting upstream and using
+ * force-with-lease. Works whether or not the remote branch already exists
+ * (creates it on first push) — so restack can reconcile every ref, including
+ * a branch that was never pushed before.
+ */
+export async function pushStackedBranch(branch: string): Promise<boolean> {
+  const { exitCode } = await $`git push -u --force-with-lease origin ${branch}`.nothrow().quiet();
+  return exitCode === 0;
+}
+
 /**
  * Check if a branch exists on the remote.
  */
@@ -168,6 +179,16 @@ export async function deleteLocalBranch(branch: string): Promise<boolean> {
   return exitCode === 0;
 }
 
+/**
+ * Rename a local branch (`git branch -m`). Git moves the whole `branch.<old>`
+ * config section to `branch.<new>`, so gh-stack membership rides along for free.
+ * Returns false if the rename failed (e.g. the new name already exists).
+ */
+export async function renameBranch(oldName: string, newName: string): Promise<boolean> {
+  const { exitCode } = await $`git branch -m ${oldName} ${newName}`.nothrow().quiet();
+  return exitCode === 0;
+}
+
 /**
  * Delete a branch on the remote (origin). Returns false on failure.
  */

package/src/lib/github.ts

@@ -2,6 +2,30 @@
 import { $ } from "bun";
 import type { PrInfo, PrStatus } from "../types.ts";
 
+let cachedNwo: string | null | undefined; // undefined = not yet looked up
+
+/**
+ * Get the repository's `owner/name` (once, cached for the process). Used to
+ * construct PR URLs locally — `https://github.com/<nwo>/pull/<n>` — so the
+ * stack visualization doesn't need a per-PR API call just for links.
+ * Returns null if it can't be resolved (links degrade to plain `#<n>`).
+ */
+export async function getRepoNwo(): Promise<string | null> {
+  if (cachedNwo !== undefined) return cachedNwo;
+  try {
+    const out = (await $`gh repo view --json nameWithOwner --jq .nameWithOwner`.text()).trim();
+    cachedNwo = out.length > 0 ? out : null;
+  } catch {
+    cachedNwo = null;
+  }
+  return cachedNwo;
+}
+
+/** Build a PR URL from a cached nwo (or null if nwo is unknown). */
+export function prUrlFor(nwo: string | null, prNumber: number): string | null {
+  return nwo ? `https://github.com/${nwo}/pull/${prNumber}` : null;
+}
+
 /**
  * Get PR number for a branch (auto-detect via gh).
  * Returns null if no PR exists.
@@ -126,19 +150,63 @@ export async function getPrBody(prNumber: number): Promise<string | null> {
 
 /**
  * Get the merge state of a PR.
- * Returns { state, mergeable, mergeStateStatus }.
+ * Returns { state, mergeable, mergeStateStatus, headRefName, headRefOid }.
+ *
+ * NOTE: `mergeable`/`mergeStateStatus` are computed against the PR's *recorded*
+ * head (`headRefOid`), which GitHub occasionally fails to advance after a child
+ * squash-merge lands on this branch. Compare `headRefOid` against the live ref
+ * (`getBranchRefSha`) to detect that staleness — see `merge.ts`.
  */
-export async function getPrMergeState(
-  prNumber: number,
-): Promise<{ state: string; mergeable: string; mergeStateStatus: string } | null> {
+export async function getPrMergeState(prNumber: number): Promise<{
+  state: string;
+  mergeable: string;
+  mergeStateStatus: string;
+  headRefName: string;
+  headRefOid: string;
+} | null> {
   try {
-    const result = await $`gh pr view ${prNumber} --json state,mergeable,mergeStateStatus`.text();
+    const result =
+      await $`gh pr view ${prNumber} --json state,mergeable,mergeStateStatus,headRefName,headRefOid`.text();
     return JSON.parse(result.trim());
   } catch {
     return null;
   }
 }
 
+/**
+ * Resolve the live SHA of a branch ref on the remote (`origin`), independent of
+ * any PR's cached head. Returns null if the ref can't be resolved.
+ */
+export async function getBranchRefSha(branch: string): Promise<string | null> {
+  const nwo = await getRepoNwo();
+  if (!nwo) return null;
+  try {
+    const sha = (
+      await $`gh api repos/${nwo}/git/ref/heads/${branch} --jq .object.sha`.text()
+    ).trim();
+    return sha.length > 0 ? sha : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Force GitHub to re-read a PR's head branch by closing and immediately
+ * reopening it. Used when the PR's recorded `headRefOid` is stuck behind the
+ * live branch tip (a child squash-merge moved the branch but GitHub missed the
+ * head-sync), which makes `mergePullRequest` reject a "Head branch is out of
+ * date" even though every status read says the PR is clean.
+ */
+export async function resyncPrHead(prNumber: number): Promise<boolean> {
+  try {
+    await $`gh pr close ${prNumber}`.quiet();
+    await $`gh pr reopen ${prNumber}`.quiet();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 /**
  * Close a PR with a comment.
  */