patchrelay 0.8.8 → 0.9.0

package/dist/webhook-agent-session-handler.js

@@ -1,228 +0,0 @@
-import { createHash } from "node:crypto";
-import { buildPreparingSessionPlan, buildRunningSessionPlan } from "./agent-session-plan.js";
-import { triggerEventAllowed } from "./project-resolution.js";
-import { listRunnableStates, resolveWorkflowStage } from "./workflow-policy.js";
-function trimPrompt(value) {
-    const trimmed = value?.trim();
-    return trimmed ? trimmed : undefined;
-}
-function buildSessionUpdateParams(projectId, agentSessionId, issueKey, plan) {
-    return {
-        projectId,
-        agentSessionId,
-        ...(issueKey ? { issueKey } : {}),
-        plan,
-    };
-}
-export class AgentSessionWebhookHandler {
-    stores;
-    turnInputDispatcher;
-    agentActivity;
-    feed;
-    constructor(stores, turnInputDispatcher, agentActivity, feed) {
-        this.stores = stores;
-        this.turnInputDispatcher = turnInputDispatcher;
-        this.agentActivity = agentActivity;
-        this.feed = feed;
-    }
-    async handle(params) {
-        const { normalized, project, issue, desiredStage, delegatedToPatchRelay } = params;
-        if (!normalized.agentSession?.id) {
-            return;
-        }
-        const promptBody = trimPrompt(normalized.agentSession.promptBody);
-        const promptContext = trimPrompt(normalized.agentSession.promptContext);
-        const issueControl = normalized.issue ? this.stores.issueControl.getIssueControl(project.id, normalized.issue.id) : undefined;
-        const activeRunLease = issueControl?.activeRunLeaseId !== undefined ? this.stores.runLeases.getRunLease(issueControl.activeRunLeaseId) : undefined;
-        const activeStage = activeRunLease?.stage;
-        const runnableWorkflow = normalized.issue?.stateName
-            ? resolveWorkflowStage(project, normalized.issue.stateName, {
-                ...(issue?.selectedWorkflowId
-                    ? { workflowDefinitionId: issue.selectedWorkflowId }
-                    : normalized.issue
-                        ? { issue: normalized.issue }
-                        : {}),
-            })
-            : undefined;
-        if (normalized.triggerEvent === "agentSessionCreated") {
-            if (!delegatedToPatchRelay) {
-                if (activeStage) {
-                    await this.agentActivity.updateSession(buildSessionUpdateParams(project.id, normalized.agentSession.id, issue?.issueKey ?? normalized.issue?.identifier, buildRunningSessionPlan(activeStage)));
-                    await this.agentActivity.publishForSession(project.id, normalized.agentSession.id, {
-                        type: "thought",
-                        body: `PatchRelay is already running the ${activeStage} workflow for this issue. Delegate it to PatchRelay if you want automation to own the workflow, or keep replying here to steer the active run.`,
-                    });
-                    return;
-                }
-                const body = runnableWorkflow
-                    ? `PatchRelay received your mention. Delegate the issue to PatchRelay to start the ${runnableWorkflow} workflow from the current \`${normalized.issue?.stateName}\` state.`
-                    : `PatchRelay received your mention, but the issue is not in a runnable workflow state yet. Move it to one of: ${listRunnableStates(project).join(", ")}, then delegate it to PatchRelay.`;
-                await this.agentActivity.publishForSession(project.id, normalized.agentSession.id, {
-                    type: "elicitation",
-                    body,
-                });
-                return;
-            }
-            if (!desiredStage && !activeStage) {
-                const runnableStates = listRunnableStates(project).join(", ");
-                await this.agentActivity.publishForSession(project.id, normalized.agentSession.id, {
-                    type: "elicitation",
-                    body: `PatchRelay is delegated, but the issue is not in a runnable workflow state. Move it to one of: ${runnableStates}.`,
-                });
-                return;
-            }
-            if (desiredStage) {
-                await this.agentActivity.updateSession(buildSessionUpdateParams(project.id, normalized.agentSession.id, issue?.issueKey ?? normalized.issue?.identifier, buildPreparingSessionPlan(desiredStage)));
-                await this.agentActivity.publishForSession(project.id, normalized.agentSession.id, {
-                    type: "response",
-                    body: `PatchRelay started working on the ${desiredStage} workflow and is preparing the workspace.`,
-                }, { ephemeral: false });
-                return;
-            }
-            if (activeStage) {
-                await this.agentActivity.updateSession(buildSessionUpdateParams(project.id, normalized.agentSession.id, issue?.issueKey ?? normalized.issue?.identifier, buildRunningSessionPlan(activeStage)));
-                await this.agentActivity.publishForSession(project.id, normalized.agentSession.id, {
-                    type: "response",
-                    body: `PatchRelay is already running the ${activeStage} workflow for this issue.`,
-                });
-            }
-            return;
-        }
-        if (normalized.triggerEvent !== "agentPrompted") {
-            return;
-        }
-        if (!triggerEventAllowed(project, normalized.triggerEvent)) {
-            return;
-        }
-        if (activeRunLease && promptBody) {
-            const dedupeKey = buildPromptDedupeKey(normalized.agentSession.id, promptBody);
-            if (issueControl?.activeRunLeaseId !== undefined &&
-                this.stores.obligations.getObligationByDedupeKey({
-                    runLeaseId: issueControl.activeRunLeaseId,
-                    kind: "deliver_turn_input",
-                    dedupeKey,
-                })) {
-                return;
-            }
-            const promptInput = ["New Linear agent prompt received while you are working.", "", promptBody].join("\n");
-            const source = `linear-agent-prompt:${normalized.agentSession.id}:${normalized.webhookId}`;
-            const obligationId = this.enqueueObligation(project.id, normalized.issue.id, activeRunLease.threadId, activeRunLease.turnId, source, promptInput, dedupeKey);
-            const flushResult = await this.turnInputDispatcher.flush({
-                id: issueControl?.activeRunLeaseId ?? 0,
-                projectId: project.id,
-                linearIssueId: normalized.issue.id,
-                ...(activeRunLease.threadId ? { threadId: activeRunLease.threadId } : {}),
-                ...(activeRunLease.turnId ? { turnId: activeRunLease.turnId } : {}),
-            }, {
-                ...(issue?.issueKey ? { issueKey: issue.issueKey } : {}),
-                failureMessage: "Failed to deliver queued Linear agent prompt to active Codex turn",
-            });
-            this.publishPromptDeliveryEvent({
-                projectId: project.id,
-                issueKey: issue?.issueKey ?? normalized.issue?.identifier,
-                stage: activeRunLease.stage,
-                obligationId,
-                flushResult,
-            });
-            await this.agentActivity.publishForSession(project.id, normalized.agentSession.id, {
-                type: "thought",
-                body: obligationId !== undefined && flushResult.deliveredObligationIds.includes(obligationId)
-                    ? `PatchRelay routed your follow-up instructions into the active ${activeRunLease.stage} workflow.`
-                    : `PatchRelay queued your follow-up instructions for delivery into the active ${activeRunLease.stage} workflow.`,
-            });
-            return;
-        }
-        if (!delegatedToPatchRelay && (promptBody || promptContext)) {
-            const body = runnableWorkflow
-                ? `PatchRelay received your prompt. Delegate the issue to PatchRelay to start the ${runnableWorkflow} workflow from the current \`${normalized.issue?.stateName}\` state.`
-                : `PatchRelay received your prompt, but the issue is not in a runnable workflow state yet. Move it to one of: ${listRunnableStates(project).join(", ")}, then delegate it to PatchRelay.`;
-            await this.agentActivity.publishForSession(project.id, normalized.agentSession.id, {
-                type: "elicitation",
-                body,
-            });
-            return;
-        }
-        if (!activeRunLease && desiredStage) {
-            await this.agentActivity.updateSession(buildSessionUpdateParams(project.id, normalized.agentSession.id, issue?.issueKey ?? normalized.issue?.identifier, buildPreparingSessionPlan(desiredStage)));
-            await this.agentActivity.publishForSession(project.id, normalized.agentSession.id, {
-                type: "response",
-                body: `PatchRelay is preparing the ${desiredStage} workflow from your latest prompt.`,
-            }, { ephemeral: false });
-            return;
-        }
-        if (!activeRunLease && !desiredStage && (promptBody || promptContext)) {
-            const runnableStates = listRunnableStates(project).join(", ");
-            await this.agentActivity.publishForSession(project.id, normalized.agentSession.id, {
-                type: "elicitation",
-                body: `PatchRelay received your prompt, but the issue is not in a runnable workflow state yet. Move it to one of: ${runnableStates}.`,
-            });
-        }
-    }
-    enqueueObligation(projectId, linearIssueId, threadId, turnId, source, promptBody, dedupeKey) {
-        const activeRunLeaseId = this.stores.issueControl.getIssueControl(projectId, linearIssueId)?.activeRunLeaseId;
-        if (activeRunLeaseId === undefined) {
-            return undefined;
-        }
-        const obligation = this.stores.obligations.enqueueObligation({
-            projectId,
-            linearIssueId,
-            kind: "deliver_turn_input",
-            source,
-            payloadJson: JSON.stringify({
-                body: promptBody,
-            }),
-            runLeaseId: activeRunLeaseId,
-            ...(threadId ? { threadId } : {}),
-            ...(turnId ? { turnId } : {}),
-            dedupeKey,
-        });
-        return obligation.id;
-    }
-    publishPromptDeliveryEvent(params) {
-        if (params.obligationId === undefined) {
-            return;
-        }
-        if (params.flushResult.deliveredObligationIds.includes(params.obligationId)) {
-            this.feed?.publish({
-                level: "info",
-                kind: "agent",
-                projectId: params.projectId,
-                issueKey: params.issueKey,
-                stage: params.stage,
-                status: "delivered",
-                summary: `Delivered follow-up prompt to active ${params.stage} workflow`,
-                detail: "The active Linear agent session was routed into the running Codex turn.",
-            });
-            return;
-        }
-        if (params.flushResult.failedObligationIds.includes(params.obligationId)) {
-            this.feed?.publish({
-                level: "warn",
-                kind: "agent",
-                projectId: params.projectId,
-                issueKey: params.issueKey,
-                stage: params.stage,
-                status: "delivery_failed",
-                summary: `Could not deliver follow-up prompt to active ${params.stage} workflow`,
-                detail: "PatchRelay kept the prompt queued and will retry delivery on the next active turn.",
-            });
-            return;
-        }
-        this.feed?.publish({
-            level: "info",
-            kind: "agent",
-            projectId: params.projectId,
-            issueKey: params.issueKey,
-            stage: params.stage,
-            status: "queued",
-            summary: `Queued follow-up prompt for active ${params.stage} workflow`,
-            detail: "PatchRelay saved the prompt for the next delivery opportunity.",
-        });
-    }
-}
-function buildPromptDedupeKey(agentSessionId, promptBody) {
-    return `linear-agent-prompt:${agentSessionId}:${hashBody(promptBody)}`;
-}
-function hashBody(value) {
-    return createHash("sha256").update(value).digest("hex");
-}

