feat: add PR comment lifecycle search API

haasonsaas · haasonsaas · commit 4c67b020ade6 · 2026-03-13T21:54:06.000-07:00
diff --git a/TODO.md b/TODO.md
@@ -113,7 +113,7 @@ This roadmap is derived from deep research into Greptile's public docs, blog, MC
 
 ## 8. APIs, Automation, and MCP-Like Surfaces
 
-71. [ ] Expose unresolved/resolved comment search through the HTTP API.
+71. [x] Expose unresolved/resolved comment search through the HTTP API.
 72. [x] Expose PR readiness through the HTTP API for CI and agent integrations.
 73. [ ] Add API endpoints to fetch learned rules, attention gaps, and top rejected patterns.
 74. [ ] Add machine-friendly APIs to fetch findings grouped by severity, file, and lifecycle state.
@@ -167,4 +167,5 @@ This roadmap is derived from deep research into Greptile's public docs, blog, MC
 - [x] Add visible feedback badges on comments so accepted and rejected states are not icon-only.
 - [x] Add a train-the-reviewer callout on review detail when thumbs coverage is low.
 - [x] Add structured custom context and per-path instruction editors to the Settings review context workflow.
+- [x] Expose latest-review PR comment search with unresolved, resolved, and dismissed lifecycle filters through the API.
 - [ ] Commit and push each validated checkpoint before moving to the next epic.
diff --git a/src/server/api.rs b/src/server/api.rs
@@ -10,15 +10,15 @@ use uuid::Uuid;
 
 use super::pr_readiness::{
     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,
+    get_pr_readiness_snapshot, latest_pr_review_session, latest_review_head_by_source,
+    load_review_inventory, pr_diff_source, 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, MergeReadiness};
+use crate::core::comment::{CommentStatus, CommentSynthesizer, MergeReadiness};
 use crate::core::convention_learner::ConventionStore;
 use tracing::{info, warn};
 
@@ -1837,6 +1837,79 @@ pub struct PrReadinessParams {
     pub pr_number: u32,
 }
 
+#[derive(Deserialize)]
+pub struct PrCommentSearchParams {
+    pub repo: String,
+    pub pr_number: u32,
+    pub status: Option<String>,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum CommentSearchFilter {
+    All,
+    Unresolved,
+    Resolved,
+    Dismissed,
+}
+
+impl CommentSearchFilter {
+    fn from_api_value(value: Option<&str>) -> Option<Self> {
+        match value.map(|value| value.trim().to_ascii_lowercase()) {
+            None => Some(Self::All),
+            Some(value) if value.is_empty() || value == "all" => Some(Self::All),
+            Some(value) if value == "open" || value == "unresolved" => Some(Self::Unresolved),
+            Some(value) if value == "resolved" => Some(Self::Resolved),
+            Some(value) if value == "dismissed" => Some(Self::Dismissed),
+            _ => None,
+        }
+    }
+
+    fn as_api_str(self) -> &'static str {
+        match self {
+            Self::All => "all",
+            Self::Unresolved => "unresolved",
+            Self::Resolved => "resolved",
+            Self::Dismissed => "dismissed",
+        }
+    }
+
+    fn matches(self, status: CommentStatus) -> bool {
+        match self {
+            Self::All => true,
+            Self::Unresolved => status == CommentStatus::Open,
+            Self::Resolved => status == CommentStatus::Resolved,
+            Self::Dismissed => status == CommentStatus::Dismissed,
+        }
+    }
+}
+
+#[derive(Serialize)]
+pub struct PrCommentSearchResponse {
+    pub repo: String,
+    pub pr_number: u32,
+    pub diff_source: String,
+    pub status: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub latest_review_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub latest_review_status: Option<ReviewStatus>,
+    #[serde(default)]
+    pub total_comments: usize,
+    #[serde(default)]
+    pub comments: Vec<crate::core::Comment>,
+}
+
+fn filter_comments_by_search_filter(
+    comments: &[crate::core::Comment],
+    filter: CommentSearchFilter,
+) -> Vec<crate::core::Comment> {
+    comments
+        .iter()
+        .filter(|comment| filter.matches(comment.status))
+        .cloned()
+        .collect()
+}
+
 #[derive(Serialize)]
 pub struct GhPullRequest {
     pub number: u32,
@@ -2081,6 +2154,49 @@ pub async fn get_gh_pr_readiness(
     ))
 }
 
