patchrelay 0.36.6 → 0.36.8

package/dist/run-finalizer.js

@@ -0,0 +1,161 @@
+import { buildStageReport, countEventMethods } from "./run-reporting.js";
+import { buildRunCompletedActivity, buildRunFailureActivity } from "./linear-session-reporting.js";
+export class RunFinalizer {
+    db;
+    logger;
+    linearSync;
+    enqueueIssue;
+    feed;
+    constructor(db, logger, linearSync, enqueueIssue, feed) {
+        this.db = db;
+        this.logger = logger;
+        this.linearSync = linearSync;
+        this.enqueueIssue = enqueueIssue;
+        this.feed = feed;
+    }
+    async finalizeCompletedRun(params) {
+        const { run, issue, thread, threadId } = params;
+        const trackedIssue = this.db.issueToTrackedIssue(issue);
+        const report = buildStageReport({ ...run, status: "completed" }, trackedIssue, thread, countEventMethods(this.db.runs.listThreadEvents(run.id)));
+        const freshIssue = this.db.getIssue(run.projectId, run.linearIssueId) ?? issue;
+        const verifiedRepairError = await params.verifyReactiveRunAdvancedBranch(run, freshIssue);
+        if (verifiedRepairError) {
+            const holdState = params.resolveRecoverableRunState(freshIssue) ?? "failed";
+            params.failRunAndClear(run, verifiedRepairError, holdState);
+            const heldIssue = this.db.getIssue(run.projectId, run.linearIssueId) ?? freshIssue;
+            this.feed?.publish({
+                level: "warn",
+                kind: "turn",
+                issueKey: freshIssue.issueKey,
+                projectId: run.projectId,
+                stage: run.runType,
+                status: "branch_not_advanced",
+                summary: verifiedRepairError,
+            });
+            void this.linearSync.emitActivity(heldIssue, buildRunFailureActivity(run.runType, verifiedRepairError));
+            void this.linearSync.syncSession(heldIssue, { activeRunType: run.runType });
+            this.linearSync.clearProgress(run.id);
+            params.releaseLease(run.projectId, run.linearIssueId);
+            return;
+        }
+        const missingReviewFixHeadError = await params.verifyReviewFixAdvancedHead(run, freshIssue);
+        if (missingReviewFixHeadError) {
+            params.failRunAndClear(run, missingReviewFixHeadError, "escalated");
+            const failedIssue = this.db.getIssue(run.projectId, run.linearIssueId) ?? freshIssue;
+            this.feed?.publish({
+                level: "error",
+                kind: "turn",
+                issueKey: freshIssue.issueKey,
+                projectId: run.projectId,
+                stage: run.runType,
+                status: "same_head_review_handoff_blocked",
+                summary: missingReviewFixHeadError,
+            });
+            void this.linearSync.emitActivity(failedIssue, buildRunFailureActivity(run.runType, missingReviewFixHeadError));
+            void this.linearSync.syncSession(failedIssue, { activeRunType: run.runType });
+            this.linearSync.clearProgress(run.id);
+            params.releaseLease(run.projectId, run.linearIssueId);
+            return;
+        }
+        const publishedOutcomeError = await params.verifyPublishedRunOutcome(run, freshIssue);
+        if (publishedOutcomeError) {
+            params.failRunAndClear(run, publishedOutcomeError, "failed");
+            const failedIssue = this.db.getIssue(run.projectId, run.linearIssueId) ?? freshIssue;
+            this.feed?.publish({
+                level: "warn",
+                kind: "turn",
+                issueKey: freshIssue.issueKey,
+                projectId: run.projectId,
+                stage: run.runType,
+                status: "publish_incomplete",
+                summary: publishedOutcomeError,
+            });
+            void this.linearSync.emitActivity(failedIssue, buildRunFailureActivity(run.runType, publishedOutcomeError));
+            void this.linearSync.syncSession(failedIssue, { activeRunType: run.runType });
+            this.linearSync.clearProgress(run.id);
+            if (params.source === "notification") {
+                params.releaseLease(run.projectId, run.linearIssueId);
+            }
+            return;
+        }
+        const refreshedIssue = await params.refreshIssueAfterReactivePublish(run, freshIssue);
+        const postRunFollowUp = await params.resolvePostRunFollowUp(run, refreshedIssue);
+        const postRunState = postRunFollowUp?.factoryState ?? params.resolveCompletedRunState(refreshedIssue, run);
+        const completed = params.withHeldLease(run.projectId, run.linearIssueId, (lease) => {
+            this.db.runs.finishRun(run.id, {
+                status: "completed",
+                threadId,
+                ...(params.completedTurnId ? { turnId: params.completedTurnId } : {}),
+                summaryJson: JSON.stringify({ latestAssistantMessage: report.assistantMessages.at(-1) ?? null }),
+                reportJson: JSON.stringify(report),
+            });
+            this.db.upsertIssue({
+                projectId: run.projectId,
+                linearIssueId: run.linearIssueId,
+                activeRunId: null,
+                ...(postRunState ? { factoryState: postRunState } : {}),
+                pendingRunType: null,
+                pendingRunContextJson: null,
+                ...(postRunFollowUp ? {} : (postRunState === "awaiting_queue" || postRunState === "done"
+                    ? {
+                        lastGitHubFailureSource: null,
+                        lastGitHubFailureHeadSha: null,
+                        lastGitHubFailureSignature: null,
+                        lastGitHubFailureCheckName: null,
+                        lastGitHubFailureCheckUrl: null,
+                        lastGitHubFailureContextJson: null,
+                        lastGitHubFailureAt: null,
+                        lastQueueIncidentJson: null,
+                        lastAttemptedFailureHeadSha: null,
+                        lastAttemptedFailureSignature: null,
+                    }
+                    : {})),
+            });
+            if (postRunFollowUp) {
+                return params.appendWakeEventWithLease(lease, issue, postRunFollowUp.pendingRunType, postRunFollowUp.context, "post_run");
+            }
+            return true;
+        });
+        if (!completed) {
+            this.logger.warn({ runId: run.id, issueId: run.linearIssueId }, "Skipping completion writes after losing issue-session lease");
+            this.linearSync.clearProgress(run.id);
+            params.releaseLease(run.projectId, run.linearIssueId);
+            return;
+        }
+        if (postRunFollowUp) {
+            this.feed?.publish({
+                level: "info",
+                kind: "stage",
+                issueKey: issue.issueKey,
+                projectId: run.projectId,
+                stage: postRunFollowUp.factoryState,
+                status: "follow_up_queued",
+                summary: postRunFollowUp.summary,
+            });
+            this.enqueueIssue(run.projectId, run.linearIssueId);
+        }
+        this.feed?.publish({
+            level: "info",
+            kind: "turn",
+            issueKey: issue.issueKey,
+            projectId: run.projectId,
+            stage: run.runType,
+            status: "completed",
+            summary: params.source === "notification"
+                ? `Turn completed for ${run.runType}`
+                : `Reconciliation: ${run.runType} completed${postRunState ? ` -> ${postRunState}` : ""}`,
+            ...(report.assistantMessages.at(-1) ? { detail: report.assistantMessages.at(-1) } : {}),
+        });
+        const updatedIssue = this.db.getIssue(run.projectId, run.linearIssueId) ?? refreshedIssue;
+        const completionSummary = report.assistantMessages.at(-1)?.slice(0, 300) ?? `${run.runType} completed.`;
+        void this.linearSync.emitActivity(updatedIssue, buildRunCompletedActivity({
+            runType: run.runType,
+            completionSummary,
+            postRunState: updatedIssue.factoryState,
+            ...(updatedIssue.prNumber !== undefined ? { prNumber: updatedIssue.prNumber } : {}),
+        }));
+        void this.linearSync.syncSession(updatedIssue);
+        this.linearSync.clearProgress(run.id);
+        params.releaseLease(run.projectId, run.linearIssueId);
+    }
+}

