1.2.1 rc

java-ecosystem/libs/analysis-engine/pom.xml

@@ -68,6 +68,12 @@
             <artifactId>okhttp</artifactId>
         </dependency>
 
+        <!-- JTokkit for token counting -->
+        <dependency>
+            <groupId>com.knuddels</groupId>
+            <artifactId>jtokkit</artifactId>
+        </dependency>
+
         <!-- Test Dependencies -->
         <dependency>
             <groupId>org.junit.jupiter</groupId>

java-ecosystem/libs/analysis-engine/src/main/java/module-info.java

@@ -18,6 +18,7 @@
     requires com.fasterxml.jackson.annotation;
     requires jakarta.persistence;
     requires kotlin.stdlib;
+    requires jtokkit;
 
     exports org.rostilos.codecrow.analysisengine.aiclient;
     exports org.rostilos.codecrow.analysisengine.config;

java-ecosystem/libs/analysis-engine/src/main/java/org/rostilos/codecrow/analysisengine/dto/request/ai/AiAnalysisRequestImpl.java

@@ -1,3 +1,3 @@
 package org.rostilos.codecrow.analysisengine.dto.request.ai;
 
 import com.fasterxml.jackson.annotation.JsonProperty;
@@ -278,6 +278,29 @@
             return self();
         }
 
