feat: add rate limit handling and duplicate PR prevention

Author: JonCanning

cmd/root.go

@@ -11,11 +11,11 @@ import (
 var Version = "dev"
 
 var rootCmd = &cobra.Command{
-	Use:                "cq",
-	Short:              "Autonomous GitHub issue worker powered by Claude",
-	Version:            Version,
-	CompletionOptions:  cobra.CompletionOptions{DisableDefaultCmd: true},
-	RunE:               runWatch,
+	Use:               "cq",
+	Short:             "Autonomous GitHub issue worker powered by Claude",
+	Version:           Version,
+	CompletionOptions: cobra.CompletionOptions{DisableDefaultCmd: true},
+	RunE:              runWatch,
 }
 
 // Execute runs the root command.

internal/poller/poller.go

@@ -7,6 +7,7 @@ import (
 	"strings"
 
 	"github.com/google/go-github/v69/github"
+	"github.com/tinybluerobots/cq/internal/ratelimit"
 )
 
 // ErrInvalidRepoFormat is returned when a repo string is not in "owner/name" format.
@@ -38,6 +39,10 @@ func (p *Poller) ListRepos(ctx context.Context) ([]string, error) {
 	for {
 		repos, resp, err := p.Client.Repositories.ListByOrg(ctx, p.Org, opts)
 		if err != nil {
+			if ratelimit.Wait(ctx, err) {
+				continue
+			}
+
 			return nil, fmt.Errorf("listing repos for org %s: %w", p.Org, err)
 		}
 
@@ -82,6 +87,10 @@ func (p *Poller) ListIssues(ctx context.Context, repo string) ([]*github.Issue,
 	for {
 		issues, resp, err := p.Client.Issues.ListByRepo(ctx, owner, name, opts)
 		if err != nil {
+			if ratelimit.Wait(ctx, err) {
+				continue
+			}
+
 			return nil, fmt.Errorf("listing issues for %s: %w", repo, err)
 		}
 

internal/ratelimit/ratelimit.go

@@ -0,0 +1,50 @@
+package ratelimit
+
+import (
+	"context"
+	"errors"
+	"log/slog"
+	"time"
+
+	"github.com/google/go-github/v69/github"
+)
+
+// Wait checks if err is a GitHub rate limit error and sleeps until the reset time.
+// Returns true if it waited (caller should retry), false otherwise.
+func Wait(ctx context.Context, err error) bool {
+	var rlErr *github.RateLimitError
+	if errors.As(err, &rlErr) {
+		wait := time.Until(rlErr.Rate.Reset.Time) + time.Second
+		if wait < 0 {
+			wait = time.Minute
+		}
+
+		slog.Warn("rate limited", "reset", rlErr.Rate.Reset.Time, "wait", wait)
+
+		select {
+		case <-time.After(wait):
+			return true
+		case <-ctx.Done():
+			return false
+		}
+	}
+
+	var abuseErr *github.AbuseRateLimitError
+	if errors.As(err, &abuseErr) {
+		wait := abuseErr.GetRetryAfter()
+		if wait == 0 {
+			wait = time.Minute
+		}
+
+		slog.Warn("abuse rate limited", "wait", wait)
+
+		select {
+		case <-time.After(wait):
+			return true
+		case <-ctx.Done():
+			return false
+		}
+	}
+
+	return false
+}

internal/ratelimit/ratelimit_test.go

@@ -0,0 +1,61 @@
+package ratelimit
+
+import (
+	"context"
+	"errors"
+	"testing"
+	"time"
+
+	"github.com/google/go-github/v69/github"
+)
+
+func TestWait_NotRateLimited(t *testing.T) {
+	if Wait(context.Background(), errors.New("some error")) {
+		t.Error("expected false for non-rate-limit error")
+	}
+}
+
+func TestWait_NilError(t *testing.T) {
+	if Wait(context.Background(), nil) {
+		t.Error("expected false for nil error")
+	}
+}
+
+func TestWait_RateLimitError(t *testing.T) {
+	resetTime := time.Now().Add(100 * time.Millisecond)
+	err := &github.RateLimitError{
+		Rate: github.Rate{
+			Remaining: 0,
+			Reset:     github.Timestamp{Time: resetTime},
+		},
+	}
+
+	start := time.Now()
+	ok := Wait(context.Background(), err)
+	elapsed := time.Since(start)
+
+	if !ok {
+		t.Error("expected true for rate limit error")
+	}
+
+	if elapsed < 100*time.Millisecond {
+		t.Errorf("waited only %v, expected >= 100ms", elapsed)
+	}
+}
+
+func TestWait_CancelledContext(t *testing.T) {
+	resetTime := time.Now().Add(10 * time.Second)
+	err := &github.RateLimitError{
+		Rate: github.Rate{
+			Remaining: 0,
+			Reset:     github.Timestamp{Time: resetTime},
+		},
+	}
+
+	ctx, cancel := context.WithCancel(context.Background())
+	cancel()
+
+	if Wait(ctx, err) {
+		t.Error("expected false for cancelled context")
+	}
+}