pr-shepherd 0.22.0 → 0.24.0

package/bin/commands/mark-files-as-viewed.mjs

@@ -0,0 +1,220 @@
+/* eslint-disable max-lines */
+import { graphql, graphqlWithRateLimit, getCurrentPrNumber, getRepoInfo, } from "../github/client.mjs";
+import { paginateForward } from "../github/pagination.mjs";
+import { isRateLimitMessage, rateLimitFromError, rateLimitFromGraphQlResult, } from "../comments/rate-limit.mjs";
+const FILES_QUERY = `query PullRequestFiles($owner: String!, $repo: String!, $pr: Int!, $filesCursor: String) {
+  repository(owner: $owner, name: $repo) {
+    pullRequest(number: $pr) {
+      id
+      number
+      files(first: 100, after: $filesCursor) {
+        pageInfo {
+          hasNextPage
+          endCursor
+        }
+        nodes {
+          path
+          viewerViewedState
+        }
+      }
+    }
+  }
+}`;
+const TEST_FILE_RE = /(^|\/)(tests?|__tests__|spec)(\/|$)|\.(test|spec)\.[cm]?[jt]sx?$|_tests?\.rs$|(^|\/)tests?\.rs$/i;
+const BULK_CHUNK_SIZE = 10;
+export async function runMarkFilesAsViewed(opts) {
+    const repo = await getRepoInfo();
+    const prNumber = opts.prNumber ?? (await getCurrentPrNumber());
+    if (!prNumber)
+        throw new Error("No PR number provided and no current branch PR found");
+    const matchPatterns = opts.matchPatterns ?? [];
+    const matchRegexes = matchPatterns.map((pattern) => compilePattern(pattern));
+    const fetched = await fetchPullRequestFiles(prNumber, repo);
+    const selected = selectChangedFiles(fetched.files, {
+        files: opts.files,
+        tests: opts.tests === true,
+        matchPatterns,
+        matchRegexes,
+    });
+    const result = {
+        repo: `${repo.owner}/${repo.name}`,
+        prNumber,
+        pullRequestId: fetched.pullRequestId,
+        requestedPaths: opts.files,
+        testSelector: opts.tests === true,
+        matchPatterns,
+        matchedPaths: selected.matchedPaths,
+        markedPaths: [],
+        alreadyViewedPaths: selected.alreadyViewedPaths,
+        missingPaths: selected.missingPaths,
+        unmatchedSelectors: selected.unmatchedSelectors,
+        errors: [],
+    };
+    await bulkMarkFilesAsViewed(fetched.pullRequestId, selected.pathsToMark, result);
+    return result;
+}
+async function fetchPullRequestFiles(pr, repo) {
+    const first = await graphql(FILES_QUERY, {
+        owner: repo.owner,
+        repo: repo.name,
+        pr,
+    });
+    const raw = first.data.repository?.pullRequest;
+    if (!raw)
+        throw new Error(`PR #${pr} not found`);
+    let files = raw.files.nodes;
+    if (raw.files.pageInfo.hasNextPage && raw.files.pageInfo.endCursor) {
+        const extra = await paginateForward(async (cursor) => {
+            const res = await graphql(FILES_QUERY, {
+                owner: repo.owner,
+                repo: repo.name,
+                pr,
+                ...(cursor ? { filesCursor: cursor } : {}),
+            });
+            const pr2 = res.data.repository?.pullRequest;
+            if (!pr2)
+                throw new Error(`PR #${pr} not found`);
+            return pr2.files;
+        }, raw.files.pageInfo.endCursor);
+        files = [...files, ...extra];
+    }
+    return { pullRequestId: raw.id, files };
+}
+function compilePattern(pattern) {
+    try {
+        return new RegExp(pattern, "i");
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        throw new Error(`Invalid --match regex ${JSON.stringify(pattern)}: ${msg}`);
+    }
+}
+function selectChangedFiles(changedFiles, opts) {
+    const byPath = new Map(changedFiles.map((f) => [f.path, f]));
+    const matched = new Set();
+    const missingPaths = [];
+    const unmatchedSelectors = [];
+    for (const path of opts.files) {
+        if (byPath.has(path))
+            matched.add(path);
+        else
+            missingPaths.push(path);
+    }
+    if (opts.tests) {
+        let matchedAny = false;
+        for (const file of changedFiles) {
+            if (TEST_FILE_RE.test(file.path)) {
+                matched.add(file.path);
+                matchedAny = true;
+            }
+        }
+        if (!matchedAny)
+            unmatchedSelectors.push("--tests");
+    }
+    for (let i = 0; i < opts.matchRegexes.length; i += 1) {
+        let matchedAny = false;
+        const regex = opts.matchRegexes[i];
+        for (const file of changedFiles) {
+            if (regex.test(file.path)) {
+                matched.add(file.path);
+                matchedAny = true;
+            }
+        }
+        if (!matchedAny)
+            unmatchedSelectors.push(`--match ${opts.matchPatterns[i]}`);
+    }
+    const matchedPaths = [...matched];
+    const alreadyViewedPaths = matchedPaths.filter((path) => byPath.get(path)?.viewerViewedState === "VIEWED");
+    const alreadyViewedSet = new Set(alreadyViewedPaths);
+    const pathsToMark = matchedPaths.filter((path) => !alreadyViewedSet.has(path));
+    return { matchedPaths, alreadyViewedPaths, missingPaths, unmatchedSelectors, pathsToMark };
+}
+function buildBulkMutation(paths) {
+    const ops = paths.map((path, i) => `  m${i}: markFileAsViewed(input: { pullRequestId: $pullRequestId, path: ${JSON.stringify(path)} }) { pullRequest { id } }`);
+    return `mutation BulkMarkFilesAsViewed($pullRequestId: ID!) {\n${ops.join("\n")}\n}`;
+}
+async function bulkMarkFilesAsViewed(pullRequestId, paths, result) {
+    for (let i = 0; i < paths.length; i += BULK_CHUNK_SIZE) {
+        const chunk = paths.slice(i, i + BULK_CHUNK_SIZE);
+        // eslint-disable-next-line no-await-in-loop
+        const stopped = await bulkMarkFilesAsViewedChunk(pullRequestId, chunk, result, i + BULK_CHUNK_SIZE < paths.length);
+        if (stopped) {
+            const markedSet = new Set(result.markedPaths);
+            result.unmarkedPaths = paths.slice(i).filter((path) => !markedSet.has(path));
+            return;
+        }
+    }
+}
+async function bulkMarkFilesAsViewedChunk(pullRequestId, paths, result, hasPendingAfter) {
+    if (paths.length === 0)
+        return false;
+    let data = {};
+    let graphQlErrors = [];
+    let suppressCurrentChunkErrors = false;
+    let rateLimitStop;
+    try {
+        const resp = await graphqlWithRateLimit(buildBulkMutation(paths), {
+            pullRequestId,
+        });
+        data = resp.data;
+        graphQlErrors = (resp.errors ?? []);
+        const messages = graphQlErrors.map((e) => e.message);
+        suppressCurrentChunkErrors = messages.some(isRateLimitMessage);
+        rateLimitStop = rateLimitFromGraphQlResult(messages, {
+            rateLimit: resp.rateLimit,
+            retryAfterSeconds: resp.retryAfterSeconds,
+            stopOnZeroRemaining: hasPendingAfter,
+        });
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        const stop = rateLimitFromError(err, msg);
+        if (stop) {
+            result.errors.push(`rate limit: ${stop.message}`);
+            result.rateLimit = stop;
+            return true;
+        }
+        for (const path of paths)
+            result.errors.push(`${path}: ${msg}`);
+        return false;
+    }
+    const errorMessagesByAlias = mapAliasErrors(graphQlErrors);
+    for (let i = 0; i < paths.length; i += 1) {
+        const alias = `m${i}`;
+        const m = data[alias];
+        if (m?.pullRequest?.id === pullRequestId) {
+            result.markedPaths.push(paths[i]);
+        }
+        else if (!suppressCurrentChunkErrors) {
+            result.errors.push(`${paths[i]}: ${errorMessagesByAlias.get(alias) ?? "mark returned null"}`);
+        }
+    }
+    if (rateLimitStop) {
+        result.errors.push(`rate limit: ${rateLimitStop.message}`);
+        result.rateLimit = rateLimitStop;
+        return true;
+    }
+    return false;
+}
+function mapAliasErrors(errors) {
+    const out = new Map();
+    for (const error of errors) {
+        if (!Array.isArray(error.path))
+            continue;
+        const alias = error.path.find((part) => typeof part === "string" && isMarkAlias(part));
+        if (typeof alias === "string")
+            out.set(alias, error.message);
+    }
+    return out;
+}
+function isMarkAlias(value) {
+    if (!value.startsWith("m"))
+        return false;
+    if (value.length === 1)
+        return false;
+    for (const char of value.slice(1)) {
+        if (char < "0" || char > "9")
+            return false;
+    }
+    return true;
+}

