pr-shepherd 0.21.0 → 0.23.0

package/bin/commands/resolve.mjs

@@ -1,12 +1,13 @@
 import { getRepoInfo, getCurrentPrNumber } from "../github/client.mjs";
 import { fetchPrBatch } from "../github/batch.mjs";
-import { getOutdatedThreads } from "../comments/outdated.mjs";
-import { autoResolveOutdated } from "../comments/resolve.mjs";
 import { loadConfig } from "../config/load.mjs";
 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";
+import { classifyThreadVisibility } from "../comments/thread-visibility.mjs";
+import { classifyReviewsForDisplay } from "../comments/review-visibility.mjs";
 export { runResolveMutate } from "./resolve-mutate.mjs";
 export async function runResolveFetch(opts) {
     const repo = await getRepoInfo();
@@ -16,39 +17,9 @@ export async function runResolveFetch(opts) {
     }
     const { data } = await fetchPrBatch(prNumber, repo);
     const stateKey = { owner: repo.owner, repo: repo.name, pr: prNumber };
-    const unresolvedThreads = data.reviewThreads.filter((t) => !t.isResolved);
-    const outdatedCandidates = data.reviewThreads.filter((t) => t.isOutdated);
-    const resolvedCandidates = data.reviewThreads.filter((t) => t.isResolved && !t.isOutdated);
-    const minimizedThreadCandidates = data.reviewThreads.filter((t) => t.isMinimized && !t.isResolved && !t.isOutdated);
     const minimizedCommentCandidates = data.comments.filter((c) => c.isMinimized);
     const seenMap = await loadSeenMap(stateKey);
-    const unseenOutdated = [];
-    const editedOutdated = [];
-    for (const t of outdatedCandidates) {
-        const cls = classifyItem(t.id, t.body, seenMap);
-        if (cls === "new")
-            unseenOutdated.push(t);
-        else if (cls === "edited")
-            editedOutdated.push(t);
-    }
-    const unseenResolved = [];
-    const editedResolved = [];
-    for (const t of resolvedCandidates) {
-        const cls = classifyItem(t.id, t.body, seenMap);
-        if (cls === "new")
-            unseenResolved.push(t);
-        else if (cls === "edited")
-            editedResolved.push(t);
-    }
-    const unseenMinimizedThreads = [];
-    const editedMinimizedThreads = [];
-    for (const t of minimizedThreadCandidates) {
-        const cls = classifyItem(t.id, t.body, seenMap);
-        if (cls === "new")
-            unseenMinimizedThreads.push(t);
-        else if (cls === "edited")
-            editedMinimizedThreads.push(t);
-    }
+    const threadVisibility = classifyThreadVisibility(data.reviewThreads, seenMap);
     const unseenMinimizedComments = [];
     const editedMinimizedComments = [];
     for (const c of minimizedCommentCandidates) {
@@ -58,52 +29,19 @@ export async function runResolveFetch(opts) {
         else if (cls === "edited")
             editedMinimizedComments.push(c);
     }
-    const outdated = getOutdatedThreads(unresolvedThreads);
-    const autoResolvedIds = new Set();
-    if (outdated.length > 0) {
-        const { resolved: resolvedIds, errors } = await autoResolveOutdated(outdated.map((t) => t.id));
-        for (const id of resolvedIds)
-            autoResolvedIds.add(id);
-        if (errors.length > 0) {
-            process.stderr.write(`pr-shepherd: auto-resolve outdated threads failed (continuing): ${errors.join(", ")}\n`);
-        }
-    }
-    const activeThreads = unresolvedThreads.filter((t) => !t.isOutdated && !t.isMinimized);
-    const resolutionOnlyThreads = unresolvedThreads.filter((t) => !autoResolvedIds.has(t.id) && (t.isOutdated || t.isMinimized));
     const cfg = loadConfig();
     const visibleCommentClassification = classifyVisibleComments(data.comments, seenMap, cfg.iterate?.minimizeComments);
-    const actionableThreads = activeThreads.map(({ isResolved: _r, isOutdated: _o, ...rest }) => {
+    const changesRequestedReviewVisibility = classifyReviewsForDisplay(data.changesRequestedReviews, seenMap);
+    const reviewSummaryVisibility = cfg.resolve.fetchReviewSummaries
+        ? classifyReviewsForDisplay(data.reviewSummaries, seenMap)
+        : { visible: [], toMarkSeen: [] };
+    const actionableThreads = threadVisibility.activeThreads.map(({ isResolved: _r, isOutdated: _o, ...rest }) => {
         const thread = rest;
         const suggestion = extractSuggestion(rest);
         if (suggestion)
             thread.suggestion = suggestion;
         return thread;
     });
-    const firstLookThreads = [
-        ...unseenOutdated.map((t) => ({
-            ...t,
-            firstLookStatus: "outdated",
-            autoResolved: autoResolvedIds.has(t.id),
-        })),
-        ...editedOutdated.map((t) => ({
-            ...t,
-            firstLookStatus: "outdated",
-            autoResolved: autoResolvedIds.has(t.id),
-            edited: true,
-        })),
-        ...unseenResolved.map((t) => ({ ...t, firstLookStatus: "resolved" })),
-        ...editedResolved.map((t) => ({
-            ...t,
-            firstLookStatus: "resolved",
-            edited: true,
-        })),
-        ...unseenMinimizedThreads.map((t) => ({ ...t, firstLookStatus: "minimized" })),
-        ...editedMinimizedThreads.map((t) => ({
-            ...t,
-            firstLookStatus: "minimized",
-            edited: true,
-        })),
-    ];
     const firstLookComments = [
         ...unseenMinimizedComments.map((c) => ({ ...c, firstLookStatus: "minimized" })),
         ...editedMinimizedComments.map((c) => ({
@@ -114,19 +52,21 @@ 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)),
+        ...threadVisibility.toMarkSeen.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)),
+        ...changesRequestedReviewVisibility.toMarkSeen.map((r) => markSeen(stateKey, r.id, r.body)),
+        ...reviewSummaryVisibility.toMarkSeen.map((r) => markSeen(stateKey, r.id, r.body)),
     ]);
     const result = {
         prNumber,
         actionableThreads,
-        resolutionOnlyThreads,
-        firstLookThreads,
+        resolutionOnlyThreads: threadVisibility.resolutionOnlyThreads,
+        firstLookThreads: threadVisibility.firstLookThreads,
         actionableComments: visibleCommentClassification.actionable,
         firstLookComments,
-        changesRequestedReviews: data.changesRequestedReviews,
-        reviewSummaries: cfg.resolve.fetchReviewSummaries ? data.reviewSummaries : [],
+        changesRequestedReviews: changesRequestedReviewVisibility.visible,
+        reviewSummaries: reviewSummaryVisibility.visible,
         commitSuggestionsEnabled: cfg.actions.commitSuggestions,
     };
     return { ...result, instructions: buildFetchInstructions(prNumber, result) };

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

@@ -102,8 +102,10 @@ function makeComment(overrides = {}) {
 export function registerHooks() {
     beforeEach(() => {
         vi.clearAllMocks();
+        mockFetchPrBatch.mockResolvedValue({ data: makeBatchData() });
         mockAutoResolveOutdated.mockResolvedValue({ resolved: [], errors: [] });
         mockApplyResolveOptions.mockResolvedValue({
+            repliedThreads: [],
             resolvedThreads: [],
             minimizedComments: [],
             dismissedReviews: [],

package/bin/commands/shepherd-journal.mjs

@@ -1,7 +1,7 @@
 export const SHEPHERD_JOURNAL_SECTION = "## Shepherd Journal";
 export const SHEPHERD_JOURNAL_SECTION_PATTERN = /^##\s+Shepherd\s+Journal$/;
 export const SHEPHERD_JOURNAL_APPEND_HINT = "If this section already exists, append your entries under it instead of creating a duplicate heading.";
-export const SHEPHERD_JOURNAL_FIRST_LOOK_GUIDANCE = "Review the bodies shown under `## Review summaries (first look)` — you are seeing these for the first time. Any IDs eligible for minimization are already included in the resolve command's `--minimize-comment-ids`; if any warrants a Shepherd Journal note, append it before running resolve.";
+export const SHEPHERD_JOURNAL_FIRST_LOOK_GUIDANCE = "Review the bodies shown under `## Review summaries (first look)` — you are seeing these for the first time. Eligible non-human IDs, when present, are already included in the resolve command's `--minimize-comment-ids`; if any warrants a Shepherd Journal note, append it before running resolve.";
 export function buildShepherdJournalInstruction(prNumber, itemReferenceGuidance) {
     return [
         `For any large decisions or rejections you made this iteration, add or update a \`${SHEPHERD_JOURNAL_SECTION}\` section in the PR description (\`gh pr edit ${prNumber} --body …\`) summarizing each decision.`,

package/bin/comments/authors.mjs

@@ -0,0 +1,14 @@
+export function isBotLogin(login) {
+    return (login ?? "").toLowerCase().includes("[bot]");
+}
+export function normalizeAuthorType(typeName, login) {
+    if (isBotLogin(login))
+        return "Bot";
+    if (typeName === "User" || typeName === "Bot")
+        return typeName;
+    return "Unknown";
+}
+export function isHumanAuthor(author) {
+    const login = author.author ?? author.login ?? "";
+    return author.authorType === "User" && !isBotLogin(login);
+}

package/bin/comments/minimize-policy.mjs

@@ -1,12 +1,15 @@
-export function shouldMinimizeAuthor(authorType, policy) {
+import { isHumanAuthor } from "./authors.mjs";
+export function shouldMinimizeAuthor(authorType, policy, author) {
+    if (isHumanAuthor({ author, authorType }))
+        return false;
     switch (policy) {
         case undefined:
         case "all":
-            return true;
+            return authorType !== "User";
         case "bots":
             return authorType === "Bot";
         case "users":
-            return authorType === "User";
+            return false;
         case "none":
             return false;
         default:

package/bin/comments/pending-ops.mjs

@@ -1,7 +1,11 @@
 export function setPendingOps(result, ops) {
     const resolved = new Set(result.resolvedThreads);
+    const replied = new Set(result.repliedThreads);
     const minimized = new Set(result.minimizedComments);
     const dismissed = new Set(result.dismissedReviews);
+    const unrepliedThreads = ops
+        .filter((op) => op.kind === "p" && !replied.has(op.id))
+        .map((op) => op.id);
     const unresolvedThreads = ops
         .filter((op) => op.kind === "r" && !resolved.has(op.id))
         .map((op) => op.id);
@@ -11,6 +15,8 @@ export function setPendingOps(result, ops) {
     const undismissedReviews = ops
         .filter((op) => op.kind === "d" && !dismissed.has(op.id))
         .map((op) => op.id);
+    if (unrepliedThreads.length > 0)
+        result.unrepliedThreads = unrepliedThreads;
     if (unresolvedThreads.length > 0)
         result.unresolvedThreads = unresolvedThreads;
     if (unminimizedComments.length > 0)

package/bin/comments/resolve.mjs

@@ -25,12 +25,14 @@ function dismissReviewNonDismissibleMessage(id) {
 }
 export async function applyResolveOptions(pr, repo, opts) {
     const resolveThreadIds = dedupeIds(opts.resolveThreadIds ?? []);
+    const replyThreadIds = dedupeIds(opts.replyThreadIds ?? []);
     const minimizeCommentIds = opts.minimizeCommentIds ?? [];
     const dismissReviewIds = dedupeIds(opts.dismissReviewIds ?? []);
     const minimizeCommentIdSet = new Set(minimizeCommentIds);
     const filteredDismissReviewIds = dismissReviewIds.filter((id) => !minimizeCommentIdSet.has(id));
     const overlappingDismissIds = dismissReviewIds.filter((id) => minimizeCommentIdSet.has(id));
     const result = {
+        repliedThreads: [],
         resolvedThreads: [],
         minimizedComments: [],
         dismissedReviews: [],
@@ -42,31 +44,35 @@ export async function applyResolveOptions(pr, repo, opts) {
             result.skippedDismissals.push(id);
         }
     }
-    if (filteredDismissReviewIds.length > 0 && !opts.dismissMessage) {
-        throw new Error("--message is required when dismissing reviews");
+    if ((filteredDismissReviewIds.length > 0 || replyThreadIds.length > 0) && !opts.dismissMessage) {
+        throw new Error("--message is required when replying to threads or dismissing reviews");
     }
     if (opts.requireSha) {
         // Verify GitHub received the commit before resolving — prevents auto-merge
         // before reviewers see the fix.
         await waitForSha(pr, repo, opts.requireSha);
     }
-    await bulkApply(resolveThreadIds, minimizeCommentIds, filteredDismissReviewIds, opts.dismissMessage ?? "", result);
+    await bulkApply(replyThreadIds, resolveThreadIds, minimizeCommentIds, filteredDismissReviewIds, opts.dismissMessage ?? "", result);
     return result;
 }
 export async function autoResolveOutdated(threadIds) {
     const result = {
+        repliedThreads: [],
         resolvedThreads: [],
         minimizedComments: [],
         dismissedReviews: [],
         errors: [],
     };
-    await bulkApply(threadIds, [], [], "", result);
+    await bulkApply([], threadIds, [], [], "", result);
     return { resolved: result.resolvedThreads, errors: result.errors };
 }
 // Keep mutation batches small so rate-limit stops leave a precise pending list.
 const BULK_CHUNK_SIZE = 10;
-function buildBulkMutation(resolveIds, minimizeIds, dismissIds, dismissMessage) {
+function buildBulkMutation(replyIds, resolveIds, minimizeIds, dismissIds, dismissMessage) {
     const ops = [];
+    for (let i = 0; i < replyIds.length; i++) {
+        ops.push(`  p${i}: addPullRequestReviewThreadReply(input: { pullRequestReviewThreadId: ${JSON.stringify(replyIds[i])}, body: ${JSON.stringify(dismissMessage)} }) { comment { id } }`);
+    }
     for (let i = 0; i < resolveIds.length; i++) {
         ops.push(`  r${i}: resolveReviewThread(input: { threadId: ${JSON.stringify(resolveIds[i])} }) { thread { isResolved } }`);
     }
@@ -78,8 +84,9 @@ function buildBulkMutation(resolveIds, minimizeIds, dismissIds, dismissMessage)
     }
     return `mutation BulkApply {\n${ops.join("\n")}\n}`;
 }
-async function bulkApply(resolveIds, minimizeIds, dismissIds, dismissMessage, result) {
+async function bulkApply(replyIds, resolveIds, minimizeIds, dismissIds, dismissMessage, result) {
     const allOps = [
+        ...replyIds.map((id) => ({ kind: "p", id })),
         ...resolveIds.map((id) => ({ kind: "r", id })),
         ...minimizeIds.map((id) => ({ kind: "m", id })),
         ...dismissIds.map((id) => ({ kind: "d", id })),
@@ -87,17 +94,15 @@ async function bulkApply(resolveIds, minimizeIds, dismissIds, dismissMessage, re
     for (let i = 0; i < allOps.length; i += BULK_CHUNK_SIZE) {
         const chunk = allOps.slice(i, i + BULK_CHUNK_SIZE);
         // eslint-disable-next-line no-await-in-loop
-        const stopped = await bulkApplyChunk(chunk.filter((o) => o.kind === "r").map((o) => o.id), chunk.filter((o) => o.kind === "m").map((o) => o.id), chunk.filter((o) => o.kind === "d").map((o) => o.id), dismissMessage, result, i + BULK_CHUNK_SIZE < allOps.length);
+        const stopped = await bulkApplyChunk(chunk.filter((o) => o.kind === "r").map((o) => o.id), chunk.filter((o) => o.kind === "p").map((o) => o.id), chunk.filter((o) => o.kind === "m").map((o) => o.id), chunk.filter((o) => o.kind === "d").map((o) => o.id), dismissMessage, result, i + BULK_CHUNK_SIZE < allOps.length);
         if (stopped) {
             setPendingOps(result, allOps.slice(i));
             return;
         }
     }
 }
-async function bulkApplyChunk(resolveIds, minimizeIds, dismissIds, dismissMessage, result, hasPendingAfter) {
-    if (resolveIds.length === 0 && minimizeIds.length === 0 && dismissIds.length === 0)
-        return false;
-    const doc = buildBulkMutation(resolveIds, minimizeIds, dismissIds, dismissMessage);
+async function bulkApplyChunk(resolveIds, replyIds, minimizeIds, dismissIds, dismissMessage, result, hasPendingAfter) {
+    const doc = buildBulkMutation(replyIds, resolveIds, minimizeIds, dismissIds, dismissMessage);
     let data = {};
     let graphQlErrors = [];
     let rateLimitStop;
@@ -122,6 +127,8 @@ async function bulkApplyChunk(resolveIds, minimizeIds, dismissIds, dismissMessag
             result.rateLimit = stop;
             return true;
         }
+        for (const id of replyIds)
+            result.errors.push(`${id}: ${msg}`);
         for (const id of resolveIds)
             result.errors.push(`${id}: ${msg}`);
         for (const id of minimizeIds)
@@ -130,6 +137,16 @@ async function bulkApplyChunk(resolveIds, minimizeIds, dismissIds, dismissMessag
             result.errors.push(`${id}: ${msg}`);
         return false;
     }
+    for (let i = 0; i < replyIds.length; i++) {
+        const id = replyIds[i];
+        if (id === undefined)
+            continue;
+        const p = data[`p${i}`];
+        if (p?.comment?.id)
+            result.repliedThreads.push(id);
+        else if (!suppressCurrentChunkErrors)
+            result.errors.push(`${id}: reply returned null or comment not created`);
+    }
     for (let i = 0; i < resolveIds.length; i++) {
         const r = data[`r${i}`];
         if (r?.thread?.isResolved === true)

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

@@ -15,9 +15,14 @@ const REPO = { owner: "owner", name: "repo" };
 function makeBulkResponse(doc) {
     const str = typeof doc === "string" ? doc : "";
     const data = {};
-    for (const [, alias] of str.matchAll(/^\s+([a-z]\d+):/gm)) {
+    for (const match of str.matchAll(/^\s+([a-z]\d+):/gm)) {
+        const alias = match[1];
+        if (alias === undefined)
+            continue;
         if (alias.startsWith("r"))
             data[alias] = { thread: { isResolved: true } };
+        else if (alias.startsWith("p"))
+            data[alias] = { comment: { id: `${alias}-comment` } };
         else if (alias.startsWith("m"))
             data[alias] = { minimizedComment: { isMinimized: true } };
         else if (alias.startsWith("d"))

package/bin/comments/review-visibility.mjs

@@ -0,0 +1,14 @@
+import { classifyItem } from "../state/seen-comments.mjs";
+export function classifyReviewsForDisplay(reviews, seenMap) {
+    const visible = [];
+    const toMarkSeen = [];
+    for (const review of reviews) {
+        const cls = classifyItem(review.id, review.body, seenMap);
+        if (cls === "unchanged")
+            continue;
+        const rendered = cls === "edited" ? { ...review, edited: true } : review;
+        visible.push(rendered);
+        toMarkSeen.push(review);
+    }
+    return { visible, toMarkSeen };
+}

package/bin/comments/thread-visibility.mjs

@@ -0,0 +1,60 @@
+import { classifyItem } from "../state/seen-comments.mjs";
+import { threadTranscriptBody } from "../threads/transcript.mjs";
+function withEdited(thread, edited) {
+    return edited ? { ...thread, edited: true } : thread;
+}
+function classifyVisibleThread(thread, seenMap) {
+    const cls = classifyItem(thread.id, threadTranscriptBody(thread), seenMap);
+    if (cls === "unchanged")
+        return null;
+    return withEdited(thread, cls === "edited");
+}
+function classifyFirstLookThread(thread, seenMap, firstLookStatus) {
+    const visible = classifyVisibleThread(thread, seenMap);
+    if (visible === null)
+        return null;
+    return { ...visible, firstLookStatus };
+}
+export function classifyThreadVisibility(threads, seenMap) {
+    const unresolvedThreads = threads.filter((t) => !t.isResolved);
+    const activeThreads = unresolvedThreads
+        .filter((t) => !t.isOutdated && !t.isMinimized)
+        .flatMap((t) => {
+        const visible = classifyVisibleThread(t, seenMap);
+        return visible ? [visible] : [];
+    });
+    const resolutionOnlyThreads = unresolvedThreads
+        .filter((t) => t.isOutdated || t.isMinimized)
+        .flatMap((t) => {
+        const visible = classifyVisibleThread(t, seenMap);
+        return visible ? [visible] : [];
+    });
+    const firstLookThreads = [
+        ...threads.flatMap((t) => {
+            if (!t.isOutdated)
+                return [];
+            const visible = classifyFirstLookThread(t, seenMap, "outdated");
+            return visible ? [visible] : [];
+        }),
+        ...threads.flatMap((t) => {
+            if (!t.isResolved || t.isOutdated)
+                return [];
+            const visible = classifyFirstLookThread(t, seenMap, "resolved");
+            return visible ? [visible] : [];
+        }),
+        ...threads.flatMap((t) => {
+            if (!t.isMinimized || t.isResolved || t.isOutdated)
+                return [];
+            const visible = classifyFirstLookThread(t, seenMap, "minimized");
+            return visible ? [visible] : [];
+        }),
+    ];
+    const seenMarkerIds = new Set();
+    const toMarkSeen = [...activeThreads, ...resolutionOnlyThreads, ...firstLookThreads].filter((thread) => {
+        if (seenMarkerIds.has(thread.id))
+            return false;
+        seenMarkerIds.add(thread.id);
+        return true;
+    });
+    return { activeThreads, resolutionOnlyThreads, firstLookThreads, toMarkSeen };
+}

package/bin/comments/visible-comments.mjs

@@ -5,7 +5,7 @@ export function classifyVisibleComments(comments, seenMap, minimizeComments) {
     const minimizeIds = [];
     const toMarkSeen = [];
     for (const c of comments.filter((comment) => !comment.isMinimized)) {
-        if (shouldMinimizeAuthor(c.authorType, minimizeComments)) {
+        if (shouldMinimizeAuthor(c.authorType, minimizeComments, c.author)) {
             actionable.push(c);
             minimizeIds.push(c.id);
             continue;

package/bin/config.json

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

package/bin/github/batch-parser-helpers.mjs

@@ -1,7 +1,6 @@
-export function mapAuthorType(typeName) {
-    if (typeName === "User" || typeName === "Bot")
-        return typeName;
-    return "Unknown";
+import { normalizeAuthorType } from "../comments/authors.mjs";
+export function mapAuthorType(typeName, login) {
+    return normalizeAuthorType(typeName, login);
 }
 export function parseCreatedAt(iso) {
     const ms = new Date(iso).getTime();

package/bin/github/batch-parsers.mjs

@@ -10,26 +10,36 @@ 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, c.author?.login),
+            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),
+            authorType: mapAuthorType(comment?.author?.__typename, comment?.author?.login),
             body: comment?.body ?? "",
             url: comment?.url ?? "",
             createdAtUnix: comment ? parseCreatedAt(comment.createdAt) : 0,
+            comments,
         };
     });
     const comments = rawCommentNodes.map((c) => ({
         id: c.id,
         isMinimized: c.isMinimized,
         author: c.author?.login ?? "unknown",
-        authorType: mapAuthorType(c.author?.__typename),
+        authorType: mapAuthorType(c.author?.__typename, c.author?.login),
         body: c.body,
         url: c.url,
         createdAtUnix: parseCreatedAt(c.createdAt),
@@ -37,7 +47,7 @@ export function parseRawPr(raw, rawThreadPages, rawCommentNodes, rawReviewNodes,
     const changesRequestedReviews = rawReviewNodes.map((r) => ({
         id: r.id,
         author: r.author?.login ?? "unknown",
-        authorType: mapAuthorType(r.author?.__typename),
+        authorType: mapAuthorType(r.author?.__typename, r.author?.login),
         body: r.body,
     }));
     const reviewSummaries = rawReviewSummaryNodes
@@ -45,7 +55,7 @@ export function parseRawPr(raw, rawThreadPages, rawCommentNodes, rawReviewNodes,
         .map((r) => ({
         id: r.id,
         author: r.author?.login ?? "unknown",
-        authorType: mapAuthorType(r.author?.__typename),
+        authorType: mapAuthorType(r.author?.__typename, r.author?.login),
         body: r.body,
     }));
     // APPROVED reviews often have empty bodies (clicking "Approve" without a comment), so
@@ -56,7 +66,7 @@ export function parseRawPr(raw, rawThreadPages, rawCommentNodes, rawReviewNodes,
         .map((r) => ({
         id: r.id,
         author: r.author?.login ?? "unknown",
-        authorType: mapAuthorType(r.author?.__typename),
+        authorType: mapAuthorType(r.author?.__typename, r.author?.login),
         body: r.body,
     }));
     const checks = rawCheckNodes.flatMap((node) => {
@@ -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.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) {