patchrelay 0.36.11 → 0.36.13

package/dist/webhooks/context-loader.js

@@ -0,0 +1,70 @@
+import { resolveProject } from "../project-resolution.js";
+import { hasCompleteIssueContext, mergeIssueMetadata, } from "./decision-helpers.js";
+export class WebhookContextLoader {
+    config;
+    linearProvider;
+    constructor(config, linearProvider) {
+        this.config = config;
+        this.linearProvider = linearProvider;
+    }
+    async load(normalized) {
+        if (!normalized.issue) {
+            return undefined;
+        }
+        let project = resolveProject(this.config, normalized.issue);
+        let hydrated = normalized;
+        if (!project) {
+            const routed = await this.tryHydrateProjectRoute(normalized);
+            if (!routed) {
+                return undefined;
+            }
+            hydrated = routed.normalized;
+            project = routed.project;
+        }
+        return {
+            project,
+            normalized: await this.hydrateIssueContext(project.id, hydrated),
+        };
+    }
+    async hydrateIssueContext(projectId, normalized) {
+        if (!normalized.issue)
+            return normalized;
+        if (normalized.triggerEvent !== "agentSessionCreated" && normalized.triggerEvent !== "agentPrompted" && normalized.entityType !== "Issue") {
+            return normalized;
+        }
+        if (normalized.entityType !== "Issue" && hasCompleteIssueContext(normalized.issue))
+            return normalized;
+        const linear = await this.linearProvider.forProject(projectId);
+        if (!linear)
+            return normalized;
+        try {
+            const liveIssue = await linear.getIssue(normalized.issue.id);
+            return { ...normalized, issue: mergeIssueMetadata(normalized.issue, liveIssue) };
+        }
+        catch {
+            return normalized;
+        }
+    }
+    async tryHydrateProjectRoute(normalized) {
+        if (!normalized.issue)
+            return undefined;
+        if (normalized.triggerEvent !== "agentSessionCreated" && normalized.triggerEvent !== "agentPrompted")
+            return undefined;
+        for (const candidate of this.config.projects) {
+            const linear = await this.linearProvider.forProject(candidate.id);
+            if (!linear)
+                continue;
+            try {
+                const liveIssue = await linear.getIssue(normalized.issue.id);
+                const hydrated = { ...normalized, issue: mergeIssueMetadata(normalized.issue, liveIssue) };
+                const resolved = resolveProject(this.config, hydrated.issue);
+                if (resolved)
+                    return { project: resolved, normalized: hydrated };
+            }
+            catch {
+                // Continue scanning candidate projects until one can resolve the issue route.
+            }
+        }
+        return undefined;
+    }
+}

package/dist/webhooks/dependency-readiness-handler.js

@@ -0,0 +1,52 @@
+export class DependencyReadinessHandler {
+    db;
+    peekPendingSessionWakeRunType;
+    constructor(db, peekPendingSessionWakeRunType) {
+        this.db = db;
+        this.peekPendingSessionWakeRunType = peekPendingSessionWakeRunType;
+    }
+    reconcile(projectId, blockerLinearIssueId) {
+        const newlyReady = [];
+        for (const dependent of this.db.issues.listDependents(projectId, blockerLinearIssueId)) {
+            const issue = this.db.issues.getIssue(projectId, dependent.linearIssueId);
+            if (!issue) {
+                continue;
+            }
+            const unresolved = this.db.issues.countUnresolvedBlockers(projectId, dependent.linearIssueId);
+            if (unresolved > 0) {
+                if (this.peekPendingSessionWakeRunType(projectId, dependent.linearIssueId) === "implementation"
+                    && issue.activeRunId === undefined
+                    && !this.db.issueSessions.hasPendingIssueSessionEvents(projectId, dependent.linearIssueId)) {
+                    this.db.issues.upsertIssue({
+                        projectId,
+                        linearIssueId: dependent.linearIssueId,
+                        pendingRunType: null,
+                        pendingRunContextJson: null,
+                    });
+                }
+                continue;
+            }
+            if (issue.factoryState !== "delegated"
+                || issue.activeRunId !== undefined
+                || this.db.issueSessions.hasPendingIssueSessionEvents(projectId, dependent.linearIssueId)) {
+                continue;
+            }
+            if (this.peekPendingSessionWakeRunType(projectId, dependent.linearIssueId) === "implementation") {
+                this.db.issues.upsertIssue({
+                    projectId,
+                    linearIssueId: dependent.linearIssueId,
+                    pendingRunType: null,
+                    pendingRunContextJson: null,
+                });
+            }
+            this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(projectId, dependent.linearIssueId, {
+                projectId,
+                linearIssueId: dependent.linearIssueId,
+                eventType: "delegated",
+                dedupeKey: `delegated:${dependent.linearIssueId}`,
+            });
+            newlyReady.push(dependent.linearIssueId);
+        }
+        return newlyReady;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "patchrelay",
-  "version": "0.36.11",
+  "version": "0.36.13",
   "license": "MIT",
   "type": "module",
   "repository": {