pr-shepherd 0.34.0 → 0.36.0

package/bin/config/load.mjs

@@ -1,22 +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 };
@@ -41,6 +59,10 @@ function isMinimizeCommentsPolicy(value) {
     return MINIMIZE_COMMENTS_POLICIES.some((policy) => policy === value);
 }
 function parseMinimizeCommentsPolicy(value) {
+    if (value === "users") {
+        process.stderr.write('pr-shepherd: config: iterate.minimizeComments: "users" is deprecated and is now treated as "none".\n');
+        return "none";
+    }
     if (isMinimizeCommentsPolicy(value))
         return value;
     throw new Error(`Invalid config: iterate.minimizeComments must be one of "all", "bots", "users", or "none", got ${JSON.stringify(value)}`);
@@ -63,21 +85,112 @@ function parseNeverCancelRuns(value) {
     }
     return value;
 }
+const KNOWN_CONFIG_KEYS = new Set([
+    "classify",
+    "botUsernames",
+    "ignoreChecks",
+    "iterate",
+    "watch",
+    "resolve",
+    "checks",
+    "mergeStatus",
+    "actions",
+]);
+const KNOWN_NESTED_KEYS = {
+    iterate: new Set([
+        "fixAttemptsPerThread",
+        "stallTimeoutMinutes",
+        "minimizeApprovals",
+        "minimizeComments",
+        "behindBaseHint",
+    ]),
+    watch: new Set(["readyDelayMinutes"]),
+    resolve: new Set(["shaPoll"]),
+    checks: new Set(["ciTriggerEvents"]),
+    mergeStatus: new Set(["blockingReviewerLogins"]),
+    actions: new Set([
+        "autoMinimizeSuppressed",
+        "autoMarkReady",
+        "neverCancelRuns",
+        "autoResolveOutdated",
+        "commitSuggestions",
+    ]),
+};
+function warnUnknownConfigKeys(config) {
+    for (const key of Object.keys(config)) {
+        if (!KNOWN_CONFIG_KEYS.has(key)) {
+            process.stderr.write(`pr-shepherd: config: unknown key "${key}" ignored.\n`);
+            delete config[key];
+            continue;
+        }
+        const value = config[key];
+        const nested = KNOWN_NESTED_KEYS[key];
+        if (nested === undefined ||
+            value === null ||
+            typeof value !== "object" ||
+            Array.isArray(value)) {
+            continue;
+        }
+        for (const child of Object.keys(value)) {
+            if (!nested.has(child)) {
+                process.stderr.write(`pr-shepherd: config: unknown key "${key}.${child}" ignored.\n`);
+                delete value[child];
+            }
+        }
+    }
+}
 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 = process.cwd();
+    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 config = deepMerge(defaults, parsed);
+        // 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;
+        }
+        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);
@@ -86,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/config.json

@@ -37,10 +37,8 @@
     "blockingReviewerLogins": ["copilot"]
   },
   "actions": {
-    "autoResolveOutdated": true,
     "autoMinimizeSuppressed": true,
     "autoMarkReady": true,
-    "commitSuggestions": true,
     "neverCancelRuns": []
   }
 }

package/bin/execution-context.d.mts

@@ -0,0 +1,9 @@
+/**
+ * Runs work with an optional working directory without changing Node's global
+ * process state. This keeps independent API/MCP requests safe to run together.
+ */
+export declare function runWithExecutionCwd<T>(cwd: string | undefined, work: () => T): T;
+/** The caller-scoped working directory, when one was supplied. */
+export declare function getExecutionCwd(): string | undefined;
+/** The caller-scoped working directory, falling back to the CLI process cwd. */
+export declare function getEffectiveCwd(): string;

package/bin/execution-context.mjs

@@ -0,0 +1,19 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+const executionContext = new AsyncLocalStorage();
+/**
+ * Runs work with an optional working directory without changing Node's global
+ * process state. This keeps independent API/MCP requests safe to run together.
+ */
+export function runWithExecutionCwd(cwd, work) {
+    if (cwd === undefined)
+        return work();
+    return executionContext.run({ cwd }, work);
+}
+/** The caller-scoped working directory, when one was supplied. */
+export function getExecutionCwd() {
+    return executionContext.getStore()?.cwd;
+}
+/** The caller-scoped working directory, falling back to the CLI process cwd. */
+export function getEffectiveCwd() {
+    return getExecutionCwd() ?? process.cwd();
+}

package/bin/exit-codes.d.mts

