Merge pull request #3 from tstromberg/main

Improve alignment

Author: tstromberg

internal/server/server.go

@@ -1765,7 +1765,7 @@ func (s *Server) processRepoSampleWithProgress(ctx context.Context, req *RepoSam
 			PR:       0,
 			Owner:    req.Owner,
 			Repo:     req.Repo,
-			Progress: "Querying GitHub for PRs...",
+			Progress: fmt.Sprintf("Querying GitHub GraphQL API for %s/%s PRs (last %d days)...", req.Owner, req.Repo, req.Days),
 		}))
 
 		// Start keep-alive to prevent client timeout during GraphQL query
@@ -1890,7 +1890,7 @@ func (s *Server) processOrgSampleWithProgress(ctx context.Context, req *OrgSampl
 		logSSEError(ctx, s.logger, sendSSE(writer, ProgressUpdate{
 			Type:     "fetching",
 			PR:       0,
-			Progress: "Querying GitHub for PRs...",
+			Progress: fmt.Sprintf("Querying GitHub Search API for %s org PRs (last %d days)...", req.Org, req.Days),
 		}))
 
 		// Start keep-alive to prevent client timeout during GraphQL query
@@ -1965,29 +1965,14 @@ func (s *Server) processOrgSampleWithProgress(ctx context.Context, req *OrgSampl
 	// Count unique authors across all PRs (not just samples)
 	totalAuthors := github.CountUniqueAuthors(prs)
 
-	// Count open PRs across all unique repos in the organization
-	uniqueRepos := make(map[string]bool)
-	for _, pr := range prs {
-		repoKey := pr.Owner + "/" + pr.Repo
-		uniqueRepos[repoKey] = true
-	}
-
-	totalOpenPRs := 0
-	for repoKey := range uniqueRepos {
-		parts := strings.SplitN(repoKey, "/", 2)
-		if len(parts) != 2 {
-			continue
-		}
-		owner, repo := parts[0], parts[1]
-		//nolint:contextcheck // Using background context intentionally to prevent client timeout from canceling work
-		openCount, err := github.CountOpenPRsInRepo(workCtx, owner, repo, token)
-		if err != nil {
-			s.logger.WarnContext(ctx, "Failed to count open PRs for repo", "repo", repoKey, errorKey, err)
-			continue
-		}
-		totalOpenPRs += openCount
+	// Count open PRs across the entire organization with a single GraphQL query
+	//nolint:contextcheck // Using background context intentionally to prevent client timeout from canceling work
+	totalOpenPRs, err := github.CountOpenPRsInOrg(workCtx, req.Org, token)
+	if err != nil {
+		s.logger.WarnContext(ctx, "Failed to count open PRs for organization", "org", req.Org, errorKey, err)
+		totalOpenPRs = 0 // Continue with 0 if we can't get the count
 	}
-	s.logger.InfoContext(ctx, "Counted total open PRs across organization", "open_prs", totalOpenPRs, "repos", len(uniqueRepos))
+	s.logger.InfoContext(ctx, "Counted total open PRs across organization", "open_prs", totalOpenPRs, "org", req.Org)
 
 	// Extrapolate costs from samples
 	extrapolated := cost.ExtrapolateFromSamples(breakdowns, len(prs), totalAuthors, totalOpenPRs, actualDays, cfg)

internal/server/static/index.html

@@ -1624,7 +1624,7 @@ <h3>Why calculate PR costs?</h3>
                 output += `    Automated Updates          ${formatCurrency(avgAutomatedUpdatesCost).padStart(10)}    ${formatTimeUnit(avgAutomatedUpdatesHours)}  (${e.bot_prs} PRs)\n`;
             }
             if (avgPRTrackingCost > 0.01) {
-                output += `    PR Tracking           ${formatCurrency(avgPRTrackingCost).padStart(10)}    ${formatTimeUnit(avgPRTrackingHours)}  (${e.open_prs} open PRs)\n`;
+                output += `    PR Tracking                ${formatCurrency(avgPRTrackingCost).padStart(10)}    ${formatTimeUnit(avgPRTrackingHours)}  (${e.open_prs} open PRs)\n`;
             }
             const avgMergeDelayCost = avgDeliveryDelayCost + avgCodeChurnCost + avgAutomatedUpdatesCost + avgPRTrackingCost;
             const avgMergeDelayHours = avgDeliveryDelayHours + avgCodeChurnHours + avgAutomatedUpdatesHours + avgPRTrackingHours;
@@ -1656,11 +1656,6 @@ <h3>Why calculate PR costs?</h3>
                 output += `    Subtotal                   ${formatCurrency(avgFutureCost).padStart(10)}    ${formatTimeUnit(avgFutureHours)}  (${pct.toFixed(1)}%)\n\n`;
             }
 
-            // Weekly waste per PR author
-            if (e.waste_hours_per_author_per_week > 0 && e.total_authors > 0) {
-                output += `  Weekly waste per PR author:       ${formatCurrency(e.waste_cost_per_author_per_week).padStart(10)}    ${formatTimeUnit(e.waste_hours_per_author_per_week)}  (${e.total_authors} authors)\n`;
-            }
-
             // Average Preventable Loss Total (before grand total)
             const avgPreventableCost = avgCodeChurnCost + avgDeliveryDelayCost + avgCodeChurnCost + (e.automated_updates_cost / totalPRs) + (e.pr_tracking_cost / totalPRs);
             const avgPreventableHours = avgCodeChurnHours + avgDeliveryDelayHours + avgCodeChurnHours + (e.automated_updates_hours / totalPRs) + (e.pr_tracking_hours / totalPRs);
@@ -1693,7 +1688,7 @@ <h3>Why calculate PR costs?</h3>
 
             // Show bot PR LOC even though cost is $0
             if ((e.bot_prs || 0) > 0) {
-                output += `    Automated Updates              —         ${formatTimeUnit(0)}  (${e.bot_prs} PRs, ${botLOC.toFixed(1)}k LOC)\n`;
+                output += `    Automated Updates          —             ${formatTimeUnit(0)}  (${e.bot_prs} PRs, ${botLOC.toFixed(1)}k LOC)\n`;
             }
 
             output += '                                ──────────\n';
@@ -1732,7 +1727,7 @@ <h3>Why calculate PR costs?</h3>
                 output += `    Automated Updates          ${formatCurrency(e.automated_updates_cost).padStart(10)}    ${formatTimeUnit(e.automated_updates_hours)}  (${e.bot_prs || 0} PRs)\n`;
             }
             if ((e.pr_tracking_cost || 0) > 0) {
-                output += `    PR Tracking           ${formatCurrency(e.pr_tracking_cost).padStart(10)}    ${formatTimeUnit(e.pr_tracking_hours)}  (${e.open_prs || 0} open PRs)\n`;
+                output += `    PR Tracking                ${formatCurrency(e.pr_tracking_cost).padStart(10)}    ${formatTimeUnit(e.pr_tracking_hours)}  (${e.open_prs || 0} open PRs)\n`;
             }
 
             const mergeDelayCost = (e.delivery_delay_cost || 0) + (e.code_churn_cost || 0) + (e.automated_updates_cost || 0) + (e.pr_tracking_cost || 0);