+pub async fn get_gh_pr_comments(
+    State(state): State<Arc<AppState>>,
+    Query(params): Query<PrCommentSearchParams>,
+) -> Result<Json<PrCommentSearchResponse>, (StatusCode, String)> {
+    if !is_valid_repo_name(&params.repo) {
+        return Err((
+            StatusCode::BAD_REQUEST,
+            "Invalid repo format. Expected 'owner/repo'.".to_string(),
+        ));
+    }
+
+    if params.pr_number == 0 || params.pr_number > 999_999_999 {
+        return Err((StatusCode::BAD_REQUEST, "Invalid PR number.".to_string()));
+    }
+
+    let filter =
+        CommentSearchFilter::from_api_value(params.status.as_deref()).ok_or_else(|| {
+            (
+                StatusCode::BAD_REQUEST,
+                "Invalid status. Must be all, unresolved, open, resolved, or dismissed."
+                    .to_string(),
+            )
+        })?;
+
+    let inventory = load_review_inventory(&state).await;
+    let latest_review = latest_pr_review_session(&inventory, &params.repo, params.pr_number);
+    let comments = latest_review
+        .as_ref()
+        .map(|review| filter_comments_by_search_filter(&review.comments, filter))
+        .unwrap_or_default();
+
+    Ok(Json(PrCommentSearchResponse {
+        repo: params.repo.clone(),
+        pr_number: params.pr_number,
+        diff_source: pr_diff_source(&params.repo, params.pr_number),
+        status: filter.as_api_str().to_string(),
+        latest_review_id: latest_review.as_ref().map(|review| review.id.clone()),
+        latest_review_status: latest_review.as_ref().map(|review| review.status.clone()),
+        total_comments: comments.len(),
+        comments,
+    }))
+}
+
 // === GitHub PR Review ===
 
 #[derive(Deserialize)]
@@ -3211,4 +3327,86 @@ mod tests {
         assert_eq!(req.pr_number, 42);
         assert!(req.post_results);
     }
+
+    fn make_search_comment(id: &str, status: CommentStatus) -> crate::core::Comment {
+        crate::core::Comment {
+            id: id.to_string(),
+            file_path: std::path::PathBuf::from("src/lib.rs"),
+            line_number: 10,
+            content: format!("comment {id}"),
+            rule_id: None,
+            severity: crate::core::comment::Severity::Warning,
+            category: crate::core::comment::Category::Bug,
+            suggestion: None,
+            confidence: 0.8,
+            code_suggestion: None,
+            tags: Vec::new(),
+            fix_effort: crate::core::comment::FixEffort::Low,
+            feedback: None,
+            status,
+        }
+    }
+
+    #[test]
+    fn test_comment_search_filter_parses_aliases() {
+        assert_eq!(
+            CommentSearchFilter::from_api_value(None),
+            Some(CommentSearchFilter::All)
+        );
+        assert_eq!(
+            CommentSearchFilter::from_api_value(Some("open")),
+            Some(CommentSearchFilter::Unresolved)
+        );
+        assert_eq!(
+            CommentSearchFilter::from_api_value(Some("unresolved")),
+            Some(CommentSearchFilter::Unresolved)
+        );
+        assert_eq!(
+            CommentSearchFilter::from_api_value(Some("resolved")),
+            Some(CommentSearchFilter::Resolved)
+        );
+        assert_eq!(
+            CommentSearchFilter::from_api_value(Some("dismissed")),
+            Some(CommentSearchFilter::Dismissed)
+        );
+        assert_eq!(CommentSearchFilter::from_api_value(Some("wat")), None);
+    }
+
+    #[test]
+    fn test_filter_comments_by_search_filter_matches_status() {
+        let comments = vec![
+            make_search_comment("open", CommentStatus::Open),
+            make_search_comment("resolved", CommentStatus::Resolved),
+            make_search_comment("dismissed", CommentStatus::Dismissed),
+        ];
+
+        assert_eq!(
+            filter_comments_by_search_filter(&comments, CommentSearchFilter::All)
+                .into_iter()
+                .map(|comment| comment.id)
+                .collect::<Vec<_>>(),
+            vec!["open", "resolved", "dismissed"]
+        );
+        assert_eq!(
+            filter_comments_by_search_filter(&comments, CommentSearchFilter::Unresolved)
+                .into_iter()
+                .map(|comment| comment.id)
+                .collect::<Vec<_>>(),
+            vec!["open"]
+        );
+        assert_eq!(
+            filter_comments_by_search_filter(&comments, CommentSearchFilter::Resolved)
+                .into_iter()
+                .map(|comment| comment.id)
+                .collect::<Vec<_>>(),
+            vec!["resolved"]
+        );
+        assert_eq!(
+            filter_comments_by_search_filter(&comments, CommentSearchFilter::Dismissed)
+                .into_iter()
+                .map(|comment| comment.id)
+                .collect::<Vec<_>>(),
+            vec!["dismissed"]
+        );
+    }
 }
