patchrelay 0.38.0 → 0.38.1

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.38.0",
-  "commit": "ec38527e2d4f",
-  "builtAt": "2026-04-10T17:39:33.237Z"
+  "version": "0.38.1",
+  "commit": "f8444979b2ac",
+  "builtAt": "2026-04-10T18:39:19.100Z"
 }

package/dist/github-linear-session-sync.js

@@ -0,0 +1,57 @@
+import { buildAgentSessionExternalUrls } from "./agent-session-presentation.js";
+import { buildAgentSessionPlanForIssue } from "./agent-session-plan.js";
+import { buildGitHubStateActivity } from "./linear-session-reporting.js";
+export async function emitGitHubLinearActivity(params) {
+    const { issue, newState, event, linearProvider, logger, feed } = params;
+    if (!issue.agentSessionId)
+        return;
+    try {
+        const linear = await linearProvider.forProject(issue.projectId);
+        if (!linear?.createAgentActivity)
+            return;
+        const content = buildGitHubStateActivity(issue.factoryState, event);
+        if (!content)
+            return;
+        const allowEphemeral = content.type === "thought" || content.type === "action";
+        await linear.createAgentActivity({
+            agentSessionId: issue.agentSessionId,
+            content,
+            ...(allowEphemeral ? { ephemeral: false } : {}),
+        });
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        logger.warn({ issueKey: issue.issueKey, newState, error: msg }, "Failed to emit Linear activity from GitHub webhook");
+        feed?.publish({
+            level: "warn",
+            kind: "linear",
+            issueKey: issue.issueKey,
+            projectId: issue.projectId,
+            status: "linear_error",
+            summary: `Linear activity failed: ${msg}`,
+        });
+    }
+}
+export async function syncGitHubLinearSession(params) {
+    const { issue, linearProvider, logger, config } = params;
+    if (!issue.agentSessionId)
+        return;
+    try {
+        const linear = await linearProvider.forProject(issue.projectId);
+        if (!linear?.updateAgentSession)
+            return;
+        const externalUrls = buildAgentSessionExternalUrls(config, {
+            ...(issue.issueKey ? { issueKey: issue.issueKey } : {}),
+            ...(issue.prUrl ? { prUrl: issue.prUrl } : {}),
+        });
+        await linear.updateAgentSession({
+            agentSessionId: issue.agentSessionId,
+            plan: buildAgentSessionPlanForIssue(issue),
+            ...(externalUrls ? { externalUrls } : {}),
+        });
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        logger.warn({ issueKey: issue.issueKey, error: msg }, "Failed to sync Linear session from GitHub webhook");
+    }
+}

package/dist/github-pr-comment-handler.js

@@ -0,0 +1,74 @@
+export class GitHubPrCommentHandler {
+    db;
+    enqueueIssue;
+    logger;
+    codex;
+    feed;
+    constructor(db, enqueueIssue, logger, codex, feed) {
+        this.db = db;
+        this.enqueueIssue = enqueueIssue;
+        this.logger = logger;
+        this.codex = codex;
+        this.feed = feed;
+    }
+    async handleCreatedComment(payload) {
+        if (payload.action !== "created")
+            return;
+        const issuePayload = payload.issue;
+        const comment = payload.comment;
+        if (!issuePayload || !comment)
+            return;
+        if (!issuePayload.pull_request)
+            return;
+        const body = typeof comment.body === "string" ? comment.body : "";
+        if (!body.trim())
+            return;
+        const user = comment.user;
+        const author = typeof user?.login === "string" ? user.login : "unknown";
+        if (typeof user?.type === "string" && user.type === "Bot")
+            return;
+        const prNumber = typeof issuePayload.number === "number" ? issuePayload.number : undefined;
+        if (!prNumber)
+            return;
+        const issue = this.db.issues.getIssueByPrNumber(prNumber);
+        if (!issue)
+            return;
+        this.feed?.publish({
+            level: "info",
+            kind: "comment",
+            issueKey: issue.issueKey,
+            projectId: issue.projectId,
+            stage: issue.factoryState,
+            status: "pr_comment",
+            summary: `GitHub PR comment from ${author}`,
+            detail: body.slice(0, 200),
+        });
+        if (issue.activeRunId) {
+            const run = this.db.runs.getRunById(issue.activeRunId);
+            if (run?.threadId && run.turnId) {
+                try {
+                    await this.codex.steerTurn({
+                        threadId: run.threadId,
+                        turnId: run.turnId,
+                        input: `GitHub PR comment from ${author}:\n\n${body}`,
+                    });
+                    this.logger.info({ issueKey: issue.issueKey, author }, "Forwarded GitHub PR comment to active run");
+                    return;
+                }
+                catch (error) {
+                    const msg = error instanceof Error ? error.message : String(error);
+                    this.logger.warn({ issueKey: issue.issueKey, error: msg }, "Failed to forward GitHub PR comment");
+                }
+            }
+        }
+        this.db.issueSessions.appendIssueSessionEvent({
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            eventType: "followup_comment",
+            eventJson: JSON.stringify({ body, author }),
+        });
+        if (this.db.issueSessions.peekIssueSessionWake(issue.projectId, issue.linearIssueId)) {
+            this.enqueueIssue(issue.projectId, issue.linearIssueId);
+        }
+    }
+}