package/dist/webhook-comment-handler.js

@@ -1,141 +0,0 @@
-import { createHash } from "node:crypto";
-import { isPatchRelayStatusComment } from "./linear-workflow.js";
-import { triggerEventAllowed } from "./project-resolution.js";
-export class CommentWebhookHandler {
-    stores;
-    turnInputDispatcher;
-    feed;
-    constructor(stores, turnInputDispatcher, feed) {
-        this.stores = stores;
-        this.turnInputDispatcher = turnInputDispatcher;
-        this.feed = feed;
-    }
-    async handle(normalized, project) {
-        if ((normalized.triggerEvent !== "commentCreated" && normalized.triggerEvent !== "commentUpdated") || !normalized.comment?.body) {
-            return;
-        }
-        if (!triggerEventAllowed(project, normalized.triggerEvent)) {
-            return;
-        }
-        const normalizedIssue = normalized.issue;
-        if (!normalizedIssue) {
-            return;
-        }
-        const issue = this.stores.issueWorkflows.getTrackedIssue(project.id, normalizedIssue.id);
-        const issueControl = this.stores.issueControl.getIssueControl(project.id, normalizedIssue.id);
-        if (!issueControl?.activeRunLeaseId) {
-            return;
-        }
-        if (isPatchRelayStatusComment(normalized.comment.id, normalized.comment.body, issueControl.serviceOwnedCommentId ?? issue?.statusCommentId)) {
-            return;
-        }
-        const runLease = this.stores.runLeases.getRunLease(issueControl.activeRunLeaseId);
-        if (!runLease) {
-            return;
-        }
-        const body = [
-            "New Linear comment received while you are working.",
-            normalized.comment.userName ? `Author: ${normalized.comment.userName}` : undefined,
-            "",
-            normalized.comment.body.trim(),
-        ]
-            .filter(Boolean)
-            .join("\n");
-        const dedupeKey = buildCommentDedupeKey(normalized.comment.id, body);
-        if (issueControl.activeRunLeaseId !== undefined &&
-            this.stores.obligations.getObligationByDedupeKey({
-                runLeaseId: issueControl.activeRunLeaseId,
-                kind: "deliver_turn_input",
-                dedupeKey,
-            })) {
-            return;
-        }
-        const obligationId = this.enqueueObligation(project.id, normalizedIssue.id, runLease.threadId, runLease.turnId, normalized.comment.id, body, dedupeKey);
-        const flushResult = await this.turnInputDispatcher.flush({
-            id: issueControl.activeRunLeaseId,
-            projectId: project.id,
-            linearIssueId: normalizedIssue.id,
-            ...(runLease.threadId ? { threadId: runLease.threadId } : {}),
-            ...(runLease.turnId ? { turnId: runLease.turnId } : {}),
-        }, {
-            ...(issue?.issueKey ? { issueKey: issue.issueKey } : {}),
-            failureMessage: "Failed to deliver queued Linear comment to active Codex turn",
-        });
-        this.publishCommentDeliveryEvent({
-            projectId: project.id,
-            issueKey: issue?.issueKey ?? normalizedIssue.identifier,
-            stage: runLease.stage,
-            obligationId,
-            authorName: normalized.comment.userName,
-            flushResult,
-        });
-    }
-    enqueueObligation(projectId, linearIssueId, threadId, turnId, commentId, body, dedupeKey) {
-        const activeRunLeaseId = this.stores.issueControl.getIssueControl(projectId, linearIssueId)?.activeRunLeaseId;
-        if (activeRunLeaseId === undefined) {
-            return undefined;
-        }
-        const obligation = this.stores.obligations.enqueueObligation({
-            projectId,
-            linearIssueId,
-            kind: "deliver_turn_input",
-            source: `linear-comment:${commentId}`,
-            payloadJson: JSON.stringify({
-                body,
-            }),
-            runLeaseId: activeRunLeaseId,
-            ...(threadId ? { threadId } : {}),
-            ...(turnId ? { turnId } : {}),
-            dedupeKey,
-        });
-        return obligation.id;
-    }
-    publishCommentDeliveryEvent(params) {
-        if (params.obligationId === undefined) {
-            return;
-        }
-        const authorDetail = params.authorName ? `Author: ${params.authorName}.` : undefined;
-        if (params.flushResult.deliveredObligationIds.includes(params.obligationId)) {
-            this.feed?.publish({
-                level: "info",
-                kind: "comment",
-                projectId: params.projectId,
-                issueKey: params.issueKey,
-                stage: params.stage,
-                status: "delivered",
-                summary: `Delivered follow-up comment to active ${params.stage} workflow`,
-                detail: authorDetail ?? "The comment was routed into the running Codex turn.",
-            });
-            return;
-        }
-        if (params.flushResult.failedObligationIds.includes(params.obligationId)) {
-            this.feed?.publish({
-                level: "warn",
-                kind: "comment",
-                projectId: params.projectId,
-                issueKey: params.issueKey,
-                stage: params.stage,
-                status: "delivery_failed",
-                summary: `Could not deliver follow-up comment to active ${params.stage} workflow`,
-                detail: authorDetail ?? "PatchRelay kept the comment queued and will retry delivery.",
-            });
-            return;
-        }
-        this.feed?.publish({
-            level: "info",
-            kind: "comment",
-            projectId: params.projectId,
-            issueKey: params.issueKey,
-            stage: params.stage,
-            status: "queued",
-            summary: `Queued follow-up comment for active ${params.stage} workflow`,
-            detail: authorDetail ?? "PatchRelay saved the comment for the next delivery opportunity.",
-        });
-    }
-}
-function buildCommentDedupeKey(commentId, body) {
-    return `linear-comment:${commentId}:${hashBody(body)}`;
-}
-function hashBody(value) {
-    return createHash("sha256").update(value).digest("hex");
-}

