co-maintainer 0.5.0 → 0.5.1-beta.2

package/dist/src/services/review_policy.js

@@ -0,0 +1,489 @@
+/** The review policy engine.
+ *
+ * A policy is an ordered list of rules. The first rule whose conditions all
+ * hold decides what happens to a pull request, and when none holds the policy's
+ * default action does. This file is pure: no database, no GitHub, no clock, so
+ * every branch of it is a table test. `webhook.ts` gathers the facts and acts on
+ * the answer. */
+export const ASSOCIATIONS = [
+    "OWNER",
+    "MEMBER",
+    "COLLABORATOR",
+    "CONTRIBUTOR",
+    "FIRST_TIME_CONTRIBUTOR",
+    "FIRST_TIMER",
+    "NONE",
+];
+export const ACTIONS = ["review", "on-request", "skip"];
+const TRUSTED = ["OWNER", "MEMBER", "COLLABORATOR"];
+export const DEFAULT_POLICY_SETTINGS = {
+    requestLabel: "co-maintainer:review",
+    requestCommand: "/co-maintainer review",
+    requesters: TRUSTED,
+    approvalScope: "head",
+};
+const SKIP_DRAFTS = {
+    name: "draft",
+    when: { draft: true },
+    action: "skip",
+};
+const SKIP_BOTS = {
+    name: "bot author",
+    when: { bot: true },
+    action: "skip",
+};
+export const TEMPLATES = {
+    everyone: { rules: [SKIP_DRAFTS, SKIP_BOTS], default: "review" },
+    "trusted-auto": {
+        rules: [
+            SKIP_DRAFTS,
+            SKIP_BOTS,
+            {
+                name: "trusted author",
+                when: { association: TRUSTED },
+                action: "review",
+            },
+        ],
+        default: "on-request",
+    },
+    "on-request-only": { rules: [], default: "on-request" },
+};
+export const TEMPLATE_NAMES = Object.keys(TEMPLATES);
+export function withDefaults(input) {
+    return {
+        rules: [],
+        default: "review",
+        ...DEFAULT_POLICY_SETTINGS,
+        ...input,
+    };
+}
+/** The policy the three old per repository switches amount to, so a repository
+ * nobody has given a policy keeps behaving exactly as before. Switched off
+ * means everything is skipped, and the drafts and bots switches only matter
+ * while it is on. */
+export function legacyPolicy(settings) {
+    if (settings.auto_review !== 1) {
+        return withDefaults({
+            rules: [],
+            default: "skip",
+            defaultReason: "auto-review-off",
+        });
+    }
+    const rules = [];
+    if (settings.skip_drafts === 1) {
+        rules.push({ ...SKIP_DRAFTS, reason: "draft" });
+    }
+    if (settings.skip_bots === 1) {
+        rules.push({ ...SKIP_BOTS, reason: "bot-author" });
+    }
+    return withDefaults({ rules, default: "review" });
+}
+function whenHolds(when, facts) {
+    if (when.association) {
+        if (facts.association === undefined ||
+            !when.association.includes(facts.association)) {
+            return false;
+        }
+    }
+    if (when.fork !== undefined && facts.fork !== when.fork)
+        return false;
+    if (when.draft !== undefined && facts.draft !== when.draft)
+        return false;
+    if (when.bot !== undefined && facts.bot !== when.bot)
+        return false;
+    if (when.labels) {
+        const have = new Set((facts.labels ?? []).map((l) => l.toLowerCase()));
+        if (!when.labels.some((label) => have.has(label.toLowerCase()))) {
+            return false;
+        }
+    }
+    if (when.targetBranch) {
+        if (facts.targetBranch === undefined ||
+            !when.targetBranch.includes(facts.targetBranch)) {
+            return false;
+        }
+    }
+    if (when.changedLines) {
+        const lines = facts.changedLines;
+        if (lines === undefined)
+            return false;
+        const { min, max } = when.changedLines;
+        if (min !== undefined && lines < min)
+            return false;
+        if (max !== undefined && lines > max)
+            return false;
+    }
+    return true;
+}
+const OUTCOME_TEXT = {
+    skip: "skipped by policy.",
+    "on-request": "waiting for a maintainer request.",
+    review: "reviewing.",
+};
+export function evaluatePolicy(policy, facts) {
+    for (let index = 0; index < policy.rules.length; index++) {
+        const rule = policy.rules[index];
+        if (!whenHolds(rule.when, facts))
+            continue;
+        const label = `Rule ${index + 1}${rule.name ? ` (${rule.name})` : ""}`;
+        return {
+            action: rule.action,
+            rule: index + 1,
+            reason: rule.reason ?? `${label}: ${OUTCOME_TEXT[rule.action]}`,
+        };
+    }
+    return {
+        action: policy.default,
+        rule: null,
+        reason: policy.defaultReason ?? `Default rule: ${OUTCOME_TEXT[policy.default]}`,
+    };
+}
+/** Whether a pull request that a policy leaves waiting for a request may be
+ * reviewed without a new one. Only the `pull-request` scope carries an earlier
+ * request forward, and only once something was actually reviewed or queued. */
+export function carriesEarlierRequest(policy, hasEarlierReview) {
+    return policy.approvalScope === "pull-request" && hasEarlierReview;
+}
+/** Whether `body` starts with the request command as a whole word. */
+export function isRequestCommand(body, command) {
+    const text = body.trim().toLowerCase();
+    const wanted = command.trim().toLowerCase();
+    if (!wanted || !text.startsWith(wanted))
+        return false;
+    const next = text.charAt(wanted.length);
+    return next === "" || /\s/.test(next);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringList(value, path) {
+    if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+        return { ok: false, problem: `${path} must be a list of strings` };
+    }
+    return { ok: true, value: value };
+}
+function associations(value, path) {
+    const list = stringList(value, path);
+    if (!list.ok)
+        return list;
+    const bad = list.value.find((item) => !ASSOCIATIONS.includes(item));
+    if (bad !== undefined) {
+        return {
+            ok: false,
+            problem: `${path} has "${bad}", expected one of ${ASSOCIATIONS.join(", ")}`,
+        };
+    }
+    return { ok: true, value: list.value };
+}
+function unknownKey(value, allowed, path) {
+    const extra = Object.keys(value).find((key) => !allowed.includes(key));
+    return extra === undefined ? undefined : `${path}: unknown field "${extra}"`;
+}
+function parseWhen(value, path) {
+    if (!isRecord(value))
+        return { ok: false, problem: `${path} must be an object` };
+    const extra = unknownKey(value, [
+        "association",
+        "fork",
+        "draft",
+        "bot",
+        "labels",
+        "targetBranch",
+        "changedLines",
+    ], path);
+    if (extra)
+        return { ok: false, problem: extra };
+    const when = {};
+    if (value.association !== undefined) {
+        const parsed = associations(value.association, `${path}.association`);
+        if (!parsed.ok)
+            return parsed;
+        when.association = parsed.value;
+    }
+    for (const key of ["fork", "draft", "bot"]) {
+        if (value[key] === undefined)
+            continue;
+        if (typeof value[key] !== "boolean") {
+            return { ok: false, problem: `${path}.${key} must be true or false` };
+        }
+        when[key] = value[key];
+    }
+    for (const key of ["labels", "targetBranch"]) {
+        if (value[key] === undefined)
+            continue;
+        const parsed = stringList(value[key], `${path}.${key}`);
+        if (!parsed.ok)
+            return parsed;
+        when[key] = parsed.value;
+    }
+    if (value.changedLines !== undefined) {
+        const lines = value.changedLines;
+        if (!isRecord(lines)) {
+            return { ok: false, problem: `${path}.changedLines must be an object` };
+        }
+        const bad = unknownKey(lines, ["min", "max"], `${path}.changedLines`);
+        if (bad)
+            return { ok: false, problem: bad };
+        for (const key of ["min", "max"]) {
+            const bound = lines[key];
+            if (bound !== undefined &&
+                (!Number.isInteger(bound) || Number(bound) < 0)) {
+                return {
+                    ok: false,
+                    problem: `${path}.changedLines.${key} must be a whole number of 0 or more`,
+                };
+            }
+        }
+        when.changedLines = lines;
+    }
+    return { ok: true, value: when };
+}
+function parseAction(value, path) {
+    if (!ACTIONS.includes(value)) {
+        return {
+            ok: false,
+            problem: `${path} must be one of ${ACTIONS.join(", ")}`,
+        };
+    }
+    return { ok: true, value: value };
+}
+/** Turns stored or user supplied policy data into a policy, or says what is
+ * wrong with it. A string names a template, an object is a full policy where
+ * every setting but the rules can be left out. */
+export function parsePolicy(value) {
+    if (typeof value === "string") {
+        const template = TEMPLATES[value];
+        if (!template) {
+            return {
+                ok: false,
+                problem: `unknown template "${value}", expected one of ${TEMPLATE_NAMES.join(", ")} or a policy object`,
+            };
+        }
+        return { ok: true, value: withDefaults(template) };
+    }
+    if (!isRecord(value)) {
+        return { ok: false, problem: "a policy is a template name or an object" };
+    }
+    const extra = unknownKey(value, [
+        "rules",
+        "default",
+        "requestLabel",
+        "requestCommand",
+        "requesters",
+        "approvalScope",
+        "maxRounds",
+    ], "policy");
+    if (extra)
+        return { ok: false, problem: extra };
+    const input = {};
+    if (value.rules !== undefined) {
+        if (!Array.isArray(value.rules)) {
+            return { ok: false, problem: "rules must be a list" };
+        }
+        const rules = [];
+        for (let index = 0; index < value.rules.length; index++) {
+            const path = `rules[${index}]`;
+            const rule = value.rules[index];
+            if (!isRecord(rule)) {
+                return { ok: false, problem: `${path} must be an object` };
+            }
+            const bad = unknownKey(rule, ["name", "when", "action"], path);
+            if (bad)
+                return { ok: false, problem: bad };
+            const when = parseWhen(rule.when ?? {}, `${path}.when`);
+            if (!when.ok)
+                return when;
+            const action = parseAction(rule.action, `${path}.action`);
+            if (!action.ok)
+                return action;
+            if (rule.name !== undefined && typeof rule.name !== "string") {
+                return { ok: false, problem: `${path}.name must be text` };
+            }
+            rules.push({ name: rule.name, when: when.value, action: action.value });
+        }
+        input.rules = rules;
+    }
+    if (value.default !== undefined) {
+        const action = parseAction(value.default, "default");
+        if (!action.ok)
+            return action;
+        input.default = action.value;
+    }
+    for (const key of ["requestLabel", "requestCommand"]) {
+        if (value[key] === undefined)
+            continue;
+        if (typeof value[key] !== "string" || !value[key].trim()) {
+            return { ok: false, problem: `${key} must be non-empty text` };
+        }
+        input[key] = value[key].trim();
+    }
+    if (value.requesters !== undefined) {
+        const parsed = associations(value.requesters, "requesters");
+        if (!parsed.ok)
+            return parsed;
+        input.requesters = parsed.value;
+    }
+    if (value.approvalScope !== undefined) {
+        if (value.approvalScope !== "head" &&
+            value.approvalScope !== "pull-request") {
+            return {
+                ok: false,
+                problem: "approvalScope must be head or pull-request",
+            };
+        }
+        input.approvalScope = value.approvalScope;
+    }
+    if (value.maxRounds !== undefined) {
+        if (!Number.isInteger(value.maxRounds) || Number(value.maxRounds) < 1) {
+            return {
+                ok: false,
+                problem: "maxRounds must be a whole number of 1 or more",
+            };
+        }
+        input.maxRounds = Number(value.maxRounds);
+    }
+    return { ok: true, value: withDefaults(input) };
+}
+/** What the dashboard shows next to each template, one plain sentence each. */
+export const TEMPLATE_INFO = [
+    {
+        name: "everyone",
+        label: "Everyone",
+        description: "Every pull request is reviewed automatically, except drafts and pull requests by bots.",
+    },
+    {
+        name: "trusted-auto",
+        label: "Trusted authors, automatic",
+        description: "Owners, members and collaborators are reviewed automatically. Everyone else waits until a maintainer asks.",
+    },
+    {
+        name: "on-request-only",
+        label: "Only when requested",
+        description: "Nothing is reviewed until a maintainer asks, with a label or a comment.",
+    },
+];
+const ASSOCIATION_WORDS = {
+    OWNER: "owners",
+    MEMBER: "members",
+    COLLABORATOR: "collaborators",
+    CONTRIBUTOR: "earlier contributors",
+    FIRST_TIME_CONTRIBUTOR: "first time contributors",
+    FIRST_TIMER: "first timers",
+    NONE: "people with no relation to the repository",
+};
+function joinWords(words, joiner) {
+    if (words.length <= 1)
+        return words.join("");
+    return `${words.slice(0, -1).join(", ")} ${joiner} ${words.at(-1)}`;
+}
+function describeWhen(when) {
+    const empty = Object.keys(when).length === 0;
+    if (empty)
+        return "All pull requests";
+    let subject = "Pull requests";
+    if (when.draft === true && when.bot === true) {
+        subject = "Draft pull requests by bots";
+    }
+    else if (when.draft === true) {
+        subject = "Draft pull requests";
+    }
+    else if (when.bot === true) {
+        subject = "Pull requests by bots";
+    }
+    const extras = [];
+    if (when.draft === false)
+        extras.push("that are ready for review");
+    if (when.bot === false)
+        extras.push("not by bots");
+    if (when.association) {
+        extras.push(`by ${joinWords(when.association.map((a) => ASSOCIATION_WORDS[a]), "or")}`);
+    }
+    if (when.fork === true)
+        extras.push("opened from a fork");
+    if (when.fork === false)
+        extras.push("opened from the repository itself");
+    if (when.labels)
+        extras.push(`labeled ${joinWords(when.labels, "or")}`);
+    if (when.targetBranch) {
+        extras.push(`into ${joinWords(when.targetBranch, "or")}`);
+    }
+    const lines = when.changedLines;
+    if (lines) {
+        if (lines.min !== undefined && lines.max !== undefined) {
+            extras.push(`changing ${lines.min} to ${lines.max} lines`);
+        }
+        else if (lines.min !== undefined) {
+            extras.push(`changing at least ${lines.min} lines`);
+        }
+        else if (lines.max !== undefined) {
+            extras.push(`changing at most ${lines.max} lines`);
+        }
+    }
+    return [subject, ...extras].join(" ");
+}
+const PLURAL_ACTION = {
+    review: "are reviewed automatically.",
+    "on-request": "wait for a maintainer request.",
+    skip: "are not reviewed.",
+};
+const SINGULAR_ACTION = {
+    review: "is reviewed automatically.",
+    "on-request": "waits for a maintainer request.",
+    skip: "is not reviewed.",
+};
+/** The policy as short sentences a maintainer can read before saving it. */
+export function describePolicy(policy) {
+    const lines = policy.rules.map((rule) => `${describeWhen(rule.when)} ${PLURAL_ACTION[rule.action]}`);
+    lines.push(policy.rules.length === 0
+        ? `Every pull request ${SINGULAR_ACTION[policy.default]}`
+        : `Any other pull request ${SINGULAR_ACTION[policy.default]}`);
+    const waits = policy.default === "on-request" ||
+        policy.rules.some((rule) => rule.action === "on-request");
+    if (waits) {
+        const who = joinWords(policy.requesters.map((a) => ASSOCIATION_WORDS[a]), "and");
+        const scope = policy.approvalScope === "head"
+            ? "A request covers the commit it was made on."
+            : "A request covers every later push to the pull request.";
+        lines.push(`${who.charAt(0).toUpperCase()}${who.slice(1)} can ask by adding the label "${policy.requestLabel}" or by commenting "${policy.requestCommand}". ${scope}`);
+    }
+    if (policy.maxRounds !== undefined) {
+        lines.push(`A pull request gets at most ${policy.maxRounds} ${policy.maxRounds === 1 ? "review" : "reviews"} from the webhook.`);
+    }
+    return lines;
+}
+function canonical(value) {
+    if (Array.isArray(value))
+        return `[${value.map(canonical).join(",")}]`;
+    if (value !== null && typeof value === "object") {
+        const entries = Object.entries(value)
+            .filter(([, item]) => item !== undefined)
+            .sort(([a], [b]) => a.localeCompare(b));
+        return `{${entries.map(([k, v]) => `${JSON.stringify(k)}:${canonical(v)}`).join(",")}}`;
+    }
+    return JSON.stringify(value);
+}
+/** What to store for a policy: the template's name when the policy is exactly
+ * that template with the default settings, the whole policy otherwise. */
+export function storedPolicyValue(policy) {
+    const wanted = canonical(policy);
+    for (const name of TEMPLATE_NAMES) {
+        if (canonical(withDefaults(TEMPLATES[name])) === wanted)
+            return name;
+    }
+    return policy;
+}
+/** What a form or API caller sent, as the value to store. `null` clears the
+ * choice, and `"legacy"` (the simple switches) is only for one repository. */
+export function policyToStore(value, options) {
+    if (value === null)
+        return { ok: true, value: null };
+    if (value === "legacy") {
+        return options.allowLegacy
+            ? { ok: true, value: '"legacy"' }
+            : { ok: false, problem: "the simple switches only exist per repository" };
+    }
+    const parsed = parsePolicy(value);
+    if (!parsed.ok)
+        return parsed;
+    return { ok: true, value: JSON.stringify(storedPolicyValue(parsed.value)) };
+}

