fix(github): replace bulk PR fetch with parallel per-branch fetches (#64)

On large repos (500+ open PRs), `gh pr list --limit 500` times out with
502 Bad Gateway (~55s). Replace `GetAllPRs()` with `GetPRsForBranches()`
which fetches PRs individually in parallel for only the branches in the
current stack. For a 3-branch stack: ~3s vs 55s+ timeout.

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

Author: javoire

CLAUDE.md

@@ -56,7 +56,7 @@ go test ./...
 
 **Merged PR Detection** (`cmd/sync.go:runSync`):
 
-- Fetches all PRs upfront for performance (cached in single API call)
+- Fetches PRs for relevant branches in parallel
 - If parent PR is merged, updates child's parent to grandparent
 - If branch's own PR is merged, removes from stack tracking
 

cmd/prune.go

@@ -3,7 +3,6 @@ package cmd
 import (
 	"fmt"
 	"os"
-	"sync"
 
 	"github.com/javoire/stackinator/internal/git"
 	"github.com/javoire/stackinator/internal/github"
@@ -70,25 +69,13 @@ func runPrune(gitClient git.GitClient, githubClient github.GitHubClient) error {
 	// Get base branch to exclude it from pruning
 	baseBranch := stack.GetBaseBranch(gitClient)
 
-	// Start PR fetch in parallel with branch loading (PR fetch is the slowest operation)
-	var wg sync.WaitGroup
-	var prCache map[string]*github.PRInfo
-	var prErr error
-
-	wg.Add(1)
-	go func() {
-		defer wg.Done()
-		prCache, prErr = githubClient.GetAllPRs()
-	}()
-
-	// Get branches to check (runs in parallel with PR fetch)
+	// Get branches to check
 	var branchNames []string
-	var branchErr error
 	if pruneAll {
 		// Check all local branches
+		var branchErr error
 		branchNames, branchErr = gitClient.ListBranches()
 		if branchErr != nil {
-			wg.Wait() // Wait for PR fetch before returning
 			return fmt.Errorf("failed to get branches: %w", branchErr)
 		}
 
@@ -102,10 +89,8 @@ func runPrune(gitClient git.GitClient, githubClient github.GitHubClient) error {
 		branchNames = filtered
 	} else {
 		// Check only stack branches
-		var stackBranches []stack.StackBranch
-		stackBranches, branchErr = stack.GetStackBranches(gitClient)
+		stackBranches, branchErr := stack.GetStackBranches(gitClient)
 		if branchErr != nil {
-			wg.Wait() // Wait for PR fetch before returning
 			return fmt.Errorf("failed to get stack branches: %w", branchErr)
 		}
 
@@ -115,7 +100,6 @@ func runPrune(gitClient git.GitClient, githubClient github.GitHubClient) error {
 	}
 
 	if len(branchNames) == 0 {
-		wg.Wait() // Wait for PR fetch before returning
 		if pruneAll {
 			fmt.Println("No branches found to check.")
 		} else {
@@ -124,19 +108,15 @@ func runPrune(gitClient git.GitClient, githubClient github.GitHubClient) error {
 		return nil
 	}
 
-	// Wait for PR fetch to complete
-	if err := spinner.WrapWithSuccess("Loading branches and fetching PRs...", "Loaded branches and PRs", func() error {
-		wg.Wait()
+	// Fetch PRs for the branches we need to check (parallel individual fetches)
+	var prCache map[string]*github.PRInfo
+	if err := spinner.WrapWithSuccess("Fetching PRs...", "Fetched PRs", func() error {
+		prCache = githubClient.GetPRsForBranches(branchNames)
 		return nil
 	}); err != nil {
 		return err
 	}
 
-	// Check for PR fetch errors
-	if prErr != nil {
-		return fmt.Errorf("failed to fetch PRs: %w", prErr)
-	}
-
 	// Find branches with merged PRs
 	var mergedBranches []string
 	for _, branchName := range branchNames {

cmd/status.go

@@ -63,28 +63,15 @@ func runStatus(gitClient git.GitClient, githubClient github.GitHubClient) error
 	var tree *stack.TreeNode
 	var allTreeBranches []string
 
-	// Start fetch and PR loading in parallel with stack tree building (if not --no-pr)
-	// These are the slowest operations and can run while we build the tree
-	var wg sync.WaitGroup
+	// Start fetch in parallel with stack tree building (if not --no-pr)
+	var fetchWg sync.WaitGroup
 	var prCache map[string]*github.PRInfo
-	var prErr error
 	fetchDone := false
 
 	if !noPR {
-		wg.Add(2)
+		fetchWg.Add(1)
 		go func() {
-			defer wg.Done()
-			prCache, prErr = githubClient.GetAllPRs()
-			if prErr != nil {
-				if verbose {
-					fmt.Printf("  [gh] Error fetching PRs: %v\n", prErr)
-				}
-				// If fetching fails, fall back to empty cache
-				prCache = make(map[string]*github.PRInfo)
-			}
-		}()
-		go func() {
-			defer wg.Done()
+			defer fetchWg.Done()
 			// Fetch latest changes from origin (needed for sync issue detection)
 			_ = gitClient.Fetch()
 			fetchDone = true
@@ -93,7 +80,7 @@ func runStatus(gitClient git.GitClient, githubClient github.GitHubClient) error
 		prCache = make(map[string]*github.PRInfo)
 	}
 
-	// Build the stack tree AND wait for PR fetch (runs in parallel)
+	// Build the stack tree, then fetch PRs for tree branches only
 	if err := spinner.WrapWithAutoDelay("Loading stack...", 300*time.Millisecond, func() error {
 		// Get current branch
 		var err error
@@ -126,42 +113,9 @@ func runStatus(gitClient git.GitClient, githubClient github.GitHubClient) error
 		// Get ALL branch names in the tree (including intermediate branches without stackparent)
 		allTreeBranches = getAllBranchNamesFromTree(tree)
 
-		// Wait for PR fetch to complete (if running)
+		// Fetch PRs for stack branches only (parallel individual fetches)
 		if !noPR {
-			wg.Wait()
-
-			// GetAllPRs only fetches open PRs (to avoid 502 timeouts on large repos).
-			// For branches in our stack that aren't in the cache, check individually
-			// to detect merged PRs that need special handling.
-			// OPTIMIZATION: Only check branches in the current tree, not all stack branches.
-			branchSet := make(map[string]bool)
-			for _, name := range allTreeBranches {
-				branchSet[name] = true
-			}
-			baseBranch := stack.GetBaseBranch(gitClient)
-
-			for _, branch := range stackBranches {
-				// Skip branches not in the current tree
-				if !branchSet[branch.Name] {
-					continue
-				}
-				// Skip if already in cache (has open PR)
-				if _, exists := prCache[branch.Name]; exists {
-					continue
-				}
-				// Fetch PR info for this branch (might be merged or non-existent)
-				if pr, err := githubClient.GetPRForBranch(branch.Name); err == nil && pr != nil {
-					prCache[branch.Name] = pr
-				}
-				// Also check parent if not in cache and not base branch
-				if branch.Parent != baseBranch {
-					if _, exists := prCache[branch.Parent]; !exists {
-						if pr, err := githubClient.GetPRForBranch(branch.Parent); err == nil && pr != nil {
-							prCache[branch.Parent] = pr
-						}
-					}
-				}
-			}
+			prCache = githubClient.GetPRsForBranches(allTreeBranches)
 		}
 
 		return nil
@@ -170,8 +124,8 @@ func runStatus(gitClient git.GitClient, githubClient github.GitHubClient) error
 	}
 
 	if len(stackBranches) == 0 {
-		// Wait for PR fetch to complete before returning
-		wg.Wait()
+		// Wait for fetch to complete before returning
+		fetchWg.Wait()
 		fmt.Println("No stack branches found.")
 		fmt.Printf("Current branch: %s\n", ui.Branch(currentBranch))
 		fmt.Printf("\nUse '%s' to create a new stack branch.\n", ui.Command("stack new <branch-name>"))
@@ -220,6 +174,9 @@ func runStatus(gitClient git.GitClient, githubClient github.GitHubClient) error
 
 	// Check for sync issues (skip if --no-pr)
 	if !noPR {
+		// Wait for git fetch to complete (needed for sync issue detection)
+		fetchWg.Wait()
+
 		// Filter stackBranches to only include branches in the current tree
 		branchSet := make(map[string]bool)
 		for _, name := range allTreeBranches {

cmd/status_test.go

@@ -31,7 +31,7 @@ func TestRunStatus(t *testing.T) {
 				// Get base branch
 				mockGit.On("GetConfig", "stack.baseBranch").Return("")
 				mockGit.On("GetDefaultBranch").Return("main")
-				// Note: GetAllPRs is NOT called because noPR is true
+				// Note: GetPRsForBranches is NOT called because noPR is true
 			},
 			expectError: false,
 		},

cmd/sync.go

@@ -272,22 +272,15 @@ func runSync(gitClient git.GitClient, githubClient github.GitHubClient) error {
 		fmt.Println(ui.Success(fmt.Sprintf("Added '%s' to stack with parent '%s'", ui.Branch(originalBranch), ui.Branch(baseBranch))))
 	}
 
-	// Start parallel fetch operations (git fetch and GitHub PR fetch)
-	// These are the slowest operations and have no dependencies between them
+	// Start git fetch in parallel (the slowest network operation)
 	var wg sync.WaitGroup
 	var fetchErr error
-	var prCache map[string]*github.PRInfo
-	var prErr error
 
-	wg.Add(2)
+	wg.Add(1)
 	go func() {
 		defer wg.Done()
 		fetchErr = gitClient.Fetch()
 	}()
-	go func() {
-		defer wg.Done()
-		prCache, prErr = githubClient.GetAllPRs()
-	}()
 
 	// While network operations run in background, do local work
 	// Get only branches in the current branch's stack
@@ -413,9 +406,22 @@ func runSync(gitClient git.GitClient, githubClient github.GitHubClient) error {
 		}
 	}
 
-	// Wait for parallel network operations to complete
+	// Collect all branches we need PR info for (stack branches + their parents)
+	prBranchSet := make(map[string]bool)
+	for _, branch := range sorted {
+		prBranchSet[branch.Name] = true
+		prBranchSet[branch.Parent] = true
+	}
+	var prBranches []string
+	for b := range prBranchSet {
+		prBranches = append(prBranches, b)
+	}
+
+	// Wait for git fetch and fetch PRs in parallel for stack branches only
+	var prCache map[string]*github.PRInfo
 	if err := spinner.WrapWithSuccess("Fetching from origin and loading PRs...", "Fetched from origin and loaded PRs", func() error {
 		wg.Wait()
+		prCache = githubClient.GetPRsForBranches(prBranches)
 		return nil
 	}); err != nil {
 		return err
@@ -426,31 +432,6 @@ func runSync(gitClient git.GitClient, githubClient github.GitHubClient) error {
 		return fmt.Errorf("failed to fetch: %w", fetchErr)
 	}
 
-	// Handle PR fetch errors gracefully
-	if prErr != nil {
-		prCache = make(map[string]*github.PRInfo)
-	}
-
-	// GetAllPRs only fetches open PRs (to avoid 502 timeouts on large repos).
-	// For branches in our stack that aren't in the cache, check individually
-	// to detect merged PRs that need special handling.
-	for _, branch := range sorted {
-		// Skip if already in cache (has open PR)
-		if _, exists := prCache[branch.Name]; exists {
-			continue
-		}
-		// Fetch PR info for this branch (might be merged or non-existent)
-		if pr, err := githubClient.GetPRForBranch(branch.Name); err == nil && pr != nil {
-			prCache[branch.Name] = pr
-		}
-		// Also check parent if not in cache
-		if _, exists := prCache[branch.Parent]; !exists {
-			if pr, err := githubClient.GetPRForBranch(branch.Parent); err == nil && pr != nil {
-				prCache[branch.Parent] = pr
-			}
-		}
-	}
-
 	// Get all remote branches in one call (more efficient than checking each branch individually)
 	remoteBranches := gitClient.GetRemoteBranchesSet()