Now it kinda works

Author: tstromberg

analysis.go

@@ -0,0 +1,59 @@
+package main
+
+import (
+	"sync"
+	"time"
+)
+
+// cacheEntry holds a cached value with expiration.
+type cacheEntry struct {
+	value      interface{}
+	expiration time.Time
+}
+
+// cache provides thread-safe caching with TTL.
+type cache struct {
+	mu      sync.RWMutex
+	entries map[string]cacheEntry
+	ttl     time.Duration
+}
+
+// newCache creates a new cache with the given TTL.
+func newCache(ttl time.Duration) *cache {
+	return &cache{
+		entries: make(map[string]cacheEntry),
+		ttl:     ttl,
+	}
+}
+
+// get retrieves a value from cache if not expired.
+func (c *cache) get(key string) (interface{}, bool) {
+	c.mu.RLock()
+	defer c.mu.RUnlock()
+	
+	entry, exists := c.entries[key]
+	if !exists || time.Now().After(entry.expiration) {
+		return nil, false
+	}
+	
+	return entry.value, true
+}
+
+// set stores a value in cache with TTL.
+func (c *cache) set(key string, value interface{}) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	
+	c.entries[key] = cacheEntry{
+		value:      value,
+		expiration: time.Now().Add(c.ttl),
+	}
+}
+
+// clear removes all entries from cache.
+func (c *cache) clear() {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	
+	c.entries = make(map[string]cacheEntry)
+}

better-reviewers

@@ -0,0 +1,27 @@
+package main
+
+import "time"
+
+// Selection methods for reviewer choice tracking
+const (
+	selectionAssignee          = "assignee-expert"
+	selectionAuthorOverlap     = "author-overlap"
+	selectionAuthorDirectory   = "author-directory" 
+	selectionAuthorProject     = "author-project"
+	selectionReviewerCommenter = "reviewer-commenter"
+	selectionReviewerOverlap   = "reviewer-overlap"
+	selectionReviewerDirectory = "reviewer-directory"
+	selectionReviewerProject   = "reviewer-project"
+)
+
+// Configuration constants
+const (
+	httpTimeout       = 120 // seconds
+	maxRetries        = 3
+	retryDelay        = 2 // seconds
+	nearbyLines       = 3 // lines within this distance count as "nearby"
+	maxFilesToAnalyze = 10
+	maxHistoricalPRs  = 50 // With caching, we can afford more lookups
+	maxRecentPRs      = 20 // Reasonable limit for recent PRs
+	cacheTTL          = 15 * time.Minute // Cache results for 15 minutes
+)

better-reviewers-new

@@ -0,0 +1,139 @@
+package main
+
+import (
+	"context"
+)
+
+// findDirectoryAuthor finds the most recent author in the affected directories.
+func (rf *ReviewerFinder) findDirectoryAuthor(ctx context.Context, pr *PullRequest, files []string) string {
+	directories := rf.getDirectories(files)
+	
+	for _, dir := range directories {
+		if author := rf.findRecentAuthorInDirectory(ctx, pr.Owner, pr.Repository, dir); author != "" {
+			if author != pr.Author && rf.isValidReviewer(ctx, pr, author) {
+				return author
+			}
+		}
+	}
+	
+	return ""
+}
+
+// findProjectAuthor finds the most recent author in the project.
+func (rf *ReviewerFinder) findProjectAuthor(ctx context.Context, pr *PullRequest) string {
+	authors := rf.findRecentAuthorsInProject(ctx, pr.Owner, pr.Repository, 10)
+	
+	for _, author := range authors {
+		if author != pr.Author && rf.isValidReviewer(ctx, pr, author) {
+			return author
+		}
+	}
+	
+	return ""
+}
+
+// findCommenterReviewer finds recent PR commenters who can review.
+func (rf *ReviewerFinder) findCommenterReviewer(ctx context.Context, pr *PullRequest, excludeAuthor string) string {
+	excludeUsers := []string{pr.Author}
+	if excludeAuthor != "" {
+		excludeUsers = append(excludeUsers, excludeAuthor)
+	}
+	
+	commenters, err := rf.getRecentPRCommenters(ctx, pr.Owner, pr.Repository, excludeUsers)
+	if err != nil {
+		return ""
+	}
+	
+	for _, commenter := range commenters {
+		if rf.isValidReviewer(ctx, pr, commenter) {
+			return commenter
+		}
+	}
+	
+	return ""
+}
+
+// findDirectoryReviewer finds the most active reviewer in the affected directories.
+func (rf *ReviewerFinder) findDirectoryReviewer(ctx context.Context, pr *PullRequest, files []string, excludeAuthor string) string {
+	directories := rf.getDirectories(files)
+	
+	for _, dir := range directories {
+		if reviewer := rf.findActiveReviewerInDirectory(ctx, pr.Owner, pr.Repository, dir); reviewer != "" {
+			if reviewer != pr.Author && reviewer != excludeAuthor && rf.isValidReviewer(ctx, pr, reviewer) {
+				return reviewer
+			}
+		}
+	}
+	
+	return ""
+}
+
+// findProjectReviewer finds the most active reviewer in the project.
+func (rf *ReviewerFinder) findProjectReviewer(ctx context.Context, pr *PullRequest, excludeAuthor string) string {
+	reviewers := rf.findActiveReviewersInProject(ctx, pr.Owner, pr.Repository, 10)
+	
+	for _, reviewer := range reviewers {
+		if reviewer != pr.Author && reviewer != excludeAuthor && rf.isValidReviewer(ctx, pr, reviewer) {
+			return reviewer
+		}
+	}
+	
+	return ""
+}
+
+// findRecentAuthorInDirectory finds the most recent commit author in a directory.
+func (rf *ReviewerFinder) findRecentAuthorInDirectory(ctx context.Context, owner, repo, directory string) string {
+	prs, err := rf.getRecentPRsInDirectory(ctx, owner, repo, directory)
+	if err != nil {
+		return ""
+	}
+	
+	fc := make(frequencyCounter)
+	for _, pr := range prs {
+		fc.add(pr.Author)
+	}
+	return fc.best()
+}
+
+// findActiveReviewerInDirectory finds the most active reviewer in a directory.
+func (rf *ReviewerFinder) findActiveReviewerInDirectory(ctx context.Context, owner, repo, directory string) string {
+	prs, err := rf.getRecentPRsInDirectory(ctx, owner, repo, directory)
+	if err != nil {
+		return ""
+	}
+	
+	fc := make(frequencyCounter)
+	for _, pr := range prs {
+		fc.addAll(pr.Reviewers)
+	}
+	return fc.best()
+}
+
+// findRecentAuthorsInProject finds recent commit authors in the project.
+func (rf *ReviewerFinder) findRecentAuthorsInProject(ctx context.Context, owner, repo string, limit int) []string {
+	prs, err := rf.getRecentPRsInProject(ctx, owner, repo)
+	if err != nil {
+		return nil
+	}
+	
+	fc := make(frequencyCounter)
+	for _, pr := range prs {
+		fc.add(pr.Author)
+	}
+	return fc.top(limit)
+}
+
+// findActiveReviewersInProject finds active reviewers in the project.
+func (rf *ReviewerFinder) findActiveReviewersInProject(ctx context.Context, owner, repo string, limit int) []string {
+	prs, err := rf.getRecentPRsInProject(ctx, owner, repo)
+	if err != nil {
+		return nil
+	}
+	
+	fc := make(frequencyCounter)
+	for _, pr := range prs {
+		fc.addAll(pr.Reviewers)
+	}
+	return fc.top(limit)
+}
+