@atolis-hq/wake 0.3.5 → 0.3.6

package/dist/src/activities/agent/agent-activity.js

@@ -97,6 +97,7 @@ async function buildUntrustedContext(workItemId, contextReader) {
         issueTitle: context.title,
         issueBody: context.body,
         comments: context.comments,
+        ...(context.pullRequest === undefined ? {} : { pullRequest: context.pullRequest }),
     };
 }
 function untrustedDataBlock(context) {
@@ -108,6 +109,7 @@ function untrustedDataBlock(context) {
         escapeUntrustedJson(JSON.stringify({
             issue: { title: context.issueTitle, body: context.issueBody },
             comments: context.comments,
+            ...(context.pullRequest === undefined ? {} : { pullRequest: context.pullRequest }),
         }, null, 2)),
         '</wake-untrusted-data>',
     ].join('\n');

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 = "ga20cb24";
+export const wakeVersion = "gd042cce";

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

@@ -1,6 +1,8 @@
-import { ResourceCorrelationRole } from '../../../resources/index.js';
+import { PullRequestCheckState, } from '../../../activities/index.js';
+import { BuiltInResourceKind, ResourceCorrelationRole, } from '../../../resources/index.js';
 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) {
@@ -11,6 +13,7 @@ export function createGitHubAgentContextReader(journal, resources) {
             return {
                 ...(await currentWorkItemContent(journal, resources, workItemId)),
                 comments,
+                ...pullRequestContextField(await currentPullRequestContext(journal, resources, workItemId)),
             };
         },
     };
@@ -28,6 +31,38 @@ async function currentWorkItemContent(journal, resources, workItemId) {
     return latestWorkObservedContent(await journal.readStream(integrationStream(adapter)), adapter, resource.externalKey.key);
 }
 const emptyWorkItemContent = { title: '', body: '' };