package/dist/webhook-desired-stage-recorder.js

@@ -1,122 +0,0 @@
-import { triggerEventAllowed } from "./project-resolution.js";
-import { resolveWorkflowStage, selectWorkflowDefinition } from "./workflow-policy.js";
-function trimPrompt(value) {
-    const trimmed = value?.trim();
-    return trimmed ? trimmed : undefined;
-}
-export class WebhookDesiredStageRecorder {
-    stores;
-    constructor(stores) {
-        this.stores = stores;
-    }
-    record(project, normalized, options) {
-        const normalizedIssue = normalized.issue;
-        if (!normalizedIssue) {
-            return {
-                issue: undefined,
-                activeStageRun: undefined,
-                desiredStage: undefined,
-                delegatedToPatchRelay: false,
-                launchInput: undefined,
-            };
-        }
-        const issue = this.stores.issueWorkflows.getTrackedIssue(project.id, normalizedIssue.id);
-        const issueControl = this.stores.issueControl.getIssueControl(project.id, normalizedIssue.id);
-        const activeStageRun = issueControl?.activeRunLeaseId !== undefined ? this.stores.issueWorkflows.getStageRun(issueControl.activeRunLeaseId) : undefined;
-        const delegatedToPatchRelay = this.isDelegatedToPatchRelay(project, normalized);
-        const stageAllowed = triggerEventAllowed(project, normalized.triggerEvent);
-        const selectedWorkflowId = this.resolveSelectedWorkflowId(project, normalized, issue, activeStageRun, delegatedToPatchRelay);
-        const desiredStage = this.resolveDesiredStage(project, normalized, issue, activeStageRun, delegatedToPatchRelay, selectedWorkflowId);
-        const launchInput = this.resolveLaunchInput(normalized.agentSession);
-        const activeAgentSessionId = normalized.agentSession?.id ??
-            (!activeStageRun && (desiredStage || (normalized.triggerEvent === "delegateChanged" && !delegatedToPatchRelay)) ? null : undefined);
-        const refreshedIssue = this.stores.workflowCoordinator.recordDesiredStage({
-            projectId: project.id,
-            linearIssueId: normalizedIssue.id,
-            ...(normalizedIssue.identifier ? { issueKey: normalizedIssue.identifier } : {}),
-            ...(normalizedIssue.title ? { title: normalizedIssue.title } : {}),
-            ...(normalizedIssue.url ? { issueUrl: normalizedIssue.url } : {}),
-            ...(normalizedIssue.stateName ? { currentLinearState: normalizedIssue.stateName } : {}),
-            ...(selectedWorkflowId !== undefined ? { selectedWorkflowId } : {}),
-            ...(desiredStage ? { desiredStage } : {}),
-            ...(desiredStage && options?.eventReceiptId !== undefined ? { desiredReceiptId: options.eventReceiptId } : {}),
-            ...(activeAgentSessionId !== undefined ? { activeAgentSessionId } : {}),
-            lastWebhookAt: new Date().toISOString(),
-        });
-        if (launchInput && !activeStageRun && delegatedToPatchRelay && stageAllowed) {
-            this.stores.obligations.enqueueObligation({
-                projectId: project.id,
-                linearIssueId: normalizedIssue.id,
-                kind: "deliver_turn_input",
-                source: `linear-agent-launch:${normalized.agentSession?.id ?? normalized.webhookId}`,
-                payloadJson: JSON.stringify({
-                    body: launchInput,
-                }),
-            });
-        }
-        return {
-            issue: refreshedIssue ?? issue,
-            activeStageRun,
-            desiredStage,
-            delegatedToPatchRelay,
-            launchInput,
-        };
-    }
-    isDelegatedToPatchRelay(project, normalized) {
-        const normalizedIssue = normalized.issue;
-        if (!normalizedIssue) {
-            return false;
-        }
-        const installation = this.stores.linearInstallations.getLinearInstallationForProject(project.id);
-        if (!installation?.actorId) {
-            return false;
-        }
-        return normalizedIssue.delegateId === installation.actorId;
-    }
-    resolveDesiredStage(project, normalized, issue, activeStageRun, delegatedToPatchRelay, selectedWorkflowId) {
-        const normalizedIssue = normalized.issue;
-        if (!normalizedIssue) {
-            return undefined;
-        }
-        if (!delegatedToPatchRelay || !triggerEventAllowed(project, normalized.triggerEvent)) {
-            return undefined;
-        }
-        const desiredStage = resolveWorkflowStage(project, normalizedIssue.stateName, {
-            ...(selectedWorkflowId ? { workflowDefinitionId: selectedWorkflowId } : {}),
-        });
-        if (!desiredStage) {
-            return undefined;
-        }
-        if (activeStageRun && desiredStage === activeStageRun.stage) {
-            return undefined;
-        }
-        if (issue?.desiredStage && desiredStage === issue.desiredStage) {
-            return undefined;
-        }
-        return desiredStage;
-    }
-    resolveSelectedWorkflowId(project, normalized, issue, activeStageRun, delegatedToPatchRelay) {
-        if (activeStageRun) {
-            return issue?.selectedWorkflowId;
-        }
-        if (!delegatedToPatchRelay || !triggerEventAllowed(project, normalized.triggerEvent) || !normalized.issue) {
-            return issue?.selectedWorkflowId;
-        }
-        const selectedWorkflow = selectWorkflowDefinition(project, normalized.issue);
-        if (selectedWorkflow) {
-            return selectedWorkflow.id;
-        }
-        return null;
-    }
-    resolveLaunchInput(agentSession) {
-        const promptBody = trimPrompt(agentSession?.promptBody);
-        if (promptBody) {
-            return ["New Linear agent input received.", "", promptBody].join("\n");
-        }
-        const promptContext = trimPrompt(agentSession?.promptContext);
-        if (promptContext) {
-            return ["Linear provided this initial agent context.", "", promptContext].join("\n");
-        }
-        return undefined;
-    }
-}

