feat: show blocker counts in GitHub discovery

Author: haasonsaas

TODO.md

@@ -103,7 +103,7 @@ This roadmap is derived from deep research into Greptile's public docs, blog, MC
 61. [x] Add feedback coverage metrics: percent of findings with thumbs or explicit disposition.
 62. [x] Add acceptance/rejection trend lines over time for recent reviews.
 63. [x] Add top accepted categories/rules and top rejected categories/rules to Analytics.
-64. [ ] Add unresolved blocker counts per repository and per PR.
+64. [x] Add unresolved blocker counts per repository and per PR.
 65. [ ] Add review completeness and mean-time-to-resolution charts.
 66. [ ] Add feedback-learning effectiveness metrics: did reranked findings get higher acceptance after rollout?
 67. [ ] Add pattern-repository utilization analytics showing when extra context actually affected findings.
@@ -161,4 +161,5 @@ This roadmap is derived from deep research into Greptile's public docs, blog, MC
 - [x] Split open findings into blocking vs informational buckets and surface critical blocker cards in review detail.
 - [x] Add PR readiness query surfaces in the CLI and HTTP API for non-UI workflows.
 - [x] Surface lifecycle-aware PR readiness summaries in the GitHub PR detail workflow.
+- [x] Surface unresolved blocker counts in repo and PR GitHub discovery views.
 - [ ] Commit and push each validated checkpoint before moving to the next epic.

src/server/api.rs

@@ -9,15 +9,16 @@ use std::sync::Arc;
 use uuid::Uuid;
 
 use super::pr_readiness::{
-    apply_dynamic_review_state, get_pr_readiness_snapshot, latest_review_head_by_source,
-    load_review_inventory, PrReadinessSnapshot,
+    apply_dynamic_review_state, build_pr_readiness_snapshot, build_repo_blocker_rollups,
+    get_pr_readiness_snapshot, latest_review_head_by_source, load_review_inventory,
+    PrReadinessSnapshot,
 };
 use super::state::{
     build_progress_callback, count_diff_files, count_reviewed_files, current_timestamp,
     emit_wide_event, AppState, FileMetricEvent, HotspotDetail, ReviewEventBuilder, ReviewListItem,
     ReviewSession, ReviewStatus, MAX_DIFF_SIZE,
 };
-use crate::core::comment::CommentSynthesizer;
+use crate::core::comment::{CommentSynthesizer, MergeReadiness};
 use crate::core::convention_learner::ConventionStore;
 use tracing::{info, warn};
 
