Merge pull request #153 from rostilos/1.5.3-rc

rostilos · web-flow · commit 62395535aa17 · 2026-03-02T00:59:47.000+02:00
feat: Add health check for RAG pipeline and enhance PR coverage checks to include merged PRs
diff --git a/java-ecosystem/libs/analysis-api/src/main/java/org/rostilos/codecrow/analysisapi/rag/RagOperationsService.java b/java-ecosystem/libs/analysis-api/src/main/java/org/rostilos/codecrow/analysisapi/rag/RagOperationsService.java
@@ -34,6 +34,16 @@ public interface RagOperationsService {
      */
     boolean isRagIndexReady(Project project);
 
+    /**
+     * Check if the RAG pipeline service is reachable (health check).
+     * Used to verify connectivity before attempting RAG operations.
+     *
+     * @return true if the RAG pipeline is healthy and reachable, false otherwise
+     */
+    default boolean isRagPipelineHealthy() {
+        return true; // Default assumes healthy; implementations should do actual check
+    }
+
     /**
      * Trigger an incremental RAG update for the given project after a branch merge or commit.
      * 
diff --git a/java-ecosystem/libs/analysis-engine/src/main/java/org/rostilos/codecrow/analysisengine/processor/analysis/BranchAnalysisProcessor.java b/java-ecosystem/libs/analysis-engine/src/main/java/org/rostilos/codecrow/analysisengine/processor/analysis/BranchAnalysisProcessor.java
@@ -205,13 +205,13 @@ public Map<String, Object> process(
                         augmentChangedFilesFromPr(changedFiles, project, prNumber);
 
                         // ── Hybrid analysis: AI analysis for uncovered direct pushes ─────
-                        // Check if unanalyzed commits are covered by open PRs.
+                        // Check if unanalyzed commits are covered by PRs (open or recently merged).
                         // If NOT covered (direct push without PR), run full AI analysis
                         // on the commit range diff, producing CodeAnalysisIssues marked
                         // with DetectionSource.DIRECT_PUSH_ANALYSIS.
                         performDirectPushAnalysisIfNeeded(
                                         project, request, unanalyzedCommits, rawDiff,
-                                        changedFiles, provider, consumer);
+                                        changedFiles, provider, consumer, prNumber);
 
                         EventNotificationEmitter.emitStatus(consumer, "analyzing_files",
                                         "Analyzing " + changedFiles.size() + " changed files");
@@ -516,7 +516,8 @@ private void performDirectPushAnalysisIfNeeded(
                         String rawDiff,
                         Set<String> changedFiles,
                         EVcsProvider provider,
-                        Consumer<Map<String, Object>> consumer) {
+                        Consumer<Map<String, Object>> consumer,
+                        Long mergedPrNumber) {
 
                 if (unanalyzedCommits.isEmpty()) {
                         log.debug("No unanalyzed commits — skipping direct push analysis check");
@@ -528,6 +529,16 @@ private void performDirectPushAnalysisIfNeeded(
                         return;
                 }
 
+                // ── Fast path: PR merge ──────────────────────────────────────────
+                // If this branch analysis was triggered by a PR merge, the code was
+                // already reviewed during the PR.  Always skip — a merge is never a
+                // direct push, and any missing analysis will be handled by reconciliation.
+                if (mergedPrNumber != null) {
+                        log.info("Skipping direct push analysis — branch event originates from PR #{} merge (not a direct push)",
+                                        mergedPrNumber);
+                        return;
+                }
+
                 // Check if a PR analysis lock is active for this branch.
                 // If so, wait — the PR analysis will handle these commits.
                 boolean prAnalysisInProgress = analysisLockService.isLocked(
@@ -538,7 +549,7 @@ private void performDirectPushAnalysisIfNeeded(
                         return;
                 }
 
-                // Check commit coverage by open PRs
+                // Check commit coverage by open/merged PRs
                 CommitCoverageService.CoverageResult coverage = commitCoverageService.checkCoverage(
                                 project.getId(), request.getTargetBranchName(), unanalyzedCommits);
 
@@ -640,6 +651,15 @@ private void performIncrementalRagUpdate(BranchProcessRequest request, Project p
                         String targetBranch = request.getTargetBranchName();
                         String baseBranch = ragOperationsService.getBaseBranch(project);
 
+                        // Health check: verify RAG pipeline is reachable before starting
+                        if (!ragOperationsService.isRagPipelineHealthy()) {
+                                log.warn("RAG pipeline is not reachable — skipping incremental update for project={}",
+                                                project.getId());
+                                EventNotificationEmitter.emitStatus(consumer, "rag_skipped",
+                                                "RAG pipeline not reachable — skipping incremental update");
+                                return;
+                        }
+
                         if (targetBranch.equals(baseBranch)) {
                                 log.info("Main branch push - updating RAG index for project={}, branch={}, commit={}",
                                                 project.getId(), targetBranch, request.getCommitHash());
diff --git a/java-ecosystem/libs/analysis-engine/src/main/java/org/rostilos/codecrow/analysisengine/service/gitgraph/CommitCoverageService.java b/java-ecosystem/libs/analysis-engine/src/main/java/org/rostilos/codecrow/analysisengine/service/gitgraph/CommitCoverageService.java
@@ -16,7 +16,7 @@
 
 /**
  * Determines whether unanalyzed commits on a branch are already covered
- * by open pull requests targeting that branch.
+ * by pull requests (open or recently merged) targeting that branch.
  * <p>
  * Used by {@code BranchAnalysisProcessor} to decide whether to run
  * a full AI analysis (hybrid path) or only reconciliation.
@@ -59,15 +59,15 @@ public enum CoverageStatus {
     }
 
     /**
-     * Check if the given unanalyzed commits are covered by open PRs targeting the branch.
+     * Check if the given unanalyzed commits are covered by PRs targeting the branch.
+     * <p>
+     * Checks both OPEN and MERGED PRs.  MERGED PRs must be included because
+     * the branch analysis flow marks a PR as MERGED <em>before</em> calling this
+     * method, so a freshly-merged PR would otherwise be invisible.
      * <p>
      * A commit is considered "covered" if it was already analyzed as part of a PR analysis
      * (i.e., there exists a {@code CodeAnalysis} with {@code analysisType = PR_REVIEW}
-     * whose commit hash matches, or the commit is in the DAG path of an analyzed PR).
-     * <p>
-     * We use a simpler heuristic: check if any open PR targeting this branch has
-     * an analysis whose commit hash is the HEAD or one of the unanalyzed commits.
-     * This avoids expensive DAG traversal through PR source branches.
+     * whose commit hash matches).
      *
      * @param projectId          the project ID
      * @param targetBranchName   the branch being pushed to
@@ -80,20 +80,25 @@ public CoverageResult checkCoverage(Long projectId, String targetBranchName,
             return new CoverageResult(CoverageStatus.FULLY_COVERED, Collections.emptyList());
         }
 
-        // Find open PRs targeting this branch
-        List<PullRequest> openPRs = pullRequestRepository.findByProjectIdAndTargetBranchNameAndState(
-                projectId, targetBranchName, PullRequestState.OPEN);
-
-        if (openPRs.isEmpty()) {
-            log.debug("No open PRs targeting branch {} — all {} commits are uncovered",
+        // Find PRs targeting this branch — both OPEN and MERGED.
+        // MERGED PRs must be included because:
+        //   1. The branch analysis marks the PR as MERGED *before* calling this check
+        //   2. Merge commits have different hashes from the PR's source commits,
+        //      so we need the PR's analyzed commit hash for coverage matching
+        List<PullRequest> relevantPRs = pullRequestRepository.findByProjectIdAndTargetBranchNameAndStateIn(
+                projectId, targetBranchName,
+                List.of(PullRequestState.OPEN, PullRequestState.MERGED));
+
+        if (relevantPRs.isEmpty()) {
+            log.debug("No open/merged PRs targeting branch {} — all {} commits are uncovered",
                     targetBranchName, unanalyzedCommits.size());
             return new CoverageResult(CoverageStatus.NOT_COVERED, new ArrayList<>(unanalyzedCommits));
         }
 
         // Collect all commit hashes that have been analyzed via PR_REVIEW for this project
         Set<String> prAnalyzedCommits = new HashSet<>();
-        for (PullRequest pr : openPRs) {
-            // Each open PR's latest commit hash was analyzed when the PR was analyzed
+        for (PullRequest pr : relevantPRs) {
+            // Each PR's latest commit hash was analyzed when the PR was reviewed
             if (pr.getCommitHash() != null) {
                 // Check if there's an actual analysis for this PR's commit
                 codeAnalysisRepository.findByProjectIdAndCommitHashAndPrNumber(
@@ -102,14 +107,15 @@ public CoverageResult checkCoverage(Long projectId, String targetBranchName,
                     // The PR analysis covers this commit and potentially all commits
                     // in the PR's source branch up to this point
                     prAnalyzedCommits.add(pr.getCommitHash());
-                    log.debug("Open PR #{} has analysis for commit {} on target branch {}",
-                            pr.getPrNumber(), shortHash(pr.getCommitHash()), targetBranchName);
+                    log.debug("PR #{} (state={}) has analysis for commit {} on target branch {}",
+                            pr.getPrNumber(), pr.getState(),
+                            shortHash(pr.getCommitHash()), targetBranchName);
                 });
             }
         }
 
         if (prAnalyzedCommits.isEmpty()) {
-            log.debug("Open PRs found but none have completed analyses — all {} commits uncovered",
+            log.debug("PRs found but none have completed analyses — all {} commits uncovered",
                     unanalyzedCommits.size());
             return new CoverageResult(CoverageStatus.NOT_COVERED, new ArrayList<>(unanalyzedCommits));
         }
@@ -120,16 +126,16 @@ public CoverageResult checkCoverage(Long projectId, String targetBranchName,
                 .collect(Collectors.toList());
 
         if (uncovered.isEmpty()) {
-            log.info("All {} unanalyzed commits are covered by open PR analyses on branch {}",
+            log.info("All {} unanalyzed commits are covered by PR analyses on branch {}",
                     unanalyzedCommits.size(), targetBranchName);
             return new CoverageResult(CoverageStatus.FULLY_COVERED, Collections.emptyList());
         } else if (uncovered.size() < unanalyzedCommits.size()) {
-            log.info("{}/{} unanalyzed commits covered by open PR analyses on branch {} — {} uncovered",
+            log.info("{}/{} unanalyzed commits covered by PR analyses on branch {} — {} uncovered",
                     unanalyzedCommits.size() - uncovered.size(), unanalyzedCommits.size(),
                     targetBranchName, uncovered.size());
             return new CoverageResult(CoverageStatus.PARTIALLY_COVERED, uncovered);
         } else {
-            log.info("No unanalyzed commits covered by open PR analyses on branch {}",
+            log.info("No unanalyzed commits covered by PR analyses on branch {}",
                     targetBranchName);
             return new CoverageResult(CoverageStatus.NOT_COVERED, new ArrayList<>(unanalyzedCommits));
         }
diff --git a/java-ecosystem/libs/analysis-engine/src/main/java/org/rostilos/codecrow/analysisengine/service/pr/PrFileEnrichmentService.java b/java-ecosystem/libs/analysis-engine/src/main/java/org/rostilos/codecrow/analysisengine/service/pr/PrFileEnrichmentService.java
@@ -42,7 +42,7 @@ public class PrFileEnrichmentService {
     @Value("${pr.enrichment.max-total-size-bytes:10485760}") // 10MB default
     private long maxTotalSizeBytes;
 
-    @Value("${pr.enrichment.rag-pipeline-url:http://localhost:8006}")
+    @Value("${pr.enrichment.rag-pipeline-url:${codecrow.rag.api.url:http://rag-pipeline:8001}}")
     private String ragPipelineUrl;
 
     @Value("${pr.enrichment.request-timeout-seconds:60}")
diff --git a/java-ecosystem/libs/analysis-engine/src/test/java/org/rostilos/codecrow/analysisengine/processor/analysis/BranchAnalysisProcessorTest.java b/java-ecosystem/libs/analysis-engine/src/test/java/org/rostilos/codecrow/analysisengine/processor/analysis/BranchAnalysisProcessorTest.java
@@ -577,10 +577,11 @@ void shouldPerformRagUpdateOnMainBranch() throws Exception {
             when(branchRepository.findByIdWithIssues(10L)).thenReturn(Optional.of(savedBranch));
             when(branchRepository.save(any(Branch.class))).thenReturn(savedBranch);
 
-            // RAG enabled, index ready, main branch
+            // RAG enabled, index ready, main branch, pipeline healthy
             when(ragOperationsService.isRagEnabled(project)).thenReturn(true);
             when(ragOperationsService.isRagIndexReady(project)).thenReturn(true);
             when(ragOperationsService.getBaseBranch(project)).thenReturn("main");
+            when(ragOperationsService.isRagPipelineHealthy()).thenReturn(true);
 
             // Final markHealthy
             when(branchRepository.findByProjectIdAndBranchName(1L, "main"))
@@ -642,6 +643,7 @@ void shouldCallUpdateBranchIndexForNonMainBranch() throws Exception {
             when(ragOperationsService.isRagEnabled(project)).thenReturn(true);
             when(ragOperationsService.isRagIndexReady(project)).thenReturn(true);
             when(ragOperationsService.getBaseBranch(project)).thenReturn("main");
+            when(ragOperationsService.isRagPipelineHealthy()).thenReturn(true);
 
             when(branchRepository.findByProjectIdAndBranchName(1L, "feature-x"))
                     .thenReturn(Optional.empty())
diff --git a/java-ecosystem/libs/core/src/main/java/org/rostilos/codecrow/core/persistence/repository/pullrequest/PullRequestRepository.java b/java-ecosystem/libs/core/src/main/java/org/rostilos/codecrow/core/persistence/repository/pullrequest/PullRequestRepository.java
@@ -31,4 +31,16 @@ List<PullRequest> findByProjectIdAndTargetBranchNameAndState(
             @Param("projectId") Long projectId,
             @Param("targetBranch") String targetBranch,
             @Param("state") PullRequestState state);
+
+    /**
+     * Find PRs targeting a specific branch in any of the given states.
+     * Used by commit coverage checks to include both OPEN and MERGED PRs
+     * when determining if commits are already covered by PR analyses.
+     */
+    @Query("SELECT pr FROM PullRequest pr WHERE pr.project.id = :projectId " +
+           "AND pr.targetBranchName = :targetBranch AND pr.state IN :states")
+    List<PullRequest> findByProjectIdAndTargetBranchNameAndStateIn(
+            @Param("projectId") Long projectId,
+            @Param("targetBranch") String targetBranch,
+            @Param("states") List<PullRequestState> states);
 }