+async function currentPullRequestContext(journal, resources, workItemId) {
+    let current;
+    for (const correlation of await resources.correlationsForWork(workItemId)) {
+        const resource = await resources.get(correlation.resourceId);
+        if (resource?.kind !== BuiltInResourceKind.PullRequest)
+            continue;
+        const adapter = parseAdapterId(resource.externalKey.adapter);
+        if (adapter === null)
+            continue;
+        for (const event of await journal.readStream(integrationStream(adapter))) {
+            const observed = selectGitHubAdapterEvent(event);
+            if (!isCurrentPullRequestObservedEvent(observed, adapter, resource.externalKey.key))
+                continue;
+            if (current === undefined || event.globalPosition > current.position)
+                current = { context: pullRequestContext(observed.payload), position: event.globalPosition };
+        }
+    }
+    return current?.context;
+}
+function pullRequestContext(payload) {
+    return {
+        checks: payload.checks ?? PullRequestCheckState.Unknown,
+        checkRuns: rawEvidenceList(payload.raw.checkRuns),
+        statuses: rawEvidenceList(payload.raw.statuses),
+    };
+}
+function rawEvidenceList(value) {
+    return Array.isArray(value) ? boundedDiagnosticEvidence(value) : [];
+}
+function pullRequestContextField(context) {
+    return context === undefined ? {} : { pullRequest: context };
+}
 function latestWorkObservedContent(events, adapter, externalKey) {
     let current;
     for (const event of events) {
@@ -44,6 +79,10 @@ function isCurrentWorkObservedEvent(observed, adapter, externalKey) {
         observed.source.id === adapter &&
         observed.payload.externalKey === externalKey);
 }
+function isCurrentPullRequestObservedEvent(observed, adapter, externalKey) {
+    return (isCurrentWorkObservedEvent(observed, adapter, externalKey) &&
+        observed.payload.kind === 'pull-request');
+}
 function parseAdapterId(value) {
     try {
         return adapterId(value);

package/dist/src/integrations/github/contracts/check-evidence.js

@@ -0,0 +1,37 @@
+const diagnosticKeys = [
+    'name',
+    'status',
+    'conclusion',
+    'started_at',
+    'completed_at',
+    'details_url',
+    'html_url',
+    'context',
+    'state',
+    'target_url',
+];
+const maxEvidenceEntries = 20;
+const maxEvidenceBytes = 12_000;
+export function boundedDiagnosticEvidence(evidence) {
+    const bounded = [];
+    let bytes = 0;
+    for (const value of evidence) {
+        if (bounded.length === maxEvidenceEntries)
+            break;
+        if (!isRecord(value))
+            continue;
+        const diagnostic = diagnosticEvidence(value);
+        const entryBytes = Buffer.byteLength(JSON.stringify(diagnostic), 'utf8');
+        if (bytes + entryBytes > maxEvidenceBytes)
+            break;
+        bounded.push(diagnostic);
+        bytes += entryBytes;
+    }
+    return bounded;
+}
+function diagnosticEvidence(entry) {
+    return Object.fromEntries(diagnosticKeys.flatMap((key) => typeof entry[key] === 'string' || entry[key] === null ? [[key, entry[key]]] : []));
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

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

@@ -2,6 +2,7 @@ import { createHash } from 'node:crypto';
 import { PullRequestCheckState, PullRequestState, ReviewActorKind, } from '../../../activities/index.js';
 import { createEventDraft, EventActorKind, EventSourceKind } from '../../../kernel/index.js';
 import { integrationStream } from '../../contracts/streams.js';
+import { boundedDiagnosticEvidence } from '../contracts/check-evidence.js';
 import { GitHubEventType } from '../contracts/events.js';
 import { formatGitHubResourceKey } from '../contracts/external-key.js';
 import { gitHubAssigneeLogins, gitHubLabelNames, } from '../contracts/payloads.js';
@@ -53,7 +54,11 @@ function pullRequestObservation(input) {
         },
         labels: gitHubLabelNames(pullRequest),
         assignees: gitHubAssigneeLogins(pullRequest),
-        raw: { number: pullRequest.number },
+        raw: {
+            number: pullRequest.number,
+            checkRuns: boundedDiagnosticEvidence(input.evidence.checkRuns),
+            statuses: boundedDiagnosticEvidence(input.evidence.statuses),
+        },
     };
     const fingerprint = evidenceFingerprint(payload, input.evidence);
     return createEventDraft({

package/dist/src/orchestration/application/advance-workflow.js

@@ -1,3 +1,4 @@
+import { ActivityEventType, PullRequestCheckState, selectActivityEvent, } from '../../activities/index.js';
 import { EventSourceKind, createEventDraft } from '../../kernel/index.js';
 import { OrchestrationEventType } from '../contracts/events.js';
 import { commandName, workflowInstanceId, } from '../contracts/identifiers.js';
@@ -147,14 +148,22 @@ export class AdvanceWorkflow {
     async listAll() {
         return (await this.repository.list()).filter((view) => view !== null);
     }
-    async listWatchMatches(eventType) {
+    async listWatchMatches(event) {
         return (await this.listAll()).flatMap((parent) => {
             const definition = this.workflows.definition(parent.workflowName);
             return definition.watches
-                .filter((watch) => watch.on?.events.includes(eventType) === true &&
+                .filter((watch) => watch.on?.events.includes(event.eventType) === true &&
                 watch.while.stages.includes(parent.currentStage) &&
-                watch.while.statuses.some((status) => status === parent.status))
+                watch.while.statuses.some((status) => status === parent.status) &&
+                matchesWatchPredicate(watch.where, event))
                 .map((watch) => ({ parent, watch }));
         });
     }
 }
+function matchesWatchPredicate(predicate, event) {
+    if (predicate === undefined)
+        return true;
+    const activityEvent = selectActivityEvent(event);
+    return (activityEvent?.eventType === ActivityEventType.PrChecksChanged &&
+        activityEvent.payload.checks === PullRequestCheckState.Failing);
+}

package/dist/src/orchestration/application/orchestration-service.js

@@ -75,8 +75,8 @@ export class OrchestrationService {
     isCausalRepeat(workflowInstanceId, triggerId, causalCycleId, requestId) {
         return this.childWorkflows.isCausalRepeat(workflowInstanceId, triggerId, causalCycleId, requestId);
     }
-    listWatchMatches(eventType) {
-        return this.advanceWorkflow.listWatchMatches(eventType);
+    listWatchMatches(event) {
+        return this.advanceWorkflow.listWatchMatches(event);
     }
 }
 export const createOrchestrationService = (journal, work, definitions) => new OrchestrationService(journal, work, definitions);

package/dist/src/orchestration/application/watch-reactor.js

@@ -8,7 +8,7 @@ export function createWatchReactor(orchestration, journal, checkpoints, runs) {
         async react(event, context) {
             const causalCycle = orchestrationCausalCycleId(selectOrchestrationEvent(event));
             const sourceWorkflowInstanceId = await resolveRunWorkflowInstanceId(event, runs);
-            for (const match of await orchestration.listWatchMatches(event.eventType)) {
+            for (const match of await orchestration.listWatchMatches(event)) {
                 if (sourceWorkflowInstanceId !== undefined &&
                     match.parent.workflowInstanceId !== sourceWorkflowInstanceId)
                     continue;

package/dist/src/orchestration/contracts/config.js

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { ApprovalAuthorityKind, WorkflowStatus } from './vocabulary.js';
+import { PullRequestCheckState } from '../../activities/index.js';
 import { WorkspaceMode } from '../../execution/index.js';
 import { MatchMode } from '../../kernel/index.js';
 const identifier = z.string().trim().min(1);
@@ -33,6 +34,9 @@ const watchGateConfigSchema = z.union([
 const commandName = z.string().regex(/^\/[a-z][a-z0-9-]*$/);
 const canonicalEventName = z.string().regex(/^[a-z][a-z0-9-]*(\.[a-z][a-z0-9-]*)+$/);
 const watchStatus = z.enum([WorkflowStatus.Active, WorkflowStatus.Waiting, WorkflowStatus.Blocked]);
+const failingChecksWatchPredicateSchema = z
+    .object({ checks: z.literal(PullRequestCheckState.Failing) })
+    .strict();
 export const watchConfigSchema = z
     .object({
     id: identifier,
@@ -46,6 +50,7 @@ export const watchConfigSchema = z
         .object({ events: z.array(canonicalEventName).min(1).readonly() })
         .strict()
         .optional(),
+    where: failingChecksWatchPredicateSchema.optional(),
     schedule: z.object({ cron: identifier }).strict().optional(),
     workflow: identifier,
     maxPerGroup: z.number().int().positive(),

package/dist/src/orchestration/domain/compiler.js

@@ -1,4 +1,4 @@
-import { activityName, ActivityOutcomeKind, } from '../../activities/index.js';
+import { ActivityEventType, activityName, ActivityOutcomeKind, } from '../../activities/index.js';
 import { workflowDefinitionConfigSchema, } from '../contracts/config.js';
 import { commandName, signalName, stageName, watchId, workflowName, } from '../contracts/identifiers.js';
 import { ApprovalAuthorityKind, TransitionTargetKind } from '../contracts/vocabulary.js';
@@ -42,6 +42,10 @@ function compileWatches(config, stageNames, knownWorkflowNames) {
             throw new Error(`Unknown watch stage: ${unknownStages.join(', ')}`);
         if (!knownWorkflowNames.includes(watch.workflow))
             throw new Error(`Unknown watch workflow: ${watch.workflow}`);
+        if (watch.where !== undefined &&
+            (watch.on === undefined ||
+                watch.on.events.some((event) => event !== ActivityEventType.PrChecksChanged)))
+            throw new Error('Watch where.checks is only valid with pr.checks-changed');
         return Object.freeze({
             ...watch,
             id: watchId(watch.id),

package/package.json

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