@@ -1769,14 +1764,14 @@ <h3>Why calculate PR costs?</h3>
 
             // Weekly waste per PR author
             if ((e.waste_hours_per_author_per_week || 0) > 0 && (e.total_authors || 0) > 0) {
-                output += `  Weekly waste per PR author:     ${formatCurrency(e.waste_cost_per_author_per_week).padStart(10)}    ${formatTimeUnit(e.waste_hours_per_author_per_week)}  (${e.total_authors} authors)\n`;
+                output += `  Weekly waste per PR author:     ${formatCurrency(e.waste_cost_per_author_per_week).padStart(12)}    ${formatTimeUnit(e.waste_hours_per_author_per_week)}  (${e.total_authors} authors)\n`;
             }
 
             // Preventable Loss Total (before grand total)
             const preventableCost = (e.code_churn_cost || 0) + (e.delivery_delay_cost || 0) + (e.automated_updates_cost || 0) + (e.pr_tracking_cost || 0);
             const preventableHours = (e.code_churn_hours || 0) + (e.delivery_delay_hours || 0) + (e.automated_updates_hours || 0) + (e.pr_tracking_hours || 0);
             const preventablePct = (preventableCost / e.total_cost) * 100;
-            output += `  Total Preventable Waste (${days} days):  ${formatCurrency(preventableCost).padStart(10)}    ${formatTimeUnit(preventableHours)}  (${preventablePct.toFixed(1)}%)\n`;
+            output += `  Preventable Loss Total       ${formatCurrency(preventableCost).padStart(10)}    ${formatTimeUnit(preventableHours)}  (${preventablePct.toFixed(1)}%)\n`;
 
             // Total
             output += '  ════════════════════════════════════════════════════\n';

