@in-the-loop-labs/pair-review 3.3.0 → 3.3.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@in-the-loop-labs/pair-review",
-  "version": "3.3.0",
+  "version": "3.3.2",
   "description": "Your AI-powered code review partner - Close the feedback loop with AI coding agents",
   "main": "src/server.js",
   "bin": {
@@ -32,7 +32,7 @@
     "test:e2e:debug": "playwright test --debug",
     "generate:skill-prompts": "node scripts/generate-skill-prompts.js",
     "changeset": "changeset",
-    "version": "changeset version && pnpm install --lockfile-only && node scripts/sync-plugin-versions.js && git add package.json pnpm-lock.yaml CHANGELOG.md .changeset .claude-plugin/marketplace.json plugin/.claude-plugin/plugin.json plugin-code-critic/.claude-plugin/plugin.json && git commit -m \"RELEASING: v$(node -p \"require('./package.json').version\")\"",
+    "version": "changeset version && pnpm install --lockfile-only && bash scripts/generate-package-lock.sh && node scripts/sync-plugin-versions.js && git add package.json pnpm-lock.yaml package-lock.json CHANGELOG.md .changeset .claude-plugin/marketplace.json plugin/.claude-plugin/plugin.json plugin-code-critic/.claude-plugin/plugin.json && git commit -m \"RELEASING: v$(node -p \"require('./package.json').version\")\"",
     "release": "npm whoami > /dev/null || { echo 'Error: Not logged in to npm. Run: npm login'; exit 1; } && pnpm run version && changeset tag && npm publish && git push && git push --tags"
   },
   "keywords": [

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

@@ -1,6 +1,6 @@
 {
   "name": "pair-review",
-  "version": "3.3.0",
+  "version": "3.3.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.3.0",
+  "version": "3.3.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/src/git/worktree-pool-lifecycle.js

@@ -231,15 +231,22 @@ class WorktreePoolLifecycle {
     // Note: poolEntry was already atomically marked 'switching' by claimAvailable()
     try {
       const git = this._simpleGit(poolEntry.path);
+      const worktreeManager = new this._GitWorktreeManager(this.db);
 
       // Resolve the remote
-      const remotes = await git.getRemotes();
-      const remote = remotes.find(r => r.name === 'origin') || remotes[0];
-      const remoteName = remote ? remote.name : 'origin';
+      const remoteName = await worktreeManager.resolveRemoteForPR(git, prData, {
+        owner: prInfo.owner,
+        repo: prInfo.repo,
+        number: prInfo.prNumber,
+      });
 
-      // Fetch new PR refs (incremental -- cheap on a warm worktree)
+      // Fetch new PR refs (incremental -- cheap on a warm worktree) with fallback
       logger.info(`Fetching PR #${prInfo.prNumber} refs into pool worktree ${poolEntry.id}`);
-      await git.fetch([remoteName, `+refs/pull/${prInfo.prNumber}/head:refs/remotes/${remoteName}/pr-${prInfo.prNumber}`]);
+      const fetchedHead = await worktreeManager.fetchPRHead(git, {
+        owner: prInfo.owner,
+        repo: prInfo.repo,
+        number: prInfo.prNumber,
+      }, prData, { remote: remoteName });
 
       // Clean the working tree before switching PRs. Without this, untracked
       // files (build artifacts, generated code) from the previous PR leak into
@@ -254,7 +261,7 @@ class WorktreePoolLifecycle {
       if (targetSha) {
         await git.checkout([targetSha]);
       } else {
-        await git.checkout([`refs/remotes/${remoteName}/pr-${prInfo.prNumber}`]);
+        await git.checkout([fetchedHead.checkoutTarget]);
       }
 
       // Run reset_script if configured
@@ -273,7 +280,6 @@ class WorktreePoolLifecycle {
           PR_NUMBER: String(prInfo.prNumber),
           WORKTREE_PATH: poolEntry.path,
         };
-        const worktreeManager = new this._GitWorktreeManager();
         await worktreeManager.executeCheckoutScript(
           options.resetScript, poolEntry.path, scriptEnv, options.checkoutTimeout
         );
@@ -285,7 +291,6 @@ class WorktreePoolLifecycle {
 
       // Best-effort disk cleanup for deleted non-pool worktree directories
       if (deletedPaths && deletedPaths.length > 0) {
-        const worktreeManager = new this._GitWorktreeManager();
         for (const deletedPath of deletedPaths) {
           try {
             await worktreeManager.cleanupWorktree(deletedPath);

package/src/git/worktree.js

@@ -66,8 +66,9 @@ class GitWorktreeManager {
   /**
    * Resolve which git remote points to the given repository URLs.
    * Compares normalized URLs against all configured remotes. If no match is
-   * found, adds (or updates) a managed `pair-review-base` remote so that
-   * subsequent fetches target the correct repository (e.g. the base repo of a fork PR).
+   * found, falls back to an existing non-managed remote instead of mutating the
+   * repository's git config. This preserves proxy/mirror setups where the
+   * canonical fetch URL may differ from GitHub's clone URL.
    *
    * @param {Object} git - simple-git instance
    * @param {string} cloneUrl - HTTPS clone URL of the target repository
@@ -81,9 +82,7 @@ class GitWorktreeManager {
     const remoteOutput = await git.raw(['remote', '-v']);
 
     if (!remoteOutput || !remoteOutput.trim()) {
-      console.log(`No remotes found, adding ${MANAGED_REMOTE} remote for ${cloneUrl}`);
-      await git.addRemote(MANAGED_REMOTE, cloneUrl);
-      return MANAGED_REMOTE;
+      throw new Error(`No remotes configured — cannot resolve base repository for ${cloneUrl}`);
     }
 
     // Parse remote output into { name: url } map (fetch URLs only)
@@ -115,9 +114,16 @@ class GitWorktreeManager {
 
     const normalizedCloneUrl = normalizeUrl(cloneUrl);
     const normalizedSshUrl = sshUrl ? normalizeUrl(sshUrl) : '';
+    const remoteNames = Object.keys(remotes);
+    const fallbackRemote = remotes.origin
+      ? 'origin'
+      : remoteNames.find((name) => name !== MANAGED_REMOTE) || 'origin';
 
-    // Check each remote for a match
+    // Check each non-managed remote for a direct URL match
     for (const [name, url] of Object.entries(remotes)) {
+      if (name === MANAGED_REMOTE) {
+        continue;
+      }
       const normalizedRemoteUrl = normalizeUrl(url);
       if (normalizedRemoteUrl === normalizedCloneUrl ||
           (normalizedSshUrl && normalizedRemoteUrl === normalizedSshUrl)) {
@@ -126,16 +132,13 @@ class GitWorktreeManager {
       }
     }
 
-    // No match found — add or update the managed remote
-    if (remotes[MANAGED_REMOTE]) {
-      console.log(`Updating ${MANAGED_REMOTE} remote URL to ${cloneUrl}`);
-      await git.raw(['remote', 'set-url', MANAGED_REMOTE, cloneUrl]);
-    } else {
-      console.log(`Adding ${MANAGED_REMOTE} remote for ${cloneUrl}`);
-      await git.addRemote(MANAGED_REMOTE, cloneUrl);
-    }
-
-    return MANAGED_REMOTE;
+    console.warn(
+      `No configured remote matched ${cloneUrl}; using existing remote '${fallbackRemote}' without modifying git config`
+    );
+    // NOTE: For fork PRs this may return a remote that does not point to the
+    // base repository. Callers rely on fetchPRHead's SHA-fallback path and
+    // tolerant base-branch fetching to handle this without mutating git config.
+    return fallbackRemote;
   }
 
   /**
@@ -170,6 +173,97 @@ class GitWorktreeManager {
     return this.resolveRemoteForRepo(git, cloneUrl, sshUrl);
   }
 
+  /**
+   * Extract a PR number from either { number } or { prNumber } shapes.
+   * @param {Object|null} prInfo
+   * @returns {number|null}
+   */
+  getPRNumber(prInfo) {
+    if (!prInfo) return null;
+    return prInfo.number || prInfo.prNumber || null;
+  }
+
+  /**
+   * Extract the PR head branch name from either REST or stored PR metadata.
+   * @param {Object|null} prData
+   * @returns {string}
+   */
+  getPRHeadBranch(prData) {
+    return prData?.head?.ref || prData?.head_branch || '';
+  }
+
+  /**
+   * Extract the PR head SHA from either REST or stored PR metadata.
+   * @param {Object|null} prData
+   * @returns {string}
+   */
+  getPRHeadSha(prData) {
+    return prData?.head?.sha || prData?.head_sha || '';
+  }
+
+  /**
+   * Detect whether a fetch failed because the remote does not expose a PR ref.
+   * @param {Error} error
+   * @returns {boolean}
+   */
+  isMissingRemoteRefError(error) {
+    const message = String(error?.message || '').toLowerCase();
+    return message.includes('couldn\'t find remote ref') ||
+      message.includes('could not find remote ref') ||
+      message.includes('remote ref does not exist') ||
+      message.includes('fatal: invalid refspec');
+  }
+
+  /**
+   * Fetch a PR head into a stable tracking ref, falling back from GitHub PR
+   * refs to a direct SHA fetch when the git transport does not expose
+   * refs/pull/* (for example, alternate internal fetch backends).
+   *
+   * @param {Object} git - simple-git instance
+   * @param {Object} prInfo - PR info { owner, repo, number } or { prNumber }
+   * @param {Object} prData - PR data from GitHub API or stored metadata
+   * @param {Object} [options={}]
+   * @param {string|null} [options.remote] - Base repository remote to use for PR-ref fetch
+   * @returns {Promise<{remote: string, trackingRef: string|null, checkoutTarget: string}>}
+   */
+  async fetchPRHead(git, prInfo, prData, options = {}) {
+    const prNumber = this.getPRNumber(prInfo);
+    const headSha = this.getPRHeadSha(prData);
+    const baseRemote = options.remote || await this.resolveRemoteForPR(git, prData, prInfo);
+
+    if (!prNumber) {
+      throw new Error('Cannot fetch PR head without a PR number');
+    }
+
+    const prTrackingRef = `refs/remotes/${baseRemote}/pr-${prNumber}`;
+
+    try {
+      await git.fetch([baseRemote, `+refs/pull/${prNumber}/head:${prTrackingRef}`]);
+      return {
+        remote: baseRemote,
+        trackingRef: prTrackingRef,
+        checkoutTarget: prTrackingRef
+      };
+    } catch (prRefError) {
+      if (!this.isMissingRemoteRefError(prRefError)) {
+        throw prRefError;
+      }
+
+      console.warn(`PR ref fetch unavailable for PR #${prNumber} on remote ${baseRemote}, falling back to SHA fetch: ${prRefError.message}`);
+
+      if (!headSha) {
+        throw prRefError;
+      }
+
+      await git.raw(['fetch', baseRemote, headSha]);
+      return {
+        remote: baseRemote,
+        trackingRef: null,
+        checkoutTarget: headSha
+      };
+    }
+  }
+
   /**
    * Execute a user-provided checkout script in the worktree.
    * The script receives PR context as environment variables and is responsible
@@ -427,20 +521,21 @@ class GitWorktreeManager {
         console.log(`Base SHA fetch not needed or already available: ${fetchError.message}`);
       }
 
-      // Fetch the PR head using GitHub's pull request refs (more reliable than branch names)
+      // Fetch the PR head using PR refs when available, with a branch/SHA fallback
       console.log(`Fetching PR #${prInfo.number} head...`);
-      await worktreeGit.fetch([remote, `+refs/pull/${prInfo.number}/head:refs/remotes/${remote}/pr-${prInfo.number}`]);
+      const fetchedHead = await this.fetchPRHead(worktreeGit, prInfo, prData, { remote });
 
       // Execute checkout script if configured (before checkout so sparse-checkout is set up)
       if (checkoutScript) {
         // Fetch the actual head branch by name (for checkout scripts that expect branch refs)
         // This may fail for fork PRs where the branch is in a different repo - that's okay
-        if (prData.head_branch) {
+        const headBranch = this.getPRHeadBranch(prData);
+        if (headBranch) {
           try {
-            console.log(`Fetching head branch ${prData.head_branch}...`);
-            await worktreeGit.fetch([remote, `+refs/heads/${prData.head_branch}:refs/remotes/${remote}/${prData.head_branch}`]);
+            console.log(`Fetching head branch ${headBranch}...`);
+            await worktreeGit.fetch([remote, `+refs/heads/${headBranch}:refs/remotes/${remote}/${headBranch}`]);
             // Create/update a local branch pointing to the fetched ref so tooling can reference it by name
-            await worktreeGit.branch(['-f', prData.head_branch, `${remote}/${prData.head_branch}`]);
+            await worktreeGit.branch(['-f', headBranch, `${remote}/${headBranch}`]);
           } catch (branchFetchError) {
             // Expected for fork PRs - the branch exists in the fork, not the base repo
             console.log(`Could not fetch head branch (may be from a fork): ${branchFetchError.message}`);
@@ -450,9 +545,9 @@ class GitWorktreeManager {
         console.log(`Executing checkout script: ${checkoutScript}`);
         const scriptEnv = {
           BASE_BRANCH: prData.base_branch,
-          HEAD_BRANCH: prData.head_branch,
+          HEAD_BRANCH: headBranch,
           BASE_SHA: prData.base_sha,
-          HEAD_SHA: prData.head_sha,
+          HEAD_SHA: this.getPRHeadSha(prData),
           PR_NUMBER: String(prInfo.number),
           WORKTREE_PATH: worktreePath
         };
@@ -461,13 +556,13 @@ class GitWorktreeManager {
       }
 
       // Checkout to PR head commit
-      const targetSha = prData.head_sha;
+      const targetSha = this.getPRHeadSha(prData);
       if (targetSha) {
         console.log(`Checking out to PR head commit ${targetSha}...`);
         await worktreeGit.checkout([targetSha]);
       } else {
-        console.log(`Checking out to PR head ref ${remote}/pr-${prInfo.number}...`);
-        await worktreeGit.checkout([`${remote}/pr-${prInfo.number}`]);
+        console.log(`Checking out to PR head ref ${fetchedHead.checkoutTarget}...`);
+        await worktreeGit.checkout([fetchedHead.checkoutTarget]);
       }
       
       // Verify we're at the correct commit
@@ -540,13 +635,13 @@ class GitWorktreeManager {
       console.log(`Fetching latest changes from ${remote}...`);
       await worktreeGit.fetch([remote, '--prune']);
 
-      // Fetch the PR head using GitHub's pull request refs
+      // Fetch the PR head using PR refs when available, with a branch/SHA fallback
       console.log(`Fetching PR #${number} head...`);
-      await worktreeGit.fetch([remote, `+refs/pull/${number}/head:refs/remotes/${remote}/pr-${number}`]);
+      const fetchedHead = await this.fetchPRHead(worktreeGit, prInfo, prData, { remote });
 
       // Checkout to PR head commit
       console.log(`Checking out to PR head commit ${headSha}...`);
-      await worktreeGit.checkout([`${remote}/pr-${number}`]);
+      await worktreeGit.checkout([fetchedHead.checkoutTarget]);
 
       // Verify we're at the correct commit
       const currentCommit = await worktreeGit.revparse(['HEAD']);
@@ -919,11 +1014,11 @@ class GitWorktreeManager {
 
       // Fetch the latest PR head from remote
       console.log(`Fetching PR #${prNumber} head from ${remote}...`);
-      await git.fetch([remote, `pull/${prNumber}/head`]);
+      const fetchedHead = await this.fetchPRHead(git, prInfo || { number: prNumber }, prData, { remote });
 
       // Reset to the fetched PR head
       console.log(`Resetting worktree to PR head...`);
-      await git.raw(['reset', '--hard', 'FETCH_HEAD']);
+      await git.raw(['reset', '--hard', fetchedHead.checkoutTarget]);
 
       // Update last_accessed_at in database
       if (this.worktreeRepo) {
@@ -977,13 +1072,13 @@ class GitWorktreeManager {
         ? await this.resolveRemoteForPR(git, prData, prInfo)
         : defaultRemote;
 
-      // 3. Fetch PR head into a persistent ref
-      console.log(`Fetching PR #${prNumber} head from ${remote} into refs/remotes/${remote}/pr-${prNumber}...`);
-      await git.fetch([remote, `+refs/pull/${prNumber}/head:refs/remotes/${remote}/pr-${prNumber}`]);
+      // 3. Fetch PR head into a persistent ref (or by SHA when refs are unavailable)
+      console.log(`Fetching PR #${prNumber} head from ${remote}...`);
+      const fetchedHead = await this.fetchPRHead(git, prInfo || { number: prNumber }, prData, { remote });
 
       // 4. Reset worktree to the fetched ref
-      console.log(`Resetting worktree to refs/remotes/${remote}/pr-${prNumber}...`);
-      await git.raw(['reset', '--hard', `refs/remotes/${remote}/pr-${prNumber}`]);
+      console.log(`Resetting worktree to ${fetchedHead.checkoutTarget}...`);
+      await git.raw(['reset', '--hard', fetchedHead.checkoutTarget]);
 
       // 5. Return the new HEAD SHA
       const headSha = (await git.revparse(['HEAD'])).trim();
@@ -1219,4 +1314,4 @@ class GitWorktreeManager {
   }
 }
 
-module.exports = { GitWorktreeManager };
+module.exports = { GitWorktreeManager };