Base retargeting support (#590)

* Follow server base changes in sync and rebase

* Handle retargets across stack commands

* Document automatic base retargeting

* Validate retarget cutoffs and recovery

* Normalize retarget comparisons in view

* Avoid false retarget consent prompts

* Keep view's retarget check best-effort

* Require consent before dropping unlanded merged branches

A merged branch below a retargeted stack can land in the old base after that
base merged. Check the boundary the cascade drops, and skip the prompt only
when those commits reached the new base.

* Keep the old base when importing a retargeted stack

Importing onto GitHub's new base hid the pending retarget, so the next rebase
skipped consent. Keep the merged first PR's base so sync repairs the stack, and
compare GitHub's base only for the tracked-stack warning.

Author: skarim

cmd/checkout.go

@@ -475,7 +475,12 @@ func reconcileAndImportRemoteStack(cfg *config.Config, client github.ClientOps,
 			if err := stack.Save(gitDir, sf); err != nil {
 				return nil, "", stackSaveError(cfg, err)
 			}
-			cfg.Successf("Local stack matches remote%s", linkedStackLabel(cfg, remoteStack.Number))
+			if base := remoteStack.Base.Ref; base != "" && localStack.Trunk.Branch != base {
+				cfg.Warningf("GitHub retargeted this stack%s from %s to %s", linkedStackLabel(cfg, remoteStack.Number), localStack.Trunk.Branch, base)
+				cfg.Printf("  Run `%s` to rebase the stack onto %s", cfg.ColorCyan("gh stack sync"), base)
+			} else {
+				cfg.Successf("Local stack matches remote%s", linkedStackLabel(cfg, remoteStack.Number))
+			}
 			return localStack, targetBranch, nil
 		}
 

cmd/checkout_test.go

@@ -1667,3 +1667,47 @@ func TestCheckout_ByPRURL_Remote(t *testing.T) {
 	assert.Equal(t, "feat-2", checkedOut)
 	assert.Contains(t, output, "Imported stack with 2 branches")
 }
+
+func TestCheckout_BaseRetarget(t *testing.T) {
+	t.Run("reports a tracked stack", func(t *testing.T) {
+		repo := setupBaseRetargetRepo(t, "main", false)
+		withIssue250Repo(t, repo.dir)
+		cfg, outR, errR := config.NewTestConfig()
+		cfg.GitHubClientOverride = repo.client
+
+		require.NoError(t, runCheckout(cfg, &checkoutOptions{target: "9"}))
+		_, diagnostics := commandOutput(t, cfg, outR, errR)
+		assert.Contains(t, diagnostics, "from parent to main")
+		assert.NotContains(t, diagnostics, "matches remote")
+		sf, err := stack.Load(repo.gitDir)
+		require.NoError(t, err)
+		assert.Equal(t, "parent", sf.Stacks[0].Trunk.Branch)
+	})
+
+	t.Run("keeps the old base until rebased", func(t *testing.T) {
+		// The child merged into the parent, which was deleted without merging.
+		repo := setupBaseRetargetRepo(t, "main", false)
+		withIssue250Repo(t, repo.dir)
+		sf, err := stack.Load(repo.gitDir)
+		require.NoError(t, err)
+		sf.Stacks = nil
+		require.NoError(t, stack.Save(repo.gitDir, sf))
+		child := issue250Git(t, repo.dir, "rev-parse", "child")
+		repo.client.FindPRByNumberFn = func(n int) (*github.PullRequest, error) {
+			if n == 11 {
+				return &github.PullRequest{Number: 11, HeadRefName: "child", BaseRefName: "parent", State: "MERGED", Merged: true, HeadRefOID: child}, nil
+			}
+			return &github.PullRequest{Number: 12, HeadRefName: "top", BaseRefName: "main", State: "OPEN"}, nil
+		}
+		cfg := issue250TestConfig(t)
+		cfg.GitHubClientOverride = repo.client
+
+		require.NoError(t, runCheckout(cfg, &checkoutOptions{target: "9"}))
+		sf, err = stack.Load(repo.gitDir)
+		require.NoError(t, err)
+		assert.Equal(t, "parent", sf.Stacks[0].Trunk.Branch)
+		top := issue250Git(t, repo.dir, "rev-parse", "top")
+		require.Error(t, runRebase(cfg, &rebaseOptions{remote: "origin"}), "dropping the unmerged parent needs consent")
+		assert.Equal(t, top, issue250Git(t, repo.dir, "rev-parse", "top"))
+	})
+}

cmd/push.go

@@ -84,6 +84,9 @@ func runPush(cfg *config.Config, opts *pushOptions) error {
 		}
 		return ErrSilent
 	}
+	if err := requireCurrentBase(cfg, s, remote); err != nil {
+		return err
+	}
 	// Sync PR state to detect merged/queued PRs before pushing.
 	_ = syncStackPRs(cfg, s)
 

cmd/push_test.go

@@ -404,3 +404,23 @@ func TestPickRemote_OverrideTakesPrecedence(t *testing.T) {
 	assert.Equal(t, "custom", remote)
 	assert.False(t, resolveCalled, "ResolveRemote should not be called when override is provided")
 }
+
+func TestPush_BaseRetarget(t *testing.T) {
+	dir := t.TempDir()
+	writeStackFile(t, dir, stack.Stack{ID: "9", Number: 9, Trunk: stack.BranchRef{Branch: "parent"}, Branches: []stack.BranchRef{{Branch: "child"}}})
+	mock := newPushMock(dir, "child")
+	mock.PushFn = func(string, []string, bool, bool) error {
+		t.Fatal("must not push before rebasing onto the new base")
+		return nil
+	}
+	restore := git.SetOps(mock)
+	defer restore()
+	cfg, _, _ := config.NewTestConfig()
+	cfg.GitHubClientOverride = &github.MockClient{
+		GetStackFn: func(int) (*github.RemoteStack, error) {
+			return &github.RemoteStack{ID: 9, Base: github.RemoteStackBase{Ref: "main"}}, nil
+		},
+	}
+
+	assert.ErrorIs(t, runPush(cfg, &pushOptions{remote: "origin"}), ErrSilent)
+}

