pr-shepherd 0.16.3 → 0.16.4

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

@@ -0,0 +1,25 @@
+// @ts-nocheck
+import { vi } from "vitest";
+import { NOW, makeOpts } from "./iterate-test-support.mjs";
+import { readStallState, writeStallState } from "../state/iterate-stall.mjs";
+const mockReadStallState = vi.mocked(readStallState);
+const mockWriteStallState = vi.mocked(writeStallState);
+const STALL_TIMEOUT_S = 1800;
+const RESOLUTION_ONLY_THREAD = {
+    id: "thread-resolution-only",
+    isResolved: false,
+    isOutdated: true,
+    isMinimized: false,
+    path: "src/old.mts",
+    line: null,
+    startLine: null,
+    author: "reviewer",
+    authorType: "Unknown",
+    body: "Already addressed on an old diff",
+    url: "",
+    createdAtUnix: NOW - 3600,
+};
+function makeOpts30mStall(overrides = {}) {
+    return makeOpts({ stallTimeoutSeconds: STALL_TIMEOUT_S, noAutoMarkReady: true, ...overrides });
+}
+export { RESOLUTION_ONLY_THREAD, STALL_TIMEOUT_S, makeOpts30mStall, mockReadStallState, mockWriteStallState, };

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

@@ -0,0 +1,149 @@
+import { vi, beforeEach, afterEach } from "vitest";
+const mockFetch = vi.fn();
+vi.stubGlobal("fetch", mockFetch);
+const { mockExecFile } = vi.hoisted(() => ({ mockExecFile: vi.fn() }));
+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: err.stderr ?? "" }));
+    },
+}));
+vi.mock("./check.mts", () => ({ runCheck: vi.fn() }));
+vi.mock("./ready-delay.mts", () => ({ updateReadyDelay: vi.fn() }));
+vi.mock("../github/client.mts", () => ({ getCurrentPrNumber: vi.fn().mockResolvedValue(42) }));
+vi.mock("../state/fix-attempts.mts", () => ({
+    readFixAttempts: vi.fn().mockResolvedValue(null),
+    writeFixAttempts: vi.fn().mockResolvedValue(undefined),
+}));
+vi.mock("../state/iterate-stall.mts", () => ({
+    readStallState: vi.fn().mockResolvedValue(null),
+    writeStallState: vi.fn().mockResolvedValue(undefined),
+    clearStallState: vi.fn().mockResolvedValue(undefined),
+}));
+const { mockLoadConfig } = vi.hoisted(() => ({ mockLoadConfig: vi.fn() }));
+vi.mock("../config/load.mts", () => ({ loadConfig: mockLoadConfig }));
+import { runCheck } from "./check.mjs";
+import { updateReadyDelay } from "./ready-delay.mjs";
+import { getCurrentPrNumber } from "../github/client.mjs";
+import { readFixAttempts, writeFixAttempts } from "../state/fix-attempts.mjs";
+import { clearStallState, readStallState, writeStallState } from "../state/iterate-stall.mjs";
+import { buildEscalateHumanMessage, buildEscalateSuggestion, checkEscalateTriggers, } from "./iterate/escalate.mjs";
+import { buildRelevantChecks, buildWaitLog, getCurrentHeadSha } from "./iterate/helpers.mjs";
+const mockRunCheck = vi.mocked(runCheck);
+const mockUpdateReadyDelay = vi.mocked(updateReadyDelay);
+const mockGetCurrentPrNumber = vi.mocked(getCurrentPrNumber);
+const mockReadFixAttempts = vi.mocked(readFixAttempts);
+const mockWriteFixAttempts = vi.mocked(writeFixAttempts);
+const mockReadStallState = vi.mocked(readStallState);
+const mockWriteStallState = vi.mocked(writeStallState);
+const mockClearStallState = vi.mocked(clearStallState);
+const NOW = 1_700_000_000;
+const READY_STATE_DEFAULT = { isReady: true, shouldCancel: false, remainingSeconds: 300 };
+function makeReport(overrides = {}) {
+    return {
+        pr: 42,
+        nodeId: "PR_kgDOAAA",
+        repo: "owner/repo",
+        status: "READY",
+        baseBranch: "main",
+        mergeStatus: {
+            status: "CLEAN",
+            state: "OPEN",
+            isDraft: false,
+            mergeable: "MERGEABLE",
+            reviewDecision: "APPROVED",
+            blockingBotReviewInProgress: false,
+            mergeStateStatus: "CLEAN",
+        },
+        checks: {
+            passing: [
+                {
+                    name: "ci",
+                    status: "COMPLETED",
+                    conclusion: "SUCCESS",
+                    detailsUrl: "https://github.com/owner/repo/actions/runs/1",
+                    event: "pull_request",
+                    runId: "run-1",
+                    category: "passed",
+                },
+            ],
+            failing: [],
+            inProgress: [],
+            skipped: [],
+            filtered: [],
+            filteredNames: [],
+            blockedByFilteredCheck: false,
+        },
+        threads: {
+            actionable: [],
+            resolutionOnly: [],
+            autoResolved: [],
+            autoResolveErrors: [],
+            firstLook: [],
+        },
+        comments: { actionable: [], firstLook: [] },
+        changesRequestedReviews: [],
+        reviewSummaries: [],
+        firstLookSummaries: [],
+        editedSummaries: [],
+        approvedReviews: [],
+        ...overrides,
+    };
+}
+function makeOpts(overrides = {}) {
+    return { prNumber: 42, format: "json", readyDelaySeconds: 600, ...overrides };
+}
+function makeReview(id, author, body) {
+    return { id, author, authorType: "Unknown", body };
+}
+function defaultConfig() {
+    return {
+        iterate: {
+            fixAttemptsPerThread: 3,
+            stallTimeoutMinutes: 30,
+            minimizeApprovals: false,
+            minimizeComments: "all",
+        },
+        watch: { readyDelayMinutes: 10 },
+        resolve: {
+            concurrency: 4,
+            shaPoll: { intervalMs: 2000, maxAttempts: 10 },
+            fetchReviewSummaries: true,
+        },
+        checks: { ciTriggerEvents: ["pull_request", "pull_request_target"] },
+        mergeStatus: { blockingReviewerLogins: ["copilot"] },
+        actions: { autoResolveOutdated: true, autoMarkReady: true, commitSuggestions: true },
+    };
+}
+function registerIterateHooks(config = defaultConfig) {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockLoadConfig.mockReturnValue(config());
+        process.env["GH_TOKEN"] = "test-token";
+        mockExecFile.mockImplementation((cmd, args) => {
+            if (cmd === "git" && args[0] === "rev-parse") {
+                return Promise.resolve({ stdout: "abc123", stderr: "" });
+            }
+            return Promise.resolve({ stdout: "", stderr: "" });
+        });
+        mockFetch.mockResolvedValue({
+            ok: true,
+            status: 200,
+            headers: new Headers({ "content-type": "application/json" }),
+            json: () => Promise.resolve({ data: {} }),
+            text: () => Promise.resolve('{"data":{}}'),
+        });
+        vi.useFakeTimers();
+        vi.setSystemTime(NOW * 1000);
+        mockUpdateReadyDelay.mockResolvedValue(READY_STATE_DEFAULT);
+        mockReadFixAttempts.mockResolvedValue(null);
+        mockWriteFixAttempts.mockResolvedValue(undefined);
+        mockReadStallState.mockResolvedValue(null);
+        mockWriteStallState.mockResolvedValue(undefined);
+        mockClearStallState.mockResolvedValue(undefined);
+    });
+    afterEach(() => vi.useRealTimers());
+}
+export { NOW, buildEscalateHumanMessage, buildEscalateSuggestion, buildRelevantChecks, buildWaitLog, checkEscalateTriggers, defaultConfig, getCurrentHeadSha, makeOpts, makeReport, makeReview, mockExecFile, mockFetch, mockGetCurrentPrNumber, mockClearStallState, mockLoadConfig, mockReadFixAttempts, mockReadStallState, mockRunCheck, mockUpdateReadyDelay, mockWriteFixAttempts, mockWriteStallState, registerIterateHooks, };

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

