patchrelay 0.38.0 → 0.38.2

package/dist/github-webhook-issue-resolution.js

@@ -0,0 +1,46 @@
+export function resolveGitHubWebhookIssue(db, project, event) {
+    if (event.prNumber !== undefined) {
+        const byPr = db.issues.getIssueByPrNumber(event.prNumber);
+        if (byPr && byPr.projectId === project.id) {
+            return { issue: byPr, linkedBy: "pr" };
+        }
+    }
+    const byBranch = db.issues.getIssueByBranch(event.branchName);
+    if (byBranch && byBranch.projectId === project.id) {
+        return { issue: byBranch, linkedBy: "branch" };
+    }
+    const byIssueKey = resolveGitHubWebhookIssueByKey(db, project, event);
+    if (byIssueKey) {
+        return { issue: byIssueKey, linkedBy: "issue_key" };
+    }
+    return undefined;
+}
+export function resolveGitHubWebhookIssueByKey(db, project, event) {
+    const candidates = new Set();
+    const sources = [event.prTitle, event.prBody, event.branchName];
+    for (const prefix of project.issueKeyPrefixes) {
+        const normalizedPrefix = prefix.trim();
+        if (!normalizedPrefix)
+            continue;
+        const pattern = new RegExp(`\\b${escapeRegExp(normalizedPrefix)}-\\d+\\b`, "gi");
+        for (const source of sources) {
+            if (!source)
+                continue;
+            for (const match of source.matchAll(pattern)) {
+                candidates.add(match[0].toUpperCase());
+            }
+        }
+    }
+    if (candidates.size !== 1) {
+        return undefined;
+    }
+    const [issueKey] = [...candidates];
+    if (!issueKey) {
+        return undefined;
+    }
+    const issue = db.issues.getIssueByKey(issueKey);
+    return issue?.projectId === project.id ? issue : undefined;
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

package/dist/github-webhook-late-publication-guard.js

@@ -0,0 +1,94 @@
+function isPatchRelayBot(login) {
+    return login === "patchrelay[bot]" || login === "app/patchrelay";
+}
+function parseRepo(repoFullName) {
+    const [owner, repo] = repoFullName.split("/", 2);
+    if (!owner || !repo)
+        return undefined;
+    return { owner, repo };
+}
+export async function maybeCloseLatePublishedImplementationPr(params) {
+    const { db, logger, feed, issue, event, fetchImpl } = params;
+    if (event.triggerEvent !== "pr_opened")
+        return false;
+    if (event.prNumber === undefined)
+        return false;
+    if (issue.prNumber !== undefined)
+        return false;
+    if (!isPatchRelayBot(event.prAuthorLogin))
+        return false;
+    const latestRun = db.runs.getLatestRunForIssue(issue.projectId, issue.linearIssueId);
+    if (!latestRun || latestRun.runType !== "implementation")
+        return false;
+    if (latestRun.status === "running" || latestRun.status === "completed")
+        return false;
+    const repo = parseRepo(event.repoFullName);
+    const token = process.env.GITHUB_TOKEN ?? process.env.GH_TOKEN;
+    if (!repo || !token) {
+        logger.warn({
+            issueKey: issue.issueKey,
+            prNumber: event.prNumber,
+            latestRunId: latestRun.id,
+            latestRunStatus: latestRun.status,
+        }, "Late PatchRelay PR was detected after the implementation run had already stopped, but PatchRelay could not auto-close it");
+        feed?.publish({
+            level: "warn",
+            kind: "github",
+            issueKey: issue.issueKey,
+            projectId: issue.projectId,
+            stage: issue.factoryState,
+            status: "late_pr_detected",
+            summary: `Detected late PR #${event.prNumber} from an inactive implementation run`,
+            detail: latestRun.failureReason ?? `Latest implementation run status: ${latestRun.status}`,
+        });
+        return false;
+    }
+    const response = await fetchImpl(`https://api.github.com/repos/${encodeURIComponent(repo.owner)}/${encodeURIComponent(repo.repo)}/pulls/${event.prNumber}`, {
+        method: "PATCH",
+        headers: {
+            Authorization: `Bearer ${token}`,
+            Accept: "application/vnd.github+json",
+            "Content-Type": "application/json",
+            "User-Agent": "patchrelay",
+            "X-GitHub-Api-Version": "2022-11-28",
+        },
+        body: JSON.stringify({ state: "closed" }),
+    });
+    if (!response.ok) {
+        logger.warn({
+            issueKey: issue.issueKey,
+            prNumber: event.prNumber,
+            status: response.status,
+            latestRunId: latestRun.id,
+            latestRunStatus: latestRun.status,
+        }, "Failed to auto-close late PatchRelay PR from an inactive implementation run");
+        feed?.publish({
+            level: "warn",
+            kind: "github",
+            issueKey: issue.issueKey,
+            projectId: issue.projectId,
+            stage: issue.factoryState,
+            status: "late_pr_close_failed",
+            summary: `Could not auto-close late PR #${event.prNumber}`,
+            detail: latestRun.failureReason ?? `Latest implementation run status: ${latestRun.status}`,
+        });
+        return false;
+    }
+    logger.warn({
+        issueKey: issue.issueKey,
+        prNumber: event.prNumber,
+        latestRunId: latestRun.id,
+        latestRunStatus: latestRun.status,
+    }, "Auto-closed late PatchRelay PR from an inactive implementation run");
+    feed?.publish({
+        level: "warn",
+        kind: "github",
+        issueKey: issue.issueKey,
+        projectId: issue.projectId,
+        stage: issue.factoryState,
+        status: "late_pr_closed",
+        summary: `Auto-closed late PR #${event.prNumber} from an inactive implementation run`,
+        detail: latestRun.failureReason ?? `Latest implementation run status: ${latestRun.status}`,
+    });
+    return true;
+}

package/dist/github-webhook-policy.js

@@ -0,0 +1,105 @@
+import { resolveFactoryStateFromGitHub } from "./factory-state.js";
+import { resolveMergeQueueProtocol, } from "./merge-queue-protocol.js";
+import { isIssueTerminal } from "./pr-state.js";
+const DEFAULT_GATE_CHECK_NAMES = ["verify", "tests"];
+/**
+ * GitHub sends both check_run and check_suite completion events.
+ * A single CI run generates many individual check_run events as each job finishes,
+ * but PatchRelay should only start ci_repair once the configured gate check
+ * has gone terminal for the current PR head SHA. We still treat most check_run
+ * events as metadata-only and only react to queue eviction checks or the settled
+ * gate check.
+ */
+export function isMetadataOnlyCheckEvent(event) {
+    return event.eventSource === "check_run"
+        && (event.triggerEvent === "check_passed" || event.triggerEvent === "check_failed");
+}
+export function getGateCheckNames(project) {
+    const configured = (project?.gateChecks ?? []).map((entry) => entry.trim()).filter(Boolean);
+    return configured.length > 0 ? configured : DEFAULT_GATE_CHECK_NAMES;
+}
+export function getPrimaryGateCheckName(project) {
+    return getGateCheckNames(project)[0] ?? "verify";
+}
+export function isGateCheckEvent(event, project) {
+    if (event.eventSource !== "check_run" || !event.checkName)
+        return false;
+    const normalized = event.checkName.trim().toLowerCase();
+    return getGateCheckNames(project).some((entry) => entry.trim().toLowerCase() === normalized);
+}
+export function deriveImmediatePrCheckStatus(issue, event, project) {
+    if (event.triggerEvent === "pr_synchronize") {
+        return "pending";
+    }
+    if (event.eventSource !== "check_run") {
+        return undefined;
+    }
+    if (!isGateCheckEvent(event, project)) {
+        return undefined;
+    }
+    if (isStaleGateEvent(issue, event)) {
+        return undefined;
+    }
+    return event.checkStatus;
+}
+export function isStaleGateEvent(issue, event) {
+    return Boolean(issue.lastGitHubCiSnapshotHeadSha
+        && event.headSha
+        && issue.lastGitHubCiSnapshotHeadSha !== event.headSha);
+}
+export function isQueueEvictionFailure(issue, event, project) {
+    const protocol = resolveMergeQueueProtocol(project);
+    return event.eventSource === "check_run"
+        && event.checkName === protocol.evictionCheckName;
+}
+export function isSettledBranchFailure(db, issue, event, project) {
+    if (event.triggerEvent !== "check_failed" || issue.prState !== "open")
+        return false;
+    if (!isGateCheckEvent(event, project))
+        return false;
+    const snapshot = db.issues.getLatestGitHubCiSnapshot(issue.projectId, issue.linearIssueId);
+    if (!snapshot || snapshot.headSha !== event.headSha)
+        return false;
+    return snapshot?.gateCheckStatus === "failure" && snapshot.headSha === event.headSha;
+}
+export function canClearFailureProvenance(issue, event, project) {
+    if (event.triggerEvent !== "check_passed")
+        return true;
+    if (isQueueEvictionFailure(issue, event, project)) {
+        return !issue.lastGitHubFailureHeadSha || issue.lastGitHubFailureHeadSha === event.headSha;
+    }
+    if (!isGateCheckEvent(event, project)) {
+        return true;
+    }
+    if (isStaleGateEvent(issue, event)) {
+        return false;
+    }
+    return !issue.lastGitHubFailureHeadSha || issue.lastGitHubFailureHeadSha === event.headSha;
+}
+export function resolveGitHubFactoryStateForEvent(issue, event, project) {
+    if (event.triggerEvent === "pr_closed") {
+        return undefined;
+    }
+    const effectiveCurrentState = (issue.factoryState === "awaiting_input" || issue.factoryState === "delegated")
+        && (event.prState === "open" || event.prNumber !== undefined)
+        ? "pr_open"
+        : issue.factoryState;
+    if (event.triggerEvent === "check_failed"
+        && isQueueEvictionFailure(issue, event, project)
+        && issue.prState === "open"
+        && issue.activeRunId === undefined
+        && !isIssueTerminal(issue)) {
+        return "repairing_queue";
+    }
+    const resolved = resolveFactoryStateFromGitHub(event.triggerEvent, effectiveCurrentState, {
+        prReviewState: issue.prReviewState,
+        activeRunId: issue.activeRunId,
+    });
+    if (resolved !== undefined) {
+        return resolved;
+    }
+    if (effectiveCurrentState !== issue.factoryState) {
+        return effectiveCurrentState;
+    }
+    return undefined;
+}

package/dist/github-webhook-reactive-run.js

@@ -0,0 +1,302 @@
+import { summarizeGitHubFailureContext } from "./github-failure-context.js";
+import { buildQueueRepairContextFromEvent } from "./merge-queue-incident.js";
+import { isIssueTerminal } from "./pr-state.js";
+import { buildGitHubQueueFailureContext, getRelevantGitHubCiSnapshot, resolveGitHubBranchFailureContext, resolveGitHubCheckClass, } from "./github-webhook-failure-context.js";
+import { isQueueEvictionFailure, isSettledBranchFailure } from "./github-webhook-policy.js";
+export async function maybeEnqueueGitHubReactiveRun(params) {
+    const { issue, event, project, logger, feed, enqueueIssue, db, fetchImpl, failureContextResolver } = params;
+    if (issue.activeRunId !== undefined)
+        return;
+    if (isIssueTerminal(issue))
+        return;
+    if (!issue.delegatedToPatchRelay) {
+        feed?.publish({
+            level: "info",
+            kind: "github",
+            issueKey: issue.issueKey,
+            projectId: issue.projectId,
+            stage: issue.factoryState,
+            status: "ignored_undelegated",
+            summary: `Ignored ${event.triggerEvent} because the issue is undelegated`,
+        });
+        return;
+    }
+    if (event.triggerEvent === "check_failed" && issue.prState === "open") {
+        await handleCheckFailedEvent({
+            db,
+            logger,
+            feed,
+            enqueueIssue,
+            issue,
+            event,
+            project,
+            failureContextResolver,
+        });
+        return;
+    }
+    if (event.triggerEvent === "review_changes_requested") {
+        await handleRequestedChangesEvent({
+            db,
+            logger,
+            feed,
+            enqueueIssue,
+            issue,
+            event,
+            fetchImpl,
+        });
+    }
+}
+async function handleCheckFailedEvent(params) {
+    const { db, logger, feed, enqueueIssue, issue, event, project, failureContextResolver } = params;
+    if (isQueueEvictionFailure(issue, event, project)) {
+        const queueRepairContext = buildQueueRepairContextFromEvent(event);
+        const failureContext = buildGitHubQueueFailureContext(event, project, queueRepairContext);
+        if (hasDuplicatePendingReactiveRun(db, feed, issue, "queue_repair", failureContext)) {
+            return;
+        }
+        const hadPendingWake = db.issueSessions.hasPendingIssueSessionEvents(issue.projectId, issue.linearIssueId);
+        db.issueSessions.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            eventType: "merge_steward_incident",
+            eventJson: JSON.stringify({
+                ...queueRepairContext,
+                ...failureContext,
+            }),
+            dedupeKey: failureContext.failureSignature,
+        });
+        const queuedRunType = hadPendingWake
+            ? db.issueSessions.peekIssueSessionWake(issue.projectId, issue.linearIssueId)?.runType
+            : enqueuePendingSessionWake(db, enqueueIssue, issue.projectId, issue.linearIssueId);
+        logger.info({ issueKey: issue.issueKey, checkName: event.checkName }, "Queue eviction detected, enqueued queue repair");
+        feed?.publish({
+            level: "warn",
+            kind: "github",
+            issueKey: issue.issueKey,
+            projectId: issue.projectId,
+            stage: "repairing_queue",
+            status: "queue_repair_queued",
+            summary: `${queuedRunType ?? "queue_repair"} queued after external failure from ${event.checkName}`,
+            detail: queueRepairContext.incidentSummary ?? queueRepairContext.incidentUrl ?? event.checkUrl,
+        });
+        return;
+    }
+    if (!isSettledBranchFailure(db, issue, event, project)) {
+        feed?.publish({
+            level: "info",
+            kind: "github",
+            issueKey: issue.issueKey,
+            projectId: issue.projectId,
+            stage: issue.factoryState,
+            status: "ci_waiting_for_settlement",
+            summary: `Waiting for settled ${project?.gateChecks?.[0] ?? "verify"} result before starting CI repair`,
+        });
+        return;
+    }
+    const failureContext = await resolveGitHubBranchFailureContext({
+        db,
+        issue,
+        event,
+        project,
+        failureContextResolver,
+    });
+    if (hasDuplicatePendingReactiveRun(db, feed, issue, "ci_repair", failureContext)) {
+        return;
+    }
+    const hadPendingWake = db.issueSessions.hasPendingIssueSessionEvents(issue.projectId, issue.linearIssueId);
+    const snapshot = getRelevantGitHubCiSnapshot(db, issue, event);
+    db.issues.upsertIssue({
+        projectId: issue.projectId,
+        linearIssueId: issue.linearIssueId,
+        lastGitHubFailureSource: "branch_ci",
+        lastGitHubFailureHeadSha: failureContext.failureHeadSha ?? null,
+        lastGitHubFailureSignature: failureContext.failureSignature ?? null,
+        lastGitHubFailureCheckName: failureContext.checkName ?? event.checkName ?? null,
+        lastGitHubFailureCheckUrl: failureContext.checkUrl ?? event.checkUrl ?? null,
+        lastGitHubFailureContextJson: JSON.stringify(failureContext),
+        lastGitHubFailureAt: new Date().toISOString(),
+        lastQueueIncidentJson: null,
+    });
+    db.issueSessions.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
+        projectId: issue.projectId,
+        linearIssueId: issue.linearIssueId,
+        eventType: "settled_red_ci",
+        eventJson: JSON.stringify({
+            ...failureContext,
+            checkClass: resolveGitHubCheckClass(failureContext.checkName ?? event.checkName, project),
+            ...(snapshot ? { ciSnapshot: snapshot } : {}),
+        }),
+        dedupeKey: failureContext.failureSignature,
+    });
+    const queuedRunType = hadPendingWake
+        ? db.issueSessions.peekIssueSessionWake(issue.projectId, issue.linearIssueId)?.runType
+        : enqueuePendingSessionWake(db, enqueueIssue, issue.projectId, issue.linearIssueId);
+    logger.info({ issueKey: issue.issueKey, checkName: failureContext.checkName ?? event.checkName }, "Enqueued CI repair run");
+    feed?.publish({
+        level: "warn",
+        kind: "github",
+        issueKey: issue.issueKey,
+        projectId: issue.projectId,
+        stage: "repairing_ci",
+        status: "ci_repair_queued",
+        summary: `${queuedRunType ?? "ci_repair"} queued for ${failureContext.jobName ?? failureContext.checkName ?? "failed check"}`,
+        detail: summarizeGitHubFailureContext(failureContext),
+    });
+}
+async function handleRequestedChangesEvent(params) {
+    const { db, logger, feed, enqueueIssue, issue, event, fetchImpl } = params;
+    const hadPendingWake = db.issueSessions.hasPendingIssueSessionEvents(issue.projectId, issue.linearIssueId);
+    const reviewComments = await fetchReviewCommentsForEvent(event, fetchImpl).catch((error) => {
+        logger.warn({
+            issueKey: issue.issueKey,
+            prNumber: event.prNumber,
+            reviewId: event.reviewId,
+            error: error instanceof Error ? error.message : String(error),
+        }, "Failed to fetch inline review comments for requested-changes event");
+        return undefined;
+    });
+    db.issueSessions.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
+        projectId: issue.projectId,
+        linearIssueId: issue.linearIssueId,
+        eventType: "review_changes_requested",
+        eventJson: JSON.stringify({
+            reviewBody: event.reviewBody,
+            reviewCommitId: event.reviewCommitId,
+            reviewId: event.reviewId,
+            reviewUrl: buildGitHubReviewUrl(event.repoFullName, event.prNumber, event.reviewId),
+            reviewerName: event.reviewerName,
+            ...(reviewComments && reviewComments.length > 0 ? { reviewComments } : {}),
+        }),
+        dedupeKey: [
+            "review_changes_requested",
+            issue.prHeadSha ?? event.headSha ?? "unknown-sha",
+            event.reviewerName ?? "unknown-reviewer",
+        ].join("::"),
+    });
+    const queuedRunType = hadPendingWake
+        ? db.issueSessions.peekIssueSessionWake(issue.projectId, issue.linearIssueId)?.runType
+        : enqueuePendingSessionWake(db, enqueueIssue, issue.projectId, issue.linearIssueId);
+    logger.info({ issueKey: issue.issueKey, reviewerName: event.reviewerName }, "Enqueued review fix run");
+    feed?.publish({
+        level: "warn",
+        kind: "github",
+        issueKey: issue.issueKey,
+        projectId: issue.projectId,
+        stage: "changes_requested",
+        status: "review_fix_queued",
+        summary: `${queuedRunType ?? "review_fix"} queued after requested changes`,
+        detail: reviewComments && reviewComments.length > 0
+            ? `${reviewComments.length} inline review comment${reviewComments.length === 1 ? "" : "s"} captured`
+            : event.reviewBody?.slice(0, 200) ?? event.reviewerName,
+    });
+}
+function hasDuplicatePendingReactiveRun(db, feed, issue, runType, failureContext) {
+    const signature = typeof failureContext.failureSignature === "string" ? failureContext.failureSignature : undefined;
+    const headSha = typeof failureContext.failureHeadSha === "string"
+        ? failureContext.failureHeadSha
+        : typeof failureContext.headSha === "string" ? failureContext.headSha : undefined;
+    if (!signature)
+        return false;
+    const pendingWake = db.issueSessions.peekIssueSessionWake(issue.projectId, issue.linearIssueId);
+    if (pendingWake?.runType === runType && pendingWake.eventIds.length > 0) {
+        const existing = pendingWake.context;
+        if (existing?.failureSignature === signature
+            && (headSha === undefined || existing.failureHeadSha === headSha || existing.headSha === headSha)) {
+            feed?.publish({
+                level: "info",
+                kind: "github",
+                issueKey: issue.issueKey,
+                projectId: issue.projectId,
+                stage: issue.factoryState,
+                status: "repair_deduped",
+                summary: `Skipped duplicate ${runType} for ${signature}`,
+            });
+            return true;
+        }
+    }
+    if (issue.lastAttemptedFailureSignature === signature
+        && (headSha === undefined || issue.lastAttemptedFailureHeadSha === headSha)) {
+        feed?.publish({
+            level: "info",
+            kind: "github",
+            issueKey: issue.issueKey,
+            projectId: issue.projectId,
+            stage: issue.factoryState,
+            status: "repair_deduped",
+            summary: `Already attempted ${runType} for this failing PR head`,
+        });
+        return true;
+    }
+    return false;
+}
+function enqueuePendingSessionWake(db, enqueueIssue, projectId, issueId) {
+    const wake = db.issueSessions.peekIssueSessionWake(projectId, issueId);
+    if (!wake) {
+        return undefined;
+    }
+    enqueueIssue(projectId, issueId);
+    return wake.runType;
+}
+async function fetchReviewCommentsForEvent(event, fetchImpl) {
+    if (event.triggerEvent !== "review_changes_requested") {
+        return undefined;
+    }
+    if (!event.repoFullName || event.prNumber === undefined || event.reviewId === undefined) {
+        return undefined;
+    }
+    const token = process.env.GITHUB_TOKEN ?? process.env.GH_TOKEN;
+    if (!token) {
+        return undefined;
+    }
+    const [owner, repo] = event.repoFullName.split("/", 2);
+    if (!owner || !repo) {
+        return undefined;
+    }
+    const response = await fetchImpl(`https://api.github.com/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/pulls/${event.prNumber}/reviews/${event.reviewId}/comments?per_page=100`, {
+        headers: {
+            Authorization: `Bearer ${token}`,
+            Accept: "application/vnd.github+json",
+            "User-Agent": "patchrelay",
+            "X-GitHub-Api-Version": "2022-11-28",
+        },
+    });
+    if (!response.ok) {
+        throw new Error(`GitHub review comment fetch failed (${response.status})`);
+    }
+    const payload = await response.json();
+    if (!Array.isArray(payload)) {
+        return undefined;
+    }
+    const comments = [];
+    for (const entry of payload) {
+        if (!entry || typeof entry !== "object")
+            continue;
+        const record = entry;
+        const body = typeof record.body === "string" ? record.body.trim() : "";
+        const id = typeof record.id === "number" ? record.id : undefined;
+        if (!body || id === undefined)
+            continue;
+        comments.push({
+            id,
+            body,
+            ...(typeof record.path === "string" ? { path: record.path } : {}),
+            ...(typeof record.line === "number" ? { line: record.line } : {}),
+            ...(typeof record.side === "string" ? { side: record.side } : {}),
+            ...(typeof record.start_line === "number" ? { startLine: record.start_line } : {}),
+            ...(typeof record.start_side === "string" ? { startSide: record.start_side } : {}),
+            ...(typeof record.commit_id === "string" ? { commitId: record.commit_id } : {}),
+            ...(typeof record.html_url === "string" ? { url: record.html_url } : {}),
+            ...(typeof record.diff_hunk === "string" ? { diffHunk: record.diff_hunk } : {}),
+            ...(typeof record.user?.login === "string"
+                ? { authorLogin: String(record.user.login) }
+                : {}),
+        });
+    }
+    return comments;
+}
+function buildGitHubReviewUrl(repoFullName, prNumber, reviewId) {
+    if (!repoFullName || prNumber === undefined || reviewId === undefined) {
+        return undefined;
+    }
+    return `https://github.com/${repoFullName}/pull/${prNumber}#pullrequestreview-${reviewId}`;
+}