@@ -1580,6 +1581,10 @@ pub struct GhRepo {
     pub language: Option<String>,
     pub updated_at: String,
     pub open_prs: usize,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub open_blockers: Option<usize>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub blocking_prs: Option<usize>,
     pub default_branch: String,
     pub stargazers_count: u32,
     pub private: bool,
@@ -1649,6 +1654,9 @@ pub async fn get_gh_repos(
             .cloned()
             .unwrap_or_default();
 
+        let inventory = load_review_inventory(&state).await;
+        let blocker_rollups = build_repo_blocker_rollups(&inventory);
+
         let repos: Vec<GhRepo> = items
             .into_iter()
             .map(|item| GhRepo {
@@ -1671,6 +1679,16 @@ pub async fn get_gh_repos(
                     .unwrap_or("")
                     .to_string(),
                 open_prs: 0,
+                open_blockers: item
+                    .get("full_name")
+                    .and_then(|v| v.as_str())
+                    .and_then(|repo| blocker_rollups.get(repo))
+                    .map(|rollup| rollup.open_blockers),
+                blocking_prs: item
+                    .get("full_name")
+                    .and_then(|v| v.as_str())
+                    .and_then(|repo| blocker_rollups.get(repo))
+                    .map(|rollup| rollup.blocking_prs),
                 default_branch: item
                     .get("default_branch")
                     .and_then(|v| v.as_str())
@@ -1714,6 +1732,9 @@ pub async fn get_gh_repos(
             )
         })?;
 
+        let inventory = load_review_inventory(&state).await;
+        let blocker_rollups = build_repo_blocker_rollups(&inventory);
+
         let repos: Vec<GhRepo> = items
             .into_iter()
             .map(|item| GhRepo {
@@ -1736,6 +1757,16 @@ pub async fn get_gh_repos(
                     .unwrap_or("")
                     .to_string(),
                 open_prs: 0,
+                open_blockers: item
+                    .get("full_name")
+                    .and_then(|v| v.as_str())
+                    .and_then(|repo| blocker_rollups.get(repo))
+                    .map(|rollup| rollup.open_blockers),
+                blocking_prs: item
+                    .get("full_name")
+                    .and_then(|v| v.as_str())
+                    .and_then(|repo| blocker_rollups.get(repo))
+                    .map(|rollup| rollup.blocking_prs),
                 default_branch: item
                     .get("default_branch")
                     .and_then(|v| v.as_str())
@@ -1821,6 +1852,10 @@ pub struct GhPullRequest {
     pub base_branch: String,
     pub labels: Vec<String>,
     pub draft: bool,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub open_blockers: Option<usize>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub merge_readiness: Option<MergeReadiness>,
 }
 
 /// Regex for validating repo names: owner/repo
@@ -1896,6 +1931,8 @@ pub async fn get_gh_prs(
         )
     })?;
 
+    let inventory = load_review_inventory(&state).await;
+
     let prs: Vec<GhPullRequest> = items
         .into_iter()
         .filter(|item| {
@@ -1930,8 +1967,20 @@ pub async fn get_gh_prs(
                     .to_string()
             };
 
+            let pr_number = item.get("number").and_then(|v| v.as_u64()).unwrap_or(0) as u32;
+            let current_head_sha = item
+                .get("head")
+                .and_then(|v| v.get("sha"))
+                .and_then(|v| v.as_str());
+            let readiness_snapshot =
+                build_pr_readiness_snapshot(&inventory, &params.repo, pr_number, current_head_sha);
+            let latest_summary = readiness_snapshot
+                .latest_review
+                .as_ref()
+                .and_then(|review| review.summary.as_ref());
+
             GhPullRequest {
-                number: item.get("number").and_then(|v| v.as_u64()).unwrap_or(0) as u32,
+                number: pr_number,
                 title: item
                     .get("title")
                     .and_then(|v| v.as_str())
@@ -1971,6 +2020,8 @@ pub async fn get_gh_prs(
                     .to_string(),
                 labels,
                 draft: item.get("draft").and_then(|v| v.as_bool()).unwrap_or(false),
+                open_blockers: latest_summary.map(|summary| summary.open_blockers),
+                merge_readiness: latest_summary.map(|summary| summary.merge_readiness),
             }
         })
         .collect();
@@ -3092,6 +3143,8 @@ mod tests {
             language: Some("Rust".to_string()),
             updated_at: "2024-01-01T00:00:00Z".to_string(),
             open_prs: 5,
+            open_blockers: Some(3),
+            blocking_prs: Some(2),
             default_branch: "main".to_string(),
             stargazers_count: 42,
             private: false,
@@ -3100,6 +3153,8 @@ mod tests {
         assert_eq!(json["full_name"], "owner/repo");
         assert_eq!(json["language"], "Rust");
         assert_eq!(json["open_prs"], 5);
+        assert_eq!(json["open_blockers"], 3);
+        assert_eq!(json["blocking_prs"], 2);
         assert_eq!(json["stargazers_count"], 42);
         assert_eq!(json["private"], false);
     }
@@ -3120,12 +3175,16 @@ mod tests {
             base_branch: "main".to_string(),
             labels: vec!["bugfix".to_string()],
             draft: false,
+            open_blockers: Some(2),
+            merge_readiness: Some(MergeReadiness::NeedsAttention),
         };
         let json = serde_json::to_value(&pr).unwrap();
         assert_eq!(json["number"], 42);
         assert_eq!(json["title"], "Fix bug");
         assert_eq!(json["author"], "dev");
         assert_eq!(json["draft"], false);
+        assert_eq!(json["open_blockers"], 2);
+        assert_eq!(json["merge_readiness"], "NeedsAttention");
         assert_eq!(json["labels"].as_array().unwrap().len(), 1);
     }
 

src/server/pr_readiness.rs

@@ -41,6 +41,12 @@ pub struct PrReadinessReview {
     pub error: Option<String>,
 }
 
+#[derive(Debug, Clone, Default, PartialEq, Eq)]
+pub struct RepoBlockerRollup {
+    pub open_blockers: usize,
+    pub blocking_prs: usize,
+}
+
 impl PrReadinessReview {
     fn from_session(session: &ReviewSession) -> Self {
         Self {
@@ -61,6 +67,12 @@ pub(crate) fn pr_diff_source(repo: &str, pr_number: u32) -> String {
     format!("pr:{repo}#{pr_number}")
 }
 
+pub(crate) fn parse_pr_diff_source(diff_source: &str) -> Option<(String, u32)> {
+    let rest = diff_source.strip_prefix("pr:")?;
+    let (repo, pr_number) = rest.rsplit_once('#')?;
+    Some((repo.to_string(), pr_number.parse().ok()?))
+}
+
 pub(crate) async fn load_review_inventory(state: &Arc<AppState>) -> Vec<ReviewSession> {
     let mut sessions: Vec<ReviewSession> = {
         let reviews = state.reviews.read().await;
@@ -132,6 +144,47 @@ pub(crate) fn apply_dynamic_review_state(
     session
 }
 
+fn latest_summarized_reviews_by_source(
+    reviews: &[ReviewSession],
+) -> HashMap<String, ReviewSession> {
+    let mut latest: HashMap<String, ReviewSession> = HashMap::new();
+    for review in reviews {
+        if review.summary.is_none() || !review.diff_source.starts_with("pr:") {
+            continue;
+        }
+        match latest.get(&review.diff_source) {
+            Some(current) if current.started_at >= review.started_at => {}
+            _ => {
+                latest.insert(review.diff_source.clone(), review.clone());
+            }
+        }
+    }
+    latest
+}
+
+pub(crate) fn build_repo_blocker_rollups(
+    reviews: &[ReviewSession],
+) -> HashMap<String, RepoBlockerRollup> {
+    let mut rollups = HashMap::new();
+    for review in latest_summarized_reviews_by_source(reviews).into_values() {
+        let Some(summary) = review.summary.as_ref() else {
+            continue;
+        };
+        let Some((repo, _)) = parse_pr_diff_source(&review.diff_source) else {
+            continue;
+        };
+
+        let rollup = rollups
+            .entry(repo)
+            .or_insert_with(RepoBlockerRollup::default);
+        rollup.open_blockers += summary.open_blockers;
+        if summary.open_blockers > 0 {
+            rollup.blocking_prs += 1;
+        }
+    }
+    rollups
+}
+
 pub(crate) fn build_pr_readiness_snapshot(
     reviews: &[ReviewSession],
     repo: &str,
@@ -308,4 +361,87 @@ mod tests {
             crate::core::comment::MergeReadiness::NeedsReReview
         );
     }
+
+    #[test]
+    fn repo_blocker_rollups_use_latest_review_per_pr() {
+        let older_pr = make_pr_review_session(
+            "r1",
+            10,
+            "sha-a",
+            vec![make_comment("c1", Severity::Warning, CommentStatus::Open)],
+        );
+        let newer_same_pr = ReviewSession {
+            id: "r2".to_string(),
+            status: ReviewStatus::Complete,
+            diff_source: "pr:owner/repo#42".to_string(),
+            github_head_sha: Some("sha-b".to_string()),
+            started_at: 20,
+            completed_at: Some(21),
+            summary: Some(CommentSynthesizer::generate_summary(&[])),
+            files_reviewed: 1,
+            comments: Vec::new(),
+            error: None,
+            pr_summary_text: None,
+            diff_content: None,
+            event: None,
+            progress: None,
+        };
+        let other_pr = ReviewSession {
+            id: "r3".to_string(),
+            status: ReviewStatus::Complete,
+            diff_source: "pr:owner/repo#43".to_string(),
+            github_head_sha: Some("sha-c".to_string()),
+            started_at: 15,
+            completed_at: Some(16),
+            summary: Some(CommentSynthesizer::generate_summary(&vec![make_comment(
+                "c2",
+                Severity::Error,
+                CommentStatus::Open,
+            )])),
+            files_reviewed: 1,
+            comments: vec![make_comment("c2", Severity::Error, CommentStatus::Open)],
+            error: None,
+            pr_summary_text: None,
+            diff_content: None,
+            event: None,
+            progress: None,
+        };
+        let other_repo = ReviewSession {
+            id: "r4".to_string(),
+            status: ReviewStatus::Complete,
+            diff_source: "pr:other/repo#7".to_string(),
+            github_head_sha: Some("sha-d".to_string()),
+            started_at: 12,
+            completed_at: Some(13),
+            summary: Some(CommentSynthesizer::generate_summary(&vec![make_comment(
+                "c3",
+                Severity::Warning,
+                CommentStatus::Open,
+            )])),
+            files_reviewed: 1,
+            comments: vec![make_comment("c3", Severity::Warning, CommentStatus::Open)],
+            error: None,
+            pr_summary_text: None,
+            diff_content: None,
+            event: None,
+            progress: None,
+        };
+
+        let rollups = build_repo_blocker_rollups(&[older_pr, newer_same_pr, other_pr, other_repo]);
+
+        assert_eq!(
+            rollups.get("owner/repo"),
+            Some(&RepoBlockerRollup {
+                open_blockers: 1,
+                blocking_prs: 1,
+            })
+        );
+        assert_eq!(
+            rollups.get("other/repo"),
+            Some(&RepoBlockerRollup {
+                open_blockers: 1,
+                blocking_prs: 1,
+            })
+        );
+    }
 }

web/src/api/types.ts

@@ -356,6 +356,8 @@ export interface GhRepo {
   language: string | null
   updated_at: string
   open_prs: number
+  open_blockers?: number
+  blocking_prs?: number
   default_branch: string
   stargazers_count: number
   private: boolean
@@ -375,6 +377,8 @@ export interface GhPullRequest {
   base_branch: string
   labels: string[]
   draft: boolean
+  open_blockers?: number
+  merge_readiness?: MergeReadiness
 }
 
 export interface PrReadinessReview {