package/bin/commands/resolve-instructions.mjs

@@ -51,8 +51,11 @@ export function buildFetchInstructions(prNumber, result) {
         : reviewSummaries.length > 0
             ? ` Review-summary IDs (\`PRR_…\` from \`## Review summaries\`) go into \`--minimize-comment-ids\`.`
             : "";
-    const resolveCommand = `${buildPrShepherdCommand(["resolve", String(prNumber)]).text} [--resolve-thread-ids <ids>] [--minimize-comment-ids <ids>] [--dismiss-review-ids <ids> --message "<reason>"]`;
-    instructions.push(`Run \`${resolveCommand}\` with only the non-empty flag subsets. Skip the command entirely if all three ID lists are empty.${requireShaHint}${dismissNote}`);
+    const resolveCommand = `${buildPrShepherdCommand(["resolve", String(prNumber)]).text} [--reply-thread-ids <ids>] [--resolve-thread-ids <ids>] [--minimize-comment-ids <ids>] [--dismiss-review-ids <ids>] [--message "<reason>"]`;
+    if (actionableThreads.length > 0 || resolutionOnlyThreads.length > 0) {
+        instructions.push(`Do not reply to your own thread comments. If the latest visible comment in a thread is your own prior Shepherd reply, leave that thread out of \`--reply-thread-ids\`.`);
+    }
+    instructions.push(`Run \`${resolveCommand}\` with only the non-empty flag subsets. Skip the command entirely if all ID lists are empty.${requireShaHint}${dismissNote}`);
     instructions.push(buildShepherdJournalInstruction(prNumber, SHEPHERD_JOURNAL_REFERENCE_GUIDANCE_THREADS_AND_COMMENTS_IN_ITEMS));
     instructions.push(`Report: echo the CLI's mutation output, then one line per Acknowledged item: \`Acknowledged <id> (@<author>): <reason>\`. If any fetched item was neither resolved nor acknowledged, stop and escalate: "<N> item(s) fetched but not acted on or acknowledged — need human direction before closing".`);
     return instructions;

package/bin/commands/resolve-mutate.mjs

@@ -1,16 +1,61 @@
 import { getRepoInfo, getCurrentPrNumber } from "../github/client.mjs";
 import { applyResolveOptions } from "../comments/resolve.mjs";
+import { fetchPrBatch } from "../github/batch.mjs";
+import { loadConfig } from "../config/load.mjs";
+import { isConfiguredBotAuthor, isHumanAuthor, normalizeBotUsernames, } from "../comments/authors.mjs";
+import { markReplySeen } from "../state/seen-comments.mjs";
+import { threadTranscriptBody } from "../threads/transcript.mjs";
 export async function runResolveMutate(opts) {
     const repo = await getRepoInfo();
     const prNumber = opts.prNumber ?? (await getCurrentPrNumber());
     if (prNumber === null) {
         throw new Error("No open PR found for current branch. Pass a PR number explicitly.");
     }
-    return applyResolveOptions(prNumber, repo, {
-        resolveThreadIds: opts.resolveThreadIds,
-        minimizeCommentIds: opts.minimizeCommentIds,
-        dismissReviewIds: opts.dismissReviewIds,
+    const { data } = await fetchPrBatch(prNumber, repo, { paginateApprovedReviews: true });
+    const config = loadConfig();
+    const botUsernames = normalizeBotUsernames(config.botUsernames);
+    const threadById = new Map(data.reviewThreads.map((t) => [t.id, t]));
+    const humanThreadIds = new Set(data.reviewThreads
+        .filter((t) => isHumanAuthor(t) && !isConfiguredBotAuthor(t, botUsernames))
+        .map((t) => t.id));
+    const humanCommentIds = new Set(data.comments
+        .filter((c) => isHumanAuthor(c) && !isConfiguredBotAuthor(c, botUsernames))
+        .map((c) => c.id));
+    const humanReviewIds = new Set([...data.reviewSummaries, ...data.approvedReviews, ...data.changesRequestedReviews]
+        .filter((r) => isHumanAuthor(r) && !isConfiguredBotAuthor(r, botUsernames))
+        .map((r) => r.id));
+    const resolveThreadIds = (opts.resolveThreadIds ?? []).filter((id) => !humanThreadIds.has(id));
+    const skippedHumanResolves = (opts.resolveThreadIds ?? []).filter((id) => humanThreadIds.has(id));
+    const replyThreadIds = opts.replyThreadIds?.filter((id) => humanThreadIds.has(id));
+    const skippedNonHumanReplies = (opts.replyThreadIds ?? []).filter((id) => !humanThreadIds.has(id));
+    const minimizeCommentIds = (opts.minimizeCommentIds ?? []).filter((id) => !humanCommentIds.has(id) && !humanReviewIds.has(id));
+    const skippedHumanMinimizes = (opts.minimizeCommentIds ?? []).filter((id) => humanCommentIds.has(id) || humanReviewIds.has(id));
+    const dismissReviewIds = (opts.dismissReviewIds ?? []).filter((id) => !humanReviewIds.has(id));
+    const skippedHumanDismissals = (opts.dismissReviewIds ?? []).filter((id) => humanReviewIds.has(id));
+    const result = await applyResolveOptions(prNumber, repo, {
+        resolveThreadIds,
+        replyThreadIds,
+        minimizeCommentIds,
+        dismissReviewIds,
         dismissMessage: opts.dismissMessage,
         requireSha: opts.requireSha,
     });
+    if (skippedHumanResolves.length > 0)
+        result.skippedHumanResolves = skippedHumanResolves;
+    if (skippedHumanMinimizes.length > 0)
+        result.skippedHumanMinimizes = skippedHumanMinimizes;
+    if (skippedHumanDismissals.length > 0)
+        result.skippedHumanDismissals = skippedHumanDismissals;
+    if (skippedNonHumanReplies.length > 0)
+        result.skippedNonHumanReplies = skippedNonHumanReplies;
+    if (opts.dismissMessage) {
+        await Promise.all(result.repliedThreads.map((id) => {
+            const thread = threadById.get(id);
+            if (!thread)
+                return Promise.resolve();
+            const previousBody = threadTranscriptBody(thread);
+            return markReplySeen({ owner: repo.owner, repo: repo.name, pr: prNumber }, id, previousBody, threadTranscriptBody(thread, [opts.dismissMessage]), opts.dismissMessage);
+        }));
+    }
+    return result;
 }

package/bin/commands/resolve.mjs

@@ -1,13 +1,15 @@
 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";
+import { markReviewInlineThreadMarkers } from "../comments/review-thread-markers.mjs";
+import { normalizeBotUsernames } from "../comments/authors.mjs";
 export { runResolveMutate } from "./resolve-mutate.mjs";
 export async function runResolveFetch(opts) {
     const repo = await getRepoInfo();
@@ -17,39 +19,11 @@ 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, threadTranscriptBody(t), 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, threadTranscriptBody(t), 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, threadTranscriptBody(t), seenMap);
-        if (cls === "new")
-            unseenMinimizedThreads.push(t);
-        else if (cls === "edited")
-            editedMinimizedThreads.push(t);
-    }
+    const cfg = loadConfig();
+    const botUsernames = normalizeBotUsernames(cfg.botUsernames);
+    const threadVisibility = classifyThreadVisibility(data.reviewThreads, seenMap, botUsernames);
     const unseenMinimizedComments = [];
     const editedMinimizedComments = [];
     for (const c of minimizedCommentCandidates) {
@@ -59,52 +33,18 @@ 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 visibleCommentClassification = classifyVisibleComments(data.comments, seenMap, cfg.iterate?.minimizeComments, botUsernames);
+    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) => ({
@@ -115,19 +55,22 @@ 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, threadTranscriptBody(t))),
+        ...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)),
     ]);
