patchrelay 0.8.9 → 0.9.1

package/dist/stage-launch.js

@@ -1,84 +0,0 @@
-import { existsSync, readFileSync } from "node:fs";
-import path from "node:path";
-import { buildCarryForwardPrompt } from "./stage-handoff.js";
-import { listWorkflowStageIds, resolveWorkflowStageConfig } from "./workflow-policy.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, "-");
-}
-export function isCodexThreadId(value) {
-    if (!value) {
-        return false;
-    }
-    return !value.startsWith("missing-thread-") && !value.startsWith("launch-failed-");
-}
-export function buildStageLaunchPlan(project, issue, stage, options) {
-    const workflow = resolveWorkflowStageConfig(project, stage, issue.selectedWorkflowId);
-    if (!workflow) {
-        throw new Error(`Workflow "${stage}" is not configured for project ${project.id}`);
-    }
-    const issueRef = sanitizePathSegment(issue.issueKey ?? issue.linearIssueId);
-    const slug = issue.title ? slugify(issue.title) : "";
-    const branchSuffix = slug ? `${issueRef}-${slug}` : issueRef;
-    return {
-        branchName: options?.branchName ?? `${project.branchPrefix}/${branchSuffix}`,
-        worktreePath: options?.worktreePath ?? path.join(project.worktreeRoot, issueRef),
-        workflowFile: workflow.workflowFile,
-        stage,
-        prompt: buildStagePrompt(project, issue, workflow.id, workflow.whenState, workflow.workflowFile, {
-            branchName: options?.branchName ?? `${project.branchPrefix}/${branchSuffix}`,
-            worktreePath: options?.worktreePath ?? path.join(project.worktreeRoot, issueRef),
-            ...(issue.selectedWorkflowId ? { workflowDefinitionId: issue.selectedWorkflowId } : {}),
-            ...(options?.previousStageRun ? { previousStageRun: options.previousStageRun } : {}),
-            ...(options?.workspace ? { workspace: options.workspace } : {}),
-            stageHistory: options?.stageHistory ?? [],
-        }),
-    };
-}
-export function buildStagePrompt(project, issue, stage, triggerState, workflowFile, options) {
-    const workflowBody = existsSync(workflowFile) ? readFileSync(workflowFile, "utf8").trim() : "";
-    const carryForward = buildCarryForwardPrompt({
-        project,
-        currentStage: stage,
-        ...(options?.workflowDefinitionId ? { workflowDefinitionId: options.workflowDefinitionId } : {}),
-        ...(options?.previousStageRun ? { previousStageRun: options.previousStageRun } : {}),
-        ...(options?.workspace ? { workspace: options.workspace } : {}),
-        stageHistory: options?.stageHistory ?? [],
-    });
-    const availableStages = listWorkflowStageIds(project, options?.workflowDefinitionId).join(", ");
-    return [
-        `Issue: ${issue.issueKey ?? issue.linearIssueId}`,
-        issue.title ? `Title: ${issue.title}` : undefined,
-        issue.issueUrl ? `Linear URL: ${issue.issueUrl}` : undefined,
-        issue.currentLinearState ? `Current Linear State: ${issue.currentLinearState}` : undefined,
-        `Workflow: ${stage}`,
-        `Triggered By State: ${triggerState}`,
-        options?.branchName ? `Branch: ${options.branchName}` : undefined,
-        options?.worktreePath ? `Worktree: ${options.worktreePath}` : undefined,
-        "",
-        "Complete only the current workflow stage. Do not invent a new workflow or skip directly to another stage.",
-        "If the correct next step is unclear, say so plainly and use `human_needed` as the next likely stage.",
-        "",
-        carryForward ? "Carry-forward Context:" : undefined,
-        carryForward,
-        "",
-        "Operate only inside the prepared worktree for this issue. Continue the issue lifecycle in this workspace.",
-        "Use the repo workflow instructions below for this stage.",
-        "End with a short `Stage result:` section in plain text with exactly four bullets:",
-        "- what happened",
-        "- key facts or artifacts",
-        `- Next likely stage: one of ${availableStages}, done, or human_needed`,
-        "- what the next stage or human should pay attention to",
-        "",
-        `Workflow File: ${path.basename(workflowFile)}`,
-        workflowBody,
-    ]
-        .filter(Boolean)
-        .join("\n");
-}

package/dist/stage-lifecycle-publisher.js

