@in-the-loop-labs/pair-review 3.0.5 → 3.1.0

package/src/routes/local.js

@@ -31,6 +31,11 @@ const { getGeneratedFilePatterns } = require('../git/gitattributes');
 const { getShaAbbrevLength } = require('../git/sha-abbrev');
 const { validateCouncilConfig, normalizeCouncilConfig } = require('./councils');
 const { TIERS, TIER_ALIASES, VALID_TIERS, resolveTier } = require('../ai/prompts/config');
+const { getProviderClass, createProvider } = require('../ai/provider');
+const { readFileSync } = require('fs');
+const { getDefaultBranch, tryGraphiteState, readGraphitePRInfo, enrichStackWithPRInfo } = require('../git/base-branch');
+const { CommentRepository } = require('../database');
+const { runExecutableAnalysis, getChangedFiles } = require('./executable-analysis');
 const {
   activeAnalyses,
   localReviewDiffs,
@@ -40,7 +45,8 @@ const {
   broadcastProgress,
   CancellationError,
   createProgressCallback,
-  parseEnabledLevels
+  parseEnabledLevels,
+  registerProcess: registerProcessForCancellation
 } = require('./shared');
 
 const router = express.Router();
@@ -66,6 +72,26 @@ function deleteLocalReviewDiff(reviewId) {
   localReviewDiffs.delete(toIntKey(reviewId));
 }
 
+/**
+ * Guard: reject the request if the review's scope resolves to zero changed files.
+ * Returns true if the guard fired (response already sent), false otherwise.
+ */
+async function rejectIfEmptyScope(res, review, localPath) {
+  const scopeContext = {
+    scopeStart: review.local_scope_start || DEFAULT_SCOPE.start,
+    scopeEnd: review.local_scope_end || DEFAULT_SCOPE.end,
+    baseBranch: review.local_base_branch || null,
+  };
+  const changedFiles = await getChangedFiles(localPath, scopeContext);
+  if (changedFiles.length === 0) {
+    res.status(409).json({
+      error: 'No changes found in the selected scope. Check that your scope includes files with modifications, or adjust the scope range.'
+    });
+    return true;
+  }
+  return false;
+}
+
 /**
  * Check whether branch scope should be selectable in the scope range selector.
  * Returns true when the current branch is a non-default, non-detached branch,
@@ -79,9 +105,8 @@ function isBranchAvailable(branchName, scopeStart, localPath) {
   if (includesBranch(scopeStart)) return true;
   if (!branchName || branchName === 'HEAD' || branchName === 'unknown') return false;
 
-  const { getDefaultBranch } = require('../git/base-branch');
-  const defaultBranch = localPath ? getDefaultBranch(localPath) : null;
-  // If detection fails, fall back to checking main/master
+  // Detect the default branch using only local refs (no network).
+  const defaultBranch = getDefaultBranch(localPath);
   if (defaultBranch) {
     return branchName !== defaultBranch;
   }
@@ -561,19 +586,14 @@ router.get('/api/local/:reviewId', async (req, res) => {
     const baseBranch = review.local_base_branch || null;
 
     // When scope does NOT include branch, check for branch detection info
-    // Frontend uses this to suggest expanding scope to include branch
+    // Frontend uses this to suggest expanding scope to include branch.
+    // Only use already-cached results here — never block the response on
+    // GitHub API calls.  Background detection (after res.json) will populate
+    // the cache for subsequent requests.
     let branchInfo = null;
     const cachedDiff = getLocalReviewDiff(reviewId);
     if (!includesBranch(scopeStart) && cachedDiff?.branchInfo) {
       branchInfo = cachedDiff.branchInfo;
-    } else if (!includesBranch(scopeStart) && !cachedDiff && review.local_path) {
-      // No cache (web UI started session) — run detection on-demand
-      const config = req.app.get('config') || {};
-      branchInfo = await detectAndBuildBranchInfo(review.local_path, branchName, {
-        repository: repositoryName,
-        githubToken: getGitHubToken(config),
-        enableGraphite: config.enable_graphite === true
-      });
     }
 
     // Check repo settings for auto_branch_review preference
@@ -602,6 +622,24 @@ router.get('/api/local/:reviewId', async (req, res) => {
 
     // Compute SHA abbreviation length from the repo's git config
     const shaAbbrevLength = getShaAbbrevLength(review.local_path);
+
+    // Detect Graphite stack if enabled
+    let stackData = null;
+    const localConfig = req.app.get('config') || {};
+    if (localConfig.enable_graphite === true && review.local_path && branchName && branchName !== 'unknown' && branchName !== 'HEAD') {
+      try {
+        const graphiteResult = tryGraphiteState(review.local_path, branchName, { execSync, readFileSync });
+        if (graphiteResult?.stack) {
+          const prInfo = readGraphitePRInfo(review.local_path, { execSync, readFileSync });
+          stackData = prInfo?.prInfos
+            ? enrichStackWithPRInfo(graphiteResult.stack, prInfo.prInfos)
+            : graphiteResult.stack;
+        }
+      } catch {
+        // Non-fatal — stack detection is an enhancement
+      }
+    }
+
     const metadataElapsed = Date.now() - tEndpoint;
     if (metadataElapsed > 200) {
       logger.debug(`[perf] metadata#${reviewId} took ${metadataElapsed}ms (threshold: 200ms)`);
@@ -622,6 +660,7 @@ router.get('/api/local/:reviewId', async (req, res) => {
       baseBranch,
       branchInfo,
       branchAvailable,
+      stackData,
       shaAbbrevLength,
       createdAt: review.created_at,
       updatedAt: review.updated_at
@@ -745,18 +784,20 @@ router.get('/api/local/:reviewId/diff', async (req, res) => {
       });
     }
 
-    // When ?w=1, regenerate the diff with whitespace changes hidden (transient view, not cached)
+    // When ?w=1 or ?base=<branch>, regenerate the diff (transient view, not cached)
     const hideWhitespace = req.query.w === '1';
+    const baseBranchOverride = req.query.base;
     const scopeStart = review.local_scope_start || DEFAULT_SCOPE.start;
     const scopeEnd = review.local_scope_end || DEFAULT_SCOPE.end;
+    const baseBranch = baseBranchOverride || review.local_base_branch;
     let diffData;
 
-    if (hideWhitespace && review.local_path) {
+    if ((hideWhitespace || baseBranchOverride) && review.local_path) {
       try {
-        const wsResult = await generateScopedDiff(review.local_path, scopeStart, scopeEnd, review.local_base_branch, { hideWhitespace: true });
+        const wsResult = await generateScopedDiff(review.local_path, scopeStart, scopeEnd, baseBranch, { hideWhitespace });
         diffData = { diff: wsResult.diff, stats: wsResult.stats };
       } catch (wsError) {
-        logger.warn(`Could not generate whitespace-filtered diff for review #${reviewId}: ${wsError.message}`);
+        logger.warn(`Could not generate diff for review #${reviewId}: ${wsError.message}`);
         // Fall through to cached diff below
       }
     }
@@ -973,6 +1014,63 @@ router.get('/api/local/:reviewId/check-stale', async (req, res) => {
   }
 });
 
+/**
+ * Handle analysis for executable providers (external CLI tools).
+ * Spawns the external CLI, maps its output to suggestions, and stores results.
+ */
+async function handleExecutableAnalysis(req, res, {
+  reviewId, review, localPath, repository, selectedProvider, selectedModel,
+  repoInstructions, requestInstructions, combinedInstructions, runId, analysisId, reviewRepo
+}) {
+  return runExecutableAnalysis(req, res, {
+    reviewId,
+    review,
+    selectedProvider,
+    selectedModel,
+    repoInstructions,
+    requestInstructions,
+    runId,
+    analysisId,
+    repository,
+    reviewType: review.review_type || 'local',
+    headSha: review.local_head_sha
+  }, {
+    activeAnalyses,
+    reviewToAnalysisId,
+    broadcastProgress,
+    broadcastReviewEvent,
+    registerProcessForCancellation
+  }, {
+    logLabel: `Review #${reviewId}`,
+    buildContext: (r, { selectedModel: model, requestInstructions: customInstructions }) => ({
+      title: null,
+      description: null,
+      cwd: localPath,
+      model,
+      baseSha: null,
+      headSha: r.local_head_sha || null,
+      baseBranch: r.local_base_branch || null,
+      headBranch: r.local_head_branch || null,
+      scopeStart: r.local_scope_start || DEFAULT_SCOPE.start,
+      scopeEnd: r.local_scope_end || DEFAULT_SCOPE.end,
+      customInstructions: customInstructions || null
+    }),
+    buildHookPayload: () => ({
+      mode: review.review_type || 'local',
+      localContext: { path: localPath, branch: review.local_head_branch, headSha: review.local_head_sha }
+    }),
+    onSuccess: async (_db, _runId, { summary }) => {
+      if (summary) {
+        try {
+          await reviewRepo.updateSummary(reviewId, summary);
+        } catch (e) {
+          logger.warn(`Failed to save summary: ${e.message}`);
+        }
+      }
+    }
+  });
+}
+
 /**
  * Start Level 1 AI analysis for local review
  */
@@ -987,7 +1085,7 @@ router.post('/api/local/:reviewId/analyses', async (req, res) => {
     }
 
     // Extract optional provider, model, tier, customInstructions and skipLevel3 from request body
-    const { provider: requestProvider, model: requestModel, tier: requestTier, customInstructions: rawInstructions, skipLevel3: requestSkipLevel3, enabledLevels: requestEnabledLevels } = req.body || {};
+    const { provider: requestProvider, model: requestModel, tier: requestTier, customInstructions: rawInstructions, skipLevel3: requestSkipLevel3, enabledLevels: requestEnabledLevels, excludePrevious } = req.body || {};
 
     // Trim and validate custom instructions
     const MAX_INSTRUCTIONS_LENGTH = 5000;
@@ -1018,10 +1116,15 @@ router.post('/api/local/:reviewId/analyses', async (req, res) => {
     const localPath = review.local_path;
     const repository = review.repository;
 
+    // Guard: reject if scope resolves to zero changed files
+    if (await rejectIfEmptyScope(res, review, localPath)) return;
+
     // Fetch repo settings for default instructions
     const repoSettingsRepo = new RepoSettingsRepository(db);
     const repoSettings = repository ? await repoSettingsRepo.getRepoSettings(repository) : null;
 
+    const appConfig = req.app.get('config') || {};
+
     // Determine provider: request body > repo settings > config > default ('claude')
     let selectedProvider;
     if (requestProvider) {
@@ -1029,8 +1132,7 @@ router.post('/api/local/:reviewId/analyses', async (req, res) => {
     } else if (repoSettings && repoSettings.default_provider) {
       selectedProvider = repoSettings.default_provider;
     } else {
-      const config = req.app.get('config') || {};
-      selectedProvider = config.default_provider || config.provider || 'claude';
+      selectedProvider = appConfig.default_provider || appConfig.provider || 'claude';
     }
 
     // Determine model: request body > repo settings > config/CLI > default
@@ -1045,8 +1147,10 @@ router.post('/api/local/:reviewId/analyses', async (req, res) => {
 
     // Get repo instructions from settings
     const repoInstructions = repoSettings?.default_instructions || null;
+    // Get global instructions from config (loaded at startup from ~/.pair-review/global-instructions.md)
+    const globalInstructions = appConfig.globalInstructions || null;
     // Merge for logging purposes (analyzer will also merge internally)
-    const combinedInstructions = mergeInstructions(repoInstructions, requestInstructions);
+    const combinedInstructions = mergeInstructions({ globalInstructions, repoInstructions, requestInstructions });
 
     // Save custom instructions to the review record
     // Only update when requestInstructions has a value - updateReview would accept
@@ -1061,6 +1165,25 @@ router.post('/api/local/:reviewId/analyses', async (req, res) => {
     const runId = uuidv4();
     const analysisId = runId;
 
+    // Check if selected provider is an executable provider (external tool)
+    const ProviderClass = getProviderClass(selectedProvider);
+    if (ProviderClass?.isExecutable) {
+      return handleExecutableAnalysis(req, res, {
+        reviewId,
+        review,
+        localPath,
+        repository,
+        selectedProvider,
+        selectedModel,
+        repoInstructions,
+        requestInstructions,
+        combinedInstructions,
+        runId,
+        analysisId,
+        reviewRepo
+      });
+    }
+
     // Extract scope early — needed for both analysis run creation and diff generation
     const scopeStart = review.local_scope_start || DEFAULT_SCOPE.start;
     const scopeEnd = review.local_scope_end || DEFAULT_SCOPE.end;
@@ -1076,6 +1199,7 @@ router.post('/api/local/:reviewId/analyses', async (req, res) => {
         provider: selectedProvider,
         model: selectedModel,
         tier,
+        globalInstructions,
         repoInstructions,
         requestInstructions,
         headSha: review.local_head_sha || null,
@@ -1181,7 +1305,7 @@ router.post('/api/local/:reviewId/analyses', async (req, res) => {
     const progressCallback = createProgressCallback(analysisId);
 
     // Start analysis asynchronously (skipRunCreation since we created the record above; also passes changedFiles for local mode path validation, tier for prompt selection, and skipLevel3 flag)
-    analyzer.analyzeLevel1(reviewId, localPath, localMetadata, progressCallback, { repoInstructions, requestInstructions }, changedFiles, { analysisId, runId, skipRunCreation: true, tier, skipLevel3: requestSkipLevel3, enabledLevels: levelsConfig })
+    analyzer.analyzeLevel1(reviewId, localPath, localMetadata, progressCallback, { globalInstructions, repoInstructions, requestInstructions }, changedFiles, { analysisId, runId, skipRunCreation: true, tier, skipLevel3: requestSkipLevel3, enabledLevels: levelsConfig, excludePrevious, serverPort: req.socket.localPort })
       .then(async result => {
         logger.section('Local Analysis Results');
         logger.success(`Analysis complete for local review #${reviewId}`);
@@ -1851,7 +1975,7 @@ router.post('/api/local/:reviewId/review-settings', async (req, res) => {
 router.post('/api/local/:reviewId/analyses/council', async (req, res) => {
   try {
     const reviewId = parseInt(req.params.reviewId, 10);
-    const { councilId, councilConfig: inlineConfig, customInstructions: rawInstructions, configType: requestConfigType } = req.body || {};
+    const { councilId, councilConfig: inlineConfig, customInstructions: rawInstructions, configType: requestConfigType, excludePrevious } = req.body || {};
 
     if (isNaN(reviewId) || reviewId <= 0) {
       return res.status(400).json({ error: 'Invalid review ID' });
@@ -1894,6 +2018,9 @@ router.post('/api/local/:reviewId/analyses/council', async (req, res) => {
 
     const localPath = review.local_path;
 
+    // Guard: reject if scope resolves to zero changed files
+    if (await rejectIfEmptyScope(res, review, localPath)) return;
+
     const councilScopeStart = review.local_scope_start || DEFAULT_SCOPE.start;
     const councilScopeEnd = review.local_scope_end || DEFAULT_SCOPE.end;
     const councilHasBranch = includesBranch(councilScopeStart);
@@ -1914,7 +2041,11 @@ router.post('/api/local/:reviewId/analyses/council', async (req, res) => {
       title: review.name || (councilHasBranch ? `Branch changes: ${review.local_base_branch}..HEAD` : 'Local changes'),
       description: '',
       base_sha: analysisBaseSha,
-      head_sha: review.local_head_sha
+      head_sha: review.local_head_sha,
+      base_branch: review.local_base_branch || null,
+      head_branch: review.local_head_branch || null,
+      scopeStart: councilScopeStart,
+      scopeEnd: councilScopeEnd,
     };
 
     const analyzer = new Analyzer(db, 'council', 'council');
@@ -1947,6 +2078,7 @@ router.post('/api/local/:reviewId/analyses/council', async (req, res) => {
 
     // Import launchCouncilAnalysis from analyses.js
     const analysesRouter = require('./analyses');
+    const localCouncilConfig = req.app.get('config') || {};
     const { analysisId, runId } = await analysesRouter.launchCouncilAnalysis(
       db,
       {
@@ -1958,7 +2090,9 @@ router.post('/api/local/:reviewId/analyses/council', async (req, res) => {
         headSha: review.local_head_sha,
         logLabel: `local review #${reviewId}`,
         initialStatusExtra: { reviewId, reviewType: 'local' },
-        config: req.app.get('config') || {},
+        config: localCouncilConfig,
+        excludePrevious,
+        serverPort: req.socket.localPort,
         hookContext: {
           mode: 'local',
           localContext: { path: localPath, branch: review.local_head_branch, headSha: review.local_head_sha },
@@ -1967,7 +2101,7 @@ router.post('/api/local/:reviewId/analyses/council', async (req, res) => {
       },
       councilConfig,
       councilId,
-      { repoInstructions, requestInstructions },
+      { globalInstructions: localCouncilConfig.globalInstructions || null, repoInstructions, requestInstructions },
       configType
     );
 

package/src/routes/mcp.js

@@ -411,7 +411,7 @@ function createMCPServer(db, options = {}) {
         SELECT
           id, ai_run_id, ai_level, ai_confidence,
           file, line_start, line_end, type, title, body,
-          reasoning, status, is_file_level, created_at
+          reasoning, status, is_file_level, severity, created_at
         FROM comments
         WHERE ${conditions.join('\n          AND ')}
         ORDER BY file, line_start
@@ -433,6 +433,7 @@ function createMCPServer(db, options = {}) {
               body: s.body,
               type: s.type,
               ai_confidence: s.ai_confidence,
+              severity: s.severity,
               status: s.status,
               reasoning: safeParseJson(s.reasoning),
             }))
@@ -457,6 +458,10 @@ function createMCPServer(db, options = {}) {
         .describe('Whether to skip Level 3 (codebase context) analysis'),
       tier: z.enum(ALL_TIER_VALUES).default('balanced')
         .describe('Analysis tier: fast (surface), balanced (standard), or thorough (deep)'),
+      excludePrevious: z.object({
+        github: z.boolean().optional().describe('Exclude GitHub PR inline review comments'),
+        feedback: z.boolean().optional().describe('Exclude existing pair-review suggestions and comments')
+      }).optional().describe('Exclude previously identified issues from results'),
     },
     async (args) => {
       // Track analysisId and reviewId for cleanup in catch block (must be outside try scope)
@@ -630,7 +635,7 @@ function createMCPServer(db, options = {}) {
           });
 
           // Launch analysis asynchronously (skipRunCreation since we created the record above)
-          analyzer.analyzeLevel1(reviewId, localPath, localMetadata, progressCallback, { repoInstructions, requestInstructions }, changedFiles, { analysisId, runId, skipRunCreation: true, tier, skipLevel3: args.skipLevel3 })
+          analyzer.analyzeLevel1(reviewId, localPath, localMetadata, progressCallback, { repoInstructions, requestInstructions }, changedFiles, { analysisId, runId, skipRunCreation: true, tier, skipLevel3: args.skipLevel3, excludePrevious: args.excludePrevious, serverPort: (options.port || config.port || 7247) })
             .then(result => handleAnalysisCompletion(analysisId, runId, result, async (r) => {
               if (r.summary) {
                 try { await reviewRepo.updateSummary(reviewId, r.summary); } catch (_) { /* ignore */ }
@@ -763,7 +768,7 @@ function createMCPServer(db, options = {}) {
           });
 
           // Launch analysis asynchronously (skipRunCreation since we created the record above)
-          analyzer.analyzeLevel1(review.id, worktreePath, prMetadata, progressCallback, { repoInstructions, requestInstructions }, null, { analysisId, runId, skipRunCreation: true, tier, skipLevel3: args.skipLevel3 })
+          analyzer.analyzeLevel1(review.id, worktreePath, prMetadata, progressCallback, { repoInstructions, requestInstructions }, null, { analysisId, runId, skipRunCreation: true, tier, skipLevel3: args.skipLevel3, excludePrevious: args.excludePrevious, serverPort: (options.port || config.port || 7247) })
             .then(result => handleAnalysisCompletion(analysisId, runId, result, async (r) => {
               try { await prMetadataRepo.updateLastAiRunId(prMetadata.id, r.runId); } catch (_) { /* ignore */ }
               if (r.summary) {
@@ -837,7 +842,7 @@ router.post('/mcp', async (req, res) => {
   try {
     const db = req.app.get('db');
     const config = req.app.get('config') || {};
-    const server = createMCPServer(db, { config });
+    const server = createMCPServer(db, { config, port: req.socket.localPort });
 
     const transport = new StreamableHTTPServerTransport({
       sessionIdGenerator: undefined,