cmd/rebase.go

@@ -26,6 +26,7 @@ type rebaseOptions struct {
 	noTrunk                   bool
 	remote                    string
 	committerDateIsAuthorDate bool
+	acceptBaseChange          bool
 }
 
 type rebaseState struct {
@@ -34,6 +35,7 @@ type rebaseState struct {
 	Worktrees                 *worktree.Context `json:"worktrees,omitempty"`
 	StackID                   string            `json:"stackId,omitempty"`
 	StackTrunk                string            `json:"stackTrunk,omitempty"`
+	TargetTrunk               string            `json:"targetTrunk,omitempty"`
 	StackBranches             []string          `json:"stackBranches,omitempty"`
 	OriginalStack             *stack.Stack      `json:"originalStack,omitempty"`
 	RebaseBase                string            `json:"rebaseBase,omitempty"`
@@ -72,7 +74,11 @@ layer in its commit history, rebasing if necessary.
 
 Use --no-trunk to skip fetching and rebasing with the trunk branch.
 Only the inter-branch rebases are performed (branch 2 onto branch 1,
-branch 3 onto branch 2, etc.).`,
+branch 3 onto branch 2, etc.).
+
+If GitHub retargeted the stack because its base branch was deleted, the
+stack is rebased onto the new base. Removing commits from an old base that
+did not merge requires confirmation, or --accept-base-change.`,
 		Example: `  # Rebase the entire stack
   $ gh stack rebase
 
@@ -102,6 +108,7 @@ branch 3 onto branch 2, etc.).`,
 	cmd.Flags().BoolVar(&opts.downstack, "downstack", false, "Only rebase branches from trunk to current branch")
 	cmd.Flags().BoolVar(&opts.upstack, "upstack", false, "Only rebase branches from current branch to top")
 	cmd.Flags().BoolVar(&opts.noTrunk, "no-trunk", false, "Skip trunk — only rebase stack branches onto each other")
+	cmd.Flags().BoolVar(&opts.acceptBaseChange, "accept-base-change", false, "Rebase onto a retargeted base even if the old base did not merge")
 	cmd.Flags().BoolVar(&opts.cont, "continue", false, "Continue rebase after resolving conflicts")
 	cmd.Flags().BoolVar(&opts.abort, "abort", false, "Abort rebase and restore all branches")
 	cmd.Flags().StringVar(&opts.remote, "remote", "", "Remote to fetch from (defaults to auto-detected remote)")
@@ -192,6 +199,7 @@ func runRebase(cfg *config.Config, opts *rebaseOptions) error {
 	}
 
 	var trunk trunkTarget
+	var newBase, cutoff string
 	if !opts.noTrunk {
 		// Resolve remote for fetch and trunk comparison
 		remote, err := pickRemote(cfg, anchor, opts.remote)
@@ -201,6 +209,14 @@ func runRebase(cfg *config.Config, opts *rebaseOptions) error {
 			}
 			return ErrSilent
 		}
+		if newBase, err = retargetedBase(cfg, s, remote); err != nil {
+			cfg.Errorf("failed to read the stack's base on GitHub: %v", err)
+			return ErrAPIFailure
+		}
+		if i := s.FirstActiveBranchIndex(); newBase != "" && i >= 0 && (i < startIdx || i >= endIdx) {
+			cfg.Errorf("rebase the whole stack to move it onto %s", newBase)
+			return ErrInvalidArgs
+		}
 
 		// Fast-forward stack branches that are behind their remote tracking branch.
 		if err := git.FetchBranches(remote, activeBranchNames(s)); err != nil {
@@ -215,10 +231,15 @@ func runRebase(cfg *config.Config, opts *rebaseOptions) error {
 			cfg.Errorf("%s", err)
 			return ErrSilent
 		}
-		trunk, err = resolveTrunkTarget(cfg, s, remote, currentBranch, trunkResolveOptions{Worktrees: ctx})
+		trunk, err = resolveTrunkTarget(cfg, s, remote, currentBranch, trunkResolveOptions{Worktrees: ctx, Branch: newBase})
 		if err != nil {
 			return err
 		}
+		if newBase != "" {
+			if cutoff, err = retargetCutoff(cfg, s, trunk, planned, opts.acceptBaseChange); err != nil {
+				return err
+			}
+		}
 		if _, err := fastForwardBranches(cfg, planned, ctx); err != nil {
 			cfg.Errorf("%s", err)
 			return ErrSilent
@@ -254,11 +275,15 @@ func runRebase(cfg *config.Config, opts *rebaseOptions) error {
 			ontoOldBase = originalRefs[prev.Branch]
 		}
 	}
+	if cutoff != "" {
+		needsOnto, ontoOldBase = true, cutoff
+	}
 
 	state := newWorktreeRebaseState(s, ctx, currentBranch, originalRefs, trunk, startIdx, endIdx)
 	state.CommitterDateIsAuthorDate = opts.committerDateIsAuthorDate
 	state.NoTrunk = opts.noTrunk
 	state.UseOnto, state.OntoOldBase = needsOnto, ontoOldBase
+	state.TargetTrunk = newBase
 	if s.Trunk.Branch != originalTrunk {
 		if err := stack.Save(gitDir, sf); err != nil {
 			return handleSaveError(cfg, err)