pr-shepherd 0.41.0 → 0.43.0

package/bin/commands/suggestion-patch-item.mjs

@@ -0,0 +1,106 @@
+import { relative, resolve } from "node:path";
+import { getEffectiveCwd } from "../execution-context.mjs";
+import { EXIT, ShepherdError } from "../exit-codes.mjs";
+import { buildPrShepherdCommand } from "../cli/runner.mjs";
+import { parseSuggestion, isCommittableSuggestion } from "../suggestions/parse.mjs";
+import { buildUnifiedDiff } from "../suggestions/patch.mjs";
+import { getUnsafeSuggestionRangeReason } from "../suggestions/range.mjs";
+const SINGLE_QUOTE_ESCAPE = String.raw `'\''`;
+export function validateSuggestionThread(thread, request) {
+    if (!thread)
+        unavailable(`Thread ${request.threadId} not found on PR.`);
+    if (thread.isResolved)
+        unavailable(`Thread ${request.threadId} is already resolved.`);
+    if (thread.isOutdated)
+        unavailable(`Thread ${request.threadId} is outdated.`);
+    if (thread.isMinimized)
+        unavailable(`Thread ${request.threadId} is minimized.`);
+    if (!thread.path || thread.line === null) {
+        unavailable(`Thread ${request.threadId} has no file/line anchor.`);
+    }
+    ensureSafePath(thread.path);
+    return thread;
+}
+export function buildSuggestionPatchItem({ thread, request, originalContent, }) {
+    const parsed = parseSuggestion(thread.body);
+    if (!parsed)
+        unavailable(`Thread ${request.threadId} has no suggestion block in the comment body.`);
+    if (!isCommittableSuggestion(parsed)) {
+        unavailable(`Thread ${request.threadId}'s suggestion body contains nested suggestion fencing or unbalanced ` +
+            `3+ backtick fences — refusing to apply (could silently truncate).`);
+    }
+    const startLine = thread.startLine ?? thread.line;
+    const endLine = thread.line;
+    const unsafeRangeReason = getUnsafeSuggestionRangeReason({
+        originalContent,
+        startLine,
+        endLine,
+        replacementLines: parsed.lines,
+    });
+    if (unsafeRangeReason) {
+        const range = startLine === endLine ? `${startLine}` : `${startLine}-${endLine}`;
+        unavailable(`Thread ${request.threadId}'s suggestion does not safely fit GitHub's anchored range ` +
+            `${thread.path}:${range}: ${unsafeRangeReason} Refusing to build a patch; inspect the ` +
+            `surrounding source and reviewer intent, then apply the change manually.`);
+    }
+    const coAuthor = `Co-authored-by: ${thread.author} <${thread.author}@users.noreply.github.com>`;
+    return {
+        threadId: request.threadId,
+        path: thread.path,
+        startLine,
+        endLine,
+        author: thread.author,
+        patch: buildUnifiedDiff({
+            path: thread.path,
+            originalContent,
+            startLine,
+            endLine,
+            replacementLines: parsed.lines,
+        }),
+        commitMessage: request.message,
+        commitBody: request.description ? `${request.description}\n\n${coAuthor}` : coAuthor,
+        filesToStage: [thread.path],
+    };
+}
+export function buildSingularInstructions(patch, prNumber) {
+    const range = patch.startLine === patch.endLine
+        ? `line ${patch.startLine}`
+        : `lines ${patch.startLine}–${patch.endLine}`;
+    const resolveCommand = buildPrShepherdCommand([
+        "apply",
+        "review",
+        String(prNumber),
+        "--resolve-thread-ids",
+        patch.threadId,
+    ]).text;
+    return [
+        `Apply the patch to \`${patch.path}\`: run \`git apply\` with the diff shown above, or edit the file directly using the line range (${range}).`,
+        `Stage the file: \`git add -- ${quotePath(patch.path)}\``,
+        `Commit: \`${buildCommitCommand(patch)}\``,
+        `Resolve the thread on GitHub: \`${resolveCommand}\``,
+        `Push when ready: \`git push\` (or \`git push --force-with-lease\` after rebasing).`,
+    ];
+}
+export function buildCommitCommand(patch) {
+    return [
+        "git commit",
+        `-m ${shellQuote(patch.commitMessage)}`,
+        ...patch.commitBody.split("\n\n").map((part) => `-m ${shellQuote(part)}`),
+    ].join(" ");
+}
+export function quotePath(path) {
+    return shellQuote(path);
+}
+function shellQuote(value) {
+    return "'" + value.replaceAll("'", SINGLE_QUOTE_ESCAPE) + "'";
+}
+function ensureSafePath(path) {
+    const cwd = getEffectiveCwd();
+    const rel = relative(cwd, resolve(cwd, path));
+    if (rel.startsWith("..") || rel === "") {
+        unavailable(`Thread path escapes the working tree: ${path}.`);
+    }
+}
+function unavailable(message) {
+    throw new ShepherdError(message, EXIT.UNAVAILABLE);
+}

