disambiguate for multiple stacks

Author: skarim

cmd/add.go

@@ -40,12 +40,23 @@ func runAdd(cfg *config.Config, args []string) error {
 		return nil
 	}
 
-	s := sf.FindStackForBranch(currentBranch)
+	s, err := sf.ResolveStack(currentBranch, cfg)
+	if err != nil {
+		cfg.Errorf("%s", err)
+		return nil
+	}
 	if s == nil {
 		cfg.Errorf("current branch %q is not part of a stack; run 'gh stack init' first", 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)
+		return nil
+	}
+
 	idx := s.IndexOf(currentBranch)
 	if idx >= 0 && idx < len(s.Branches)-1 {
 		cfg.Errorf("can only add branches on top of the stack; checkout the top branch %q first", s.Branches[len(s.Branches)-1].Branch)

cmd/init.go

@@ -78,7 +78,7 @@ func runInit(cfg *config.Config, opts *initOptions) error {
 
 	// Don't allow initializing a stack if the current branch is already part of another stack
 	if currentBranch != "" {
-		if existing := sf.FindStackForBranch(currentBranch); existing != nil {
+		if stacks := sf.FindAllStacksForBranch(currentBranch); len(stacks) > 0 {
 			cfg.Errorf("current branch %q is already part of a stack", currentBranch)
 			return nil
 		}

cmd/navigate.go

@@ -170,14 +170,26 @@ func loadCurrentStack(cfg *config.Config) (*stack.Stack, string, error) {
 		return nil, "", fmt.Errorf("%s", errMsg)
 	}
 
-	s := sf.FindStackForBranch(currentBranch)
+	s, err := sf.ResolveStack(currentBranch, cfg)
+	if err != nil {
+		cfg.Errorf("%s", err)
+		return nil, "", err
+	}
 	if s == nil {
 		errMsg := fmt.Sprintf("current branch %q is not part of a stack", currentBranch)
 		cfg.Errorf("current branch %q is not part of a stack", currentBranch)
 		cfg.Printf("Checkout an existing stack using %s or create a new stack using %s", cfg.ColorCyan("gh stack checkout"), cfg.ColorCyan("gh stack init"))
 		return nil, "", fmt.Errorf("%s", errMsg)
 	}
 
+	// Re-read current branch in case disambiguation caused a checkout
+	currentBranch, err = git.CurrentBranch()
+	if err != nil {
+		errMsg := fmt.Sprintf("failed to get current branch: %s", err)
+		cfg.Errorf("%s", errMsg)
+		return nil, "", fmt.Errorf("%s", errMsg)
+	}
+
 	return s, currentBranch, nil
 }
 

cmd/push.go

@@ -52,12 +52,23 @@ func runPush(cfg *config.Config, opts *pushOptions) error {
 		return nil
 	}
 
-	s := sf.FindStackForBranch(currentBranch)
+	s, err := sf.ResolveStack(currentBranch, cfg)
+	if err != nil {
+		cfg.Errorf("%s", err)
+		return nil
+	}
 	if s == nil {
 		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)
+		return nil
+	}
+
 	client, err := cfg.GitHubClient()
 	if err != nil {
 		cfg.Errorf("failed to create GitHub client: %s", err)

cmd/rebase.go

@@ -91,12 +91,23 @@ func runRebase(cfg *config.Config, opts *rebaseOptions) error {
 		}
 	}
 
-	s := sf.FindStackForBranch(currentBranch)
+	s, err := sf.ResolveStack(currentBranch, cfg)
+	if err != nil {
+		cfg.Errorf("%s", err)
+		return nil
+	}
 	if s == nil {
 		cfg.Errorf("no stack found for branch %s", 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)
+		return nil
+	}
+
 	cfg.Printf("Fetching origin ...")
 	if err := git.Fetch("origin"); err != nil {
 		cfg.Warningf("Failed to fetch origin: %v", err)
@@ -223,7 +234,10 @@ func continueRebase(cfg *config.Config, gitDir string) error {
 
 	// Use the saved original branch to find the stack, since git may be in
 	// a detached HEAD state during an active rebase.
-	s := sf.FindStackForBranch(state.OriginalBranch)
+	s, err := sf.ResolveStack(state.OriginalBranch, cfg)
+	if err != nil {
+		return err
+	}
 	if s == nil {
 		return fmt.Errorf("no stack found for branch %s", state.OriginalBranch)
 	}

cmd/unstack.go

@@ -55,7 +55,11 @@ func runUnstack(cfg *config.Config, opts *unstackOptions) error {
 		}
 	}
 
-	s := sf.FindStackForBranch(target)
+	s, err := sf.ResolveStack(target, cfg)
+	if err != nil {
+		cfg.Errorf("%s", err)
+		return nil
+	}
 	if s == nil {
 		cfg.Errorf("branch %q is not part of a stack", target)
 		return nil

cmd/view.go

@@ -56,13 +56,24 @@ func runView(cfg *config.Config, opts *viewOptions) error {
 		return nil
 	}
 
-	s := sf.FindStackForBranch(currentBranch)
+	s, err := sf.ResolveStack(currentBranch, cfg)
+	if err != nil {
+		cfg.Errorf("%s", err)
+		return nil
+	}
 	if s == nil {
 		cfg.Errorf("current branch %q is not part of a stack", currentBranch)
 		cfg.Printf("Checkout an existing stack using %s or create a new stack using %s", cfg.ColorCyan("gh stack checkout"), cfg.ColorCyan("gh stack init"))
 		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)
+		return nil
+	}
+
 	if opts.web {
 		return viewWeb(cfg, s)
 	}

internal/stack/resolve.go

@@ -0,0 +1,58 @@
+package stack
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/cli/go-gh/v2/pkg/prompter"
+	"github.com/github/gh-stack/internal/config"
+	"github.com/github/gh-stack/internal/git"
+)
+
+// ResolveStack finds the stack for the given branch, handling ambiguity when
+// a branch (typically a trunk) belongs to multiple stacks. If exactly one
+// stack matches, it is returned directly. If multiple stacks match, the user
+// is prompted to select one and the working tree is switched to the top branch
+// of the selected stack. Returns nil with no error if no stack contains the
+// branch.
+func (sf *StackFile) ResolveStack(branch string, cfg *config.Config) (*Stack, error) {
+	stacks := sf.FindAllStacksForBranch(branch)
+
+	switch len(stacks) {
+	case 0:
+		return nil, nil
+	case 1:
+		return stacks[0], nil
+	}
+
+	if !cfg.IsInteractive() {
+		return nil, fmt.Errorf("branch %q belongs to multiple stacks; use an interactive terminal to select one", branch)
+	}
+
+	cfg.Warningf("Branch %q is the trunk of multiple stacks\n", branch)
+
+	options := make([]string, len(stacks))
+	for i, s := range stacks {
+		options[i] = s.DisplayName()
+	}
+
+	p := prompter.New(os.Stdin, os.Stdout, os.Stderr)
+	selected, err := p.Select("Which stack would you like to use?", "", options)
+	if err != nil {
+		return nil, fmt.Errorf("stack selection: %w", err)
+	}
+
+	s := stacks[selected]
+
+	// Switch to the top branch of the selected stack so future commands
+	// resolve unambiguously.
+	topBranch := s.Branches[len(s.Branches)-1].Branch
+	if topBranch != branch {
+		if err := git.CheckoutBranch(topBranch); err != nil {
+			return nil, fmt.Errorf("failed to checkout branch %s: %w", topBranch, err)
+		}
+		cfg.Successf("Switched to %s\n", topBranch)
+	}
+
+	return s, nil
+}

internal/stack/stack.go

@@ -25,6 +25,16 @@ type Stack struct {
 	Branches []BranchRef `json:"branches"`
 }
 
+// DisplayName returns a human-readable chain representation of the stack.
+// Format: (trunk) <- branch1 <- branch2 <- branch3
+func (s *Stack) DisplayName() string {
+	result := "(" + s.Trunk.Branch + ")"
+	for _, b := range s.Branches {
+		result += " <- " + b.Branch
+	}
+	return result
+}
+
 // BranchNames returns the list of branch names in order.
 func (s *Stack) BranchNames() []string {
 	names := make([]string, len(s.Branches))
@@ -69,14 +79,15 @@ type StackFile struct {
 	Stacks        []Stack `json:"stacks"`
 }
 
-// FindStackForBranch returns the stack that contains the given branch, or nil.
-func (sf *StackFile) FindStackForBranch(branch string) *Stack {
+// FindAllStacksForBranch returns all stacks that contain the given branch.
+func (sf *StackFile) FindAllStacksForBranch(branch string) []*Stack {
+	var stacks []*Stack
 	for i := range sf.Stacks {
 		if sf.Stacks[i].Contains(branch) {
-			return &sf.Stacks[i]
+			stacks = append(stacks, &sf.Stacks[i])
 		}
 	}
-	return nil
+	return stacks
 }
 
 // ValidateNoDuplicateBranch checks that the branch is not already in any stack.