pkg/github/query.go

@@ -825,3 +825,83 @@ func CountOpenPRsInRepo(ctx context.Context, owner, repo, token string) (int, er
 
 	return count, nil
 }
+
+// CountOpenPRsInOrg counts all open PRs across an entire GitHub organization with a single GraphQL query.
+// This is much more efficient than counting PRs repo-by-repo for organizations with many repositories.
+// Only counts PRs created more than 24 hours ago to exclude brand-new PRs.
+func CountOpenPRsInOrg(ctx context.Context, org, token string) (int, error) {
+	// Only count PRs created more than 24 hours ago
+	twentyFourHoursAgo := time.Now().Add(-24 * time.Hour).Format("2006-01-02T15:04:05Z")
+
+	query := `query($searchQuery: String!) {
+		search(query: $searchQuery, type: ISSUE, first: 0) {
+			issueCount
+		}
+	}`
+
+	// Search query: is:pr is:open org:orgname created:<date
+	searchQuery := fmt.Sprintf("is:pr is:open org:%s created:<%s", org, twentyFourHoursAgo)
+
+	variables := map[string]any{
+		"searchQuery": searchQuery,
+	}
+
+	queryJSON, err := json.Marshal(map[string]any{
+		"query":     query,
+		"variables": variables,
+	})
+	if err != nil {
+		return 0, fmt.Errorf("failed to marshal query: %w", err)
+	}
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, "https://api.github.com/graphql", bytes.NewBuffer(queryJSON))
+	if err != nil {
+		return 0, fmt.Errorf("failed to create request: %w", err)
+	}
+
+	req.Header.Set("Authorization", "Bearer "+token)
+	req.Header.Set("Content-Type", "application/json")
+
+	slog.Info("HTTP request starting",
+		"method", "POST",
+		"url", "https://api.github.com/graphql",
+		"host", "api.github.com")
+
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return 0, fmt.Errorf("request failed: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return 0, fmt.Errorf("unexpected status code: %d", resp.StatusCode)
+	}
+
+	var result struct {
+		Data struct {
+			Search struct {
+				IssueCount int `json:"issueCount"`
+			} `json:"search"`
+		} `json:"data"`
+		Errors []struct {
+			Message string
+		}
+	}
+
+	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
+		return 0, fmt.Errorf("failed to decode response: %w", err)
+	}
+
+	if len(result.Errors) > 0 {
+		return 0, fmt.Errorf("GraphQL error: %s", result.Errors[0].Message)
+	}
+
+	count := result.Data.Search.IssueCount
+
+	slog.Info("Counted PRs open >24 hours in organization",
+		"org", org,
+		"open_prs", count,
+		"filter", "created >24h ago")
+
+	return count, nil
+}