@@ -1,284 +0,0 @@
-import { buildAwaitingHandoffSessionPlan, buildCompletedSessionPlan, buildPreparingSessionPlan, buildRunningSessionPlan, } from "./agent-session-plan.js";
-import { buildAgentSessionExternalUrls } from "./agent-session-presentation.js";
-import { buildAwaitingHandoffComment, buildHumanNeededComment, buildRunningStatusComment, resolveActiveLinearState, resolveWorkflowLabelCleanup, resolveWorkflowLabelNames, } from "./linear-workflow.js";
-import { sanitizeDiagnosticText } from "./utils.js";
-export class StageLifecyclePublisher {
-    config;
-    stores;
-    linearProvider;
-    logger;
-    feed;
-    constructor(config, stores, linearProvider, logger, feed) {
-        this.config = config;
-        this.stores = stores;
-        this.linearProvider = linearProvider;
-        this.logger = logger;
-        this.feed = feed;
-    }
-    async markStageActive(project, issue, stageRun) {
-        const activeState = resolveActiveLinearState(project, stageRun.stage, issue.selectedWorkflowId);
-        const linear = await this.linearProvider.forProject(stageRun.projectId);
-        if (!activeState || !linear) {
-            return;
-        }
-        await linear.setIssueState(stageRun.linearIssueId, activeState);
-        const labels = resolveWorkflowLabelNames(project, "working");
-        if (labels.add.length > 0 || labels.remove.length > 0) {
-            await linear.updateIssueLabels({
-                issueId: stageRun.linearIssueId,
-                ...(labels.add.length > 0 ? { addNames: labels.add } : {}),
-                ...(labels.remove.length > 0 ? { removeNames: labels.remove } : {}),
-            });
-        }
-        this.stores.workflowCoordinator.upsertTrackedIssue({
-            projectId: stageRun.projectId,
-            linearIssueId: stageRun.linearIssueId,
-            currentLinearState: activeState,
-            statusCommentId: issue.statusCommentId ?? null,
-            activeAgentSessionId: issue.activeAgentSessionId ?? null,
-            lifecycleStatus: "running",
-        });
-    }
-    async refreshRunningStatusComment(projectId, issueId, stageRunId, issueKey) {
-        const linear = await this.linearProvider.forProject(projectId);
-        if (!linear) {
-            return;
-        }
-        const issue = this.stores.issueWorkflows.getTrackedIssue(projectId, issueId);
-        const stageRun = this.stores.issueWorkflows.getStageRun(stageRunId);
-        const workspace = stageRun ? this.stores.issueWorkflows.getWorkspace(stageRun.workspaceId) : undefined;
-        if (!issue || !stageRun || !workspace) {
-            return;
-        }
-        try {
-            const result = await linear.upsertIssueComment({
-                issueId,
-                ...(issue.statusCommentId ? { commentId: issue.statusCommentId } : {}),
-                body: buildRunningStatusComment({
-                    issue,
-                    stageRun,
-                    branchName: workspace.branchName,
-                }),
-            });
-            this.stores.workflowCoordinator.setIssueStatusComment(projectId, issueId, result.id);
-        }
-        catch (error) {
-            this.logger.warn({
-                issueKey,
-                stageRunId,
-                issueId,
-                error: error instanceof Error ? error.message : String(error),
-            }, "Failed to refresh running status comment after stage startup");
-        }
-    }
-    async publishStageStarted(issue, stage) {
-        if (!issue.activeAgentSessionId) {
-            return false;
-        }
-        const linear = await this.linearProvider.forProject(issue.projectId);
-        if (!linear) {
-            return false;
-        }
-        const sessionUpdated = await this.updateAgentSession(linear, issue, buildRunningSessionPlan(stage), stage);
-        try {
-            await linear.createAgentActivity({
-                agentSessionId: issue.activeAgentSessionId,
-                content: {
-                    type: "response",
-                    body: `PatchRelay started the ${stage} workflow and is working in the background.`,
-                },
-            });
-            return true;
-        }
-        catch (error) {
-            this.logger.warn({
-                issueKey: issue.issueKey,
-                stage,
-                agentSessionId: issue.activeAgentSessionId,
-                error: error instanceof Error ? error.message : String(error),
-            }, "Failed to publish Linear agent activity after stage startup");
-            return sessionUpdated;
-        }
-    }
-    async publishStageCompletion(stageRun, enqueueIssue) {
-        const refreshedIssue = this.stores.issueWorkflows.getTrackedIssue(stageRun.projectId, stageRun.linearIssueId);
-        if (refreshedIssue?.desiredStage) {
-            const linear = await this.linearProvider.forProject(stageRun.projectId);
-            if (refreshedIssue.activeAgentSessionId && linear) {
-                await this.updateAgentSession(linear, refreshedIssue, buildPreparingSessionPlan(refreshedIssue.desiredStage), refreshedIssue.desiredStage);
-            }
-            this.feed?.publish({
-                level: "info",
-                kind: "stage",
-                issueKey: refreshedIssue.issueKey,
-                projectId: refreshedIssue.projectId,
-                stage: stageRun.stage,
-                ...(refreshedIssue.selectedWorkflowId ? { workflowId: refreshedIssue.selectedWorkflowId } : {}),
-                nextStage: refreshedIssue.desiredStage,
-                status: "queued",
-                summary: `Completed ${stageRun.stage} workflow and queued ${refreshedIssue.desiredStage}`,
-            });
-            await this.publishAgentCompletion(refreshedIssue, {
-                type: "thought",
-                body: `The ${stageRun.stage} workflow finished. PatchRelay is preparing the ${refreshedIssue.desiredStage} workflow next.`,
-            });
-            enqueueIssue(stageRun.projectId, stageRun.linearIssueId);
-            return;
-        }
-        const project = this.config.projects.find((candidate) => candidate.id === stageRun.projectId);
-        const activeState = project ? resolveActiveLinearState(project, stageRun.stage, refreshedIssue?.selectedWorkflowId) : undefined;
-        const linear = project ? await this.linearProvider.forProject(stageRun.projectId) : undefined;
-        if (refreshedIssue && linear && project && activeState) {
-            try {
-                const linearIssue = await linear.getIssue(stageRun.linearIssueId);
-                if (linearIssue.stateName?.trim().toLowerCase() === activeState.trim().toLowerCase()) {
-                    const labels = resolveWorkflowLabelNames(project, "awaitingHandoff");
-                    if (labels.add.length > 0 || labels.remove.length > 0) {
-                        await linear.updateIssueLabels({
-                            issueId: stageRun.linearIssueId,
-                            ...(labels.add.length > 0 ? { addNames: labels.add } : {}),
-                            ...(labels.remove.length > 0 ? { removeNames: labels.remove } : {}),
-                        });
-                    }
-                    this.stores.workflowCoordinator.setIssueLifecycleStatus(stageRun.projectId, stageRun.linearIssueId, "paused");
-                    const finalStageRun = this.stores.issueWorkflows.getStageRun(stageRun.id) ?? stageRun;
-                    let deliveredToSession = false;
-                    if (refreshedIssue.activeAgentSessionId) {
-                        deliveredToSession = await this.updateAgentSession(linear, refreshedIssue, buildAwaitingHandoffSessionPlan(stageRun.stage));
-                    }
-                    this.feed?.publish({
-                        level: "info",
-                        kind: "stage",
-                        issueKey: refreshedIssue.issueKey,
-                        projectId: refreshedIssue.projectId,
-                        stage: stageRun.stage,
-                        ...(refreshedIssue.selectedWorkflowId ? { workflowId: refreshedIssue.selectedWorkflowId } : {}),
-                        status: "handoff",
-                        summary: `Completed ${stageRun.stage} workflow`,
-                        detail: `Waiting for a Linear state change or follow-up input while the issue remains in ${activeState}.`,
-                    });
-                    deliveredToSession =
-                        (await this.publishAgentCompletion(refreshedIssue, {
-                            type: "elicitation",
-                            body: `PatchRelay finished the ${stageRun.stage} workflow. Move the issue to its next workflow state or leave a follow-up prompt to continue.`,
-                        })) || deliveredToSession;
-                    if (!deliveredToSession && !refreshedIssue.activeAgentSessionId) {
-                        const result = await linear.upsertIssueComment({
-                            issueId: stageRun.linearIssueId,
-                            ...(refreshedIssue.statusCommentId ? { commentId: refreshedIssue.statusCommentId } : {}),
-                            body: buildAwaitingHandoffComment({
-                                issue: refreshedIssue,
-                                stageRun: finalStageRun,
-                                activeState,
-                            }),
-                        });
-                        this.stores.workflowCoordinator.setIssueStatusComment(stageRun.projectId, stageRun.linearIssueId, result.id);
-                    }
-                    return;
-                }
-                const cleanup = resolveWorkflowLabelCleanup(project);
-                if (cleanup.remove.length > 0) {
-                    await linear.updateIssueLabels({
-                        issueId: stageRun.linearIssueId,
-                        removeNames: cleanup.remove,
-                    });
-                }
-            }
-            catch (error) {
-                this.logger.warn({
-                    issueKey: refreshedIssue.issueKey,
-                    issueId: stageRun.linearIssueId,
-                    stageRunId: stageRun.id,
-                    stage: stageRun.stage,
-                    error: sanitizeDiagnosticText(error instanceof Error ? error.message : String(error)),
-                }, "Stage completed locally but PatchRelay could not finish the final Linear sync");
-            }
-        }
-        if (refreshedIssue) {
-            let deliveredToSession = false;
-            if (refreshedIssue.activeAgentSessionId && linear) {
-                deliveredToSession = await this.updateAgentSession(linear, refreshedIssue, refreshedIssue.lifecycleStatus === "paused"
-                    ? buildAwaitingHandoffSessionPlan(stageRun.stage)
-                    : buildCompletedSessionPlan(stageRun.stage));
-            }
-            this.feed?.publish({
-                level: "info",
-                kind: "stage",
-                issueKey: refreshedIssue.issueKey,
-                projectId: refreshedIssue.projectId,
-                stage: stageRun.stage,
-                ...(refreshedIssue.selectedWorkflowId ? { workflowId: refreshedIssue.selectedWorkflowId } : {}),
-                status: "completed",
-                summary: `Completed ${stageRun.stage} workflow`,
-            });
-            deliveredToSession =
-                (await this.publishAgentCompletion(refreshedIssue, {
-                    type: refreshedIssue.lifecycleStatus === "paused" ? "elicitation" : "response",
-                    body: refreshedIssue.lifecycleStatus === "paused"
-                        ? `PatchRelay finished the ${stageRun.stage} workflow and now needs human input before it can continue.`
-                        : `PatchRelay finished the ${stageRun.stage} workflow.`,
-                })) || deliveredToSession;
-            if (refreshedIssue.lifecycleStatus === "paused" && linear && !deliveredToSession) {
-                const result = await linear.upsertIssueComment({
-                    issueId: stageRun.linearIssueId,
-                    ...(refreshedIssue.statusCommentId ? { commentId: refreshedIssue.statusCommentId } : {}),
-                    body: buildHumanNeededComment({
-                        issue: refreshedIssue,
-                        stageRun: this.stores.issueWorkflows.getStageRun(stageRun.id) ?? stageRun,
-                    }),
-                });
-                this.stores.workflowCoordinator.setIssueStatusComment(stageRun.projectId, stageRun.linearIssueId, result.id);
-            }
-        }
-    }
-    async updateAgentSession(linear, issue, plan, stage) {
-        if (!issue.activeAgentSessionId) {
-            return false;
-        }
-        try {
-            const externalUrls = buildAgentSessionExternalUrls(this.config, issue.issueKey);
-            await linear.updateAgentSession?.({
-                agentSessionId: issue.activeAgentSessionId,
-                ...(externalUrls ? { externalUrls } : {}),
-                plan,
-            });
-            return true;
-        }
-        catch (error) {
-            this.logger.warn({
-                issueKey: issue.issueKey,
-                issueId: issue.linearIssueId,
-                ...(stage ? { stage } : {}),
-                agentSessionId: issue.activeAgentSessionId,
-                error: sanitizeDiagnosticText(error instanceof Error ? error.message : String(error)),
-            }, "Failed to update Linear agent session");
-            return false;
-        }
-    }
-    async publishAgentCompletion(issue, content) {
-        if (!issue.activeAgentSessionId) {
-            return false;
-        }
-        const linear = await this.linearProvider.forProject(issue.projectId);
-        if (!linear) {
-            return false;
-        }
-        try {
-            await linear.createAgentActivity({
-                agentSessionId: issue.activeAgentSessionId,
-                content,
-            });
-            return true;
-        }
-        catch (error) {
-            this.logger.warn({
-                issueKey: issue.issueKey,
-                issueId: issue.linearIssueId,
-                agentSessionId: issue.activeAgentSessionId,
-                activityType: content.type,
-                error: sanitizeDiagnosticText(error instanceof Error ? error.message : String(error)),
-            }, "Failed to publish Linear agent activity");
-            return false;
-        }
-    }
-}

