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,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/sync.go

@@ -22,10 +22,10 @@ func SyncCmd(cfg *config.Config) *cobra.Command {
 
 This command performs a safe, non-interactive synchronization:
 
-  1. Fetches the latest changes from origin
+  1. Fetches the latest changes from the remote
   2. Fast-forwards the trunk branch to match the remote
   3. Cascade-rebases stack branches onto their updated parents
-  4. Pushes all branches (using --force-with-lease)
+  4. Pushes all branches atomically (using --force-with-lease --atomic)
   5. Syncs PR state from GitHub
 
 If a rebase conflict is detected, all branches are restored to their
@@ -75,22 +75,29 @@ func runSync(cfg *config.Config, _ *syncOptions) error {
 		return nil
 	}
 
+	// Resolve remote once for fetch and push
+	remote, err := pickRemote(cfg, currentBranch)
+	if err != nil {
+		cfg.Errorf("%s", err)
+		return nil
+	}
+
 	// --- Step 1: Fetch ---
 	// 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)
+	if err := git.Fetch(remote); err != nil {
+		cfg.Warningf("Failed to fetch %s: %v", remote, err)
 	} else {
-		cfg.Successf("Fetched latest changes")
+		cfg.Successf("Fetched latest changes from %s", remote)
 	}
 
 	// --- Step 2: Fast-forward trunk ---
 	trunk := s.Trunk.Branch
 	trunkUpdated := false
 
 	localSHA, localErr := git.HeadSHA(trunk)
-	remoteSHA, remoteErr := git.HeadSHA("origin/" + trunk)
+	remoteSHA, remoteErr := git.HeadSHA(remote + "/" + trunk)
 
 	if localErr != nil || remoteErr != nil {
 		cfg.Warningf("Could not compare trunk %s with remote — skipping trunk update", trunk)
@@ -101,13 +108,12 @@ func runSync(cfg *config.Config, _ *syncOptions) error {
 		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)
 			cfg.Printf("  Local and remote %s have diverged. Resolve manually.", trunk)
 		} else {
 			// Fast-forward the trunk branch
 			if currentBranch == trunk {
-				// Can't update ref of checked-out branch; merge instead
-				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))
@@ -231,12 +237,7 @@ func runSync(cfg *config.Config, _ *syncOptions) error {
 
 	// --- Step 4: Push ---
 	cfg.Printf("")
-	var branches []string
-	for _, b := range s.Branches {
-		if !b.IsMerged() {
-			branches = append(branches, b.Branch)
-		}
-	}
+	branches := activeBranchNames(s)
 
 	if mergedCount := len(s.MergedBranches()); mergedCount > 0 {
 		cfg.Printf("Skipping %d merged %s", mergedCount, plural(mergedCount, "branch", "branches"))
@@ -248,8 +249,8 @@ func runSync(cfg *config.Config, _ *syncOptions) error {
 		// After rebase, force-with-lease is required (history rewritten).
 		// Without rebase, try a normal push first.
 		force := rebased
-		cfg.Printf("Pushing branches ...")
-		if err := git.Push("origin", branches, force, false); err != nil {
+		cfg.Printf("Pushing %d %s to %s...", len(branches), plural(len(branches), "branch", "branches"), remote)
+		if err := git.Push(remote, branches, force, true); err != nil {
 			if !force {
 				cfg.Warningf("Push failed — branches may need force push after rebase")
 				cfg.Printf("  Run %s to push with --force-with-lease.",
@@ -293,19 +294,7 @@ func runSync(cfg *config.Config, _ *syncOptions) error {
 	}
 
 	// --- Step 6: Update base SHAs and save ---
-	for i := range s.Branches {
-		// Skip merged branches when updating base SHAs.
-		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)
 
 	if err := stack.Save(gitDir, sf); err != nil {
 		cfg.Errorf("failed to save stack state: %s", err)

cmd/utils.go

@@ -90,3 +90,31 @@ func syncStackPRs(cfg *config.Config, s *stack.Stack) {
 		}
 	}
 }
+
+// updateBaseSHAs refreshes the Base and Head SHAs for all active branches
+// in a stack. Call this after any operation that may have moved branch refs
+// (rebase, push, etc.).
+func updateBaseSHAs(s *stack.Stack) {
+	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
+		}
+	}
+}
+
+// activeBranchNames returns the branch names for all non-merged branches in a stack.
+func activeBranchNames(s *stack.Stack) []string {
+	active := s.ActiveBranches()
+	names := make([]string, len(active))
+	for i, b := range active {
+		names[i] = b.Branch
+	}
+	return names
+}

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)