@@ -0,0 +1,118 @@
+// @ts-nocheck
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+const mockFetch = vi.fn();
+vi.stubGlobal("fetch", mockFetch);
+const { mockExecFile } = vi.hoisted(() => ({ mockExecFile: vi.fn() }));
+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: err.stderr ?? "" }));
+    },
+}));
+vi.mock("./check.mts", () => ({ runCheck: vi.fn() }));
+vi.mock("./ready-delay.mts", () => ({ updateReadyDelay: vi.fn() }));
+vi.mock("../github/client.mts", () => ({
+    getCurrentPrNumber: vi.fn().mockResolvedValue(42),
+}));
+vi.mock("../state/fix-attempts.mts", () => ({
+    readFixAttempts: vi.fn().mockResolvedValue(null),
+    writeFixAttempts: vi.fn().mockResolvedValue(undefined),
+}));
+vi.mock("../state/iterate-stall.mts", () => ({
+    readStallState: vi.fn().mockResolvedValue(null),
+    writeStallState: vi.fn().mockResolvedValue(undefined),
+}));
+const { mockLoadConfig } = vi.hoisted(() => ({ mockLoadConfig: vi.fn() }));
+vi.mock("../config/load.mts", () => ({ loadConfig: mockLoadConfig }));
+import { runIterate } from "./iterate/index.mjs";
+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";
+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);
+function makeReport(overrides = {}) {
+    return {
+        pr: 42,
+        nodeId: "PR_kgDOAAA",
+        repo: "owner/repo",
+        status: "READY",
+        baseBranch: "main",
+        mergeStatus: {
+            status: "CLEAN",
+            state: "OPEN",
+            isDraft: false,
+            mergeable: "MERGEABLE",
+            reviewDecision: "APPROVED",
+            blockingBotReviewInProgress: false,
+            mergeStateStatus: "CLEAN",
+        },
+        checks: {
+            passing: [],
+            failing: [],
+            inProgress: [],
+            skipped: [],
+            filtered: [],
+            filteredNames: [],
+            blockedByFilteredCheck: false,
+        },
+        threads: {
+            actionable: [],
+            resolutionOnly: [],
+            autoResolved: [],
+            autoResolveErrors: [],
+            firstLook: [],
+        },
+        comments: { actionable: [], firstLook: [] },
+        changesRequestedReviews: [],
+        reviewSummaries: [],
+        firstLookSummaries: [],
+        editedSummaries: [],
+        approvedReviews: [],
+        ...overrides,
+    };
+}
+function makeOpts(overrides = {}) {
+    return {
+        prNumber: 42,
+        format: "json",
+        readyDelaySeconds: 600,
+        ...overrides,
+    };
+}
+export function registerHooks() {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockExecFile.mockResolvedValue({ stdout: "abc1234\n", stderr: "" });
+        mockLoadConfig.mockReturnValue({
+            iterate: {
+                fixAttemptsPerThread: 3,
+                stallTimeoutMinutes: 60,
+                minimizeApprovals: false,
+            },
+            watch: { readyDelayMinutes: 10 },
+            resolve: {
+                concurrency: 4,
+                shaPoll: { intervalMs: 2000, maxAttempts: 10 },
+                fetchReviewSummaries: true,
+            },
+            checks: { ciTriggerEvents: ["pull_request"] },
+            mergeStatus: { blockingReviewerLogins: [] },
+            actions: { autoResolveOutdated: false, autoMarkReady: false, commitSuggestions: false },
+        });
+        mockReadFixAttempts.mockResolvedValue(null);
+        mockWriteFixAttempts.mockResolvedValue(undefined);
+        mockReadStallState.mockResolvedValue(null);
+        mockWriteStallState.mockResolvedValue(undefined);
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+}
+export { makeOpts, makeReport, mockExecFile, mockFetch, mockLoadConfig, mockReadFixAttempts, mockReadStallState, mockRunCheck, mockUpdateReadyDelay, mockWriteFixAttempts, mockWriteStallState, readFixAttempts, readStallState, runCheck, runIterate, updateReadyDelay, writeFixAttempts, writeStallState, };

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

