@in-the-loop-labs/pair-review 3.6.0 → 3.7.0

package/src/routes/local.js

@@ -497,10 +497,13 @@ router.post('/api/local/start', async (req, res) => {
     const digest = await computeScopedDigest(repoPath, scopeStart, scopeEnd);
 
     // Branch detection: when no uncommitted changes, check if branch has commits ahead
+    const { resolveHostBinding: _resolveHostBindingForBranch } = require('../config');
+    const branchBinding = repository ? _resolveHostBindingForBranch(repository, config) : null;
     const branchInfo = await detectAndBuildBranchInfo(repoPath, branch, {
       repository,
       diff,
-      githubToken: getGitHubToken(config),
+      githubToken: branchBinding?.token || getGitHubToken(config),
+      hostBinding: branchBinding,
       enableGraphite: config.enable_graphite === true
     });
 
@@ -716,13 +719,18 @@ router.get('/api/local/:reviewId', async (req, res) => {
         && branchName && branchName !== 'HEAD' && branchName !== 'unknown'
         && repositoryName && repositoryName.includes('/')) {
       const bgConfig = req.app.get('config') || {};
-      const bgToken = getGitHubToken(bgConfig);
+      const { resolveHostBinding: _resolveHostBinding } = require('../config');
+      const bgBinding = _resolveHostBinding(repositoryName, bgConfig);
+      const bgToken = bgBinding.token;
       const bgT0 = Date.now();
       const { detectBaseBranch } = require('../git/base-branch');
       detectBaseBranch(review.local_path, branchName, {
         repository: repositoryName,
         enableGraphite: bgConfig.enable_graphite === true,
-        _deps: bgToken ? { getGitHubToken: () => bgToken } : undefined
+        _deps: bgToken ? {
+          getGitHubToken: () => bgToken,
+          getHostBinding: () => bgBinding
+        } : undefined
       }).then(detection => {
         if (detection && detection.baseBranch) {
           return reviewRepo.updateReview(reviewId, { local_base_branch: detection.baseBranch });
@@ -1450,7 +1458,9 @@ 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)
+    // 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).
+    // Local mode has no associated GitHub PR, so githubClient is intentionally omitted —
+    // the analyzer drops the GitHub dedup section when no client is supplied.
     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');
@@ -1940,11 +1950,16 @@ router.post('/api/local/:reviewId/set-scope', async (req, res) => {
         } else {
           const { detectBaseBranch } = require('../git/base-branch');
           const config = req.app.get('config') || {};
-          const token = getGitHubToken(config);
+          const { resolveHostBinding: _resolveHostBinding } = require('../config');
+          const localBinding = _resolveHostBinding(review.repository, config);
+          const token = localBinding.token;
           const detection = await detectBaseBranch(localPath, currentBranch, {
             repository: review.repository,
             enableGraphite: config.enable_graphite === true,
-            _deps: token ? { getGitHubToken: () => token } : undefined
+            _deps: token ? {
+              getGitHubToken: () => token,
+              getHostBinding: () => localBinding
+            } : undefined
           });
           if (!detection) {
             return res.status(400).json({ error: 'Could not detect base branch' });
@@ -2257,11 +2272,19 @@ router.post('/api/local/:reviewId/analyses/council', async (req, res) => {
       baseBranch: review.local_base_branch || null,
     });
 
-    // Generate and cache diff
+    // Generate and cache diff. Hoist the result out of the try so we can also
+    // persist it to `local_diffs` below (after reviewRepo is constructed) — the
+    // council path previously cached the diff in-memory only, which left the
+    // manual tour/summary buttons reporting a false "no-diff" after a restart.
+    let councilDiff = null;
+    let councilStats = null;
+    let councilDigest = null;
     try {
       const diffResult = await generateScopedDiff(localPath, councilScopeStart, councilScopeEnd, review.local_base_branch);
-      const digest = await computeScopedDigest(localPath, councilScopeStart, councilScopeEnd);
-      setLocalReviewDiff(reviewId, { diff: diffResult.diff, stats: diffResult.stats, digest });
+      councilDigest = await computeScopedDigest(localPath, councilScopeStart, councilScopeEnd);
+      councilDiff = diffResult.diff;
+      councilStats = diffResult.stats;
+      setLocalReviewDiff(reviewId, { diff: councilDiff, stats: councilStats, digest: councilDigest });
     } catch (diffError) {
       logger.warn(`Could not generate diff for local council review ${reviewId}: ${diffError.message}`);
     }
@@ -2269,6 +2292,16 @@ router.post('/api/local/:reviewId/analyses/council', async (req, res) => {
     // Resolve instructions
     const repoSettingsRepo = new RepoSettingsRepository(db);
     const reviewRepo = new ReviewRepository(db);
+
+    // Durably persist the diff so it survives a restart and the manual
+    // tour/summary buttons can find it (parity with the analysis-push path).
+    if (councilDiff) {
+      try {
+        await reviewRepo.saveLocalDiff(reviewId, { diff: councilDiff, stats: councilStats, digest: councilDigest });
+      } catch (saveError) {
+        logger.warn(`Could not persist diff for local council review ${reviewId}: ${saveError.message}`);
+      }
+    }
     const repoSettings = await repoSettingsRepo.getRepoSettings(review.repository);
     const repoInstructions = repoSettings?.default_instructions || null;
     const requestInstructions = rawInstructions?.trim() || null;
@@ -2286,6 +2319,8 @@ router.post('/api/local/:reviewId/analyses/council', async (req, res) => {
     const { providerOverrides: councilProviderOverrides, providerOverridesMap: councilProviderOverridesMap } =
       buildCouncilProviderOverrides(localCouncilConfig, review.repository, repoSettings);
 
+    // Local mode has no associated GitHub PR, so we do not pass a githubClient.
+    // The analyzer drops the GitHub dedup section when no client is supplied.
     const { analysisId, runId } = await analysesRouter.launchCouncilAnalysis(
       db,
       {
@@ -2380,10 +2415,65 @@ router.post('/api/local/:reviewId/jobs/:jobKey/start', async (req, res) => {
       return res.status(404).json({ error: `Local review #${reviewId} not found` });
     }
 
-    const localDiff = await reviewRepo.getLocalDiff(reviewId);
-    const diffText = localDiff ? (localDiff.diff || '') : '';
     const worktreePath = review.local_path || null;
 
+    // Resolve the diff through the same chain the rest of this file uses, rather
+    // than a DB-only read. Reviews created via the analysis-push, council, or MCP
+    // paths may have a diff only in the in-memory cache (or nowhere yet), so a
+    // DB-only read would falsely report "no-diff" for a review that clearly has
+    // changes. Order: (1) in-memory cache, (2) persisted `local_diffs` row,
+    // (3) regenerate from the live working tree (scope-aware) and persist.
+    let diffText = getLocalReviewDiff(reviewId)?.diff || '';
+
+    if (!diffText) {
+      const persistedDiff = await reviewRepo.getLocalDiff(reviewId);
+      diffText = persistedDiff?.diff || '';
+    }
+
+    if (!diffText && worktreePath) {
+      // Regenerate from the current working tree and persist (in-memory + DB) so
+      // the next read is fast and durable, and so pre-Fix-B reviews self-heal.
+      // Mirrors the council diff block above: on error, log and leave it empty.
+      try {
+        const { start: scopeStart, end: scopeEnd } = reviewScope(review);
+        const hasBranch = includesBranch(scopeStart);
+
+        // Snapshot guard: mirror the HEAD invariant enforced by the refresh-diff
+        // handler (see ~line 1702). For a non-branch review, the persisted diff is
+        // pinned to `local_head_sha`. If HEAD has since moved, regenerating here
+        // would silently re-snapshot the CURRENT worktree onto a row that still
+        // claims the OLDER SHA — a data-consistency hole. So we only regenerate
+        // when HEAD still matches; otherwise we leave diffText empty and let the
+        // `{ started: false, reason: 'no-diff' }` response funnel the user through
+        // the established refresh-diff / resolve-head-change flow. Branch-scoped
+        // reviews persist across HEAD changes, so they always regenerate.
+        let headPinned = true;
+        if (!hasBranch && review.local_head_sha) {
+          // Lazy require keeps getHeadSha stubbable via vi.spyOn in tests.
+          const { getHeadSha } = require('../local-review');
+          const currentHeadSha = await getHeadSha(worktreePath);
+          if (currentHeadSha !== review.local_head_sha) {
+            headPinned = false;
+            logger.warn(`Skipping self-heal diff regen for local review ${reviewId} (${jobKey}): HEAD moved on non-branch review (recorded ${review.local_head_sha}, current ${currentHeadSha}) — funneling through resolve-head-change`);
+          }
+        }
+
+        if (headPinned) {
+          const diffResult = await generateScopedDiff(worktreePath, scopeStart, scopeEnd, review.local_base_branch);
+          diffText = diffResult.diff || '';
+          if (diffText) {
+            const digest = await computeScopedDigest(worktreePath, scopeStart, scopeEnd);
+            setLocalReviewDiff(reviewId, { diff: diffText, stats: diffResult.stats, digest });
+            await reviewRepo.saveLocalDiff(reviewId, { diff: diffText, stats: diffResult.stats, digest });
+          }
+        }
+      } catch (regenError) {
+        // A getHeadSha throw (e.g. missing worktree) lands here: leave diffText
+        // empty so the no-diff response fires, matching prior behavior.
+        logger.warn(`Could not regenerate diff for local review ${reviewId} manual ${jobKey} start: ${regenError.message}`);
+      }
+    }
+
     if (!diffText || !worktreePath) {
       return res.json({ started: false, reason: 'no-diff' });
     }

package/src/routes/mcp.js

@@ -11,19 +11,22 @@ const { getTierForModel } = require('../ai/provider');
 const { TIERS, TIER_ALIASES, resolveTier } = require('../ai/prompts/config');
 const { GitWorktreeManager } = require('../git/worktree');
 const path = require('path');
-const { getCurrentBranch } = require('../local-review');
+const { getCurrentBranch, generateScopedDiff, computeScopedDigest } = require('../local-review');
+const { reviewScope } = require('../local-scope');
 const { normalizeRepository } = require('../utils/paths');
 const logger = require('../utils/logger');
 const { broadcastReviewEvent } = require('../events/review-events');
 const {
   activeAnalyses,
   reviewToAnalysisId,
+  localReviewDiffs,
   determineCompletionInfo,
   broadcastProgress,
   createProgressCallback
 } = require('./shared');
 const { safeParseJson } = require('../utils/safe-parse-json');
-const { resolveLoadSkills } = require('../config');
+const { resolveLoadSkills, resolveHostBinding } = require('../config');
+const { GitHubClient } = require('../github/client');
 
 // All valid tier values: canonical tiers + aliases (for Zod enum validation)
 const ALL_TIER_VALUES = /** @type {[string, ...string[]]} */ ([...TIERS, ...Object.keys(TIER_ALIASES)]);
@@ -557,6 +560,32 @@ function createMCPServer(db, options = {}) {
 
           const review = await reviewRepo.getLocalReviewById(reviewId);
 
+          // Persist the diff so the web UI can display it and the manual
+          // tour/summary buttons work (including after a restart). The MCP path
+          // previously stored the diff only in analysis_runs, leaving no
+          // `local_diffs` row.
+          //
+          // Use the review's recorded scope — not the default-scope wrapper — so
+          // re-using a review that was moved to `staged` or `branch` scope does
+          // not clobber its durable row with a narrower default-scope patch. Set
+          // the in-memory cache alongside the DB row so the cache-first readers
+          // in routes/local.js don't keep serving a stale entry. Non-fatal:
+          // matches the analysis-push path.
+          try {
+            const { start: scopeStart, end: scopeEnd } = reviewScope(review);
+            const diffResult = await generateScopedDiff(
+              localPath,
+              scopeStart,
+              scopeEnd,
+              review.local_base_branch || null
+            );
+            const digest = await computeScopedDigest(localPath, scopeStart, scopeEnd);
+            localReviewDiffs.set(reviewId, { diff: diffResult.diff, stats: diffResult.stats, digest });
+            await reviewRepo.saveLocalDiff(reviewId, { diff: diffResult.diff, stats: diffResult.stats, digest });
+          } catch (diffError) {
+            logger.warn(`Could not generate or persist diff for local review ${reviewId}: ${diffError.message}`);
+          }
+
           // Resolve provider and model
           const repoSettings = repository ? await repoSettingsRepo.getRepoSettings(repository) : null;
           const provider = process.env.PAIR_REVIEW_PROVIDER || repoSettings?.default_provider || config.default_provider || config.provider || 'claude';
@@ -640,7 +669,9 @@ function createMCPServer(db, options = {}) {
             headSha: localHeadSha
           });
 
-          // Launch analysis asynchronously (skipRunCreation since we created the record above)
+          // Launch analysis asynchronously (skipRunCreation since we created the record above).
+          // Local mode has no associated GitHub PR, so githubClient is intentionally
+          // omitted — the analyzer drops the GitHub dedup section when no client is supplied.
           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) {
@@ -762,6 +793,18 @@ function createMCPServer(db, options = {}) {
           const progressCallback = createProgressCallback(analysisId);
           const tier = resolveTier(args.tier);
 
+          // Build a GitHubClient so the analyzer can pre-fetch existing PR
+          // review comments when args.excludePrevious.github is set. Uses
+          // the repo's binding so alt-host repos route to the right host
+          // with the right token.
+          const prAnalysisBinding = resolveHostBinding(repository, config);
+          const prAnalysisGithubClient = prAnalysisBinding.token
+            ? new GitHubClient(prAnalysisBinding)
+            : undefined;
+          if (prAnalysisGithubClient) {
+            logger.debug(`analyzer githubClient wired for ${owner}/${repo}#${prNumber} (mcp)`);
+          }
+
           logger.log('MCP', `Starting PR analysis: PR #${prNumber} in ${repository}, runId=${runId}`, 'magenta');
 
           // Create DB analysis_runs record just before launching so it's queryable for polling
@@ -779,7 +822,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, excludePrevious: args.excludePrevious, serverPort: (options.port || config.port || 7247) })
+          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), githubClient: prAnalysisGithubClient })
             .then(result => handleAnalysisCompletion(analysisId, runId, result, async (r) => {
               try { await prMetadataRepo.updateLastAiRunId(prMetadata.id, r.runId); } catch (_) { /* ignore */ }
               if (r.summary) {