push all branches atomically and resolve remotes

Author: skarim

cmd/add.go

@@ -213,7 +213,7 @@ func runAdd(cfg *config.Config, opts *addOptions, args []string) error {
 		return nil
 	}
 
-	base, _ := git.HeadSHA(currentBranch)
+	base, _ := git.RevParse(currentBranch)
 	s.Branches = append(s.Branches, stack.BranchRef{Branch: branchName, Base: base})
 
 	// Stage and commit on the NEW branch if -m is provided

cmd/init.go

@@ -213,7 +213,7 @@ func runInit(cfg *config.Config, opts *initOptions) error {
 	}
 
 	// Build stack
-	trunkSHA, _ := git.HeadSHA(trunk)
+	trunkSHA, _ := git.RevParse(trunk)
 	branchRefs := make([]stack.BranchRef, len(branches))
 	for i, b := range branches {
 		parent := trunk

cmd/push.go

@@ -1,6 +1,7 @@
 package cmd
 
 import (
+	"errors"
 	"fmt"
 	"strings"
 
@@ -12,8 +13,8 @@ import (
 )
 
 type pushOptions struct {
-	auto  bool
-	draft bool
+	auto    bool
+	draft   bool
 	skipPRs bool
 }
 
@@ -54,40 +55,40 @@ func runPush(cfg *config.Config, opts *pushOptions) error {
 		return nil
 	}
 
-	s, err := resolveStack(sf, currentBranch, cfg)
-	if err != nil {
-		cfg.Errorf("%s", err)
-		return nil
-	}
-	if s == nil {
+	// Find the stack for the current branch without switching branches.
+	// Push should never change the user's checked-out branch.
+	stacks := sf.FindAllStacksForBranch(currentBranch)
+	if len(stacks) == 0 {
 		cfg.Errorf("current branch %q is not part of a stack", currentBranch)
 		return nil
 	}
-
-	// Re-read current branch in case disambiguation caused a checkout
-	currentBranch, err = git.CurrentBranch()
-	if err != nil {
-		cfg.Errorf("failed to get current branch: %s", err)
+	if len(stacks) > 1 {
+		cfg.Errorf("branch %q belongs to multiple stacks; checkout a non-trunk branch first", currentBranch)
 		return nil
 	}
+	s := stacks[0]
 
 	client, err := cfg.GitHubClient()
 	if err != nil {
 		cfg.Errorf("failed to create GitHub client: %s", err)
 		return nil
 	}
 
-	// Push all branches
+	// Push all active branches atomically
+	remote, err := pickRemote(cfg, currentBranch)
+	if err != nil {
+		cfg.Errorf("%s", err)
+		return nil
+	}
 	merged := s.MergedBranches()
 	if len(merged) > 0 {
 		cfg.Printf("Skipping %d merged %s", len(merged), plural(len(merged), "branch", "branches"))
 	}
-	for _, b := range s.ActiveBranches() {
-		cfg.Printf("Pushing %s...", b.Branch)
-		if err := git.Push("origin", []string{b.Branch}, true, false); err != nil {
-			cfg.Errorf("failed to push %s: %s", b.Branch, err)
-			return nil
-		}
+	activeBranches := activeBranchNames(s)
+	cfg.Printf("Pushing %d %s to %s...", len(activeBranches), plural(len(activeBranches), "branch", "branches"), remote)
+	if err := git.Push(remote, activeBranches, true, true); err != nil {
+		cfg.Errorf("failed to push: %s", err)
+		return nil
 	}
 
 	if opts.skipPRs {
@@ -174,18 +175,7 @@ func runPush(cfg *config.Config, opts *pushOptions) error {
 	fmt.Fprintf(cfg.Err, "  grouped into a Stack.\n")
 
 	// Update base commit hashes and sync PR state
-	for i := range s.Branches {
-		if s.Branches[i].IsMerged() {
-			continue
-		}
-		parent := s.ActiveBaseBranch(s.Branches[i].Branch)
-		if base, err := git.HeadSHA(parent); err == nil {
-			s.Branches[i].Base = base
-		}
-		if head, err := git.HeadSHA(s.Branches[i].Branch); err == nil {
-			s.Branches[i].Head = head
-		}
-	}
+	updateBaseSHAs(s)
 	syncStackPRs(cfg, s)
 
 	if err := stack.Save(gitDir, sf); err != nil {
@@ -235,3 +225,30 @@ func humanize(s string) string {
 		return r
 	}, s)
 }
+
+// pickRemote determines which remote to push to. It delegates to
+// git.ResolveRemote for config-based resolution and remote listing.
+// If multiple remotes exist with no configured default, the user is
+// prompted to select one interactively.
+func pickRemote(cfg *config.Config, branch string) (string, error) {
+	remote, err := git.ResolveRemote(branch)
+	if err == nil {
+		return remote, nil
+	}
+
+	var multi *git.ErrMultipleRemotes
+	if !errors.As(err, &multi) {
+		return "", err
+	}
+
+	if !cfg.IsInteractive() {
+		return "", fmt.Errorf("multiple remotes configured; set remote.pushDefault or use an interactive terminal")
+	}
+
+	p := prompter.New(cfg.In, cfg.Out, cfg.Err)
+	selected, promptErr := p.Select("Multiple remotes found. Which remote should be used?", "", multi.Remotes)
+	if promptErr != nil {
+		return "", fmt.Errorf("remote selection: %w", promptErr)
+	}
+	return multi.Remotes[selected], nil
+}

cmd/rebase.go

@@ -114,25 +114,35 @@ func runRebase(cfg *config.Config, opts *rebaseOptions) error {
 	// Enable git rerere so conflict resolutions are remembered.
 	_ = git.EnableRerere()
 
-	if err := git.Fetch("origin"); err != nil {
-		cfg.Warningf("Failed to fetch origin: %v", err)
+	// Resolve remote for fetch and trunk comparison
+	remote, err := pickRemote(cfg, currentBranch)
+	if err != nil {
+		cfg.Errorf("%s", err)
+		return nil
+	}
+
+	if err := git.Fetch(remote); err != nil {
+		cfg.Warningf("Failed to fetch %s: %v", remote, err)
 	} else {
-		cfg.Successf("Fetched origin")
+		cfg.Successf("Fetched %s", remote)
 	}
 
 	// Fast-forward trunk so the cascade rebase targets the latest upstream.
 	trunk := s.Trunk.Branch
-	localSHA, localErr := git.HeadSHA(trunk)
-	remoteSHA, remoteErr := git.HeadSHA("origin/" + trunk)
+	localSHA, remoteSHA := "", ""
+	trunkRefs, trunkErr := git.RevParseMulti([]string{trunk, remote + "/" + trunk})
+	if trunkErr == nil {
+		localSHA, remoteSHA = trunkRefs[0], trunkRefs[1]
+	}
 
-	if localErr == nil && remoteErr == nil && localSHA != remoteSHA {
+	if trunkErr == nil && localSHA != remoteSHA {
 		isAncestor, err := git.IsAncestor(localSHA, remoteSHA)
 		if err != nil {
 			cfg.Warningf("Could not determine fast-forward status for %s: %v", trunk, err)
 		} else if !isAncestor {
-			cfg.Warningf("Trunk %s has diverged from origin — skipping trunk update", trunk)
+			cfg.Warningf("Trunk %s has diverged from %s — skipping trunk update", trunk, remote)
 		} else if currentBranch == trunk {
-			if err := ffMerge(trunk); err != nil {
+			if err := git.MergeFF(remote + "/" + trunk); err != nil {
 				cfg.Warningf("Failed to fast-forward %s: %v", trunk, err)
 			} else {
 				cfg.Successf("Trunk %s fast-forwarded to %s", trunk, short(remoteSHA))
@@ -184,14 +194,14 @@ func runRebase(cfg *config.Config, opts *rebaseOptions) error {
 	// Sync PR state before rebase so we can detect merged PRs.
 	syncStackPRs(cfg, s)
 
-	originalRefs := make(map[string]string)
-	for _, b := range s.Branches {
-		sha, err := git.HeadSHA(b.Branch)
-		if err != nil {
-			cfg.Errorf("failed to resolve HEAD SHA for %s: %s", b.Branch, err)
-			return nil
-		}
-		originalRefs[b.Branch] = sha
+	branchNames := make([]string, len(s.Branches))
+	for i, b := range s.Branches {
+		branchNames[i] = b.Branch
+	}
+	originalRefs, err := git.RevParseMap(branchNames)
+	if err != nil {
+		cfg.Errorf("failed to resolve branch SHAs: %s", err)
+		return nil
 	}
 
 	// Track --onto rebase state for squash-merged branches.
@@ -312,25 +322,7 @@ func runRebase(cfg *config.Config, opts *rebaseOptions) error {
 
 	_ = git.CheckoutBranch(currentBranch)
 
-	for i := range s.Branches {
-		// Skip merged branches when updating base SHAs.
-		if s.Branches[i].IsMerged() {
-			continue
-		}
-		// Find the first non-merged ancestor, or trunk.
-		parent := s.Trunk.Branch
-		for j := i - 1; j >= 0; j-- {
-			if !s.Branches[j].IsMerged() {
-				parent = s.Branches[j].Branch
-				break
-			}
-		}
-		base, _ := git.HeadSHA(parent)
-		s.Branches[i].Base = base
-		if head, err := git.HeadSHA(s.Branches[i].Branch); err == nil {
-			s.Branches[i].Head = head
-		}
-	}
+	updateBaseSHAs(s)
 
 	syncStackPRs(cfg, s)
 
@@ -521,25 +513,7 @@ func continueRebase(cfg *config.Config, gitDir string) error {
 	clearRebaseState(gitDir)
 	_ = git.CheckoutBranch(state.OriginalBranch)
 
-	for i := range s.Branches {
-		// Skip merged branches when updating base SHAs.
-		if s.Branches[i].IsMerged() {
-			continue
-		}
-		// Find the first non-merged ancestor, or trunk.
-		parent := s.Trunk.Branch
-		for j := i - 1; j >= 0; j-- {
-			if !s.Branches[j].IsMerged() {
-				parent = s.Branches[j].Branch
-				break
-			}
-		}
-		base, _ := git.HeadSHA(parent)
-		s.Branches[i].Base = base
-		if head, err := git.HeadSHA(s.Branches[i].Branch); err == nil {
-			s.Branches[i].Head = head
-		}
-	}
+	updateBaseSHAs(s)
 
 	syncStackPRs(cfg, s)
 

cmd/rebase_test.go

@@ -34,7 +34,7 @@ func newRebaseMock(tmpDir string, currentBranch string) *git.MockOps {
 	return &git.MockOps{
 		GitDirFn:        func() (string, error) { return tmpDir, nil },
 		CurrentBranchFn: func() (string, error) { return currentBranch, nil },
-		HeadSHAFn:       func(ref string) (string, error) { return "sha-" + ref, nil },
+		RevParseFn:       func(ref string) (string, error) { return "sha-" + ref, nil },
 		IsAncestorFn:    func(a, d string) (bool, error) { return true, nil },
 		FetchFn:         func(string) error { return nil },
 		EnableRerereFn:  func() error { return nil },