@atolis-hq/wake 0.1.4 → 0.1.5

package/dist/src/adapters/github/github-client.js

@@ -59,6 +59,37 @@ export function createGitHubClient(token) {
             });
             return data;
         },
+        async getRequiredStatusChecks(owner, repo, branch) {
+            const { data } = await octokit.rest.repos.getBranch({
+                owner,
+                repo,
+                branch,
+            });
+            const requiredStatusChecks = data.protection?.required_status_checks;
+            return {
+                contexts: requiredStatusChecks?.contexts ?? [],
+                checks: (requiredStatusChecks?.checks ?? [])
+                    .map((check) => check.context)
+                    .filter((context) => typeof context === 'string'),
+            };
+        },
+        async listCheckRunsForRef(owner, repo, ref) {
+            const { data } = await octokit.rest.checks.listForRef({
+                owner,
+                repo,
+                ref,
+                per_page: 100,
+            });
+            return data.check_runs;
+        },
+        async getCombinedStatusForRef(owner, repo, ref) {
+            const { data } = await octokit.rest.repos.getCombinedStatusForRef({
+                owner,
+                repo,
+                ref,
+            });
+            return data.statuses;
+        },
         async listPullRequests(owner, repo, maxResults) {
             const perPage = Math.min(maxResults, 100);
             const results = [];

package/dist/src/adapters/github/github-pull-request-activity-source.js

@@ -22,6 +22,19 @@ function reviewThreadRootId(comment, byId) {
 function reviewThreadResourceUri(repo, prNumber, rootId) {
     return buildResourceUri('github', 'pr-review-thread', `${repo}#${prNumber}/rt_${rootId}`);
 }
+function safeEventToken(value) {
+    return value.replace(/[^a-z0-9]+/gi, '-');
+}
+function isFailingCheckRun(run) {
+    return (run.status === 'completed' &&
+        (run.conclusion === 'failure' ||
+            run.conclusion === 'timed_out' ||
+            run.conclusion === 'cancelled' ||
+            run.conclusion === 'action_required'));
+}
+function isFailingStatus(status) {
+    return status.state === 'failure' || status.state === 'error';
+}
 // selfLogin is the only reliable signal for an agent-authored comment posted
 // by direct API/CLI call (e.g. a `revise` run replying via `gh api
 // .../replies`), which never carries the marker and whose account `type` is
@@ -206,13 +219,118 @@ export function createGitHubPullRequestActivitySource(deps) {
         }
         return events;
     }
+    async function pollRequiredCheckFailures(ref, resourceUri, ingestedAt) {
+        if (!deps.config.sources.github.pullRequests.enabled ||
+            !deps.config.sources.github.pullRequests.checks.enabled ||
+            deps.client.getRequiredStatusChecks === undefined ||
+            deps.client.listCheckRunsForRef === undefined ||
+            deps.client.getCombinedStatusForRef === undefined) {
+            return [];
+        }
+        const pr = await deps.client.getPullRequest(ref.owner, ref.repo, ref.number);
+        const headSha = pr.head.sha;
+        const baseRef = pr.base?.ref;
+        if (headSha === undefined || baseRef === undefined) {
+            return [];
+        }
+        const required = await deps.client.getRequiredStatusChecks(ref.owner, ref.repo, baseRef);
+        const requiredContexts = new Set([...required.contexts, ...required.checks]);
+        if (requiredContexts.size === 0) {
+            return [];
+        }
+        const [checkRuns, statuses] = await Promise.all([
+            deps.client.listCheckRunsForRef(ref.owner, ref.repo, headSha),
+            deps.client.getCombinedStatusForRef(ref.owner, ref.repo, headSha),
+        ]);
+        const events = [];
+        for (const run of checkRuns) {
+            if (!requiredContexts.has(run.name) || !isFailingCheckRun(run)) {
+                continue;
+            }
+            const occurredAt = run.completed_at ?? run.started_at ?? ingestedAt;
+            const sourceUrl = run.html_url ?? run.details_url ?? pr.html_url;
+            events.push(createUnkeyedEventEnvelope({
+                eventId: `pr-check-failed-${safeEventToken(ref.repoRef)}-${ref.number}-${safeEventToken(run.name)}-${headSha}-${safeEventToken(occurredAt)}-${run.conclusion}`,
+                streamScope: 'work-item',
+                direction: 'inbound',
+                sourceSystem: githubPrSource,
+                sourceEventType: 'pr.checks.failed',
+                sourceRefs: { repo: ref.repoRef, sourceUrl, resourceUri },
+                occurredAt,
+                ingestedAt,
+                trigger: 'context-only',
+                payload: {
+                    comment: {
+                        id: `pr-check-failed-${headSha}-${run.id}-${run.conclusion}`,
+                        body: `Required check failed: ${run.name} (${run.conclusion}).`,
+                        author: { login: 'github-checks' },
+                        createdAt: occurredAt,
+                        updatedAt: occurredAt,
+                        resourceUri,
+                    },
+                    checkFailure: {
+                        kind: 'check_run',
+                        name: run.name,
+                        conclusion: run.conclusion,
+                        headSha,
+                    },
+                },
+            }));
+        }
+        for (const status of statuses) {
+            if (!requiredContexts.has(status.context) || !isFailingStatus(status)) {
+                continue;
+            }
+            events.push(createUnkeyedEventEnvelope({
+                eventId: `pr-status-failed-${safeEventToken(ref.repoRef)}-${ref.number}-${safeEventToken(status.context)}-${headSha}-${safeEventToken(status.updated_at)}-${status.state}`,
+                streamScope: 'work-item',
+                direction: 'inbound',
+                sourceSystem: githubPrSource,
+                sourceEventType: 'pr.checks.failed',
+                sourceRefs: { repo: ref.repoRef, sourceUrl: status.target_url ?? pr.html_url, resourceUri },
+                occurredAt: status.updated_at,
+                ingestedAt,
+                trigger: 'context-only',
+                payload: {
+                    comment: {
+                        id: `pr-status-failed-${headSha}-${status.context}-${status.state}`,
+                        body: `Required status failed: ${status.context} (${status.state})${status.description === undefined || status.description === null ? '.' : `: ${status.description}`}`,
+                        author: { login: 'github-status' },
+                        createdAt: status.created_at,
+                        updatedAt: status.updated_at,
+                        resourceUri,
+                    },
+                    checkFailure: {
+                        kind: 'status',
+                        name: status.context,
+                        conclusion: status.state,
+                        headSha,
+                    },
+                },
+            }));
+        }
+        return events;
+    }
     return {
         async pollEvents(input) {
             const ingestedAt = deps.now().toISOString();
             const watched = (input?.watch ?? []).filter((ref) => ref.resourceUri.startsWith('github:pr:'));
             const discovered = await discoverPullRequests(ingestedAt);
             const activityBatches = await Promise.all(watched.map((ref) => pollWatchedPr(ref.resourceUri, ingestedAt)));
-            return [...discovered, ...activityBatches.flat()];
+            const checkBatches = await Promise.all(watched.map(async (watchRef) => {
+                const ref = repoAndNumberFromPrUri(watchRef.resourceUri);
+                if (ref === null) {
+                    return [];
+                }
+                try {
+                    return await pollRequiredCheckFailures(ref, watchRef.resourceUri, ingestedAt);
+                }
+                catch (error) {
+                    console.error(`[github-pr-activity-source] check poll failed for ${watchRef.resourceUri}, skipping this tick: ${error instanceof Error ? error.message : String(error)}`);
+                    return [];
+                }
+            }));
+            return [...discovered, ...activityBatches.flat(), ...checkBatches.flat()];
         },
         async deliverIntent(input) {
             const resourceUri = input.event.sourceRefs.resourceUri;

package/dist/src/core/projection-updater.js

@@ -91,7 +91,8 @@ async function applyEvent(current, event, ctx, config) {
         event.sourceEventType === 'ticket.comment.updated' ||
         event.sourceEventType === 'pr.comment.created' ||
         event.sourceEventType === 'pr.review.created' ||
-        event.sourceEventType === 'pr.review-comment.created') {
+        event.sourceEventType === 'pr.review-comment.created' ||
+        event.sourceEventType === 'pr.checks.failed') {
         const comment = event.payload.comment;
         if (comment === undefined || typeof comment !== 'object' || comment === null) {
             return current;

package/dist/src/domain/schema.js

@@ -452,12 +452,15 @@ export const wakeConfigSchema = z.object({
                 enabled: z.boolean().default(false),
                 maxPullRequestsPerRepo: z.number().int().positive().default(25),
                 commentPageSize: z.number().int().positive().default(25),
+                checks: z.object({
+                    enabled: z.boolean().default(true),
+                }).default({ enabled: true }),
                 policy: z.object({
                     requiredAuthors: z.array(z.string()).default([]),
                 }).default({ requiredAuthors: [] }),
-            }).default({ enabled: false, maxPullRequestsPerRepo: 25, commentPageSize: 25, policy: { requiredAuthors: [] } }),
-        }).default({ enabled: false, repos: [], polling: { maxIssuesPerRepo: 25, commentPageSize: 25, lookbackMs: 60_000 }, policy: { requiredLabels: [], ignoredLabels: [], requiredAssignees: [] }, publication: { postStatusComments: true }, pullRequests: { enabled: false, maxPullRequestsPerRepo: 25, commentPageSize: 25, policy: { requiredAuthors: [] } } }),
-    }).default({ github: { enabled: false, repos: [], polling: { maxIssuesPerRepo: 25, commentPageSize: 25, lookbackMs: 60_000 }, policy: { requiredLabels: [], ignoredLabels: [], requiredAssignees: [] }, publication: { postStatusComments: true }, pullRequests: { enabled: false, maxPullRequestsPerRepo: 25, commentPageSize: 25, policy: { requiredAuthors: [] } } } }),
+            }).default({ enabled: false, maxPullRequestsPerRepo: 25, commentPageSize: 25, checks: { enabled: true }, policy: { requiredAuthors: [] } }),
+        }).default({ enabled: false, repos: [], polling: { maxIssuesPerRepo: 25, commentPageSize: 25, lookbackMs: 60_000 }, policy: { requiredLabels: [], ignoredLabels: [], requiredAssignees: [] }, publication: { postStatusComments: true }, pullRequests: { enabled: false, maxPullRequestsPerRepo: 25, commentPageSize: 25, checks: { enabled: true }, policy: { requiredAuthors: [] } } }),
+    }).default({ github: { enabled: false, repos: [], polling: { maxIssuesPerRepo: 25, commentPageSize: 25, lookbackMs: 60_000 }, policy: { requiredLabels: [], ignoredLabels: [], requiredAssignees: [] }, publication: { postStatusComments: true }, pullRequests: { enabled: false, maxPullRequestsPerRepo: 25, commentPageSize: 25, checks: { enabled: true }, policy: { requiredAuthors: [] } } } }),
     sinks: z.record(z.string(), sinkEntrySchema).default({}),
 }).superRefine((config, ctx) => {
     const promptsRoot = config.paths.promptsRoot ?? defaultPromptsRoot();

package/dist/src/version.js

@@ -1 +1 @@
-export const wakeVersion = "0.1.4+g6aa4c64";
+export const wakeVersion = "0.1.5+g2910a1f";

package/package.json

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