package/dist/run-launcher.js

@@ -0,0 +1,193 @@
+import { buildHookEnv, runProjectHook } from "./hook-runner.js";
+import { buildRunFailureActivity } from "./linear-session-reporting.js";
+import { loadPatchRelayRepoPrompting } from "./patchrelay-customization.js";
+import { buildRunPrompt as buildPatchRelayRunPrompt, findDisallowedPatchRelayPromptSectionIds, findUnknownPatchRelayPromptSectionIds, mergePromptCustomizationLayers, resolvePromptLayers, } from "./prompting/patchrelay.js";
+import { execCommand } from "./utils.js";
+function slugify(value) {
+    return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60);
+}
+function sanitizePathSegment(value) {
+    return value.replace(/[^a-zA-Z0-9._-]+/g, "-");
+}
+function shouldCompactThread(issue, threadGeneration, context) {
+    const followUpCount = typeof context?.followUpCount === "number" ? context.followUpCount : 0;
+    return issue.threadId !== undefined
+        && (threadGeneration ?? 0) >= 4
+        && followUpCount >= 4;
+}
+export function shouldReuseIssueThread(params) {
+    return Boolean(params.existingThreadId) && !params.compactThread && params.resumeThread;
+}
+export class RunLauncher {
+    config;
+    db;
+    codex;
+    logger;
+    worktreeManager;
+    constructor(config, db, codex, logger, worktreeManager) {
+        this.config = config;
+        this.db = db;
+        this.codex = codex;
+        this.logger = logger;
+        this.worktreeManager = worktreeManager;
+    }
+    prepareLaunchPlan(params) {
+        const repoPrompting = loadPatchRelayRepoPrompting({
+            repoRoot: params.project.repoPath,
+            logger: this.logger,
+        });
+        const promptLayer = mergePromptCustomizationLayers(resolvePromptLayers(this.config.prompting, params.runType), resolvePromptLayers(repoPrompting, params.runType));
+        const unknownPromptSections = findUnknownPatchRelayPromptSectionIds(promptLayer);
+        if (unknownPromptSections.length > 0) {
+            this.logger.warn({ issueKey: params.issue.issueKey, runType: params.runType, unknownPromptSections }, "PatchRelay prompt customization references unknown section ids");
+        }
+        const disallowedPromptSections = findDisallowedPatchRelayPromptSectionIds(promptLayer);
+        if (disallowedPromptSections.length > 0) {
+            this.logger.warn({ issueKey: params.issue.issueKey, runType: params.runType, disallowedPromptSections }, "PatchRelay prompt customization attempted to replace non-overridable sections");
+        }
+        const prompt = buildPatchRelayRunPrompt({
+            issue: params.issue,
+            runType: params.runType,
+            repoPath: params.project.repoPath,
+            ...(params.effectiveContext ? { context: params.effectiveContext } : {}),
+            ...(promptLayer ? { promptLayer } : {}),
+        });
+        const issueRef = sanitizePathSegment(params.issue.issueKey ?? params.issue.linearIssueId);
+        const slug = params.issue.title ? slugify(params.issue.title) : "";
+        const branchSuffix = slug ? `${issueRef}-${slug}` : issueRef;
+        const branchName = params.issue.branchName ?? `${params.project.branchPrefix}/${branchSuffix}`;
+        const worktreePath = params.issue.worktreePath ?? `${params.project.worktreeRoot}/${issueRef}`;
+        return { prompt, branchName, worktreePath };
+    }
+    claimRun(params) {
+        return this.db.issueSessions.withIssueSessionLease(params.item.projectId, params.item.issueId, params.leaseId, () => {
+            const fresh = this.db.getIssue(params.item.projectId, params.item.issueId);
+            if (!fresh || fresh.activeRunId !== undefined)
+                return undefined;
+            const wakeIssue = params.materializeLegacyPendingWake(fresh, {
+                projectId: params.item.projectId,
+                linearIssueId: params.item.issueId,
+                leaseId: params.leaseId,
+            });
+            const freshWake = params.resolveRunWake(wakeIssue);
+            if (!freshWake || freshWake.runType !== params.runType)
+                return undefined;
+            const created = this.db.runs.createRun({
+                issueId: fresh.id,
+                projectId: params.item.projectId,
+                linearIssueId: params.item.issueId,
+                runType: params.runType,
+                ...(params.sourceHeadSha ? { sourceHeadSha: params.sourceHeadSha } : {}),
+                promptText: params.prompt,
+            });
+            const failureHeadSha = typeof params.effectiveContext?.failureHeadSha === "string"
+                ? params.effectiveContext.failureHeadSha
+                : typeof params.effectiveContext?.headSha === "string" ? params.effectiveContext.headSha : undefined;
+            const failureSignature = typeof params.effectiveContext?.failureSignature === "string" ? params.effectiveContext.failureSignature : undefined;
+            this.db.upsertIssue({
+                projectId: params.item.projectId,
+                linearIssueId: params.item.issueId,
+                pendingRunType: null,
+                pendingRunContextJson: null,
+                activeRunId: created.id,
+                branchName: params.branchName,
+                worktreePath: params.worktreePath,
+                factoryState: params.runType === "implementation" ? "implementing"
+                    : params.runType === "ci_repair" ? "repairing_ci"
+                        : params.runType === "review_fix" || params.runType === "branch_upkeep" ? "changes_requested"
+                            : params.runType === "queue_repair" ? "repairing_queue"
+                                : "implementing",
+                ...((params.runType === "ci_repair" || params.runType === "queue_repair") && failureSignature
+                    ? {
+                        lastAttemptedFailureSignature: failureSignature,
+                        lastAttemptedFailureHeadSha: failureHeadSha ?? null,
+                    }
+                    : {}),
+            });
+            this.db.issueSessions.consumeIssueSessionEvents(params.item.projectId, params.item.issueId, freshWake.eventIds, created.id);
+            this.db.issueSessions.setIssueSessionLastWakeReason(params.item.projectId, params.item.issueId, freshWake.wakeReason ?? null);
+            this.db.issueSessions.setBranchOwnerWithLease({ projectId: params.item.projectId, linearIssueId: params.item.issueId, leaseId: params.leaseId }, "patchrelay");
+            return created;
+        });
+    }
+    async launchTurn(params) {
+        let threadId;
+        let turnId;
+        let parentThreadId;
+        try {
+            await this.worktreeManager.ensureIssueWorktree(params.project.repoPath, params.project.worktreeRoot, params.worktreePath, params.branchName, { allowExistingOutsideRoot: params.issue.branchName !== undefined });
+            if (params.botIdentity) {
+                const gitBin = this.config.runner.gitBin;
+                await execCommand(gitBin, ["-C", params.worktreePath, "config", "user.name", params.botIdentity.name], { timeoutMs: 5_000 });
+                await execCommand(gitBin, ["-C", params.worktreePath, "config", "user.email", params.botIdentity.email], { timeoutMs: 5_000 });
+                const credentialHelper = `!f() { echo "username=x-access-token"; echo "password=$(cat ${params.botIdentity.tokenFile})"; }; f`;
+                await execCommand(gitBin, ["-C", params.worktreePath, "config", "credential.helper", credentialHelper], { timeoutMs: 5_000 });
+            }
+            await params.resetWorktreeToTrackedBranch(params.worktreePath, params.branchName, params.issue);
+            if (params.runType !== "queue_repair") {
+                await params.freshenWorktree(params.worktreePath, params.project, params.issue);
+            }
+            const hookEnv = buildHookEnv(params.issue.issueKey ?? params.issue.linearIssueId, params.branchName, params.runType, params.worktreePath);
+            const prepareResult = await runProjectHook(params.project.repoPath, "prepare-worktree", { cwd: params.worktreePath, env: hookEnv });
+            if (prepareResult.ran && prepareResult.exitCode !== 0) {
+                throw new Error(`prepare-worktree hook failed (exit ${prepareResult.exitCode}): ${prepareResult.stderr?.slice(0, 500) ?? ""}`);
+            }
+            params.assertLaunchLease(params.run, "before starting the Codex turn");
+            const compactThread = shouldCompactThread(params.issue, params.issueSession?.threadGeneration, params.effectiveContext);
+            if (compactThread && params.issue.threadId) {
+                parentThreadId = params.issue.threadId;
+            }
+            if (shouldReuseIssueThread({ existingThreadId: params.issue.threadId, compactThread, resumeThread: params.resumeThread })) {
+                threadId = params.issue.threadId;
+            }
+            else {
+                const thread = await this.codex.startThread({ cwd: params.worktreePath });
+                threadId = thread.id;
+                this.db.issueSessions.upsertIssueWithLease({ projectId: params.project.id, linearIssueId: params.issue.linearIssueId, leaseId: params.leaseId }, { projectId: params.project.id, linearIssueId: params.issue.linearIssueId, threadId });
+            }
+            try {
+                const turn = await this.codex.startTurn({ threadId, cwd: params.worktreePath, input: params.prompt });
+                turnId = turn.turnId;
+            }
+            catch (turnError) {
+                const msg = turnError instanceof Error ? turnError.message : String(turnError);
+                if (msg.includes("thread not found") || msg.includes("not materialized")) {
+                    this.logger.info({ issueKey: params.issue.issueKey, staleThreadId: threadId }, "Thread is stale, retrying with fresh thread");
+                    const thread = await this.codex.startThread({ cwd: params.worktreePath });
+                    threadId = thread.id;
+                    this.db.issueSessions.upsertIssueWithLease({ projectId: params.project.id, linearIssueId: params.issue.linearIssueId, leaseId: params.leaseId }, { projectId: params.project.id, linearIssueId: params.issue.linearIssueId, threadId });
+                    const turn = await this.codex.startTurn({ threadId, cwd: params.worktreePath, input: params.prompt });
+                    turnId = turn.turnId;
+                }
+                else {
+                    throw turnError;
+                }
+            }
+            params.assertLaunchLease(params.run, "after starting the Codex turn");
+            return { threadId, turnId, ...(parentThreadId ? { parentThreadId } : {}) };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            const lostLease = error instanceof Error && error.name === "IssueSessionLeaseLostError";
+            if (!lostLease) {
+                const nextState = params.isRequestedChangesRunType(params.runType) ? "escalated" : "failed";
+                this.db.issueSessions.finishRunWithLease({ projectId: params.project.id, linearIssueId: params.issue.linearIssueId, leaseId: params.leaseId }, params.run.id, {
+                    status: "failed",
+                    failureReason: message,
+                });
+                this.db.issueSessions.upsertIssueWithLease({ projectId: params.project.id, linearIssueId: params.issue.linearIssueId, leaseId: params.leaseId }, {
+                    projectId: params.project.id,
+                    linearIssueId: params.issue.linearIssueId,
+                    activeRunId: null,
+                    factoryState: nextState,
+                });
+            }
+            this.logger.error({ issueKey: params.issue.issueKey, runType: params.runType, error: message }, `Failed to launch ${params.runType} run`);
+            const failedIssue = this.db.getIssue(params.project.id, params.issue.linearIssueId) ?? params.issue;
+            void params.linearSync.emitActivity(failedIssue, buildRunFailureActivity(params.runType, `Failed to start ${params.lowerCaseFirst(message)}`));
+            void params.linearSync.syncSession(failedIssue, { activeRunType: params.runType });
+            params.releaseLease(params.project.id, params.issue.linearIssueId);
+            throw error;
+        }
+    }
+}