pr-shepherd 0.56.5 → 0.57.0

package/bin/github/merge-target-rules.mjs

@@ -1,38 +1,55 @@
+import { githubOperation } from "./transport.mjs";
+import { readRestBehind } from "./rest-check-read.mjs";
+import { readRestBranchRules } from "./rest-rules-read.mjs";
 import { EXIT, ShepherdError } from "../exit-codes.mjs";
 import { parseBranchRules } from "./batch-parsers-rules.mjs";
 import { graphqlWithRateLimit } from "./client.mjs";
 import { missingRepositoryError } from "./errors.mjs";
+import { cachedBaseBehind, storeBaseBehind, } from "./base-behind-cache.mjs";
 import { BASE_BEHIND_QUERY, REF_RULES_QUERY } from "./queries.mjs";
-import { readStackTopology } from "./stack-read.mjs";
+import { readStackTopology, verifiedBottomOpenLayer } from "./stack-read.mjs";
 /**
  * Required status contexts for the branch GitHub actually merges into.
- * A native stack uses the trunk ref, and `behindBy` is that trunk against the bottom open layer.
+ * A native stack uses the trunk ref, and `trunkBehindBy` compares that trunk against the bottom
+ * open layer. The trunk rules and the stack topology come from this tick's `BatchPr` when the
+ * context holds them; otherwise `RefRules` and `PollStackTopology` read them.
  */
 export async function loadMergeTargetStatus(input, context) {
     const trunk = input.stack?.baseRefName;
     if (!trunk)
         return { contexts: [...input.localContexts] };
-    let headRef = input.headRefName;
+    const repo = { owner: input.owner, name: input.name };
+    let headRef = input.headRefOid || input.headRefName;
     let stackBottomPr = input.pr;
     if (trunk !== input.baseRefName) {
-        const bottom = await bottomOpenLayer(input.pr, { owner: input.owner, name: input.name }, trunk, context);
-        headRef = bottom.headRefName;
+        const bottom = await bottomOpenLayer(input.pr, repo, context);
+        headRef = bottom.headRefOid;
         stackBottomPr = bottom.number;
     }
-    const loaded = await fetchRefRules(input.owner, input.name, `refs/heads/${trunk}`, headRef);
+    const embedded = context?.trunkRules(input.pr, repo, trunk);
+    if (embedded) {
+        return {
+            contexts: embedded.contexts,
+            trunkBehindBy: () => loadBaseBehindBy(input.owner, input.name, trunk, headRef, {
+                stateKey: { owner: input.owner, repo: input.name, pr: input.pr },
+                slot: "trunk-behind",
+                ...(embedded.tipOid && { baseTipOid: embedded.tipOid }),
+            }),
+            stackBottomPr,
+        };
+    }
+    const loaded = await loadRefRules(input.owner, input.name, `refs/heads/${trunk}`, headRef);
     return {
         contexts: loaded.contexts,
-        ...(loaded.behindBy > 0 && { trunkBehindBy: loaded.behindBy }),
+        trunkBehindBy: () => Promise.resolve(loaded.behindBy),
         stackBottomPr,
     };
 }
