feat: adapt pullfrog for gitea + ollama
This commit is contained in:
+145
-505
@@ -1,11 +1,12 @@
|
||||
import { createHash } from "node:crypto";
|
||||
import { statSync, unlinkSync, writeFileSync } from "node:fs";
|
||||
import { join } from "node:path";
|
||||
import type { Octokit, RestEndpointMethodTypes } from "@octokit/rest";
|
||||
import { type } from "arktype";
|
||||
import { log } from "../utils/cli.ts";
|
||||
import { countLines, createDiffCoverageState } from "../utils/diffCoverage.ts";
|
||||
import { $git, $gitFetchWithDeepen } from "../utils/gitAuth.ts";
|
||||
import type { Gitea } from "../utils/gitea.ts";
|
||||
import type { ChangedFileWithPatch } from "../utils/gitea.ts";
|
||||
import { executeLifecycleHook } from "../utils/lifecycle.ts";
|
||||
import { computeIncrementalDiff } from "../utils/rangeDiff.ts";
|
||||
import { retry } from "../utils/retry.ts";
|
||||
@@ -15,123 +16,89 @@ import { commentableLinesForFile } from "./review.ts";
|
||||
import type { ToolContext } from "./server.ts";
|
||||
import { execute, tool } from "./shared.ts";
|
||||
|
||||
type PullFile = RestEndpointMethodTypes["pulls"]["listFiles"]["response"]["data"][number];
|
||||
|
||||
export type FormatFilesResult = {
|
||||
content: string;
|
||||
toc: string;
|
||||
};
|
||||
export type FormatFilesResult = { content: string; toc: string };
|
||||
|
||||
export type FetchAndFormatPrDiffResult = FormatFilesResult & {
|
||||
files: PullFile[];
|
||||
files: DiffFile[];
|
||||
};
|
||||
|
||||
/**
|
||||
* formats PR files with explicit line numbers for each code line.
|
||||
* preserves all original diff info (file headers, hunk headers) and adds:
|
||||
* | OLD | NEW | TYPE | code
|
||||
* returns both the formatted content and a TOC with line ranges per file.
|
||||
*/
|
||||
export function formatFilesWithLineNumbers(files: PullFile[]): FormatFilesResult {
|
||||
export type DiffFile = {
|
||||
filename?: string | undefined;
|
||||
patch?: string | undefined;
|
||||
};
|
||||
|
||||
export function formatFilesWithLineNumbers(files: DiffFile[]): FormatFilesResult {
|
||||
const output: string[] = [];
|
||||
const tocEntries: Array<{ filename: string; startLine: number; endLine: number }> = [];
|
||||
|
||||
// calculate TOC header size: "## Files (N)\n" + N entries + "\n---\n\n"
|
||||
const tocHeaderSize = 1 + files.length + 2;
|
||||
let currentLine = tocHeaderSize + 1;
|
||||
|
||||
for (const file of files) {
|
||||
const filename = file.filename ?? "(unknown)";
|
||||
const fileStartLine = currentLine;
|
||||
|
||||
// file header
|
||||
output.push(`diff --git a/${file.filename} b/${file.filename}`);
|
||||
output.push(`--- a/${file.filename}`);
|
||||
output.push(`+++ b/${file.filename}`);
|
||||
output.push(`diff --git a/${filename} b/${filename}`);
|
||||
output.push(`--- a/${filename}`);
|
||||
output.push(`+++ b/${filename}`);
|
||||
currentLine += 3;
|
||||
|
||||
if (!file.patch) {
|
||||
output.push("(binary file or no changes)");
|
||||
output.push("");
|
||||
currentLine += 2;
|
||||
tocEntries.push({
|
||||
filename: file.filename,
|
||||
startLine: fileStartLine,
|
||||
endLine: currentLine - 1,
|
||||
});
|
||||
tocEntries.push({ filename, startLine: fileStartLine, endLine: currentLine - 1 });
|
||||
continue;
|
||||
}
|
||||
|
||||
// parse and format the patch with line numbers
|
||||
const lines = file.patch.split("\n");
|
||||
let oldLine = 0;
|
||||
let newLine = 0;
|
||||
|
||||
for (const line of lines) {
|
||||
// hunk header: @@ -OLD,COUNT +NEW,COUNT @@ optional context
|
||||
const hunkMatch = line.match(/^@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@/);
|
||||
if (hunkMatch) {
|
||||
oldLine = parseInt(hunkMatch[1], 10);
|
||||
newLine = parseInt(hunkMatch[2], 10);
|
||||
output.push(line); // pass through unchanged
|
||||
output.push(line);
|
||||
currentLine++;
|
||||
continue;
|
||||
}
|
||||
|
||||
// code lines within hunks
|
||||
const changeType = line[0] || " ";
|
||||
const code = line.slice(1);
|
||||
|
||||
if (changeType === "-") {
|
||||
// removed line: show old line number, no new line number
|
||||
output.push(`| ${padNum(oldLine)} | | - | ${code}`);
|
||||
oldLine++;
|
||||
} else if (changeType === "+") {
|
||||
// added line: no old line number, show new line number
|
||||
output.push(`| | ${padNum(newLine)} | + | ${code}`);
|
||||
newLine++;
|
||||
} else if (changeType === " " || changeType === "\\") {
|
||||
// context line or "\ No newline at end of file"
|
||||
if (changeType === "\\") {
|
||||
output.push(line); // pass through as-is
|
||||
output.push(line);
|
||||
} else {
|
||||
output.push(`| ${padNum(oldLine)} | ${padNum(newLine)} | | ${code}`);
|
||||
oldLine++;
|
||||
newLine++;
|
||||
}
|
||||
} else {
|
||||
// unknown line type, pass through
|
||||
output.push(line);
|
||||
}
|
||||
currentLine++;
|
||||
}
|
||||
output.push(""); // blank line between files
|
||||
output.push("");
|
||||
currentLine++;
|
||||
|
||||
tocEntries.push({
|
||||
filename: file.filename,
|
||||
startLine: fileStartLine,
|
||||
endLine: currentLine - 1,
|
||||
});
|
||||
tocEntries.push({ filename, startLine: fileStartLine, endLine: currentLine - 1 });
|
||||
}
|
||||
|
||||
// build TOC. each entry includes the precomputed sha256 anchor used in
|
||||
// github PR Files Changed URLs (#diff-<hex>), so the agent never needs to
|
||||
// shell out to sha256sum.
|
||||
const tocLines = [`## Files (${files.length})`];
|
||||
for (const entry of tocEntries) {
|
||||
const anchor = createHash("sha256").update(entry.filename).digest("hex");
|
||||
tocLines.push(
|
||||
`- ${entry.filename} → lines ${entry.startLine}-${entry.endLine} · diff-${anchor}`
|
||||
);
|
||||
tocLines.push(`- ${entry.filename} → lines ${entry.startLine}-${entry.endLine} · diff-${anchor}`);
|
||||
}
|
||||
tocLines.push("");
|
||||
tocLines.push("---");
|
||||
tocLines.push("");
|
||||
tocLines.push("", "---", "");
|
||||
|
||||
const toc = tocLines.join("\n");
|
||||
const content = toc + output.join("\n");
|
||||
|
||||
return { content, toc };
|
||||
return { content: toc + output.join("\n"), toc };
|
||||
}
|
||||
|
||||
function padNum(n: number): string {
|
||||
@@ -159,33 +126,30 @@ export type CheckoutPrResult = {
|
||||
toc: string;
|
||||
commitCount: number;
|
||||
commitLog: string;
|
||||
/** true when commitLog was capped because the PR has more commits than we render */
|
||||
commitLogTruncated: boolean;
|
||||
/** true when commit metadata could not be computed (e.g. base ref unreachable after shallow fetch). commitCount/commitLog are zero/empty in that case, not "no commits". */
|
||||
commitLogUnavailable: boolean;
|
||||
/** non-fatal warning from the post-checkout lifecycle hook, if any */
|
||||
hookWarning?: string | undefined;
|
||||
instructions: string;
|
||||
};
|
||||
|
||||
/**
|
||||
* fetches PR files from GitHub and formats them with line numbers and TOC.
|
||||
* this is the core diff formatting logic, extracted for testability.
|
||||
*/
|
||||
export async function fetchAndFormatPrDiff(
|
||||
ctx: ToolContext,
|
||||
pullNumber: number
|
||||
): Promise<FetchAndFormatPrDiffResult> {
|
||||
const files = await ctx.octokit.paginate(ctx.octokit.rest.pulls.listFiles, {
|
||||
const raw = await ctx.gitea.paginate(ctx.gitea.rest.repository.repoGetPullRequestFiles, {
|
||||
owner: ctx.repo.owner,
|
||||
repo: ctx.repo.name,
|
||||
pull_number: pullNumber,
|
||||
per_page: 100,
|
||||
index: pullNumber,
|
||||
});
|
||||
// ChangedFile from the SDK omits `patch`; Gitea does return it, so we map here.
|
||||
const files: DiffFile[] = raw.map((f) => ({
|
||||
filename: f.filename,
|
||||
patch: (f as unknown as { patch?: string }).patch,
|
||||
}));
|
||||
return { ...formatFilesWithLineNumbers(files), files };
|
||||
}
|
||||
|
||||
import { captureInitialHead, type GitContext } from "../utils/setup.ts";
|
||||
import { captureInitialHead } from "../utils/setup.ts";
|
||||
|
||||
export type PrData = {
|
||||
number: number;
|
||||
@@ -197,74 +161,78 @@ export type PrData = {
|
||||
maintainerCanModify: boolean;
|
||||
};
|
||||
|
||||
type EnsureBeforeShaParams = {
|
||||
sha: string;
|
||||
octokit: Octokit;
|
||||
owner: string;
|
||||
repo: string;
|
||||
const STALE_LOCK_AGE_MS = 30_000;
|
||||
const PULL_REF_RETRY_DELAYS_MS = [2_000, 5_000, 10_000];
|
||||
const PULL_REF_MISSING_PATTERN = /couldn't find remote ref pull\/\d+\/head/i;
|
||||
|
||||
const GIT_LOCK_PATHS = [".git/shallow.lock", ".git/index.lock", ".git/objects/maintenance.lock"] as const;
|
||||
|
||||
function cleanupStaleGitLocks(): void {
|
||||
const now = Date.now();
|
||||
for (const relPath of GIT_LOCK_PATHS) {
|
||||
let mtimeMs: number;
|
||||
try { mtimeMs = statSync(relPath).mtimeMs; } catch { continue; }
|
||||
if (now - mtimeMs < STALE_LOCK_AGE_MS) continue;
|
||||
try { unlinkSync(relPath); log.warning(`» removed stale ${relPath}`); } catch {}
|
||||
}
|
||||
}
|
||||
|
||||
type CheckoutPrBranchParams = {
|
||||
gitToken: string;
|
||||
isShallow: boolean;
|
||||
owner: string;
|
||||
name: string;
|
||||
gitea: Gitea;
|
||||
toolState: import("../toolState.ts").ToolState;
|
||||
shell: import("../external.ts").ShellPermission;
|
||||
postCheckoutScript: string | null;
|
||||
beforeSha?: string | undefined;
|
||||
};
|
||||
|
||||
type CreateTempBranchParams = {
|
||||
octokit: Octokit;
|
||||
owner: string;
|
||||
repo: string;
|
||||
ref: string;
|
||||
sha: string;
|
||||
};
|
||||
async function abortIfPullRequestMoved(args: { gitea: Gitea; owner: string; repo: string; pr: PrData }): Promise<void> {
|
||||
try {
|
||||
const data = (await args.gitea.rest.repository.repoGetPullRequest({ owner: args.owner, repo: args.repo, index: args.pr.number })).data;
|
||||
if (data.state !== "open" || data.head?.sha !== args.pr.headSha) {
|
||||
throw new Error(`PR #${args.pr.number} is no longer in the state it was at dispatch. Aborting.`);
|
||||
}
|
||||
} catch (e) {
|
||||
if (e instanceof Error && e.message.includes("no longer")) throw e;
|
||||
// API error — lenient, don't abort
|
||||
}
|
||||
}
|
||||
|
||||
type CreateTempBranchParams = { gitea: Gitea; owner: string; repo: string; branchName: string; sha: string };
|
||||
|
||||
async function createTempBranch(params: CreateTempBranchParams) {
|
||||
const response = await params.octokit.rest.git.createRef({
|
||||
await params.gitea.rest.repository.repoCreateBranch({
|
||||
owner: params.owner,
|
||||
repo: params.repo,
|
||||
ref: `refs/heads/${params.ref}`,
|
||||
sha: params.sha,
|
||||
body: { new_branch_name: params.branchName, old_ref_name: params.sha },
|
||||
});
|
||||
return {
|
||||
data: response.data,
|
||||
async [Symbol.asyncDispose]() {
|
||||
try {
|
||||
await params.octokit.rest.git.deleteRef({
|
||||
owner: params.owner,
|
||||
repo: params.repo,
|
||||
ref: `heads/${params.ref}`,
|
||||
});
|
||||
log.debug(`» deleted temp branch ${params.ref}`);
|
||||
await params.gitea.rest.repository.repoDeleteBranch({ owner: params.owner, repo: params.repo, branch: params.branchName });
|
||||
log.debug(`» deleted temp branch ${params.branchName}`);
|
||||
} catch (e) {
|
||||
log.debug(
|
||||
`» failed to delete temp branch ${params.ref}: ${e instanceof Error ? e.message : String(e)}`
|
||||
);
|
||||
log.debug(`» failed to delete temp branch ${params.branchName}: ${e instanceof Error ? e.message : String(e)}`);
|
||||
}
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
async function ensureBeforeShaReachable(params: EnsureBeforeShaParams): Promise<boolean> {
|
||||
try {
|
||||
$("git", ["cat-file", "-t", params.sha], { log: false });
|
||||
log.debug(`» before_sha ${params.sha.slice(0, 7)} is reachable`);
|
||||
return true;
|
||||
} catch {
|
||||
// not available locally — create a temporary branch to fetch it
|
||||
}
|
||||
async function ensureBeforeShaReachable(params: {
|
||||
sha: string; gitea: Gitea; owner: string; repo: string; gitToken: string; isShallow: boolean;
|
||||
}): Promise<boolean> {
|
||||
try { $("git", ["cat-file", "-t", params.sha], { log: false }); return true; } catch {}
|
||||
|
||||
const tempBranch = `pullfrog/tmp/${params.sha.slice(0, 12)}`;
|
||||
const branchName = `shockbot/tmp/${params.sha.slice(0, 12)}`;
|
||||
try {
|
||||
log.debug(`» before_sha ${params.sha.slice(0, 7)} not reachable, creating temp branch...`);
|
||||
await using _ref = await createTempBranch({
|
||||
octokit: params.octokit,
|
||||
owner: params.owner,
|
||||
repo: params.repo,
|
||||
sha: params.sha,
|
||||
ref: tempBranch,
|
||||
});
|
||||
await using _ref = await createTempBranch({ gitea: params.gitea, owner: params.owner, repo: params.repo, branchName, sha: params.sha });
|
||||
await $gitFetchWithDeepen(
|
||||
["--no-tags", ...(params.isShallow ? ["--depth=1"] : []), "origin", tempBranch],
|
||||
["--no-tags", ...(params.isShallow ? ["--depth=1"] : []), "origin", branchName],
|
||||
{ token: params.gitToken },
|
||||
`before_sha temp branch ${tempBranch}`
|
||||
`before_sha temp branch ${branchName}`
|
||||
);
|
||||
log.debug(`» fetched before_sha via temp branch ${tempBranch}`);
|
||||
return true;
|
||||
} catch (e) {
|
||||
log.debug(`» failed to fetch before_sha: ${e instanceof Error ? e.message : String(e)}`);
|
||||
@@ -272,174 +240,30 @@ async function ensureBeforeShaReachable(params: EnsureBeforeShaParams): Promise<
|
||||
}
|
||||
}
|
||||
|
||||
type CheckoutPrBranchParams = GitContext & {
|
||||
beforeSha?: string | undefined;
|
||||
};
|
||||
|
||||
// stale lock files left over from a crashed/cancelled prior git process block
|
||||
// every subsequent fetch with `Unable to create '<path>': File exists`. only
|
||||
// sweep locks older than this threshold so we never race a concurrent
|
||||
// legitimate git op that's holding the lock.
|
||||
const STALE_LOCK_AGE_MS = 30_000;
|
||||
|
||||
// PR head refs (refs/pull/N/head) sometimes lag the pull_request.opened
|
||||
// webhook by a few seconds. retry the missing-ref case with backoff
|
||||
// before giving up — see issue #591.
|
||||
const PULL_REF_RETRY_DELAYS_MS = [2_000, 5_000, 10_000];
|
||||
const PULL_REF_MISSING_PATTERN = /couldn't find remote ref pull\/\d+\/head/i;
|
||||
|
||||
const GIT_LOCK_PATHS = [
|
||||
".git/shallow.lock",
|
||||
".git/index.lock",
|
||||
".git/objects/maintenance.lock",
|
||||
] as const;
|
||||
|
||||
function cleanupStaleGitLocks(): void {
|
||||
const now = Date.now();
|
||||
for (const relPath of GIT_LOCK_PATHS) {
|
||||
let mtimeMs: number;
|
||||
try {
|
||||
mtimeMs = statSync(relPath).mtimeMs;
|
||||
} catch {
|
||||
continue;
|
||||
}
|
||||
if (now - mtimeMs < STALE_LOCK_AGE_MS) continue;
|
||||
try {
|
||||
unlinkSync(relPath);
|
||||
log.warning(`» removed stale ${relPath} from prior run`);
|
||||
} catch (e) {
|
||||
log.debug(
|
||||
`» failed to remove stale ${relPath}: ${e instanceof Error ? e.message : String(e)}`
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns false when a PR's current state diverges from what we dispatched
|
||||
* on (closed/merged, or head SHA differs from pr.headSha). Used to short-
|
||||
* circuit the pull/N/head retry loop when the ref is missing because the
|
||||
* PR has moved on, not because of a webhook race.
|
||||
*
|
||||
* Network failures here are treated as "still valid" — we'd rather burn the
|
||||
* retry budget than wrongly abort on a transient API blip.
|
||||
*
|
||||
* Note: this answers "should we keep trying?", NOT "will the next fetch
|
||||
* succeed?". `pulls.get` (REST API) and `pull/N/head` (git ref) are served
|
||||
* by independent GitHub replicas with their own propagation lag, so
|
||||
* `pulls.get` reporting an open PR with a matching head SHA does not
|
||||
* guarantee the git ref is yet visible — and vice versa (see issue #591
|
||||
* for the original webhook-vs-ref replication-lag context).
|
||||
*/
|
||||
async function isPullRequestStillDispatchable(args: {
|
||||
octokit: Octokit;
|
||||
owner: string;
|
||||
repo: string;
|
||||
pr: PrData;
|
||||
}): Promise<boolean> {
|
||||
try {
|
||||
const { data } = await args.octokit.rest.pulls.get({
|
||||
owner: args.owner,
|
||||
repo: args.repo,
|
||||
pull_number: args.pr.number,
|
||||
});
|
||||
if (data.state !== "open") return false;
|
||||
if (data.head.sha !== args.pr.headSha) return false;
|
||||
return true;
|
||||
} catch {
|
||||
// lenient — don't abort on API hiccups
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Throws the friendly clean-abort error when the PR has moved on since
|
||||
* dispatch. Wraps `isPullRequestStillDispatchable` so the abort message
|
||||
* lives in one place and is invoked from the inner `catch` around the
|
||||
* `pull/N/head` fetch on every missing-ref failure.
|
||||
*/
|
||||
async function abortIfPullRequestMoved(args: {
|
||||
octokit: Octokit;
|
||||
owner: string;
|
||||
repo: string;
|
||||
pr: PrData;
|
||||
}): Promise<void> {
|
||||
const stillValid = await isPullRequestStillDispatchable(args);
|
||||
if (stillValid) return;
|
||||
throw new Error(
|
||||
`PR #${args.pr.number} is no longer in the state it was at dispatch (likely closed, merged, or force-pushed between webhook fire and run start). aborting checkout — re-trigger the run if this PR is still active.`
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Shared helper to checkout a PR branch and configure fork remotes.
|
||||
* Assumes origin remote is already configured with authentication.
|
||||
* Updates toolState.issueNumber, toolState.checkoutSha, and toolState.pushUrl (for fork PRs).
|
||||
*/
|
||||
export async function checkoutPrBranch(
|
||||
pr: PrData,
|
||||
params: CheckoutPrBranchParams
|
||||
): Promise<{ hookWarning?: string | undefined }> {
|
||||
const { octokit, owner, name, gitToken, toolState, beforeSha } = params;
|
||||
const { gitea, owner, name, gitToken, toolState, beforeSha } = params;
|
||||
log.info(`» checking out PR #${pr.number}...`);
|
||||
|
||||
// SECURITY: PR ref names come from GitHub and are attacker-controlled on
|
||||
// forks (the PR author picks headRef freely, and baseRef could be a
|
||||
// maliciously-named branch on the target repo). reject leading-dash names
|
||||
// before they reach any git command — without this, a ref like
|
||||
// "-upload-pack=evil" fed into `git fetch origin <ref>` would be parsed as
|
||||
// a flag, not a refspec.
|
||||
rejectIfLeadingDash(pr.baseRef, "PR base ref");
|
||||
rejectIfLeadingDash(pr.headRef, "PR head ref");
|
||||
|
||||
// self-hosted runners and cancelled jobs frequently leave stale .git/*.lock
|
||||
// files behind. without this sweep, the first fetch below aborts with
|
||||
// `Unable to create '.git/shallow.lock': File exists` and the agent has to
|
||||
// shell out to `rm -f` (issue #564).
|
||||
cleanupStaleGitLocks();
|
||||
|
||||
const isFork = pr.headRepoFullName !== pr.baseRepoFullName;
|
||||
|
||||
// always use pr-{number} as local branch name for consistency
|
||||
// this avoids naming conflicts and makes push config simpler
|
||||
const localBranch = `pr-${pr.number}`;
|
||||
|
||||
const isShallow =
|
||||
$("git", ["rev-parse", "--is-shallow-repository"], { log: false }).trim() === "true";
|
||||
const isShallow = $("git", ["rev-parse", "--is-shallow-repository"], { log: false }).trim() === "true";
|
||||
|
||||
toolState.checkoutSha = $("git", ["rev-parse", "HEAD"], { log: false }).trim();
|
||||
const alreadyOnBranch = toolState.checkoutSha === pr.headSha;
|
||||
|
||||
// fetch base branch so origin/<base> exists for diff operations.
|
||||
// wrap with deepen-retry: on shallow clones (the actions/checkout default
|
||||
// is depth=1), repos with deep PR ancestry can't reach the baseRef tip in
|
||||
// a single round trip, surfacing as `Could not read <sha>` / `remote did
|
||||
// not send all necessary objects` (issue #656).
|
||||
log.debug(`» fetching base branch (${pr.baseRef})...`);
|
||||
await $gitFetchWithDeepen(
|
||||
["--no-tags", "origin", pr.baseRef],
|
||||
{ token: gitToken },
|
||||
`base branch ${pr.baseRef}`
|
||||
);
|
||||
await $gitFetchWithDeepen(["--no-tags", "origin", pr.baseRef], { token: gitToken }, `base branch ${pr.baseRef}`);
|
||||
|
||||
// alreadyOnBranch only matches for repeated checkout_pr calls for the same PR in one session
|
||||
// (without the tip moving), or if an external setup already checked out the PR head.
|
||||
// normal PR-triggered runs won't match here — actions/checkout lands on a synthesized
|
||||
// merge commit whose SHA differs from pr.headSha.
|
||||
//
|
||||
// so the fetch+checkout block below will almost always execute, and the fetched HEAD
|
||||
// might differ from pr.headSha. toolState.checkoutSha is set after to capture the actual SHA.
|
||||
if (!alreadyOnBranch) {
|
||||
// checkout base branch first to avoid "refusing to fetch into current branch" error
|
||||
// -B creates or resets the branch to match origin/baseBranch
|
||||
$("git", ["checkout", "-B", pr.baseRef, `origin/${pr.baseRef}`], { log: false });
|
||||
|
||||
// fetch PR branch using pull/{n}/head refspec (works for both fork and same-repo PRs).
|
||||
// two transient classes wrap this fetch:
|
||||
// - shallow-unreachable (`Could not read <sha>` etc.) — handled by the
|
||||
// inner `$gitFetchWithDeepen` deepen-retry (one shot, see issue #656)
|
||||
// - pull/N/head webhook race (`couldn't find remote ref pull/N/head`) —
|
||||
// handled by the outer retry below (see issue #591)
|
||||
log.debug(`» fetching PR #${pr.number} (${localBranch})...`);
|
||||
await retry(
|
||||
async () => {
|
||||
@@ -450,13 +274,9 @@ export async function checkoutPrBranch(
|
||||
`PR #${pr.number}`
|
||||
);
|
||||
} catch (e) {
|
||||
// on the webhook race, check whether the PR still matches what we
|
||||
// dispatched on. if it's been closed/merged or the head SHA moved,
|
||||
// no amount of retrying will populate the expected ref — surface a
|
||||
// clean abort error instead of burning the full retry budget.
|
||||
const msg = e instanceof Error ? e.message : String(e);
|
||||
if (PULL_REF_MISSING_PATTERN.test(msg)) {
|
||||
await abortIfPullRequestMoved({ octokit, owner, repo: name, pr });
|
||||
await abortIfPullRequestMoved({ gitea, owner, repo: name, pr });
|
||||
}
|
||||
throw e;
|
||||
}
|
||||
@@ -464,138 +284,58 @@ export async function checkoutPrBranch(
|
||||
{
|
||||
delaysMs: PULL_REF_RETRY_DELAYS_MS,
|
||||
label: `pull/${pr.number}/head fetch`,
|
||||
shouldRetry: (e) =>
|
||||
PULL_REF_MISSING_PATTERN.test(e instanceof Error ? e.message : String(e)),
|
||||
shouldRetry: (e) => PULL_REF_MISSING_PATTERN.test(e instanceof Error ? e.message : String(e)),
|
||||
}
|
||||
);
|
||||
|
||||
// checkout the branch
|
||||
$("git", ["checkout", localBranch], { log: false });
|
||||
log.debug(`» checked out PR #${pr.number}`);
|
||||
// make sure toolState.checkoutSha is set to the actual checked-out SHA (which might be different from pr.headSha)
|
||||
toolState.checkoutSha = $("git", ["rev-parse", "HEAD"], { log: false }).trim();
|
||||
}
|
||||
|
||||
const beforeShaReachable = beforeSha
|
||||
? await ensureBeforeShaReachable({
|
||||
sha: beforeSha,
|
||||
octokit,
|
||||
owner,
|
||||
repo: name,
|
||||
gitToken,
|
||||
isShallow,
|
||||
})
|
||||
? await ensureBeforeShaReachable({ sha: beforeSha, gitea, owner, repo: name, gitToken, isShallow })
|
||||
: false;
|
||||
|
||||
// compute deepen depth for shallow clones. actions/checkout uses depth=1
|
||||
// by default, which breaks rebase/log because git can't find the merge base.
|
||||
// use the GitHub compare API to fetch exactly enough history.
|
||||
// computed after checkout so compareCommits uses the actual checked-out SHA.
|
||||
if (isShallow) {
|
||||
let deepenDepth = 0;
|
||||
try {
|
||||
// ahead_by = PR commits past merge base, behind_by = base commits past merge base.
|
||||
// --deepen extends ALL shallow roots equally (can't deepen a single branch),
|
||||
// so we need the max across both the PR head and before_sha to ensure all
|
||||
// three points (base, head, before_sha) reach the merge base in a single deepen call.
|
||||
const [prComparison, beforeShaComparison] = await Promise.all([
|
||||
octokit.rest.repos.compareCommits({
|
||||
owner,
|
||||
repo: name,
|
||||
base: pr.baseRef,
|
||||
head: toolState.checkoutSha,
|
||||
}),
|
||||
const [prComp, beforeComp] = await Promise.all([
|
||||
gitea.rest.repository.repoCompareDiff({ owner, repo: name, basehead: `${pr.baseRef}...${toolState.checkoutSha}` }),
|
||||
beforeSha && beforeShaReachable
|
||||
? octokit.rest.repos.compareCommits({
|
||||
owner,
|
||||
repo: name,
|
||||
base: pr.baseRef,
|
||||
head: beforeSha,
|
||||
})
|
||||
? gitea.rest.repository.repoCompareDiff({ owner, repo: name, basehead: `${pr.baseRef}...${beforeSha}` })
|
||||
: undefined,
|
||||
]);
|
||||
deepenDepth =
|
||||
Math.max(
|
||||
prComparison.data.ahead_by,
|
||||
prComparison.data.behind_by,
|
||||
beforeShaComparison?.data.ahead_by ?? 0,
|
||||
beforeShaComparison?.data.behind_by ?? 0
|
||||
) + 10;
|
||||
log.debug(
|
||||
`» PR: ${prComparison.data.ahead_by} ahead / ${prComparison.data.behind_by} behind` +
|
||||
(beforeShaComparison
|
||||
? `, before_sha: ${beforeShaComparison.data.ahead_by} ahead / ${beforeShaComparison.data.behind_by} behind`
|
||||
: "") +
|
||||
`, deepen by ${deepenDepth}`
|
||||
);
|
||||
const prTotal = prComp.data.total_commits ?? 0;
|
||||
const beforeTotal = beforeComp?.data.total_commits ?? 0;
|
||||
deepenDepth = Math.max(prTotal, beforeTotal) + 10;
|
||||
log.debug(`» compare: PR=${prTotal}, before=${beforeTotal}, deepen=${deepenDepth}`);
|
||||
} catch {
|
||||
deepenDepth = 1000;
|
||||
log.debug(`» compare API failed, falling back to --deepen=${deepenDepth}`);
|
||||
}
|
||||
// deepen after both branches are fetched so the merge base is reachable from both sides
|
||||
if (deepenDepth) {
|
||||
log.debug(`» deepening by ${deepenDepth} to reach merge base...`);
|
||||
await $git("fetch", [`--deepen=${deepenDepth}`, "--no-tags", "origin"], {
|
||||
token: gitToken,
|
||||
});
|
||||
await $git("fetch", [`--deepen=${deepenDepth}`, "--no-tags", "origin"], { token: gitToken });
|
||||
}
|
||||
}
|
||||
|
||||
// configure push remote for this branch
|
||||
// NOTE: This always runs regardless of alreadyOnBranch, because setupGit doesn't configure
|
||||
// fork remotes. This ensures fork PRs can push even when checkout_pr is called after setupGit.
|
||||
if (isFork) {
|
||||
const remoteName = `pr-${pr.number}`;
|
||||
// SECURITY: fork URL without token - auth is injected via GIT_ASKPASS in $git()
|
||||
const forkUrl = `https://github.com/${pr.headRepoFullName}.git`;
|
||||
|
||||
// add fork as a named remote (suppress logging to avoid "error: remote already exists" spam)
|
||||
try {
|
||||
$("git", ["remote", "add", remoteName, forkUrl], { log: false });
|
||||
log.debug(`» added remote '${remoteName}' for fork ${pr.headRepoFullName}`);
|
||||
} catch {
|
||||
// remote already exists, update its URL
|
||||
$("git", ["remote", "set-url", remoteName, forkUrl], { log: false });
|
||||
log.debug(`» updated remote '${remoteName}' for fork ${pr.headRepoFullName}`);
|
||||
}
|
||||
|
||||
// set branch push config so `git push` knows where to push
|
||||
const giteaUrl = (process.env.GITEA_URL ?? "https://git.shockvpn.com").replace(/\/$/, "");
|
||||
const forkUrl = `${giteaUrl}/${pr.headRepoFullName}.git`;
|
||||
try { $("git", ["remote", "add", remoteName, forkUrl], { log: false }); }
|
||||
catch { $("git", ["remote", "set-url", remoteName, forkUrl], { log: false }); }
|
||||
$("git", ["config", `branch.${localBranch}.pushRemote`, remoteName], { log: false });
|
||||
// set merge ref so git knows the remote branch name (may differ from local)
|
||||
$("git", ["config", `branch.${localBranch}.merge`, `refs/heads/${pr.headRef}`], { log: false });
|
||||
log.debug(`» configured branch '${localBranch}' to push to '${remoteName}/${pr.headRef}'`);
|
||||
|
||||
// warn if maintainer can't modify (push will likely fail)
|
||||
if (!pr.maintainerCanModify) {
|
||||
log.warning(
|
||||
`» fork PR has maintainer_can_modify=false - push operations will fail. ` +
|
||||
`ask the PR author to enable "Allow edits from maintainers" or the fork may be owned by an organization.`
|
||||
);
|
||||
}
|
||||
if (!pr.maintainerCanModify) log.warning(`» fork PR has maintainer_can_modify=false — push will likely fail.`);
|
||||
toolState.pushUrl = forkUrl;
|
||||
} else {
|
||||
// for same-repo PRs, push to origin
|
||||
$("git", ["config", `branch.${localBranch}.pushRemote`, "origin"], { log: false });
|
||||
$("git", ["config", `branch.${localBranch}.merge`, `refs/heads/${pr.headRef}`], { log: false });
|
||||
}
|
||||
|
||||
// update toolState
|
||||
toolState.issueNumber = pr.number;
|
||||
if (isFork) {
|
||||
toolState.pushUrl = `https://github.com/${pr.headRepoFullName}.git`;
|
||||
}
|
||||
toolState.pushDest = { remoteName: isFork ? `pr-${pr.number}` : "origin", remoteBranch: pr.headRef, localBranch };
|
||||
|
||||
// store push destination so push_branch can use it directly
|
||||
// git config is the primary mechanism, but toolState serves as a reliable fallback
|
||||
// in case git config reads fail in certain environments
|
||||
toolState.pushDest = {
|
||||
remoteName: isFork ? `pr-${pr.number}` : "origin",
|
||||
remoteBranch: pr.headRef,
|
||||
localBranch,
|
||||
};
|
||||
|
||||
// execute post-checkout lifecycle hook. soft-fail: surface the warning
|
||||
// to the agent via the tool response instead of throwing, so a flaky or
|
||||
// slightly-broken hook doesn't block checkout entirely.
|
||||
const postCheckoutHook = await executeLifecycleHook({
|
||||
event: "post-checkout",
|
||||
script: params.postCheckoutScript,
|
||||
@@ -604,54 +344,42 @@ export async function checkoutPrBranch(
|
||||
return { hookWarning: postCheckoutHook.warning };
|
||||
}
|
||||
|
||||
/**
|
||||
* dedupes concurrent `checkout_pr` calls for the same PR. agents (notably
|
||||
* Sonnet/Claude) occasionally emit duplicate parallel tool_use blocks for the
|
||||
* same args in one turn; without this, both invocations race
|
||||
* `checkoutPrBranch` against the same `.git/shallow.lock` and one fails with
|
||||
* `File exists` (issue #642). cleared in `finally` so subsequent same-PR
|
||||
* calls re-do the work normally.
|
||||
*/
|
||||
const inFlightCheckouts = new Map<number, Promise<CheckoutPrResult>>();
|
||||
|
||||
type InitialHead = NonNullable<ToolContext["toolState"]["initialHead"]>;
|
||||
|
||||
function headsEqual(a: InitialHead, b: InitialHead): boolean {
|
||||
if (a.kind === "branch" && b.kind === "branch") return a.name === b.name;
|
||||
if (a.kind === "detached" && b.kind === "detached") return a.sha === b.sha;
|
||||
return false;
|
||||
}
|
||||
|
||||
function describeHead(h: InitialHead): string {
|
||||
if (h.kind === "branch") return `branch \`${h.name}\``;
|
||||
return `detached HEAD \`${h.sha}\``;
|
||||
return h.kind === "branch" ? `branch \`${h.name}\`` : `detached HEAD \`${h.sha}\``;
|
||||
}
|
||||
|
||||
export function CheckoutPrTool(ctx: ToolContext) {
|
||||
const runCheckout = async (pull_number: number): Promise<CheckoutPrResult> => {
|
||||
const prResponse = await ctx.octokit.rest.pulls.get({
|
||||
const prResult = await ctx.gitea.rest.repository.repoGetPullRequest({
|
||||
owner: ctx.repo.owner,
|
||||
repo: ctx.repo.name,
|
||||
pull_number,
|
||||
index: pull_number,
|
||||
});
|
||||
const prData = prResult.data;
|
||||
|
||||
const headRepo = prResponse.data.head.repo;
|
||||
if (!headRepo) {
|
||||
throw new Error(`PR #${pull_number} source repository was deleted`);
|
||||
}
|
||||
const headRepo = prData.head?.repo;
|
||||
if (!headRepo) throw new Error(`PR #${pull_number} source repository was deleted`);
|
||||
|
||||
const pr: PrData = {
|
||||
number: pull_number,
|
||||
headSha: prResponse.data.head.sha,
|
||||
headRef: prResponse.data.head.ref,
|
||||
headRepoFullName: headRepo.full_name,
|
||||
baseRef: prResponse.data.base.ref,
|
||||
baseRepoFullName: prResponse.data.base.repo.full_name,
|
||||
maintainerCanModify: prResponse.data.maintainer_can_modify,
|
||||
headSha: prData.head?.sha ?? "",
|
||||
headRef: prData.head?.ref ?? "",
|
||||
headRepoFullName: headRepo.full_name ?? "",
|
||||
baseRef: prData.base?.ref ?? "",
|
||||
baseRepoFullName: prData.base?.repo?.full_name ?? "",
|
||||
maintainerCanModify: prData.allow_maintainer_edit ?? false,
|
||||
};
|
||||
|
||||
const checkoutResult = await checkoutPrBranch(pr, {
|
||||
octokit: ctx.octokit,
|
||||
gitea: ctx.gitea,
|
||||
owner: ctx.repo.owner,
|
||||
name: ctx.repo.name,
|
||||
gitToken: ctx.gitToken,
|
||||
@@ -661,16 +389,11 @@ export function CheckoutPrTool(ctx: ToolContext) {
|
||||
beforeSha: ctx.toolState.beforeSha,
|
||||
});
|
||||
|
||||
const tempDir = process.env.PULLFROG_TEMP_DIR;
|
||||
if (!tempDir) {
|
||||
throw new Error(
|
||||
"PULLFROG_TEMP_DIR not set - checkout_pr must run in pullfrog action context"
|
||||
);
|
||||
}
|
||||
const tempDir = process.env.SHOCKBOT_TEMP_DIR;
|
||||
if (!tempDir) throw new Error("SHOCKBOT_TEMP_DIR not set");
|
||||
|
||||
const headShort = ctx.toolState.checkoutSha!.slice(0, 7);
|
||||
|
||||
// compute incremental diff if we have a beforeSha to compare against
|
||||
let incrementalDiffPath: string | undefined;
|
||||
if (ctx.toolState.beforeSha && ctx.toolState.checkoutSha) {
|
||||
const beforeShort = ctx.toolState.beforeSha.slice(0, 7);
|
||||
@@ -680,126 +403,75 @@ export function CheckoutPrTool(ctx: ToolContext) {
|
||||
headSha: ctx.toolState.checkoutSha,
|
||||
});
|
||||
if (incremental) {
|
||||
incrementalDiffPath = join(
|
||||
tempDir,
|
||||
`pr-${pull_number}-${beforeShort}-${headShort}-incremental.diff`
|
||||
);
|
||||
incrementalDiffPath = join(tempDir, `pr-${pull_number}-${beforeShort}-${headShort}-incremental.diff`);
|
||||
writeFileSync(incrementalDiffPath, incremental);
|
||||
log.info(
|
||||
`» incremental diff computed (${incremental.length} bytes) → ${incrementalDiffPath}`
|
||||
);
|
||||
log.info(`» incremental diff computed → ${incrementalDiffPath}`);
|
||||
}
|
||||
}
|
||||
|
||||
// fetch PR files and format with line numbers
|
||||
const formatResult = await fetchAndFormatPrDiff(ctx, pull_number);
|
||||
const diffPreview = formatResult.content.split("\n").slice(0, 100).join("\n");
|
||||
log.debug(`formatted diff preview (first 100 lines):\n${diffPreview}`);
|
||||
const diffPath = join(tempDir, `pr-${pull_number}-${headShort}.diff`);
|
||||
writeFileSync(diffPath, formatResult.content);
|
||||
log.debug(`wrote diff to ${diffPath} (${formatResult.content.length} bytes)`);
|
||||
|
||||
ctx.toolState.diffCoverage = createDiffCoverageState({
|
||||
diffPath,
|
||||
totalLines: countLines({ content: formatResult.content }),
|
||||
toc: formatResult.toc,
|
||||
previous: ctx.toolState.diffCoverage,
|
||||
});
|
||||
log.debug(
|
||||
`» diff coverage initialized: diffPath=${diffPath}, totalLines=${ctx.toolState.diffCoverage.totalLines}, tocEntries=${ctx.toolState.diffCoverage.tocEntries.length}`
|
||||
);
|
||||
|
||||
// cache commentable-lines snapshot so review-time validation matches what
|
||||
// GitHub will anchor to (commit_id=checkoutSha), even if the PR is updated
|
||||
// between checkout and review.
|
||||
const cached = new Map<string, ReturnType<typeof commentableLinesForFile>>();
|
||||
for (const file of formatResult.files) {
|
||||
cached.set(file.filename, commentableLinesForFile(file.patch));
|
||||
if (file.filename) cached.set(file.filename, commentableLinesForFile(file.patch));
|
||||
}
|
||||
ctx.toolState.commentableLinesByFile = cached;
|
||||
ctx.toolState.commentableLinesPullNumber = pull_number;
|
||||
ctx.toolState.commentableLinesCheckoutSha = ctx.toolState.checkoutSha;
|
||||
|
||||
const incrementalInstructions = incrementalDiffPath
|
||||
? ` IMPORTANT: incrementalDiffPath contains ONLY the changes since the last reviewed version ` +
|
||||
`(computed via range-diff). you MUST read incrementalDiffPath FIRST to understand what changed, ` +
|
||||
`then use diffPath for full PR context. do NOT skip the incremental diff.`
|
||||
: "";
|
||||
|
||||
// commit metadata relative to the PR base (e.g. main). use origin/<base>
|
||||
// because the local base ref may not exist after a shallow fetch. cap
|
||||
// the log so a PR with thousands of commits doesn't blow up the tool
|
||||
// response. if the base ref can't be resolved (e.g. shallow fetch that
|
||||
// didn't pull down origin/<base>), degrade gracefully rather than
|
||||
// failing the whole checkout_pr call over metadata.
|
||||
const COMMIT_LOG_MAX = 200;
|
||||
const baseRange = `origin/${pr.baseRef}..HEAD`;
|
||||
let commitCount = 0;
|
||||
let commitLog = "";
|
||||
let commitLogUnavailable = false;
|
||||
try {
|
||||
commitCount = parseInt(
|
||||
$("git", ["rev-list", "--count", baseRange], { log: false }).trim() || "0",
|
||||
10
|
||||
);
|
||||
commitLog = $("git", ["log", "--oneline", `--max-count=${COMMIT_LOG_MAX}`, baseRange], {
|
||||
log: false,
|
||||
});
|
||||
} catch (err) {
|
||||
commitCount = parseInt($("git", ["rev-list", "--count", baseRange], { log: false }).trim() || "0", 10);
|
||||
commitLog = $("git", ["log", "--oneline", `--max-count=${COMMIT_LOG_MAX}`, baseRange], { log: false });
|
||||
} catch {
|
||||
commitLogUnavailable = true;
|
||||
log.debug(
|
||||
`» unable to compute commit metadata for ${baseRange}: ${err instanceof Error ? err.message : String(err)}`
|
||||
);
|
||||
}
|
||||
const commitLogTruncated = commitCount > COMMIT_LOG_MAX;
|
||||
|
||||
const hookWarningInstructions = checkoutResult.hookWarning
|
||||
? ` HOOK WARNING: the post-checkout lifecycle hook reported a non-fatal failure (see hookWarning). ` +
|
||||
`decide whether to retry based on the guidance in that field before proceeding.`
|
||||
: "";
|
||||
|
||||
const commitLogInstructions = commitLogUnavailable
|
||||
? ` NOTE: commit metadata is partial (base ref unreachable, likely a shallow fetch). ` +
|
||||
`commitCount/commitLog may be 0/empty or incomplete; treat them as "unknown" rather than "no commits", ` +
|
||||
`and use \`git log\` directly if you need the full history.`
|
||||
: commitLogTruncated
|
||||
? ` NOTE: commitLog was capped at ${COMMIT_LOG_MAX} entries out of ${commitCount} commits; ` +
|
||||
`use \`git log\` directly if you need the full history.`
|
||||
: "";
|
||||
|
||||
return {
|
||||
success: true,
|
||||
number: prResponse.data.number,
|
||||
title: prResponse.data.title,
|
||||
body: prResponse.data.body,
|
||||
number: prData.number!,
|
||||
title: prData.title ?? "",
|
||||
body: prData.body ?? null,
|
||||
base: pr.baseRef,
|
||||
localBranch: `pr-${pull_number}`,
|
||||
remoteBranch: `refs/heads/${pr.headRef}`,
|
||||
isFork: pr.headRepoFullName !== pr.baseRepoFullName,
|
||||
maintainerCanModify: pr.maintainerCanModify,
|
||||
url: prResponse.data.html_url,
|
||||
url: prData.html_url ?? "",
|
||||
headRepo: pr.headRepoFullName,
|
||||
diffPath,
|
||||
incrementalDiffPath,
|
||||
toc: formatResult.toc,
|
||||
commitCount,
|
||||
commitLog,
|
||||
commitLogTruncated,
|
||||
commitLogTruncated: commitCount > COMMIT_LOG_MAX,
|
||||
commitLogUnavailable,
|
||||
hookWarning: checkoutResult.hookWarning,
|
||||
instructions:
|
||||
`the diff file at diffPath contains a table of contents (TOC) at the top listing every changed file with its line range. ` +
|
||||
`use the TOC line ranges as your checklist and read specific files from the diff instead of reading the entire file. ` +
|
||||
`for example, if the TOC says "src/foo.ts → lines 5-42", read lines 5-42 from diffPath to see that file's changes. ` +
|
||||
`review files selectively based on relevance rather than reading everything sequentially. ` +
|
||||
`to inspect the PR's changed files, use diffPath — do NOT run \`git diff <base>..<head>\` to re-derive what's already in diffPath. the formatted diff with line numbers is authoritative. ` +
|
||||
`\`git log\` and \`git diff --stat\` are fine for commit-range overview, and \`git diff\` / \`git diff --cached\` are fine for inspecting *your own* uncommitted changes — but PR review content MUST come from diffPath. ` +
|
||||
`before your review is submitted, a one-time coverage pre-flight may error listing unread TOC regions. ` +
|
||||
`retry the same create_pull_request_review call to proceed — optionally after reading the listed ranges. the pre-flight will not block again this session. ` +
|
||||
`the local branch is 'localBranch' (pr-{number}), not the remote branch name. ` +
|
||||
`when pushing, omit branchName to use the current branch. do not use remoteBranch as a local branch name.` +
|
||||
incrementalInstructions +
|
||||
hookWarningInstructions +
|
||||
commitLogInstructions,
|
||||
`the diff file at diffPath contains a table of contents (TOC) listing every changed file with its line range. ` +
|
||||
`use the TOC line ranges as your checklist and read specific files from the diff. ` +
|
||||
`for example, if the TOC says "src/foo.ts → lines 5-42", read lines 5-42 from diffPath. ` +
|
||||
`review files selectively based on relevance. ` +
|
||||
`to inspect the PR's changed files, use diffPath — do NOT run git diff commands. ` +
|
||||
(incrementalDiffPath
|
||||
? ` IMPORTANT: read incrementalDiffPath FIRST to understand what changed since last review, then use diffPath for full context.`
|
||||
: "") +
|
||||
(checkoutResult.hookWarning ? ` HOOK WARNING: the post-checkout hook reported a non-fatal failure.` : "") +
|
||||
(commitLogUnavailable ? ` NOTE: commit metadata is partial (shallow fetch).` : commitCount > COMMIT_LOG_MAX ? ` NOTE: commitLog was capped at ${COMMIT_LOG_MAX} entries.` : ""),
|
||||
} satisfies CheckoutPrResult;
|
||||
};
|
||||
|
||||
@@ -807,12 +479,8 @@ export function CheckoutPrTool(ctx: ToolContext) {
|
||||
name: "checkout_pr",
|
||||
timeoutMs: 600_000,
|
||||
description:
|
||||
"Checkout a pull request branch locally. This fetches the PR branch and sets up push configuration for fork PRs. " +
|
||||
"Returns diffPath pointing to the formatted diff file. " +
|
||||
"Example: `checkout_pr({ pull_number: 1234 })`. " +
|
||||
"Large repos can take several minutes — wait for the call to finish; do not treat a slow response as failure. " +
|
||||
"If you see `MCP error -32001: Request timed out`, retry the same call without touching git lock files first — that error is a client-side abort. " +
|
||||
"If the retry then reports `.git/shallow.lock: File exists` or `.git/index.lock: File exists`, remove those lock files via the shell tool and retry again.",
|
||||
"Checkout a pull request branch locally. Returns diffPath pointing to the formatted diff file. " +
|
||||
"Example: `checkout_pr({ pull_number: 1234 })`. Large repos can take several minutes.",
|
||||
parameters: CheckoutPr,
|
||||
execute: execute(async ({ pull_number }) => {
|
||||
const inFlight = inFlightCheckouts.get(pull_number);
|
||||
@@ -821,30 +489,14 @@ export function CheckoutPrTool(ctx: ToolContext) {
|
||||
return inFlight;
|
||||
}
|
||||
|
||||
// unconditional refusal: any dirty working tree blocks checkout_pr, even
|
||||
// when HEAD is already on pr-N. no stashing, no live-HEAD escape hatch.
|
||||
// shared-cwd subagents made "carry edits along" semantics dangerous
|
||||
// (zed-industries/cloud, 2026-05-18) — forcing commit/discard before
|
||||
// any PR-context op eliminates the entire carry-forward failure class.
|
||||
const dirty = $("git", ["status", "--porcelain"], { log: false }).trim();
|
||||
if (dirty) {
|
||||
throw new Error(
|
||||
`cannot checkout PR #${pull_number} while the working tree has uncommitted changes. ` +
|
||||
`commit (then push if needed), or discard with \`git restore --staged --worktree .\` / \`git clean -fd\` before retrying. ` +
|
||||
`this refusal is unconditional — even re-checking-out the PR you're already on is refused, ` +
|
||||
`because shared-working-tree subagents make carry-forward edits unsafe. dirty paths:\n${dirty}`
|
||||
`commit or discard with \`git restore --staged --worktree .\` / \`git clean -fd\` before retrying.\n${dirty}`
|
||||
);
|
||||
}
|
||||
|
||||
// initial-branch invariant: the only sanctioned HEAD positions for a
|
||||
// checkout_pr call are (a) the run-entry HEAD captured by setupGit, or
|
||||
// (b) `pr-${pull_number}` for idempotent same-PR re-checkout (e.g.
|
||||
// re-fetch after the PR head moved). anything else means a subagent
|
||||
// silently parked HEAD on another PR, which is the zed-industries/cloud
|
||||
// (2026-05-18) cross-PR clobber shape. uses the same live probe (not
|
||||
// toolState.issueNumber, poisonable per the PR #796 review) and
|
||||
// discriminates branch vs detached so detached-entry runs don't get a
|
||||
// trivial "any future detached state matches" carve-out.
|
||||
const initialHead = ctx.toolState.initialHead;
|
||||
if (initialHead) {
|
||||
const currentHead = captureInitialHead(process.cwd());
|
||||
@@ -852,30 +504,18 @@ export function CheckoutPrTool(ctx: ToolContext) {
|
||||
const onTarget = currentHead.kind === "branch" && currentHead.name === targetBranch;
|
||||
const onInitial = headsEqual(currentHead, initialHead);
|
||||
if (!onTarget && !onInitial) {
|
||||
const recoverCmd =
|
||||
initialHead.kind === "branch"
|
||||
? `git checkout ${initialHead.name}`
|
||||
: `git checkout ${initialHead.sha}`;
|
||||
const recoverCmd = initialHead.kind === "branch" ? `git checkout ${initialHead.name}` : `git checkout ${initialHead.sha}`;
|
||||
throw new Error(
|
||||
`cannot checkout PR #${pull_number} from ${describeHead(currentHead)}. ` +
|
||||
`the only sanctioned HEAD positions for checkout_pr are the run-entry HEAD ` +
|
||||
`(${describeHead(initialHead)}) or the target PR's branch (\`${targetBranch}\`, idempotent re-checkout). ` +
|
||||
`recover with \`${recoverCmd}\` first — if that would carry uncommitted ` +
|
||||
`work along, commit or discard it (\`git restore --staged --worktree .\` / \`git clean -fd\`) before switching. ` +
|
||||
`routing around this via the \`git\` tool's \`checkout\`/\`switch\` subcommands is not sanctioned: ` +
|
||||
`this guard exists to prevent the shared-working-tree cross-PR clobber pattern from the ` +
|
||||
`zed-industries/cloud (2026-05-18) incident.`
|
||||
`recover with \`${recoverCmd}\` first.`
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
const promise = runCheckout(pull_number);
|
||||
inFlightCheckouts.set(pull_number, promise);
|
||||
try {
|
||||
return await promise;
|
||||
} finally {
|
||||
inFlightCheckouts.delete(pull_number);
|
||||
}
|
||||
try { return await promise; }
|
||||
finally { inFlightCheckouts.delete(pull_number); }
|
||||
}),
|
||||
});
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user