fix merge conflict

Author: tstromberg

README.md

@@ -20,30 +20,39 @@ Lives in your menubar like a tiny waterfowl of productivity shame, watching your
 - **🧠 Smart turn-based assignment** - knows who is blocking a PR, knows when tests are failing, etc.
 - **⭐ Auto-start** on login (macOS)
 - **🔔 Auto-open** incoming PRs in your browser (off by default, rate-limited)
+- **🎯 Org Filtering** for orgs you may not care about in a home or work context
 
-You can also visit the web-based equivalent at https://dash.ready-to-review.dev/
+You can also visit the web-based dashboard at https://dash.ready-to-review.dev/
 
-## macOS Quick Start ⚡ (How to Get Honked At)
+## Dependencies
 
-### Option 1: Authenticating using GitHub CLI
+* [go](https://go.dev/) 1.23.4 or higher
+* [gh](https://cli.github.com/), AKA the GitHub command-line utility
 
-Install dependencies: the [GitHub CLI, aka "gh"](https://cli.github.com/) and [Go](https://go.dev/):
+## macOS Quick Start ⚡ (Get Honked At)
+
+Install dependencies:
 
 ```bash
 brew install gh go
-gh auth login
 ```
 
-Then summon the goose:
+Confirm that `gh` is properly authenticated:
+
+```
+gh auth status || gh auth login
+```
+
+Build & run:
 
 ```bash
 git clone https://github.com/ready-to-review/goose.git
 cd goose && make run
 ```
 
-`make run` will cause the goose to implant itself into `/Applications/Review Goose.app` for future use. To be persistently annoyed by the goose every time you start your computer, click the `Start at Login` menu item.
+This will will cause the goose to implant itself into `/Applications/Review Goose.app` for future invocations. To be persistently annoyed every time you login, click the `Start at Login` menu item.
 
-### Option 2: Using a fine-grained access token
+### Using a fine-grained access token
 
 If you want more control over which repositories the goose can access, you can use a [fine-grained personal access token](https://github.com/settings/personal-access-tokens/new) with the following permissions:
 
@@ -53,33 +62,31 @@ If you want more control over which repositories the goose can access, you can u
 You can then use the token like so:
 
 ```bash
-export GITHUB_TOKEN=your_token_here
-git clone https://github.com/ready-to-review/goose.git
-cd goose && make run
+env GITHUB_TOKEN=your_token_here goose
 ```
 
-We don't yet try to persist fine-grained tokens to disk - PR's welcome!
+We don't yet persist fine-grained tokens to disk - PR's welcome!
 
 ## Known Issues
 
-- Blocking logic isn't 100% accurate - issues welcome!
+- Visual notifications won't work on macOS until we release signed binaries.
+- Blocking turn logic isn't 100% accurate - open an issue if you find something.
 - The goose may not stop honking until you review your PRs
-- Visual notifications won't work on macOS until we sign the binary
 - Linux, BSD, and Windows support is implemented but untested
 
 ## Pricing
 
-The Goose is part of the [codeGROOVE](https://codegroove.dev) developer acceleration platform:
-- **FREE forever** for open-source or public repositories
-- Coming soon: GitHub Sponsors gain access to private repos ($2.56/mo recommended)
+- Review Goose is free forever for public repositories ❤️
+- Private repo access will soon be a supporter-only feature to ensure the goose is fed. ($2.56/mo is our recommendation)
 
 ## Privacy
 
 - Your GitHub token is used to authenticate against GitHub and codeGROOVE's API for state-machine & natural-language processing
-- Your GitHub token is never stored or logged,
-- PR metadata may be locally or remotely cached for up to 20 days (performance)
+- Your GitHub token is never stored or logged.
+- PR metadata may be cached locally & remotely for up to 20 days
+- No data is resold to anyone. We don't even want it.
 - No telemetry is collected
 
 ---
 
-Built with ❤️ by [codeGROOVE](https://codegroove.dev/) - PRs welcome!
+Built with 🪿 by [codeGROOVE](https://codegroove.dev/) - PRs welcome!

cmd/goose/filtering_test.go

@@ -0,0 +1,157 @@
+package main
+
+import (
+	"testing"
+	"time"
+)
+
+// TestCountPRsWithHiddenOrgs tests that PRs from hidden orgs are not counted
+func TestCountPRsWithHiddenOrgs(t *testing.T) {
+	app := &App{
+		incoming: []PR{
+			{Repository: "org1/repo1", NeedsReview: true, UpdatedAt: time.Now()},
+			{Repository: "org2/repo2", NeedsReview: true, UpdatedAt: time.Now()},
+			{Repository: "org3/repo3", NeedsReview: true, UpdatedAt: time.Now()},
+		},
+		outgoing: []PR{
+			{Repository: "org1/repo4", IsBlocked: true, UpdatedAt: time.Now()},
+			{Repository: "org2/repo5", IsBlocked: true, UpdatedAt: time.Now()},
+		},
+		hiddenOrgs: map[string]bool{
+			"org2": true, // Hide org2
+		},
+		hideStaleIncoming: false,
+	}
+
+	counts := app.countPRs()
+
+	// Should only count PRs from org1 and org3, not org2
+	if counts.IncomingTotal != 2 {
+		t.Errorf("IncomingTotal = %d, want 2 (org2 should be hidden)", counts.IncomingTotal)
+	}
+	if counts.IncomingBlocked != 2 {
+		t.Errorf("IncomingBlocked = %d, want 2 (org2 should be hidden)", counts.IncomingBlocked)
+	}
+	if counts.OutgoingTotal != 1 {
+		t.Errorf("OutgoingTotal = %d, want 1 (org2 should be hidden)", counts.OutgoingTotal)
+	}
+	if counts.OutgoingBlocked != 1 {
+		t.Errorf("OutgoingBlocked = %d, want 1 (org2 should be hidden)", counts.OutgoingBlocked)
+	}
+}
+
+// TestCountPRsWithStalePRs tests that stale PRs are not counted when hideStaleIncoming is true
+func TestCountPRsWithStalePRs(t *testing.T) {
+	now := time.Now()
+	staleTime := now.Add(-100 * 24 * time.Hour) // 100 days ago
+	recentTime := now.Add(-1 * time.Hour)       // 1 hour ago
+
+	app := &App{
+		incoming: []PR{
+			{Repository: "org1/repo1", NeedsReview: true, UpdatedAt: staleTime},
+			{Repository: "org1/repo2", NeedsReview: true, UpdatedAt: recentTime},
+			{Repository: "org2/repo3", NeedsReview: false, UpdatedAt: staleTime},
+		},
+		outgoing: []PR{
+			{Repository: "org1/repo4", IsBlocked: true, UpdatedAt: staleTime},
+			{Repository: "org1/repo5", IsBlocked: true, UpdatedAt: recentTime},
+		},
+		hiddenOrgs:        map[string]bool{},
+		hideStaleIncoming: true, // Hide stale PRs
+	}
+
+	counts := app.countPRs()
+
+	// Should only count recent PRs
+	if counts.IncomingTotal != 1 {
+		t.Errorf("IncomingTotal = %d, want 1 (stale PRs should be hidden)", counts.IncomingTotal)
+	}
+	if counts.IncomingBlocked != 1 {
+		t.Errorf("IncomingBlocked = %d, want 1 (stale PRs should be hidden)", counts.IncomingBlocked)
+	}
+	if counts.OutgoingTotal != 1 {
+		t.Errorf("OutgoingTotal = %d, want 1 (stale PRs should be hidden)", counts.OutgoingTotal)
+	}
+	if counts.OutgoingBlocked != 1 {
+		t.Errorf("OutgoingBlocked = %d, want 1 (stale PRs should be hidden)", counts.OutgoingBlocked)
+	}
+}
+
+// TestCountPRsWithBothFilters tests that both filters work together
+func TestCountPRsWithBothFilters(t *testing.T) {
+	now := time.Now()
+	staleTime := now.Add(-100 * 24 * time.Hour)
+	recentTime := now.Add(-1 * time.Hour)
+
+	app := &App{
+		incoming: []PR{
+			{Repository: "org1/repo1", NeedsReview: true, UpdatedAt: recentTime},  // Should be counted
+			{Repository: "org2/repo2", NeedsReview: true, UpdatedAt: recentTime},  // Hidden org
+			{Repository: "org3/repo3", NeedsReview: true, UpdatedAt: staleTime},   // Stale
+			{Repository: "org1/repo4", NeedsReview: false, UpdatedAt: recentTime}, // Not blocked
+		},
+		outgoing: []PR{
+			{Repository: "org1/repo5", IsBlocked: true, UpdatedAt: recentTime}, // Should be counted
+			{Repository: "org2/repo6", IsBlocked: true, UpdatedAt: recentTime}, // Hidden org
+			{Repository: "org3/repo7", IsBlocked: true, UpdatedAt: staleTime},  // Stale
+		},
+		hiddenOrgs: map[string]bool{
+			"org2": true,
+		},
+		hideStaleIncoming: true,
+	}
+
+	counts := app.countPRs()
+
+	// Should only count org1/repo1 (incoming) and org1/repo5 (outgoing)
+	if counts.IncomingTotal != 2 {
+		t.Errorf("IncomingTotal = %d, want 2", counts.IncomingTotal)
+	}
+	if counts.IncomingBlocked != 1 {
+		t.Errorf("IncomingBlocked = %d, want 1", counts.IncomingBlocked)
+	}
+	if counts.OutgoingTotal != 1 {
+		t.Errorf("OutgoingTotal = %d, want 1", counts.OutgoingTotal)
+	}
+	if counts.OutgoingBlocked != 1 {
+		t.Errorf("OutgoingBlocked = %d, want 1", counts.OutgoingBlocked)
+	}
+}
+
+// TestExtractOrgFromRepo tests the org extraction function
+func TestExtractOrgFromRepo(t *testing.T) {
+	tests := []struct {
+		repo string
+		name string
+		want string
+	}{
+		{
+			name: "standard repo path",
+			repo: "microsoft/vscode",
+			want: "microsoft",
+		},
+		{
+			name: "single segment",
+			repo: "justarepo",
+			want: "justarepo",
+		},
+		{
+			name: "empty string",
+			repo: "",
+			want: "",
+		},
+		{
+			name: "nested path",
+			repo: "org/repo/subpath",
+			want: "org",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := extractOrgFromRepo(tt.repo); got != tt.want {
+				t.Errorf("extractOrgFromRepo(%q) = %q, want %q", tt.repo, got, tt.want)
+			}
+		})
+	}
+}

cmd/goose/github.go

@@ -20,6 +20,15 @@ import (
 	"golang.org/x/oauth2"
 )
 
+// extractOrgFromRepo extracts the organization name from a repository path like "org/repo".
+func extractOrgFromRepo(repo string) string {
+	parts := strings.Split(repo, "/")
+	if len(parts) >= 1 {
+		return parts[0]
+	}
+	return ""
+}
+
 // initClients initializes GitHub and Turn API clients.
 func (app *App) initClients(ctx context.Context) error {
 	token, err := app.token(ctx)
@@ -321,6 +330,17 @@ func (app *App) fetchPRsInternal(ctx context.Context, waitForTurn bool) (incomin
 		}
 		repo := strings.TrimPrefix(issue.GetRepositoryURL(), "https://api.github.com/repos/")
 
+		// Extract org and track it (but don't filter here)
+		org := extractOrgFromRepo(repo)
+		if org != "" {
+			app.mu.Lock()
+			if !app.seenOrgs[org] {
+				log.Printf("[ORG] Discovered new organization: %s", org)
+			}
+			app.seenOrgs[org] = true
+			app.mu.Unlock()
+		}
+
 		pr := PR{
 			Title:      issue.GetTitle(),
 			URL:        issue.GetHTMLURL(),

cmd/goose/main.go

@@ -98,6 +98,8 @@ type App struct {
 	enableAutoBrowser   bool
 	hideStaleIncoming   bool
 	noCache             bool
+	hiddenOrgs          map[string]bool
+	seenOrgs            map[string]bool
 }
 
 func loadCurrentUser(ctx context.Context, app *App) {
@@ -220,6 +222,8 @@ func main() {
 		enableAutoBrowser:  false, // Default to false for safety
 		browserRateLimiter: NewBrowserRateLimiter(browserOpenDelay, maxBrowserOpensMinute, maxBrowserOpensDay),
 		startTime:          time.Now(),
+		seenOrgs:           make(map[string]bool),
+		hiddenOrgs:         make(map[string]bool),
 	}
 
 	// Load saved settings
@@ -627,6 +631,12 @@ func (app *App) checkForNewlyBlockedPRs(ctx context.Context) {
 		}
 	}
 
+	// Get hidden orgs for filtering
+	hiddenOrgs := make(map[string]bool)
+	for org, hidden := range app.hiddenOrgs {
+		hiddenOrgs[org] = hidden
+	}
+
 	// Log any removed entries
 	removedCount := 0
 	for url := range app.blockedPRTimes {
@@ -656,6 +666,12 @@ func (app *App) checkForNewlyBlockedPRs(ctx context.Context) {
 
 	// Check incoming PRs
 	for i := range incoming {
+		// Skip PRs from hidden orgs for notifications
+		org := extractOrgFromRepo(incoming[i].Repository)
+		if org != "" && hiddenOrgs[org] {
+			continue
+		}
+
 		if !incoming[i].NeedsReview {
 			continue
 		}
@@ -700,6 +716,12 @@ func (app *App) checkForNewlyBlockedPRs(ctx context.Context) {
 
 	// Check outgoing PRs
 	for i := range outgoing {
+		// Skip PRs from hidden orgs for notifications
+		org := extractOrgFromRepo(outgoing[i].Repository)
+		if org != "" && hiddenOrgs[org] {
+			continue
+		}
+
 		if !outgoing[i].IsBlocked {
 			continue
 		}