diff --git a/java-ecosystem/libs/rag-engine/src/main/java/org/rostilos/codecrow/ragengine/client/RagPipelineClient.java b/java-ecosystem/libs/rag-engine/src/main/java/org/rostilos/codecrow/ragengine/client/RagPipelineClient.java
@@ -435,7 +435,11 @@ private Map<String, Object> doRequest(String url, Map<String, Object> payload, O
 
             if (!response.isSuccessful()) {
                 log.error("RAG API request failed: {} - {}", response.code(), responseBody);
-                throw new IOException("RAG API error: " + response.code());
+                // Include truncated response body in exception so callers can see the actual error
+                String detail = responseBody.length() > 500
+                        ? responseBody.substring(0, 500) + "..."
+                        : responseBody;
+                throw new IOException("RAG API error: " + response.code() + " — " + detail);
             }
 
             return objectMapper.readValue(responseBody, Map.class);
diff --git a/java-ecosystem/libs/rag-engine/src/main/java/org/rostilos/codecrow/ragengine/service/RagOperationsServiceImpl.java b/java-ecosystem/libs/rag-engine/src/main/java/org/rostilos/codecrow/ragengine/service/RagOperationsServiceImpl.java
@@ -71,6 +71,11 @@ public RagOperationsServiceImpl(
         this.ragPipelineClient = ragPipelineClient;
     }
 
+    @Override
+    public boolean isRagPipelineHealthy() {
+        return ragPipelineClient.isHealthy();
+    }
+
     @Override
     public boolean isRagEnabled(Project project) {
         if (!ragApiEnabled) {