+        /**
+         * Set previous issues from ALL PR analysis versions.
+         * This provides the LLM with complete issue history including resolved issues,
+         * helping it understand what was already found and fixed.
+         * 
+         * Issues are deduplicated by keeping only the most recent version of each issue.
+         * Resolved issues are included so the LLM knows what was already addressed.
+         * 
+         * @param allPrAnalyses List of all analyses for this PR, ordered by version DESC (newest first)
+         */
+        public T withAllPrAnalysesData(List<CodeAnalysis> allPrAnalyses) {
+            if (allPrAnalyses == null || allPrAnalyses.isEmpty()) {
+                return self();
+            }
+
+            this.previousCodeAnalysisIssues = allPrAnalyses.stream()
+                    .flatMap(analysis -> analysis.getIssues().stream())
+                    .map(AiRequestPreviousIssueDTO::fromEntity)
+                    .toList();
+
+            return self();
+        }
+
         public T withMaxAllowedTokens(int maxAllowedTokens) {
             this.maxAllowedTokens = maxAllowedTokens;
             return self();

java-ecosystem/libs/analysis-engine/src/main/java/org/rostilos/codecrow/analysisengine/dto/request/ai/AiRequestPreviousIssueDTO.java

@@ -15,12 +15,23 @@ public record AiRequestPreviousIssueDTO(
         String branch,
         String pullRequestId,
         String status, // open|resolved|ignored
-        String category
+        String category,
+        // Resolution tracking fields
+        Integer prVersion, // Which PR iteration this issue was found in
+        String resolvedDescription, // Description of how the issue was resolved
+        String resolvedByCommit, // Commit hash that resolved the issue
+        Long resolvedInPrVersion // PR version where this was resolved (null if still open)
 ) {
     public static AiRequestPreviousIssueDTO fromEntity(CodeAnalysisIssue issue) {
         String categoryStr = issue.getIssueCategory() != null 
             ? issue.getIssueCategory().name() 
             : IssueCategory.CODE_QUALITY.name();
+
+        Integer prVersion = null;
+        if (issue.getAnalysis() != null) {
+            prVersion = issue.getAnalysis().getPrVersion();
+        }
+
         return new AiRequestPreviousIssueDTO(
                 String.valueOf(issue.getId()),
                 categoryStr,
@@ -33,7 +44,11 @@ public static AiRequestPreviousIssueDTO fromEntity(CodeAnalysisIssue issue) {
                 issue.getAnalysis() == null ? null : issue.getAnalysis().getBranchName(),
                 issue.getAnalysis() == null || issue.getAnalysis().getPrNumber() == null ? null : String.valueOf(issue.getAnalysis().getPrNumber()),
                 issue.isResolved() ? "resolved" : "open",
-                categoryStr
+                categoryStr,
+                prVersion,
+                issue.getResolvedDescription(),
+                issue.getResolvedCommitHash(),
+                issue.getResolvedAnalysisId()
         );
     }
 }

java-ecosystem/libs/analysis-engine/src/main/java/org/rostilos/codecrow/analysisengine/dto/request/processor/PrProcessRequest.java

@@ -35,6 +35,13 @@ public class PrProcessRequest implements AnalysisProcessRequest {
     public String prAuthorId;
 
     public String prAuthorUsername;
+
+    /**
+     * Optional pre-acquired lock key. If set, the processor will skip lock acquisition
+     * and use this lock key directly. This prevents double-locking when the webhook handler
+     * has already acquired the lock before calling the processor.
+     */
+    public String preAcquiredLockKey;
 
 
     public Long getProjectId() {
@@ -64,4 +71,6 @@ public String getSourceBranchName() {
     public String getPrAuthorId() { return prAuthorId; }
 
     public String getPrAuthorUsername() { return prAuthorUsername; }
+
+    public String getPreAcquiredLockKey() { return preAcquiredLockKey; }
 }

java-ecosystem/libs/analysis-engine/src/main/java/org/rostilos/codecrow/analysisengine/exception/DiffTooLargeException.java

@@ -0,0 +1,47 @@
+package org.rostilos.codecrow.analysisengine.exception;
+
+/**
+ * Exception thrown when a diff exceeds the configured token limit for analysis.
+ * This is a soft skip - the analysis is not performed but the job is not marked as failed.
+ */
+public class DiffTooLargeException extends RuntimeException {
+
+    private final int estimatedTokens;
+    private final int maxAllowedTokens;
+    private final Long projectId;
+    private final Long pullRequestId;
+
+    public DiffTooLargeException(int estimatedTokens, int maxAllowedTokens, Long projectId, Long pullRequestId) {
+        super(String.format(
+            "PR diff exceeds token limit: estimated %d tokens, max allowed %d tokens (project=%d, PR=%d)",
+            estimatedTokens, maxAllowedTokens, projectId, pullRequestId
+        ));
+        this.estimatedTokens = estimatedTokens;
+        this.maxAllowedTokens = maxAllowedTokens;
+        this.projectId = projectId;
+        this.pullRequestId = pullRequestId;
+    }
+
+    public int getEstimatedTokens() {
+        return estimatedTokens;
+    }
+
+    public int getMaxAllowedTokens() {
+        return maxAllowedTokens;
+    }
+
+    public Long getProjectId() {
+        return projectId;
+    }
+
+    public Long getPullRequestId() {
+        return pullRequestId;
+    }
+
+    /**
+     * Returns the percentage of the token limit that would be used.
+     */
+    public double getUtilizationPercentage() {
+        return maxAllowedTokens > 0 ? (estimatedTokens * 100.0 / maxAllowedTokens) : 0;
+    }
+}

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

@@ -29,6 +29,7 @@
 import java.time.Duration;
 import java.time.Instant;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 
@@ -90,34 +91,45 @@
         // Publish analysis started event
         publishAnalysisStartedEvent(project, request, correlationId);
 
-        Optional<String> lockKey = analysisLockService.acquireLockWithWait(
-                project,
-                request.getSourceBranchName(),
-                AnalysisLockType.PR_ANALYSIS,
-                request.getCommitHash(),
-                request.getPullRequestId(),
-                consumer::accept
-        );
-
-        if (lockKey.isEmpty()) {
-            String message = String.format(
-                    "Failed to acquire lock after %d minutes for project=%s, PR=%d, branch=%s. Another analysis is still in progress.",
-                    analysisLockService.getLockWaitTimeoutMinutes(),
-                    project.getId(),
-                    request.getPullRequestId(),
-                    request.getSourceBranchName()
-            );
-            log.warn(message);
-
-            // Publish failed event due to lock timeout
-            publishAnalysisCompletedEvent(project, request, correlationId, startTime, 
-                    AnalysisCompletedEvent.CompletionStatus.FAILED, 0, 0, "Lock acquisition timeout");
-
-            throw new AnalysisLockedException(
-                    AnalysisLockType.PR_ANALYSIS.name(),
+        // Check if a lock was already acquired by the caller (e.g., webhook handler)
+        // to prevent double-locking which causes unnecessary 2-minute waits
+        String lockKey;
+        boolean isPreAcquired = false;
+        if (request.getPreAcquiredLockKey() != null && !request.getPreAcquiredLockKey().isBlank()) {
+            lockKey = request.getPreAcquiredLockKey();
+            isPreAcquired = true;
+            log.info("Using pre-acquired lock: {} for project={}, PR={}", lockKey, project.getId(), request.getPullRequestId());
+        } else {
+            Optional<String> acquiredLock = analysisLockService.acquireLockWithWait(
+                    project,
                     request.getSourceBranchName(),
-                    project.getId()
+                    AnalysisLockType.PR_ANALYSIS,
+                    request.getCommitHash(),
+                    request.getPullRequestId(),
+                    consumer::accept
             );
+
+            if (acquiredLock.isEmpty()) {
+                String message = String.format(
+                        "Failed to acquire lock after %d minutes for project=%s, PR=%d, branch=%s. Another analysis is still in progress.",
+                        analysisLockService.getLockWaitTimeoutMinutes(),
+                        project.getId(),
+                        request.getPullRequestId(),
+                        request.getSourceBranchName()
+                );
+                log.warn(message);
+
+                // Publish failed event due to lock timeout
+                publishAnalysisCompletedEvent(project, request, correlationId, startTime, 
+                        AnalysisCompletedEvent.CompletionStatus.FAILED, 0, 0, "Lock acquisition timeout");
+
+                throw new AnalysisLockedException(
+                        AnalysisLockType.PR_ANALYSIS.name(),
+                        request.getSourceBranchName(),
+                        project.getId()
+                );
+            }
+            lockKey = acquiredLock.get();
         }
 
         try {
@@ -139,16 +151,24 @@
                 return Map.of("status", "cached", "cached", true);
             }
 
-            Optional<CodeAnalysis> previousAnalysis = codeAnalysisService.getPreviousVersionCodeAnalysis(
+            // Get all previous analyses for this PR to provide full issue history to AI
+            List<CodeAnalysis> allPrAnalyses = codeAnalysisService.getAllPrAnalyses(
                     project.getId(),
                     request.getPullRequestId()
             );
+
+            // Get the most recent analysis for incremental diff calculation
+            Optional<CodeAnalysis> previousAnalysis = allPrAnalyses.isEmpty() 
+                    ? Optional.empty() 
+                    : Optional.of(allPrAnalyses.get(0));
 
-            // Ensure branch index exists for target branch if configured
+            // Ensure branch index exists for TARGET branch (e.g., "1.2.1-rc")
+            // This is where the PR will merge TO - we want RAG context from this branch
             ensureRagIndexForTargetBranch(project, request.getTargetBranchName(), consumer);
 
             VcsAiClientService aiClientService = vcsServiceFactory.getAiClientService(provider);
-            AiAnalysisRequest aiRequest = aiClientService.buildAiAnalysisRequest(project, request, previousAnalysis);
+            AiAnalysisRequest aiRequest = aiClientService.buildAiAnalysisRequest(
+                    project, request, previousAnalysis, allPrAnalyses);
 
             Map<String, Object> aiResponse = aiAnalysisClient.performAnalysis(aiRequest, event -> {
                 try {
@@ -208,7 +228,9 @@
 
             return Map.of("status", "error", "message", e.getMessage());
         } finally {
-            analysisLockService.releaseLock(lockKey.get());
+            if (!isPreAcquired) {
+                analysisLockService.releaseLock(lockKey);
+            }
         }
     }
 

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

@@ -7,6 +7,7 @@
 import org.rostilos.codecrow.analysisengine.dto.request.processor.AnalysisProcessRequest;
 
 import java.security.GeneralSecurityException;
+import java.util.List;
 import java.util.Optional;
 
 /**
@@ -31,4 +32,23 @@ AiAnalysisRequest buildAiAnalysisRequest(
             AnalysisProcessRequest request,
             Optional<CodeAnalysis> previousAnalysis
     ) throws GeneralSecurityException;
+
+    /**
+     * Builds an AI analysis request with full PR issue history.
+     * 
+     * @param project          The project being analyzed
+     * @param request          The analysis process request
+     * @param previousAnalysis Optional previous analysis for incremental analysis (used for delta diff calculation)
+     * @param allPrAnalyses    All analyses for this PR, ordered by version DESC (for issue history)
+     * @return The AI analysis request ready to be sent to the AI client
+     */
+    default AiAnalysisRequest buildAiAnalysisRequest(
+            Project project,
+            AnalysisProcessRequest request,
+            Optional<CodeAnalysis> previousAnalysis,
+            List<CodeAnalysis> allPrAnalyses
+    ) throws GeneralSecurityException {
+        // Default implementation falls back to the previous method for backward compatibility
+        return buildAiAnalysisRequest(project, request, previousAnalysis);
+    }
 }

java-ecosystem/libs/analysis-engine/src/main/java/org/rostilos/codecrow/analysisengine/util/TokenEstimator.java

@@ -0,0 +1,83 @@
+package org.rostilos.codecrow.analysisengine.util;
+
+import com.knuddels.jtokkit.Encodings;
+import com.knuddels.jtokkit.api.Encoding;
+import com.knuddels.jtokkit.api.EncodingRegistry;
+import com.knuddels.jtokkit.api.EncodingType;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Utility class for estimating token counts in text content.
+ * Uses the cl100k_base encoding (used by GPT-4, Claude, and most modern LLMs).
+ */
+public class TokenEstimator {
+    private static final Logger log = LoggerFactory.getLogger(TokenEstimator.class);
+
+    private static final EncodingRegistry ENCODING_REGISTRY = Encodings.newDefaultEncodingRegistry();
+    private static final Encoding ENCODING = ENCODING_REGISTRY.getEncoding(EncodingType.CL100K_BASE);
+
+    /**
+     * Estimate the number of tokens in the given text.
+     * 
+     * @param text The text to estimate tokens for
+     * @return The estimated token count, or 0 if text is null/empty
+     */
+    public static int estimateTokens(String text) {
+        if (text == null || text.isEmpty()) {
+            return 0;
+        }
+        try {
+            return ENCODING.countTokens(text);
+        } catch (Exception e) {
+            log.warn("Failed to count tokens, using fallback estimation: {}", e.getMessage());
+            // Fallback: rough estimate of ~4 characters per token
+            return text.length() / 4;
+        }
+    }
+
+    /**
+     * Check if the estimated token count exceeds the given limit.
+     * 
+     * @param text The text to check
+     * @param maxTokens The maximum allowed tokens
+     * @return true if the text exceeds the limit, false otherwise
+     */
+    public static boolean exceedsLimit(String text, int maxTokens) {
+        return estimateTokens(text) > maxTokens;
+    }
+
+    /**
+     * Result of a token estimation check with details.
+     */
+    public record TokenEstimationResult(
+        int estimatedTokens,
+        int maxAllowedTokens,
+        boolean exceedsLimit,
+        double utilizationPercentage
+    ) {
+        public String toLogString() {
+            return String.format("Tokens: %d / %d (%.1f%%) - %s",
+                estimatedTokens, maxAllowedTokens, utilizationPercentage,
+                exceedsLimit ? "EXCEEDS LIMIT" : "within limit");
+        }
+    }
+
+    /**
+     * Estimate tokens and check against limit, returning detailed result.
+     * 
+     * @param text The text to check
+     * @param maxTokens The maximum allowed tokens
+     * @return Detailed estimation result
+     */
+    public static TokenEstimationResult estimateAndCheck(String text, int maxTokens) {
+        int estimated = estimateTokens(text);
+        double utilization = maxTokens > 0 ? (estimated * 100.0 / maxTokens) : 0;
+        return new TokenEstimationResult(
+            estimated,
+            maxTokens,
+            estimated > maxTokens,
+            utilization
+        );
+    }
+}