refactor: reduce time taken to post review-in-progress comment

Author: LennyMalcolm0

api/models/ai-review.model.ts

@@ -19,6 +19,8 @@ export interface PullRequestData {
     formattedPullRequest: string;
     /** Raw concatenated git diff from the *previous* review cycle, used for follow-up prompts. */
     previousDiff?: string;
+    /** ID of the in-progress comment already posted before queueing the job */
+    pendingCommentId?: string;
 }
 
 export interface ChangedFile {

api/services/pr-review/orchestration.service.ts

@@ -33,6 +33,7 @@ export class AIReviewOrchestrationService {
                     prNumber: prData.prNumber,
                     prUrl: prData.prUrl,
                     repositoryName: prData.repositoryName,
+                    commentId: prData.pendingCommentId,
                     mergeScore: 0,
                     rulesViolated: [],
                     rulesPassed: [],
@@ -192,25 +193,6 @@ export class AIReviewOrchestrationService {
             // Create initial review result record
             const initialResult = await this.createInitialReviewResult(prData);
 
-            // Post an "in progress" comment so contributors know a review is underway
-            try {
-                const commentResult = await AIReviewCommentService.postInProgressComment(
-                    prData.installationId,
-                    prData.repositoryName,
-                    prData.prNumber
-                );
-
-                if (commentResult.success && commentResult.commentId) {
-                    await prisma.aIReviewResult.update({
-                        where: { id: initialResult.id },
-                        data: { commentId: commentResult.commentId }
-                    });
-                }
-            } catch (inProgressError) {
-                // Non-fatal — log and continue with analysis
-                dataLogger.error("Failed to post in-progress comment", { inProgressError });
-            }
-
             // Execute analysis
             const reviewResult = await PRAnalysisService.analyzePullRequest(prData);
 
@@ -291,24 +273,6 @@ export class AIReviewOrchestrationService {
             const initialResult = await this.createInitialReviewResult(prData);
             recordId = initialResult.id;
 
-            // Post a "follow-up review in progress" notification comment
-            try {
-                const commentResult = await AIReviewCommentService.postFollowUpInProgressComment(
-                    prData.installationId,
-                    prData.repositoryName,
-                    prData.prNumber
-                );
-
-                if (commentResult.success && commentResult.commentId) {
-                    await prisma.aIReviewResult.update({
-                        where: { id: recordId },
-                        data: { commentId: commentResult.commentId }
-                    });
-                }
-            } catch (inProgressError) {
-                dataLogger.error("Failed to post follow-up in-progress comment", { inProgressError });
-            }
-
             // Run the follow-up analysis
             const reviewResult = await PRAnalysisService.analyzePullRequestFollowUp(prData);
 

api/services/pr-review/workflow-integration.service.ts

@@ -1,6 +1,7 @@
 import { PullRequestData, GitHubWebhookPayload } from "../../models/ai-review.model";
 import { backgroundJobService, BackgroundJobService } from "../background-job.service";
 import { AIReviewOrchestrationService } from "./orchestration.service";
+import { AIReviewCommentService } from "./comment.service";
 import { PRAnalysisService } from "./pr-analysis.service";
 import { PRAnalysisError } from "../../models/error.model";
 import { dataLogger, messageLogger } from "../../config/logger.config";
@@ -75,6 +76,7 @@ export class WorkflowIntegrationService {
         reason?: string;
     }> {
         const startTime = Date.now();
+        let prData: PullRequestData = {} as PullRequestData;
 
         try {
             dataLogger.info(
@@ -86,10 +88,47 @@ export class WorkflowIntegrationService {
                 }
             );
 
+            // Determine whether this is a follow-up (synchronize) or initial review.
+            // Manual triggers ("review" comment) always queue as an initial review.
+            const isFollowUp = !payload.manualTrigger && payload.action === "synchronize";
+            const { pull_request, repository, installation } = payload;
+
+            let isActualFollowUp = false;
+            if (isFollowUp) {
+                // Check whether a completed initial review already exists for this PR
+                isActualFollowUp = await this.orchestrationService.hasCompletedReview(
+                    installation.id.toString(),
+                    pull_request.number,
+                    repository.full_name
+                );
+            }
+
+            // Post an "in progress" comment so contributors know a review is underway
+            try {
+                const commentResult = isActualFollowUp
+                    ? await AIReviewCommentService.postFollowUpInProgressComment(
+                        installation.id.toString(),
+                        repository.full_name,
+                        pull_request.number
+                    )
+                    : await AIReviewCommentService.postInProgressComment(
+                        installation.id.toString(),
+                        repository.full_name,
+                        pull_request.number
+                    );
+
+                if (commentResult.success && commentResult.commentId) {
+                    prData.pendingCommentId = commentResult.commentId;
+                }
+            } catch (inProgressError) {
+                dataLogger.error("Failed to post in-progress comment", { inProgressError });
+            }
+
             // Extract and validate PR data
-            let prData: PullRequestData;
             try {
+                const pendingCommentId = prData.pendingCommentId;
                 prData = await PRAnalysisService.createCompletePRData(payload);
+                prData.pendingCommentId = pendingCommentId;
             } catch (error) {
                 if (error instanceof PRAnalysisError && error.code === "PR_NOT_ELIGIBLE_ERROR") {
                     dataLogger.info(
@@ -105,32 +144,19 @@ export class WorkflowIntegrationService {
             // Log analysis decision
             PRAnalysisService.logAnalysisDecision(prData, true);
 
-            // Determine whether this is a follow-up (synchronize) or initial review.
-            // Manual triggers ("review" comment) always queue as an initial review.
-            const isFollowUp = !payload.manualTrigger && payload.action === "synchronize";
-
             let jobId: string;
-            if (isFollowUp) {
-                // Check whether a completed initial review already exists for this PR
-                const hasPreviousReview = await this.orchestrationService.hasCompletedReview(
-                    prData.installationId,
-                    prData.prNumber,
-                    prData.repositoryName
-                );
-
-                if (hasPreviousReview) {
-                    // Queue as a follow-up job
-                    jobId = await this.jobQueue.addPRAnalysisJob(prData, true);
-                    dataLogger.info("Queued follow-up review job", { jobId, prNumber: prData.prNumber });
-                } else {
-                    // No prior review exists yet — treat this like an initial review
-                    jobId = await this.jobQueue.addPRAnalysisJob(prData, false);
-                    dataLogger.info("No prior review found; queued as initial review", { jobId, prNumber: prData.prNumber });
-                }
+            if (isActualFollowUp) {
+                // Queue as a follow-up job
+                jobId = await this.jobQueue.addPRAnalysisJob(prData, true);
+                dataLogger.info("Queued follow-up review job", { jobId, prNumber: prData.prNumber });
             } else {
-                // Initial review (opened / ready_for_review)
+                // No prior review exists yet, or it's an opened/ready_for_review event — treat this like an initial review
                 jobId = await this.jobQueue.addPRAnalysisJob(prData, false);
-                dataLogger.info("Queued initial review job", { jobId, prNumber: prData.prNumber });
+                if (isFollowUp) {
+                    dataLogger.info("No prior review found; queued as initial review", { jobId, prNumber: prData.prNumber });
+                } else {
+                    dataLogger.info("Queued initial review job", { jobId, prNumber: prData.prNumber });
+                }
             }
 
             dataLogger.info(