@in-the-loop-labs/pair-review 3.0.0 → 3.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@in-the-loop-labs/pair-review",
-  "version": "3.0.0",
+  "version": "3.0.2",
   "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.0",
+  "version": "3.0.2",
   "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.0",
+  "version": "3.0.2",
   "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/js/local.js

@@ -674,6 +674,10 @@ class LocalManager {
             // User cancelled — keep old diff, early return
             return;
           }
+          // resolved is the response object — merge branchAvailable into result
+          if (resolved.branchAvailable !== undefined) {
+            result.branchAvailable = resolved.branchAvailable;
+          }
         }
         // Branch scope: backend already updated SHA and persisted diff — fall through
       }
@@ -702,7 +706,7 @@ class LocalManager {
   /**
    * Handle a non-branch-scope HEAD SHA change.
    * Shows a 3-option dialog (or auto-updates in silent mode).
-   * @returns {boolean} true if the session was updated in-place (caller should apply diff),
+   * @returns {Object|false} The response data object if the session was updated in-place (caller should apply diff),
    *                    false if cancelled or redirecting away (caller should skip _applyRefreshedDiff)
    */
   async _resolveHeadChange(result, opts) {
@@ -771,8 +775,9 @@ class LocalManager {
       return false; // navigating away — caller must not fire _applyRefreshedDiff
     }
 
-    // action === 'updated' — session SHA + diff updated, continue to reload
-    return true;
+    // action === 'updated' — session SHA + diff updated, continue to reload.
+    // Return the response data so the caller can extract branchAvailable, etc.
+    return data;
   }
 
   /**
@@ -806,6 +811,11 @@ class LocalManager {
     // refresh must call unconditionally since the manager won't re-fire its callback.
     await manager.loadAISuggestions(null, manager.selectedRunId);
 
+    // Update branchAvailable on the scope selector if the backend sent an updated value
+    if (result.branchAvailable !== undefined && manager.diffOptionsDropdown) {
+      manager.diffOptionsDropdown.branchAvailable = result.branchAvailable;
+    }
+
     // Clear stale state after successful refresh
     manager._hideStaleBadge();
     manager._stalenessPromise = null;

package/src/ai/analyzer.js

@@ -27,6 +27,14 @@ const { buildSparseCheckoutGuidance } = require('./prompts/sparse-checkout-guida
 /** Minimum total suggestion count across all voices before consolidation is applied */
 const COUNCIL_CONSOLIDATION_THRESHOLD = 8;
 
+/**
+ * Common git diff flags used across all diff operations.
+ * - --no-color: Disable color output (guards against color.diff=always in user config)
+ * - --no-ext-diff: Disable external diff drivers
+ * - --src-prefix/--dst-prefix: Ensure consistent a/ b/ prefixes (overrides user's diff.noprefix)
+ */
+const GIT_DIFF_COMMON_FLAGS = '--no-color --no-ext-diff --src-prefix=a/ --dst-prefix=b/';
+
 /**
  * Build a human-readable display label for a council voice/reviewer.
  * Uses 1-based index so logs read "Reviewer 1", "Reviewer 2", etc.
@@ -989,10 +997,10 @@ ${prMetadata.description || '(No description provided)'}
     const isLocal = prMetadata.reviewType === 'local';
     if (isLocal) {
       // For local mode, diff against HEAD to see working directory changes
-      return suffix ? `git diff --no-ext-diff HEAD ${suffix}` : 'git diff --no-ext-diff HEAD';
+      return suffix ? `git diff ${GIT_DIFF_COMMON_FLAGS} HEAD ${suffix}` : `git diff ${GIT_DIFF_COMMON_FLAGS} HEAD`;
     }
     // For PR mode, diff between base and head commits
-    const baseCmd = `git diff --no-ext-diff ${prMetadata.base_sha}...${prMetadata.head_sha}`;
+    const baseCmd = `git diff ${GIT_DIFF_COMMON_FLAGS} ${prMetadata.base_sha}...${prMetadata.head_sha}`;
     return suffix ? `${baseCmd} ${suffix}` : baseCmd;
   }
 

package/src/database.js

@@ -2717,6 +2717,7 @@ class ReviewRepository {
    * @param {Object} [updates.reviewData] - Additional review data (will be JSON stringified)
    * @param {string} [updates.customInstructions] - Custom instructions used for AI analysis
    * @param {string} [updates.summary] - AI analysis summary
+   * @param {string} [updates.local_head_sha] - Local HEAD SHA
    * @param {Date|string} [updates.submittedAt] - Submission timestamp
    * @returns {Promise<boolean>} True if record was updated
    */
@@ -2759,6 +2760,11 @@ class ReviewRepository {
       params.push(updates.local_head_branch);
     }
 
+    if (updates.local_head_sha !== undefined) {
+      setClauses.push('local_head_sha = ?');
+      params.push(updates.local_head_sha);
+    }
+
     if (updates.submittedAt !== undefined) {
       setClauses.push('submitted_at = ?');
       const submittedAt = updates.submittedAt instanceof Date

package/src/local-review.js

@@ -33,6 +33,14 @@ const MAX_FILE_SIZE = 1024 * 1024;
  */
 const GIT_DIFF_HAS_DIFFERENCES = 1;
 
+/**
+ * Common git diff flags used across all diff operations.
+ * - --no-color: Disable color output for consistent parsing
+ * - --no-ext-diff: Disable external diff drivers
+ * - --src-prefix/--dst-prefix: Ensure consistent a/ b/ prefixes (overrides user's diff.noprefix)
+ */
+const GIT_DIFF_COMMON_FLAGS = '--no-color --no-ext-diff --src-prefix=a/ --dst-prefix=b/';
+
 /**
  * Find the main git repository root, resolving through worktrees.
  * For regular repos, returns the repo root.
@@ -401,7 +409,7 @@ function generateUntrackedDiffs(repoPath, untrackedFiles, wFlag) {
         const filePath = path.join(repoPath, untracked.file);
         let fileDiff;
         try {
-          fileDiff = execSync(`git diff --no-index --no-color --no-ext-diff${wFlag} -- /dev/null "${filePath}"`, {
+          fileDiff = execSync(`git diff --no-index ${GIT_DIFF_COMMON_FLAGS}${wFlag} -- /dev/null "${filePath}"`, {
             cwd: repoPath,
             encoding: 'utf8',
             stdio: ['pipe', 'pipe', 'pipe'],
@@ -478,37 +486,37 @@ async function generateScopedDiff(repoPath, scopeStart, scopeEnd, baseBranch, op
   try {
     if (hasBranch && !hasStaged && !hasUnstaged) {
       // Branch only → committed changes since merge-base
-      diff = execSync(`git diff ${mergeBaseSha}..HEAD --no-color --no-ext-diff --unified=25${wFlag}`, {
+      diff = execSync(`git diff ${mergeBaseSha}..HEAD ${GIT_DIFF_COMMON_FLAGS} --unified=25${wFlag}`, {
         cwd: repoPath, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'],
         maxBuffer: 50 * 1024 * 1024
       });
     } else if (hasBranch && hasStaged && !hasUnstaged) {
       // Branch–Staged → staged changes relative to merge-base
-      diff = execSync(`git diff --cached ${mergeBaseSha} --no-color --no-ext-diff --unified=25${wFlag}`, {
+      diff = execSync(`git diff --cached ${mergeBaseSha} ${GIT_DIFF_COMMON_FLAGS} --unified=25${wFlag}`, {
         cwd: repoPath, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'],
         maxBuffer: 50 * 1024 * 1024
       });
     } else if (hasBranch && hasUnstaged) {
       // Branch–Unstaged (or Branch–Untracked) → working tree vs merge-base
-      diff = execSync(`git diff ${mergeBaseSha} --no-color --no-ext-diff --unified=25${wFlag}`, {
+      diff = execSync(`git diff ${mergeBaseSha} ${GIT_DIFF_COMMON_FLAGS} --unified=25${wFlag}`, {
         cwd: repoPath, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'],
         maxBuffer: 50 * 1024 * 1024
       });
     } else if (hasStaged && !hasUnstaged) {
       // Staged only → cached changes
-      diff = execSync(`git diff --cached --no-color --no-ext-diff --unified=25${wFlag}`, {
+      diff = execSync(`git diff --cached ${GIT_DIFF_COMMON_FLAGS} --unified=25${wFlag}`, {
         cwd: repoPath, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'],
         maxBuffer: 50 * 1024 * 1024
       });
     } else if (hasStaged && hasUnstaged) {
       // Staged–Unstaged (or Staged–Untracked) → all changes vs HEAD
-      diff = execSync(`git diff HEAD --no-color --no-ext-diff --unified=25${wFlag}`, {
+      diff = execSync(`git diff HEAD ${GIT_DIFF_COMMON_FLAGS} --unified=25${wFlag}`, {
         cwd: repoPath, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'],
         maxBuffer: 50 * 1024 * 1024
       });
     } else if (hasUnstaged) {
       // Unstaged only or Unstaged–Untracked → working tree changes
-      diff = execSync(`git diff --no-color --no-ext-diff --unified=25${wFlag}`, {
+      diff = execSync(`git diff ${GIT_DIFF_COMMON_FLAGS} --unified=25${wFlag}`, {
         cwd: repoPath, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'],
         maxBuffer: 50 * 1024 * 1024
       });
@@ -590,7 +598,7 @@ async function computeScopedDigest(repoPath, scopeStart, scopeEnd) {
   // Staged in scope → cached diff content
   if (scopeIncludes(scopeStart, scopeEnd, 'staged')) {
     try {
-      const result = await execAsync('git diff --cached --no-ext-diff', {
+      const result = await execAsync(`git diff --cached ${GIT_DIFF_COMMON_FLAGS}`, {
         cwd: repoPath, encoding: 'utf8', maxBuffer: 50 * 1024 * 1024
       });
       parts.push('STAGED:' + result.stdout);
@@ -602,7 +610,7 @@ async function computeScopedDigest(repoPath, scopeStart, scopeEnd) {
   // Unstaged in scope → working tree diff
   if (scopeIncludes(scopeStart, scopeEnd, 'unstaged')) {
     try {
-      const result = await execAsync('git diff --no-ext-diff', {
+      const result = await execAsync(`git diff ${GIT_DIFF_COMMON_FLAGS}`, {
         cwd: repoPath, encoding: 'utf8', maxBuffer: 50 * 1024 * 1024
       });
       parts.push('UNSTAGED:' + result.stdout);

package/src/routes/local.js

@@ -66,6 +66,34 @@ function deleteLocalReviewDiff(reviewId) {
   localReviewDiffs.delete(toIntKey(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.
+ */
+async function checkBranchAvailable(localPath, branchName, scopeStart, config, repositoryName) {
+  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
+  }
+  return false;
+}
+
 /**
  * Delete a local review session and its in-memory diff cache.
  * Shared by both single-delete and bulk-delete routes.
@@ -575,26 +603,9 @@ 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.
-    let branchAvailable = includesBranch(scopeStart) || Boolean(branchInfo);
-    if (!branchAvailable && branchName && branchName !== 'HEAD' && branchName !== 'unknown' && review.local_path) {
-      try {
-        const { getBranchCommitCount } = require('../local-review');
-        const { detectBaseBranch } = require('../git/base-branch');
-        const config = req.app.get('config') || {};
-        const depsOverride = getGitHubToken(config) ? { getGitHubToken: () => getGitHubToken(config) } : undefined;
-        const detection = await detectBaseBranch(review.local_path, branchName, {
-          repository: repositoryName,
-          enableGraphite: config.enable_graphite === true,
-          _deps: depsOverride
-        });
-        if (detection) {
-          const commitCount = await getBranchCommitCount(review.local_path, detection.baseBranch);
-          branchAvailable = commitCount > 0;
-        }
-      } catch {
-        // Non-fatal — branch stop stays disabled
-      }
-    }
+    const branchAvailable = Boolean(branchInfo) || await checkBranchAvailable(
+      review.local_path, branchName, scopeStart, req.app.get('config') || {}, repositoryName
+    );
 
     // Compute SHA abbreviation length from the repo's git config
     const shaAbbrevLength = getShaAbbrevLength(review.local_path);
@@ -1364,6 +1375,15 @@ router.post('/api/local/:reviewId/refresh', async (req, res) => {
       logger.warn(`Could not check HEAD SHA: ${headError.message}`);
     }
 
+    // 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') || {};
+    let branchName;
+    try { branchName = await getCurrentBranch(localPath); } catch (_) { branchName = review.local_head_branch || null; }
+    const branchAvailable = await checkBranchAvailable(
+      localPath, branchName, scopeStart, config, review.repository
+    );
+
     // Non-branch HEAD change: skip diff computation entirely — the old diff is
     // preserved until the user decides (via resolve-head-change) what to do.
     // The resolve-head-change endpoint will recompute the diff for whichever
@@ -1373,6 +1393,7 @@ router.post('/api/local/:reviewId/refresh', async (req, res) => {
         success: true,
         message: 'HEAD changed — awaiting user decision',
         headShaChanged,
+        branchAvailable,
         previousHeadSha: originalHeadSha,
         currentHeadSha: currentHeadSha || null,
         stats: {}
@@ -1397,6 +1418,7 @@ router.post('/api/local/:reviewId/refresh', async (req, res) => {
       success: true,
       message: 'Diff refreshed successfully',
       headShaChanged,
+      branchAvailable,
       previousHeadSha: originalHeadSha,
       currentHeadSha: currentHeadSha || null,
       stats: {
@@ -1453,17 +1475,24 @@ router.post('/api/local/:reviewId/resolve-head-change', async (req, res) => {
     const scopeEnd = review.local_scope_end || DEFAULT_SCOPE.end;
 
     if (action === 'update') {
-      // Check for UNIQUE conflict before updating
-      const headBranch = review.local_head_branch || null;
+      // Read live branch — may differ from stored value after a checkout.
+      // Lazy require to ensure testability via vi.spyOn on the module exports.
+      let headBranch;
+      try { headBranch = await require('../local-review').getCurrentBranch(localPath); } catch (_) { headBranch = review.local_head_branch || null; }
+
+      // Check for UNIQUE conflict before any mutation.
+      // Use the live branch + new SHA so the conflict check targets the
+      // final identity tuple (localPath, newHeadSha, headBranch).
       const conflict = await reviewRepo.getLocalReview(localPath, newHeadSha, headBranch);
       if (conflict && conflict.id !== reviewId) {
         logger.log('API', `UNIQUE conflict: session #${conflict.id} already exists for this HEAD`, 'yellow');
         return res.json({ success: true, action: 'redirect', sessionId: conflict.id });
       }
 
-      // Update SHA
-      await reviewRepo.updateLocalHeadSha(reviewId, newHeadSha);
-      logger.log('API', `Updated HEAD SHA on session ${reviewId}`, 'cyan');
+      // 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');
 
       // Recompute and persist diff
       const scopedResult = await generateScopedDiff(localPath, scopeStart, scopeEnd, review.local_base_branch);
@@ -1475,7 +1504,14 @@ router.post('/api/local/:reviewId/resolve-head-change', async (req, res) => {
         logger.warn(`Could not persist diff to database: ${persistError.message}`);
       }
 
-      return res.json({ success: true, action: 'updated' });
+      // 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
+      );
+
+      return res.json({ success: true, action: 'updated', branchAvailable });
     }
 
     // action === 'new-session'