+    await markReviewInlineThreadMarkers(stateKey, data.reviewThreads);
     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/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,32 @@
+function isBotLogin(login) {
+    return (login ?? "").toLowerCase().includes("[bot]");
+}
+function normalizeBotUsername(login) {
+    return (login ?? "")
+        .trim()
+        .toLowerCase()
+        .replace(/\[bot\]$/i, "");
+}
+export function normalizeBotUsernames(botUsernames = []) {
+    return new Set((botUsernames ?? []).map((name) => normalizeBotUsername(name)));
+}
+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);
+}
+export function isConfiguredBotAuthor(author, botUsernames = new Set()) {
+    const login = author.author ?? author.login ?? "";
+    if (author.authorType === "Bot" || isBotLogin(login))
+        return true;
+    const normalized = normalizeBotUsername(login);
+    if (normalized === "")
+        return false;
+    return botUsernames.has(normalized);
+}

package/bin/comments/minimize-policy.mjs

@@ -1,12 +1,16 @@
-export function shouldMinimizeAuthor(authorType, policy) {
+import { isConfiguredBotAuthor, isHumanAuthor } from "./authors.mjs";
+export function shouldMinimizeAuthor(authorType, policy, author, botUsernames = new Set()) {
+    const isConfiguredBot = isConfiguredBotAuthor({ author, authorType }, botUsernames);
+    if (isHumanAuthor({ author, authorType }) && !isConfiguredBot)
+        return false;
     switch (policy) {
         case undefined:
         case "all":
-            return true;
+            return authorType !== "User" || isConfiguredBot;
         case "bots":
-            return authorType === "Bot";
+            return isConfiguredBot;
         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)