pr-shepherd 0.35.0 → 0.36.0

package/bin/commands/iterate/index.mjs

@@ -5,7 +5,7 @@ import { graphql } from "../../github/http.mjs";
 import { MARK_PR_READY_MUTATION } from "../../github/queries.mjs";
 import { loadConfig } from "../../config/load.mjs";
 import { EXIT, ShepherdError } from "../../exit-codes.mjs";
-import { getCurrentHeadSha, buildSummary, buildRelevantChecks, buildActiveChecks, buildWaitLog, buildSuppressedCheckFields, buildTerminalCancelResult, } from "./helpers.mjs";
+import { getCurrentHeadSha, buildSummary, buildRelevantChecks, buildActiveChecks, buildWaitLog, buildSuppressedCheckFields, buildTerminalCancelResult, blockedCancelNote, } from "./helpers.mjs";
 import { classifyReviewSummaries } from "./classify.mjs";
 import { applyStallGuard } from "./stall.mjs";
 import { clearStallState } from "../../state/iterate-stall.mjs";
@@ -90,6 +90,7 @@ export async function runIterate(opts) {
         summary: buildSummary(report),
         baseBranch: report.baseBranch,
         branchProtection: report.branchProtection,
+        mergeRequirements: report.mergeStatus.mergeRequirements,
         checks: buildRelevantChecks(report),
         inProgressChecks: buildActiveChecks(report),
         ...buildSuppressedCheckFields(report),
@@ -97,15 +98,7 @@ export async function runIterate(opts) {
     };
     if (readyState.shouldCancel) {
         await clearStallState(stallKey);
-        let cancelNote;
-        if (base.mergeStatus !== "BLOCKED")
-            cancelNote = "has been ready for review";
-        else if (base.reviewDecision === "REVIEW_REQUIRED")
-            cancelNote = "is awaiting human review";
-        else if (base.reviewDecision === "APPROVED")
-            cancelNote = "is awaiting additional approvals";
-        else
-            cancelNote = "is awaiting human review or branch protection resolution";
+        const cancelNote = blockedCancelNote(base);
         return {
             ...base,
             action: "cancel",

package/bin/commands/poll.d.mts

@@ -2,6 +2,8 @@ import type { IterateCommandOptions, IterateResult } from "../types.mts";
 interface PollCommandOptions extends IterateCommandOptions {
     intervalSeconds: number;
     timeoutSeconds: number;
+    /** Settle window after first FIX_CODE before returning. Default 60. 0 disables. */
+    debounceSeconds?: number;
     quietStatus?: boolean;
     untilTerminal?: boolean;
 }

package/bin/commands/poll.mjs

@@ -1,5 +1,6 @@
 import { runIterate } from "./iterate/index.mjs";
 import { sleep } from "../util/sleep.mjs";
+const DEFAULT_POLL_DEBOUNCE_SECONDS = 60;
 function writeTickProgress(tick, elapsedSeconds, sleepSeconds, verbose) {
     if (verbose) {
         process.stderr.write(`[poll tick ${tick} / +${elapsedSeconds}s] WAIT — sleeping ${sleepSeconds}s\n`);
@@ -54,11 +55,18 @@ function writeWaitProgress(opts) {
     }
     return signature;
 }
+function writeDebounceProgress(tick, elapsedMs, remainingMs) {
+    const elapsedSeconds = Math.round(elapsedMs / 1000);
+    const remainingSeconds = Math.round(remainingMs / 1000);
+    process.stderr.write(`[poll tick ${tick} / +${elapsedSeconds}s] FIX_CODE — debounce ${remainingSeconds}s remaining\n`);
+}
 /** @deprecated Hidden implementation for the legacy `poll` alias. */
 export async function runPoll(opts) {
-    const { intervalSeconds, timeoutSeconds, quietStatus: quietStatusOpt, untilTerminal: untilTerminalOpt, ...iterateOpts } = opts;
+    const { intervalSeconds, timeoutSeconds, debounceSeconds: debounceSecondsOpt, quietStatus: quietStatusOpt, untilTerminal: untilTerminalOpt, ...iterateOpts } = opts;
     const intervalMs = Math.min(intervalSeconds * 1000, MAX_TIMER_MS);
     const timeoutMs = Math.min(timeoutSeconds * 1000, MAX_TIMER_MS);
+    const debounceSeconds = debounceSecondsOpt ?? DEFAULT_POLL_DEBOUNCE_SECONDS;
+    const debounceMs = Math.min(debounceSeconds * 1000, MAX_TIMER_MS);
     const start = Date.now();
     let tick = 0;
     let lastResult;
@@ -73,27 +81,30 @@ export async function runPoll(opts) {
     // terminal CANCEL/merged result. Pin the PR resolved by the first tick so later ticks target it
     // directly and never re-run branch discovery.
     let prNumber = opts.prNumber;
+    let debounceUntil = null;
     while (true) {
         tick += 1;
-        lastResult = await runIterate({ ...iterateOpts, prNumber });
+        const pastDebounce = debounceUntil !== null && Date.now() >= debounceUntil;
+        lastResult = await runIterate({
+            ...iterateOpts,
+            prNumber,
+            persistSeen: debounceSeconds === 0 || pastDebounce,
+        });
         prNumber ??= lastResult.pr;
-        if (lastResult.action !== "wait" && !(untilTerminal && lastResult.action === "mark_ready")) {
-            break;
-        }
-        const elapsedMs = Date.now() - start;
-        if (!untilTerminal) {
-            const remainingMs = timeoutMs - elapsedMs;
-            if (remainingMs <= 0)
-                break;
-            if (remainingMs + TIMER_DRIFT_TOLERANCE_MS < intervalMs)
-                break;
-        }
-        const nextSleepMs = intervalMs;
-        if (lastResult.action === "wait") {
+        if (lastResult.action === "wait" && !pastDebounce) {
+            debounceUntil = null;
+            const elapsedMs = Date.now() - start;
+            if (!untilTerminal) {
+                const remainingMs = timeoutMs - elapsedMs;
+                if (remainingMs <= 0)
+                    break;
+                if (remainingMs + TIMER_DRIFT_TOLERANCE_MS < intervalMs)
+                    break;
+            }
             lastWaitSignature = writeWaitProgress({
                 tick,
                 elapsedMs,
-                sleepMs: nextSleepMs,
+                sleepMs: intervalMs,
                 result: lastResult,
                 quietStatus,
                 verbose,
@@ -101,8 +112,31 @@ export async function runPoll(opts) {
             });
             if (!quietStatus && !verbose)
                 dotsPrinted = true;
+            await sleep(intervalMs);
+            continue;
+        }
+        if (untilTerminal && lastResult.action === "mark_ready" && !pastDebounce) {
+            debounceUntil = null;
+            await sleep(intervalMs);
+            continue;
+        }
+        if (lastResult.action === "fix_code" && debounceSeconds > 0 && !pastDebounce) {
+            debounceUntil ??= Date.now() + debounceMs;
+            const remainingMs = debounceUntil - Date.now();
+            if (remainingMs > 0) {
+                if (dotsPrinted) {
+                    process.stderr.write("\n");
+                    dotsPrinted = false;
+                }
+                writeDebounceProgress(tick, Date.now() - start, remainingMs);
+                await sleep(Math.min(intervalMs, remainingMs));
+            }
+            // Always continue so a tick that *started* before debounceUntil but *finished*
+            // after it cannot return with persistSeen: false. The next loop iteration
+            // sees pastDebounce and persists.
+            continue;
         }
-        await sleep(nextSleepMs);
+        break;
     }
     if (dotsPrinted)
         process.stderr.write("\n");

package/bin/commands/ready-delay.mjs

@@ -6,9 +6,8 @@
  * `readyDelaySeconds` consecutively. Any not-READY result resets the timer.
  */
 import { readFile, writeFile, mkdir, unlink } from "node:fs/promises";
-import { join, dirname } from "node:path";
-import { SAFE_SEGMENT } from "../util/path-segment.mjs";
-import { resolveStateBase } from "../state/base.mjs";
+import { dirname } from "node:path";
+import { resolvePrStatePath } from "../state/base.mjs";
 /**
  * Update the ready-delay state machine and return the current decision.
  *
@@ -57,16 +56,7 @@ export async function updateReadyDelay(prNumber, isReady, readyDelaySeconds, own
 // Helpers
 // ---------------------------------------------------------------------------
 function readySincePath(pr, owner, repo) {
-    for (const [field, value] of [
-        ["owner", owner],
-        ["repo", repo],
-    ]) {
-        if (!SAFE_SEGMENT.test(value)) {
-            throw new Error(`Invalid path segment "${field}": ${value}`);
-        }
-    }
-    const base = resolveStateBase();
-    return join(base, `${owner}-${repo}`, String(pr), "ready-since.txt");
+    return resolvePrStatePath({ owner, repo, pr }, "ready-since.txt");
 }
 async function safeUnlink(path) {
     try {

package/bin/config/load.mjs

@@ -1,24 +1,40 @@
 /* eslint-disable max-lines */
 import { readFileSync, statSync } from "node:fs";
-import { join, dirname } from "node:path";
+import { dirname, join, resolve } from "node:path";
 import { homedir } from "node:os";
 import { parse } from "yaml";
 import builtins from "../config.json" with { type: "json" };
 import { getEffectiveCwd } from "../execution-context.mjs";
 const MINIMIZE_COMMENTS_POLICIES = ["all", "bots", "users", "none"];
 const RC_FILENAME = ".pr-shepherdrc.yml";
-function findRcFile(startDir) {
-    const home = homedir();
-    let current = startDir;
-    while (true) {
-        const candidate = join(current, RC_FILENAME);
+/**
+ * Collect `.pr-shepherdrc.yml` files from `startDir` toward `$HOME` (closest first).
+ * `$HOME/.pr-shepherdrc.yml` is always included when it exists, even if cwd is
+ * outside the home directory. The walk never includes the filesystem root, so a
+ * `/.pr-shepherdrc.yml` cannot override the user-level file.
+ */
+function collectRcFiles(startDir) {
+    const home = resolve(homedir());
+    const seen = new Set();
+    const files = [];
+    const add = (dir) => {
+        const candidate = resolve(join(dir, RC_FILENAME));
+        if (seen.has(candidate))
+            return;
         if (statSync(candidate, { throwIfNoEntry: false })?.isFile()) {
-            return candidate;
+            seen.add(candidate);
+            files.push(candidate);
         }
-        if (current === home || current === dirname(current))
-            return null;
+    };
+    let current = resolve(startDir);
+    while (current !== dirname(current)) {
+        add(current);
+        if (current === home)
+            break;
         current = dirname(current);
     }
+    add(home);
+    return files;
 }
 function deepMerge(base, override) {
     const result = { ...base };
@@ -125,30 +141,56 @@ function warnUnknownConfigKeys(config) {
 }
 const defaults = builtins;
 const configCache = new Map();
+function stripDeprecatedActionKeys(parsed) {
+    const rawActions = parsed.actions;
+    if (rawActions === null || typeof rawActions !== "object" || Array.isArray(rawActions))
+        return;
+    const actions = rawActions;
+    for (const key of ["autoResolveOutdated", "commitSuggestions"]) {
+        if (key in actions) {
+            process.stderr.write(`pr-shepherd: config: actions.${key} is deprecated and ignored.\n`);
+            delete actions[key];
+        }
+    }
+}
+function readRcFile(rcPath) {
+    try {
+        const raw = readFileSync(rcPath, "utf8");
+        const parsed = (parse(raw) ?? {});
+        stripDeprecatedActionKeys(parsed);
+        warnUnknownConfigKeys(parsed);
+        return parsed;
+    }
+    catch (err) {
+        process.stderr.write(`pr-shepherd: failed to parse ${rcPath}: ${err instanceof Error ? err.message : String(err)}\n`);
+        return null;
+    }
+}
 export function loadConfig() {
     const cwd = getEffectiveCwd();
     if (configCache.has(cwd))
         return configCache.get(cwd);
-    const rcPath = findRcFile(cwd);
-    if (!rcPath) {
+    const rcPaths = collectRcFiles(cwd);
+    if (rcPaths.length === 0) {
         configCache.set(cwd, defaults);
         return defaults;
     }
     try {
-        const raw = readFileSync(rcPath, "utf8");
-        const parsed = (parse(raw) ?? {});
-        const rawActions = parsed.actions;
-        if (rawActions !== null && typeof rawActions === "object" && !Array.isArray(rawActions)) {
-            const actions = rawActions;
-            for (const key of ["autoResolveOutdated", "commitSuggestions"]) {
-                if (key in actions) {
-                    process.stderr.write(`pr-shepherd: config: actions.${key} is deprecated and ignored.\n`);
-                    delete actions[key];
-                }
-            }
+        // Farthest file first so closer directories override, ESLint-style.
+        let overlay = {};
+        let loaded = false;
+        for (const rcPath of [...rcPaths].reverse()) {
+            const parsed = readRcFile(rcPath);
+            if (parsed === null)
+                continue;
+            overlay = deepMerge(overlay, parsed);
+            loaded = true;
         }
-        warnUnknownConfigKeys(parsed);
-        const config = deepMerge(defaults, parsed);
+        if (!loaded) {
+            configCache.set(cwd, defaults);
+            return defaults;
+        }
+        const config = deepMerge(structuredClone(defaults), overlay);
         config.botUsernames = parseBotUsernames(config.botUsernames);
         config.ignoreChecks = parseIgnoreChecks(config.ignoreChecks);
         config.actions.neverCancelRuns = parseNeverCancelRuns(config.actions.neverCancelRuns);
@@ -157,7 +199,7 @@ export function loadConfig() {
         return config;
     }
     catch (err) {
-        process.stderr.write(`pr-shepherd: failed to parse ${rcPath}: ${err instanceof Error ? err.message : String(err)}\n`);
+        process.stderr.write(`pr-shepherd: failed to parse ${rcPaths[0]}: ${err instanceof Error ? err.message : String(err)}\n`);
         const fallback = { ...defaults };
         configCache.set(cwd, fallback);
         return fallback;

package/bin/github/batch-page-helpers.d.mts

@@ -0,0 +1,45 @@
+import type { RawContextNode, RawComment, RawPr, RawReview, RawReviewSummary, RawThread } from "./batch-raw-types.mts";
+export interface RawPageResponse {
+    repository: {
+        pullRequest: {
+            reviewThreads?: RawPr["reviewThreads"];
+            comments?: RawPr["comments"];
+            changesRequestedReviews?: RawPr["changesRequestedReviews"];
+            reviewSummaries?: RawPr["reviewSummaries"];
+            approvedReviews?: RawPr["approvedReviews"];
+            commits?: RawPr["commits"];
+        } | null;
+    };
+}
+export declare function backwardCursor(conn: {
+    pageInfo: {
+        hasPreviousPage: boolean;
+        startCursor: string | null;
+    };
+} | undefined): string | undefined;
+export declare function forwardCursor(conn: {
+    pageInfo: {
+        hasNextPage: boolean;
+        endCursor: string | null;
+    };
+} | undefined): string | undefined;
+export interface PageCursors {
+    threads?: string;
+    comments?: string;
+    changesRequested?: string;
+    reviewSummaries?: string;
+    approvedReviews?: string;
+    checks?: string;
+}
+export interface PageAccumulator {
+    threads: RawThread[];
+    comments: RawComment[];
+    changesRequested: RawReview[];
+    reviewSummaries: RawReviewSummary[];
+    approvedReviews: RawReviewSummary[];
+    checks: RawContextNode[];
+}
+export declare function applyIncludedPage(dest: PageAccumulator, pr2: NonNullable<RawPageResponse["repository"]["pullRequest"]>, cursors: PageCursors, firstOid: string | undefined, pageCount: number, pr: number): {
+    cursors: PageCursors;
+    pageCount: number;
+};

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

@@ -0,0 +1,63 @@
+import { requireContextNodes } from "./batch-response.mjs";
+export function backwardCursor(conn) {
+    if (conn?.pageInfo.hasPreviousPage === true && conn.pageInfo.startCursor) {
+        return conn.pageInfo.startCursor;
+    }
+    return undefined;
+}
+export function forwardCursor(conn) {
+    if (conn?.pageInfo.hasNextPage === true && conn.pageInfo.endCursor) {
+        return conn.pageInfo.endCursor;
+    }
+    return undefined;
+}
+function prependConnection(dest, conn, pr) {
+    if (!conn)
+        throw new Error(`PR #${pr} not found`);
+    dest.unshift(...conn.nodes);
+}
+function takeCheckPage(pr2, firstOid, pageCount) {
+    if (!pr2.commits?.nodes[0]?.commit.statusCheckRollup) {
+        throw new Error(`Check-context pagination interrupted: statusCheckRollup disappeared on page ${pageCount + 1} (possible force-push race). Retry after the push stabilizes.`);
+    }
+    const currentOid = pr2.commits.nodes[0]?.commit.oid;
+    if (firstOid !== undefined && currentOid !== undefined && currentOid !== firstOid) {
+        throw new Error(`Check-context pagination interrupted: head commit changed from ${firstOid} to ${currentOid} between pages (force-push race). Retry.`);
+    }
+    const ctxs = pr2.commits.nodes[0]?.commit.statusCheckRollup?.contexts;
+    if (!ctxs) {
+        return { pageInfo: { hasNextPage: false, endCursor: null }, nodes: [] };
+    }
+    return { ...ctxs, nodes: requireContextNodes(ctxs.nodes) };
+}
+export function applyIncludedPage(dest, pr2, cursors, firstOid, pageCount, pr) {
+    const next = {};
+    let nextPageCount = pageCount;
+    if (cursors.threads !== undefined) {
+        prependConnection(dest.threads, pr2.reviewThreads, pr);
+        next.threads = backwardCursor(pr2.reviewThreads);
+    }
+    if (cursors.comments !== undefined) {
+        prependConnection(dest.comments, pr2.comments, pr);
+        next.comments = backwardCursor(pr2.comments);
+    }
+    if (cursors.changesRequested !== undefined) {
+        prependConnection(dest.changesRequested, pr2.changesRequestedReviews, pr);
+        next.changesRequested = backwardCursor(pr2.changesRequestedReviews);
+    }
+    if (cursors.reviewSummaries !== undefined) {
+        prependConnection(dest.reviewSummaries, pr2.reviewSummaries, pr);
+        next.reviewSummaries = backwardCursor(pr2.reviewSummaries);
+    }
+    if (cursors.approvedReviews !== undefined) {
+        prependConnection(dest.approvedReviews, pr2.approvedReviews, pr);
+        next.approvedReviews = backwardCursor(pr2.approvedReviews);
+    }
+    if (cursors.checks !== undefined) {
+        nextPageCount++;
+        const extra = takeCheckPage(pr2, firstOid, nextPageCount);
+        dest.checks.push(...extra.nodes);
+        next.checks = forwardCursor(extra);
+    }
+    return { cursors: next, pageCount: nextPageCount };
+}

package/bin/github/batch-page.d.mts

@@ -0,0 +1,14 @@
+import { type RateLimitInfo, type RepoInfo } from "./client.mts";
+import { type PageAccumulator } from "./batch-page-helpers.mts";
+import type { RawPr } from "./batch-raw-types.mts";
+export interface PaginatedBatchNodes extends PageAccumulator {
+    rateLimit?: RateLimitInfo;
+}
+export interface PaginateBatchOptions {
+    paginateApprovedReviews?: boolean;
+}
+/**
+ * Fetch remaining connection pages with a slim `@include` query. Independent
+ * connections that still have cursors are combined into one request per round.
+ */
+export declare function paginateBatchConnections(pr: number, repo: RepoInfo, raw: RawPr, opts: PaginateBatchOptions, initialRateLimit?: RateLimitInfo): Promise<PaginatedBatchNodes>;

package/bin/github/batch-page.mjs

@@ -0,0 +1,62 @@
+import { graphqlWithRateLimit } from "./client.mjs";
+import { GitHubRequestError } from "./errors.mjs";
+import { BATCH_PR_PAGE_QUERY } from "./queries.mjs";
+import { requireContextNodes } from "./batch-response.mjs";
+import { applyIncludedPage, backwardCursor, forwardCursor, } from "./batch-page-helpers.mjs";
+/**
+ * Fetch remaining connection pages with a slim `@include` query. Independent
+ * connections that still have cursors are combined into one request per round.
+ */
+export async function paginateBatchConnections(pr, repo, raw, opts, initialRateLimit) {
+    const dest = {
+        threads: [...raw.reviewThreads.nodes],
+        comments: [...raw.comments.nodes],
+        changesRequested: [...raw.changesRequestedReviews.nodes],
+        reviewSummaries: [...raw.reviewSummaries.nodes],
+        approvedReviews: [...raw.approvedReviews.nodes],
+        checks: [
+            ...requireContextNodes(raw.commits.nodes[0]?.commit.statusCheckRollup?.contexts.nodes ?? []),
+        ],
+    };
+    const firstOid = raw.commits.nodes[0]?.commit.oid;
+    let cursors = {
+        threads: backwardCursor(raw.reviewThreads),
+        comments: backwardCursor(raw.comments),
+        changesRequested: backwardCursor(raw.changesRequestedReviews),
+        reviewSummaries: backwardCursor(raw.reviewSummaries),
+        approvedReviews: opts.paginateApprovedReviews === true ? backwardCursor(raw.approvedReviews) : undefined,
+        checks: forwardCursor(raw.commits.nodes[0]?.commit.statusCheckRollup?.contexts),
+    };
+    let rateLimit = initialRateLimit;
+    let pageCount = 0;
+    while (Object.values(cursors).some((cursor) => cursor !== undefined)) {
+        if (rateLimit?.remaining === 0) {
+            throw new GitHubRequestError("GitHub GraphQL rate limit remaining is 0; pagination incomplete", { status: 403, rateLimit });
+        }
+        const res = await graphqlWithRateLimit(BATCH_PR_PAGE_QUERY, {
+            owner: repo.owner,
+            repo: repo.name,
+            pr,
+            includeThreads: cursors.threads !== undefined,
+            threadsCursor: cursors.threads ?? null,
+            includeComments: cursors.comments !== undefined,
+            commentsCursor: cursors.comments ?? null,
+            includeChangesRequested: cursors.changesRequested !== undefined,
+            changesRequestedCursor: cursors.changesRequested ?? null,
+            includeReviewSummaries: cursors.reviewSummaries !== undefined,
+            reviewSummariesCursor: cursors.reviewSummaries ?? null,
+            includeApprovedReviews: cursors.approvedReviews !== undefined,
+            approvedReviewsCursor: cursors.approvedReviews ?? null,
+            includeChecks: cursors.checks !== undefined,
+            checksCursor: cursors.checks ?? null,
+        });
+        rateLimit = res.rateLimit ?? rateLimit;
+        const pr2 = res.data.repository.pullRequest;
+        if (!pr2)
+            throw new Error(`PR #${pr} not found`);
+        const applied = applyIncludedPage(dest, pr2, cursors, firstOid, pageCount, pr);
+        cursors = applied.cursors;
+        pageCount = applied.pageCount;
+    }
+    return { ...dest, rateLimit };
+}

package/bin/github/batch-parse-suites.d.mts

@@ -0,0 +1,4 @@
+import type { CheckRun } from "../types.mts";
+import type { RawPr } from "./batch-raw-types.mts";
+export declare function parseCheckSuitesComplete(raw: RawPr): boolean;
+export declare function parseSuiteStartupFailures(raw: RawPr): CheckRun[];

package/bin/github/batch-parse-suites.mjs

@@ -0,0 +1,25 @@
+export function parseCheckSuitesComplete(raw) {
+    return raw.commits.nodes[0]?.commit.checkSuites?.pageInfo.hasNextPage === false;
+}
+export function parseSuiteStartupFailures(raw) {
+    const suites = raw.commits.nodes[0]?.commit.checkSuites;
+    if (!suites)
+        return [];
+    return suites.nodes.flatMap((node) => {
+        if (node.conclusion !== "STARTUP_FAILURE" || node.workflowRun == null)
+            return [];
+        const runId = node.workflowRun.databaseId != null ? String(node.workflowRun.databaseId) : null;
+        const name = node.workflowRun.workflow?.name?.trim() || (runId ? `workflow run ${runId}` : "workflow run");
+        return [
+            {
+                name,
+                status: "COMPLETED",
+                conclusion: "STARTUP_FAILURE",
+                source: "startup_failure",
+                detailsUrl: node.workflowRun.url ?? "",
+                event: node.workflowRun.event,
+                runId,
+            },
+        ];
+    });
+}

package/bin/github/batch-parsers-rules.d.mts

@@ -0,0 +1,6 @@
+import type { BranchRules, MergeQueueEntryStatus, StackStatus } from "../types.mts";
+import type { RawBaseRef, RawPrMergeFields } from "./batch-raw-rules.mts";
+export declare const EMPTY_BRANCH_RULES: BranchRules;
+export declare function parseBranchRules(baseRef: RawBaseRef | null | undefined): BranchRules;
+export declare function parseMergeQueueEntry(raw: RawPrMergeFields["mergeQueueEntry"]): MergeQueueEntryStatus | null;
+export declare function parseStack(raw: RawPrMergeFields): StackStatus | null;

package/bin/github/batch-parsers-rules.mjs

@@ -0,0 +1,122 @@
+export const EMPTY_BRANCH_RULES = {
+    requiredApprovingReviewCount: 0,
+    requiresConversationResolution: false,
+    requiresCodeOwnerReviews: false,
+    requiresLastPushApproval: false,
+    requiresCommitSignatures: false,
+    requiresLinearHistory: false,
+    requiresStrictStatusChecks: false,
+    requiredStatusCheckContexts: [],
+    requiredDeploymentEnvironments: [],
+    requiresMergeQueue: false,
+    requiresWorkflows: false,
+    requiresCodeScanning: false,
+};
+export function parseBranchRules(baseRef) {
+    const rules = {
+        ...EMPTY_BRANCH_RULES,
+        requiredStatusCheckContexts: [],
+        requiredDeploymentEnvironments: [],
+    };
+    if (!baseRef)
+        return rules;
+    foldClassicProtection(rules, baseRef.branchProtectionRule);
+    for (const node of baseRef.rules?.nodes ?? [])
+        foldRulesetRule(rules, node);
+    return rules;
+}
+export function parseMergeQueueEntry(raw) {
+    if (!raw)
+        return null;
+    return {
+        position: raw.position,
+        state: raw.state,
+        estimatedTimeToMerge: raw.estimatedTimeToMerge,
+    };
+}
+export function parseStack(raw) {
+    if (!raw.stack)
+        return null;
+    return {
+        number: raw.stack.number,
+        size: raw.stack.size,
+        position: raw.stackEntry?.position ?? 0,
+        baseRefName: raw.stack.baseRefName,
+    };
+}
+function foldClassicProtection(rules, bp) {
+    if (!bp)
+        return;
+    if (bp.requiresApprovingReviews) {
+        rules.requiredApprovingReviewCount = Math.max(rules.requiredApprovingReviewCount, bp.requiredApprovingReviewCount ?? 0);
+    }
+    if (bp.requiresConversationResolution)
+        rules.requiresConversationResolution = true;
+    if (bp.requiresCodeOwnerReviews)
+        rules.requiresCodeOwnerReviews = true;
+    if (bp.requireLastPushApproval)
+        rules.requiresLastPushApproval = true;
+    if (bp.requiresCommitSignatures)
+        rules.requiresCommitSignatures = true;
+    if (bp.requiresLinearHistory)
+        rules.requiresLinearHistory = true;
+    if (bp.requiresStrictStatusChecks)
+        rules.requiresStrictStatusChecks = true;
+    if (bp.requiresStatusChecks) {
+        mergeUnique(rules.requiredStatusCheckContexts, bp.requiredStatusCheckContexts ?? []);
+    }
+    if (bp.requiresDeployments) {
+        mergeUnique(rules.requiredDeploymentEnvironments, bp.requiredDeploymentEnvironments ?? []);
+    }
+}
+function foldRulesetRule(rules, node) {
+    const p = node.parameters;
+    switch (node.type) {
+        case "PULL_REQUEST":
+            if (p?.requiredApprovingReviewCount != null) {
+                rules.requiredApprovingReviewCount = Math.max(rules.requiredApprovingReviewCount, p.requiredApprovingReviewCount);
+            }
+            if (p?.requiredReviewThreadResolution)
+                rules.requiresConversationResolution = true;
+            if (p?.requireCodeOwnerReview)
+                rules.requiresCodeOwnerReviews = true;
+            if (p?.requireLastPushApproval)
+                rules.requiresLastPushApproval = true;
+            break;
+        case "REQUIRED_REVIEW_THREAD_RESOLUTION":
+            rules.requiresConversationResolution = true;
+            break;
+        case "REQUIRED_STATUS_CHECKS":
+            if (p?.strictRequiredStatusChecksPolicy)
+                rules.requiresStrictStatusChecks = true;
+            mergeUnique(rules.requiredStatusCheckContexts, (p?.requiredStatusChecks ?? []).map((c) => c.context));
+            break;
+        case "REQUIRED_SIGNATURES":
+            rules.requiresCommitSignatures = true;
+            break;
+        case "REQUIRED_LINEAR_HISTORY":
+            rules.requiresLinearHistory = true;
+            break;
+        case "REQUIRED_DEPLOYMENTS":
+            mergeUnique(rules.requiredDeploymentEnvironments, p?.requiredDeploymentEnvironments ?? []);
+            break;
+        case "MERGE_QUEUE":
+            rules.requiresMergeQueue = true;
+            break;
+        case "WORKFLOWS":
+        case "REQUIRED_WORKFLOW_STATUS_CHECKS":
+            rules.requiresWorkflows = true;
+            break;
+        case "CODE_SCANNING":
+            rules.requiresCodeScanning = true;
+            break;
+        default:
+            break;
+    }
+}
+function mergeUnique(target, values) {
+    for (const value of values) {
+        if (value && !target.includes(value))
+            target.push(value);
+    }
+}