cloving 1.2.0 → 1.4.0

package/dist/src/daemon/github-ci-filters.js

@@ -0,0 +1,138 @@
+import { parse } from "yaml";
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function triggerKind(trigger) {
+    if (!isRecord(trigger))
+        return "push";
+    const types = patterns(trigger["types"]);
+    return types === undefined || types.includes("synchronize")
+        ? "push"
+        : "event";
+}
+export function pullRequestTrigger(source) {
+    try {
+        const document = parse(source, { merge: true });
+        if (!isRecord(document) || !("on" in document))
+            return true;
+        const events = document["on"];
+        if (typeof events === "string")
+            return events === "pull_request";
+        if (Array.isArray(events))
+            return events.includes("pull_request");
+        if (isRecord(events))
+            return "pull_request" in events ? events["pull_request"] : false;
+        return true;
+    }
+    catch {
+        return true;
+    }
+}
+function patternToken(token) {
+    if (token === "**/")
+        return { kind: "directory" };
+    if (token === "*" || token === "**")
+        return {
+            kind: "character",
+            matcher: token === "*" ? /[^/]/ : /[\s\S]/,
+            optional: true,
+            repeat: true,
+        };
+    const literal = token.startsWith("\\") ? token.slice(1) : token;
+    const source = token.startsWith("[")
+        ? token
+        : literal.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return {
+        kind: "character",
+        matcher: new RegExp(`^${source}$`),
+        optional: false,
+        repeat: false,
+    };
+}
+function patternTokens(source) {
+    const tokens = [];
+    for (const raw of source.match(/\*\*\/|\*\*|\*|\[[a-zA-Z0-9-]+\]|\\[\s\S]|[\s\S]/g) ?? []) {
+        if (raw !== "?" && raw !== "+") {
+            tokens.push(patternToken(raw));
+            continue;
+        }
+        const previous = tokens.pop();
+        if (previous?.kind !== "character" || previous.optional || previous.repeat)
+            throw new Error("invalid-workflow-filter");
+        tokens.push({ ...previous, optional: raw === "?", repeat: raw === "+" });
+    }
+    return tokens;
+}
+function advanceDirectory({ value, previous, }) {
+    let reachable = false;
+    return Array.from({ length: value.length + 1 }, (_, index) => {
+        const matches = previous[index] === true || (reachable && value[index - 1] === "/");
+        reachable ||= previous[index] === true;
+        return matches;
+    });
+}
+function advancePattern(token, input) {
+    const { value, previous } = input;
+    const next = [];
+    for (let index = 0; index <= value.length; index += 1) {
+        const consumes = index > 0 && token.matcher.test(value[index - 1] ?? "");
+        next[index] =
+            (token.optional && previous[index] === true) ||
+                (consumes &&
+                    (previous[index - 1] === true ||
+                        (token.repeat && next[index - 1] === true)));
+    }
+    return next;
+}
+function matchesPattern(value, source) {
+    let previous = [true];
+    for (const token of patternTokens(source))
+        previous =
+            token.kind === "directory"
+                ? advanceDirectory({ value, previous })
+                : advancePattern(token, { value, previous });
+    return previous[value.length] === true;
+}
+function selected(value, patterns) {
+    let included = false;
+    for (const pattern of patterns) {
+        const negative = pattern.startsWith("!");
+        const source = negative ? pattern.slice(1) : pattern;
+        try {
+            if (matchesPattern(value, source))
+                included = !negative;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    return included;
+}
+function patterns(value) {
+    if (!Array.isArray(value) || value.length === 0)
+        return undefined;
+    return value.every((item) => typeof item === "string")
+        ? value
+        : undefined;
+}
+function allows(values, filters) {
+    const include = patterns(filters.include);
+    const ignore = patterns(filters.ignore);
+    if (include !== undefined &&
+        !values.some((value) => selected(value, include) !== false))
+        return false;
+    return (ignore === undefined ||
+        values.some((value) => selected(value, ignore) !== true));
+}
+export function workflowApplies(trigger, context) {
+    if (!isRecord(trigger))
+        return trigger !== false;
+    return (allows([context.branch], {
+        include: trigger["branches"],
+        ignore: trigger["branches-ignore"],
+    }) &&
+        allows(context.paths, {
+            include: trigger["paths"],
+            ignore: trigger["paths-ignore"],
+        }));
+}

package/dist/src/daemon/github-ci-rerun.d.ts

@@ -0,0 +1,26 @@
+import { type Operation } from "./github-operation.ts";
+export interface CiRerun {
+    readonly run: string;
+    readonly requestedAt: number;
+    readonly output: string;
+}
+export interface CiWait {
+    readonly commit: string;
+    readonly startedAt: number;
+    readonly reruns: CiRerun[];
+}
+export declare function ciWait(operation: Operation, commit: string): Promise<CiWait>;
+export declare function workflowAttempt(operation: Operation, run: string): Promise<{
+    readonly attempt: number;
+    readonly status: string;
+}>;
+export declare function attemptChecks(operation: Operation, workflow: {
+    readonly run: string;
+    readonly attempt: number;
+}): Promise<ReadonlySet<number>>;
+export declare function rerunCi(operation: Operation, request: {
+    readonly wait: CiWait;
+    readonly rerun: CiRerun;
+    readonly deadline: number;
+}): Promise<void>;
+export declare function attemptOutput(attempts: readonly string[]): string;

package/dist/src/daemon/github-ci-rerun.js

@@ -0,0 +1,92 @@
+import { field, repositoryPath } from "./github-operation.js";
+import { githubRead } from "./github-retry.js";
+import { operationKey, writeRecord } from "./operation-journal.js";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+function isRerun(value) {
+    return (typeof field(value, "run") === "string" &&
+        /^\d+$/.test(String(field(value, "run"))) &&
+        typeof field(value, "requestedAt") === "number" &&
+        typeof field(value, "output") === "string");
+}
+export async function ciWait(operation, commit) {
+    const text = await readFile(join(operation.folder, `ci-${operationKey(commit)}.json`), "utf8").catch((error) => {
+        if (field(error, "code") === "ENOENT")
+            return undefined;
+        throw error;
+    });
+    if (text === undefined)
+        return { commit, startedAt: Date.now(), reruns: [] };
+    const stored = JSON.parse(text);
+    const startedAt = field(stored, "startedAt");
+    const reruns = field(stored, "reruns");
+    if (field(stored, "commit") !== commit ||
+        typeof startedAt !== "number" ||
+        !Array.isArray(reruns) ||
+        !reruns.every(isRerun))
+        throw new Error("github-call-failed");
+    return { commit, startedAt, reruns };
+}
+export async function workflowAttempt(operation, run) {
+    const value = JSON.parse(await githubRead(operation, [
+        "api",
+        `${repositoryPath}/actions/runs/${run}`,
+    ]));
+    const attempt = field(value, "run_attempt");
+    const status = field(value, "status");
+    if (typeof attempt !== "number" ||
+        !Number.isSafeInteger(attempt) ||
+        attempt < 1 ||
+        typeof status !== "string")
+        throw new Error("github-call-failed");
+    return { attempt, status };
+}
+export async function attemptChecks(operation, workflow) {
+    const pages = JSON.parse(await githubRead(operation, [
+        "api",
+        "--paginate",
+        "--slurp",
+        `${repositoryPath}/actions/runs/${workflow.run}/attempts/${String(workflow.attempt)}/jobs?per_page=100`,
+    ]));
+    if (!Array.isArray(pages) || pages.length === 0)
+        throw new Error("github-call-failed");
+    const ids = new Set();
+    for (const page of pages) {
+        const jobs = field(page, "jobs");
+        if (!Array.isArray(jobs))
+            throw new Error("github-call-failed");
+        for (const job of jobs) {
+            const id = /\/check-runs\/(\d+)$/.exec(String(field(job, "check_run_url")))?.[1];
+            if (id === undefined)
+                throw new Error("github-call-failed");
+            ids.add(Number(id));
+        }
+    }
+    return ids;
+}
+export async function rerunCi(operation, request) {
+    const { wait, rerun } = request;
+    wait.reruns.push(rerun);
+    await writeRecord(operation.folder, {
+        name: `ci-${operationKey(wait.commit)}.json`,
+        value: wait,
+        permissions: "private",
+    });
+    if (Date.now() >= request.deadline)
+        return;
+    try {
+        await operation.calls.gh(["run", "rerun", rerun.run, "--failed"]);
+    }
+    catch (error) {
+        operation.signal.throwIfAborted();
+        throw Object.assign(new Error("github-network-failed", { cause: error }), {
+            detail: field(error, "detail"),
+        });
+    }
+}
+export function attemptOutput(attempts) {
+    const allowance = Math.floor(6_000 / attempts.length) - 40;
+    return attempts
+        .map((output, index) => `Attempt ${String(index + 1)}:\n${output.length <= allowance ? output : output.slice(0, 400) + "\n…\n" + output.slice(-(allowance - 404))}`)
+        .join("\n");
+}

package/dist/src/daemon/github-ci-workflows.d.ts

@@ -0,0 +1,10 @@
+import { type Operation } from "./github-operation.ts";
+export interface ExpectedWorkflow {
+    readonly path: string;
+    readonly kind: "push" | "event";
+}
+export declare function pullRequestWorkflows(operation: Operation, commit: string): Promise<readonly ExpectedWorkflow[]>;
+export declare function pendingWorkflows(operation: Operation, input: {
+    readonly commit: string;
+    readonly workflows: readonly ExpectedWorkflow[];
+}): Promise<readonly string[]>;

package/dist/src/daemon/github-ci-workflows.js

@@ -0,0 +1,148 @@
+import { pullRequestTrigger, triggerKind, workflowApplies, } from "./github-ci-filters.js";
+import { field, repositoryPath } from "./github-operation.js";
+import { githubRead } from "./github-retry.js";
+async function pullBase(operation) {
+    const pull = JSON.parse(await githubRead(operation, [
+        "api",
+        `${repositoryPath}/pulls/${String(operation.payload["number"])}`,
+    ]));
+    if (typeof pull !== "object" || pull === null || !("base" in pull))
+        throw new Error("github-call-failed");
+    const baseData = pull.base;
+    if (typeof baseData !== "object" || baseData === null)
+        throw new Error("github-call-failed");
+    const base = field(baseData, "sha");
+    const branch = field(baseData, "ref");
+    if (typeof base !== "string" ||
+        !/^[0-9a-f]{40,64}$/.test(base) ||
+        typeof branch !== "string")
+        throw new Error("github-call-failed");
+    return { base, branch };
+}
+async function appliesToPull(operation, input) {
+    const { commit, trigger } = input;
+    if (trigger === false)
+        return false;
+    if (typeof trigger !== "object" || trigger === null)
+        return true;
+    if (!["paths", "paths-ignore", "branches", "branches-ignore"].some((key) => Object.hasOwn(trigger, key)))
+        return true;
+    const { base, branch } = await pullBase(operation);
+    await operation.calls.git(operation.settings.repository, [
+        "fetch",
+        "--quiet",
+        "--no-tags",
+        "origin",
+        base,
+    ]);
+    const paths = await operation.calls.git(operation.settings.repository, [
+        "diff",
+        "--name-only",
+        "-z",
+        `${base}...${commit}`,
+    ]);
+    return workflowApplies(trigger, {
+        branch,
+        paths: paths.split("\0").filter((path) => path !== ""),
+    });
+}
+export async function pullRequestWorkflows(operation, commit) {
+    const read = (parts) => operation.calls.git(operation.settings.repository, parts);
+    const paths = await read([
+        "ls-tree",
+        "-r",
+        "--name-only",
+        "-z",
+        commit,
+        "--",
+        ".github/workflows",
+    ]);
+    const workflows = [];
+    for (const path of paths.split("\0")) {
+        if (!/^\.github\/workflows\/[^/]+\.ya?ml$/.test(path))
+            continue;
+        const trigger = pullRequestTrigger(await read(["show", `${commit}:${path}`]));
+        if (await appliesToPull(operation, { commit, trigger }))
+            workflows.push({ path, kind: triggerKind(trigger) });
+    }
+    if (workflows.length === 0)
+        return workflows;
+    const inactive = await inactiveWorkflows(operation);
+    return workflows.filter((workflow) => !inactive.has(workflow.path));
+}
+function isList(value) {
+    return Array.isArray(value);
+}
+async function actionPages(operation, request) {
+    const pages = JSON.parse(await githubRead(operation, ["api", "--paginate", "--slurp", request.path]));
+    if (!isList(pages) || pages.length === 0)
+        throw new Error("github-call-failed");
+    return pages.flatMap((page) => {
+        if (typeof page !== "object" || page === null)
+            throw new Error("github-call-failed");
+        const items = field(page, request.key);
+        if (!isList(items))
+            throw new Error("github-call-failed");
+        return items;
+    });
+}
+async function inactiveWorkflows(operation) {
+    const workflows = await actionPages(operation, {
+        path: `${repositoryPath}/actions/workflows?per_page=100`,
+        key: "workflows",
+    });
+    const inactive = new Set();
+    for (const workflow of workflows) {
+        if (typeof workflow !== "object" || workflow === null)
+            throw new Error("github-call-failed");
+        const path = field(workflow, "path");
+        const state = field(workflow, "state");
+        if (typeof path !== "string" || typeof state !== "string")
+            throw new Error("github-call-failed");
+        if (state !== "active")
+            inactive.add(path);
+    }
+    return inactive;
+}
+function isWorkflowRun(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const conclusion = field(value, "conclusion");
+    return (typeof field(value, "id") === "number" &&
+        ["path", "head_sha", "event", "status"].every((key) => typeof field(value, key) === "string") &&
+        (conclusion === null || typeof conclusion === "string"));
+}
+async function workflowRuns(operation, commit) {
+    const runs = await actionPages(operation, {
+        path: `${repositoryPath}/actions/runs?head_sha=${commit}&event=pull_request&per_page=100`,
+        key: "workflow_runs",
+    });
+    if (!runs.every(isWorkflowRun))
+        throw new Error("github-call-failed");
+    return runs;
+}
+export async function pendingWorkflows(operation, input) {
+    if (input.workflows.length === 0)
+        return [];
+    const paths = input.workflows.map((workflow) => workflow.path);
+    const latest = new Map();
+    for (const run of await workflowRuns(operation, input.commit)) {
+        if (run.head_sha !== input.commit || run.event !== "pull_request")
+            continue;
+        const path = paths
+            .filter((expected) => run.path === expected || run.path.startsWith(`${expected}@`))
+            .sort((left, right) => right.length - left.length)[0];
+        if (path === undefined)
+            continue;
+        if (run.id > (latest.get(path)?.id ?? -1))
+            latest.set(path, run);
+    }
+    const pending = input.workflows.filter((workflow) => {
+        const run = latest.get(workflow.path);
+        if (run === undefined)
+            return workflow.kind === "push";
+        return (run.status !== "completed" ||
+            !["success", "neutral", "skipped"].includes(run.conclusion ?? ""));
+    });
+    return pending.length === 0 ? [] : ["waiting for GitHub Actions checks"];
+}

package/dist/src/daemon/github-ci.js

@@ -1,6 +1,9 @@
+import { settingsEnvironment } from "../cli/project-settings.js";
 import { setTimeout as delay } from "node:timers/promises";
 import { githubText } from "./github-calls.js";
 import { githubRead } from "./github-retry.js";
+import { pendingWorkflows, pullRequestWorkflows, } from "./github-ci-workflows.js";
+import { ciWait, workflowAttempt, attemptChecks, rerunCi, attemptOutput, } from "./github-ci-rerun.js";
 import { field, githubTiming, repositoryPath, } from "./github-operation.js";
 function isCheckRun(value) {
     const conclusion = field(value, "conclusion");
@@ -117,12 +120,18 @@ async function failedOutput(operation, checks) {
         .join("\n")
         .slice(0, 6_000);
 }
+function requiredCheckNames(operation) {
+    if (operation.settings.requiredChecks !== undefined)
+        return operation.settings.requiredChecks === null
+            ? undefined
+            : operation.settings.requiredChecks;
+    const setting = settingsEnvironment({ ...process.env, ...operation.settings.environment }, operation.settings.repository)["CLOVING_REQUIRED_CHECKS"];
+    return setting === undefined ? undefined : JSON.parse(setting);
+}
 function requiredChecks(operation) {
-    const setting = operation.settings.environment?.["CLOVING_REQUIRED_CHECKS"] ??
-        process.env["CLOVING_REQUIRED_CHECKS"];
-    if (setting === undefined)
+    const names = requiredCheckNames(operation);
+    if (names === undefined)
         return undefined;
-    const names = JSON.parse(setting);
     if (!Array.isArray(names) ||
         !names.every((name) => typeof name === "string" && name.trim() !== ""))
         throw new Error("invalid-payload");
@@ -131,27 +140,117 @@ function requiredChecks(operation) {
 function pendingChecks(checks, names) {
     return [...names].filter((name) => !checks.some((check) => check.name === name && check.status === "completed"));
 }
-export async function waitForCi(operation, commit) {
-    const { pollMilliseconds: poll, ciGraceMilliseconds: grace, ciLimitMilliseconds: limit, } = {
+function runOf(check) {
+    return check.app?.slug === "github-actions"
+        ? /\/actions\/runs\/(\d+)/.exec(check.details_url ?? "")?.[1]
+        : undefined;
+}
+async function rerunBeforeDeadline(operation, request) {
+    if (Date.now() >= request.deadline)
+        return;
+    const output = await failedOutput(operation, request.checks);
+    const requestedAt = Date.now();
+    if (requestedAt >= request.deadline)
+        return;
+    await rerunCi(operation, {
+        wait: request.wait,
+        rerun: { run: request.run, requestedAt, output },
+        deadline: request.deadline,
+    });
+}
+async function rerunFailedChecks(operation, input) {
+    const { wait, failed } = input;
+    const failures = failed.filter((check) => runOf(check) === undefined);
+    const pending = [];
+    const runs = new Set(failed.flatMap((check) => runOf(check) ?? []));
+    for (const run of runs) {
+        const checks = failed.filter((check) => runOf(check) === run);
+        const recorded = wait.reruns.find((rerun) => rerun.run === run);
+        const workflow = await workflowAttempt(operation, run);
+        if (workflow.attempt === 1 &&
+            recorded === undefined &&
+            workflow.status === "completed")
+            await rerunBeforeDeadline(operation, {
+                wait,
+                run,
+                checks,
+                deadline: input.deadline,
+            });
+        if (workflow.attempt === 1) {
+            pending.push(`workflow ${run} rerun`);
+            continue;
+        }
+        const ids = await attemptChecks(operation, {
+            run,
+            attempt: workflow.attempt,
+        });
+        const current = checks.filter((check) => ids.has(check.id));
+        if (current.length === 0) {
+            pending.push(`workflow ${run} rerun`);
+            continue;
+        }
+        failures.push(...current);
+    }
+    return { failures, pending };
+}
+async function ciFailureOutput(operation, input) {
+    const { wait, failed } = input;
+    const previous = wait.reruns.filter((rerun) => failed.some((check) => runOf(check) === rerun.run));
+    const current = await failedOutput(operation, failed);
+    return previous.length === 0
+        ? current
+        : attemptOutput([
+            previous.map((rerun) => rerun.output).join("\n"),
+            current,
+        ]);
+}
+async function ciSettings(operation, commit) {
+    const timing = {
         ...githubTiming,
         ciGraceMilliseconds: 60_000,
         ciLimitMilliseconds: 5_400_000,
         ...operation.settings.timing,
     };
-    const started = Date.now();
     const required = requiredChecks(operation);
+    const workflows = required === undefined ? await pullRequestWorkflows(operation, commit) : [];
+    return {
+        required,
+        workflows,
+        poll: timing.pollMilliseconds,
+        limit: timing.ciLimitMilliseconds,
+        grace: workflows.some((workflow) => workflow.kind === "push")
+            ? Infinity
+            : timing.ciGraceMilliseconds,
+    };
+}
+export async function waitForCi(operation, commit) {
+    const wait = await ciWait(operation, commit);
+    const started = wait.startedAt;
+    const { required, workflows, grace, poll, limit } = await ciSettings(operation, commit);
     const names = new Set(required);
     for (;;) {
         const checks = latestRuns(await checkRuns(operation, commit), required);
         for (const check of checks)
             names.add(check.name);
         const failed = checks.filter((check) => check.status === "completed" && !passing.has(check.conclusion ?? ""));
-        if (failed.length > 0)
+        const retried = await rerunFailedChecks(operation, {
+            wait,
+            failed,
+            deadline: started + limit,
+        });
+        if (retried.failures.length > 0)
             return {
                 reason: "ci-failed",
-                output: await failedOutput(operation, failed),
+                output: await ciFailureOutput(operation, {
+                    wait,
+                    failed: retried.failures,
+                }),
             };
-        const pending = pendingChecks(checks, names);
+        const pending = [
+            ...pendingChecks(checks, names),
+            ...retried.pending,
+            ...(await pendingWorkflows(operation, { commit, workflows })),
+        ];
         if (pending.length === 0 &&
             (required !== undefined ||
                 names.size > 0 ||

package/dist/src/daemon/github-issue-methods.d.ts

@@ -1,3 +1,5 @@
 import { type Operation } from "./github-operation.ts";
+export declare function repositoryName(reply: string): string;
+export declare function captureDraft(operation: Operation): Promise<unknown>;
 export declare function createIssue(operation: Operation): Promise<unknown>;
 export declare function discard(operation: Operation): Promise<unknown>;

package/dist/src/daemon/github-issue-methods.js

@@ -1,4 +1,5 @@
 import { existsSync } from "node:fs";
+import { createHash } from "node:crypto";
 import { lstat, readFile } from "node:fs/promises";
 import { basename, join } from "node:path";
 import { existingTree, removeWorktree, repositoryPath, text, } from "./github-operation.js";
@@ -30,7 +31,7 @@ function issuePage(line) {
         throw new Error("github-call-failed");
     return page.map((issue) => issueOf(issue));
 }
-function repositoryName(reply) {
+export function repositoryName(reply) {
     const repository = JSON.parse(reply);
     if (typeof repository !== "object" ||
         repository === null ||
@@ -50,6 +51,28 @@ async function draftOf(operation) {
         throw new Error("draft-not-available");
     return readFile(path, "utf8");
 }
+function draftDigest(text) {
+    return "sha256:" + createHash("sha256").update(text).digest("hex");
+}
+export async function captureDraft(operation) {
+    const text = await draftOf(operation);
+    const capture = { text, digest: draftDigest(text) };
+    if (Buffer.byteLength(JSON.stringify(capture)) > 65_536)
+        throw new Error("draft-too-large");
+    return capture;
+}
+function checkDraftDigest(operation, draft) {
+    if (!Object.hasOwn(operation.payload, "expectedDigests"))
+        return;
+    const digests = operation.payload["expectedDigests"];
+    if (!Array.isArray(digests) ||
+        digests.length === 0 ||
+        !digests.every((digest) => typeof digest === "string" && /^sha256:[0-9a-f]{64}$/.test(digest)))
+        throw new Error("invalid-payload");
+    const current = draftDigest(draft);
+    if (!digests.every((digest) => digest === current))
+        throw new Error("draft-changed");
+}
 async function knownIssue(operation, marker) {
     const output = await operation.calls.gh([
         "api",
@@ -62,7 +85,10 @@ async function knownIssue(operation, marker) {
 }
 export async function createIssue(operation) {
     operatorPrivateTexts(operation.settings);
-    const draft = await draftOf(operation);
+    const draft = Object.hasOwn(operation.payload, "text")
+        ? reportText(operation)
+        : await draftOf(operation);
+    checkDraftDigest(operation, draft);
     const [heading = "", ...lines] = draft.split("\n");
     if (!heading.startsWith("# ") || heading.slice(2).trim() === "")
         throw new Error("invalid-draft");
@@ -89,6 +115,15 @@ export async function createIssue(operation) {
     const url = printed.trim().split("\n").at(-1) ?? "";
     return issueFromUrl(url);
 }
+function reportText(operation) {
+    if (Object.hasOwn(operation.payload, "draft") ||
+        Object.hasOwn(operation.payload, "expectedDigests"))
+        throw new Error("invalid-payload");
+    const report = text(operation, "text");
+    if (Buffer.byteLength(report) > 65536)
+        throw new Error("draft-too-large");
+    return report;
+}
 export async function discard(operation) {
     const place = treePlace({
         worktrees: operation.settings.worktrees,

package/dist/src/daemon/github-merge-call.d.ts

@@ -1,14 +1,17 @@
 import { type Operation } from "./github-operation.ts";
+export type MergeCheck = "beforeMerge" | null;
 export interface ReviewedPull {
     readonly number: number;
     readonly commit: string;
+    readonly check?: MergeCheck | undefined;
 }
 export declare function knownMerge(operation: Operation, expected: ReviewedPull & {
     readonly updated: string;
 }): Promise<{
     readonly head: string;
+    readonly open: boolean;
     readonly merged: string | undefined;
 }>;
 export declare function mergePull(operation: Operation, pull: ReviewedPull & {
     readonly updated: string;
-}): Promise<string>;
+}): Promise<string | Error>;