@in-the-loop-labs/pair-review 3.0.4 → 3.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@in-the-loop-labs/pair-review",
-  "version": "3.0.4",
+  "version": "3.0.6",
   "description": "Your AI-powered code review partner - Close the feedback loop with AI coding agents",
   "main": "src/server.js",
   "bin": {

package/plugin/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "pair-review",
-  "version": "3.0.4",
+  "version": "3.0.6",
   "description": "pair-review app integration — Open PRs and local changes in the pair-review web UI, run server-side AI analysis, and address review feedback. Requires the pair-review MCP server.",
   "author": {
     "name": "in-the-loop-labs",

package/plugin-code-critic/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "code-critic",
-  "version": "3.0.4",
+  "version": "3.0.6",
   "description": "AI-powered code review analysis — Run three-level AI analysis and implement-review-fix loops directly in your coding agent. Works standalone, no server required.",
   "author": {
     "name": "in-the-loop-labs",

package/public/css/pr.css

@@ -6000,12 +6000,8 @@ body::before {
   color: var(--color-accent, #2f81f7);
 }
 
-/* PR description popover */
+/* PR description popover - appended to document.body with fixed positioning */
 .pr-description-popover {
-  position: absolute;
-  top: calc(100% + 8px);
-  left: 50%;
-  transform: translateX(-50%);
   z-index: 1000;
   width: min(500px, 90vw);
   background: var(--color-bg-primary, #0d1117);

package/public/js/pr.js

@@ -970,11 +970,8 @@ class PRManager {
     const toggle = document.getElementById('pr-description-toggle');
     if (!toggle) return;
 
-    const wrapper = toggle.closest('.pr-title-wrapper');
-    if (!wrapper) return;
-
     const closePopover = () => {
-      const existing = wrapper.querySelector('.pr-description-popover');
+      const existing = document.querySelector('.pr-description-popover');
       if (existing) existing.remove();
       toggle.classList.remove('active');
       toggle.setAttribute('aria-expanded', 'false');
@@ -982,7 +979,7 @@ class PRManager {
 
     toggle.addEventListener('click', (e) => {
       e.stopPropagation();
-      const existing = wrapper.querySelector('.pr-description-popover');
+      const existing = document.querySelector('.pr-description-popover');
       if (existing) {
         closePopover();
         return;
@@ -1017,7 +1014,16 @@ class PRManager {
 
       popover.append(arrow, header, content);
 
-      wrapper.appendChild(popover);
+      // Position relative to the toggle button
+      const rect = toggle.getBoundingClientRect();
+      popover.style.position = 'fixed';
+      popover.style.top = `${rect.bottom + 8}px`;
+      popover.style.left = `${rect.left + rect.width / 2}px`;
+      popover.style.transform = 'translateX(-50%)';
+
+      // Append to document.body to escape overflow:hidden on .header-center
+      document.body.appendChild(popover);
+
       toggle.classList.add('active');
       toggle.setAttribute('aria-expanded', 'true');
 

package/src/database.js

@@ -2755,6 +2755,11 @@ class ReviewRepository {
       params.push(updates.name);
     }
 
+    if (updates.local_base_branch !== undefined) {
+      setClauses.push('local_base_branch = ?');
+      params.push(updates.local_base_branch);
+    }
+
     if (updates.local_head_branch !== undefined) {
       setClauses.push('local_head_branch = ?');
       params.push(updates.local_head_branch);

package/src/git/base-branch.js

@@ -170,4 +170,52 @@ function tryDefaultBranch(repoPath, currentBranch, deps) {
   return null;
 }
 
-module.exports = { detectBaseBranch };
+/**
+ * Synchronously detect the default branch for a repository using only
+ * local refs (no network I/O).
+ *
+ * Priority:
+ *   1. `git symbolic-ref refs/remotes/origin/HEAD` — reads the local ref
+ *      that `git clone` sets automatically.
+ *   2. Check whether `refs/heads/main` or `refs/heads/master` exist locally.
+ *
+ * @param {string} localPath - Absolute path to the repository
+ * @param {Object} [_deps] - Dependency overrides for testing
+ * @returns {string|null} Default branch name, or null if it cannot be determined
+ */
+function getDefaultBranch(localPath, _deps) {
+  if (!localPath) return null;
+  const deps = { ...defaults, ..._deps };
+
+  // Try symbolic-ref (set by git clone)
+  try {
+    const ref = deps.execSync('git symbolic-ref refs/remotes/origin/HEAD', {
+      cwd: localPath,
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+    // ref looks like "refs/remotes/origin/main"
+    const branch = ref.replace(/^refs\/remotes\/origin\//, '');
+    if (branch && branch !== ref) return branch;
+  } catch {
+    // origin/HEAD not set — fall through to local check
+  }
+
+  // Fallback: check if main or master exists locally
+  for (const candidate of ['main', 'master']) {
+    try {
+      deps.execSync(`git rev-parse --verify refs/heads/${candidate}`, {
+        cwd: localPath,
+        encoding: 'utf8',
+        stdio: ['pipe', 'pipe', 'pipe'],
+      });
+      return candidate;
+    } catch {
+      // Branch doesn't exist
+    }
+  }
+
+  return null;
+}
+
+module.exports = { detectBaseBranch, getDefaultBranch };

package/src/routes/local.js

@@ -31,6 +31,9 @@ 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 { getDefaultBranch } = require('../git/base-branch');
+const { CommentRepository } = require('../database');
 const {
   activeAnalyses,
   localReviewDiffs,
@@ -68,30 +71,23 @@ function deleteLocalReviewDiff(reviewId) {
 
 /**
  * Check whether branch scope should be selectable in the scope range selector.
- * Returns true when the branch has commits ahead of the base branch.
- * Non-fatal: returns false on any error.
+ * Returns true when the current branch is a non-default, non-detached branch,
+ * or when the scope already includes branch.
+ *
+ * @param {string} branchName - Current branch name
+ * @param {string} scopeStart - Current scope start stop
+ * @param {string} localPath - Absolute path to the repository (used to detect the actual default branch)
  */
-async function checkBranchAvailable(localPath, branchName, scopeStart, config, repositoryName) {
+function isBranchAvailable(branchName, scopeStart, localPath) {
   if (includesBranch(scopeStart)) return true;
-  if (!branchName || branchName === 'HEAD' || branchName === 'unknown' || !localPath) return false;
-  try {
-    const baseBranch = require('../git/base-branch');
-    const depsOverride = getGitHubToken(config) ? { getGitHubToken: () => getGitHubToken(config) } : undefined;
-    const detection = await baseBranch.detectBaseBranch(localPath, branchName, {
-      repository: repositoryName,
-      enableGraphite: config.enable_graphite === true,
-      _deps: depsOverride
-    });
-    if (detection) {
-      // Lazy require to ensure testability via vi.spyOn on the module exports
-      const localReview = require('../local-review');
-      const commitCount = await localReview.getBranchCommitCount(localPath, detection.baseBranch);
-      return commitCount > 0;
-    }
-  } catch {
-    // Non-fatal — branch stop stays disabled
+  if (!branchName || branchName === 'HEAD' || branchName === 'unknown') return false;
+
+  // Detect the default branch using only local refs (no network).
+  const defaultBranch = getDefaultBranch(localPath);
+  if (defaultBranch) {
+    return branchName !== defaultBranch;
   }
-  return false;
+  return branchName !== 'main' && branchName !== 'master';
 }
 
 /**
@@ -506,6 +502,7 @@ router.post('/api/local/start', async (req, res) => {
  * Get local review metadata
  */
 router.get('/api/local/:reviewId', async (req, res) => {
+  const tEndpoint = Date.now();
   try {
     const reviewId = parseInt(req.params.reviewId);
 
@@ -566,19 +563,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,13 +594,15 @@ router.get('/api/local/:reviewId', async (req, res) => {
 
     // Determine if Branch stop should be selectable in the scope range selector.
     // This is independent of branchInfo (which guards on no uncommitted changes).
-    // Branch is available when: not detached HEAD, not on default branch, and has commits ahead.
-    const branchAvailable = Boolean(branchInfo) || await checkBranchAvailable(
-      review.local_path, branchName, scopeStart, req.app.get('config') || {}, repositoryName
-    );
+    // Branch is available when: not detached HEAD, not on default branch.
+    const branchAvailable = Boolean(branchInfo) || isBranchAvailable(branchName, scopeStart, review.local_path);
 
     // Compute SHA abbreviation length from the repo's git config
     const shaAbbrevLength = getShaAbbrevLength(review.local_path);
+    const metadataElapsed = Date.now() - tEndpoint;
+    if (metadataElapsed > 200) {
+      logger.debug(`[perf] metadata#${reviewId} took ${metadataElapsed}ms (threshold: 200ms)`);
+    }
 
     res.json({
       id: review.id,
@@ -630,6 +624,29 @@ router.get('/api/local/:reviewId', async (req, res) => {
       updatedAt: review.updated_at
     });
 
+    // Background: pre-cache base branch detection so set-scope is fast later
+    if (!includesBranch(scopeStart) && !review.local_base_branch
+        && branchName && branchName !== 'HEAD' && branchName !== 'unknown'
+        && repositoryName && repositoryName.includes('/')) {
+      const bgConfig = req.app.get('config') || {};
+      const bgToken = getGitHubToken(bgConfig);
+      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
+      }).then(detection => {
+        if (detection && detection.baseBranch) {
+          return reviewRepo.updateReview(reviewId, { local_base_branch: detection.baseBranch });
+        }
+      }).then(() => {
+        logger.debug(`[perf] metadata#${reviewId} background-detectBaseBranch: ${Date.now() - bgT0}ms`);
+      }).catch(err => {
+        logger.warn(`Background base branch detection failed: ${err.message}`);
+      });
+    }
+
     // Fire review.loaded hook (session already exists to be fetched by ID)
     const hookConfig = req.app.get('config') || {};
     if (hasHooks('review.loaded', hookConfig)) {
@@ -704,6 +721,7 @@ router.patch('/api/local/:reviewId/name', async (req, res) => {
  * Get local diff
  */
 router.get('/api/local/:reviewId/diff', async (req, res) => {
+  const tEndpoint = Date.now();
   try {
     const reviewId = parseInt(req.params.reviewId);
 
@@ -781,6 +799,10 @@ router.get('/api/local/:reviewId/diff', async (req, res) => {
       }
     }
 
+    const diffElapsed = Date.now() - tEndpoint;
+    if (diffElapsed > 200) {
+      logger.debug(`[perf] diff#${reviewId} took ${diffElapsed}ms (threshold: 200ms)`);
+    }
     res.json({
       diff: diffContent || '',
       generated_files: generatedFiles,
@@ -805,6 +827,7 @@ router.get('/api/local/:reviewId/diff', async (req, res) => {
  * Uses a digest of the diff content for accurate change detection
  */
 router.get('/api/local/:reviewId/check-stale', async (req, res) => {
+  const tEndpoint = Date.now();
   try {
     const reviewId = parseInt(req.params.reviewId);
 
@@ -861,6 +884,10 @@ router.get('/api/local/:reviewId/check-stale', async (req, res) => {
 
     // When branch is in scope and HEAD changed, early return (existing behavior)
     if (includesBranch(scopeStart) && headShaChanged) {
+      const staleEarlyElapsed = Date.now() - tEndpoint;
+      if (staleEarlyElapsed > 200) {
+        logger.debug(`[perf] check-stale#${reviewId} took ${staleEarlyElapsed}ms (threshold: 200ms)`);
+      }
       return res.json({
         isStale: true,
         headShaChanged,
@@ -918,6 +945,10 @@ router.get('/api/local/:reviewId/check-stale', async (req, res) => {
 
     const isStale = storedDiffData.digest !== currentDigest;
 
+    const staleElapsed = Date.now() - tEndpoint;
+    if (staleElapsed > 200) {
+      logger.debug(`[perf] check-stale#${reviewId} took ${staleElapsed}ms (threshold: 200ms)`);
+    }
     res.json({
       isStale,
       storedDigest: storedDiffData.digest,
@@ -1377,12 +1408,10 @@ router.post('/api/local/:reviewId/refresh', async (req, res) => {
 
     // Recompute branchAvailable so the frontend can update the scope selector
     // (e.g. after a commit creates the first branch-ahead commit).
-    const config = req.app.get('config') || {};
+    // Lazy require to ensure testability via vi.spyOn on the module exports.
     let branchName;
-    try { branchName = await getCurrentBranch(localPath); } catch (_) { branchName = review.local_head_branch || null; }
-    const branchAvailable = await checkBranchAvailable(
-      localPath, branchName, scopeStart, config, review.repository
-    );
+    try { branchName = await require('../local-review').getCurrentBranch(localPath); } catch (_) { branchName = review.local_head_branch || null; }
+    const branchAvailable = isBranchAvailable(branchName, scopeStart, localPath);
 
     // Non-branch HEAD change: skip diff computation entirely — the old diff is
     // preserved until the user decides (via resolve-head-change) what to do.
@@ -1491,8 +1520,8 @@ router.post('/api/local/:reviewId/resolve-head-change', async (req, res) => {
 
       // Persist SHA and branch together in a single write so SQLite only
       // ever sees the final identity tuple — no transient intermediate state.
-      await reviewRepo.updateReview(reviewId, { local_head_sha: newHeadSha, local_head_branch: headBranch });
-      logger.log('API', `Updated HEAD SHA and branch on session ${reviewId}`, 'cyan');
+      await reviewRepo.updateReview(reviewId, { local_head_sha: newHeadSha, local_head_branch: headBranch, local_base_branch: null });
+      logger.log('API', `Updated HEAD SHA and branch on session ${reviewId} (cleared cached base branch)`, 'cyan');
 
       // Recompute and persist diff
       const scopedResult = await generateScopedDiff(localPath, scopeStart, scopeEnd, review.local_base_branch);
@@ -1506,10 +1535,7 @@ router.post('/api/local/:reviewId/resolve-head-change', async (req, res) => {
 
       // Recompute branchAvailable — the commit may have created the first
       // branch-ahead commit, making the Branch scope stop selectable.
-      const config = req.app.get('config') || {};
-      const branchAvailable = await checkBranchAvailable(
-        localPath, headBranch, scopeStart, config, review.repository
-      );
+      const branchAvailable = isBranchAvailable(headBranch, scopeStart, localPath);
 
       return res.json({ success: true, action: 'updated', branchAvailable });
     }
@@ -1593,20 +1619,26 @@ router.post('/api/local/:reviewId/set-scope', async (req, res) => {
     let baseBranch = requestBaseBranch || null;
     let currentBranch = null;
     if (includesBranch(scopeStart)) {
-      currentBranch = await getCurrentBranch(localPath);
+      currentBranch = await require('../local-review').getCurrentBranch(localPath);
       if (!baseBranch) {
-        const { detectBaseBranch } = require('../git/base-branch');
-        const config = req.app.get('config') || {};
-        const token = getGitHubToken(config);
-        const detection = await detectBaseBranch(localPath, currentBranch, {
-          repository: review.repository,
-          enableGraphite: config.enable_graphite === true,
-          _deps: token ? { getGitHubToken: () => token } : undefined
-        });
-        if (!detection) {
-          return res.status(400).json({ error: 'Could not detect base branch' });
+        // Use cached base branch from background detection if available
+        if (review.local_base_branch && review.local_head_branch === currentBranch) {
+          baseBranch = review.local_base_branch;
+          logger.debug(`[perf] set-scope#${reviewId} using cached base branch: ${baseBranch}`);
+        } else {
+          const { detectBaseBranch } = require('../git/base-branch');
+          const config = req.app.get('config') || {};
+          const token = getGitHubToken(config);
+          const detection = await detectBaseBranch(localPath, currentBranch, {
+            repository: review.repository,
+            enableGraphite: config.enable_graphite === true,
+            _deps: token ? { getGitHubToken: () => token } : undefined
+          });
+          if (!detection) {
+            return res.status(400).json({ error: 'Could not detect base branch' });
+          }
+          baseBranch = detection.baseBranch;
         }
-        baseBranch = detection.baseBranch;
       }
 
       // Validate branch name to prevent shell injection