@atolis-hq/wake 0.2.43 → 0.2.44

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

@@ -194,6 +194,37 @@ export function createGitHubClient(token) {
                 }),
             });
         },
+        async listPullRequestFiles(owner, repo, pullNumber) {
+            return fetchPaginatedWithEtag({
+                cache: etagCache,
+                cacheKey: `pr-files:${owner}/${repo}#${pullNumber}`,
+                pages: (headers) => octokit.paginate.iterator(octokit.rest.pulls.listFiles, {
+                    owner,
+                    repo,
+                    pull_number: pullNumber,
+                    per_page: 100,
+                    ...(headers === undefined ? {} : { headers }),
+                }),
+            });
+        },
+        async createPullRequestApproval(owner, repo, pullNumber, body) {
+            await octokit.rest.pulls.createReview({
+                owner,
+                repo,
+                pull_number: pullNumber,
+                event: 'APPROVE',
+                body,
+            });
+        },
+        async enablePullRequestAutoMerge(pullRequestNodeId) {
+            await octokit.graphql(`mutation EnableWakeAutoMerge($pullRequestId: ID!) {
+          enablePullRequestAutoMerge(input: { pullRequestId: $pullRequestId }) {
+            pullRequest {
+              id
+            }
+          }
+        }`, { pullRequestId: pullRequestNodeId });
+        },
         async replyToReviewComment(owner, repo, pullNumber, commentId, body) {
             return octokit.rest.pulls.createReplyForReviewComment({
                 owner,

package/dist/src/adapters/github/github-pull-request-merge-actor.js

@@ -0,0 +1,29 @@
+function parseGithubPullRequestResourceUri(resourceUri) {
+    const match = /^github:pr:([^/]+)\/([^#]+)#(\d+)$/.exec(resourceUri);
+    if (match === null) {
+        throw new Error(`Unsupported GitHub pull request resource URI: ${resourceUri}`);
+    }
+    return {
+        owner: match[1],
+        repo: match[2],
+        pullNumber: Number(match[3]),
+    };
+}
+export function createGitHubPullRequestMergeActor(input) {
+    return {
+        async listChangedFiles(resourceUri) {
+            const ref = parseGithubPullRequestResourceUri(resourceUri);
+            const files = await input.client.listPullRequestFiles(ref.owner, ref.repo, ref.pullNumber);
+            return files.map((file) => file.filename);
+        },
+        async approve(resourceUri, body) {
+            const ref = parseGithubPullRequestResourceUri(resourceUri);
+            await input.client.createPullRequestApproval(ref.owner, ref.repo, ref.pullNumber, body);
+        },
+        async enableAutoMerge(resourceUri) {
+            const ref = parseGithubPullRequestResourceUri(resourceUri);
+            const pr = await input.client.getPullRequest(ref.owner, ref.repo, ref.pullNumber);
+            await input.client.enablePullRequestAutoMerge(pr.node_id);
+        },
+    };
+}

package/dist/src/core/policy-engine.js

@@ -188,7 +188,13 @@ export function createPolicyEngine() {
             if (latestComment?.isBotAuthored === true &&
                 latestComment.resourceUri !== undefined &&
                 latestComment.body.includes(prReviewApprovalMarker)) {
-                return { approved: true, pendingAction };
+                return {
+                    approved: true,
+                    pendingAction,
+                    targetResourceUri: latestComment.resourceUri,
+                    triggeringCommentId: latestComment.id,
+                    triggeringCommentBody: latestComment.body,
+                };
             }
             if (latestHumanComment === undefined) {
                 return null;

package/dist/src/core/tick-runner.js

@@ -110,6 +110,202 @@ export function createTickRunner(deps) {
     function hasLabel(projection, label) {
         return projection.issue.labels.includes(label);
     }
+    function approvedMergePolicyForStage(stage) {
+        return (stage?.watch?.find((watch) => watch.onApproved?.merge !== undefined)?.onApproved?.merge ??
+            null);
+    }
+    function escapeRegex(input) {
+        return input.replace(/[.+?^${}()|[\]\\]/g, '\\$&');
+    }
+    function globPatternMatches(pattern, path) {
+        const regex = new RegExp(`^${pattern.split('*').map(escapeRegex).join('.*')}$`);
+        return regex.test(path);
+    }
+    function reviewerMessageFromApprovalComment(body) {
+        return body
+            .replaceAll(prReviewApprovalMarker, '')
+            .replaceAll('<!-- wake:pr-review-changes-requested -->', '')
+            .trim();
+    }
+    async function evaluatePrMergeRisk(input) {
+        const incumbent = await deps.resourceIndex.resolve(input.targetResourceUri);
+        if (incumbent !== undefined && incumbent !== input.projection.workItemKey) {
+            return {
+                passed: false,
+                reason: `Merge policy blocked this PR because ${input.targetResourceUri} is primary-correlated to ${incumbent}, not ${input.projection.workItemKey}.`,
+            };
+        }
+        const blockedLabel = input.policy.blockedLabels.find((label) => input.projection.issue.labels.includes(label));
+        if (blockedLabel !== undefined) {
+            return {
+                passed: false,
+                reason: `Merge policy blocked this PR because the work item has blocked label "${blockedLabel}".`,
+            };
+        }
+        if (deps.prMergeActor === undefined) {
+            return {
+                passed: false,
+                reason: 'Merge policy blocked this PR because no pull request merge actor is configured.',
+            };
+        }
+        const filesChanged = await deps.prMergeActor.listChangedFiles(input.targetResourceUri);
+        if (input.policy.maxFilesChanged !== undefined &&
+            filesChanged.length > input.policy.maxFilesChanged) {
+            return {
+                passed: false,
+                reason: `Merge policy blocked this PR because it changes ${filesChanged.length} files, exceeding maxFilesChanged ${input.policy.maxFilesChanged}.`,
+            };
+        }
+        for (const pattern of input.policy.blockedPaths) {
+            const blockedPath = filesChanged.find((path) => globPatternMatches(pattern, path));
+            if (blockedPath !== undefined) {
+                return {
+                    passed: false,
+                    reason: `Merge policy blocked this PR because changed path "${blockedPath}" matches blockedPaths pattern "${pattern}".`,
+                };
+            }
+        }
+        return { passed: true, filesChanged };
+    }
+    async function publishPrMergePolicyBlock(input) {
+        const commentId = input.approvalResolution.triggeringCommentId;
+        const targetResourceUri = input.approvalResolution.targetResourceUri;
+        if (commentId === undefined || targetResourceUri === undefined) {
+            return { status: 'idle' };
+        }
+        const runId = `merge-gate-blocked-${commentId.replace(/[^a-z0-9]+/gi, '-')}`;
+        const occurredAt = eventStampNow();
+        const blockedEvent = createEventEnvelope({
+            eventId: `${runId}-completed`,
+            workItemKey: input.projection.workItemKey,
+            streamScope: 'work-item',
+            direction: 'internal',
+            sourceSystem: 'wake',
+            sourceEventType: 'wake.run.completed',
+            sourceRefs: {
+                repo: input.projection.issue.repo,
+                issueNumber: input.projection.issue.number,
+                runId,
+                resourceUri: targetResourceUri,
+            },
+            occurredAt,
+            ingestedAt: occurredAt,
+            trigger: 'immediate',
+            payload: {
+                action: input.approvalResolution.pendingAction,
+                sentinel: 'BLOCKED',
+                runId,
+                reason: 'pr-review-merge-policy-blocked',
+                blockReason: 'pr-review-merge-policy-blocked',
+                handledCommentId: commentId,
+                body: input.reason,
+            },
+        });
+        const appended = await deps.stateStore.appendEventEnvelope(blockedEvent);
+        await projectionUpdater.rebuildFromEvents([appended]);
+        const reviewerMessage = reviewerMessageFromApprovalComment(input.approvalResolution.triggeringCommentBody ?? '');
+        const body = [reviewerMessage, input.reason].filter((part) => part.length > 0).join('\n\n');
+        await deliverOutboundEvent(createEventEnvelope({
+            eventId: `${runId}-publish-intent`,
+            workItemKey: input.projection.workItemKey,
+            streamScope: 'work-item',
+            direction: 'outbound',
+            sourceSystem: 'wake',
+            sourceEventType: 'wake.publish.intent.requested',
+            sourceRefs: {
+                repo: input.projection.issue.repo,
+                issueNumber: input.projection.issue.number,
+                runId,
+                resourceUri: targetResourceUri,
+            },
+            occurredAt,
+            ingestedAt: occurredAt,
+            trigger: 'context-only',
+            payload: {
+                kind: 'question',
+                origin: input.projection.origin ?? 'github',
+                body,
+                action: input.approvalResolution.pendingAction,
+                sentinel: 'BLOCKED',
+                runId,
+                idempotencyKey: `${commentId}:pr-review-merge-policy-blocked`,
+                deliveryState: 'PENDING',
+            },
+            derivedHints: { stage: input.projection.wake.stage },
+        }));
+        await deliverOutboundEvent(createLabelsEvent({
+            projection: input.projection,
+            runId,
+            statusLabel: 'wake:status.blocked',
+            stageLabel: stageLabelForStage(input.projection.wake.stage),
+            workflowLabel: workflowLabelForWorkflowName(input.workflowName),
+            occurredAt,
+        }));
+        return {
+            status: 'processed',
+            runId,
+            sentinel: 'BLOCKED',
+            nextStage: null,
+        };
+    }
+    async function performApprovedPrMergeActions(input) {
+        if (deps.prMergeActor === undefined ||
+            input.approvalResolution.targetResourceUri === undefined ||
+            input.approvalResolution.triggeringCommentId === undefined) {
+            return;
+        }
+        const targetResourceUri = input.approvalResolution.targetResourceUri;
+        const commentId = input.approvalResolution.triggeringCommentId.replace(/[^a-z0-9]+/gi, '-');
+        const reviewBody = reviewerMessageFromApprovalComment(input.approvalResolution.triggeringCommentBody ?? '');
+        const approvedEventId = `pr-merge-approved-${commentId}`;
+        if (input.mergePolicy.approve &&
+            (await deps.stateStore.readEventEnvelope(approvedEventId)) === null) {
+            await deps.prMergeActor.approve(targetResourceUri, reviewBody);
+            const occurredAt = eventStampNow();
+            await deps.stateStore.appendEventEnvelope(createEventEnvelope({
+                eventId: approvedEventId,
+                workItemKey: input.projection.workItemKey,
+                streamScope: 'work-item',
+                direction: 'internal',
+                sourceSystem: 'wake',
+                sourceEventType: 'wake.pr-review.approved',
+                sourceRefs: {
+                    resourceUri: targetResourceUri,
+                    commentId: input.approvalResolution.triggeringCommentId,
+                },
+                occurredAt,
+                ingestedAt: occurredAt,
+                trigger: 'context-only',
+                payload: {
+                    idempotencyKey: `${input.approvalResolution.triggeringCommentId}:pr-review-approval`,
+                },
+            }));
+        }
+        const autoMergeEventId = `pr-auto-merge-enabled-${commentId}`;
+        if (input.mergePolicy.autoMerge &&
+            (await deps.stateStore.readEventEnvelope(autoMergeEventId)) === null) {
+            await deps.prMergeActor.enableAutoMerge(targetResourceUri);
+            const occurredAt = eventStampNow();
+            await deps.stateStore.appendEventEnvelope(createEventEnvelope({
+                eventId: autoMergeEventId,
+                workItemKey: input.projection.workItemKey,
+                streamScope: 'work-item',
+                direction: 'internal',
+                sourceSystem: 'wake',
+                sourceEventType: 'wake.pr-auto-merge.enabled',
+                sourceRefs: {
+                    resourceUri: targetResourceUri,
+                    commentId: input.approvalResolution.triggeringCommentId,
+                },
+                occurredAt,
+                ingestedAt: occurredAt,
+                trigger: 'context-only',
+                payload: {
+                    idempotencyKey: `${input.approvalResolution.triggeringCommentId}:pr-auto-merge`,
+                },
+            }));
+        }
+    }
     // Closes the loop on #82's review feedback: rather than scrape a PR link
     // out of the agent's free text, the agent emits a `wake-artifacts` fence
     // (domain/schema.ts's parseRunnerArtifacts) and Wake verifies each claim
@@ -656,6 +852,27 @@ export function createTickRunner(deps) {
                         promptContextOverrides = workflowAction?.promptContext;
                     }
                     else if (approvalResolution.approved) {
+                        const mergePolicy = approvedMergePolicyForStage(workflow.stages[candidate.wake.stage]);
+                        if (approvalResolution.targetResourceUri !== undefined && mergePolicy !== null) {
+                            const risk = await evaluatePrMergeRisk({
+                                projection: candidate,
+                                targetResourceUri: approvalResolution.targetResourceUri,
+                                policy: mergePolicy,
+                            });
+                            if (!risk.passed) {
+                                return await publishPrMergePolicyBlock({
+                                    projection: candidate,
+                                    approvalResolution,
+                                    reason: risk.reason,
+                                    workflowName,
+                                });
+                            }
+                            await performApprovedPrMergeActions({
+                                projection: candidate,
+                                approvalResolution,
+                                mergePolicy,
+                            });
+                        }
                         const approvalId = `approval-${candidate.issue.number}-${deps.clock.now().getTime()}`;
                         const approvedAt = deps.clock.now().toISOString();
                         const automaticApproval = approvalResolution.automatic === true;
@@ -684,7 +901,11 @@ export function createTickRunner(deps) {
                                 nextStage,
                                 runId: approvalId,
                                 reason: automaticApproval ? 'auto:approved' : 'human:approved',
-                                ...(automaticApproval ? {} : { handledCommentId: latestHumanCommentId(candidate) }),
+                                ...(automaticApproval
+                                    ? {}
+                                    : {
+                                        handledCommentId: approvalResolution.triggeringCommentId ?? latestHumanCommentId(candidate),
+                                    }),
                                 ...(automaticApproval
                                     ? {
                                         autoResolution: {

package/dist/src/domain/schema.js

@@ -377,6 +377,20 @@ const workflowWorkspaceSchema = z.enum(['none', 'read-only', 'branch']);
 const workflowTriggerScheduleSchema = z.object({
     cron: z.string().min(1),
 });
+const approvedMergePolicySchema = z
+    .object({
+    approve: z.boolean().default(false),
+    autoMerge: z.boolean().default(false),
+    maxFilesChanged: z.number().int().positive().optional(),
+    blockedPaths: z.array(z.string().min(1)).default([]),
+    blockedLabels: z.array(z.string().min(1)).default([]),
+})
+    .default({
+    approve: false,
+    autoMerge: false,
+    blockedPaths: [],
+    blockedLabels: [],
+});
 const workflowStageSchema = stageRouteSchema.extend({
     workspace: workflowWorkspaceSchema,
     onDone: identifierSchema,
@@ -392,6 +406,11 @@ const workflowStageSchema = stageRouteSchema.extend({
             .optional(),
         schedule: workflowTriggerScheduleSchema.optional(),
         workflow: identifierSchema,
+        onApproved: z
+            .object({
+            merge: approvedMergePolicySchema.optional(),
+        })
+            .optional(),
     }))
         .optional(),
 });

package/dist/src/main.js

@@ -19,6 +19,7 @@ import { createGitHubArtifactVerifier } from './adapters/github/github-artifact-
 import { createGitHubClient } from './adapters/github/github-client.js';
 import { createGitHubIssuesWorkSource } from './adapters/github/github-issues-work-source.js';
 import { createGitHubPullRequestActivitySource } from './adapters/github/github-pull-request-activity-source.js';
+import { createGitHubPullRequestMergeActor } from './adapters/github/github-pull-request-merge-actor.js';
 import { runAuditCommand } from './cli/audit-command.js';
 import { runCorrelateCommand } from './cli/correlate-command.js';
 import { runDoctorCommand } from './cli/doctor-command.js';
@@ -497,6 +498,9 @@ export async function buildRuntime(args) {
     const artifactVerifier = prTrackingEnabled && githubClient !== undefined
         ? createGitHubArtifactVerifier({ client: githubClient })
         : undefined;
+    const prMergeActor = prTrackingEnabled && githubClient !== undefined
+        ? createGitHubPullRequestMergeActor({ client: githubClient })
+        : undefined;
     const ticketingSystem = githubClient !== undefined
         ? createGitHubIssuesWorkSource({
             client: githubClient,
@@ -577,6 +581,7 @@ export async function buildRuntime(args) {
         workspaceManager,
         resourceIndex,
         ...(artifactVerifier === undefined ? {} : { artifactVerifier }),
+        ...(prMergeActor === undefined ? {} : { prMergeActor }),
     });
     return {
         config,

package/dist/src/version.js

@@ -124,4 +124,4 @@ export function resolveWakeVersion(options = {}) {
     }
     return '0.1.0-dev';
 }
-export const wakeVersion = "g45197ea";
+export const wakeVersion = "gc00f4ed";

package/package.json

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