@@ -0,0 +1,114 @@
+// @ts-nocheck
+import { describe, it, expect, vi, beforeEach } from "vitest";
+vi.mock("../github/client.mts", () => ({
+    getRepoInfo: vi.fn().mockResolvedValue({ owner: "owner", name: "repo" }),
+    getCurrentPrNumber: vi.fn().mockResolvedValue(42),
+}));
+vi.mock("../state/seen-comments.mts", async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        loadSeenMap: vi.fn().mockResolvedValue(new Map()),
+        markSeen: vi.fn().mockResolvedValue(undefined),
+    };
+});
+vi.mock("../github/batch.mts", () => ({
+    fetchPrBatch: vi.fn(),
+}));
+vi.mock("../comments/resolve.mts", () => ({
+    autoResolveOutdated: vi.fn(),
+    applyResolveOptions: vi.fn(),
+}));
+vi.mock("../config/load.mts", () => ({
+    loadConfig: vi.fn().mockReturnValue({
+        resolve: {
+            shaPoll: { intervalMs: 2000, maxAttempts: 10 },
+            fetchReviewSummaries: true,
+        },
+        actions: {
+            autoResolveOutdated: true,
+            autoMarkReady: true,
+            commitSuggestions: true,
+        },
+    }),
+}));
+import { runResolveFetch, runResolveMutate } from "./resolve.mjs";
+import { getCurrentPrNumber } from "../github/client.mjs";
+import { fetchPrBatch } from "../github/batch.mjs";
+import { autoResolveOutdated, applyResolveOptions } from "../comments/resolve.mjs";
+import { loadConfig } from "../config/load.mjs";
+import { loadSeenMap, markSeen, hashBody } from "../state/seen-comments.mjs";
+const mockGetCurrentPrNumber = vi.mocked(getCurrentPrNumber);
+const mockFetchPrBatch = vi.mocked(fetchPrBatch);
+const mockAutoResolveOutdated = vi.mocked(autoResolveOutdated);
+const mockApplyResolveOptions = vi.mocked(applyResolveOptions);
+const mockLoadConfig = vi.mocked(loadConfig);
+const mockLoadSeenMap = vi.mocked(loadSeenMap);
+const mockMarkSeen = vi.mocked(markSeen);
+const BASE_OPTS = { format: "text" };
+function makeBatchData(overrides = {}) {
+    return {
+        nodeId: "PR_kgDOAAA",
+        number: 42,
+        state: "OPEN",
+        isDraft: false,
+        mergeable: "MERGEABLE",
+        mergeStateStatus: "CLEAN",
+        reviewDecision: "APPROVED",
+        headRefOid: "abc123",
+        headRefName: "feature",
+        headRepoWithOwner: "owner/repo",
+        baseRefName: "main",
+        reviewRequests: [],
+        latestReviews: [],
+        reviewThreads: [],
+        comments: [],
+        changesRequestedReviews: [],
+        reviewSummaries: [],
+        approvedReviews: [],
+        checks: [],
+        ...overrides,
+    };
+}
+function makeThread(overrides = {}) {
+    return {
+        id: "t-1",
+        isResolved: false,
+        isOutdated: false,
+        isMinimized: false,
+        path: "src/foo.ts",
+        line: 1,
+        startLine: null,
+        author: "alice",
+        authorType: "Unknown",
+        body: "fix this",
+        url: "",
+        createdAtUnix: 1_700_000_000,
+        ...overrides,
+    };
+}
+function makeComment(overrides = {}) {
+    return {
+        id: "c-1",
+        isMinimized: false,
+        author: "bob",
+        authorType: "Unknown",
+        body: "nit",
+        url: "",
+        createdAtUnix: 1_700_000_000,
+        ...overrides,
+    };
+}
+export function registerHooks() {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockAutoResolveOutdated.mockResolvedValue({ resolved: [], errors: [] });
+        mockApplyResolveOptions.mockResolvedValue({
+            resolvedThreads: [],
+            minimizedComments: [],
+            dismissedReviews: [],
+            errors: [],
+        });
+    });
+}
+export { BASE_OPTS, applyResolveOptions, autoResolveOutdated, fetchPrBatch, getCurrentPrNumber, hashBody, loadConfig, loadSeenMap, makeBatchData, makeComment, makeThread, markSeen, mockApplyResolveOptions, mockAutoResolveOutdated, mockFetchPrBatch, mockGetCurrentPrNumber, mockLoadConfig, mockLoadSeenMap, mockMarkSeen, runResolveFetch, runResolveMutate, };

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

@@ -0,0 +1,9 @@
+// @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";
+function countMentions(text, phrase) {
+    return (text.match(new RegExp(phrase, "g")) ?? []).length;
+}
+export { SHEPHERD_JOURNAL_APPEND_HINT, SHEPHERD_JOURNAL_FIRST_LOOK_GUIDANCE, SHEPHERD_JOURNAL_REFERENCE_GUIDANCE_THREADS_AND_COMMENTS_IN_ITEMS, SHEPHERD_JOURNAL_REFERENCE_GUIDANCE_THREADS_AND_COMMENTS_IN_ITEM_HEADINGS, SHEPHERD_JOURNAL_SECTION, SHEPHERD_JOURNAL_SECTION_PATTERN, buildFetchInstructions, buildFixInstructions, buildShepherdJournalInstruction, countMentions, };

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/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 };
+}