@@ -0,0 +1,51 @@
+/**
+ * Process exit codes for the pr-shepherd CLI.
+ *
+ * Three bands:
+ *   0        done — shepherd finished and the PR is in a good terminal state
+ *   10-19    shepherd RAN successfully; the code reports PR state
+ *   64-78    shepherd FAILED (BSD `sysexits.h` codes)
+ *
+ * Caller rule: `$? >= 64` means shepherd itself failed. `0` or `10-19` means it
+ * ran to completion and is reporting PR state. See docs/exit-codes.md.
+ */
+import type { IterateResult } from "./types.mts";
+export declare const EXIT: Readonly<{
+    /** `cancel` + `merged` or `ready-delay-elapsed` — shepherd finished cleanly. */
+    readonly OK: 0;
+    /** Nothing to do yet; CI still in progress. */
+    readonly WAIT: 10;
+    /** Draft PR converted to ready for review. */
+    readonly MARK_READY: 11;
+    /** Agent work required. */
+    readonly FIX_CODE: 12;
+    /** Human attention required. */
+    readonly ESCALATE: 13;
+    /** `cancel` + `closed` — PR closed without merging. */
+    readonly CLOSED: 14;
+    /** Bad/unknown flag, unknown subcommand, missing required arg, invalid duration. */
+    readonly USAGE: 64;
+    /** Malformed caller data: bad `--require-sha`, `PRRC_*` IDs, bad repo string. */
+    readonly DATAERR: 65;
+    /** Input file/stdin could not be read. */
+    readonly NOINPUT: 66;
+    /** Precondition unmet: no open PR for branch, thread not eligible, unclassified 4xx. */
+    readonly UNAVAILABLE: 69;
+    /** Unexpected/unclassified internal error — the fallback. */
+    readonly SOFTWARE: 70;
+    /** Retryable GitHub failure: 429, 5xx, rate limit exhausted, `Retry-After` present. */
+    readonly TEMPFAIL: 75;
+    /** GitHub 401/403 — missing token or insufficient PAT scopes. */
+    readonly NOPERM: 77;
+    /** `.pr-shepherdrc.yml` validation failure. */
+    readonly CONFIG: 78;
+}>;
+/** An error that carries its own exit code, so the top-level handler doesn't have to guess. */
+export declare class ShepherdError extends Error {
+    readonly exitCode: number;
+    constructor(message: string, exitCode: number, opts?: {
+        cause?: unknown;
+    });
+}
+export declare function iterateResultToExitCode(result: IterateResult): number;
+export declare function errorToExitCode(err: unknown): number;

package/bin/github/activity.d.mts

@@ -0,0 +1,3 @@
+import type { PrActivitySummary, PrComment, Review, ReviewThread } from "../types.mts";
+import type { RawPr } from "./batch-raw-types.mts";
+export declare function buildPrActivitySummary(raw: RawPr, comments: PrComment[], reviewThreads: ReviewThread[], reviewSummaries: Review[], changesRequestedReviews: Review[], approvedReviews: Review[]): PrActivitySummary;

package/bin/github/activity.mjs

@@ -8,6 +8,7 @@ function reviewActivityItems(reviews, latestCommitCommittedAtUnix, kind) {
         id: r.id,
         author: r.author,
         authorType: r.authorType,
+        ...(r.authorAssociation !== undefined && { authorAssociation: r.authorAssociation }),
         body: r.body,
         createdAtUnix: r.createdAtUnix ?? 0,
     }));
@@ -26,6 +27,9 @@ export function buildPrActivitySummary(raw, comments, reviewThreads, reviewSumma
                 id: c.id,
                 author: c.author,
                 authorType: c.authorType,
+                ...(c.authorAssociation !== undefined && {
+                    authorAssociation: c.authorAssociation,
+                }),
                 body: c.body,
                 url: c.url,
                 createdAtUnix: c.createdAtUnix,
@@ -37,6 +41,9 @@ export function buildPrActivitySummary(raw, comments, reviewThreads, reviewSumma
                 id: c.id,
                 author: c.author,
                 authorType: c.authorType,
+                ...(c.authorAssociation !== undefined && {
+                    authorAssociation: c.authorAssociation,
+                }),
                 body: c.body,
                 url: c.url,
                 createdAtUnix: c.createdAtUnix,

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-parser-helpers.d.mts

@@ -0,0 +1,22 @@
+import type { AuthorType, CheckConclusion, CheckRun, CheckStatus, Review, ReviewThread } from "../types.mts";
+import type { RawContextNode } from "./batch-raw-types.mts";
+export declare function mapAuthorType(typeName: string | undefined | null, login?: string | undefined | null): AuthorType;
+export declare function parseCreatedAt(iso: string): number;
+/** Map a GraphQL CheckRun context node to a CheckRun. */
+export declare function mapCheckRunNode(node: Extract<RawContextNode, {
+    __typename: "CheckRun";
+}>): CheckRun;
+export declare function latestApprovedLogins(latest: Array<{
+    login: string;
+    state: string;
+}>): Set<string>;
+/**
+ * A CR review is stale when its commit.oid differs from the PR head AND every
+ * associated review thread is resolved or outdated. Reviews with no associated
+ * threads are treated conservatively (not marked stale).
+ */
+export declare function isReviewStale(review: Review, headRefOid: string, reviewThreads: ReviewThread[]): boolean;
+export declare function mapStatusContextState(state: string): {
+    status: CheckStatus;
+    conclusion: CheckConclusion;
+};

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;