@in-the-loop-labs/pair-review 1.6.2 → 2.0.1

package/src/routes/mcp.js

@@ -7,20 +7,24 @@ const { v4: uuidv4 } = require('uuid');
 const { ReviewRepository, CommentRepository, AnalysisRunRepository, RepoSettingsRepository, PRMetadataRepository, query } = require('../database');
 const { renderPromptForSkill } = require('../ai/prompts/render-for-skill');
 const Analyzer = require('../ai/analyzer');
+const { getTierForModel } = require('../ai/provider');
+const { TIERS, TIER_ALIASES, resolveTier } = require('../ai/prompts/config');
 const { GitWorktreeManager } = require('../git/worktree');
 const path = require('path');
 const { normalizeRepository } = require('../utils/paths');
 const logger = require('../utils/logger');
+const { broadcastReviewEvent } = require('../sse/review-events');
 const {
   activeAnalyses,
-  prToAnalysisId,
-  localReviewToAnalysisId,
-  getLocalReviewKey,
+  reviewToAnalysisId,
   determineCompletionInfo,
   broadcastProgress,
   createProgressCallback
 } = require('./shared');
 
+// All valid tier values: canonical tiers + aliases (for Zod enum validation)
+const ALL_TIER_VALUES = /** @type {[string, ...string[]]} */ ([...TIERS, ...Object.keys(TIER_ALIASES)]);
+
 const router = express.Router();
 
 /**
@@ -61,6 +65,9 @@ async function handleAnalysisCompletion(analysisId, runId, result, savePersisten
   };
   activeAnalyses.set(analysisId, completedStatus);
   broadcastProgress(analysisId, completedStatus);
+  if (currentStatus.reviewId) {
+    broadcastReviewEvent(currentStatus.reviewId, { type: 'review:analysis_completed' });
+  }
 
   // Auto-cleanup after 30 minutes
   setTimeout(() => activeAnalyses.delete(analysisId), 30 * 60 * 1000);
@@ -195,14 +202,15 @@ function createMCPServer(db, options = {}) {
     {
       promptType: z.enum(['level1', 'level2', 'level3', 'orchestration'])
         .describe('Analysis level'),
-      tier: z.enum(['fast', 'balanced', 'thorough']).default('balanced')
+      tier: z.enum(ALL_TIER_VALUES).default('balanced')
         .describe('Prompt tier — fast (surface), balanced (standard), or thorough (deep)'),
       customInstructions: z.string().max(5000).optional()
         .describe('Optional repo or user-specific review instructions to include'),
     },
     async (args) => {
       try {
-        const rendered = renderPromptForSkill(args.promptType, args.tier, {
+        const tier = resolveTier(args.tier);
+        const rendered = renderPromptForSkill(args.promptType, tier, {
           customInstructions: args.customInstructions,
         });
         return { content: [{ type: 'text', text: rendered }] };
@@ -300,6 +308,8 @@ function createMCPServer(db, options = {}) {
               id: r.id,
               provider: r.provider,
               model: r.model,
+              // Enrich historical runs that predate the tier column (migration 22)
+              tier: r.tier ?? (r.provider && r.model ? getTierForModel(r.provider, r.model) : null),
               status: r.status,
               summary: r.summary,
               head_sha: r.head_sha,
@@ -439,14 +449,13 @@ function createMCPServer(db, options = {}) {
         .describe('Optional repo or user-specific review instructions'),
       skipLevel3: z.boolean().default(false)
         .describe('Whether to skip Level 3 (codebase context) analysis'),
-      tier: z.enum(['fast', 'balanced', 'thorough']).default('balanced')
+      tier: z.enum(ALL_TIER_VALUES).default('balanced')
         .describe('Analysis tier: fast (surface), balanced (standard), or thorough (deep)'),
     },
     async (args) => {
-      // Track analysisId and key for cleanup in catch block (must be outside try scope)
+      // Track analysisId and reviewId for cleanup in catch block (must be outside try scope)
       let analysisId = null;
-      let trackingKey = null;
-      let trackingMap = null;
+      let trackingReviewId = null;
 
       try {
         const reviewRepo = new ReviewRepository(db);
@@ -514,8 +523,7 @@ function createMCPServer(db, options = {}) {
           });
 
           // Concurrent analysis guard: check if one is already running
-          const reviewKey = getLocalReviewKey(reviewId);
-          const existingAnalysisId = localReviewToAnalysisId.get(reviewKey);
+          const existingAnalysisId = reviewToAnalysisId.get(reviewId);
           if (existingAnalysisId && activeAnalyses.get(existingAnalysisId)?.status === 'running') {
             return {
               content: [{
@@ -540,8 +548,7 @@ function createMCPServer(db, options = {}) {
           // Create unified run/analysis ID and DB record immediately
           const runId = uuidv4();
           analysisId = runId;
-          trackingKey = reviewKey;
-          trackingMap = localReviewToAnalysisId;
+          trackingReviewId = reviewId;
 
           const requestInstructions = args.customInstructions?.trim() || null;
           const repoInstructions = repoSettings?.default_instructions || null;
@@ -566,10 +573,11 @@ function createMCPServer(db, options = {}) {
           };
           activeAnalyses.set(analysisId, initialStatus);
 
-          // Store local review to analysis ID mapping
-          localReviewToAnalysisId.set(reviewKey, analysisId);
+          // Store review to analysis ID mapping (unified map)
+          reviewToAnalysisId.set(reviewId, analysisId);
 
           broadcastProgress(analysisId, initialStatus);
+          broadcastReviewEvent(reviewId, { type: 'review:analysis_started', analysisId });
 
           // Create analyzer and launch asynchronously
           const analyzer = new Analyzer(db, model, provider);
@@ -592,7 +600,7 @@ function createMCPServer(db, options = {}) {
           }
 
           const progressCallback = createProgressCallback(analysisId);
-          const tier = args.tier;
+          const tier = resolveTier(args.tier);
 
           logger.log('MCP', `Starting local analysis: review #${reviewId}, runId=${runId}`, 'magenta');
 
@@ -604,6 +612,7 @@ function createMCPServer(db, options = {}) {
             reviewId,
             provider,
             model,
+            tier,
             repoInstructions,
             requestInstructions,
             headSha: localHeadSha
@@ -618,7 +627,7 @@ function createMCPServer(db, options = {}) {
             }))
             .catch(error => handleAnalysisFailure(analysisId, error, `local review #${reviewId}`))
             .finally(() => {
-              localReviewToAnalysisId.delete(reviewKey);
+              reviewToAnalysisId.delete(reviewId);
             });
 
           return {
@@ -645,18 +654,16 @@ function createMCPServer(db, options = {}) {
           const repository = normalizeRepository(owner, repo);
 
           // Concurrent analysis guard: check if one is already running
-          // Use normalized repository to ensure case-insensitive matching
-          const prKey = `${repository}/${prNumber}`;
-          const existingAnalysisId = prToAnalysisId.get(prKey);
+          // First need the review to get the integer reviewId for the unified map
+          const existingReviewForGuard = await reviewRepo.getReviewByPR(prNumber, repository);
+          const existingAnalysisId = existingReviewForGuard ? reviewToAnalysisId.get(existingReviewForGuard.id) : null;
           if (existingAnalysisId && activeAnalyses.get(existingAnalysisId)?.status === 'running') {
-            // Look up the review to return its ID
-            const existingReview = await reviewRepo.getReviewByPR(prNumber, repository);
             return {
               content: [{
                 type: 'text',
                 text: JSON.stringify({
                   analysisId: existingAnalysisId,
-                  reviewId: existingReview?.id || null,
+                  reviewId: existingReviewForGuard?.id || null,
                   status: 'already_running',
                   message: 'An analysis is already running for this PR'
                 }, null, 2)
@@ -689,8 +696,7 @@ function createMCPServer(db, options = {}) {
           // Create unified run/analysis ID and DB record immediately
           const runId = uuidv4();
           analysisId = runId;
-          trackingKey = prKey;
-          trackingMap = prToAnalysisId;
+          trackingReviewId = review.id;
 
           // Save custom instructions if provided
           const requestInstructions = args.customInstructions?.trim() || null;
@@ -702,6 +708,7 @@ function createMCPServer(db, options = {}) {
 
           const initialStatus = {
             id: analysisId,
+            reviewId: review.id,
             prNumber,
             repository,
             reviewType: 'pr',
@@ -719,13 +726,14 @@ function createMCPServer(db, options = {}) {
           };
           activeAnalyses.set(analysisId, initialStatus);
 
-          prToAnalysisId.set(prKey, analysisId);
+          reviewToAnalysisId.set(review.id, analysisId);
 
           broadcastProgress(analysisId, initialStatus);
+          broadcastReviewEvent(review.id, { type: 'review:analysis_started', analysisId });
 
           const analyzer = new Analyzer(db, model, provider);
           const progressCallback = createProgressCallback(analysisId);
-          const tier = args.tier;
+          const tier = resolveTier(args.tier);
 
           logger.log('MCP', `Starting PR analysis: PR #${prNumber} in ${repository}, runId=${runId}`, 'magenta');
 
@@ -737,6 +745,7 @@ function createMCPServer(db, options = {}) {
             reviewId: review.id,
             provider,
             model,
+            tier,
             repoInstructions,
             requestInstructions,
             headSha: prMetadata.head_sha || null
@@ -752,7 +761,7 @@ function createMCPServer(db, options = {}) {
             }))
             .catch(error => handleAnalysisFailure(analysisId, error, `PR #${prNumber}`))
             .finally(() => {
-              prToAnalysisId.delete(prKey);
+              reviewToAnalysisId.delete(review.id);
             });
 
           return {
@@ -790,8 +799,8 @@ function createMCPServer(db, options = {}) {
             await analysisRunRepo.update(analysisId, { status: 'failed' });
           } catch (_) { /* record may not exist yet */ }
         }
-        if (trackingKey && trackingMap) {
-          trackingMap.delete(trackingKey);
+        if (trackingReviewId != null) {
+          reviewToAnalysisId.delete(trackingReviewId);
         }
 
         logger.error(`MCP start_analysis error: ${error.message}`);