@atolis-hq/wake 0.3.34 → 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 = "g01f75bf";
+export const wakeVersion = "g4327396";

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.34",
+  "version": "0.3.35",
   "description": "Local autonomous agent control plane for software development",
   "license": "Apache-2.0",
   "repository": {