-async function bottomOpenLayer(pr, repo, trunk, context) {
+async function bottomOpenLayer(pr, repo, context) {
     const topology = await (context?.readStackTopology(pr, repo) ?? readStackTopology(pr, repo));
-    const bottom = topology.ordered.find((member) => member.state === "OPEN" && member.baseRefName === trunk);
-    if (!bottom) {
-        throw new ShepherdError(`Native stack for PR #${pr} has no open layer based on ${trunk}`, EXIT.TEMPFAIL);
-    }
-    return bottom;
+    // GitHub can retain a merged parent's branch as the lowest open layer's
+    // base. Stack order, rather than retargeting, determines the review target.
+    return verifiedBottomOpenLayer(topology.ordered, pr);
 }
 /**
  * Commits on the PR base that `headRef` does not contain.
@@ -41,37 +58,55 @@ async function bottomOpenLayer(pr, repo, trunk, context) {
  * `mergeStateStatus` stays `BLOCKED` when a conversation or an expected check
  * is also open, so this compare is the behind count that status hides.
  */
-export async function loadBaseBehindBy(owner, name, baseRefName, headRef) {
-    const qualifiedName = `refs/heads/${baseRefName}`;
-    const { data } = await graphqlWithRateLimit(BASE_BEHIND_QUERY, {
-        owner,
-        repo: name,
-        qualifiedName,
-        headRef,
-    });
-    if (!data.repository)
-        throw missingRepositoryError({ owner, name });
-    const ref = data.repository.ref;
-    if (!ref) {
-        throw new ShepherdError(`Branch ${qualifiedName} was not found in ${owner}/${name}`, EXIT.TEMPFAIL);
-    }
-    return ref.compare?.behindBy ?? 0;
+export async function loadBaseBehindBy(owner, name, baseRefName, headRef, cache) {
+    const cached = await cachedBaseBehind(cache, headRef);
+    if (cached !== undefined)
+        return cached;
+    return githubOperation("BaseBehind", async () => {
+        const qualifiedName = `refs/heads/${baseRefName}`;
+        const { data } = await graphqlWithRateLimit(BASE_BEHIND_QUERY, {
+            owner,
+            repo: name,
+            qualifiedName,
+            headRef,
+        });
+        if (!data.repository)
+            throw missingRepositoryError({ owner, name });
+        const ref = data.repository.ref;
+        if (!ref) {
+            throw new ShepherdError(`Branch ${qualifiedName} was not found in ${owner}/${name}`, EXIT.TEMPFAIL);
+        }
+        if (!ref.compare)
+            return 0;
+        await storeBaseBehind(cache, ref.target?.oid, headRef, ref.compare.behindBy);
+        return ref.compare.behindBy;
+    }, () => readRestBehind({ owner, name }, baseRefName, headRef));
 }
-async function fetchRefRules(owner, name, qualifiedName, headRef) {
-    const { data } = await graphqlWithRateLimit(REF_RULES_QUERY, {
-        owner,
-        repo: name,
-        qualifiedName,
-        headRef,
+export async function loadRefRules(owner, name, qualifiedName, headRef) {
+    return githubOperation("RefRules", async () => {
+        const { data } = await graphqlWithRateLimit(REF_RULES_QUERY, {
+            owner,
+            repo: name,
+            qualifiedName,
+            headRef,
+        });
+        if (!data.repository)
+            throw missingRepositoryError({ owner, name });
+        const ref = data.repository.ref;
+        if (!ref) {
+            throw new ShepherdError(`Branch ${qualifiedName} was not found in ${owner}/${name}`, EXIT.TEMPFAIL);
+        }
+        return {
+            contexts: parseBranchRules(ref).requiredStatusCheckContexts,
+            behindBy: ref.compare?.behindBy ?? 0,
+        };
+    }, async () => {
+        const rules = await readRestBranchRules({ owner, name }, qualifiedName.replace(/^refs\/heads\//, ""));
+        if (rules.unavailable.length > 0)
+            throw new ShepherdError(rules.unavailable.map((item) => item.reason).join("; "), EXIT.UNAVAILABLE);
+        return {
+            contexts: parseBranchRules(rules.baseRef).requiredStatusCheckContexts,
+            behindBy: await readRestBehind({ owner, name }, qualifiedName.replace(/^refs\/heads\//, ""), headRef),
+        };
     });
-    if (!data.repository)
-        throw missingRepositoryError({ owner, name });
-    const ref = data.repository.ref;
-    if (!ref) {
-        throw new ShepherdError(`Branch ${qualifiedName} was not found in ${owner}/${name}`, EXIT.TEMPFAIL);
-    }
-    return {
-        contexts: parseBranchRules(ref).requiredStatusCheckContexts,
-        behindBy: ref.compare?.behindBy ?? 0,
-    };
 }

package/bin/github/mutation-policy.d.mts

@@ -0,0 +1,6 @@
+export type GithubMutationOperation = "reply" | "resolve" | "dismiss" | "ready" | "minimize" | "view";
+/**
+ * Whether iterate may generate a mutation from the capability data available on
+ * this transport. Explicit `apply` requests do not use this policy.
+ */
+export declare function canGenerateGithubMutation(capability: boolean | undefined, operation: GithubMutationOperation): boolean;

package/bin/github/mutation-policy.mjs

@@ -0,0 +1,21 @@
+import { getGithubTransport, isCcrTransport } from "./transport.mjs";
+/**
+ * Whether iterate may generate a mutation from the capability data available on
+ * this transport. Explicit `apply` requests do not use this policy.
+ */
+export function canGenerateGithubMutation(capability, operation) {
+    if (capability === false)
+        return false;
+    const transport = getGithubTransport();
+    if (transport === "graphql")
+        return capability === true;
+    if (operation === "minimize" || operation === "view")
+        return false;
+    if (operation === "resolve" || operation === "ready")
+        return isCcrTransport();
+    if (capability === true)
+        return true;
+    if (operation === "reply" || operation === "dismiss")
+        return true;
+    return false;
+}

package/bin/github/poll-summary-annotation-probe.mjs

@@ -1,3 +1,5 @@
+import { githubOperation } from "./transport.mjs";
+import { readRestAnnotationCounts } from "./rest-check-read.mjs";
 import { graphqlWithRateLimit } from "./client.mjs";
 import { isCurrentSummaryReady } from "./poll-summary-readiness.mjs";
 import { summarizePollSummaryChecks } from "./poll-summary-checks.mjs";
@@ -78,16 +80,21 @@ async function collectProbePages(oid, repo) {
 }
 async function fetchProbePage(oid, repo, before) {
     try {
-        const { data } = await graphqlWithRateLimit(POLL_SUMMARY_ANNOTATION_PROBE_QUERY, {
-            owner: repo.owner,
-            repo: repo.name,
-            oid,
-            before,
-        });
-        const object = data.repository?.object;
-        if (object?.__typename !== "Commit" || object.oid !== oid)
-            return null;
-        return object.statusCheckRollup?.contexts ?? null;
+        return await githubOperation("PollSummaryAnnotationProbe", async () => {
+            const { data } = await graphqlWithRateLimit(POLL_SUMMARY_ANNOTATION_PROBE_QUERY, {
+                owner: repo.owner,
+                repo: repo.name,
+                oid,
+                before,
+            });
+            const object = data.repository?.object;
+            if (object?.__typename !== "Commit" || object.oid !== oid)
+                return null;
+            return object.statusCheckRollup?.contexts ?? null;
+        }, async () => ({
+            pageInfo: { hasPreviousPage: false, startCursor: null },
+            nodes: await readRestAnnotationCounts(oid, repo),
+        }));
     }
     catch {
         return null;

package/bin/github/poll-summary-check-blockers.d.mts

@@ -10,7 +10,7 @@ type Routed = Pick<PollSummaryItem, "action" | "reasons">;
 export declare function applyOpenCheckBlockers(raw: RawSummaryPr, repo: {
     owner: string;
     name: string;
-}, routed: Routed, checks: PollSummaryChecks, review: PollSummaryReview, stack: boolean): Promise<Routed & {
+}, routed: Routed, checks: PollSummaryChecks, review: PollSummaryReview, stack: boolean, requiredContexts?: readonly string[]): Promise<Routed & {
     pollProbe?: true;
 }>;
 export {};

package/bin/github/poll-summary-check-blockers.mjs

@@ -6,12 +6,12 @@ import { failingSummaryCheckNames } from "./poll-summary-checks.mjs";
  * deferred stay on the routed action. Stack rows are probed so the planner
  * does not start a one-PR session for a wait it would otherwise shepherd.
  */
-export async function applyOpenCheckBlockers(raw, repo, routed, checks, review, stack) {
+export async function applyOpenCheckBlockers(raw, repo, routed, checks, review, stack, requiredContexts) {
     if (routed.action !== "fix_code" || !routed.reasons.includes("failing-checks"))
         return routed;
     if ((review.actionable ?? 0) > 0 || checks.incomplete)
         return routed;
-    const names = failingSummaryCheckNames(raw);
+    const names = failingSummaryCheckNames(raw, requiredContexts);
     if (names.length === 0)
         return routed;
     const gate = await resolveCheckBlockerGate({ owner: repo.owner, repo: repo.name, pr: raw.number }, names.map((name) => ({ name })));

package/bin/github/poll-summary-check-hydration.mjs

@@ -1,3 +1,5 @@
+import { githubOperation } from "./transport.mjs";
+import { readRestCommitChecks } from "./rest-check-read.mjs";
 import { graphqlWithRateLimit } from "./client.mjs";
 import { POLL_SUMMARY_CHECK_PAGE_QUERY } from "./queries.mjs";
 /**
@@ -27,7 +29,10 @@ async function hydrateCommitContexts(commit, repo) {
         const older = await fetchOlderContexts(commit.oid, pageInfo.startCursor, repo);
         if (!older)
             break;
-        nodes.unshift(...older.nodes);
+        if (older.fullSnapshot)
+            nodes.splice(0, nodes.length, ...older.nodes);
+        else
+            nodes.unshift(...older.nodes);
         pageInfo = older.pageInfo;
     }
     // A window that shifted between pages can repeat or skip contexts; the
@@ -42,14 +47,24 @@ async function hydrateCommitContexts(commit, repo) {
     };
 }
 async function fetchOlderContexts(oid, before, repo) {
-    const { data } = await graphqlWithRateLimit(POLL_SUMMARY_CHECK_PAGE_QUERY, {
-        owner: repo.owner,
-        repo: repo.name,
-        oid,
-        before,
+    return githubOperation("PollSummaryCheckPage", async () => {
+        const { data } = await graphqlWithRateLimit(POLL_SUMMARY_CHECK_PAGE_QUERY, {
+            owner: repo.owner,
+            repo: repo.name,
+            oid,
+            before,
+        });
+        const object = data.repository?.object;
+        if (object?.__typename !== "Commit" || object.oid !== oid)
+            return null;
+        return object.statusCheckRollup?.contexts ?? null;
+    }, async () => {
+        const checks = await readRestCommitChecks(oid, repo);
+        return {
+            fullSnapshot: true,
+            totalCount: checks.nodes.length,
+            pageInfo: { hasPreviousPage: false },
+            nodes: checks.nodes,
+        };
     });
-    const object = data.repository?.object;
-    if (object?.__typename !== "Commit" || object.oid !== oid)
-        return null;
-    return object.statusCheckRollup?.contexts ?? null;
 }

package/bin/github/poll-summary-checks.d.mts

@@ -1,5 +1,5 @@
 import type { PollSummaryChecks } from "../types.mts";
 import type { RawSummaryPr } from "./poll-summary-raw.mts";
-export declare function summarizePollSummaryChecks(raw: RawSummaryPr): PollSummaryChecks;
+export declare function summarizePollSummaryChecks(raw: RawSummaryPr, requiredContexts?: readonly string[]): PollSummaryChecks;
 /** Names of failing checks in the loaded summary rollup. */
-export declare function failingSummaryCheckNames(raw: RawSummaryPr): string[];
+export declare function failingSummaryCheckNames(raw: RawSummaryPr, requiredContexts?: readonly string[]): string[];

package/bin/github/poll-summary-checks.mjs

@@ -1,9 +1,9 @@
 import { classifyChecks } from "../checks/classify.mjs";
 import { parseCreatedAt } from "./batch-parser-helpers.mjs";
-export function summarizePollSummaryChecks(raw) {
+export function summarizePollSummaryChecks(raw, requiredContexts) {
     const rollups = summaryRollups(raw);
     const counts = {};
-    for (const check of classifiedSummaryChecks(raw)) {
+    for (const check of classifiedSummaryChecks(raw, requiredContexts)) {
         const key = {
             passed: "passing",
             failing: "failing",
@@ -22,8 +22,8 @@ export function summarizePollSummaryChecks(raw) {
     return summary;
 }
 /** Names of failing checks in the loaded summary rollup. */
-export function failingSummaryCheckNames(raw) {
-    return classifiedSummaryChecks(raw)
+export function failingSummaryCheckNames(raw, requiredContexts) {
+    return classifiedSummaryChecks(raw, requiredContexts)
         .filter((check) => check.category === "failing")
         .map((check) => check.name);
 }
@@ -36,9 +36,12 @@ function summaryRollups(raw) {
         },
     ].flatMap(({ rollup, scope }) => (rollup ? [{ rollup, scope }] : []));
 }
-function classifiedSummaryChecks(raw) {
+function classifiedSummaryChecks(raw, requiredContexts) {
     // A successful check on the queue commit cannot cover a PR-head cancellation, or vice versa.
-    return summaryRollups(raw).flatMap(({ rollup, scope }) => classifyChecks(checkRuns(rollup, scope), scope === "merge_group" ? { additionalRelevantEvents: ["merge_group"] } : {}));
+    return summaryRollups(raw).flatMap(({ rollup, scope }) => classifyChecks(checkRuns(rollup, scope), {
+        ...(scope === "merge_group" && { additionalRelevantEvents: ["merge_group"] }),
+        ...(requiredContexts && { requiredContexts }),
+    }));
 }
 function checkRuns(rollup, scope) {
     return rollup.contexts.nodes.map((context) => {

package/bin/github/poll-summary-command.d.mts

@@ -0,0 +1,2 @@
+import type { PollSummaryCommandOptions, PollSummaryItem } from "../types.mts";
+export declare function pollCommandFields(repo: string, pr: number, isDraft: boolean, opts: PollSummaryCommandOptions): Pick<PollSummaryItem, "pollCommand" | "pollProbe">;

package/bin/github/poll-summary-command.mjs

@@ -0,0 +1,24 @@
+import { loadConfig } from "../config/load.mjs";
+import { formatPrUrl } from "../pr-reference.mjs";
+import { buildPrShepherdCommand } from "../cli/runner.mjs";
+export function pollCommandFields(repo, pr, isDraft, opts) {
+    const autoMarkReadyDisabled = opts.noAutoMarkReady || loadConfig().actions.autoMarkReady === false;
+    const boundedDraft = isDraft && autoMarkReadyDisabled;
+    const args = boundedDraft
+        ? [formatPrUrl(repo, pr), "--timeout", "1s", "--debounce", "0s", "--no-auto-mark-ready"]
+        : [formatPrUrl(repo, pr), "--until-terminal"];
+    if (opts.merge && opts.stackPrNumber === undefined)
+        args.push("--merge");
+    if (opts.readyDelaySeconds !== undefined)
+        args.push("--ready-delay", `${opts.readyDelaySeconds}s`);
+    if (opts.stallTimeoutSeconds !== undefined)
+        args.push("--stall-timeout", `${opts.stallTimeoutSeconds}s`);
+    if (opts.instructions)
+        args.push("--instructions", opts.instructions);
+    if (opts.pollMode === "event")
+        args.push("--poll-mode", "event");
+    if (opts.noAutoMarkReady && !boundedDraft)
+        args.push("--no-auto-mark-ready");
+    const pollCommand = buildPrShepherdCommand(args).text;
+    return boundedDraft ? { pollCommand, pollProbe: true } : { pollCommand };
+}

package/bin/github/poll-summary-fingerprint.d.mts

@@ -5,4 +5,4 @@ import type { RawSummaryPr } from "./poll-summary-raw.mts";
  * computed merge state are checked separately: including them here would
  * invalidate a READY receipt merely because a ready PR entered the queue.
  */
-export declare function fingerprintRawSummaryPr(raw: RawSummaryPr): string | null;
+export declare function fingerprintRawSummaryPr(summary: RawSummaryPr): string | null;

package/bin/github/poll-summary-fingerprint.mjs

@@ -1,11 +1,13 @@
 import { createHash } from "node:crypto";
+import { withoutHandoffFields } from "./poll-summary-handoff-fields.mjs";
 /**
  * Bind receipts to the review and head-commit CI evidence shared by one-PR
  * completion and stack reconciliation. Queue entry, queue checks, and GitHub's
  * computed merge state are checked separately: including them here would
  * invalidate a READY receipt merely because a ready PR entered the queue.
  */
-export function fingerprintRawSummaryPr(raw) {
+export function fingerprintRawSummaryPr(summary) {
+    const raw = withoutHandoffFields(summary);
     if (!raw.updatedAt || !raw.headRefOid || !raw.baseRefOid)
         return null;
     const reviewTruncated = raw.comments.pageInfo.hasPreviousPage ||
@@ -13,6 +15,7 @@ export function fingerprintRawSummaryPr(raw) {
         raw.reviewThreads.pageInfo.hasPreviousPage ||
         raw.reviewThreads.nodes.some((thread) => thread.comments.pageInfo.hasPreviousPage);
     const evidence = {
+        ...(raw.transport === "rest" && { transport: "rest" }),
         number: raw.number,
         state: raw.state,
         lifecycleEvents: raw.lifecycleEvents,
@@ -32,7 +35,6 @@ export function fingerprintRawSummaryPr(raw) {
             ...raw.reviewThreads,
             nodes: raw.reviewThreads.nodes.map((thread) => ({
                 ...thread,
-                rootComments: thread.rootComments && hideBodies(thread.rootComments),
                 comments: hideBodies(thread.comments),
             })),
         },

package/bin/github/poll-summary-handoff-fields.d.mts

@@ -0,0 +1,3 @@
+import type { RawSummaryPr } from "./poll-summary-raw.mts";
+/** `raw` without the fields only the handoff reads. */
+export declare function withoutHandoffFields(raw: RawSummaryPr): RawSummaryPr;

package/bin/github/poll-summary-handoff-fields.mjs

@@ -0,0 +1,73 @@
+/**
+ * The GraphQL summary selects these fields only so a routed stack layer's first
+ * tick can skip `BatchPr` (see `stack-handoff.mts`). They are not readiness
+ * evidence, and some (an edited hidden comment's `updatedAt`) change after a PR
+ * settles, so READY-receipt fingerprints leave them out. REST summaries never
+ * carry them. A thread comment's `isMinimized` stays: the fingerprint hides
+ * minimized bodies, as it already did for comments and reviews.
+ */
+const COMMENT = ["viewerCanMinimize", "createdAt", "updatedAt"];
+const REVIEW = [...COMMENT, "url", "commit"];
+const THREAD = ["viewerCanReply", "viewerCanResolve", "line", "startLine"];
+const THREAD_COMMENT = ["pullRequestReview", "path", "line", "startLine", "createdAt", "updatedAt"];
+const STATUS_CONTEXT = ["createdAt", "targetUrl", "description"];
+function omit(value, keys) {
+    const copy = { ...value };
+    for (const key of keys)
+        delete copy[key];
+    return copy;
+}
+function omitEach(connection, keys) {
+    return { ...connection, nodes: connection.nodes.map((node) => omit(node, keys)) };
+}
+/** `raw` without the fields only the handoff reads. */
+export function withoutHandoffFields(raw) {
+    if (raw.transport === "rest")
+        return raw;
+    return {
+        ...raw,
+        ...(raw.reviewRequests && {
+            reviewRequests: {
+                nodes: raw.reviewRequests.nodes.map(({ requestedReviewer }) => ({
+                    requestedReviewer: requestedReviewer && omit(requestedReviewer, ["name"]),
+                })),
+            },
+        }),
+        comments: omitEach(raw.comments, COMMENT),
+        reviews: omitEach(raw.reviews, REVIEW),
+        reviewThreads: {
+            ...raw.reviewThreads,
+            nodes: raw.reviewThreads.nodes.map((thread) => ({
+                ...omit(thread, THREAD),
+                comments: omitEach(thread.comments, THREAD_COMMENT),
+            })),
+        },
+        commits: {
+            ...omit(raw.commits, ["totalCount"]),
+            nodes: raw.commits.nodes.map(({ commit }) => {
+                const rollup = commit.statusCheckRollup;
+                return {
+                    commit: {
+                        ...commit,
+                        statusCheckRollup: rollup && {
+                            ...omit(rollup, ["state"]),
+                            contexts: {
+                                ...rollup.contexts,
+                                nodes: rollup.contexts.nodes.map((node) => node.__typename === "StatusContext"
+                                    ? omit(node, STATUS_CONTEXT)
+                                    : {
+                                        ...node,
+                                        checkSuite: node.checkSuite && {
+                                            ...omit(node.checkSuite, ["updatedAt"]),
+                                            workflowRun: node.checkSuite.workflowRun &&
+                                                omit(node.checkSuite.workflowRun, ["updatedAt"]),
+                                        },
+                                    }),
+                            },
+                        },
+                    },
+                };
+            }),
+        },
+    };
+}

package/bin/github/poll-summary-projector.d.mts

@@ -1,4 +1,4 @@
 import type { PollSummaryCommandOptions, PollSummaryItem } from "../types.mts";
 import type { RepoInfo } from "./client.mts";
 import type { RawSummaryPr } from "./poll-summary-raw.mts";
-export declare function summarizePollSummaryPr(raw: RawSummaryPr, repo: RepoInfo, opts: PollSummaryCommandOptions, viewerCanAdminister?: boolean, mergeTargetContexts?: readonly string[], viewerLogin?: string | null): Promise<PollSummaryItem>;
+export declare function summarizePollSummaryPr(raw: RawSummaryPr, repo: RepoInfo, opts: PollSummaryCommandOptions, viewerCanAdminister?: boolean | undefined, mergeTargetContexts?: readonly string[], viewerLogin?: string | null): Promise<PollSummaryItem>;

package/bin/github/poll-summary-projector.mjs

@@ -1,7 +1,7 @@
+import { pollCommandFields } from "./poll-summary-command.mjs";
 import { loadConfig } from "../config/load.mjs";
 import { updateReadyDelay } from "../commands/ready-delay.mjs";
 import { formatPrUrl } from "../pr-reference.mjs";
-import { buildPrShepherdCommand } from "../cli/runner.mjs";
 import { loadSeenMap } from "../state/seen-comments.mjs";
 import { isReadyReceiptCurrent, readReadyReceipt } from "../state/ready-receipts.mjs";
 import { summarizePollSummaryChecks } from "./poll-summary-checks.mjs";
@@ -11,12 +11,16 @@ import { isCurrentSummaryReady } from "./poll-summary-readiness.mjs";
 import { applyOpenCheckBlockers } from "./poll-summary-check-blockers.mjs";
 import { normalizePollSummaryState, routePollSummary } from "./poll-summary-route.mjs";
 import { hydrateReadyAnnotationProbe, readyFingerprint } from "./poll-summary-annotation-probe.mjs";
-import { applyUnreportedRequiredChecks } from "./poll-summary-unreported.mjs";
-export async function summarizePollSummaryPr(raw, repo, opts, viewerCanAdminister = false, mergeTargetContexts, viewerLogin = null) {
+import { applyUnreportedRequiredChecks, summaryRequiredContexts, } from "./poll-summary-unreported.mjs";
+import { aliasThreadSeenMarkers } from "./rest-identities.mjs";
+import { restQueueRequirement } from "./poll-summary-rest-queue.mjs";
+export async function summarizePollSummaryPr(raw, repo, opts, viewerCanAdminister = undefined, mergeTargetContexts, viewerLogin = null) {
     const repoName = `${repo.owner}/${repo.name}`;
     const seen = await loadSeenMap({ owner: repo.owner, repo: repo.name, pr: raw.number });
-    const checks = summarizePollSummaryChecks(raw);
-    applyUnreportedRequiredChecks(raw, checks, mergeTargetContexts);
+    await aliasThreadSeenMarkers(repo, raw.number, raw.reviewThreads.nodes.map(({ id }) => id), seen);
+    const required = summaryRequiredContexts(raw, mergeTargetContexts);
+    const checks = summarizePollSummaryChecks(raw, required);
+    applyUnreportedRequiredChecks(raw, checks, required);
     const review = await summarizePollSummaryReview(raw, seen, viewerCanAdminister);
     const blockingReviewerInProgress = detectBlockingReviewer(raw);
     const removalEvent = currentQueueRemovalEvent(raw);
@@ -74,12 +78,15 @@ export async function summarizePollSummaryPr(raw, repo, opts, viewerCanAdministe
         : removalEvent
             ? projectQueueRemoval(removalEvent)
             : undefined;
-    const blocked = await applyOpenCheckBlockers(raw, repo, { action, reasons }, checks, review, opts.stackPrNumber !== undefined);
+    const blocked = await applyOpenCheckBlockers(raw, repo, { action, reasons }, checks, review, opts.stackPrNumber !== undefined, required);
     action = blocked.action;
     reasons = blocked.reasons;
+    const requiresMergeQueue = raw.transport === "rest" ? restQueueRequirement(raw) : undefined;
     return {
         pr: raw.number,
         repo: repoName,
+        ...(raw.transport && { transport: raw.transport }),
+        ...(raw.transportUnavailable?.length && { transportUnavailable: raw.transportUnavailable }),
         title: raw.title,
         url: raw.url || formatPrUrl(repoName, raw.number),
         ...(raw.author?.login && { authorLogin: raw.author.login }),
@@ -97,6 +104,7 @@ export async function summarizePollSummaryPr(raw, repo, opts, viewerCanAdministe
         baseRefName: raw.baseRefName,
         ...(raw.isDraft && { isDraft: true }),
         ...(raw.isInMergeQueue && { isInMergeQueue: true }),
+        ...(requiresMergeQueue !== undefined && { requiresMergeQueue }),
         ...(queueRemoval && { queueRemoval }),
         ...(blockingReviewerInProgress && { blockingReviewerInProgress: true }),
         ...(remainingSeconds !== undefined && { remainingSeconds }),
@@ -125,24 +133,9 @@ function projectQueueRemoval(removal) {
 }
 function detectBlockingReviewer(raw) {
     const prefixes = (loadConfig().mergeStatus?.blockingReviewerLogins ?? []).map((login) => login.toLowerCase());
-    const matches = (author) => author !== null && prefixes.some((prefix) => author.login.toLowerCase().startsWith(prefix));
+    // A team reviewer has a name, not a login, so it never matches a login prefix.
+    const matches = (author) => typeof author?.login === "string" &&
+        prefixes.some((prefix) => author.login.toLowerCase().startsWith(prefix));
     return ((raw.reviewRequests?.nodes ?? []).some((request) => matches(request.requestedReviewer)) ||
         (raw.latestReviews?.nodes ?? []).some((review) => review.state === "PENDING" && matches(review.author)));
 }
-function pollCommandFields(repo, pr, isDraft, opts) {
-    const autoMarkReadyDisabled = opts.noAutoMarkReady || loadConfig().actions.autoMarkReady === false;
-    const boundedDraft = isDraft && autoMarkReadyDisabled;
-    const args = boundedDraft
-        ? [formatPrUrl(repo, pr), "--timeout", "1s", "--debounce", "0s", "--no-auto-mark-ready"]
-        : [formatPrUrl(repo, pr), "--until-terminal"];
-    if (opts.merge && opts.stackPrNumber === undefined)
-        args.push("--merge");
-    if (opts.readyDelaySeconds !== undefined)
-        args.push("--ready-delay", `${opts.readyDelaySeconds}s`);
-    if (opts.stallTimeoutSeconds !== undefined)
-        args.push("--stall-timeout", `${opts.stallTimeoutSeconds}s`);
-    if (opts.noAutoMarkReady && !boundedDraft)
-        args.push("--no-auto-mark-ready");
-    const pollCommand = buildPrShepherdCommand(args).text;
-    return boundedDraft ? { pollCommand, pollProbe: true } : { pollCommand };
-}