package/dist/stage-turn-input-dispatcher.js

@@ -1,104 +0,0 @@
-import { sanitizeDiagnosticText } from "./utils.js";
-import { safeJsonParse } from "./utils.js";
-export class StageTurnInputDispatcher {
-    inputs;
-    codex;
-    logger;
-    constructor(inputs, codex, logger) {
-        this.inputs = inputs;
-        this.codex = codex;
-        this.logger = logger;
-    }
-    routePendingInputs(stageRun, threadId, turnId) {
-        const issueControl = this.inputs.issueControl.getIssueControl(stageRun.projectId, stageRun.linearIssueId);
-        if (!issueControl?.activeRunLeaseId) {
-            return;
-        }
-        for (const obligation of this.listPendingInputObligations(stageRun.projectId, stageRun.linearIssueId, issueControl.activeRunLeaseId)) {
-            this.inputs.obligations.updateObligationRouting(obligation.id, {
-                runLeaseId: issueControl.activeRunLeaseId,
-                threadId,
-                turnId,
-            });
-        }
-    }
-    async flush(stageRun, options) {
-        if (!stageRun.threadId || !stageRun.turnId) {
-            return { deliveredInputIds: [], deliveredObligationIds: [], deliveredCount: 0, failedObligationIds: [] };
-        }
-        const issueControl = this.inputs.issueControl.getIssueControl(stageRun.projectId, stageRun.linearIssueId);
-        if (!issueControl?.activeRunLeaseId) {
-            return { deliveredInputIds: [], deliveredObligationIds: [], deliveredCount: 0, failedObligationIds: [] };
-        }
-        const deliveredInputIds = [];
-        const deliveredObligationIds = [];
-        const failedObligationIds = [];
-        let deliveredCount = 0;
-        const obligationQuery = options?.retryInProgress ? { includeInProgress: true } : undefined;
-        for (const obligation of this.listPendingInputObligations(stageRun.projectId, stageRun.linearIssueId, issueControl.activeRunLeaseId, obligationQuery)) {
-            const payload = safeJsonParse(obligation.payloadJson);
-            const body = payload?.body?.trim();
-            if (!body) {
-                this.inputs.obligations.markObligationStatus(obligation.id, "failed", "obligation payload had no deliverable body");
-                continue;
-            }
-            const claimed = obligation.status === "in_progress" && options?.retryInProgress
-                ? true
-                : this.inputs.obligations.claimPendingObligation(obligation.id, {
-                    runLeaseId: issueControl.activeRunLeaseId,
-                    threadId: stageRun.threadId,
-                    turnId: stageRun.turnId,
-                });
-            if (!claimed) {
-                continue;
-            }
-            try {
-                if (obligation.status === "in_progress") {
-                    this.inputs.obligations.updateObligationRouting(obligation.id, {
-                        runLeaseId: issueControl.activeRunLeaseId,
-                        threadId: stageRun.threadId,
-                        turnId: stageRun.turnId,
-                    });
-                }
-                await this.codex.steerTurn({
-                    threadId: stageRun.threadId,
-                    turnId: stageRun.turnId,
-                    input: body,
-                });
-                deliveredObligationIds.push(obligation.id);
-                this.inputs.obligations.markObligationStatus(obligation.id, "completed");
-                deliveredCount += 1;
-                this.logger.debug({
-                    threadId: stageRun.threadId,
-                    turnId: stageRun.turnId,
-                    obligationId: obligation.id,
-                    source: obligation.source,
-                }, "Delivered queued turn input to Codex");
-            }
-            catch (error) {
-                this.inputs.obligations.markObligationStatus(obligation.id, "pending", error instanceof Error ? error.message : String(error));
-                failedObligationIds.push(obligation.id);
-                this.logger.warn({
-                    issueKey: options?.issueKey,
-                    threadId: stageRun.threadId,
-                    turnId: stageRun.turnId,
-                    obligationId: obligation.id,
-                    source: obligation.source,
-                    error: sanitizeDiagnosticText(error instanceof Error ? error.message : String(error)),
-                }, options?.failureMessage ?? "Failed to deliver queued turn input");
-                break;
-            }
-        }
-        return { deliveredInputIds, deliveredObligationIds, deliveredCount, failedObligationIds };
-    }
-    listPendingInputObligations(projectId, linearIssueId, activeRunLeaseId, options) {
-        const query = options?.includeInProgress
-            ? { kind: "deliver_turn_input", includeInProgress: true }
-            : { kind: "deliver_turn_input" };
-        return this.inputs.obligations
-            .listPendingObligations(query)
-            .filter((obligation) => obligation.projectId === projectId &&
-            obligation.linearIssueId === linearIssueId &&
-            (obligation.runLeaseId === undefined || obligation.runLeaseId === activeRunLeaseId));
-    }
-}