package/dist/github-webhook-failure-context.js

@@ -0,0 +1,70 @@
+export function getRelevantGitHubCiSnapshot(db, issue, event) {
+    const snapshot = db.issues.getLatestGitHubCiSnapshot(issue.projectId, issue.linearIssueId);
+    if (!snapshot)
+        return undefined;
+    if (snapshot.headSha !== event.headSha)
+        return undefined;
+    return snapshot;
+}
+export function pickPrimaryFailedCheck(snapshot) {
+    const gateName = snapshot.gateCheckName?.trim().toLowerCase();
+    return snapshot.failedChecks.find((entry) => entry.name.trim().toLowerCase() !== gateName)
+        ?? snapshot.failedChecks[0];
+}
+export async function resolveGitHubBranchFailureContext(params) {
+    const repoFullName = params.project?.github?.repoFullName ?? params.event.repoFullName;
+    const snapshot = getRelevantGitHubCiSnapshot(params.db, params.issue, params.event);
+    const primaryFailedCheck = snapshot ? pickPrimaryFailedCheck(snapshot) : undefined;
+    const context = await params.failureContextResolver.resolve({
+        source: "branch_ci",
+        repoFullName,
+        event: primaryFailedCheck
+            ? {
+                ...params.event,
+                checkName: primaryFailedCheck.name,
+                checkUrl: primaryFailedCheck.detailsUrl ?? params.event.checkUrl,
+                checkDetailsUrl: primaryFailedCheck.detailsUrl ?? params.event.checkDetailsUrl,
+            }
+            : params.event,
+    });
+    return {
+        ...(context ? context : {}),
+        ...(context?.headSha || params.event.headSha ? { failureHeadSha: context?.headSha ?? params.event.headSha } : {}),
+        ...(context?.failureSignature ? { failureSignature: context.failureSignature } : {}),
+    };
+}
+export function buildGitHubQueueFailureContext(event, project, queueRepairContext) {
+    const repoFullName = event.repoFullName || project?.github?.repoFullName || "";
+    const incident = queueRepairContext && typeof queueRepairContext === "object"
+        ? queueRepairContext
+        : undefined;
+    const summary = typeof incident?.incidentSummary === "string"
+        ? incident.incidentSummary
+        : event.checkOutputSummary ?? event.checkOutputTitle;
+    const failureHeadSha = event.headSha;
+    const failureSignature = [
+        "queue_eviction",
+        failureHeadSha ?? "unknown-sha",
+        event.checkName ?? "merge-steward/queue",
+    ].join("::");
+    return {
+        source: "queue_eviction",
+        repoFullName,
+        capturedAt: new Date().toISOString(),
+        ...(failureHeadSha ? { headSha: failureHeadSha, failureHeadSha } : {}),
+        ...(event.checkName ? { checkName: event.checkName } : {}),
+        ...(event.checkUrl ? { checkUrl: event.checkUrl } : {}),
+        ...(event.checkDetailsUrl ? { checkDetailsUrl: event.checkDetailsUrl } : {}),
+        ...(summary ? { summary } : {}),
+        failureSignature,
+    };
+}
+export function resolveGitHubCheckClass(checkName, project) {
+    if (!checkName || !project)
+        return "code";
+    if ((project.reviewChecks ?? []).some((name) => checkName.includes(name)))
+        return "review";
+    if ((project.gateChecks ?? []).some((name) => checkName.includes(name)))
+        return "gate";
+    return "code";
+}