@expo/code-review-cli 0.2.2 → 0.2.3

package/README.md

@@ -84,9 +84,11 @@ Options (most to least common):
 | `--no-fail` | Always exit 0 (otherwise a `request_changes` decision exits non-zero). |
 | `-h`, `--help` | Show help. |
 
-`--pr` uses the PR's diff (authoritative) but reads your checked-out files for
-surrounding context; for full fidelity, `gh pr checkout <n>` first and run a plain
-`ecr review`.
+`--pr` uses the PR's diff (authoritative) and checks the PR head out into a
+throwaway worktree so the agents' surrounding-source reads and the verifier see the
+PR's versions of files — no manual `gh pr checkout` needed, and your working tree is
+left untouched. (If that materialization can't run — e.g. not a git checkout — it
+falls back to reading the current working directory.)
 
 In CI it runs automatically from the scaffolded workflows — by label or a `/review`
 comment (see **CI usage**). From Claude Code (or another agent), add a slash command

package/build/core/review.js

@@ -67,7 +67,28 @@ export async function runReview(source, options) {
         });
         return output;
     }
+    // Prepare auth BEFORE the chdir below: it doesn't depend on the working directory,
+    // and doing it first means nothing that can throw sits between the chdir and the
+    // guarded blocks — so a prepareAuth failure can't leak the worktree or leave cwd
+    // pointing at it.
     const auth = await prepareAuth(config);
+    // Read the PR-head tree (not the current checkout) when the source can materialize
+    // it, so the agents' surrounding-source reads and the verifier's re-reads see the
+    // versions that match the diff. Config is already fully loaded in memory, so the
+    // chdir doesn't affect it; run-log/patch paths are absolute; gh/git calls already
+    // ran above. Fails soft to the current directory.
+    const originalCwd = process.cwd();
+    const readRoot = (await source.prepareReadRootAsync?.()) ?? null;
+    const restoreCwd = async () => {
+        if (readRoot) {
+            process.chdir(originalCwd);
+            await readRoot.cleanup();
+        }
+    };
+    if (readRoot) {
+        progress('Reviewing the PR-head tree (so reads match the PR, not the checkout).');
+        process.chdir(readRoot.dir);
+    }
     progress('Starting OpenCode server…');
     let handle = null;
     try {
@@ -75,6 +96,7 @@ export async function runReview(source, options) {
     }
     catch (error) {
         await auth.cleanup();
+        await restoreCwd();
         throw new Error(`Failed to start the OpenCode server. Ensure the \`opencode\` CLI is installed and ` +
             `model credentials are configured.\n${errorMessage(error)}`);
     }
@@ -382,6 +404,7 @@ export async function runReview(source, options) {
     finally {
         handle?.close();
         await auth.cleanup();
+        await restoreCwd();
     }
 }
 /**

package/build/sources/github-pr.js

@@ -1,3 +1,6 @@
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
 import { run } from '../core/exec.js';
 import { parseUnifiedDiff } from '../core/diff.js';
 /**
@@ -33,4 +36,47 @@ export class GitHubPRSource {
         const { stdout } = await run('gh', ['pr', 'diff', String(this.options.prNumber), ...this.repoArgs()], { cwd: this.options.cwd });
         return parseUnifiedDiff(stdout);
     }
+    /**
+     * Check the PR HEAD out into a throwaway git worktree so the agents and verifier
+     * read the PR's versions of files (not whatever branch happens to be checked out).
+     * Fetches the head from the repo's own URL — `refs/pull/<n>/head`, which the base
+     * repo hosts even for fork PRs — so it's always the correct PR, independent of the
+     * local `origin`. Fails SOFT: any problem (not a git repo, fetch/worktree error)
+     * returns null, and the review falls back to reading the current checkout.
+     */
+    async prepareReadRootAsync() {
+        const cwd = this.options.cwd;
+        if (!this.options.repo) {
+            // Without an explicit owner/repo we can't build the fetch URL safely.
+            return null;
+        }
+        const url = `https://github.com/${this.options.repo}.git`;
+        const ref = `refs/pull/${this.options.prNumber}/head`;
+        let parent;
+        try {
+            await run('git', ['fetch', '--no-tags', '--depth=1', url, ref], { cwd });
+            parent = await mkdtemp(path.join(tmpdir(), 'ecr-prhead-'));
+            const dir = path.join(parent, 'head'); // must not pre-exist for `worktree add`
+            await run('git', ['worktree', 'add', '--detach', dir, 'FETCH_HEAD'], { cwd });
+            const removeParent = parent;
+            return {
+                dir,
+                cleanup: async () => {
+                    try {
+                        await run('git', ['worktree', 'remove', '--force', dir], { cwd });
+                    }
+                    catch {
+                        // best effort — fall through to removing the temp dir
+                    }
+                    await rm(removeParent, { recursive: true, force: true });
+                },
+            };
+        }
+        catch {
+            if (parent) {
+                await rm(parent, { recursive: true, force: true }).catch(() => { });
+            }
+            return null;
+        }
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expo/code-review-cli",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "description": "Generic, config-driven AI code reviewer engine. Repos supply their agents via .expo-code-review/.",
   "license": "MIT",
   "repository": {