patchrelay 0.81.0 → 0.83.0

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

@@ -1,309 +0,0 @@
-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";
-import { buildRequestedChangesWakeIdentity } from "./reactive-wake-keys.js";
-const WRITER = "github-webhook-reactive-run";
-export async function maybeEnqueueGitHubReactiveRun(params) {
-    const { issue, event, project, logger, feed, wakeDispatcher, db, fetchImpl, failureContextResolver } = params;
-    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") {
-        if (issue.activeRunId !== undefined) {
-            return;
-        }
-        await handleCheckFailedEvent({
-            db,
-            logger,
-            feed,
-            wakeDispatcher,
-            issue,
-            event,
-            project,
-            failureContextResolver,
-        });
-        return;
-    }
-    if (event.triggerEvent === "review_changes_requested") {
-        await handleRequestedChangesEvent({
-            db,
-            logger,
-            feed,
-            wakeDispatcher,
-            issue,
-            event,
-            fetchImpl,
-        });
-    }
-}
-async function handleCheckFailedEvent(params) {
-    const { db, logger, feed, wakeDispatcher, issue, event, project, failureContextResolver } = params;
-    // Plan §4.3: while In Deploy (`awaiting_queue`), branch CI is metadata
-    // only — the lander owns admission, and its spec CI on the integration
-    // tree is the gate. Queue eviction failures still flow through (they're
-    // how the lander signals a real integration regression).
-    if (issue.factoryState === "awaiting_queue" && !isQueueEvictionFailure(issue, event, project)) {
-        feed?.publish({
-            level: "info",
-            kind: "github",
-            issueKey: issue.issueKey,
-            projectId: issue.projectId,
-            stage: issue.factoryState,
-            status: "branch_ci_metadata_in_deploy",
-            summary: `Ignored ${event.checkName ?? "branch CI"} failure while In Deploy; lander owns admission`,
-        });
-        return;
-    }
-    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 queuedRunType = wakeDispatcher.recordEventAndDispatch(issue.projectId, issue.linearIssueId, {
-            eventType: "merge_steward_incident",
-            eventJson: JSON.stringify({
-                ...queueRepairContext,
-                ...failureContext,
-            }),
-            ...(failureContext.failureSignature ? { dedupeKey: failureContext.failureSignature } : {}),
-        });
-        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 snapshot = getRelevantGitHubCiSnapshot(db, issue, event);
-    db.issueSessions.commitIssueState({
-        writer: WRITER,
-        update: {
-            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,
-        },
-    });
-    const queuedRunType = wakeDispatcher.recordEventAndDispatch(issue.projectId, issue.linearIssueId, {
-        eventType: "settled_red_ci",
-        eventJson: JSON.stringify({
-            ...failureContext,
-            checkClass: resolveGitHubCheckClass(failureContext.checkName ?? event.checkName, project),
-            ...(snapshot ? { ciSnapshot: snapshot } : {}),
-        }),
-        ...(failureContext.failureSignature ? { dedupeKey: failureContext.failureSignature } : {}),
-    });
-    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 { logger, feed, wakeDispatcher, issue, event, fetchImpl } = params;
-    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;
-    });
-    const identity = buildRequestedChangesWakeIdentity({
-        linearIssueId: issue.linearIssueId,
-        headSha: issue.prHeadSha ?? event.headSha,
-        reviewCommitId: event.reviewCommitId,
-        reviewId: event.reviewId,
-        reviewerName: event.reviewerName,
-    });
-    const queuedRunType = wakeDispatcher.recordEventAndDispatch(issue.projectId, issue.linearIssueId, {
-        eventType: "review_changes_requested",
-        eventJson: JSON.stringify({
-            requestedChangesCoalesceKey: identity.coalesceKey,
-            ...(identity.headSha ? { requestedChangesHeadSha: identity.headSha } : {}),
-            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: identity.dedupeKey,
-    });
-    logger.info({
-        issueKey: issue.issueKey,
-        reviewerName: event.reviewerName,
-        deferredUntilRunRelease: issue.activeRunId !== undefined,
-    }, "Captured requested-changes follow-up");
-    feed?.publish({
-        level: "warn",
-        kind: "github",
-        issueKey: issue.issueKey,
-        projectId: issue.projectId,
-        stage: "changes_requested",
-        status: "review_fix_queued",
-        summary: issue.activeRunId === undefined
-            ? `${queuedRunType ?? "review_fix"} queued after requested changes`
-            : `${queuedRunType ?? "review_fix"} recorded and will resume after the active run finishes`,
-        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;
-}
-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}`;
-}