package/dist/webhook-event-ports.js

@@ -1 +0,0 @@
-export {};

package/dist/workflow-policy.js

@@ -1,149 +0,0 @@
-function normalize(value) {
-    const trimmed = value?.trim();
-    return trimmed ? trimmed.toLowerCase() : undefined;
-}
-function normalizeWorkflowLabel(value) {
-    return normalize(value)?.replace(/[\s_-]+/g, "");
-}
-function extractIssuePrefix(identifier) {
-    const value = identifier?.trim();
-    if (!value) {
-        return undefined;
-    }
-    const [prefix] = value.split("-", 1);
-    return prefix ? prefix.toUpperCase() : undefined;
-}
-function withWorkflowDefinitionId(workflowDefinitionId) {
-    return workflowDefinitionId ? { workflowDefinitionId } : undefined;
-}
-export function listProjectWorkflowDefinitions(project) {
-    if (project.workflowDefinitions && project.workflowDefinitions.length > 0) {
-        return project.workflowDefinitions;
-    }
-    return [
-        {
-            id: project.workflowSelection?.defaultWorkflowId ?? "default",
-            stages: project.workflows,
-        },
-    ];
-}
-export function resolveWorkflowDefinitionById(project, workflowDefinitionId) {
-    const normalized = normalize(workflowDefinitionId);
-    if (!normalized) {
-        return undefined;
-    }
-    return listProjectWorkflowDefinitions(project).find((definition) => normalize(definition.id) === normalized);
-}
-export function selectWorkflowDefinition(project, issue) {
-    const workflowDefinitions = listProjectWorkflowDefinitions(project);
-    if (workflowDefinitions.length === 0) {
-        return undefined;
-    }
-    const labelNames = new Set((issue?.labelNames ?? []).map((label) => label.trim().toLowerCase()).filter(Boolean));
-    const matchedWorkflowIds = new Set();
-    for (const rule of project.workflowSelection?.byLabel ?? []) {
-        if (labelNames.has(rule.label.trim().toLowerCase())) {
-            matchedWorkflowIds.add(rule.workflowId);
-        }
-    }
-    if (matchedWorkflowIds.size === 1) {
-        const [workflowId] = [...matchedWorkflowIds];
-        return resolveWorkflowDefinitionById(project, workflowId);
-    }
-    if (matchedWorkflowIds.size > 1) {
-        return undefined;
-    }
-    if (project.workflowSelection?.defaultWorkflowId) {
-        return resolveWorkflowDefinitionById(project, project.workflowSelection.defaultWorkflowId);
-    }
-    return workflowDefinitions[0];
-}
-function resolveStageList(project, options) {
-    if (options?.workflowDefinitionId) {
-        return resolveWorkflowDefinitionById(project, options.workflowDefinitionId)?.stages ?? [];
-    }
-    if (options?.issue) {
-        return selectWorkflowDefinition(project, options.issue)?.stages ?? [];
-    }
-    return project.workflows;
-}
-export function resolveWorkflow(project, stateName, options) {
-    const normalized = normalize(stateName);
-    if (!normalized) {
-        return undefined;
-    }
-    return resolveStageList(project, options).find((workflow) => normalize(workflow.whenState) === normalized);
-}
-export function resolveWorkflowStage(project, stateName, options) {
-    return resolveWorkflow(project, stateName, options)?.id;
-}
-export function resolveWorkflowStageConfig(project, workflowId, workflowDefinitionId) {
-    const normalized = normalize(workflowId);
-    if (!normalized) {
-        return undefined;
-    }
-    return resolveStageList(project, withWorkflowDefinitionId(workflowDefinitionId)).find((workflow) => normalize(workflow.id) === normalized);
-}
-export function listRunnableStates(project, options) {
-    return [...new Set(resolveStageList(project, options).map((workflow) => workflow.whenState))];
-}
-export function listWorkflowStageIds(project, workflowDefinitionId) {
-    return resolveStageList(project, withWorkflowDefinitionId(workflowDefinitionId)).map((workflow) => workflow.id);
-}
-export function resolveWorkflowIndex(project, workflowId, workflowDefinitionId) {
-    if (!workflowId) {
-        return -1;
-    }
-    return resolveStageList(project, withWorkflowDefinitionId(workflowDefinitionId)).findIndex((workflow) => workflow.id === workflowId);
-}
-export function resolveDefaultTransitionTarget(project, currentStage, workflowDefinitionId) {
-    const stages = resolveStageList(project, withWorkflowDefinitionId(workflowDefinitionId));
-    const currentIndex = resolveWorkflowIndex(project, currentStage, workflowDefinitionId);
-    if (currentIndex < 0) {
-        return undefined;
-    }
-    const nextStage = stages[currentIndex + 1]?.id;
-    return nextStage ?? "done";
-}
-export function listAllowedTransitionTargets(project, currentStage, workflowDefinitionId) {
-    const stages = resolveStageList(project, withWorkflowDefinitionId(workflowDefinitionId));
-    const currentIndex = resolveWorkflowIndex(project, currentStage, workflowDefinitionId);
-    if (currentIndex < 0) {
-        return ["human_needed"];
-    }
-    const targets = new Set(["human_needed"]);
-    const defaultTarget = resolveDefaultTransitionTarget(project, currentStage, workflowDefinitionId);
-    if (defaultTarget) {
-        targets.add(defaultTarget);
-    }
-    if (currentIndex > 0) {
-        targets.add(stages[currentIndex - 1].id);
-    }
-    if (currentIndex > 1) {
-        targets.add(stages[0].id);
-    }
-    return [...targets];
-}
-export function transitionTargetAllowed(project, currentStage, nextTarget, workflowDefinitionId) {
-    return listAllowedTransitionTargets(project, currentStage, workflowDefinitionId).includes(nextTarget);
-}
-export function resolveWorkflowStageCandidate(project, value, workflowDefinitionId) {
-    const normalized = normalizeWorkflowLabel(value);
-    if (!normalized) {
-        return undefined;
-    }
-    return resolveStageList(project, withWorkflowDefinitionId(workflowDefinitionId)).find((workflow) => {
-        const candidates = [workflow.id, workflow.whenState, workflow.activeState];
-        return candidates.some((candidate) => normalizeWorkflowLabel(candidate) === normalized);
-    })?.id;
-}
-export function matchesProject(issue, project) {
-    const issuePrefix = extractIssuePrefix(issue.identifier);
-    const teamCandidates = [issue.teamId, issue.teamKey].filter((value) => Boolean(value));
-    const labelNames = new Set(issue.labelNames.map((label) => label.toLowerCase()));
-    const matchesPrefix = project.issueKeyPrefixes.length === 0 ||
-        (issuePrefix ? project.issueKeyPrefixes.map((value) => value.toUpperCase()).includes(issuePrefix) : false);
-    const matchesTeam = project.linearTeamIds.length === 0 || teamCandidates.some((candidate) => project.linearTeamIds.includes(candidate));
-    const matchesLabel = project.allowLabels.length === 0 || project.allowLabels.some((label) => labelNames.has(label.toLowerCase()));
-    return matchesPrefix && matchesTeam && matchesLabel;
-}

package/dist/workflow-ports.js

@@ -1 +0,0 @@
-export {};