// Build elegant HTML structure
let html = '
';
- html += `
${sourceName}
`;
+ const repoCount = e.unique_repositories || 0;
+ const publicCount = e.public_repositories || 0;
+ const privateCount = e.private_repositories || 0;
+ const repoText = repoCount === 1 ? 'repository' : 'repositories';
+ const visibilityText = privateCount > 0 ? `(${publicCount} public, ${privateCount} private)` : 'public';
+ html += `
${sourceName} - ${repoCount} ${visibilityText} ${repoText} analyzed
`;
html += '
';
html += `Period: Last ${days} days • `;
html += `Total public PRs: ${e.total_prs} (${e.human_prs} human, ${e.bot_prs} bot) • `;
@@ -2382,7 +2392,8 @@
Why calculate PR costs?
const extPreventableHours = e.code_churn_hours + e.delivery_delay_hours + e.automated_updates_hours + e.pr_tracking_hours;
const extPreventableCost = e.code_churn_cost + e.delivery_delay_cost + e.automated_updates_cost + e.pr_tracking_cost;
const extEfficiencyPct = e.total_hours > 0 ? 100.0 * (e.total_hours - extPreventableHours) / e.total_hours : 100.0;
- const extEfficiency = efficiencyGrade(extEfficiencyPct);
+ // Use grades computed by backend (single source of truth)
+ const extEfficiency = { grade: e.efficiency_grade, message: e.efficiency_message };
const annualMultiplier = 365.0 / parseInt(days);
const annualWasteHours = extPreventableHours * annualMultiplier;
const annualWasteCost = extPreventableCost * annualMultiplier;
@@ -2401,7 +2412,12 @@ Why calculate PR costs?
const mergeRate = e.merge_rate || 0;
const mergedPRs = e.merged_prs || 0;
const unmergedPRs = e.unmerged_prs || 0;
- html += formatEfficiencyHTML(extEfficiencyPct, extEfficiency.grade, extEfficiency.message, extPreventableCost, extPreventableHours, e.total_cost, e.total_hours, avgPRDurationHours, true, annualWasteCost, annualWasteHours, wasteHoursPerWeek, wasteCostPerWeek, wasteHoursPerAuthorPerWeek, wasteCostPerAuthorPerWeek, totalAuthors, salary, benefitsMultiplier, analysisType, sourceName, mergeRate, mergedPRs, unmergedPRs);
+ // Use backend-computed grades (single source of truth)
+ const velocityGrade = e.merge_velocity_grade || '';
+ const velocityMessage = e.merge_velocity_message || '';
+ const mergeRateGrade = e.merge_rate_grade || '';
+ const mergeRateMessage = e.merge_rate_grade_message || '';
+ html += formatEfficiencyHTML(extEfficiencyPct, extEfficiency.grade, extEfficiency.message, extPreventableCost, extPreventableHours, e.total_cost, e.total_hours, avgPRDurationHours, true, annualWasteCost, annualWasteHours, wasteHoursPerWeek, wasteCostPerWeek, wasteHoursPerAuthorPerWeek, wasteCostPerAuthorPerWeek, totalAuthors, salary, benefitsMultiplier, analysisType, sourceName, mergeRate, mergedPRs, unmergedPRs, velocityGrade, velocityMessage, mergeRateGrade, mergeRateMessage);
// Add R2R callout if enabled, otherwise generic merge time callout
// Calculate modeled efficiency (with 1.5h merge time)
diff --git a/pkg/cost/analyze.go b/pkg/cost/analyze.go
index e0062a4..f4261c5 100644
--- a/pkg/cost/analyze.go
+++ b/pkg/cost/analyze.go
@@ -32,12 +32,14 @@ type AnalysisRequest struct {
Concurrency int // Number of concurrent fetches (0 = sequential)
}
-// PRSummaryInfo contains basic PR information needed for fetching.
+// PRSummaryInfo contains basic PR information needed for fetching and analysis.
type PRSummaryInfo struct {
UpdatedAt time.Time
Owner string
Repo string
+ State string // "OPEN", "CLOSED", "MERGED"
Number int
+ Merged bool // Whether the PR was merged
}
// AnalysisResult contains the breakdowns from analyzed PRs.
diff --git a/pkg/cost/cost.go b/pkg/cost/cost.go
index 4426faa..bf6c8a0 100644
--- a/pkg/cost/cost.go
+++ b/pkg/cost/cost.go
@@ -154,12 +154,12 @@ type PRData struct {
CreatedAt time.Time
ClosedAt time.Time
Author string
+ State string
Events []ParticipantEvent
LinesAdded int
LinesDeleted int
AuthorBot bool
- Merged bool // Whether the PR was merged
- State string // PR state: "open", "closed"
+ Merged bool
}
// AuthorCostDetail breaks down the author's costs.
diff --git a/pkg/cost/cost_test.go b/pkg/cost/cost_test.go
index 501e022..7f7e587 100644
--- a/pkg/cost/cost_test.go
+++ b/pkg/cost/cost_test.go
@@ -1261,7 +1261,7 @@ func TestAnalyzePRsContextCancellation(t *testing.T) {
func TestExtrapolateFromSamplesEmpty(t *testing.T) {
cfg := DefaultConfig()
- result := ExtrapolateFromSamples([]Breakdown{}, 100, 10, 5, 30, cfg, []PRMergeStatus{})
+ result := ExtrapolateFromSamples([]Breakdown{}, 100, 10, 5, 30, cfg, []PRSummaryInfo{}, nil)
if result.TotalPRs != 100 {
t.Errorf("Expected TotalPRs=100, got %d", result.TotalPRs)
@@ -1298,12 +1298,12 @@ func TestExtrapolateFromSamplesSingle(t *testing.T) {
// Extrapolate from 1 sample to 10 total PRs
// Create merge status for 10 PRs: 9 merged, 1 open
- prStatuses := make([]PRMergeStatus, 10)
- for i := 0; i < 9; i++ {
- prStatuses[i] = PRMergeStatus{Merged: true, State: "MERGED"}
+ prStatuses := make([]PRSummaryInfo, 10)
+ for i := range 9 {
+ prStatuses[i] = PRSummaryInfo{Owner: "test", Repo: "test", Merged: true, State: "MERGED"}
}
- prStatuses[9] = PRMergeStatus{Merged: false, State: "OPEN"}
- result := ExtrapolateFromSamples([]Breakdown{breakdown}, 10, 2, 0, 7, cfg, prStatuses)
+ prStatuses[9] = PRSummaryInfo{Owner: "test", Repo: "test", Merged: false, State: "OPEN"}
+ result := ExtrapolateFromSamples([]Breakdown{breakdown}, 10, 2, 0, 7, cfg, prStatuses, nil)
if result.TotalPRs != 10 {
t.Errorf("Expected TotalPRs=10, got %d", result.TotalPRs)
@@ -1368,14 +1368,14 @@ func TestExtrapolateFromSamplesMultiple(t *testing.T) {
// Extrapolate from 2 samples to 20 total PRs over 14 days
// Create merge status for 20 PRs: 17 merged, 3 open
- prStatuses := make([]PRMergeStatus, 20)
- for i := 0; i < 17; i++ {
- prStatuses[i] = PRMergeStatus{Merged: true, State: "MERGED"}
+ prStatuses := make([]PRSummaryInfo, 20)
+ for i := range 17 {
+ prStatuses[i] = PRSummaryInfo{Owner: "test", Repo: "test", Merged: true, State: "MERGED"}
}
for i := 17; i < 20; i++ {
- prStatuses[i] = PRMergeStatus{Merged: false, State: "OPEN"}
+ prStatuses[i] = PRSummaryInfo{Owner: "test", Repo: "test", Merged: false, State: "OPEN"}
}
- result := ExtrapolateFromSamples(breakdowns, 20, 5, 3, 14, cfg, prStatuses)
+ result := ExtrapolateFromSamples(breakdowns, 20, 5, 3, 14, cfg, prStatuses, nil)
if result.TotalPRs != 20 {
t.Errorf("Expected TotalPRs=20, got %d", result.TotalPRs)
@@ -1446,11 +1446,11 @@ func TestExtrapolateFromSamplesBotVsHuman(t *testing.T) {
}
// Create merge status for 10 PRs: all merged
- prStatuses := make([]PRMergeStatus, 10)
- for i := 0; i < 10; i++ {
- prStatuses[i] = PRMergeStatus{Merged: true, State: "MERGED"}
+ prStatuses := make([]PRSummaryInfo, 10)
+ for i := range 10 {
+ prStatuses[i] = PRSummaryInfo{Owner: "test", Repo: "test", Merged: true, State: "MERGED"}
}
- result := ExtrapolateFromSamples(breakdowns, 10, 5, 0, 7, cfg, prStatuses)
+ result := ExtrapolateFromSamples(breakdowns, 10, 5, 0, 7, cfg, prStatuses, nil)
// Should have both human and bot PR counts
if result.HumanPRs <= 0 {
@@ -1502,11 +1502,11 @@ func TestExtrapolateFromSamplesWasteCalculation(t *testing.T) {
// Extrapolate over 7 days
// Create merge status for 10 PRs: all merged
- prStatuses := make([]PRMergeStatus, 10)
- for i := 0; i < 10; i++ {
- prStatuses[i] = PRMergeStatus{Merged: true, State: "MERGED"}
+ prStatuses := make([]PRSummaryInfo, 10)
+ for i := range 10 {
+ prStatuses[i] = PRSummaryInfo{Owner: "test", Repo: "test", Merged: true, State: "MERGED"}
}
- result := ExtrapolateFromSamples([]Breakdown{breakdown}, 10, 3, 0, 7, cfg, prStatuses)
+ result := ExtrapolateFromSamples([]Breakdown{breakdown}, 10, 3, 0, 7, cfg, prStatuses, nil)
// Waste per week should be calculated
if result.WasteHoursPerWeek <= 0 {
@@ -1552,14 +1552,14 @@ func TestExtrapolateFromSamplesR2RSavings(t *testing.T) {
}
// Create merge status for 100 PRs: 95 merged, 5 open
- prStatuses := make([]PRMergeStatus, 100)
- for i := 0; i < 95; i++ {
- prStatuses[i] = PRMergeStatus{Merged: true, State: "MERGED"}
+ prStatuses := make([]PRSummaryInfo, 100)
+ for i := range 95 {
+ prStatuses[i] = PRSummaryInfo{Owner: "test", Repo: "test", Merged: true, State: "MERGED"}
}
for i := 95; i < 100; i++ {
- prStatuses[i] = PRMergeStatus{Merged: false, State: "OPEN"}
+ prStatuses[i] = PRSummaryInfo{Owner: "test", Repo: "test", Merged: false, State: "OPEN"}
}
- result := ExtrapolateFromSamples(breakdowns, 100, 10, 5, 30, cfg, prStatuses)
+ result := ExtrapolateFromSamples(breakdowns, 100, 10, 5, 30, cfg, prStatuses, nil)
// R2R savings should be calculated
// Savings formula: baseline waste - remodeled waste - subscription cost
@@ -1597,14 +1597,14 @@ func TestExtrapolateFromSamplesOpenPRTracking(t *testing.T) {
// Test with actual open PRs
actualOpenPRs := 15
// Create merge status for 100 PRs: 85 merged, 15 open
- prStatuses := make([]PRMergeStatus, 100)
- for i := 0; i < 85; i++ {
- prStatuses[i] = PRMergeStatus{Merged: true, State: "MERGED"}
+ prStatuses := make([]PRSummaryInfo, 100)
+ for i := range 85 {
+ prStatuses[i] = PRSummaryInfo{Owner: "test", Repo: "test", Merged: true, State: "MERGED"}
}
for i := 85; i < 100; i++ {
- prStatuses[i] = PRMergeStatus{Merged: false, State: "OPEN"}
+ prStatuses[i] = PRSummaryInfo{Owner: "test", Repo: "test", Merged: false, State: "OPEN"}
}
- result := ExtrapolateFromSamples([]Breakdown{breakdown}, 100, 5, actualOpenPRs, 30, cfg, prStatuses)
+ result := ExtrapolateFromSamples([]Breakdown{breakdown}, 100, 5, actualOpenPRs, 30, cfg, prStatuses, nil)
// Open PRs should match actual count (not extrapolated)
if result.OpenPRs != actualOpenPRs {
@@ -1641,11 +1641,11 @@ func TestExtrapolateFromSamplesParticipants(t *testing.T) {
}, cfg)
// Create merge status for 10 PRs: all merged
- prStatuses := make([]PRMergeStatus, 10)
- for i := 0; i < 10; i++ {
- prStatuses[i] = PRMergeStatus{Merged: true, State: "MERGED"}
+ prStatuses := make([]PRSummaryInfo, 10)
+ for i := range 10 {
+ prStatuses[i] = PRSummaryInfo{Owner: "test", Repo: "test", Merged: true, State: "MERGED"}
}
- result := ExtrapolateFromSamples([]Breakdown{breakdown}, 10, 5, 0, 7, cfg, prStatuses)
+ result := ExtrapolateFromSamples([]Breakdown{breakdown}, 10, 5, 0, 7, cfg, prStatuses, nil)
// Participant costs should be extrapolated
if result.ParticipantReviewCost <= 0 {
diff --git a/pkg/cost/extrapolate.go b/pkg/cost/extrapolate.go
index 019d79d..c4b0f03 100644
--- a/pkg/cost/extrapolate.go
+++ b/pkg/cost/extrapolate.go
@@ -13,6 +13,8 @@ type PRMergeStatus struct {
// ExtrapolatedBreakdown represents cost estimates extrapolated from a sample
// of PRs to estimate total costs across a larger population.
+//
+//nolint:govet // fieldalignment: struct optimized for API clarity over memory layout
type ExtrapolatedBreakdown struct {
// Sample metadata
TotalPRs int `json:"total_prs"` // Total number of PRs in the population
@@ -22,6 +24,9 @@ type ExtrapolatedBreakdown struct {
SuccessfulSamples int `json:"successful_samples"` // Number of samples that processed successfully
UniqueAuthors int `json:"unique_authors"` // Number of unique PR authors (excluding bots) in sample
TotalAuthors int `json:"total_authors"` // Total unique authors across all PRs (not just samples)
+ UniqueRepositories int `json:"unique_repositories"` // Number of unique repositories with PRs
+ PublicRepositories int `json:"public_repositories"` // Number of public repositories analyzed
+ PrivateRepositories int `json:"private_repositories"` // Number of private repositories analyzed
WasteHoursPerWeek float64 `json:"waste_hours_per_week"` // Preventable hours wasted per week (organizational)
WasteCostPerWeek float64 `json:"waste_cost_per_week"` // Preventable cost wasted per week (organizational)
WasteHoursPerAuthorPerWeek float64 `json:"waste_hours_per_author_per_week"` // Preventable hours wasted per author per week
@@ -109,6 +114,14 @@ type ExtrapolatedBreakdown struct {
MergeRate float64 `json:"merge_rate"` // Percentage of PRs successfully merged (0-100)
MergeRateNote string `json:"merge_rate_note"` // Explanation of what counts as merged/unmerged
+ // Grading (computed from metrics above)
+ EfficiencyGrade string `json:"efficiency_grade"` // Letter grade for development efficiency
+ EfficiencyMessage string `json:"efficiency_message"` // Description of efficiency grade
+ MergeVelocityGrade string `json:"merge_velocity_grade"` // Letter grade for merge velocity
+ MergeVelocityMessage string `json:"merge_velocity_message"` // Description of merge velocity grade
+ MergeRateGrade string `json:"merge_rate_grade"` // Letter grade for merge rate
+ MergeRateGradeMessage string `json:"merge_rate_grade_message"` // Description of merge rate grade
+
// R2R cost savings calculation
UniqueNonBotUsers int `json:"unique_non_bot_users"` // Count of unique non-bot users (authors + participants)
R2RSavings float64 `json:"r2r_savings"` // Annual savings if R2R cuts PR time to target merge time
@@ -124,7 +137,8 @@ type ExtrapolatedBreakdown struct {
// - actualOpenPRs: Count of actually open PRs (for tracking overhead)
// - daysInPeriod: Number of days the sample covers (for per-week calculations)
// - cfg: Configuration for hourly rate and hours per week calculation
-// - prStatuses: Merge status for all PRs (for merge rate calculation)
+// - prs: Slice of PR summaries (for merge rate and repository counting)
+// - repoVisibility: Map of repository name to visibility status (nil = assume all public)
//
// Returns:
// - ExtrapolatedBreakdown with averaged costs scaled to total population
@@ -133,28 +147,53 @@ type ExtrapolatedBreakdown struct {
// by the total PR count to estimate population-wide costs.
//
//nolint:revive,maintidx // Complex calculation function benefits from cohesion
-func ExtrapolateFromSamples(breakdowns []Breakdown, totalPRs, totalAuthors, actualOpenPRs int, daysInPeriod int, cfg Config, prStatuses []PRMergeStatus) ExtrapolatedBreakdown {
+func ExtrapolateFromSamples(breakdowns []Breakdown, totalPRs, totalAuthors, actualOpenPRs int, daysInPeriod int, cfg Config, prs []PRSummaryInfo, repoVisibility map[string]bool) ExtrapolatedBreakdown {
+ // Count unique repositories and their visibility
+ uniqueRepos := make(map[string]bool)
+ publicCount := 0
+ privateCount := 0
+
+ for _, pr := range prs {
+ repoKey := pr.Owner + "/" + pr.Repo
+ if uniqueRepos[repoKey] {
+ continue // Already counted this repo
+ }
+ uniqueRepos[repoKey] = true
+
+ // Check visibility - if repoVisibility is nil or doesn't have this repo, assume public
+ if repoVisibility != nil {
+ if isPrivate, ok := repoVisibility[pr.Repo]; ok && isPrivate {
+ privateCount++
+ } else {
+ publicCount++
+ }
+ } else {
+ publicCount++
+ }
+ }
+
if len(breakdowns) == 0 {
// Calculate merge rate even with no successful samples
mergedCount := 0
- for _, status := range prStatuses {
- if status.Merged {
+ for _, pr := range prs {
+ if pr.Merged {
mergedCount++
}
}
mergeRate := 0.0
- if len(prStatuses) > 0 {
- mergeRate = 100.0 * float64(mergedCount) / float64(len(prStatuses))
+ if len(prs) > 0 {
+ mergeRate = 100.0 * float64(mergedCount) / float64(len(prs))
}
return ExtrapolatedBreakdown{
- TotalPRs: totalPRs,
- SampledPRs: 0,
- SuccessfulSamples: 0,
- MergedPRs: mergedCount,
- UnmergedPRs: len(prStatuses) - mergedCount,
- MergeRate: mergeRate,
- MergeRateNote: "Recently modified PRs successfully merged",
+ TotalPRs: totalPRs,
+ SampledPRs: 0,
+ SuccessfulSamples: 0,
+ UniqueRepositories: len(uniqueRepos),
+ MergedPRs: mergedCount,
+ UnmergedPRs: len(prs) - mergedCount,
+ MergeRate: mergeRate,
+ MergeRateNote: "Recently modified PRs successfully merged",
}
}
@@ -485,8 +524,8 @@ func ExtrapolateFromSamples(breakdowns []Breakdown, totalPRs, totalAuthors, actu
// Calculate merge rate from all PRs (not just samples)
mergedCount := 0
unmergedCount := 0
- for _, status := range prStatuses {
- if status.Merged {
+ for _, pr := range prs {
+ if pr.Merged {
mergedCount++
} else {
unmergedCount++
@@ -494,16 +533,30 @@ func ExtrapolateFromSamples(breakdowns []Breakdown, totalPRs, totalAuthors, actu
}
mergeRate := 0.0
- if len(prStatuses) > 0 {
- mergeRate = 100.0 * float64(mergedCount) / float64(len(prStatuses))
+ if len(prs) > 0 {
+ mergeRate = 100.0 * float64(mergedCount) / float64(len(prs))
}
slog.Info("Calculated merge rate from all PRs",
- "total_prs", len(prStatuses),
+ "total_prs", len(prs),
"merged", mergedCount,
"unmerged", unmergedCount,
"merge_rate_pct", mergeRate)
+ // Calculate efficiency percentage and grade
+ productiveCost := extAuthorTotal + extParticipantCost
+ efficiencyPct := 0.0
+ if extTotalCost > 0 {
+ efficiencyPct = 100.0 * productiveCost / extTotalCost
+ }
+ efficiencyGrade, efficiencyMessage := EfficiencyGrade(efficiencyPct)
+
+ // Calculate merge velocity grade
+ mergeVelocityGrade, mergeVelocityMessage := MergeVelocityGrade(avgPRDuration)
+
+ // Calculate merge rate grade
+ mergeRateGrade, mergeRateGradeMessage := MergeRateGrade(mergeRate)
+
return ExtrapolatedBreakdown{
TotalPRs: totalPRs,
HumanPRs: extHumanPRs,
@@ -587,7 +640,17 @@ func ExtrapolateFromSamples(breakdowns []Breakdown, totalPRs, totalAuthors, actu
MergeRate: mergeRate,
MergeRateNote: "Recently modified PRs successfully merged",
- UniqueNonBotUsers: uniqueUserCount,
- R2RSavings: r2rSavings,
+ EfficiencyGrade: efficiencyGrade,
+ EfficiencyMessage: efficiencyMessage,
+ MergeVelocityGrade: mergeVelocityGrade,
+ MergeVelocityMessage: mergeVelocityMessage,
+ MergeRateGrade: mergeRateGrade,
+ MergeRateGradeMessage: mergeRateGradeMessage,
+
+ UniqueNonBotUsers: uniqueUserCount,
+ UniqueRepositories: len(uniqueRepos),
+ PublicRepositories: publicCount,
+ PrivateRepositories: privateCount,
+ R2RSavings: r2rSavings,
}
}
diff --git a/pkg/cost/grading.go b/pkg/cost/grading.go
new file mode 100644
index 0000000..31977d4
--- /dev/null
+++ b/pkg/cost/grading.go
@@ -0,0 +1,63 @@
+package cost
+
+// EfficiencyGrade returns a letter grade and message based on efficiency percentage (MIT scale).
+// Efficiency is the percentage of total cost that goes to productive work (author + participant)
+// vs overhead/delays.
+func EfficiencyGrade(efficiencyPct float64) (grade, message string) {
+ switch {
+ case efficiencyPct >= 97:
+ return "A+", "Impeccable"
+ case efficiencyPct >= 93:
+ return "A", "Excellent"
+ case efficiencyPct >= 90:
+ return "A-", "Nearly excellent"
+ case efficiencyPct >= 87:
+ return "B+", "Acceptable+"
+ case efficiencyPct >= 83:
+ return "B", "Acceptable"
+ case efficiencyPct >= 80:
+ return "B-", "Nearly acceptable"
+ case efficiencyPct >= 70:
+ return "C", "Average"
+ case efficiencyPct >= 60:
+ return "D", "Not good my friend."
+ default:
+ return "F", "Failing"
+ }
+}
+
+// MergeVelocityGrade returns a grade based on average PR open time in hours.
+// Faster merge times indicate better team velocity and lower coordination overhead.
+func MergeVelocityGrade(avgOpenHours float64) (grade, message string) {
+ switch {
+ case avgOpenHours <= 4: // 4 hours
+ return "A+", "World-class velocity"
+ case avgOpenHours <= 24: // 1 day
+ return "A", "High-performing team"
+ case avgOpenHours <= 84: // 3.5 days
+ return "B", "Room for improvement"
+ case avgOpenHours <= 132: // 5.5 days
+ return "C", "Sluggish"
+ case avgOpenHours <= 168: // 7 days (1 week)
+ return "D", "Slow"
+ default:
+ return "F", "Failing"
+ }
+}
+
+// MergeRateGrade returns a grade based on the percentage of PRs successfully merged.
+// Higher merge rates indicate less wasted effort on abandoned work.
+func MergeRateGrade(mergeRatePct float64) (grade, message string) {
+ switch {
+ case mergeRatePct > 90:
+ return "A", "Excellent"
+ case mergeRatePct > 80:
+ return "B", "Good"
+ case mergeRatePct > 70:
+ return "C", "Acceptable"
+ case mergeRatePct > 60:
+ return "D", "Low"
+ default:
+ return "F", "Poor"
+ }
+}
diff --git a/pkg/github/query.go b/pkg/github/query.go
index b8c8861..43f3746 100644
--- a/pkg/github/query.go
+++ b/pkg/github/query.go
@@ -993,3 +993,145 @@ func CountOpenPRsInOrg(ctx context.Context, org, token string) (int, error) {
return count, nil
}
+
+// RepoVisibility contains repository name and privacy status.
+type RepoVisibility struct {
+ Name string
+ IsPrivate bool
+}
+
+// FetchOrgRepositoriesWithActivity fetches all repositories in an organization
+// that had activity (pushes) in the specified time period, along with their privacy status.
+// This is useful for determining which repositories were analyzed and whether they're public or private.
+//
+// Parameters:
+// - ctx: Context for the API call
+// - org: GitHub organization name
+// - since: Only include repos with activity after this time
+// - token: GitHub authentication token
+//
+// Returns:
+// - Map of repository name to RepoVisibility struct
+func FetchOrgRepositoriesWithActivity(ctx context.Context, org string, since time.Time, token string) (map[string]RepoVisibility, error) {
+ query := `
+ query($org: String!, $cursor: String) {
+ organization(login: $org) {
+ repositories(first: 100, after: $cursor, orderBy: {field: PUSHED_AT, direction: DESC}) {
+ pageInfo {
+ hasNextPage
+ endCursor
+ }
+ nodes {
+ name
+ isPrivate
+ pushedAt
+ }
+ }
+ }
+ }
+ `
+
+ repos := make(map[string]RepoVisibility)
+ var cursor *string
+
+ for {
+ variables := map[string]any{
+ "org": org,
+ "cursor": cursor,
+ }
+
+ payload := map[string]any{
+ "query": query,
+ "variables": variables,
+ }
+
+ bodyBytes, err := json.Marshal(payload)
+ if err != nil {
+ return nil, fmt.Errorf("failed to marshal request: %w", err)
+ }
+
+ req, err := http.NewRequestWithContext(ctx, http.MethodPost, "https://api.github.com/graphql", bytes.NewReader(bodyBytes))
+ if err != nil {
+ return nil, fmt.Errorf("failed to create request: %w", err)
+ }
+
+ req.Header.Set("Authorization", "Bearer "+token)
+ req.Header.Set("Content-Type", "application/json")
+
+ client := &http.Client{Timeout: 30 * time.Second}
+ resp, err := client.Do(req)
+ if err != nil {
+ return nil, fmt.Errorf("failed to make request: %w", err)
+ }
+
+ if resp.StatusCode != http.StatusOK {
+ _ = resp.Body.Close() //nolint:errcheck // best effort close on error path
+ return nil, fmt.Errorf("GraphQL request failed with status %d", resp.StatusCode)
+ }
+
+ var result struct {
+ Data struct {
+ Organization struct {
+ Repositories struct {
+ PageInfo struct {
+ EndCursor string
+ HasNextPage bool
+ }
+ Nodes []struct {
+ PushedAt time.Time
+ Name string
+ IsPrivate bool
+ }
+ }
+ }
+ }
+ Errors []struct {
+ Message string
+ }
+ }
+
+ if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
+ _ = resp.Body.Close() //nolint:errcheck // best effort close on error path
+ return nil, fmt.Errorf("failed to decode response: %w", err)
+ }
+ _ = resp.Body.Close() //nolint:errcheck // best effort close after successful read
+
+ if len(result.Errors) > 0 {
+ return nil, fmt.Errorf("GraphQL error: %s", result.Errors[0].Message)
+ }
+
+ // Process repositories and filter by activity date
+ foundRecentActivity := false
+ for _, node := range result.Data.Organization.Repositories.Nodes {
+ if node.PushedAt.Before(since) {
+ // Since repos are ordered by PUSHED_AT DESC, once we hit one before 'since',
+ // all remaining repos will also be before 'since'
+ break
+ }
+ foundRecentActivity = true
+ repos[node.Name] = RepoVisibility{
+ Name: node.Name,
+ IsPrivate: node.IsPrivate,
+ }
+ }
+
+ // If we found no recent activity on this page, we can stop
+ if !foundRecentActivity {
+ break
+ }
+
+ // Continue to next page if there is one
+ if !result.Data.Organization.Repositories.PageInfo.HasNextPage {
+ break
+ }
+
+ cursor = &result.Data.Organization.Repositories.PageInfo.EndCursor
+ }
+
+ slog.Info("Fetched organization repositories with recent activity",
+ "org", org,
+ "since", since.Format(time.RFC3339),
+ "repo_count", len(repos))
+
+ return repos, nil
+}