pr-shepherd 0.20.0 → 0.22.0

package/bin/commands/commit-suggestion.apply.test-support.mjs

@@ -1,5 +1,4 @@
-// @ts-nocheck
-import { describe, it, expect, vi, beforeEach } from "vitest";
+import { vi } from "vitest";
 // ---------------------------------------------------------------------------
 // Hoisted mocks
 // ---------------------------------------------------------------------------

package/bin/commands/commit-suggestion.test-support.mjs

@@ -1,5 +1,4 @@
-// @ts-nocheck
-import { describe, it, expect, vi, beforeEach } from "vitest";
+import { vi, beforeEach } from "vitest";
 // ---------------------------------------------------------------------------
 // Hoisted mocks
 // ---------------------------------------------------------------------------

package/bin/commands/iterate/escalate.mjs

@@ -52,11 +52,25 @@ export function buildEscalateHumanMessage(escalate, pr) {
     lines.push(escalate.suggestion);
     const hasItems = escalate.unresolvedThreads.length > 0 ||
         escalate.changesRequestedReviews.length > 0 ||
-        escalate.ambiguousComments.length > 0;
+        escalate.ambiguousComments.length > 0 ||
+        (escalate.stalledChecks?.length ?? 0) > 0;
     if (hasItems) {
         lines.push("");
         lines.push("## Items needing attention");
         lines.push("");
+        for (const c of escalate.stalledChecks ?? []) {
+            const target = c.runId
+                ? `run \`${c.runId}\``
+                : c.detailsUrl
+                    ? `external \`${c.detailsUrl}\``
+                    : "no run ID";
+            const ageMinutes = Math.floor(c.ageSeconds / 60);
+            lines.push(`- check \`${c.name}\` — ${c.status} ${c.source}, ${target}, waiting ${ageMinutes} minute${ageMinutes === 1 ? "" : "s"}`);
+            if (c.summary)
+                lines.push(`  > ${c.summary}`);
+        }
+        if ((escalate.stalledChecks?.length ?? 0) > 0)
+            lines.push("");
         for (const t of escalate.unresolvedThreads) {
             const loc = t.path ? `\`${t.path}:${t.line ?? "?"}\`` : "(no location)";
             lines.push(`- thread \`${t.id}\` — ${loc} (@${t.author}):`);
@@ -96,7 +110,7 @@ export function buildEscalateHumanMessage(escalate, pr) {
 }
 export function buildEscalateSuggestion(triggers, detail) {
     if (triggers.includes("stall-timeout")) {
-        const mins = detail ?? "30";
+        const mins = detail ?? "60";
         return `No progress detected for ${mins} minute${parseInt(mins, 10) === 1 ? "" : "s"} — state has not changed. This is a manual checkpoint: inspect the PR and apply a manual fix before resuming.`;
     }
     if (triggers.includes("base-branch-unknown")) {

package/bin/commands/iterate/fix-code.mjs

@@ -1,11 +1,13 @@
 /* eslint-disable max-lines */
 import { readFixAttempts, writeFixAttempts } from "../../state/fix-attempts.mjs";
 import { toAgentThread, toAgentComment, toAgentChecks } from "../../reporters/agent.mjs";
+import { markSeen } from "../../state/seen-comments.mjs";
 import { checkEscalateTriggers, validateBaseBranch, buildEscalateSuggestion, buildEscalateHumanMessage, } from "./escalate.mjs";
 import { buildResolveCommand } from "./classify.mjs";
 import { buildFixInstructions } from "./render.mjs";
 import { applyStallGuard } from "./stall.mjs";
 import { tryCancelRun, buildInProgressRunIds } from "./helpers.mjs";
+import { annotationMarkerBody } from "../check-annotations.mjs";
 export async function handleFixCode(ctx) {
     const { base, report, opts, headSha, stallKey, prNumber, stallTimeoutSeconds, repoOwner, repoName, reviewSummaryIds, firstLookSummaries, editedSummaries, surfacedApprovals, } = ctx;
     const failingChecks = report.checks.failing;
@@ -101,7 +103,7 @@ export async function handleFixCode(ctx) {
     const firstLookThreads = report.threads.firstLook;
     const firstLookComments = report.comments.firstLook;
     const instructions = buildFixInstructions(threads, actionableComments, checks, changesRequestedReviews, baseLookup.branch, resolveCommand, hasConflicts, prNumber, cancelled.length, firstLookThreads, firstLookComments, firstLookSummaries, editedSummaries, inProgressRunIds, resolutionOnlyThreads);
-    return applyStallGuard(stallKey, stallTimeoutSeconds, headSha, base, prNumber, {
+    const prospectiveResult = {
         ...base,
         baseBranch: baseLookup.branch,
         action: "fix_code",
@@ -122,5 +124,10 @@ export async function handleFixCode(ctx) {
             inProgressRunIds,
         },
         cancelled,
-    }, report, reviewSummaryIds);
+    };
+    const result = await applyStallGuard(stallKey, stallTimeoutSeconds, headSha, base, prNumber, prospectiveResult, report, reviewSummaryIds);
+    if (result.action === "fix_code") {
+        await Promise.allSettled(result.fix.checks.flatMap((ch) => (ch.annotations ?? []).map((a) => markSeen(stallKey, a.id, annotationMarkerBody(a)))));
+    }
+    return result;
 }

package/bin/commands/iterate/helpers.mjs

@@ -53,6 +53,7 @@ export function buildRelevantChecks(report) {
                 ...(c.jobName !== undefined && { jobName: c.jobName }),
                 ...(c.failedStep !== undefined && { failedStep: c.failedStep }),
                 ...(c.summary !== undefined && { summary: c.summary }),
+                ...(c.annotations !== undefined && { annotations: c.annotations }),
             },
         ];
     });

package/bin/commands/iterate/render.mjs

@@ -30,6 +30,9 @@ export function buildFixInstructions(threads, actionableComments, checks, change
             actionableSections.push("`## Actionable comments`");
         if (checks.length > 0)
             actionableSections.push("`## Failing checks`");
+        if (checks.some((c) => (c.annotations?.length ?? 0) > 0)) {
+            actionableSections.push("`## Check annotations`");
+        }
         if (changesRequestedReviews.length > 0)
             actionableSections.push("`## Changes-requested reviews`");
         const sectionRef = actionableSections.length > 0 ? `under ${actionableSections.join(", ")}` : "above";
@@ -65,6 +68,9 @@ export function buildFixInstructions(threads, actionableComments, checks, change
         instructions.push(`Resolve the threads under \`## Review threads to resolve\` with the \`resolve:\` command shown below. These threads are already outdated or minimized, so no code edit is required for them unless their body reveals separate work you choose to do.`);
     }
     instructions.push(...buildFailingCheckInstructions(checks));
+    if (checks.some((c) => (c.annotations?.length ?? 0) > 0)) {
+        instructions.push(`For each item under \`## Check annotations\`: inspect the referenced file range and decide whether the annotation requires a code change. These annotations are surfaced once per PR and do not need any resolve/minimize mutation.`);
+    }
     if (changesRequestedReviews.length > 0) {
         instructions.push(`For each bullet under \`## Changes-requested reviews\` above: read the review body and apply the requested changes.`);
     }

package/bin/commands/iterate/stall.mjs

@@ -1,5 +1,5 @@
 import { readStallState, writeStallState } from "../../state/iterate-stall.mjs";
-import { toAgentThread, toAgentComment } from "../../reporters/agent.mjs";
+import { toAgentThread, toAgentComment, toAgentStalledCheck } from "../../reporters/agent.mjs";
 import { buildEscalateSuggestion, buildEscalateHumanMessage } from "./escalate.mjs";
 export function computeStallFingerprint(action, headSha, base, report, reviewSummaryIds) {
     const checks = [
@@ -27,8 +27,31 @@ export function computeStallFingerprint(action, headSha, base, report, reviewSum
     });
 }
 export async function applyStallGuard(stallKey, stallTimeoutSeconds, headSha, base, prNumber, prospectiveResult, report, reviewSummaryIds) {
-    const fingerprint = computeStallFingerprint(prospectiveResult.action, headSha, base, report, reviewSummaryIds);
     const nowSeconds = Math.floor(Date.now() / 1000);
+    const stalledChecks = findCiStartStalledChecks(report.checks.inProgress, nowSeconds, {
+        stallTimeoutSeconds,
+        action: prospectiveResult.action,
+    });
+    if (stalledChecks.length > 0) {
+        const stalledMinutes = Math.floor(Math.max(...stalledChecks.map((c) => c.ageSeconds)) / 60);
+        const escalateBase = {
+            triggers: ["stall-timeout"],
+            unresolvedThreads: [],
+            ambiguousComments: [],
+            changesRequestedReviews: [],
+            stalledChecks,
+            suggestion: buildEscalateSuggestion(["stall-timeout"], String(stalledMinutes)),
+        };
+        return {
+            ...base,
+            action: "escalate",
+            escalate: {
+                ...escalateBase,
+                humanMessage: buildEscalateHumanMessage(escalateBase, prNumber),
+            },
+        };
+    }
+    const fingerprint = computeStallFingerprint(prospectiveResult.action, headSha, base, report, reviewSummaryIds);
     const stored = await readStallState(stallKey);
     if (stored && stored.fingerprint === fingerprint) {
         const ageSeconds = nowSeconds - stored.firstSeenAt;
@@ -65,3 +88,21 @@ export async function applyStallGuard(stallKey, stallTimeoutSeconds, headSha, ba
     await writeStallState(stallKey, { fingerprint, firstSeenAt: nowSeconds });
     return prospectiveResult;
 }
+function findCiStartStalledChecks(checks, nowSeconds, opts) {
+    if (opts.stallTimeoutSeconds <= 0 || opts.action !== "wait")
+        return [];
+    return checks
+        .filter((c) => isUnstartedCheck(c))
+        .map((c) => toAgentStalledCheck(c, nowSeconds))
+        .filter((c) => c.createdAtUnix !== undefined && c.ageSeconds >= opts.stallTimeoutSeconds);
+}
+function isUnstartedCheck(check) {
+    if (check.source === "status_context")
+        return true;
+    if (check.startedAtUnix !== undefined)
+        return false;
+    return (check.status === "PENDING" ||
+        check.status === "QUEUED" ||
+        check.status === "REQUESTED" ||
+        check.status === "WAITING");
+}

package/bin/commands/iterate-stall.test-support.mjs

@@ -1,4 +1,3 @@
-// @ts-nocheck
 import { vi } from "vitest";
 import { NOW, makeOpts } from "./iterate-test-support.mjs";
 import { readStallState, writeStallState } from "../state/iterate-stall.mjs";

package/bin/commands/iterate-test-support.mjs

@@ -103,7 +103,7 @@ function defaultConfig() {
     return {
         iterate: {
             fixAttemptsPerThread: 3,
-            stallTimeoutMinutes: 30,
+            stallTimeoutMinutes: 60,
             minimizeApprovals: false,
             minimizeComments: "all",
         },

package/bin/commands/iterate.fix-code-in-progress.test-support.mjs

@@ -1,5 +1,4 @@
-// @ts-nocheck
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { vi, beforeEach, afterEach } from "vitest";
 const mockFetch = vi.fn();
 vi.stubGlobal("fetch", mockFetch);
 const { mockExecFile } = vi.hoisted(() => ({ mockExecFile: vi.fn() }));
@@ -24,6 +23,9 @@ vi.mock("../state/iterate-stall.mts", () => ({
     readStallState: vi.fn().mockResolvedValue(null),
     writeStallState: vi.fn().mockResolvedValue(undefined),
 }));
+vi.mock("../state/seen-comments.mts", () => ({
+    markSeen: vi.fn().mockResolvedValue(undefined),
+}));
 const { mockLoadConfig } = vi.hoisted(() => ({ mockLoadConfig: vi.fn() }));
 vi.mock("../config/load.mts", () => ({ loadConfig: mockLoadConfig }));
 import { runIterate } from "./iterate/index.mjs";
@@ -31,12 +33,14 @@ import { runCheck } from "./check.mjs";
 import { updateReadyDelay } from "./ready-delay.mjs";
 import { readFixAttempts, writeFixAttempts } from "../state/fix-attempts.mjs";
 import { readStallState, writeStallState } from "../state/iterate-stall.mjs";
+import { markSeen } from "../state/seen-comments.mjs";
 const mockRunCheck = vi.mocked(runCheck);
 const mockUpdateReadyDelay = vi.mocked(updateReadyDelay);
 const mockReadFixAttempts = vi.mocked(readFixAttempts);
 const mockWriteFixAttempts = vi.mocked(writeFixAttempts);
 const mockReadStallState = vi.mocked(readStallState);
 const mockWriteStallState = vi.mocked(writeStallState);
+const mockMarkSeen = vi.mocked(markSeen);
 function makeReport(overrides = {}) {
     return {
         pr: 42,
@@ -44,6 +48,7 @@ function makeReport(overrides = {}) {
         repo: "owner/repo",
         status: "READY",
         baseBranch: "main",
+        branchProtection: null,
         mergeStatus: {
             status: "CLEAN",
             state: "OPEN",
@@ -115,4 +120,4 @@ export function registerHooks() {
         vi.restoreAllMocks();
     });
 }
-export { makeOpts, makeReport, mockExecFile, mockFetch, mockLoadConfig, mockReadFixAttempts, mockReadStallState, mockRunCheck, mockUpdateReadyDelay, mockWriteFixAttempts, mockWriteStallState, readFixAttempts, readStallState, runCheck, runIterate, updateReadyDelay, writeFixAttempts, writeStallState, };
+export { makeOpts, makeReport, mockExecFile, mockFetch, mockLoadConfig, mockReadFixAttempts, mockReadStallState, mockMarkSeen, mockRunCheck, mockUpdateReadyDelay, mockWriteFixAttempts, mockWriteStallState, readFixAttempts, readStallState, runCheck, runIterate, updateReadyDelay, writeFixAttempts, writeStallState, };

package/bin/commands/poll.mjs

@@ -3,9 +3,12 @@ function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
 function writeTickProgress(tick, elapsedSeconds, sleepSeconds, verbose) {
-    if (process.stderr.isTTY || verbose) {
+    if (verbose) {
         process.stderr.write(`[poll tick ${tick} / +${elapsedSeconds}s] WAIT — sleeping ${sleepSeconds}s\n`);
     }
+    else {
+        process.stderr.write(".");
+    }
 }
 const MAX_TIMER_MS = 2 ** 31 - 1;
 export async function runPoll(opts) {
@@ -16,17 +19,23 @@ export async function runPoll(opts) {
     let tick = 0;
     let lastResult;
     const verbose = opts.verbose === true;
+    let dotsPrinted = false;
     while (true) {
         tick += 1;
         lastResult = await runIterate(iterateOpts);
         if (lastResult.action !== "wait")
-            return lastResult;
+            break;
         const elapsedMs = Date.now() - start;
         const remainingMs = timeoutMs - elapsedMs;
         if (remainingMs <= 0)
-            return lastResult;
+            break;
         const nextSleepMs = Math.min(intervalMs, remainingMs);
         writeTickProgress(tick, Math.round(elapsedMs / 1000), Math.round(nextSleepMs / 1000), verbose);
+        if (!verbose)
+            dotsPrinted = true;
         await sleep(nextSleepMs);
     }
+    if (dotsPrinted)
+        process.stderr.write("\n");
+    return lastResult;
 }

package/bin/commands/resolve.mjs

@@ -7,6 +7,7 @@ import { classifyVisibleComments } from "../comments/visible-comments.mjs";
 import { extractSuggestion } from "../suggestions/extract.mjs";
 import { buildFetchInstructions } from "./resolve-instructions.mjs";
 import { loadSeenMap, markSeen, classifyItem } from "../state/seen-comments.mjs";
+import { threadTranscriptBody } from "../threads/transcript.mjs";
 export { runResolveMutate } from "./resolve-mutate.mjs";
 export async function runResolveFetch(opts) {
     const repo = await getRepoInfo();
@@ -25,7 +26,7 @@ export async function runResolveFetch(opts) {
     const unseenOutdated = [];
     const editedOutdated = [];
     for (const t of outdatedCandidates) {
-        const cls = classifyItem(t.id, t.body, seenMap);
+        const cls = classifyItem(t.id, threadTranscriptBody(t), seenMap);
         if (cls === "new")
             unseenOutdated.push(t);
         else if (cls === "edited")
@@ -34,7 +35,7 @@ export async function runResolveFetch(opts) {
     const unseenResolved = [];
     const editedResolved = [];
     for (const t of resolvedCandidates) {
-        const cls = classifyItem(t.id, t.body, seenMap);
+        const cls = classifyItem(t.id, threadTranscriptBody(t), seenMap);
         if (cls === "new")
             unseenResolved.push(t);
         else if (cls === "edited")
@@ -43,7 +44,7 @@ export async function runResolveFetch(opts) {
     const unseenMinimizedThreads = [];
     const editedMinimizedThreads = [];
     for (const t of minimizedThreadCandidates) {
-        const cls = classifyItem(t.id, t.body, seenMap);
+        const cls = classifyItem(t.id, threadTranscriptBody(t), seenMap);
         if (cls === "new")
             unseenMinimizedThreads.push(t);
         else if (cls === "edited")
@@ -114,7 +115,7 @@ export async function runResolveFetch(opts) {
     ];
     // Mark new and edited items as seen (best-effort — markSeen never throws).
     await Promise.allSettled([
-        ...firstLookThreads.map((t) => markSeen(stateKey, t.id, t.body)),
+        ...firstLookThreads.map((t) => markSeen(stateKey, t.id, threadTranscriptBody(t))),
         ...firstLookComments.map((c) => markSeen(stateKey, c.id, c.body)),
         ...visibleCommentClassification.toMarkSeen.map((c) => markSeen(stateKey, c.id, c.body)),
     ]);

package/bin/commands/resolve.test-support.mjs

@@ -1,5 +1,4 @@
-// @ts-nocheck
-import { describe, it, expect, vi, beforeEach } from "vitest";
+import { vi, beforeEach } from "vitest";
 vi.mock("../github/client.mts", () => ({
     getRepoInfo: vi.fn().mockResolvedValue({ owner: "owner", name: "repo" }),
     getCurrentPrNumber: vi.fn().mockResolvedValue(42),
@@ -67,6 +66,7 @@ function makeBatchData(overrides = {}) {
         reviewSummaries: [],
         approvedReviews: [],
         checks: [],
+        branchProtection: null,
         ...overrides,
     };
 }

package/bin/commands/shepherd-journal.test-support.mjs

@@ -1,5 +1,3 @@
-// @ts-nocheck
-import { describe, expect, it } from "vitest";
 import { buildShepherdJournalInstruction, SHEPHERD_JOURNAL_APPEND_HINT, SHEPHERD_JOURNAL_FIRST_LOOK_GUIDANCE, SHEPHERD_JOURNAL_REFERENCE_GUIDANCE_THREADS_AND_COMMENTS_IN_ITEM_HEADINGS, SHEPHERD_JOURNAL_REFERENCE_GUIDANCE_THREADS_AND_COMMENTS_IN_ITEMS, SHEPHERD_JOURNAL_SECTION, SHEPHERD_JOURNAL_SECTION_PATTERN, } from "./shepherd-journal.mjs";
 import { buildFixInstructions } from "./iterate/render.mjs";
 import { buildFetchInstructions } from "./resolve-instructions.mjs";

package/bin/comments/resolve.test-support.mjs

@@ -1,5 +1,4 @@
-// @ts-nocheck
-import { describe, it, expect, vi, beforeEach } from "vitest";
+import { vi, beforeEach } from "vitest";
 // ---------------------------------------------------------------------------
 // Mock github/client.mts before any imports.
 // ---------------------------------------------------------------------------

package/bin/config.json

@@ -1,7 +1,7 @@
 {
   "iterate": {
     "fixAttemptsPerThread": 3,
-    "stallTimeoutMinutes": 30,
+    "stallTimeoutMinutes": 60,
     "minimizeApprovals": false,
     "minimizeComments": "all"
   },

package/bin/github/batch-parsers.mjs

@@ -10,19 +10,29 @@ export function parseRawPr(raw, rawThreadPages, rawCommentNodes, rawReviewNodes,
     }));
     const reviewThreads = rawThreadPages.map((t) => {
         const comment = t.comments.nodes[0];
+        const comments = t.comments.nodes.map((c) => ({
+            id: c.id,
+            isMinimized: c.isMinimized,
+            author: c.author?.login ?? "unknown",
+            authorType: mapAuthorType(c.author?.__typename),
+            body: c.body,
+            url: c.url,
+            createdAtUnix: parseCreatedAt(c.createdAt),
+        }));
         return {
             id: t.id,
             isResolved: t.isResolved,
             isOutdated: t.isOutdated,
             isMinimized: comment?.isMinimized ?? false,
-            path: comment?.path ?? null,
-            line: comment?.line ?? null,
-            startLine: comment?.startLine ?? null,
+            path: t.path ?? comment?.path ?? null,
+            line: t.line ?? comment?.line ?? null,
+            startLine: t.startLine ?? comment?.startLine ?? null,
             author: comment?.author?.login ?? "unknown",
             authorType: mapAuthorType(comment?.author?.__typename),
             body: comment?.body ?? "",
             url: comment?.url ?? "",
             createdAtUnix: comment ? parseCreatedAt(comment.createdAt) : 0,
+            comments,
         };
     });
     const comments = rawCommentNodes.map((c) => ({
@@ -64,14 +74,28 @@ export function parseRawPr(raw, rawThreadPages, rawCommentNodes, rawReviewNodes,
             const event = node.checkSuite?.workflowRun?.event ?? null;
             const runId = extractRunId(node.detailsUrl);
             const summary = extractCheckRunSummary(node.title, node.summary);
+            const rawCreatedAt = node.checkSuite
+                ? (node.checkSuite.workflowRun?.createdAt ?? node.checkSuite.createdAt)
+                : undefined;
+            const rawUpdatedAt = node.checkSuite
+                ? (node.checkSuite.workflowRun?.updatedAt ?? node.checkSuite.updatedAt)
+                : undefined;
+            const createdAtUnix = rawCreatedAt ? parseCreatedAt(rawCreatedAt) : undefined;
+            const startedAtUnix = node.startedAt ? parseCreatedAt(node.startedAt) : undefined;
+            const updatedAtUnix = rawUpdatedAt ? parseCreatedAt(rawUpdatedAt) : undefined;
             return [
                 {
+                    id: node.id,
                     name: node.name,
                     status: node.status,
                     conclusion: node.conclusion,
+                    source: "check_run",
                     detailsUrl: node.detailsUrl ?? "",
                     event,
                     runId,
+                    ...(createdAtUnix !== undefined && { createdAtUnix }),
+                    ...(startedAtUnix !== undefined && { startedAtUnix }),
+                    ...(updatedAtUnix !== undefined && { updatedAtUnix }),
                     ...(summary !== undefined && { summary }),
                 },
             ];
@@ -79,14 +103,17 @@ export function parseRawPr(raw, rawThreadPages, rawCommentNodes, rawReviewNodes,
         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 }),
                 },
             ];

package/bin/github/batch-parsers.test-support.mjs

@@ -1,5 +1,4 @@
-// @ts-nocheck
-import { describe, it, expect, vi, beforeEach } from "vitest";
+import { vi, beforeEach } from "vitest";
 vi.mock("./client.mts", () => ({
     graphql: vi.fn(),
     graphqlWithRateLimit: vi.fn(),

package/bin/github/batch.mjs

@@ -1,5 +1,6 @@
 import { graphql, graphqlWithRateLimit } from "./client.mjs";
 import { paginateForward, paginateBackward } from "./pagination.mjs";
+import { hydrateThreadCommentPages } from "./thread-comments.mjs";
 import { BATCH_PR_QUERY } from "./queries.mjs";
 import { parseRawPr } from "./batch-parsers.mjs";
 /**
@@ -36,6 +37,7 @@ export async function fetchPrBatch(pr, repo, opts = {}) {
         // extra contains pages before the first page.
         rawThreadPages = [...extra, ...rawThreadPages];
     }
+    rawThreadPages = await hydrateThreadCommentPages(rawThreadPages);
     // Paginate comments backward if the first page is incomplete.
     let rawCommentNodes = raw.comments.nodes;
     if (raw.comments.pageInfo.hasPreviousPage && raw.comments.pageInfo.startCursor) {

package/bin/github/batch.test-support.mjs

@@ -1,5 +1,4 @@
-// @ts-nocheck
-import { describe, it, expect, vi, beforeEach } from "vitest";
+import { vi, beforeEach } from "vitest";
 vi.mock("./client.mts", () => ({
     graphql: vi.fn(),
     graphqlWithRateLimit: vi.fn(),

package/bin/github/check-annotations.mjs

@@ -0,0 +1,75 @@
+import { createHash } from "node:crypto";
+import { graphql } from "./client.mjs";
+import { CHECK_RUN_ANNOTATIONS_QUERY } from "./queries.mjs";
+const ANNOTATIONS_PER_PAGE = 100;
+const MAX_ANNOTATION_PAGES = 10;
+export async function fetchCheckRunAnnotations(checkRunId) {
+    let cursor = null;
+    const nodes = [];
+    for (let page = 1; page <= MAX_ANNOTATION_PAGES; page++) {
+        // eslint-disable-next-line no-await-in-loop
+        const result = await fetchAnnotationPage(checkRunId, cursor);
+        nodes.push(...result.nodes);
+        if (!result.pageInfo.hasNextPage || !result.pageInfo.endCursor)
+            break;
+        if (page === MAX_ANNOTATION_PAGES) {
+            process.stderr.write(`pr-shepherd: annotation pagination cap (${MAX_ANNOTATION_PAGES * ANNOTATIONS_PER_PAGE} annotations) reached for check run ${checkRunId} — annotation output may be incomplete\n`);
+            break;
+        }
+        cursor = result.pageInfo.endCursor;
+    }
+    return nodes.map((node) => toCheckAnnotation(checkRunId, node));
+}
+async function fetchAnnotationPage(checkRunId, cursor) {
+    const res = await graphql(CHECK_RUN_ANNOTATIONS_QUERY, {
+        id: checkRunId,
+        ...(cursor ? { cursor } : {}),
+    });
+    const node = res.data.node;
+    if (node?.__typename !== "CheckRun" || node.annotations === undefined) {
+        return { pageInfo: { hasNextPage: false, endCursor: null }, nodes: [] };
+    }
+    return node.annotations;
+}
+function toCheckAnnotation(checkRunId, raw) {
+    const id = `check_annotation_${raw.fullDatabaseId ?? fallbackId(checkRunId, raw)}`;
+    const title = raw.title?.trim() || undefined;
+    const rawDetails = raw.rawDetails?.trim() || undefined;
+    const blobUrl = raw.blobUrl?.trim() || undefined;
+    return {
+        id,
+        path: raw.path,
+        startLine: raw.location?.start.line ?? null,
+        endLine: raw.location?.end.line ?? raw.location?.start.line ?? null,
+        ...(raw.location?.start.column !== undefined && {
+            startColumn: raw.location.start.column,
+        }),
+        ...(raw.location?.end.column !== undefined && {
+            endColumn: raw.location.end.column,
+        }),
+        level: raw.annotationLevel,
+        ...(title !== undefined && { title }),
+        message: raw.message,
+        ...(rawDetails !== undefined && { rawDetails }),
+        ...(blobUrl !== undefined && { blobUrl }),
+    };
+}
+function fallbackId(checkRunId, raw) {
+    const start = raw.location?.start;
+    const end = raw.location?.end;
+    const parts = [
+        checkRunId,
+        raw.path,
+        raw.annotationLevel,
+        raw.title ?? "",
+        raw.message,
+        raw.rawDetails ?? "",
+        raw.blobUrl ?? "",
+        String(start?.line ?? ""),
+        String(start?.column ?? ""),
+        String(end?.line ?? ""),
+        String(end?.column ?? ""),
+    ];
+    const input = parts.map((part) => `${part.length}:${part}`).join("|");
+    return createHash("sha256").update(input).digest("hex").slice(0, 24);
+}

package/bin/github/client.test-support.mjs

@@ -0,0 +1,55 @@
+import { vi, beforeEach, afterEach } from "vitest";
+import { _resetTokenCache } from "./http.mjs";
+export const mockFetch = vi.fn();
+vi.stubGlobal("fetch", mockFetch);
+const { _mockExecFile } = vi.hoisted(() => ({ _mockExecFile: vi.fn() }));
+export const mockExecFile = _mockExecFile;
+vi.mock("node:child_process", () => ({
+    execFile: (cmd, args, optsOrCb, maybeCb) => {
+        const cb = typeof optsOrCb === "function" ? optsOrCb : maybeCb;
+        _mockExecFile(cmd, args)
+            .then((result) => cb(null, result))
+            .catch((err) => cb(err, { stdout: "", stderr: "" }));
+    },
+}));
+export function gqlOk(data) {
+    return {
+        ok: true,
+        status: 200,
+        headers: new Headers({ "content-type": "application/json" }),
+        json: () => Promise.resolve({ data }),
+        text: () => Promise.resolve(JSON.stringify({ data })),
+    };
+}
+export function restOk(data) {
+    return {
+        ok: true,
+        status: 200,
+        headers: new Headers({ "content-type": "application/json" }),
+        json: () => Promise.resolve(data),
+        text: () => Promise.resolve(JSON.stringify(data)),
+    };
+}
+export function gqlErrors(errors) {
+    return {
+        ok: true,
+        status: 200,
+        headers: new Headers({ "content-type": "application/json" }),
+        json: () => Promise.resolve({ data: null, errors }),
+        text: () => Promise.resolve(JSON.stringify({ data: null, errors })),
+    };
+}
+export function registerClientHooks() {
+    beforeEach(() => {
+        mockFetch.mockReset();
+        mockExecFile.mockReset();
+        _resetTokenCache();
+        delete process.env["GITHUB_TOKEN"];
+        delete process.env["GITHUB_PERSONAL_ACCESS_TOKEN"];
+        process.env["GH_TOKEN"] = "test-token";
+    });
+    afterEach(() => {
+        delete process.env["GH_TOKEN"];
+        _resetTokenCache();
+    });
+}

package/bin/github/gql/batch-pr.gql

@@ -67,8 +67,14 @@ query BatchPr(
           id
           isResolved
           isOutdated
-          # first: 1 — we want the reviewer's original comment, not the latest reply.
-          comments(first: 1) {
+          path
+          line
+          startLine
+          comments(first: 100) {
+            pageInfo {
+              hasNextPage
+              endCursor
+            }
             nodes {
               id
               isMinimized
@@ -164,21 +170,28 @@ query BatchPr(
                 nodes {
                   __typename
                   ... on CheckRun {
+                    id
                     name
                     status
                     conclusion
                     detailsUrl
+                    startedAt
                     title
                     summary
                     checkSuite {
+                      createdAt
+                      updatedAt
                       workflowRun {
                         event
+                        createdAt
+                        updatedAt
                       }
                     }
                   }
                   ... on StatusContext {
                     context
                     state
+                    createdAt
                     targetUrl
                     description
                   }