push all branches atomically and resolve remotes

Author: skarim

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,44 @@ 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 := s.ActiveBranches()
+	branchNames := make([]string, len(activeBranches))
+	for i, b := range activeBranches {
+		branchNames[i] = b.Branch
+	}
+	cfg.Printf("Pushing %d %s to %s...", len(branchNames), plural(len(branchNames), "branch", "branches"), remote)
+	if err := git.Push(remote, branchNames, true, true); err != nil {
+		cfg.Errorf("failed to push: %s", err)
+		return nil
 	}
 
 	if opts.skipPRs {
@@ -235,3 +240,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
+}

internal/git/git.go

@@ -2,6 +2,7 @@ package git
 
 import (
 	"context"
+	"fmt"
 	"os"
 	"os/exec"
 	"strings"
@@ -13,6 +14,16 @@ import (
 // client is a shared git client used by all package-level functions.
 var client = &cligit.Client{}
 
+// ErrMultipleRemotes is returned by ResolveRemote when multiple remotes
+// are configured and none is designated as the push target.
+type ErrMultipleRemotes struct {
+	Remotes []string
+}
+
+func (e *ErrMultipleRemotes) Error() string {
+	return fmt.Sprintf("multiple remotes configured: %s", strings.Join(e.Remotes, ", "))
+}
+
 // CommitInfo holds metadata about a single commit.
 type CommitInfo struct {
 	SHA     string
@@ -118,6 +129,14 @@ func Push(remote string, branches []string, force, atomic bool) error {
 	return ops.Push(remote, branches, force, atomic)
 }
 
+// ResolveRemote determines the remote for pushing a branch. Checks git
+// config in priority order, falls back to listing remotes. Returns
+// *ErrMultipleRemotes if multiple remotes exist with no configured default.
+func ResolveRemote(branch string) (string, error) {
+	return ops.ResolveRemote(branch)
+}
+
+
 // Rebase rebases the current branch onto the given base.
 // If rerere resolves all conflicts automatically, the rebase continues
 // without user intervention.

internal/git/gitops.go

@@ -3,6 +3,7 @@ package git
 import (
 	"context"
 	"errors"
+	"fmt"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -23,6 +24,7 @@ type Ops interface {
 	DefaultBranch() (string, error)
 	CreateBranch(name, base string) error
 	Push(remote string, branches []string, force, atomic bool) error
+	ResolveRemote(branch string) (string, error)
 	Rebase(base string) error
 	EnableRerere() error
 	RebaseOnto(newBase, oldBase, branch string) error
@@ -122,6 +124,38 @@ func (d *defaultOps) Push(remote string, branches []string, force, atomic bool)
 	return runSilent(args...)
 }
 
+// ResolveRemote determines the remote for pushing a branch. It checks git
+// config keys in priority order (branch.<name>.pushRemote, remote.pushDefault,
+// branch.<name>.remote), then falls back to listing all remotes. If exactly
+// one remote exists it is returned. If multiple exist, ErrMultipleRemotes is
+// returned with the list attached. If none exist, a plain error is returned.
+func (d *defaultOps) ResolveRemote(branch string) (string, error) {
+	candidates := []string{
+		"branch." + branch + ".pushRemote",
+		"remote.pushDefault",
+		"branch." + branch + ".remote",
+	}
+	for _, key := range candidates {
+		out, err := run("config", "--get", key)
+		if err == nil && out != "" {
+			return out, nil
+		}
+	}
+
+	out, err := run("remote")
+	if err != nil {
+		return "", fmt.Errorf("could not list remotes: %w", err)
+	}
+	remotes := strings.Fields(strings.TrimSpace(out))
+	if len(remotes) == 1 {
+		return remotes[0], nil
+	}
+	if len(remotes) > 1 {
+		return "", &ErrMultipleRemotes{Remotes: remotes}
+	}
+	return "", fmt.Errorf("no remotes configured")
+}
+
 func (d *defaultOps) Rebase(base string) error {
 	err := runSilent("rebase", base)
 	if err == nil {

internal/git/mock_ops.go

@@ -12,6 +12,7 @@ type MockOps struct {
 	DefaultBranchFn       func() (string, error)
 	CreateBranchFn        func(string, string) error
 	PushFn                func(string, []string, bool, bool) error
+	ResolveRemoteFn       func(string) (string, error)
 	RebaseFn              func(string) error
 	EnableRerereFn        func() error
 	RebaseOntoFn          func(string, string, string) error
@@ -98,6 +99,13 @@ func (m *MockOps) Push(remote string, branches []string, force, atomic bool) err
 	return nil
 }
 
+func (m *MockOps) ResolveRemote(branch string) (string, error) {
+	if m.ResolveRemoteFn != nil {
+		return m.ResolveRemoteFn(branch)
+	}
+	return "origin", nil
+}
+
 func (m *MockOps) Rebase(base string) error {
 	if m.RebaseFn != nil {
 		return m.RebaseFn(base)