fix: use --repo flag for gh commands to handle multiple remotes

cmd/prune.go

@@ -44,7 +44,8 @@ If a branch has unmerged commits locally, use --force to delete it anyway.`,
   stack prune --dry-run`,
 	Run: func(cmd *cobra.Command, args []string) {
 		gitClient := git.NewGitClient()
-		githubClient := github.NewGitHubClient()
+		repo := github.ParseRepoFromURL(gitClient.GetRemoteURL("origin"))
+		githubClient := github.NewGitHubClient(repo)
 
 		if err := runPrune(gitClient, githubClient); err != nil {
 			fmt.Fprintf(os.Stderr, "Error: %v\n", err)

cmd/reparent.go

@@ -34,7 +34,8 @@ This is useful for:
 		newParent := args[0]
 
 		gitClient := git.NewGitClient()
-		githubClient := github.NewGitHubClient()
+		repo := github.ParseRepoFromURL(gitClient.GetRemoteURL("origin"))
+		githubClient := github.NewGitHubClient(repo)
 
 		if err := runReparent(gitClient, githubClient, newParent); err != nil {
 			fmt.Fprintf(os.Stderr, "Error: %v\n", err)

cmd/status.go

@@ -41,7 +41,8 @@ This helps you visualize your stack and see which branches have PRs.`,
   #  feature-auth-tests *`,
 	Run: func(cmd *cobra.Command, args []string) {
 		gitClient := git.NewGitClient()
-		githubClient := github.NewGitHubClient()
+		repo := github.ParseRepoFromURL(gitClient.GetRemoteURL("origin"))
+		githubClient := github.NewGitHubClient(repo)
 
 		if err := runStatus(gitClient, githubClient); err != nil {
 			fmt.Fprintf(os.Stderr, "Error: %v\n", err)

cmd/sync.go

@@ -72,7 +72,8 @@ Uncommitted changes are automatically stashed and reapplied (using --autostash).
   stack sync`,
 	Run: func(cmd *cobra.Command, args []string) {
 		gitClient := git.NewGitClient()
-		githubClient := github.NewGitHubClient()
+		repo := github.ParseRepoFromURL(gitClient.GetRemoteURL("origin"))
+		githubClient := github.NewGitHubClient(repo)
 
 		if err := runSync(gitClient, githubClient); err != nil {
 			// Don't print if error was already displayed with detailed message

cmd/worktree.go

@@ -52,7 +52,8 @@ Use --prune to clean up worktrees for branches with merged PRs.`,
 	},
 	Run: func(cmd *cobra.Command, args []string) {
 		gitClient := git.NewGitClient()
-		githubClient := github.NewGitHubClient()
+		repo := github.ParseRepoFromURL(gitClient.GetRemoteURL("origin"))
+		githubClient := github.NewGitHubClient(repo)
 
 		var err error
 		if worktreePrune {

internal/git/git.go

@@ -648,3 +648,8 @@ func (c *gitClient) ListWorktrees() ([]string, error) {
 
 	return paths, nil
 }
+
+// GetRemoteURL returns the URL of the specified remote (e.g., "origin")
+func (c *gitClient) GetRemoteURL(remoteName string) string {
+	return c.runCmdMayFail("remote", "get-url", remoteName)
+}

internal/git/interface.go

@@ -48,4 +48,5 @@ type GitClient interface {
 	AddWorktreeFromRemote(path, branch string) error
 	RemoveWorktree(path string) error
 	ListWorktrees() ([]string, error)
+	GetRemoteURL(remoteName string) string
 }

internal/github/github.go

@@ -26,15 +26,60 @@ type PRInfo struct {
 }
 
 // githubClient implements the GitHubClient interface using exec.Command
-type githubClient struct{}
+type githubClient struct {
+	repo string // OWNER/REPO format, used with --repo flag
+}
 
 // NewGitHubClient creates a new GitHubClient implementation
-func NewGitHubClient() GitHubClient {
-	return &githubClient{}
+// repo should be in OWNER/REPO format (e.g., "javoire/stackinator")
+func NewGitHubClient(repo string) GitHubClient {
+	return &githubClient{repo: repo}
+}
+
+// ParseRepoFromURL extracts OWNER/REPO from a git remote URL
+// Supports formats:
+//   - git@github.com:owner/repo.git
+//   - https://github.com/owner/repo.git
+//   - git@ghe.spotify.net:owner/repo.git
+//   - https://ghe.spotify.net/owner/repo
+func ParseRepoFromURL(remoteURL string) string {
+	remoteURL = strings.TrimSpace(remoteURL)
+	if remoteURL == "" {
+		return ""
+	}
+
+	// Remove .git suffix
+	remoteURL = strings.TrimSuffix(remoteURL, ".git")
+
+	// Handle SSH format: git@host:owner/repo
+	if strings.HasPrefix(remoteURL, "git@") {
+		parts := strings.SplitN(remoteURL, ":", 2)
+		if len(parts) == 2 {
+			return parts[1]
+		}
+	}
+
+	// Handle HTTPS format: https://host/owner/repo
+	if strings.HasPrefix(remoteURL, "https://") || strings.HasPrefix(remoteURL, "http://") {
+		// Find the path after the host
+		afterScheme := strings.TrimPrefix(remoteURL, "https://")
+		afterScheme = strings.TrimPrefix(afterScheme, "http://")
+		// Split host from path
+		slashIdx := strings.Index(afterScheme, "/")
+		if slashIdx != -1 {
+			return afterScheme[slashIdx+1:]
+		}
+	}
+
+	return ""
 }
 
 // runGH executes a gh CLI command and returns stdout
 func (c *githubClient) runGH(args ...string) (string, error) {
+	// Add --repo flag if repo is set (ensures correct repo with multiple remotes)
+	if c.repo != "" {
+		args = append([]string{"--repo", c.repo}, args...)
+	}
 	if Verbose {
 		fmt.Printf("  [gh] %s\n", strings.Join(args, " "))
 	}

internal/github/github_test.go

@@ -26,10 +26,56 @@ func TestPRInfoParsing(t *testing.T) {
 }
 
 func TestNewGitHubClient(t *testing.T) {
-	client := NewGitHubClient()
+	client := NewGitHubClient("owner/repo")
 	assert.NotNil(t, client)
 }
 
+func TestParseRepoFromURL(t *testing.T) {
+	tests := []struct {
+		name     string
+		url      string
+		expected string
+	}{
+		{
+			name:     "SSH format",
+			url:      "git@github.com:javoire/stackinator.git",
+			expected: "javoire/stackinator",
+		},
+		{
+			name:     "HTTPS format",
+			url:      "https://github.com/javoire/stackinator.git",
+			expected: "javoire/stackinator",
+		},
+		{
+			name:     "HTTPS without .git",
+			url:      "https://github.com/javoire/stackinator",
+			expected: "javoire/stackinator",
+		},
+		{
+			name:     "GHE SSH format",
+			url:      "git@ghe.spotify.net:some-org/some-repo.git",
+			expected: "some-org/some-repo",
+		},
+		{
+			name:     "GHE HTTPS format",
+			url:      "https://ghe.spotify.net/some-org/some-repo",
+			expected: "some-org/some-repo",
+		},
+		{
+			name:     "empty string",
+			url:      "",
+			expected: "",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := ParseRepoFromURL(tt.url)
+			assert.Equal(t, tt.expected, result)
+		})
+	}
+}
+
 // Note: More comprehensive tests would require mocking exec.Command or running actual gh CLI commands
 // For unit tests focused on critical path, we rely on integration tests or testutil mocks
 

internal/testutil/mocks.go

@@ -246,6 +246,11 @@ func (m *MockGitClient) ListWorktrees() ([]string, error) {
 	return args.Get(0).([]string), args.Error(1)
 }
 
+func (m *MockGitClient) GetRemoteURL(remoteName string) string {
+	args := m.Called(remoteName)
+	return args.String(0)
+}
+
 // MockGitHubClient is a mock implementation of github.GitHubClient for testing
 type MockGitHubClient struct {
 	mock.Mock