@atolis-hq/wake 0.3.33 → 0.3.35

package/dist/src/bootstrap/composition-root.js

@@ -37,7 +37,10 @@ export async function createCompositionRoot(wakeRoot, options = {}) {
     const resources = createResourceService(journal, lookup);
     const pullRequests = createPullRequestService(journal, work, resources);
     const activities = options.activities ??
-        createBuiltInActivityRegistry(journal, pullRequests, resources, wakeRoot, createGitHubAgentContextReader(journal, resources));
+        createBuiltInActivityRegistry(journal, pullRequests, resources, wakeRoot, createGitHubAgentContextReader(journal, resources, {
+            publicUiUrl: config.surfaces.web.publicUrl,
+            githubAdapters: githubAdapters(config),
+        }));
     const definitions = Object.fromEntries(Object.entries(config.orchestration.workflows).map(([name, definition]) => [
         name,
         compileWorkflow(name, definition, activities, Object.keys(config.orchestration.workflows)),
@@ -156,3 +159,6 @@ export async function createCompositionRoot(wakeRoot, options = {}) {
         ...runtime,
     };
 }
+function githubAdapters(config) {
+    return Object.entries(config.integrations).flatMap(([adapter, integration]) => integration.enabled && (integration.provider ?? adapter) === 'github' ? [adapter] : []);
+}

package/dist/src/bootstrap/version.js

@@ -108,4 +108,4 @@ export function resolveWakeVersion(options = {}) {
         return `g${headHash.slice(0, 7)}`;
     return '0.1.0-dev';
 }
-export const wakeVersion = "g0a8e435";
+export const wakeVersion = "g4327396";

package/dist/src/integrations/delivery/application/delivery-outcome-reactor.js

@@ -16,48 +16,42 @@ export class DeliveryOutcomeReactor {
     async runOnce() {
         const consumer = 'reactor:delivery-outcomes';
         const events = await this.journal.readAll(await this.checkpoints.load(consumer));
+        const resolvedDeliveryEventIds = new Set();
         for (const event of events) {
-            const delivery = selectDeliveryEvent(event);
-            if (delivery !== null) {
-                const command = {
-                    workflowInstanceId: workflowInstanceId(delivery.payload.workflowInstanceId),
-                    activationId: activationId(delivery.payload.activationId),
-                };
-                if (await this.isAwaitingThisDelivery(command, delivery.payload.intentEventId)) {
-                    if (delivery.eventType === DeliveryEventType.Confirmed ||
-                        (delivery.eventType === DeliveryEventType.Reconciled &&
-                            delivery.payload.result === DeliveryResultKind.Confirmed))
-                        await this.orchestration.acceptOutcome({
-                            ...command,
-                            outcome: {
-                                kind: ActivityOutcomeKind.Done,
-                                data: { deliveryEventId: delivery.eventId },
-                            },
-                        }, {
-                            commandId: delivery.eventId,
-                            correlationId: event.correlationId,
-                            actor: { kind: EventActorKind.System, id: 'delivery-outcome-reactor' },
-                            occurredAt: event.recordedAt,
-                        });
-                    if (delivery.eventType === DeliveryEventType.Failed)
-                        await this.orchestration.acceptOutcome({
-                            ...command,
-                            outcome: {
-                                kind: ActivityOutcomeKind.Failed,
-                                data: { reason: delivery.payload.code },
-                            },
-                        }, {
-                            commandId: delivery.eventId,
-                            correlationId: event.correlationId,
-                            actor: { kind: EventActorKind.System, id: 'delivery-outcome-reactor' },
-                            occurredAt: event.recordedAt,
-                        });
-                }
-            }
+            await this.reconcile(event, resolvedDeliveryEventIds);
             await this.checkpoints.save(consumer, event.globalPosition);
         }
+        for (const event of await this.journal.readAll(0))
+            await this.reconcile(event, resolvedDeliveryEventIds);
         return events.length;
     }
+    async reconcile(event, seen) {
+        const delivery = selectDeliveryEvent(event);
+        if (delivery === null || seen.has(delivery.eventId))
+            return;
+        const outcome = delivery.eventType === DeliveryEventType.Confirmed ||
+            (delivery.eventType === DeliveryEventType.Reconciled &&
+                delivery.payload.result === DeliveryResultKind.Confirmed)
+            ? { kind: ActivityOutcomeKind.Done, data: { deliveryEventId: delivery.eventId } }
+            : delivery.eventType === DeliveryEventType.Failed
+                ? { kind: ActivityOutcomeKind.Failed, data: { reason: delivery.payload.code } }
+                : null;
+        if (outcome === null)
+            return;
+        const command = {
+            workflowInstanceId: workflowInstanceId(delivery.payload.workflowInstanceId),
+            activationId: activationId(delivery.payload.activationId),
+        };
+        if (!(await this.isAwaitingThisDelivery(command, delivery.payload.intentEventId)))
+            return;
+        seen.add(delivery.eventId);
+        await this.orchestration.acceptOutcome({ ...command, outcome }, {
+            commandId: delivery.eventId,
+            correlationId: event.correlationId,
+            actor: { kind: EventActorKind.System, id: 'delivery-outcome-reactor' },
+            occurredAt: event.recordedAt,
+        });
+    }
     /**
      * A delivery's own completion may only resolve the activation that
      * actually asked to wait on it (an activity outcome of `waiting` with

package/dist/src/integrations/github/application/agent-context-reader.js

@@ -4,9 +4,9 @@ import { adapterId } from '../../contracts/identifiers.js';
 import { integrationStream } from '../../contracts/streams.js';
 import { boundedDiagnosticEvidence } from '../contracts/check-evidence.js';
 import { GitHubEventType, selectGitHubAdapterEvent } from '../contracts/events.js';
-import { createCommentHistoryReader } from './comment-history-reader.js';
-export function createGitHubAgentContextReader(journal, resources) {
-    const commentHistory = createCommentHistoryReader(journal, resources);
+import { createCommentHistoryReader, } from './comment-history-reader.js';
+export function createGitHubAgentContextReader(journal, resources, options = {}) {
+    const commentHistory = createCommentHistoryReader(journal, resources, options);
     return {
         async forWorkItem(workItemId, options) {
             const comments = await commentHistory.forWorkItem(workItemId, options);

package/dist/src/integrations/github/application/comment-history-reader.js

@@ -1,40 +1,149 @@
 import { ResourceCorrelationRole } from '../../../resources/index.js';
 import { adapterId } from '../../contracts/identifiers.js';
+import { DeliveryEventType, selectDeliveryEvent } from '../../delivery/contracts/events.js';
+import { DeliveryIntentEventType, selectDeliveryIntentEvent, } from '../../delivery/contracts/intents.js';
+import { DeliveryResultKind } from '../../delivery/contracts/vocabulary.js';
 import { GitHubEventType, selectGitHubAdapterEvent } from '../contracts/events.js';
-export function createCommentHistoryReader(journal, resources) {
+import { GitHubAdapter, UnknownGitHubIdentity } from '../contracts/vocabulary.js';
+import { formatAgentRunComment } from './agent-run-comment.js';
+export function createCommentHistoryReader(journal, resources, readerOptions = {}) {
     return {
         async forWorkItem(workItemId, options) {
-            const keys = new Set((await Promise.all((await resources.correlationsForWork(workItemId))
+            const resourcesById = new Map((await Promise.all((await resources.correlationsForWork(workItemId))
                 .filter((correlation) => correlation.role === ResourceCorrelationRole.Primary)
-                .map((correlation) => resources.get(correlation.resourceId)))).flatMap((resource) => {
-                if (resource === null || parseAdapterId(resource.externalKey.adapter) === null)
+                .map((correlation) => resources.get(correlation.resourceId)))).flatMap((resource) => resource === null ? [] : [[resource.resourceId, resource]]));
+            const keys = new Set([...resourcesById.values()].flatMap((resource) => {
+                if (parseAdapterId(resource.externalKey.adapter) === null)
                     return [];
                 return [`${resource.externalKey.adapter}:${resource.externalKey.key}`];
             }));
             if (keys.size === 0)
                 return [];
-            return (await journal.readAll(0)).flatMap((event) => {
-                if (options?.observedSince !== undefined && event.occurredAt <= options.observedSince)
-                    return [];
-                const observed = selectGitHubAdapterEvent(event);
-                if (observed?.eventType !== GitHubEventType.CommentObserved)
-                    return [];
-                if (!keys.has(`${observed.stream.id}:${observed.payload.externalKey}`))
-                    return [];
-                return [
-                    {
-                        author: observed.payload.actor.id,
-                        occurredAt: observed.occurredAt,
-                        body: observed.payload.body,
-                        ...(observed.payload.reviewKind !== 'issue' || observed.payload.location === undefined
-                            ? {}
-                            : { location: observed.payload.location }),
-                    },
-                ];
-            });
+            const githubAdapters = new Set(readerOptions.githubAdapters ?? [GitHubAdapter]);
+            const githubResourceIds = new Set([...resourcesById.entries()].flatMap(([resourceId, resource]) => githubAdapters.has(resource.externalKey.adapter) ? [resourceId] : []));
+            return readCommentHistory(await journal.readAll(0), resourcesById, keys, githubResourceIds, options?.observedSince, readerOptions.publicUiUrl);
+        },
+    };
+}
+function readCommentHistory(events, resourcesById, keys, githubResourceIds, observedSince, publicUiUrl) {
+    const intents = commentIntents(events, githubResourceIds);
+    const observed = providerComments(events, keys);
+    const confirmed = confirmations(events, intents);
+    return reconcileCommentHistory(observed, confirmed, resourcesById, observedSince, publicUiUrl);
+}
+function commentIntents(events, githubResourceIds) {
+    const intents = new Map();
+    for (const event of events) {
+        const intent = selectDeliveryIntentEvent(event);
+        if (intent !== null &&
+            isCommentIntent(intent) &&
+            githubResourceIds.has(intent.payload.resourceId))
+            intents.set(intent.eventId, intent);
+    }
+    return intents;
+}
+function providerComments(events, keys) {
+    const observed = new Map();
+    for (const event of events) {
+        const comment = providerComment(event, keys);
+        if (comment !== null)
+            observed.set(event.eventId, comment);
+    }
+    return observed;
+}
+function confirmations(events, intents) {
+    const confirmed = new Map();
+    for (const event of events) {
+        const delivery = selectDeliveryEvent(event);
+        if (delivery === null || !isConfirmed(delivery))
+            continue;
+        const intent = intents.get(delivery.payload.intentEventId);
+        if (intent === undefined)
+            continue;
+        const candidate = { event, intent };
+        const current = confirmed.get(delivery.payload.intentEventId);
+        if (current === undefined || candidate.event.globalPosition < current.event.globalPosition)
+            confirmed.set(delivery.payload.intentEventId, candidate);
+    }
+    return confirmed;
+}
+function reconcileCommentHistory(observed, confirmed, resourcesById, observedSince, publicUiUrl) {
+    const history = new Map();
+    for (const entry of observed.values())
+        history.set(entry.event.eventId, {
+            entry: entry.value,
+            occurredAt: entry.event.occurredAt,
+            globalPosition: entry.event.globalPosition,
+        });
+    for (const [intentEventId, confirmation] of confirmed) {
+        const resource = resourcesById.get(confirmation.intent.payload.resourceId);
+        if (resource === undefined)
+            continue;
+        const resourceKey = `${resource.externalKey.adapter}:${resource.externalKey.key}`;
+        const matchingProvider = [...observed.values()].find((entry) => entry.resourceKey === resourceKey && deliveryMarker(entry.value.body) === intentEventId);
+        history.set(intentEventId, {
+            entry: matchingProvider?.value ??
+                syntheticComment(confirmation.intent, confirmation.event.occurredAt, publicUiUrl),
+            occurredAt: confirmation.event.occurredAt,
+            globalPosition: confirmation.event.globalPosition,
+        });
+        if (matchingProvider !== undefined)
+            history.delete(matchingProvider.event.eventId);
+    }
+    return [...history.values()]
+        .filter((entry) => observedSince === undefined || entry.occurredAt > observedSince)
+        .sort((left, right) => left.globalPosition - right.globalPosition)
+        .map((entry) => entry.entry);
+}
+function isCommentIntent(value) {
+    return (value.eventType === DeliveryIntentEventType.StatusPublishRequested ||
+        value.eventType === DeliveryIntentEventType.ReplyPublishRequested ||
+        value.eventType === DeliveryIntentEventType.AgentRunPublishRequested);
+}
+function isConfirmed(value) {
+    return (value.eventType === DeliveryEventType.Confirmed ||
+        (value.eventType === DeliveryEventType.Reconciled &&
+            value.payload.result === DeliveryResultKind.Confirmed));
+}
+function providerComment(event, keys) {
+    const observed = selectGitHubAdapterEvent(event);
+    if (observed?.eventType !== GitHubEventType.CommentObserved ||
+        !keys.has(`${observed.stream.id}:${observed.payload.externalKey}`))
+        return null;
+    return {
+        event,
+        resourceKey: `${observed.stream.id}:${observed.payload.externalKey}`,
+        value: {
+            author: observed.payload.actor.id,
+            occurredAt: observed.occurredAt,
+            body: observed.payload.body,
+            ...(observed.payload.reviewKind !== 'issue' || observed.payload.location === undefined
+                ? {}
+                : { location: observed.payload.location }),
         },
     };
 }
+function syntheticComment(intent, occurredAt, publicUiUrl) {
+    return {
+        author: UnknownGitHubIdentity,
+        occurredAt,
+        body: deliveredCommentBody(intent, publicUiUrl),
+    };
+}
+function deliveredCommentBody(intent, publicUiUrl) {
+    const marker = `<!-- wake:delivery:${intent.eventId} -->`;
+    const body = intent.eventType === DeliveryIntentEventType.AgentRunPublishRequested
+        ? formatAgentRunComment({
+            idempotencyKey: intent.eventId,
+            ...intent.payload.report,
+            publicUiUrl,
+        })
+        : intent.payload.body;
+    return `${body}\n${marker}`.trim();
+}
+function deliveryMarker(body) {
+    return /<!--\s*wake:delivery:([^\s>]+)\s*-->/.exec(body)?.[1];
+}
 function parseAdapterId(value) {
     try {
         return adapterId(value);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atolis-hq/wake",
-  "version": "0.3.33",
+  "version": "0.3.35",
   "description": "Local autonomous agent control plane for software development",
   "license": "Apache-2.0",
   "repository": {