@atolis-hq/wake 0.3.34 → 0.3.36

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 = "g3fd5716";

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/dist/src/integrations/github/application/wake-labels.js

@@ -11,6 +11,7 @@ export function isGitHubWakeEcho(input) {
         input.labels.some(isGitHubWakeMarker));
 }
 export function createGitHubWakeLabelReconciler(input) {
+    const syncedDesiredLabels = new Map();
     const openWorkItemIds = async (workItemIds) => {
         const open = new Set();
         for (const workItemId of workItemIds) {
@@ -50,17 +51,22 @@ export function createGitHubWakeLabelReconciler(input) {
                     const locator = parseGitHubIssueKey(resource.externalKey.key);
                     if (locator === null)
                         continue;
+                    const fingerprint = desired.join('\u0000');
+                    if (syncedDesiredLabels.get(resource.resourceId) === fingerprint)
+                        continue;
                     // One issue's persistent failure (rate limit, permissions, a stale
                     // resource) must not stop every other open work item from being
                     // reconciled this pass — each correlation is an independent GitHub
                     // call with no ordering dependency on the others.
                     try {
-                        const current = await input.getLabels(locator.owner, locator.repo, locator.number);
+                        const current = await request(input, () => input.getLabels(locator.owner, locator.repo, locator.number));
                         const next = reconcileGitHubWakeLabels(current, desired);
                         if (!sameLabels(current, next))
-                            await input.setLabels(locator.owner, locator.repo, locator.number, next);
+                            await request(input, () => input.setLabels(locator.owner, locator.repo, locator.number, next));
+                        syncedDesiredLabels.set(resource.resourceId, fingerprint);
                     }
                     catch (error) {
+                        syncedDesiredLabels.delete(resource.resourceId);
                         onError({ workItemId: workflow.workItemId, ...locator }, error);
                     }
                 }
@@ -68,6 +74,9 @@ export function createGitHubWakeLabelReconciler(input) {
         },
     };
 }
+function request(input, operation) {
+    return input.requests === undefined ? operation() : input.requests.run(operation);
+}
 function defaultOnError(failure, error) {
     process.stderr.write(`GitHub label reconcile failed for ${failure.owner}/${failure.repo}#${failure.number}: ${error instanceof Error ? error.message : String(error)}\n`);
 }

package/dist/src/integrations/github/contracts/config.js

@@ -33,11 +33,12 @@ export const gitHubConfigSchema = z
     polling: z
         .object({
         maxPerRepo: z.number().int().positive().default(25),
+        maxConcurrent: z.number().int().positive().default(4),
         commentPageSize: z.number().int().positive().max(100).default(25),
         lookbackMs: z.number().int().nonnegative().default(60_000),
     })
         .strict()
-        .default({ maxPerRepo: 25, commentPageSize: 25, lookbackMs: 60_000 }),
+        .default({ maxPerRepo: 25, maxConcurrent: 4, commentPageSize: 25, lookbackMs: 60_000 }),
     intake: z.array(intakeRuleSchema).default([]),
     publication: z
         .object({ postStatusComments: z.boolean().default(true) })

package/dist/src/integrations/github/infrastructure/request-coordinator.js

@@ -0,0 +1,123 @@
+export class GitHubRequestCooldownError extends Error {
+    retryAt;
+    constructor(retryAt) {
+        super(`GitHub provider is cooling down until ${new Date(retryAt).toISOString()}`);
+        this.retryAt = retryAt;
+        this.name = 'GitHubRequestCooldownError';
+    }
+}
+export function createGitHubRequestCoordinator(options) {
+    return new CoordinatedGitHubRequests(options);
+}
+class CoordinatedGitHubRequests {
+    options;
+    queue = [];
+    now;
+    active = 0;
+    draining = false;
+    cooldownUntil = 0;
+    transientFailureCount = 0;
+    constructor(options) {
+        this.options = options;
+        this.now = options.now ?? Date.now;
+    }
+    run(request) {
+        return new Promise((resolve, reject) => {
+            this.queue.push({
+                request: request,
+                resolve: resolve,
+                reject,
+            });
+            void this.drain();
+        });
+    }
+    async drain() {
+        if (this.draining)
+            return;
+        this.draining = true;
+        try {
+            while (this.active < this.options.maxConcurrent && this.queue.length > 0) {
+                if (this.cooldownUntil > this.now()) {
+                    const error = new GitHubRequestCooldownError(this.cooldownUntil);
+                    this.queue.splice(0).forEach((pending) => pending.reject(error));
+                    return;
+                }
+                const pending = this.queue.shift();
+                this.active += 1;
+                void Promise.resolve()
+                    .then(pending.request)
+                    .then((value) => {
+                    this.transientFailureCount = 0;
+                    pending.resolve(value);
+                }, (error) => {
+                    this.recordFailure(error);
+                    pending.reject(error);
+                })
+                    .finally(() => {
+                    this.active -= 1;
+                    void this.drain();
+                });
+            }
+        }
+        finally {
+            this.draining = false;
+        }
+    }
+    recordFailure(error) {
+        const retryAfterMs = retryAfterMilliseconds(error, this.now());
+        if (statusOf(error) === 429) {
+            this.cooldownUntil = this.now() + (retryAfterMs ?? 60_000);
+            this.transientFailureCount = 0;
+            return;
+        }
+        if (isTransient(error)) {
+            const delay = Math.min(5_000 * 2 ** this.transientFailureCount, 60_000);
+            this.transientFailureCount += 1;
+            this.cooldownUntil = this.now() + delay;
+        }
+    }
+}
+function statusOf(error) {
+    if (typeof error !== 'object' || error === null || !('status' in error))
+        return undefined;
+    return typeof error.status === 'number' ? error.status : undefined;
+}
+function isTransient(error) {
+    const status = statusOf(error);
+    if (status !== undefined)
+        return status >= 500;
+    return (error instanceof TypeError ||
+        (typeof error === 'object' &&
+            error !== null &&
+            'code' in error &&
+            typeof error.code === 'string'));
+}
+function retryAfterMilliseconds(error, now) {
+    const value = retryAfterValue(error);
+    if (value === undefined || value === null)
+        return undefined;
+    const seconds = Number(value);
+    if (Number.isFinite(seconds) && seconds >= 0)
+        return seconds * 1_000;
+    const timestamp = Date.parse(value);
+    return Number.isFinite(timestamp) ? Math.max(0, timestamp - now) : undefined;
+}
+function retryAfterValue(error) {
+    if (typeof error !== 'object' || error === null || !('response' in error))
+        return undefined;
+    const response = error.response;
+    if (typeof response !== 'object' || response === null || !('headers' in response))
+        return undefined;
+    return headerValue(response.headers);
+}
+function headerValue(headers) {
+    if (typeof headers !== 'object' || headers === null)
+        return undefined;
+    if ('get' in headers && typeof headers.get === 'function') {
+        const value = headers.get('retry-after');
+        return typeof value === 'string' ? value : undefined;
+    }
+    if ('retry-after' in headers && typeof headers['retry-after'] === 'string')
+        return headers['retry-after'];
+    return undefined;
+}

package/dist/src/integrations/github/infrastructure/source.js

@@ -2,8 +2,11 @@ import { ReviewerAuthorizationSource, } from '../../../activities/index.js';
 import { GitHubEventType } from '../contracts/events.js';
 import { issueCommentObservation, issueObservation } from './issue-source.js';
 import { createGitHubPullRequestSource } from './pr-source.js';
+import { createGitHubRequestCoordinator, } from './request-coordinator.js';
 import { githubReviewObservation } from './review-source.js';
-export function createGitHubSource(config, client, adapter) {
+export function createGitHubSource(config, client, adapter, requests = createGitHubRequestCoordinator({
+    maxConcurrent: config.polling.maxConcurrent,
+})) {
     let nextPollAt = 0;
     // Draft eventIds are already content fingerprints (see issue-source.ts/pr-source.ts),
     // so the journal itself is idempotent per item. This cache only avoids re-appending
@@ -16,7 +19,14 @@ export function createGitHubSource(config, client, adapter) {
             if (Date.now() < nextPollAt)
                 return [];
             nextPollAt = Date.now() + config.polling.lookbackMs;
-            const perRepository = await Promise.all(config.repositories.map(({ owner, repo }) => pollRepository({ client, config, adapter, signal, owner, repo })));
+            const perRepository = await Promise.all(config.repositories.map(({ owner, repo }) => pollRepository({
+                client: limitGitHubSourceClient(client, requests),
+                config,
+                adapter,
+                signal,
+                owner,
+                repo,
+            })));
             return perRepository.flat().filter((draft) => {
                 if (draft.eventType !== GitHubEventType.WorkObserved)
                     return true;
@@ -27,6 +37,28 @@ export function createGitHubSource(config, client, adapter) {
         },
     };
 }
+function limitGitHubSourceClient(client, requests) {
+    return {
+        ...client,
+        listIssues: (owner, repo, maxResults) => requests.run(() => client.listIssues(owner, repo, maxResults)),
+        listPullRequests: (owner, repo, maxResults) => requests.run(() => client.listPullRequests(owner, repo, maxResults)),
+        listCheckRunsForRef: (owner, repo, ref) => requests.run(() => client.listCheckRunsForRef(owner, repo, ref)),
+        getCombinedStatusForRef: (owner, repo, ref) => requests.run(() => client.getCombinedStatusForRef(owner, repo, ref)),
+        listPullRequestFiles: (owner, repo, pullNumber) => requests.run(() => client.listPullRequestFiles(owner, repo, pullNumber)),
+        listIssueComments: (owner, repo, issueNumber, pageSize) => requests.run(() => client.listIssueComments(owner, repo, issueNumber, pageSize)),
+        listReviews: (owner, repo, pullNumber, pageSize) => requests.run(() => client.listReviews(owner, repo, pullNumber, pageSize)),
+        ...(client.listReviewComments === undefined
+            ? {}
+            : {
+                listReviewComments: (owner, repo, pullNumber, pageSize) => requests.run(() => client.listReviewComments(owner, repo, pullNumber, pageSize)),
+            }),
+        ...(client.collaboratorPermission === undefined
+            ? {}
+            : {
+                collaboratorPermission: (owner, repo, login) => requests.run(() => client.collaboratorPermission(owner, repo, login)),
+            }),
+    };
+}
 async function pollRepository(input) {
     const { client, config, adapter, signal, owner, repo } = input;
     const context = {

package/dist/src/integrations/github/provider.js

@@ -9,6 +9,7 @@ import { GitHubEventType } from './contracts/events.js';
 import { createGitHubClient } from './infrastructure/client.js';
 import { createGitHubDelivery } from './infrastructure/delivery.js';
 import { resolveGitHubCliToken } from './infrastructure/gh-auth.js';
+import { createGitHubRequestCoordinator } from './infrastructure/request-coordinator.js';
 import { createGitHubSource } from './infrastructure/source.js';
 export const gitHubProviderDefinition = {
     provider: 'github',
@@ -20,16 +21,20 @@ export const gitHubProviderDefinition = {
         if (services === undefined)
             throw new Error('GitHub provider requires composed services');
         const client = createGitHubClient(config.token ?? resolveGitHubCliToken());
+        const requests = createGitHubRequestCoordinator({
+            maxConcurrent: config.polling.maxConcurrent,
+        });
         return {
             adapter,
             eventTypes: Object.values(GitHubEventType),
-            source: createGitHubSource(config, client, adapter),
+            source: createGitHubSource(config, client, adapter, requests),
             maintenance: createGitHubWakeLabelReconciler({
                 orchestration: services.orchestration,
                 resources: services.resources,
                 work: services.work,
                 getLabels: client.getIssueLabels,
                 setLabels: client.setIssueLabels,
+                requests,
             }),
             delivery: createGitHubDelivery(async (intent, idempotencyKey) => {
                 const resource = await services.resources.get(resourceId(intent.resourceId));

package/package.json

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