package/dist/src/services/setup.d.ts

@@ -1,14 +1,15 @@
 import type { AiResponse, GitHubClient, Options } from "../types.ts";
 import type { LogFn } from "./jobs.ts";
 import type { JobRow } from "../store/rows.ts";
-export type AiMetrics = {
+import { type CostTally } from "../util/cost.ts";
+export type AiMetrics = CostTally & {
     calls: number;
     tokensIn: number;
     tokensOut: number;
-    cost: number;
-    costKnown: boolean;
 };
 export declare function emptyAiMetrics(): AiMetrics;
+/** One AI response into the run totals. */
+export declare function addAiMetrics(metrics: AiMetrics, response: AiResponse): void;
 export declare function recordAiCost(repo: string, job: string, response: AiResponse): Promise<void>;
 export declare function clientFor(options: Options): GitHubClient;
 export declare function runInitOrRemake(options: Options): Promise<void>;

package/dist/src/services/setup.js

@@ -20,8 +20,17 @@ import { closeAppDb, isAppDbOpen, openAppDb } from "../store/app_db.js";
 import { getRepo, markKnowledgeBuilt } from "../store/repos.js";
 import { nowIso } from "../util/time.js";
 import { mkdir, readTextFile, remove } from "../util/runtime.js";
+import { addResponseCost, emptyTally } from "../util/cost.js";
+import { costLabel } from "../util/run_summary.js";
 export function emptyAiMetrics() {
-    return { calls: 0, tokensIn: 0, tokensOut: 0, cost: 0, costKnown: true };
+    return { calls: 0, tokensIn: 0, tokensOut: 0, ...emptyTally() };
+}
+/** One AI response into the run totals. */
+export function addAiMetrics(metrics, response) {
+    metrics.calls++;
+    metrics.tokensIn += response.tokensIn;
+    metrics.tokensOut += response.tokensOut;
+    addResponseCost(metrics, response);
 }
 export async function recordAiCost(repo, job, response) {
     await cacheSet("cost", `${repo}:${crypto.randomUUID()}`, JSON.stringify({
@@ -31,7 +40,8 @@ export async function recordAiCost(repo, job, response) {
         model: response.model,
         tokensIn: response.tokensIn,
         tokensOut: response.tokensOut,
-        usd: response.provider === "hetzner" ? 0 : (response.cost ?? null),
+        usd: response.cost ?? null,
+        status: response.cost === undefined ? "unknown" : "known",
     }));
 }
 export function clientFor(options) {
@@ -76,7 +86,7 @@ async function skillPath(repo) {
 async function writeReviewDocuments(repo, documents, signalCount) {
     const directory = `${reposDir()}/${repo}`;
     if (!documents) {
-        // F05: this used to delete the files without a word. The plan's rule is
+        // This used to delete the files without a word. The rule is
         // "says why the third file is missing": keep it to one line.
         log("write", `PR_REVIEW_GUIDE.md skipped: found ${signalCount} review signals, needs at least 3`);
         await Promise.all([
@@ -98,7 +108,7 @@ async function writeReviewDocuments(repo, documents, signalCount) {
  * of the assembled skill into their own file, so `review` can check a pull
  * request against how this repository's code actually looks, not just the
  * review-bar checklist mined from past PR comments. The skill links to this
- * file rather than repeating it (CORE-32 / F26c), so its body is built from
+ * file rather than repeating it, so its body is built from
  * the facts instead of being scraped back out of the skill. */
 async function writeCodebaseDocument(repo, facts, overrides = {}) {
     const path = `${reposDir()}/${repo}/CODEBASE.md`;
@@ -188,15 +198,7 @@ async function initOrRemake(options) {
     if (lowAi) {
         log("ai", "starting extract_unit jobs");
         const usage = async (job, response) => {
-            aiMetrics.calls++;
-            aiMetrics.tokensIn += response.tokensIn;
-            aiMetrics.tokensOut += response.tokensOut;
-            if (response.provider === "hetzner")
-                aiMetrics.cost += 0;
-            else if (response.cost === undefined)
-                aiMetrics.costKnown = false;
-            else
-                aiMetrics.cost += response.cost;
+            addAiMetrics(aiMetrics, response);
             await recordAiCost(options.repo, job, response);
         };
         const enriched = await timed("extract_unit AI", options.logTime, () => enrichFactsWithReport(lowAi, options.repo, facts, source, options, usage));
@@ -289,8 +291,8 @@ async function initOrRemake(options) {
         : "already current"}`);
     log("done", `${facts.length} facts · ${source.pullRequests.length} pull requests · ${source.commits.length} commits`);
     if (skipped.length) {
-        // F04: a skipped unit used to vanish into a log line and recur as a "cache
-        // hit" forever. Say it in the final line instead, in the plan's shape:
+        // A skipped unit used to vanish into a log line and recur as a "cache
+        // hit" forever. Say it in the final line instead, in this shape:
         // `1 unit skipped (PR #3: output was not JSON)`.
         const parts = skipped.map((unit) => unit.reason);
         const line = skipped.length === 1
@@ -300,7 +302,7 @@ async function initOrRemake(options) {
     }
     printRunSummary(summaryFromMetrics(aiMetrics, performance.now() - operationStarted));
     if (options.logTime) {
-        log("time", `AI total · calls=${aiMetrics.calls} · input=${aiMetrics.tokensIn} tokens · output=${aiMetrics.tokensOut} tokens · cost=${aiMetrics.costKnown ? aiMetrics.cost.toFixed(4) : "unknown"}`);
+        log("time", `AI total · calls=${aiMetrics.calls} · input=${aiMetrics.tokensIn} tokens · output=${aiMetrics.tokensOut} tokens · cost=${costLabel(aiMetrics)}`);
         log("time", `total init/sync · ${((performance.now() - operationStarted) / 1000).toFixed(2)}s`);
     }
 }

package/dist/src/services/setup_checklist.js

@@ -1,8 +1,8 @@
-/** The "Finish setup" checklist shown on the home page (CORE-75, C01/F26).
+/** The "Finish setup" checklist shown on the home page.
  *
  * Each item is derived from state that already exists, so the card reflects
  * what serve can actually do rather than a parallel bookkeeping of it. The
- * webhook item reuses CORE-71's reachability check. */
+ * webhook item reuses the existing reachability check. */
 import { readConfig, resolveAppPrivateKey } from "../config.js";
 import { countReviews } from "../store/reviews.js";
 import { listRemoteTokens } from "../store/remote_tokens.js";

package/dist/src/services/webhook.d.ts

@@ -1,4 +1,16 @@
+import type { RepoRow } from "../store/rows.ts";
+import { type ReviewPolicy } from "./review_policy.ts";
 export declare const REVIEW_DEBOUNCE_MS = 20000;
+/** The policy that governs a repository. A repository pinned to `"legacy"`, and
+ * one with nothing stored and no server default, follow the three old
+ * switches. A stored value that no longer parses does too, so a bad edit
+ * degrades to today's behavior rather than to a silent stop. */
+export declare function policySource(row: RepoRow): {
+    policy: ReviewPolicy;
+    /** True when the three old switches are what decides. */
+    legacy: boolean;
+};
+export declare function policyForRepo(row: RepoRow): ReviewPolicy;
 export type WebhookResult = {
     outcome: "enqueued" | "skipped" | "ignored" | "error";
     reason?: string;
@@ -18,5 +30,16 @@ export declare function maybeEnqueueReview(input: {
     trigger: string;
     headSha?: string;
     maxDiffLines?: number;
+    /** What the pull request payload said about its author and shape. Left out
+     * when GitHub did not send it, and a rule that asks about it then skips. */
+    association?: string;
+    fork?: boolean;
+    labels?: string[];
+    targetBranch?: string;
+    /** Set when a maintainer asked for this review by label or comment. The
+     * reaction endpoint is where the App acknowledges it once the job starts. */
+    request?: {
+        reaction: string;
+    };
 }): WebhookResult;
 export declare function dispatchGithubEvent(event: string, payload: Record<string, unknown>, deliveryId: string, maxDiffLines?: number): WebhookResult;