feat: Enhance GitHub and GitLab services with PR/MR merge handling and analysis updates

- Added target branch name and current commit hash to AI client services for GitHub and GitLab.
- Implemented findPullRequestForCommit method in GitHubOperationsService to retrieve PRs associated with commits.
- Implemented findPullRequestForCommit method in GitLabOperationsService to retrieve MRs associated with commits.
- Created GitHubPrMergeWebhookHandler to handle PR merge events and trigger branch reconciliation.
- Created GitLabMrMergeWebhookHandler to handle MR merge events and trigger branch reconciliation.
- Updated AnalysisIssueController and ProjectAnalyticsController to support new issue resolution context (resolvedByPr and resolvedCommitHash).
- Enhanced IssueStatusUpdateRequest to include resolvedByPr and resolvedCommitHash fields.
- Updated AnalysisService to handle new resolution metadata when updating issue status.
- Improved prompt builder documentation for resolved issues.
- Removed outdated IMPLEMENTATION_SUMMARY.md file.

Author: rostilos

frontend

@@ -153,17 +153,37 @@ public Map<String, Object> process(BranchProcessRequest request, Consumer<Map<St
             EVcsProvider provider = getVcsProvider(project);
             VcsOperationsService operationsService = vcsServiceFactory.getOperationsService(provider);
 
+            // If sourcePrNumber is not set, try to look it up from the commit
+            // This handles cases where branch analysis is triggered by push events
+            Long prNumber = request.getSourcePrNumber();
+            if (prNumber == null && request.getCommitHash() != null) {
+                try {
+                    prNumber = operationsService.findPullRequestForCommit(
+                            client,
+                            vcsInfo.workspace(),
+                            vcsInfo.repoSlug(),
+                            request.getCommitHash()
+                    );
+                    if (prNumber != null) {
+                        log.info("Found PR #{} for commit {} via API lookup", prNumber, request.getCommitHash());
+                        request.sourcePrNumber = prNumber; // Update request for later use
+                    }
+                } catch (Exception e) {
+                    log.debug("Could not look up PR for commit {}: {}", request.getCommitHash(), e.getMessage());
+                }
+            }
+
             String rawDiff;
-            // Use PR diff if sourcePrNumber is available (from pullrequest:fulfilled events)
+            // Use PR diff if sourcePrNumber is available (from pullrequest:fulfilled events or API lookup)
             // This ensures we get ALL files from the PR, not just the merge commit changes
-            if (request.getSourcePrNumber() != null) {
+            if (prNumber != null) {
                 rawDiff = operationsService.getPullRequestDiff(
                         client,
                         vcsInfo.workspace(),
                         vcsInfo.repoSlug(),
-                        String.valueOf(request.getSourcePrNumber())
+                        String.valueOf(prNumber)
                 );
-                log.info("Fetched PR #{} diff for branch analysis (contains all PR files)", request.getSourcePrNumber());
+                log.info("Fetched PR #{} diff for branch analysis (contains all PR files)", prNumber);
             } else {
                 rawDiff = operationsService.getCommitDiff(
                         client,
@@ -423,7 +443,7 @@ private void reanalyzeCandidateIssues(Set<String> changedFiles, Branch branch, P
                         if (item instanceof Map) {
                             @SuppressWarnings("unchecked")
                             Map<String, Object> issueData = (Map<String, Object>) item;
-                            processReconciledIssue(issueData, branch, request.getCommitHash());
+                            processReconciledIssue(issueData, branch, request.getCommitHash(), request.getSourcePrNumber());
                         }
                     }
                 }
@@ -435,7 +455,7 @@ else if (issuesObj instanceof Map) {
                         if (val instanceof Map) {
                             @SuppressWarnings("unchecked")
                             Map<String, Object> issueData = (Map<String, Object>) val;
-                            processReconciledIssue(issueData, branch, request.getCommitHash());
+                            processReconciledIssue(issueData, branch, request.getCommitHash(), request.getSourcePrNumber());
                         }
                     }
                 } else if (issuesObj != null) {
@@ -464,8 +484,12 @@ else if (issuesObj instanceof Map) {
         }
     }
 
-    private void processReconciledIssue(Map<String, Object> issueData, Branch branch, String commitHash) {
-        Object issueIdFromAi = issueData.get("id");
+    private void processReconciledIssue(Map<String, Object> issueData, Branch branch, String commitHash, Long sourcePrNumber) {
+        // Try both "issueId" (as instructed in prompt) and "id" (fallback) for the issue identifier
+        Object issueIdFromAi = issueData.get("issueId");
+        if (issueIdFromAi == null) {
+            issueIdFromAi = issueData.get("id");
+        }
         Long actualIssueId = null;
 
         if (issueIdFromAi != null) {
@@ -485,26 +509,47 @@ private void processReconciledIssue(Map<String, Object> issueData, Branch branch
             resolved = true;
         }
 
+        // Extract AI's resolution reason/description if provided
+        String resolvedDescription = null;
+        if (issueData.get("reason") != null) {
+            resolvedDescription = String.valueOf(issueData.get("reason"));
+        }
+
         if (resolved && actualIssueId != null) {
             Optional<BranchIssue> branchIssueOpt = branchIssueRepository
                     .findByBranchIdAndCodeAnalysisIssueId(branch.getId(), actualIssueId);
             if (branchIssueOpt.isPresent()) {
                 BranchIssue bi = branchIssueOpt.get();
                 if (!bi.isResolved()) {
+                    java.time.OffsetDateTime now = java.time.OffsetDateTime.now();
+                    
+                    // Update BranchIssue with resolution info
                     bi.setResolved(true);
-                    bi.setResolvedInPrNumber(null);
+                    bi.setResolvedInPrNumber(sourcePrNumber);
                     bi.setResolvedInCommitHash(commitHash);
+                    bi.setResolvedDescription(resolvedDescription);
+                    bi.setResolvedAt(now);
+                    bi.setResolvedBy("AI-reconciliation");
                     branchIssueRepository.save(bi);
 
+                    // Update CodeAnalysisIssue with resolution info (preserving original issue data)
                     Optional<CodeAnalysisIssue> caiOpt = codeAnalysisIssueRepository.findById(actualIssueId);
                     if (caiOpt.isPresent()) {
                         CodeAnalysisIssue cai = caiOpt.get();
                         cai.setResolved(true);
+                        cai.setResolvedDescription(resolvedDescription);
+                        cai.setResolvedByPr(sourcePrNumber);
+                        cai.setResolvedCommitHash(commitHash);
+                        cai.setResolvedAt(now);
+                        cai.setResolvedBy("AI-reconciliation");
+                        // Note: original issue fields (reason, suggestedFixDescription, suggestedFixDiff, etc.) are preserved
                         codeAnalysisIssueRepository.save(cai);
                     }
-                    log.info("Marked branch issue {} as resolved (commit: {})",
+                    log.info("Marked branch issue {} as resolved (commit: {}, PR: {}, description: {})",
                             actualIssueId,
-                            commitHash);
+                            commitHash,
+                            sourcePrNumber,
+                            resolvedDescription != null ? resolvedDescription.substring(0, Math.min(100, resolvedDescription.length())) : "none");
                 }
             }
         }

java-ecosystem/libs/analysis-engine/src/main/java/org/rostilos/codecrow/analysisengine/processor/analysis/BranchAnalysisProcessor.java

@@ -68,4 +68,17 @@ public interface VcsOperationsService {
      * @throws IOException on network errors
      */
     boolean checkFileExistsInBranch(OkHttpClient client, String workspace, String repoSlug, String branchName, String filePath) throws IOException;
+
+    /**
+     * Finds the pull request number that introduced a specific commit to the repository.
+     * This is useful for branch reconciliation when we need to track which PR resolved an issue.
+     *
+     * @param client authorized HTTP client
+     * @param workspace workspace or team/organization slug
+     * @param repoSlug repository slug
+     * @param commitHash the commit hash to look up
+     * @return the PR/MR number that introduced this commit, or null if not found or commit wasn't from a PR
+     * @throws IOException on network errors
+     */
+    Long findPullRequestForCommit(OkHttpClient client, String workspace, String repoSlug, String commitHash) throws IOException;
 }

java-ecosystem/libs/analysis-engine/src/main/java/org/rostilos/codecrow/analysisengine/service/vcs/VcsOperationsService.java

@@ -25,7 +25,14 @@ public record IssueDTO (
     Long analysisId,
     Long prNumber,
     String commitHash,
-    OffsetDateTime detectedAt
+    OffsetDateTime detectedAt,
+    // Resolution info - populated when issue is resolved
+    String resolvedDescription,
+    Long resolvedByPr,
+    String resolvedCommitHash,
+    Long resolvedAnalysisId,
+    OffsetDateTime resolvedAt,
+    String resolvedBy
 ) {
     public static IssueDTO fromEntity(CodeAnalysisIssue issue) {
         String categoryStr = issue.getIssueCategory() != null 
@@ -53,7 +60,14 @@ public static IssueDTO fromEntity(CodeAnalysisIssue issue) {
                 analysis != null ? analysis.getId() : null,
                 analysis != null ? analysis.getPrNumber() : null,
                 analysis != null ? analysis.getCommitHash() : null,
-                issue.getCreatedAt()
+                issue.getCreatedAt(),
+                // Resolution info
+                issue.getResolvedDescription(),
+                issue.getResolvedByPr(),
+                issue.getResolvedCommitHash(),
+                issue.getResolvedAnalysisId(),
+                issue.getResolvedAt(),
+                issue.getResolvedBy()
         );
     }
 }

java-ecosystem/libs/core/src/main/java/org/rostilos/codecrow/core/dto/analysis/issue/IssueDTO.java

@@ -41,6 +41,15 @@ public class BranchIssue {
     @Column(name = "resolved_in_commit_hash", length = 40)
     private String resolvedInCommitHash;
 
+    @Column(name = "resolved_description", columnDefinition = "TEXT")
+    private String resolvedDescription;
+
+    @Column(name = "resolved_at")
+    private OffsetDateTime resolvedAt;
+
+    @Column(name = "resolved_by", length = 100)
+    private String resolvedBy;
+
     @Column(name = "created_at", nullable = false, updatable = false)
     private OffsetDateTime createdAt = OffsetDateTime.now();
 
@@ -75,6 +84,15 @@ public void onUpdate() {
     public String getResolvedInCommitHash() { return resolvedInCommitHash; }
     public void setResolvedInCommitHash(String resolvedInCommitHash) { this.resolvedInCommitHash = resolvedInCommitHash; }
 
+    public String getResolvedDescription() { return resolvedDescription; }
+    public void setResolvedDescription(String resolvedDescription) { this.resolvedDescription = resolvedDescription; }
+
+    public OffsetDateTime getResolvedAt() { return resolvedAt; }
+    public void setResolvedAt(OffsetDateTime resolvedAt) { this.resolvedAt = resolvedAt; }
+
+    public String getResolvedBy() { return resolvedBy; }
+    public void setResolvedBy(String resolvedBy) { this.resolvedBy = resolvedBy; }
+
     public OffsetDateTime getCreatedAt() { return createdAt; }
     public OffsetDateTime getUpdatedAt() { return updatedAt; }
 }

java-ecosystem/libs/core/src/main/java/org/rostilos/codecrow/core/model/branch/BranchIssue.java

@@ -43,6 +43,25 @@ public class CodeAnalysisIssue {
     @Column(name = "is_resolved", nullable = false)
     private boolean resolved;
 
+    // Resolution tracking fields - populated when issue is marked as resolved
+    @Column(name = "resolved_description", columnDefinition = "TEXT")
+    private String resolvedDescription;
+
+    @Column(name = "resolved_by_pr")
+    private Long resolvedByPr;
+
+    @Column(name = "resolved_commit_hash", length = 40)
+    private String resolvedCommitHash;
+
+    @Column(name = "resolved_analysis_id")
+    private Long resolvedAnalysisId;
+
+    @Column(name = "resolved_at")
+    private OffsetDateTime resolvedAt;
+
+    @Column(name = "resolved_by", length = 100)
+    private String resolvedBy;
+
     @Column(name = "created_at", nullable = false, updatable = false)
     private OffsetDateTime createdAt = OffsetDateTime.now();
 
@@ -75,5 +94,23 @@ public class CodeAnalysisIssue {
     public boolean isResolved() { return resolved; }
     public void setResolved(boolean resolved) { this.resolved = resolved; }
 
+    public String getResolvedDescription() { return resolvedDescription; }
+    public void setResolvedDescription(String resolvedDescription) { this.resolvedDescription = resolvedDescription; }
+
+    public Long getResolvedByPr() { return resolvedByPr; }
+    public void setResolvedByPr(Long resolvedByPr) { this.resolvedByPr = resolvedByPr; }
+
+    public String getResolvedCommitHash() { return resolvedCommitHash; }
+    public void setResolvedCommitHash(String resolvedCommitHash) { this.resolvedCommitHash = resolvedCommitHash; }
+
+    public Long getResolvedAnalysisId() { return resolvedAnalysisId; }
+    public void setResolvedAnalysisId(Long resolvedAnalysisId) { this.resolvedAnalysisId = resolvedAnalysisId; }
+
+    public OffsetDateTime getResolvedAt() { return resolvedAt; }
+    public void setResolvedAt(OffsetDateTime resolvedAt) { this.resolvedAt = resolvedAt; }
+
+    public String getResolvedBy() { return resolvedBy; }
+    public void setResolvedBy(String resolvedBy) { this.resolvedBy = resolvedBy; }
+
     public OffsetDateTime getCreatedAt() { return createdAt; }
 }

java-ecosystem/libs/core/src/main/java/org/rostilos/codecrow/core/model/codeanalysis/CodeAnalysisIssue.java

@@ -0,0 +1,28 @@
+-- Add resolution tracking fields to code_analysis_issue table
+-- These fields preserve the original issue data while tracking resolution metadata separately
+
+ALTER TABLE code_analysis_issue 
+ADD COLUMN IF NOT EXISTS resolved_description TEXT,
+ADD COLUMN IF NOT EXISTS resolved_by_pr BIGINT,
+ADD COLUMN IF NOT EXISTS resolved_commit_hash VARCHAR(40),
+ADD COLUMN IF NOT EXISTS resolved_analysis_id BIGINT,
+ADD COLUMN IF NOT EXISTS resolved_at TIMESTAMP WITH TIME ZONE,
+ADD COLUMN IF NOT EXISTS resolved_by VARCHAR(100);
+
+-- Add resolution tracking fields to branch_issue table
+ALTER TABLE branch_issue 
+ADD COLUMN IF NOT EXISTS resolved_description TEXT,
+ADD COLUMN IF NOT EXISTS resolved_at TIMESTAMP WITH TIME ZONE,
+ADD COLUMN IF NOT EXISTS resolved_by VARCHAR(100);
+
+-- Add comments explaining the purpose of these fields
+COMMENT ON COLUMN code_analysis_issue.resolved_description IS 'AI or user explanation of how/why the issue was resolved';
+COMMENT ON COLUMN code_analysis_issue.resolved_by_pr IS 'PR number that resolved this issue (if applicable)';
+COMMENT ON COLUMN code_analysis_issue.resolved_commit_hash IS 'Commit hash that resolved this issue';
+COMMENT ON COLUMN code_analysis_issue.resolved_analysis_id IS 'Analysis ID during which this issue was resolved';
+COMMENT ON COLUMN code_analysis_issue.resolved_at IS 'Timestamp when the issue was marked as resolved';
+COMMENT ON COLUMN code_analysis_issue.resolved_by IS 'Actor who resolved the issue (user, AI-reconciliation, manual)';
+
+COMMENT ON COLUMN branch_issue.resolved_description IS 'AI or user explanation of how/why the issue was resolved on this branch';
+COMMENT ON COLUMN branch_issue.resolved_at IS 'Timestamp when the issue was marked as resolved on this branch';
+COMMENT ON COLUMN branch_issue.resolved_by IS 'Actor who resolved the issue on this branch (user, AI-reconciliation, manual)';