gh-stack 0.19.4 → 0.19.6

package/README.md

@@ -92,6 +92,9 @@ add [branch] [--parent <branch>]
     stack — without pushing or opening a PR. Walks local ancestry: if the
     branch sits on top of an existing stack it's adopted into it (parent
     auto-detected); otherwise a new stack is created from the chain.
+    A PR that gh-stack already recorded for a branch in git config (in
+    another worktree of the repo) is kept, so a stack submitted from a
+    worktree can be tracked in the main checkout and merged from there.
 
     --parent <branch>: stack it directly on <branch> (which it must
     already be based on), tracking <branch> first if needed. Use this
@@ -650,6 +653,7 @@ per-stack files plus git-native branch config, rather than a single JSON blob:
   deleted/<stack>.json         tombstones (recoverable)
   snapshots/<ts>__<stack>.json append-only, retained per-stack
   restack-state.json           the last restack/sync/join run: resume point + action log
+  push-failure.log             full output of the last refused push (a failing pre-push hook, say)
 ```
 
 A single `active/<stack>.json` looks like:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gh-stack",
-  "version": "0.19.4",
+  "version": "0.19.6",
   "description": "Stacked PR manager for squash-merge workflows",
   "author": "Kiliman <kiliman@gmail.com>",
   "license": "MIT",

package/src/commands/add.ts

@@ -38,7 +38,8 @@ OPTIONS
                      its stack and has no PR (e.g. a mistaken ${"`"}init${"`"} at trunk).
 
 Network-free — nothing is pushed and no PR is opened. Run ${"`"}gh-stack submit${"`"} when
-you're ready to publish.
+you're ready to publish. A PR already recorded for the branch in git config
+(by gh-stack in another worktree of this repo) is kept.
 
 EXAMPLES
   gh-stack add                    Track the current branch

package/src/lib/chain.ts

@@ -4,9 +4,25 @@
 // 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 { allBranchMemberships, type BranchMembership } from "./branch-config.ts";
 import { findStackForBranch, getOrderedBranches, stackBase } from "./metadata.ts";
 import type { StackMetadata, Branch } from "../types.ts";
 
+/**
+ * A new stack entry for a branch, keeping the PR number and id already
+ * recorded for it in git config. Git config is shared by every worktree of a
+ * repo, but stack files are not: a branch submitted in one worktree and then
+ * tracked in another (the dependency sweep's handoff) would otherwise lose its
+ * PR, and `sync` and `merge --base` would not see it merge.
+ */
+function newBranchEntry(parent: string, recorded: BranchMembership | undefined): Branch {
+  return {
+    parent,
+    ...(recorded?.pr != null && { pr: recorded.pr }),
+    ...(recorded?.id && { id: recorded.id }),
+  };
+}
+
 /**
  * Detect a chain of branches from trunk to the current branch.
  *
@@ -107,6 +123,7 @@ export async function resolveOrCreateStack(
   trunk: string,
 ): Promise<StackResolution> {
   const fullChain = await detectBranchChain(branch, trunk); // trunk→current
+  const recorded = await allBranchMemberships();
 
   // Walk from just below `branch` downward; the first tracked ancestor is the
   // attachment point. Everything above it (up to `branch`) is the untracked
@@ -143,7 +160,7 @@ export async function resolveOrCreateStack(
       }
 
       if (stack.branches[name]) continue; // already tracked — leave as-is
-      stack.branches[name] = { parent };
+      stack.branches[name] = newBranchEntry(parent, recorded.get(name));
       stack.last_branch = name;
       addedBranches.push(name);
     }
@@ -177,8 +194,7 @@ export async function resolveOrCreateStack(
     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.branches[name] = newBranchEntry(parent, recorded.get(name));
     stack.last_branch = name;
     addedBranches.push(name);
   }

package/src/lib/git.ts

@@ -1,6 +1,7 @@
 // Git command helpers using Bun's shell API
 import { $ } from "bun";
 import { createHash } from "node:crypto";
+import { mkdir } from "node:fs/promises";
 
 export const STACK_SYNC_TAG_PREFIX = "stack-sync-base";
 export const STACK_SYNC_TAG_GLOB = `${STACK_SYNC_TAG_PREFIX}-*`;
@@ -153,9 +154,18 @@ export type PushResult =
        * moved since the last fetch. `rejected`: anything else.
        */
       reason: "not-integrated" | "stale-lease" | "rejected";
-      stderr: string;
+      /**
+       * git's stdout and stderr together. A local pre-push hook's output lands
+       * on either, depending on the git version (stdout as of git 2.56).
+       */
+      output: string;
+      /** Where a `rejected` push's full output was saved, when that worked. */
+      logFile?: string;
     };
 
+/** How many lines of a failed push's output `pushFailureHint` shows. */
+const PUSH_OUTPUT_TAIL = 20;
+
 /**
  * The one way gh-stack force-pushes a branch (restack, sync, merge's advance,
  * submit, join). Sets upstream, and works whether or not the branch exists on
@@ -179,17 +189,35 @@ export async function forcePushWithLease(
   const lease = opts.expect
     ? `--force-with-lease=refs/heads/${branch}:${opts.expect}`
     : "--force-with-lease";
-  const { exitCode, stderr } = await $`git push -u ${lease} --force-if-includes origin ${branch}`
-    .nothrow()
-    .quiet();
+  const { exitCode, stdout } =
+    await $`git push -u ${lease} --force-if-includes origin ${branch} 2>&1`.nothrow().quiet();
   if (exitCode === 0) return { ok: true };
-  const text = stderr.toString();
-  const reason = text.includes("remote ref updated since checkout")
+  const output = stdout.toString();
+  const reason = output.includes("remote ref updated since checkout")
     ? "not-integrated"
-    : text.includes("stale info")
+    : output.includes("stale info")
       ? "stale-lease"
       : "rejected";
-  return { ok: false, reason, stderr: text };
+  if (reason !== "rejected") return { ok: false, reason, output };
+  return { ok: false, reason, output, logFile: await savePushFailure(output) };
+}
+
+/**
+ * Save a failed push's full output to `.git/.gh-stack/push-failure.log`. A
+ * failing pre-push hook (a test suite, say) can print a thousand lines, so
+ * `pushFailureHint` shows only the end and points here for the rest. Best
+ * effort: a failed write returns undefined.
+ */
+async function savePushFailure(text: string): Promise<string | undefined> {
+  try {
+    const dir = `${await gitDir()}/.gh-stack`;
+    await mkdir(dir, { recursive: true });
+    const file = `${dir}/push-failure.log`;
+    await Bun.write(file, text);
+    return file;
+  } catch {
+    return undefined;
+  }
 }
 
 /** Why a force-push was refused, and what to do, in gh-stack terms (plain lines). */
@@ -208,13 +236,19 @@ export function pushFailureHint(branch: string, result: PushResult): string[] {
         `origin/${branch} moved since your last fetch, so the lease refused.`,
         `Look at what's there first: git fetch origin ${branch} && git log ${branch}..origin/${branch}`,
       ];