diff --git a/src/server/mod.rs b/src/server/mod.rs
@@ -117,6 +117,7 @@ pub async fn start_server(config: Config, host: &str, port: u16) -> anyhow::Resu
         .route("/gh/repos", get(api::get_gh_repos))
         .route("/gh/prs", get(api::get_gh_prs))
         .route("/gh/pr-readiness", get(api::get_gh_pr_readiness))
+        .route("/gh/pr-comments", get(api::get_gh_pr_comments))
         .route("/gh/review", post(api::start_pr_review))
         .route("/agent/tools", get(api::get_agent_tools))
         .route("/gh/auth/device", post(github::start_device_flow))
diff --git a/src/server/pr_readiness.rs b/src/server/pr_readiness.rs
@@ -162,6 +162,20 @@ fn latest_summarized_reviews_by_source(
     latest
 }
 
+pub(crate) fn latest_pr_review_session(
+    reviews: &[ReviewSession],
+    repo: &str,
+    pr_number: u32,
+) -> Option<ReviewSession> {
+    let diff_source = pr_diff_source(repo, pr_number);
+
+    reviews
+        .iter()
+        .filter(|session| session.diff_source == diff_source && session.summary.is_some())
+        .max_by_key(|session| (session.started_at, session.completed_at.unwrap_or_default()))
+        .cloned()
+}
+
 pub(crate) fn build_repo_blocker_rollups(
     reviews: &[ReviewSession],
 ) -> HashMap<String, RepoBlockerRollup> {
@@ -193,11 +207,7 @@ pub(crate) fn build_pr_readiness_snapshot(
 ) -> PrReadinessSnapshot {
     let diff_source = pr_diff_source(repo, pr_number);
     let latest_by_source = latest_review_head_by_source(reviews);
-    let latest_review = reviews
-        .iter()
-        .filter(|session| session.diff_source == diff_source && session.summary.is_some())
-        .max_by_key(|session| (session.started_at, session.completed_at.unwrap_or_default()))
-        .cloned()
+    let latest_review = latest_pr_review_session(reviews, repo, pr_number)
         .map(|session| apply_dynamic_review_state(session, &latest_by_source, current_head_sha))
         .map(|session| PrReadinessReview::from_session(&session));
 
@@ -362,6 +372,40 @@ mod tests {
         );
     }
 
+    #[test]
+    fn latest_pr_review_session_ignores_newer_failed_reviews() {
+        let older_complete = make_pr_review_session(
+            "r1",
+            10,
+            "sha-a",
+            vec![make_comment("c1", Severity::Warning, CommentStatus::Open)],
+        );
+        let newer_failed = ReviewSession {
+            id: "r2".to_string(),
+            status: ReviewStatus::Failed,
+            diff_source: "pr:owner/repo#42".to_string(),
+            github_head_sha: Some("sha-b".to_string()),
+            started_at: 20,
+            completed_at: Some(21),
+            summary: None,
+            files_reviewed: 0,
+            comments: Vec::new(),
+            error: Some("boom".to_string()),
+            pr_summary_text: None,
+            diff_content: None,
+            event: None,
+            progress: None,
+        };
+
+        let latest_review =
+            latest_pr_review_session(&[older_complete, newer_failed], "owner/repo", 42)
+                .expect("latest completed review");
+
+        assert_eq!(latest_review.id, "r1");
+        assert_eq!(latest_review.status, ReviewStatus::Complete);
+        assert_eq!(latest_review.comments.len(), 1);
+    }
+
     #[test]
     fn repo_blocker_rollups_use_latest_review_per_pr() {
         let older_pr = make_pr_review_session(