package/bin/commands/suggestion-patches.d.mts

@@ -0,0 +1,6 @@
+import type { BuildSuggestionPatchesResult, GlobalOptions } from "../types.mts";
+import { type SuggestionPatchRequest } from "./suggestion-patch-item.mts";
+export interface SuggestionPatchesOptions extends GlobalOptions {
+    suggestions: readonly SuggestionPatchRequest[];
+}
+export declare function runSuggestionPatches(opts: SuggestionPatchesOptions): Promise<BuildSuggestionPatchesResult>;

package/bin/commands/suggestion-patches.mjs

@@ -0,0 +1,108 @@
+import { getRepoInfo, getCurrentPrNumber, getCurrentBranch } from "../github/client.mjs";
+import { fetchSuggestionThreads } from "../github/suggestion-thread.mjs";
+import { EXIT, ShepherdError } from "../exit-codes.mjs";
+import { buildCommitCommand, buildSuggestionPatchItem, quotePath, validateSuggestionThread, } from "./suggestion-patch-item.mjs";
+import { checkPatchesApply, getLocalHeadSha, getPathsStatus, isAncestor, readPrHeadFile, } from "./suggestion-patch-git.mjs";
+export async function runSuggestionPatches(opts) {
+    validateRequests(opts.suggestions);
+    const repo = await getRepoInfo();
+    const prNumber = opts.prNumber ?? (await getCurrentPrNumber());
+    if (prNumber === null) {
+        throw new ShepherdError("No open PR found for current branch. Pass a PR number explicitly.", EXIT.UNAVAILABLE);
+    }
+    const [currentBranch, localHeadSha, data] = await Promise.all([
+        getCurrentBranch(),
+        getLocalHeadSha(),
+        fetchSuggestionThreads(prNumber, repo, opts.suggestions.map((suggestion) => suggestion.threadId)),
+    ]);
+    await validateHead({ currentBranch, localHeadSha, prNumber, data });
+    const threads = data.threads.map((thread, index) => validateSuggestionThread(thread, opts.suggestions[index]));
+    const paths = [...new Set(threads.map((thread) => thread.path))];
+    const status = await getPathsStatus(paths);
+    if (status !== "") {
+        throw new ShepherdError(`Suggestion target files have uncommitted changes:\n${status}\n` +
+            "Commit or stash them before running build-suggestion-patches.", EXIT.UNAVAILABLE);
+    }
+    const originals = await readOriginals(data.headRefOid, paths);
+    const patches = threads.map((thread, index) => buildSuggestionPatchItem({
+        thread,
+        request: opts.suggestions[index],
+        originalContent: originals.get(thread.path),
+    }));
+    try {
+        await checkPatchesApply(patches.map((patch) => patch.patch));
+    }
+    catch (error) {
+        throw new ShepherdError(`Ordered suggestion patches built from PR head ${data.headRefOid} do not apply to ` +
+            `local HEAD ${localHeadSha}: ${errorMessage(error)} No patches were returned; inspect the ` +
+            "current source and reviewer intent.", EXIT.UNAVAILABLE);
+    }
+    return {
+        pr: prNumber,
+        repo: `${repo.owner}/${repo.name}`,
+        patches,
+        postActionInstructions: buildBatchInstructions(patches),
+    };
+}
+function validateRequests(requests) {
+    if (requests.length === 0)
+        usage("At least one suggestion is required.");
+    const seen = new Set();
+    for (const request of requests) {
+        if (!request.threadId || request.threadId.trim() === "")
+            usage("Each --thread-id is required.");
+        if (!request.message || request.message.trim() === "") {
+            usage(`--message is required and must be non-empty for thread ${request.threadId}.`);
+        }
+        if (seen.has(request.threadId))
+            usage(`Duplicate thread ID: ${request.threadId}.`);
+        seen.add(request.threadId);
+    }
+}
+async function validateHead({ currentBranch, localHeadSha, prNumber, data, }) {
+    if (!data.headRepoWithOwner) {
+        throw new ShepherdError(`PR #${prNumber} head repository is unavailable (fork may have been deleted).`, EXIT.UNAVAILABLE);
+    }
+    if (currentBranch !== data.headRefName) {
+        throw new ShepherdError(`Current branch "${currentBranch}" does not match PR head branch "${data.headRefName}". ` +
+            `Check out "${data.headRefName}" before applying suggestions.`, EXIT.UNAVAILABLE);
+    }
+    if (localHeadSha === data.headRefOid)
+        return;
+    await ensureDescendant(data.headRefOid, localHeadSha, data.headRefName);
+}
+async function ensureDescendant(prHeadSha, localHeadSha, branch) {
+    if (await isAncestor(prHeadSha, localHeadSha))
+        return;
+    throw new ShepherdError(`Local HEAD ${localHeadSha} is not PR head ${prHeadSha} or its descendant. ` +
+        `Pull/rebase "${branch}" to the latest PR head and try again.`, EXIT.UNAVAILABLE);
+}
+async function readOriginals(headSha, paths) {
+    const entries = await Promise.all(paths.map(async (path) => {
+        try {
+            return [path, await readPrHeadFile(headSha, path)];
+        }
+        catch (error) {
+            throw new ShepherdError(`Could not read ${path} at PR head ${headSha}: ${errorMessage(error)}`, EXIT.UNAVAILABLE);
+        }
+    }));
+    return new Map(entries);
+}
+function buildBatchInstructions(patches) {
+    const patchInstructions = patches.flatMap((patch, index) => [
+        `Apply patch ${index + 1} to \`${patch.path}\` using \`git apply\`.`,
+        `Stage patch ${index + 1}: \`git add -- ${quotePath(patch.path)}\``,
+        `Commit patch ${index + 1}: \`${buildCommitCommand(patch)}\``,
+    ]);
+    return [
+        ...patchInstructions,
+        "Push once after every patch is committed: `git push` (or `git push --force-with-lease` after rebasing).",
+        `Then continue with the originating iterate output's \`apply review\` instructions for thread IDs: ${patches.map((patch) => patch.threadId).join(", ")}.`,
+    ];
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function usage(message) {
+    throw new ShepherdError(message, EXIT.USAGE);
+}

package/bin/config/load.d.mts

@@ -43,6 +43,10 @@ interface PrShepherdConfig {
     mergeStatus: {
         blockingReviewerLogins: string[];
     };
+    merge?: {
+        /** Options added to ordinary `gh pr merge` commands. Queue commands never use these. */
+        commandArgs: string[];
+    };
     actions: {
         autoMinimizeSuppressed: boolean;
         autoMarkReady: boolean;

package/bin/config/load.mjs

@@ -5,6 +5,7 @@ import { homedir } from "node:os";
 import { parse } from "yaml";
 import builtins from "../config.json" with { type: "json" };
 import { getEffectiveCwd } from "../execution-context.mjs";
+import { findMergeStrategies } from "./merge-command-args.mjs";
 const MINIMIZE_COMMENTS_POLICIES = ["all", "bots", "users", "none"];
 const RC_FILENAME = ".pr-shepherdrc.yml";
 /**
@@ -85,6 +86,35 @@ function parseNeverCancelRuns(value) {
     }
     return value;
 }
+const SHEPHERD_OWNED_MERGE_FLAGS = [
+    "--repo",
+    "-R",
+    "--auto",
+    "--disable-auto",
+    "--match-head-commit",
+    "--admin",
+    "--body-file",
+    "-F",
+    "--help",
+    "-h",
+];
+function parseMergeCommandArgs(value) {
+    if (!Array.isArray(value) || !value.every((item) => typeof item === "string")) {
+        throw new Error("Invalid config: merge.commandArgs must be an array of strings");
+    }
+    for (const arg of value) {
+        if (SHEPHERD_OWNED_MERGE_FLAGS.some((flag) => arg === flag ||
+            arg.startsWith(`${flag}=`) ||
+            (flag.startsWith("-") && !flag.startsWith("--") && arg.startsWith(flag)))) {
+            throw new Error(`Invalid config: merge.commandArgs cannot include Shepherd-owned ${arg}`);
+        }
+    }
+    const strategies = findMergeStrategies(value);
+    if (strategies.length > 1) {
+        throw new Error(`Invalid config: merge.commandArgs includes multiple merge strategies: ${strategies.join(", ")}`);
+    }
+    return strategies.length === 0 ? [...value, "--merge"] : [...value];
+}
 const KNOWN_CONFIG_KEYS = new Set([
     "classify",
     "botUsernames",
@@ -94,6 +124,7 @@ const KNOWN_CONFIG_KEYS = new Set([
     "resolve",
     "checks",
     "mergeStatus",
+    "merge",
     "actions",
 ]);
 const KNOWN_NESTED_KEYS = {
@@ -108,6 +139,7 @@ const KNOWN_NESTED_KEYS = {
     resolve: new Set(["shaPoll"]),
     checks: new Set(["ciTriggerEvents"]),
     mergeStatus: new Set(["blockingReviewerLogins"]),
+    merge: new Set(["commandArgs"]),
     actions: new Set([
         "autoMinimizeSuppressed",
         "autoMarkReady",
@@ -194,6 +226,8 @@ export function loadConfig() {
         config.botUsernames = parseBotUsernames(config.botUsernames);
         config.ignoreChecks = parseIgnoreChecks(config.ignoreChecks);
         config.actions.neverCancelRuns = parseNeverCancelRuns(config.actions.neverCancelRuns);
+        if (config.merge)
+            config.merge.commandArgs = parseMergeCommandArgs(config.merge.commandArgs);
         config.iterate.minimizeComments = parseMinimizeCommentsPolicy(config.iterate.minimizeComments);
         configCache.set(cwd, config);
         return config;

package/bin/config/merge-command-args.d.mts

@@ -0,0 +1,2 @@
+/** Return active merge strategies while validating compound strategy syntax. */
+export declare function findMergeStrategies(args: string[]): string[];

package/bin/config/merge-command-args.mjs

@@ -0,0 +1,44 @@
+const MERGE_STRATEGY_FLAGS = new Map([
+    ["--merge", "merge"],
+    ["-m", "merge"],
+    ["--squash", "squash"],
+    ["-s", "squash"],
+    ["--rebase", "rebase"],
+    ["-r", "rebase"],
+]);
+/** Return active merge strategies while validating compound strategy syntax. */
+export function findMergeStrategies(args) {
+    const strategies = [];
+    for (const arg of args) {
+        const exact = MERGE_STRATEGY_FLAGS.get(arg);
+        if (exact) {
+            strategies.push(exact);
+            continue;
+        }
+        const longAssignment = /^(--merge|--squash|--rebase)=(.*)$/.exec(arg);
+        const shortAssignment = /^(-[msr])=(.*)$/.exec(arg);
+        const assignment = longAssignment ?? shortAssignment;
+        if (assignment) {
+            if (assignment[2] !== "true" && assignment[2] !== "false") {
+                throw new Error(`Invalid config: merge.commandArgs strategy ${arg} must use true or false`);
+            }
+            if (assignment[2] === "true") {
+                strategies.push(MERGE_STRATEGY_FLAGS.get(assignment[1]));
+            }
+            continue;
+        }
+        const shortBundle = /^-([dmrs]{2,})$/.exec(arg);
+        if (shortBundle) {
+            for (const flag of shortBundle[1]) {
+                const strategy = MERGE_STRATEGY_FLAGS.get(`-${flag}`);
+                if (strategy)
+                    strategies.push(strategy);
+            }
+            continue;
+        }
+        if (/^-[dmrs].+/.test(arg)) {
+            throw new Error(`Invalid config: merge.commandArgs cannot safely parse compound short option ${arg}; use separate flags or long options`);
+        }
+    }
+    return strategies;
+}

package/bin/config.json

@@ -36,6 +36,9 @@
   "mergeStatus": {
     "blockingReviewerLogins": ["copilot"]
   },
+  "merge": {
+    "commandArgs": []
+  },
   "actions": {
     "autoMinimizeSuppressed": true,
     "autoMarkReady": true,

package/bin/exit-codes.d.mts

@@ -23,6 +23,8 @@ export declare const EXIT: Readonly<{
     readonly ESCALATE: 13;
     /** `cancel` + `closed` — PR closed without merging. */
     readonly CLOSED: 14;
+    /** Agent should run the emitted merge or queue command. */
+    readonly MERGE: 15;
     /** Bad/unknown flag, unknown subcommand, missing required arg, invalid duration. */
     readonly USAGE: 64;
     /** Malformed caller data: bad `--require-sha`, `PRRC_*` IDs, bad repo string. */

package/bin/exit-codes.mjs

@@ -22,6 +22,8 @@ export const EXIT = Object.freeze({
     ESCALATE: 13,
     /** `cancel` + `closed` — PR closed without merging. */
     CLOSED: 14,
+    /** Agent should run the emitted merge or queue command. */
+    MERGE: 15,
     /** Bad/unknown flag, unknown subcommand, missing required arg, invalid duration. */
     USAGE: 64,
     /** Malformed caller data: bad `--require-sha`, `PRRC_*` IDs, bad repo string. */
@@ -65,6 +67,8 @@ export function iterateResultToExitCode(result) {
             return EXIT.FIX_CODE;
         case "escalate":
             return EXIT.ESCALATE;
+        case "merge":
+            return EXIT.MERGE;
     }
 }
 export function errorToExitCode(err) {

package/bin/github/batch-parse-checks.d.mts

@@ -0,0 +1,3 @@
+import type { CheckRun } from "../types.mts";
+import type { RawContextNode } from "./batch-raw-types.mts";
+export declare function parseCheckNodes(nodes: Array<RawContextNode | null> | undefined, mergeCommitOid?: string): CheckRun[];

package/bin/github/batch-parse-checks.mjs

@@ -0,0 +1,29 @@
+import { mapCheckRunNode, mapStatusContextState, parseCreatedAt } from "./batch-parser-helpers.mjs";
+export function parseCheckNodes(nodes, mergeCommitOid) {
+    return (nodes ?? []).flatMap((node) => {
+        const scope = mergeCommitOid
+            ? { scope: "merge_group", commitOid: mergeCommitOid }
+            : {};
+        if (node?.__typename === "CheckRun")
+            return [{ ...mapCheckRunNode(node), ...scope }];
+        if (node?.__typename !== "StatusContext")
+            return [];
+        const { status, conclusion } = mapStatusContextState(node.state);
+        const summary = node.description?.trim() || undefined;
+        const createdAtUnix = node.createdAt ? parseCreatedAt(node.createdAt) : undefined;
+        return [
+            {
+                name: node.context,
+                status,
+                conclusion,
+                source: "status_context",
+                detailsUrl: node.targetUrl ?? "",
+                event: null,
+                runId: null,
+                ...scope,
+                ...(createdAtUnix !== undefined && { createdAtUnix }),
+                ...(summary !== undefined && { summary }),
+            },
+        ];
+    });
+}

package/bin/github/batch-parsers-rules.d.mts

@@ -1,6 +1,8 @@
-import type { BranchRules, MergeQueueEntryStatus, StackStatus } from "../types.mts";
+import type { AutoMergeRequestStatus, BranchRules, MergeQueueEntryStatus, MergeQueueRemovalStatus, StackStatus } from "../types.mts";
 import type { RawBaseRef, RawPrMergeFields } from "./batch-raw-rules.mts";
 export declare const EMPTY_BRANCH_RULES: BranchRules;
 export declare function parseBranchRules(baseRef: RawBaseRef | null | undefined): BranchRules;
 export declare function parseMergeQueueEntry(raw: RawPrMergeFields["mergeQueueEntry"]): MergeQueueEntryStatus | null;
+export declare function parseAutoMergeRequest(raw: RawPrMergeFields["autoMergeRequest"]): AutoMergeRequestStatus | null;
+export declare function parseLatestMergeQueueRemoval(raw: RawPrMergeFields): MergeQueueRemovalStatus | null;
 export declare function parseStack(raw: RawPrMergeFields): StackStatus | null;

package/bin/github/batch-parsers-rules.mjs

@@ -32,8 +32,41 @@ export function parseMergeQueueEntry(raw) {
         position: raw.position,
         state: raw.state,
         estimatedTimeToMerge: raw.estimatedTimeToMerge,
+        ...(raw.headCommit?.oid && { headCommitOid: raw.headCommit.oid }),
+        ...(raw.enqueuedAt && { enqueuedAtUnix: parseUnix(raw.enqueuedAt) }),
+        ...(raw.enqueuer?.login && { enqueuer: raw.enqueuer.login }),
     };
 }
+export function parseAutoMergeRequest(raw) {
+    if (!raw)
+        return null;
+    return {
+        enabledAtUnix: parseUnix(raw.enabledAt),
+        mergeMethod: raw.mergeMethod,
+        ...(raw.enabledBy?.login && { enabledBy: raw.enabledBy.login }),
+    };
+}
+export function parseLatestMergeQueueRemoval(raw) {
+    const removal = raw.mergeQueueRemovals?.nodes[0];
+    if (!removal)
+        return null;
+    const lastAddedAt = raw.mergeQueueAdditions?.nodes[0]?.createdAt;
+    if (lastAddedAt && Date.parse(lastAddedAt) > Date.parse(removal.createdAt))
+        return null;
+    return {
+        reason: removal.reason,
+        createdAtUnix: parseUnix(removal.createdAt),
+        ...(removal.actor?.login && { actor: removal.actor.login }),
+        ...(removal.beforeCommit?.oid && { beforeCommitOid: removal.beforeCommit.oid }),
+        ...(removal.beforeCommit?.parents && {
+            beforeCommitParentOids: removal.beforeCommit.parents.nodes.map((parent) => parent.oid),
+        }),
+    };
+}
+function parseUnix(value) {
+    const ms = Date.parse(value);
+    return Number.isFinite(ms) ? Math.floor(ms / 1000) : 0;
+}
 export function parseStack(raw) {
     if (!raw.stack)
         return null;

package/bin/github/batch-parsers.mjs

@@ -1,7 +1,9 @@
-import { mapAuthorType, parseCreatedAt, mapStatusContextState, latestApprovedLogins, isReviewStale, mapCheckRunNode, } from "./batch-parser-helpers.mjs";
+import { mapAuthorType, parseCreatedAt, latestApprovedLogins, isReviewStale, } from "./batch-parser-helpers.mjs";
+import { parseCheckNodes } from "./batch-parse-checks.mjs";
+import { requireContextNodes } from "./batch-response.mjs";
 import { buildPrActivitySummary } from "./activity.mjs";
 import { parseBranchProtection } from "./branch-protection.mjs";
-import { parseBranchRules, parseMergeQueueEntry, parseStack } from "./batch-parsers-rules.mjs";
+import { parseAutoMergeRequest, parseBranchRules, parseLatestMergeQueueRemoval, parseMergeQueueEntry, parseStack, } from "./batch-parsers-rules.mjs";
 function parseReviewNode(r) {
     const base = {
         id: r.id,
@@ -86,30 +88,15 @@ export function parseRawPr(raw, rawThreadPages, rawCommentNodes, rawReviewNodes,
     const approvedReviews = rawApprovedReviewNodes
         .filter((r) => !r.isMinimized)
         .map((r) => parseReviewNode(r));
-    const checks = rawCheckNodes.flatMap((node) => {
-        if (node.__typename === "CheckRun") {
-            return [mapCheckRunNode(node)];
-        }
-        if (node.__typename === "StatusContext") {
-            const { status, conclusion } = mapStatusContextState(node.state);
-            const summary = node.description?.trim() || undefined;
-            const createdAtUnix = node.createdAt ? parseCreatedAt(node.createdAt) : undefined;
-            return [
-                {
-                    name: node.context,
-                    status,
-                    conclusion,
-                    source: "status_context",
-                    detailsUrl: node.targetUrl ?? "",
-                    event: null,
-                    runId: null,
-                    ...(createdAtUnix !== undefined && { createdAtUnix }),
-                    ...(summary !== undefined && { summary }),
-                },
-            ];
-        }
-        return [];
-    });
+    const checks = parseCheckNodes(rawCheckNodes);
+    const queueHead = raw.mergeQueueEntry?.headCommit;
+    const removedQueueHead = raw.mergeQueueRemovals?.nodes[0]?.beforeCommit;
+    const mergeQueueChecks = parseCheckNodes(queueHead?.statusCheckRollup
+        ? requireContextNodes(queueHead.statusCheckRollup.contexts.nodes)
+        : undefined, queueHead?.oid);
+    const removedMergeQueueChecks = parseCheckNodes(removedQueueHead?.statusCheckRollup
+        ? requireContextNodes(removedQueueHead.statusCheckRollup.contexts.nodes)
+        : undefined, removedQueueHead?.oid);
     return {
         nodeId: raw.id,
         number: raw.number,
@@ -135,6 +122,16 @@ export function parseRawPr(raw, rawThreadPages, rawCommentNodes, rawReviewNodes,
         isInMergeQueue: raw.isInMergeQueue ?? false,
         isMergeQueueEnabled: raw.isMergeQueueEnabled ?? false,
         mergeQueueEntry: parseMergeQueueEntry(raw.mergeQueueEntry),
+        autoMergeRequest: parseAutoMergeRequest(raw.autoMergeRequest),
+        latestMergeQueueRemoval: parseLatestMergeQueueRemoval(raw),
+        ...(mergeQueueChecks.length > 0 && { mergeQueueChecks }),
+        ...(queueHead?.statusCheckRollup?.contexts.pageInfo.hasNextPage && {
+            mergeQueueChecksIncomplete: true,
+        }),
+        ...(removedMergeQueueChecks.length > 0 && { removedMergeQueueChecks }),
+        ...(removedQueueHead?.statusCheckRollup?.contexts.pageInfo.hasNextPage && {
+            removedMergeQueueChecksIncomplete: true,
+        }),
         stack: parseStack(raw),
         activity: buildPrActivitySummary(raw, comments, reviewThreads, reviewSummaries, allChangesRequestedReviews, approvedReviews),
     };

package/bin/github/batch-raw-rules.d.mts

@@ -12,10 +12,49 @@ export interface RawBranchProtectionRule {
     requiresDeployments?: boolean;
     requiredDeploymentEnvironments?: string[] | null;
 }
+import type { RawContextNode } from "./batch-raw-types.mts";
+interface RawCheckCommit {
+    oid: string;
+    committedDate?: string;
+    parents?: {
+        nodes: Array<{
+            oid: string;
+        }>;
+    };
+    statusCheckRollup: {
+        contexts: {
+            pageInfo: {
+                hasNextPage: boolean;
+                endCursor: string | null;
+            };
+            nodes: Array<RawContextNode | null>;
+        };
+    } | null;
+}
 interface RawMergeQueueEntry {
     position: number;
     state: string;
     estimatedTimeToMerge: number | null;
+    headCommit?: RawCheckCommit | null;
+    enqueuedAt?: string;
+    enqueuer?: {
+        login: string;
+    } | null;
+}
+interface RawAutoMergeRequest {
+    enabledAt: string;
+    mergeMethod: string;
+    enabledBy?: {
+        login: string;
+    } | null;
+}
+interface RawMergeQueueRemoval {
+    reason: string | null;
+    actor?: {
+        login: string;
+    } | null;
+    createdAt: string;
+    beforeCommit?: RawCheckCommit | null;
 }
 interface RawStack {
     number: number;
@@ -50,6 +89,15 @@ export interface RawPrMergeFields {
     isInMergeQueue?: boolean;
     isMergeQueueEnabled?: boolean;
     mergeQueueEntry?: RawMergeQueueEntry | null;
+    autoMergeRequest?: RawAutoMergeRequest | null;
+    mergeQueueRemovals?: {
+        nodes: RawMergeQueueRemoval[];
+    } | null;
+    mergeQueueAdditions?: {
+        nodes: Array<{
+            createdAt: string;
+        }>;
+    } | null;
     stack?: RawStack | null;
     stackEntry?: {
         position: number;

package/bin/github/batch-raw-types.mjs

@@ -1,2 +1 @@
-// Private raw GraphQL response types for the batch PR query.
 export {};

package/bin/github/batch.mjs

@@ -6,6 +6,7 @@ import { parseCheckSuitesComplete, parseSuiteStartupFailures } from "./batch-par
 import { mergeStartupFailureChecks } from "../checks/startup-failures.mjs";
 import { paginateBatchConnections } from "./batch-page.mjs";
 import { requireRawPr } from "./batch-response.mjs";
+import { hydrateMergeQueueChecks } from "./merge-queue-checks.mjs";
 /**
  * Fetch all PR data needed for a `shepherd check` in one (or a few, if paginating) GraphQL requests.
  */
@@ -16,6 +17,7 @@ export async function fetchPrBatch(pr, repo, opts = {}) {
         pr,
     });
     const raw = requireRawPr(result.data, pr, repo);
+    await hydrateMergeQueueChecks(raw, repo);
     const paged = await paginateBatchConnections(pr, repo, raw, opts, result.rateLimit);
     const rawThreadPages = await hydrateThreadCommentPages(paged.threads);
     const data = parseRawPr(raw, rawThreadPages, paged.comments, paged.changesRequested, paged.reviewSummaries, paged.approvedReviews, paged.checks);