-    default:
-      return [
-        result.stderr
-          .trim()
-          .split("\n")
-          .find((l) => l.includes("rejected") || l.startsWith("error")) ?? result.stderr.trim(),
-      ];
+    default: {
+      // Show the end of git's output, not just its "failed to push" line: a
+      // local pre-push hook prints its reason above that line, and a remote
+      // rejection names the rule that refused the push.
+      const lines = result.output.split("\n").filter((l) => l.trim() !== "");
+      const tail = lines.slice(-PUSH_OUTPUT_TAIL);
+      const hint = ["git push failed. The end of its output (a pre-push hook prints here too):"];
+      hint.push(...tail.map((l) => `  ${l.trimEnd()}`));
+      if (result.logFile && lines.length > tail.length) {
+        hint.push(`Full output (${lines.length} lines): ${result.logFile}`);
+      }
+      return hint;
+    }
   }
 }
 

package/src/lib/paths.ts

@@ -7,6 +7,7 @@
 //     deleted/<stack>.json         tombstones (recoverable)
 //     snapshots/<ts>__<stack>.json append-only pre-operation branch tips
 //     restack-state.json           last restack/sync/join run: resume point + action log
+//     push-failure.log             full output of the last rejected push (git.forcePushWithLease)
 //
 // Everything lives inside `.git/` and is never committed — gh-stack is a
 // single-developer tool, so there's no need to share metadata across clones.

package/src/lib/using-gh-stack.md

@@ -129,6 +129,11 @@ This resolves the catch-22 where `sync`/`restack` said "not in any stack" for a
 tip you hadn't submitted yet. (`submit` still auto-tracks too — `add` is just the
 no-publish path.)
 
+**Handing a stack over from another worktree.** Stack files are per worktree,
+but the PR numbers gh-stack records in git config are shared. So after
+submitting from a worktree, `gh-stack add <top-branch>` in the main checkout
+tracks the whole chain _with_ its PRs, and `sync`/`merge --base` work there.
+
 **Splice an existing branch/PR into a stack — `gh-stack join`.** For a branch
 that should have been stacked but was cut from main on its own (often with its
 own PR already open):
@@ -296,6 +301,11 @@ it (its PR would be diffed against the parent's old history); the run lists it
 as held and exits 1 until `--resume` gets the parent pushed. `merge` and `join`
 refuse to run while a restack/sync is pending.
 
+**Why did the push fail?** gh-stack prints the last lines of `git push`'s
+output, which includes a pre-push hook's own messages, and saves all of it to
+`.git/.gh-stack/push-failure.log`. Fix the cause (a failing check, say), then
+`--resume`.
+
 **"Origin has commits that the local branches don't"** (restack/sync exit 1
 before changing anything): a branch's copy on origin has commits it never had,
 often the squash commit a `merge --collapse` added on GitHub. Run the