@atolis-hq/wake 0.2.97 → 0.3.0

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

@@ -1,584 +0,0 @@
-import { buildResourceUri } from '../../domain/resource-uri.js';
-import { createUnkeyedEventEnvelope, createEventEnvelope } from '../../lib/event-log.js';
-import { formatGitHubError, formatWakeComment, readControlPlaneUiUrl, wakeIdempotencyMarker, } from './github-issues-work-source.js';
-const githubPrSource = 'github-pr';
-const wakeCommentMarker = '<!-- wake:agent -->';
-function prResourceUri(repo, number) {
-    return buildResourceUri('github', 'pr', `${repo}#${number}`);
-}
-function reviewThreadRootId(comment, byId) {
-    let current = comment;
-    const visited = new Set();
-    while (current.in_reply_to_id !== undefined && !visited.has(current.id)) {
-        visited.add(current.id);
-        const parent = byId.get(current.in_reply_to_id);
-        if (parent === undefined) {
-            break;
-        }
-        current = parent;
-    }
-    return current.id;
-}
-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
-// `User`, not `Bot` — checking only those two would let the agent's own
-// replies look human and re-trigger another run against themselves (#258
-// follow-up incident: 99 duplicate replies from exactly this gap). Optional
-// because it's undefined when the GitHub client is a fake/test double.
-function isBotAuthored(comment, selfLogin) {
-    return (comment.user?.type === 'Bot' ||
-        (comment.body ?? '').includes(wakeCommentMarker) ||
-        (selfLogin !== undefined && comment.user?.login === selfLogin));
-}
-export function createGitHubPullRequestActivitySource(deps) {
-    function repoAndNumberFromPrUri(resourceUri) {
-        // github:pr:<owner>/<repo>#<number>
-        const locator = resourceUri.split(':').slice(2).join(':');
-        const match = /^([^/]+)\/([^#]+)#(\d+)$/.exec(locator);
-        if (match === null) {
-            return null;
-        }
-        const [, owner, repo, numberStr] = match;
-        if (owner === undefined || repo === undefined || numberStr === undefined) {
-            return null;
-        }
-        return { owner, repo, repoRef: `${owner}/${repo}`, number: Number(numberStr) };
-    }
-    function reviewThreadRefFromUri(resourceUri) {
-        const locator = resourceUri.split(':').slice(2).join(':');
-        const match = /^([^/]+)\/([^#]+)#(\d+)\/rt_(\d+)$/.exec(locator);
-        if (match === null) {
-            return null;
-        }
-        const [, owner, repo, numberStr, rootIdStr] = match;
-        if (owner === undefined ||
-            repo === undefined ||
-            numberStr === undefined ||
-            rootIdStr === undefined) {
-            return null;
-        }
-        return {
-            owner,
-            repo,
-            repoRef: `${owner}/${repo}`,
-            number: Number(numberStr),
-            rootId: Number(rootIdStr),
-        };
-    }
-    function prCommentPublishedEvent(input) {
-        return createEventEnvelope({
-            eventId: `${input.intent.eventId}-published`,
-            workItemKey: input.intent.workItemKey,
-            streamScope: 'work-item',
-            direction: 'outbound',
-            sourceSystem: githubPrSource,
-            sourceEventType: 'pr.comment.reply.published',
-            sourceRefs: { repo: input.repoRef, resourceUri: input.resourceUri },
-            occurredAt: input.publishedAt,
-            ingestedAt: input.publishedAt,
-            trigger: 'context-only',
-            payload: {
-                intentEventId: input.intent.eventId,
-                idempotencyKey: input.intent.payload.idempotencyKey,
-                deliveryState: 'CONFIRMED',
-                kind: input.intent.payload.kind,
-                body: input.intent.payload.body,
-                providerId: input.providerId,
-            },
-        });
-    }
-    function reviewCommentPublishedEvent(input) {
-        return createEventEnvelope({
-            eventId: `${input.intent.eventId}-published`,
-            workItemKey: input.intent.workItemKey,
-            streamScope: 'work-item',
-            direction: 'outbound',
-            sourceSystem: githubPrSource,
-            sourceEventType: 'pr.review-comment.reply.published',
-            sourceRefs: {
-                resourceUri: input.resourceUri,
-                sourceUrl: input.sourceUrl,
-            },
-            occurredAt: input.publishedAt,
-            ingestedAt: input.publishedAt,
-            trigger: 'context-only',
-            payload: {
-                intentEventId: input.intent.eventId,
-                idempotencyKey: input.intent.payload.idempotencyKey,
-                deliveryState: 'CONFIRMED',
-                kind: input.intent.payload.kind,
-                body: input.intent.payload.body,
-                providerId: input.providerId,
-            },
-        });
-    }
-    async function discoverPullRequests(ingestedAt) {
-        const seenPrData = new Map();
-        const confirmedOpenRepos = new Set();
-        if (!deps.config.sources.github.pullRequests.enabled) {
-            return { events: [], seenPrData, confirmedOpenRepos };
-        }
-        const events = [];
-        for (const repoRef of deps.config.sources.github.repos) {
-            const [owner, repo] = repoRef.split('/');
-            if (owner === undefined || repo === undefined) {
-                continue;
-            }
-            try {
-                const maxResults = deps.config.sources.github.pullRequests.maxPullRequestsPerRepo;
-                const prs = await deps.client.listPullRequests(owner, repo, maxResults);
-                // listPullRequests only ever returns open PRs (state: 'open'), so an
-                // uncapped result set here is a complete picture of what's currently
-                // open — used below to confirm a watched PR has actually closed
-                // rather than merely being truncated by maxResults.
-                if (prs.length < maxResults) {
-                    confirmedOpenRepos.add(repoRef);
-                }
-                for (const pr of prs) {
-                    const resourceUri = prResourceUri(repoRef, pr.number);
-                    seenPrData.set(resourceUri, {
-                        headSha: pr.head.sha,
-                        baseRef: pr.base?.ref,
-                        htmlUrl: pr.html_url,
-                    });
-                    const known = await deps.resourceIndex.resolve(resourceUri);
-                    if (known !== undefined) {
-                        continue;
-                    }
-                    events.push(createUnkeyedEventEnvelope({
-                        // Embeds updated_at (mirroring the issue path's ticket.upsert
-                        // eventId) so a PR that fails mint qualification is re-offered
-                        // for qualification whenever it actually changes — not
-                        // permanently quarantined under UNRESOLVED_WORK_ITEM_KEY the
-                        // first time it's seen, even after config or the PR itself
-                        // changes. appendEventEnvelope still dedups on eventId, so an
-                        // unchanged PR is only ever appended once per updated_at value.
-                        eventId: `pr-seen-${repoRef.replace(/[^a-z0-9]+/gi, '-')}-${pr.number}-${pr.updated_at}`,
-                        streamScope: 'global-intake',
-                        direction: 'inbound',
-                        sourceSystem: githubPrSource,
-                        sourceEventType: 'pr.seen',
-                        sourceRefs: { repo: repoRef, sourceUrl: pr.html_url, resourceUri },
-                        occurredAt: pr.updated_at,
-                        ingestedAt,
-                        trigger: 'context-only',
-                        payload: {
-                            pr: {
-                                number: pr.number,
-                                author: pr.user?.login ?? 'unknown',
-                                headRef: pr.head.ref,
-                            },
-                        },
-                    }));
-                }
-            }
-            catch (error) {
-                console.error(`[github-pr-activity-source] discovery failed for ${repoRef}, skipping this tick: ${formatGitHubError(error)}`);
-            }
-        }
-        return { events, seenPrData, confirmedOpenRepos };
-    }
-    async function pollWatchedPr(resourceUri, ingestedAt) {
-        if (!deps.config.sources.github.pullRequests.enabled) {
-            return [];
-        }
-        const ref = repoAndNumberFromPrUri(resourceUri);
-        if (ref === null) {
-            return [];
-        }
-        const events = [];
-        const perPage = deps.config.sources.github.pullRequests.commentPageSize;
-        try {
-            const comments = await deps.client.listComments(ref.owner, ref.repo, ref.number, perPage);
-            for (const comment of comments) {
-                events.push(createUnkeyedEventEnvelope({
-                    eventId: `pr-comment-${ref.repoRef}-${ref.number}-${comment.id}-${comment.updated_at}`,
-                    streamScope: 'work-item',
-                    direction: 'inbound',
-                    sourceSystem: githubPrSource,
-                    sourceEventType: 'pr.comment.created',
-                    sourceRefs: {
-                        repo: ref.repoRef,
-                        commentId: String(comment.id),
-                        sourceUrl: comment.html_url,
-                        resourceUri,
-                    },
-                    occurredAt: comment.updated_at,
-                    ingestedAt,
-                    trigger: 'context-only',
-                    payload: {
-                        comment: {
-                            id: `pr-${comment.id}`,
-                            body: comment.body ?? '',
-                            author: { login: comment.user?.login ?? 'unknown' },
-                            createdAt: comment.created_at,
-                            updatedAt: comment.updated_at,
-                            resourceUri,
-                        },
-                    },
-                    derivedHints: { botAuthoredComment: isBotAuthored(comment, deps.selfLogin) },
-                }));
-            }
-            const reviews = await deps.client.listReviews(ref.owner, ref.repo, ref.number, perPage);
-            for (const review of reviews) {
-                // GitHub allows submitting a review (e.g. "Request changes" or
-                // "Approve") with no comment text — skipping those entirely would
-                // lose the state-change signal itself, not just a missing comment,
-                // so a bare state marker is still emitted.
-                const body = (review.body ?? '').trim();
-                const submittedAt = review.submitted_at ?? ingestedAt;
-                events.push(createUnkeyedEventEnvelope({
-                    eventId: `pr-review-${ref.repoRef}-${ref.number}-${review.id}`,
-                    streamScope: 'work-item',
-                    direction: 'inbound',
-                    sourceSystem: githubPrSource,
-                    sourceEventType: 'pr.review.created',
-                    sourceRefs: {
-                        repo: ref.repoRef,
-                        commentId: `review-${review.id}`,
-                        sourceUrl: review.html_url,
-                        resourceUri,
-                    },
-                    occurredAt: submittedAt,
-                    ingestedAt,
-                    trigger: 'context-only',
-                    payload: {
-                        comment: {
-                            id: `pr-review-${review.id}`,
-                            body: body.length === 0 ? `[${review.state}]` : `[${review.state}] ${body}`,
-                            author: { login: review.user?.login ?? 'unknown' },
-                            createdAt: submittedAt,
-                            updatedAt: submittedAt,
-                            resourceUri,
-                        },
-                    },
-                    derivedHints: { botAuthoredComment: isBotAuthored(review, deps.selfLogin) },
-                }));
-            }
-            const reviewComments = await deps.client.listReviewComments(ref.owner, ref.repo, ref.number, perPage);
-            const byId = new Map(reviewComments.map((c) => [c.id, c]));
-            for (const comment of reviewComments) {
-                const rootId = reviewThreadRootId(comment, byId);
-                const threadUri = reviewThreadResourceUri(ref.repoRef, ref.number, rootId);
-                events.push(createUnkeyedEventEnvelope({
-                    eventId: `pr-review-comment-${ref.repoRef}-${ref.number}-${comment.id}-${comment.updated_at}`,
-                    streamScope: 'work-item',
-                    direction: 'inbound',
-                    sourceSystem: githubPrSource,
-                    sourceEventType: 'pr.review-comment.created',
-                    sourceRefs: {
-                        repo: ref.repoRef,
-                        commentId: String(comment.id),
-                        sourceUrl: comment.html_url,
-                        resourceUri: threadUri,
-                        // The thread's own resourceUri is never registered on its own
-                        // (each thread is unique), so core falls back to resolving via
-                        // the owning PR when this misses the index on first sighting.
-                        parentResourceUri: resourceUri,
-                    },
-                    occurredAt: comment.updated_at,
-                    ingestedAt,
-                    trigger: 'context-only',
-                    payload: {
-                        comment: {
-                            id: `pr-review-comment-${comment.id}`,
-                            body: comment.body ?? '',
-                            author: { login: comment.user?.login ?? 'unknown' },
-                            createdAt: comment.created_at,
-                            updatedAt: comment.updated_at,
-                            resourceUri: threadUri,
-                            reviewThread: {
-                                path: comment.path,
-                                line: comment.line ?? comment.original_line ?? undefined,
-                            },
-                        },
-                    },
-                    derivedHints: { botAuthoredComment: isBotAuthored(comment, deps.selfLogin) },
-                }));
-            }
-        }
-        catch (error) {
-            console.error(`[github-pr-activity-source] activity poll failed for ${resourceUri}, skipping this tick: ${formatGitHubError(error)}`);
-        }
-        return events;
-    }
-    async function pollRequiredCheckFailures(ref, resourceUri, ingestedAt, cachedPr) {
-        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 [];
-        }
-        // headSha/baseRef/htmlUrl are already returned by this tick's PR
-        // discovery pass (listPullRequests) — reuse that instead of spending a
-        // dedicated getPullRequest call per watched PR. Falls back only when the
-        // watched PR wasn't present in discovery (e.g. truncated by
-        // maxPullRequestsPerRepo, or pullRequests polling failed this tick).
-        let headSha;
-        let baseRef;
-        let htmlUrl;
-        if (cachedPr?.headSha !== undefined && cachedPr.baseRef !== undefined) {
-            headSha = cachedPr.headSha;
-            baseRef = cachedPr.baseRef;
-            htmlUrl = cachedPr.htmlUrl;
-        }
-        else {
-            const pr = await deps.client.getPullRequest(ref.owner, ref.repo, ref.number);
-            headSha = pr.head.sha;
-            baseRef = pr.base?.ref;
-            htmlUrl = pr.html_url;
-        }
-        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 ?? htmlUrl;
-            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 ?? htmlUrl,
-                    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 { events: discovered, seenPrData, confirmedOpenRepos, } = await discoverPullRequests(ingestedAt);
-            // A watched PR absent from this tick's complete open-PR listing has
-            // closed or merged — stop spending its 7 activity/checks calls every
-            // tick. `confirmedOpenRepos` only covers repos where discovery
-            // succeeded and wasn't truncated, so an untruncated miss or a failed
-            // repo poll leaves the PR in the active set rather than risking a
-            // false drop.
-            const activeWatched = watched.filter((ref) => {
-                const parsed = repoAndNumberFromPrUri(ref.resourceUri);
-                if (parsed === null) {
-                    return true;
-                }
-                return !confirmedOpenRepos.has(parsed.repoRef) || seenPrData.has(ref.resourceUri);
-            });
-            const activityBatches = await Promise.all(activeWatched.map((ref) => pollWatchedPr(ref.resourceUri, ingestedAt)));
-            const checkBatches = await Promise.all(activeWatched.map(async (watchRef) => {
-                const ref = repoAndNumberFromPrUri(watchRef.resourceUri);
-                if (ref === null) {
-                    return [];
-                }
-                try {
-                    return await pollRequiredCheckFailures(ref, watchRef.resourceUri, ingestedAt, seenPrData.get(watchRef.resourceUri));
-                }
-                catch (error) {
-                    console.error(`[github-pr-activity-source] check poll failed for ${watchRef.resourceUri}, skipping this tick: ${formatGitHubError(error)}`);
-                    return [];
-                }
-            }));
-            return [...discovered, ...activityBatches.flat(), ...checkBatches.flat()];
-        },
-        async deliverIntent(input) {
-            const resourceUri = input.event.sourceRefs.resourceUri;
-            if (resourceUri === undefined) {
-                throw new Error(`cannot deliver intent ${input.event.eventId}: missing sourceRefs.resourceUri`);
-            }
-            const publishedAt = deps.now().toISOString();
-            if (resourceUri.startsWith('github:pr-review-thread:')) {
-                const ref = reviewThreadRefFromUri(resourceUri);
-                if (ref === null) {
-                    throw new Error(`cannot deliver intent ${input.event.eventId}: malformed review-thread uri ${resourceUri}`);
-                }
-                const marker = wakeIdempotencyMarker(input.event.payload.idempotencyKey);
-                if (marker !== undefined) {
-                    const comments = await deps.client.listReviewComments(ref.owner, ref.repo, ref.number, deps.config.sources.github.pullRequests.commentPageSize);
-                    const existing = comments.find((comment) => (comment.body ?? '').includes(marker));
-                    if (existing !== undefined) {
-                        return [
-                            reviewCommentPublishedEvent({
-                                intent: input.event,
-                                resourceUri,
-                                sourceUrl: existing.html_url,
-                                publishedAt,
-                                providerId: existing.id,
-                            }),
-                        ];
-                    }
-                }
-                const response = await deps.client.replyToReviewComment(ref.owner, ref.repo, ref.number, ref.rootId, formatWakeComment(input.event.payload, await readControlPlaneUiUrl(deps.config.paths.wakeRoot)));
-                return [
-                    reviewCommentPublishedEvent({
-                        intent: input.event,
-                        resourceUri,
-                        sourceUrl: response?.html_url,
-                        publishedAt,
-                        providerId: response?.id,
-                    }),
-                ];
-            }
-            const ref = repoAndNumberFromPrUri(resourceUri);
-            if (ref === null) {
-                throw new Error(`cannot deliver intent ${input.event.eventId}: malformed pr uri ${resourceUri}`);
-            }
-            const marker = wakeIdempotencyMarker(input.event.payload.idempotencyKey);
-            if (marker !== undefined) {
-                const comments = await deps.client.listComments(ref.owner, ref.repo, ref.number, deps.config.sources.github.pullRequests.commentPageSize);
-                const existing = comments.find((comment) => (comment.body ?? '').includes(marker));
-                if (existing !== undefined) {
-                    return [
-                        prCommentPublishedEvent({
-                            intent: input.event,
-                            resourceUri,
-                            repoRef: ref.repoRef,
-                            publishedAt,
-                            providerId: existing.id,
-                        }),
-                    ];
-                }
-            }
-            const response = await deps.client.createComment(ref.owner, ref.repo, ref.number, formatWakeComment(input.event.payload, await readControlPlaneUiUrl(deps.config.paths.wakeRoot)));
-            return [
-                prCommentPublishedEvent({
-                    intent: input.event,
-                    resourceUri,
-                    repoRef: ref.repoRef,
-                    publishedAt,
-                    providerId: response?.data?.id,
-                }),
-            ];
-        },
-        async reconcileIntent(input) {
-            const resourceUri = input.event.sourceRefs.resourceUri;
-            const marker = wakeIdempotencyMarker(input.event.payload.idempotencyKey);
-            if (resourceUri === undefined || marker === undefined) {
-                return [];
-            }
-            const publishedAt = deps.now().toISOString();
-            if (resourceUri.startsWith('github:pr-review-thread:')) {
-                const ref = reviewThreadRefFromUri(resourceUri);
-                if (ref === null) {
-                    return [];
-                }
-                const comments = await deps.client.listReviewComments(ref.owner, ref.repo, ref.number, deps.config.sources.github.pullRequests.commentPageSize);
-                const existing = comments.find((comment) => (comment.body ?? '').includes(marker));
-                if (existing === undefined) {
-                    return [];
-                }
-                return [
-                    reviewCommentPublishedEvent({
-                        intent: input.event,
-                        resourceUri,
-                        sourceUrl: existing.html_url,
-                        publishedAt,
-                        providerId: existing.id,
-                    }),
-                ];
-            }
-            const ref = repoAndNumberFromPrUri(resourceUri);
-            if (ref === null) {
-                return [];
-            }
-            const comments = await deps.client.listComments(ref.owner, ref.repo, ref.number, deps.config.sources.github.pullRequests.commentPageSize);
-            const existing = comments.find((comment) => (comment.body ?? '').includes(marker));
-            if (existing === undefined) {
-                return [];
-            }
-            return [
-                prCommentPublishedEvent({
-                    intent: input.event,
-                    resourceUri,
-                    repoRef: ref.repoRef,
-                    publishedAt,
-                    providerId: existing.id,
-                }),
-            ];
-        },
-    };
-}

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

@@ -1,45 +0,0 @@
-// GitHub's enablePullRequestAutoMerge mutation queues a merge pending
-// required checks; it refuses with an "already in clean status" error when
-// there's nothing left to wait for (checks already passed/skipped). That's
-// not a policy rejection — it just means the direct merge endpoint is the
-// right call instead of the auto-merge queue.
-function isAlreadyCleanError(error) {
-    return error instanceof Error && /is in clean status/i.test(error.message);
-}
-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, mergeMethod) {
-            const ref = parseGithubPullRequestResourceUri(resourceUri);
-            const pr = await input.client.getPullRequest(ref.owner, ref.repo, ref.pullNumber);
-            try {
-                await input.client.enablePullRequestAutoMerge(pr.node_id, mergeMethod);
-            }
-            catch (error) {
-                if (!isAlreadyCleanError(error)) {
-                    throw error;
-                }
-                await input.client.mergePullRequest(ref.owner, ref.repo, ref.pullNumber, mergeMethod);
-            }
-        },
-    };
-}