pr-shepherd 0.16.3 → 0.17.0

package/bin/comments/resolve.mjs

@@ -1,9 +1,48 @@
+/* eslint-disable max-lines */
 import { graphqlWithRateLimit } from "../github/client.mjs";
 import { isRateLimitMessage, rateLimitFromError, rateLimitFromGraphQlResult, } from "./rate-limit.mjs";
 import { setPendingOps } from "./pending-ops.mjs";
 import { waitForSha } from "./sha-poll.mjs";
+const COMMENTED_DISMISS_ERROR_PATTERNS = [
+    /can\s*not\s+dismiss[\s\S]*?commented pull request review/i,
+];
+function dedupeIds(ids) {
+    const seen = new Set();
+    const out = [];
+    for (const id of ids) {
+        if (seen.has(id))
+            continue;
+        seen.add(id);
+        out.push(id);
+    }
+    return out;
+}
+function isCommentedDismissError(message) {
+    return COMMENTED_DISMISS_ERROR_PATTERNS.some((pattern) => pattern.test(message));
+}
+function dismissReviewNonDismissibleMessage(id) {
+    return `Not dismissed: ${id} is a COMMENTED review. Use --minimize-comment-ids instead; --dismiss-review-ids is only for CHANGES_REQUESTED reviews.`;
+}
 export async function applyResolveOptions(pr, repo, opts) {
-    if ((opts.dismissReviewIds?.length ?? 0) > 0 && !opts.dismissMessage) {
+    const resolveThreadIds = dedupeIds(opts.resolveThreadIds ?? []);
+    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 = {
+        resolvedThreads: [],
+        minimizedComments: [],
+        dismissedReviews: [],
+        errors: [],
+    };
+    if (overlappingDismissIds.length > 0) {
+        result.skippedDismissals = [];
+        for (const id of overlappingDismissIds) {
+            result.skippedDismissals.push(id);
+        }
+    }
+    if (filteredDismissReviewIds.length > 0 && !opts.dismissMessage) {
         throw new Error("--message is required when dismissing reviews");
     }
     if (opts.requireSha) {
@@ -11,13 +50,7 @@ export async function applyResolveOptions(pr, repo, opts) {
         // before reviewers see the fix.
         await waitForSha(pr, repo, opts.requireSha);
     }
-    const result = {
-        resolvedThreads: [],
-        minimizedComments: [],
-        dismissedReviews: [],
-        errors: [],
-    };
-    await bulkApply(opts.resolveThreadIds ?? [], opts.minimizeCommentIds ?? [], opts.dismissReviewIds ?? [], opts.dismissMessage ?? "", result);
+    await bulkApply(resolveThreadIds, minimizeCommentIds, filteredDismissReviewIds, opts.dismissMessage ?? "", result);
     return result;
 }
 export async function autoResolveOutdated(threadIds) {
@@ -65,13 +98,15 @@ async function bulkApplyChunk(resolveIds, minimizeIds, dismissIds, dismissMessag
     if (resolveIds.length === 0 && minimizeIds.length === 0 && dismissIds.length === 0)
         return false;
     const doc = buildBulkMutation(resolveIds, minimizeIds, dismissIds, dismissMessage);
-    let data;
+    let data = {};
+    let graphQlErrors = [];
     let rateLimitStop;
     let suppressCurrentChunkErrors = false;
     try {
         const resp = await graphqlWithRateLimit(doc, {});
         data = resp.data;
-        const graphQlErrorMessages = resp.errors?.map((e) => e.message) ?? [];
+        graphQlErrors = (resp.errors ?? []);
+        const graphQlErrorMessages = graphQlErrors.map((e) => e.message);
         suppressCurrentChunkErrors = graphQlErrorMessages.some(isRateLimitMessage);
         rateLimitStop = rateLimitFromGraphQlResult(graphQlErrorMessages, {
             rateLimit: resp.rateLimit,
@@ -109,12 +144,27 @@ async function bulkApplyChunk(resolveIds, minimizeIds, dismissIds, dismissMessag
         else if (!suppressCurrentChunkErrors)
             result.errors.push(`${minimizeIds[i]}: minimize returned null or comment not minimized`);
     }
+    const singleDismiss = dismissIds.length === 1;
+    const commentedDismissErrorIndexes = new Set();
+    let hasUnmappedCommentedDismissError = false;
+    for (const error of graphQlErrors) {
+        if (!isCommentedDismissError(error.message))
+            continue;
+        const alias = dismissErrorAliasIndex(error);
+        if (alias === undefined) {
+            hasUnmappedCommentedDismissError = true;
+            continue;
+        }
+        commentedDismissErrorIndexes.add(alias);
+    }
     for (let i = 0; i < dismissIds.length; i++) {
         const d = data[`d${i}`];
         if (d?.pullRequestReview != null)
             result.dismissedReviews.push(dismissIds[i]);
         else if (!suppressCurrentChunkErrors)
-            result.errors.push(`${dismissIds[i]}: dismiss returned null`);
+            result.errors.push(commentedDismissErrorIndexes.has(i) || (singleDismiss && hasUnmappedCommentedDismissError)
+                ? dismissReviewNonDismissibleMessage(dismissIds[i])
+                : `${dismissIds[i]}: dismiss returned null`);
     }
     if (rateLimitStop) {
         result.errors.push(`rate limit: ${rateLimitStop.message}`);
@@ -123,3 +173,12 @@ async function bulkApplyChunk(resolveIds, minimizeIds, dismissIds, dismissMessag
     }
     return false;
 }
+function dismissErrorAliasIndex(error) {
+    if (!Array.isArray(error.path))
+        return undefined;
+    const alias = error.path.find((part) => typeof part === "string" && /^d\d+$/.test(part));
+    if (typeof alias !== "string")
+        return undefined;
+    const parsed = Number.parseInt(alias.slice(1), 10);
+    return Number.isNaN(parsed) ? undefined : parsed;
+}

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

@@ -0,0 +1,40 @@
+// @ts-nocheck
+import { describe, it, expect, vi, beforeEach } from "vitest";
+// ---------------------------------------------------------------------------
+// Mock github/client.mts before any imports.
+// ---------------------------------------------------------------------------
+vi.mock("../github/client.mts", () => ({
+    graphqlWithRateLimit: vi.fn(),
+    getPrHeadSha: vi.fn(),
+}));
+import { applyResolveOptions, autoResolveOutdated } from "./resolve.mjs";
+import { graphqlWithRateLimit, getPrHeadSha } from "../github/client.mjs";
+const mockGraphql = vi.mocked(graphqlWithRateLimit);
+const mockGetPrHeadSha = vi.mocked(getPrHeadSha);
+const REPO = { owner: "owner", name: "repo" };
+/** Build a mock response with the correct nested shape for each alias type (r/m/d). */
+function makeBulkResponse(doc) {
+    const str = typeof doc === "string" ? doc : "";
+    const data = {};
+    for (const [, alias] of str.matchAll(/^\s+([a-z]\d+):/gm)) {
+        if (alias.startsWith("r"))
+            data[alias] = { thread: { isResolved: true } };
+        else if (alias.startsWith("m"))
+            data[alias] = { minimizedComment: { isMinimized: true } };
+        else if (alias.startsWith("d"))
+            data[alias] = { pullRequestReview: { state: "DISMISSED" } };
+        else
+            data[alias] = {};
+    }
+    return { data };
+}
+// ---------------------------------------------------------------------------
+// applyResolveOptions
+// ---------------------------------------------------------------------------
+export function registerHooks() {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockGraphql.mockImplementation(async (doc) => makeBulkResponse(doc));
+    });
+}
+export { REPO, applyResolveOptions, autoResolveOutdated, getPrHeadSha, graphqlWithRateLimit, makeBulkResponse, mockGetPrHeadSha, mockGraphql, };

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

@@ -0,0 +1,67 @@
+// @ts-nocheck
+import { describe, it, expect, vi, beforeEach } from "vitest";
+vi.mock("./client.mts", () => ({
+    graphql: vi.fn(),
+    graphqlWithRateLimit: vi.fn(),
+}));
+import { fetchPrBatch } from "./batch.mjs";
+import { graphql, graphqlWithRateLimit } from "./client.mjs";
+const mockGraphql = vi.mocked(graphql);
+const mockGraphqlWithRateLimit = vi.mocked(graphqlWithRateLimit);
+const REPO = { owner: "owner", name: "repo" };
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function makeRawPr(overrides = {}) {
+    return {
+        id: "PR_kgDOAAA",
+        number: 42,
+        state: "OPEN",
+        isDraft: false,
+        mergeable: "MERGEABLE",
+        mergeStateStatus: "CLEAN",
+        reviewDecision: "APPROVED",
+        headRefOid: "abc123",
+        headRefName: "feature",
+        headRepository: { nameWithOwner: "owner/repo" },
+        baseRefName: "main",
+        reviewRequests: { nodes: [] },
+        latestReviews: { nodes: [] },
+        reviewThreads: {
+            pageInfo: { hasPreviousPage: false, startCursor: null },
+            nodes: [],
+        },
+        comments: {
+            pageInfo: { hasPreviousPage: false, startCursor: null },
+            nodes: [],
+        },
+        changesRequestedReviews: {
+            pageInfo: { hasPreviousPage: false, startCursor: null },
+            nodes: [],
+        },
+        reviewSummaries: {
+            pageInfo: { hasPreviousPage: false, startCursor: null },
+            nodes: [],
+        },
+        approvedReviews: {
+            pageInfo: { hasPreviousPage: false, startCursor: null },
+            nodes: [],
+        },
+        commits: { nodes: [{ commit: { statusCheckRollup: null } }] },
+        ...overrides,
+    };
+}
+function makeResponse(pr = makeRawPr()) {
+    return { data: { repository: { pullRequest: pr } } };
+}
+// ---------------------------------------------------------------------------
+// PR not found
+// ---------------------------------------------------------------------------
+export function registerHooks() {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockGraphql.mockResolvedValue(makeResponse());
+        mockGraphqlWithRateLimit.mockResolvedValue(makeResponse());
+    });
+}
+export { REPO, fetchPrBatch, graphql, graphqlWithRateLimit, makeRawPr, makeResponse, mockGraphql, mockGraphqlWithRateLimit, };

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

@@ -0,0 +1,67 @@
+// @ts-nocheck
+import { describe, it, expect, vi, beforeEach } from "vitest";
+vi.mock("./client.mts", () => ({
+    graphql: vi.fn(),
+    graphqlWithRateLimit: vi.fn(),
+}));
+import { fetchPrBatch } from "./batch.mjs";
+import { graphql, graphqlWithRateLimit } from "./client.mjs";
+const mockGraphql = vi.mocked(graphql);
+const mockGraphqlWithRateLimit = vi.mocked(graphqlWithRateLimit);
+const REPO = { owner: "owner", name: "repo" };
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function makeRawPr(overrides = {}) {
+    return {
+        id: "PR_kgDOAAA",
+        number: 42,
+        state: "OPEN",
+        isDraft: false,
+        mergeable: "MERGEABLE",
+        mergeStateStatus: "CLEAN",
+        reviewDecision: "APPROVED",
+        headRefOid: "abc123",
+        headRefName: "feature",
+        headRepository: { nameWithOwner: "owner/repo" },
+        baseRefName: "main",
+        reviewRequests: { nodes: [] },
+        latestReviews: { nodes: [] },
+        reviewThreads: {
+            pageInfo: { hasPreviousPage: false, startCursor: null },
+            nodes: [],
+        },
+        comments: {
+            pageInfo: { hasPreviousPage: false, startCursor: null },
+            nodes: [],
+        },
+        changesRequestedReviews: {
+            pageInfo: { hasPreviousPage: false, startCursor: null },
+            nodes: [],
+        },
+        reviewSummaries: {
+            pageInfo: { hasPreviousPage: false, startCursor: null },
+            nodes: [],
+        },
+        approvedReviews: {
+            pageInfo: { hasPreviousPage: false, startCursor: null },
+            nodes: [],
+        },
+        commits: { nodes: [{ commit: { statusCheckRollup: null } }] },
+        ...overrides,
+    };
+}
+function makeResponse(pr = makeRawPr()) {
+    return { data: { repository: { pullRequest: pr } } };
+}
+// ---------------------------------------------------------------------------
+// reviewSummaries — COMMENTED reviews surfaced for agent-driven minimize
+// ---------------------------------------------------------------------------
+export function registerHooks() {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockGraphql.mockResolvedValue(makeResponse());
+        mockGraphqlWithRateLimit.mockResolvedValue(makeResponse());
+    });
+}
+export { REPO, fetchPrBatch, graphql, graphqlWithRateLimit, makeRawPr, makeResponse, mockGraphql, mockGraphqlWithRateLimit, };

package/bin/github/client.mjs

@@ -34,7 +34,16 @@ export async function getCurrentPrNumber() {
         if (branch === "HEAD")
             return null;
         const repo = await getRepoInfo();
-        const result = await httpGraphql(PR_NUMBER_BY_BRANCH_QUERY, { owner: repo.owner, repo: repo.name, branch });
+        return getPrNumberForBranch(branch, repo.owner, repo.name);
+    }
+    catch {
+        return null;
+    }
+}
+/** Returns the PR number for a given branch, or null if no open PR is found. */
+export async function getPrNumberForBranch(branch, owner, repo) {
+    try {
+        const result = await httpGraphql(PR_NUMBER_BY_BRANCH_QUERY, { owner, repo, branch });
         return result.data.repository?.pullRequests.nodes[0]?.number ?? null;
     }
     catch {

package/bin/github/graphql-http.mjs

@@ -0,0 +1,73 @@
+import { appendEntry, nextEntry } from "../log/log-file.mjs";
+import { formatRequestEntry, formatResponseEntry } from "../log/session.mjs";
+import { GitHubRequestError } from "./errors.mjs";
+import { makeHeaders } from "./http-auth.mjs";
+import { requestWithTokenRetry } from "./http-request.mjs";
+import { parseRateLimit, parseRetryAfter, redactToken, sanitizeBody, } from "./http-utils.mjs";
+const BASE_URL = "https://api.github.com";
+async function graphqlInner(query, vars) {
+    const url = `${BASE_URL}/graphql`;
+    const n = nextEntry();
+    appendEntry(formatRequestEntry({
+        n,
+        kind: "GraphQL",
+        method: "POST",
+        url,
+        body: { query, variables: vars },
+    }));
+    const t0 = performance.now();
+    const { res, attempt, retryT0 } = await requestWithTokenRetry(async () => fetch(url, {
+        method: "POST",
+        headers: await makeHeaders(),
+        body: JSON.stringify({ query, variables: vars }),
+    }), t0, (status, durationMs) => appendEntry(formatResponseEntry({ n, kind: "GraphQL", method: "POST", url, status, durationMs })));
+    const durationMs = Math.round(performance.now() - retryT0);
+    const rateLimit = parseRateLimit(res.headers);
+    const retryAfterSeconds = parseRetryAfter(res.headers);
+    if (!res.ok) {
+        const body = await res.text();
+        appendEntry(formatResponseEntry({
+            n,
+            kind: "GraphQL",
+            method: "POST",
+            url,
+            status: res.status,
+            durationMs,
+            textBody: redactToken(body),
+            attempt: attempt > 1 ? attempt : undefined,
+        }));
+        throw new GitHubRequestError(`GitHub GraphQL request failed: ${res.status} ${sanitizeBody(body)}`, { status: res.status, rateLimit: rateLimit ?? undefined, retryAfterSeconds });
+    }
+    const parsed = (await res.json());
+    appendEntry(formatResponseEntry({
+        n,
+        kind: "GraphQL",
+        method: "POST",
+        url,
+        status: res.status,
+        durationMs,
+        body: parsed,
+        attempt: attempt > 1 ? attempt : undefined,
+    }));
+    if (parsed.data == null) {
+        const messages = (parsed.errors ?? []).map((e) => e.message).join("; ");
+        throw new GitHubRequestError(`GitHub GraphQL error (no data): ${messages}`, {
+            status: res.status,
+            rateLimit: rateLimit ?? undefined,
+            retryAfterSeconds,
+        });
+    }
+    if (parsed.errors?.length) {
+        const messages = parsed.errors.map((e) => e.message).join("; ");
+        process.stderr.write(`pr-shepherd: GraphQL non-fatal errors: ${messages}\n`);
+    }
+    return { data: parsed.data, rateLimit, retryAfterSeconds, errors: parsed.errors };
+}
+export async function graphql(query, vars = {}) {
+    const { data } = await graphqlInner(query, vars);
+    return { data };
+}
+export async function graphqlWithRateLimit(query, vars = {}) {
+    const { data, rateLimit, retryAfterSeconds, errors } = await graphqlInner(query, vars);
+    return { data, rateLimit: rateLimit ?? undefined, retryAfterSeconds, errors };
+}

package/bin/github/http-auth.mjs

@@ -0,0 +1,48 @@
+import { execFile as execFileCb } from "node:child_process";
+import { promisify } from "node:util";
+const execFile = promisify(execFileCb);
+let _token;
+export function _resetTokenCache() {
+    _token = undefined;
+}
+export function hasCachedToken() {
+    return _token !== undefined;
+}
+export function clearTokenCache() {
+    _token = undefined;
+}
+async function resolveToken() {
+    if (_token)
+        return _token;
+    const envToken = process.env["GH_TOKEN"] ?? process.env["GITHUB_TOKEN"];
+    if (envToken) {
+        _token = envToken;
+        return _token;
+    }
+    try {
+        const { stdout } = await execFile("gh", ["auth", "token"]);
+        const token = stdout.trim();
+        if (token) {
+            _token = token;
+            return _token;
+        }
+    }
+    catch {
+        // fall through to error
+    }
+    const codexToken = process.env["GITHUB_PERSONAL_ACCESS_TOKEN"];
+    if (codexToken) {
+        _token = codexToken;
+        return _token;
+    }
+    throw new Error("No GitHub token found. Set GH_TOKEN, GITHUB_TOKEN, or GITHUB_PERSONAL_ACCESS_TOKEN, or run `gh auth login`.");
+}
+export async function makeHeaders() {
+    return {
+        Authorization: `Bearer ${await resolveToken()}`,
+        Accept: "application/vnd.github+json",
+        "X-GitHub-Api-Version": "2022-11-28",
+        "User-Agent": "pr-shepherd",
+        "Content-Type": "application/json",
+    };
+}

package/bin/github/http-request.mjs

@@ -0,0 +1,15 @@
+import { clearTokenCache, hasCachedToken } from "./http-auth.mjs";
+export async function requestWithTokenRetry(fn, t0, onIntermediate) {
+    const res = await fn();
+    if (res.status === 401 && hasCachedToken()) {
+        onIntermediate?.(401, Math.round(performance.now() - t0));
+        try {
+            await res.arrayBuffer();
+        }
+        catch { }
+        clearTokenCache();
+        const retryT0 = performance.now();
+        return { res: await fn(), attempt: 2, retryT0 };
+    }
+    return { res, attempt: 1, retryT0: t0 };
+}

package/bin/github/http-utils.mjs

@@ -0,0 +1,34 @@
+export function sanitizeBody(body) {
+    return body.replace(/Bearer\s+\S+/gi, "[REDACTED]").slice(0, 200);
+}
+export function redactToken(body) {
+    return body.replace(/Bearer\s+\S+/gi, "[REDACTED]");
+}
+export function redactUrl(url) {
+    try {
+        const u = new URL(url);
+        return `${u.origin}${u.pathname}`;
+    }
+    catch {
+        return url;
+    }
+}
+export function parseRateLimit(headers) {
+    const rRaw = headers.get("x-ratelimit-remaining");
+    const lRaw = headers.get("x-ratelimit-limit");
+    const tRaw = headers.get("x-ratelimit-reset");
+    if (rRaw === null || lRaw === null || tRaw === null)
+        return null;
+    const remaining = Number(rRaw);
+    const limit = Number(lRaw);
+    const resetAt = Number(tRaw);
+    if (Number.isFinite(remaining) && Number.isFinite(limit) && Number.isFinite(resetAt)) {
+        return { remaining, limit, resetAt };
+    }
+    return null;
+}
+export function parseRetryAfter(headers) {
+    const raw = headers.get("retry-after");
+    const seconds = Number(raw);
+    return raw !== null && Number.isFinite(seconds) && seconds >= 0 ? seconds : undefined;
+}