opencode-magi 0.9.0 → 0.11.0

package/dist/tools/review/action.js

@@ -0,0 +1,429 @@
+import { MagiError } from "@/magi";
+import { Prompt } from "@/prompts";
+import { command, filterEmpty, isArray, isObject, isString, loop, marker, omitNullish, quote, retry, wait, Worker, } from "@/utils";
+const events = {
+    APPROVED: "APPROVE",
+    CHANGES_REQUESTED: "REQUEST_CHANGES",
+    CLOSED: "COMMENT",
+};
+const mergeWorker = new Worker(1);
+export async function postReviews() {
+    this.context.abort.throwIfAborted();
+    if (this.state.dryRun)
+        return;
+    await this.updateEvent(`Posting reviews.`);
+    if (!this.config.review.reviewers?.length)
+        throw new MagiError("blocked", "No reviewers configured.");
+    if (!this.state.reviewers)
+        throw new MagiError("blocked", "Reviewers not found.");
+    const args = {
+        owner: this.config.github.owner,
+        pull_number: this.number,
+        repo: this.config.github.repo,
+    };
+    if (this.config.mode === "single") {
+        if (!this.state.pr?.verdict)
+            throw new MagiError("blocked", "PR verdict not found.");
+        const octokit = await this.magi.createOctokit(this.config, this.context.abort, this.config.account);
+        const graphql = this.magi.createGraphql(octokit);
+        const reviewers = Object.entries(this.state.reviewers).filter(([, { status }]) => status !== "skip");
+        await Promise.all(reviewers.flatMap(([, { outputs }]) => (outputs?.at(-1)?.resolves ?? []).map(({ threadId }) => graphql.resolveReviewThread({ threadId }))));
+        await Promise.all(reviewers.flatMap(([, { outputs }]) => (outputs?.at(-1)?.followUps ?? []).map(({ body, commentId }) => octokit.rest.pulls.createReplyForReviewComment({
+            ...args,
+            body,
+            comment_id: commentId,
+        }))));
+        const event = events[this.state.pr.verdict];
+        const params = { ...args, event };
+        if (this.state.pr.verdict === "CHANGES_REQUESTED") {
+            const findings = reviewers.flatMap(([id, { outputs }]) => {
+                const output = outputs?.at(-1);
+                return (output?.findings ?? output?.newFindings ?? [])
+                    .filter(({ state }) => state === "accepted")
+                    .map((finding) => ({ ...finding, id }));
+            });
+            if (!findings.length) {
+                await this.updateEvent(`Finished posting reviews.`);
+                return;
+            }
+            params.comments = findings.map(({ body, id, line, path, startLine }) => ({
+                body: [
+                    body,
+                    marker.stringify({ command: "review", reviewer: id }),
+                ].join("\n\n"),
+                line,
+                path,
+                ...(startLine == null
+                    ? {}
+                    : { start_line: startLine, start_side: "RIGHT" }),
+            }));
+        }
+        if (this.state.pr.verdict !== "APPROVED") {
+            if (!this.state.operator?.sessionId)
+                throw new MagiError("blocked", "Reporter session ID not found.");
+            await this.updateEvent(`Generating comment by operator.`);
+            const contents = JSON.stringify(reviewers.flatMap(([, { outputs }]) => {
+                const output = outputs?.at(-1);
+                if (!output || output.verdict === "APPROVED")
+                    return [];
+                if (output.verdict === "CLOSED")
+                    return [output.comment];
+                else
+                    return (output.findings ?? output.newFindings ?? []).filter(({ state }) => state === "accepted");
+            }), null, 2);
+            const prompt = await Prompt.init(this.magi, this.config, "review/comment");
+            const taskMessage = await prompt.create(undefined, ["output_contract", ["contents", contents]], {
+                owner: this.config.github.owner,
+                pr: this.number.toString(),
+                repo: this.config.github.repo,
+                verdict: this.state.pr.verdict,
+            });
+            const output = await retry(async (count, e) => {
+                const raw = await this.magi.promptSession(this.state.operator.sessionId, count === 1 ? taskMessage : await prompt.repair(e), this.context.abort);
+                await this.createAgentFile("comment", "operator", raw, count);
+                const parsed = prompt.parse(raw);
+                if (!prompt.validate(parsed))
+                    throw new Error("Invalid output for operator.");
+                return parsed.comment;
+            }, {
+                error: async (e, count) => {
+                    if (e instanceof MagiError)
+                        throw e;
+                    await this.updateEvent(`Attempt ${count} failed to post comment by operator. Retrying...`);
+                },
+                retries: this.config.output.repairAttempts,
+                signal: this.context.abort,
+            });
+            if (!output)
+                throw new MagiError("blocked", "Invalid output for operator.");
+            await this.updateEvent(`Generated comment by operator.`);
+            params.body = output;
+        }
+        params.body = [
+            params.body ?? "",
+            marker.stringify(...filterEmpty(reviewers.map(([id, { outputs }]) => {
+                const output = outputs?.at(-1);
+                if (!output)
+                    return;
+                const body = output.comment
+                    ? encodeURIComponent(output.comment)
+                    : undefined;
+                return omitNullish({
+                    body,
+                    command: "review",
+                    reviewer: id,
+                    verdict: output.verdict,
+                });
+            }))),
+        ].join("\n\n");
+        const { data } = await octokit.rest.pulls.createReview(params);
+        const posted = data.html_url;
+        await this.updateState({
+            reviewers: Object.fromEntries(Object.keys(this.state.reviewers).map((id) => [id, { posted }])),
+        });
+        await this.updateEvent(`Finished posting reviews.`);
+    }
+    else {
+        const worker = new Worker(this.config.review.concurrency.reviewers);
+        const reviewers = Object.fromEntries(await Promise.all(Object.entries(this.state.reviewers).map(([id, { account, outputs, review, status }]) => worker.run(async () => {
+            if (status === "skip")
+                return [id, { posted: review?.html_url }];
+            const output = outputs?.at(-1);
+            if (!output)
+                throw new MagiError("blocked", "Reviewer output not found.");
+            const octokit = await this.magi.createOctokit(this.config, this.context.abort, account);
+            const graphql = this.magi.createGraphql(octokit);
+            await Promise.all((output.resolves ?? []).map(({ threadId }) => graphql.resolveReviewThread({ threadId })));
+            await Promise.all((output.followUps ?? []).map(({ body, commentId }) => octokit.rest.pulls.createReplyForReviewComment({
+                ...args,
+                body,
+                comment_id: commentId,
+            })));
+            const event = events[output.verdict];
+            const params = { ...args, event };
+            if (output.verdict !== "APPROVED")
+                params.body = output.comment;
+            if (output.verdict === "CHANGES_REQUESTED") {
+                const findings = (output.findings ??
+                    output.newFindings ??
+                    []).filter(({ state }) => state === "accepted");
+                if (!findings.length)
+                    return [id, {}];
+                params.comments = findings.map(({ body, line, path, startLine }) => ({
+                    body,
+                    line,
+                    path,
+                    ...(startLine == null
+                        ? {}
+                        : { start_line: startLine, start_side: "RIGHT" }),
+                }));
+            }
+            params.body = [
+                params.body ?? "",
+                marker.stringify({
+                    command: "review",
+                    reviewer: id,
+                    verdict: output.verdict,
+                }),
+            ].join("\n\n");
+            const { data } = await octokit.rest.pulls.createReview(params);
+            return [id, { posted: data.html_url }];
+        }))));
+        await this.updateState({ reviewers });
+        await this.updateEvent(`Finished posting reviews.`);
+    }
+}
+export async function automate() {
+    this.context.abort.throwIfAborted();
+    if (!this.state.pr?.metadata)
+        throw new MagiError("blocked", "PR metadata not found.");
+    if (!this.state.pr.verdict)
+        throw new MagiError("blocked", "PR verdict not found.");
+    if (!["APPROVED", "CLOSED"].includes(this.state.pr.verdict))
+        return "SKIPPED";
+    const automation = this.config[this.state.command].automation;
+    const action = this.state.pr.verdict === "APPROVED" ? "merge" : "close";
+    if (!automation[action]) {
+        await this.updateState({ pr: { automation: "SKIPPED" } });
+        await this.updateEvent(`Skipped ${action} automation.`);
+        return "SKIPPED";
+    }
+    const account = this.state.operator.account;
+    if (action === "merge") {
+        if (!this.state.pr.checks)
+            throw new MagiError("blocked", "PR checks not found.");
+        const failed = this.state.pr.checks.failed;
+        const pending = this.state.pr.checks.pending;
+        if (failed.length || pending.length) {
+            await this.updateState({ pr: { automation: "SKIPPED" } });
+            await this.updateEvent(`Skipped merge automation because unresolved CI checks remain.`);
+            return "SKIPPED";
+        }
+        if (await isConflict.call(this)) {
+            await this.updateState({ pr: { automation: "CONFLICT" } });
+            await this.updateEvent(`Merge automation found conflicts.`);
+            return "CONFLICT";
+        }
+    }
+    if (this.state.dryRun) {
+        await this.updateState({ pr: { automation: "SKIPPED" } });
+        await this.updateEvent(`Skipped ${action} automation during dry run.`);
+        return "SKIPPED";
+    }
+    const token = await this.magi.getGhToken(account, this.context.abort);
+    if (action === "merge" && !this.config.review.merge.queue) {
+        const rules = JSON.parse(await this.exec(command("gh", "api", quote(`repos/${this.config.github.owner}/${this.config.github.repo}/rules/branches/${this.state.pr.metadata.base.ref}`)), {
+            env: { GH_TOKEN: token },
+            signal: this.context.abort,
+        }));
+        if (isArray(rules)) {
+            const enabledMergeQueue = rules.some((rule) => !!rule &&
+                isObject(rule) &&
+                "type" in rule &&
+                rule.type === "merge_queue");
+            if (enabledMergeQueue)
+                throw new MagiError("blocked", `Base branch \`${this.state.pr.metadata.base.ref}\` requires merge queue, but \`review.merge.queue\` is \`false\`. Enable \`review.merge.queue\` or target a branch without merge queue.`);
+        }
+    }
+    if (action !== "merge" || this.config.review.merge.queue)
+        await this.updateEvent(`${action === "merge" ? "Merging" : "Closing"}.`);
+    else
+        await this.updateEvent(`Waiting to merge.`);
+    if (action === "merge" && this.config.review.merge.queue) {
+        const octokit = await this.magi.createOctokit(this.config, this.context.abort, account);
+        const graphql = this.magi.createGraphql(octokit);
+        const enqueuedAt = new Date().toISOString();
+        await graphql.enqueuePullRequest({ id: this.state.pr.metadata.node_id });
+        await this.updateEvent(`Waiting for merge queue.`);
+        const result = await waitMergeQueue.call(this, enqueuedAt);
+        if (result === "CONFLICT")
+            return result;
+    }
+    else {
+        const prefix = ["gh", "pr"];
+        const suffix = [this.number.toString(), "--repo", this.state.repo];
+        const args = [...prefix, action, ...suffix];
+        if (action === "merge") {
+            if (this.config.review.merge.method === "merge")
+                args.push("--merge");
+            if (this.config.review.merge.method === "rebase")
+                args.push("--rebase");
+            if (this.config.review.merge.method === "squash")
+                args.push("--squash");
+            if (this.config.review.merge.auto)
+                args.push("--auto");
+            if (this.config.review.merge.deleteBranch)
+                args.push("--delete-branch");
+        }
+        const options = { env: { GH_TOKEN: token }, signal: this.context.abort };
+        const waitMerge = async () => {
+            return await loop(async () => {
+                this.context.abort.throwIfAborted();
+                const data = await this.exec(command(...prefix, "view", ...suffix, "--json", "autoMergeRequest,mergeStateStatus,state,statusCheckRollup"), options);
+                const { autoMergeRequest: auto, mergeStateStatus: status, state, statusCheckRollup: checks, } = JSON.parse(data);
+                if (state === "MERGED")
+                    return "MERGED";
+                if (status === "DIRTY")
+                    return "CONFLICT";
+                if (status === "BEHIND") {
+                    await this.updateEvent(`Updating with the base branch before merging.`);
+                    await this.exec(command(...prefix, "update-branch", ...suffix), options);
+                    return;
+                }
+                if (status === "BLOCKED" && hasFailedChecks(checks))
+                    throw new MagiError("blocked", `Required checks failed before merging.`);
+                if (!auto && state === "OPEN")
+                    throw new MagiError("blocked", `Auto-merge is no longer enabled.`);
+            }, 30_000);
+        };
+        const runAutomation = async () => {
+            try {
+                await this.updateEvent(`Merging.`);
+                await this.exec(command(...args), options);
+                if (action === "merge" && this.config.review.merge.auto) {
+                    const result = await waitMerge();
+                    if (result === "CONFLICT") {
+                        await this.updateState({ pr: { automation: "CONFLICT" } });
+                        await this.updateEvent(`Merge automation found conflicts.`);
+                        return "CONFLICT";
+                    }
+                }
+            }
+            catch (e) {
+                const message = e instanceof Error ? e.message : String(e);
+                if (action !== "merge")
+                    throw e;
+                switch (true) {
+                    case /\bconflicts?\b|merge commit cannot be cleanly created/i.test(message):
+                        await this.updateState({ pr: { automation: "CONFLICT" } });
+                        await this.updateEvent(`Merge automation found conflicts.`);
+                        return "CONFLICT";
+                    case /head (branch|ref) is (not up to date|out of date)/i.test(message):
+                        await this.updateEvent(`Updating with the base branch before merging.`);
+                        await this.exec(command(...prefix, "update-branch", ...suffix), options);
+                        await this.exec(command(...args), options);
+                        if (this.config.review.merge.auto) {
+                            const result = await waitMerge();
+                            if (result === "CONFLICT") {
+                                await this.updateState({ pr: { automation: "CONFLICT" } });
+                                await this.updateEvent(`Merge automation found conflicts.`);
+                                return "CONFLICT";
+                            }
+                        }
+                        break;
+                    default:
+                        throw e;
+                }
+            }
+        };
+        const result = action === "merge"
+            ? await mergeWorker.run(runAutomation)
+            : await runAutomation();
+        if (result)
+            return result;
+    }
+    await this.updateState({
+        pr: { automation: action === "merge" ? "MERGED" : "CLOSED" },
+    });
+    await this.updateEvent(`Finished ${action} automation.`);
+    return action === "merge" ? "MERGED" : "CLOSED";
+}
+function hasFailedChecks(checks) {
+    if (!isArray(checks))
+        return false;
+    const latest = checks.reduce((prev, check) => {
+        if (!isObject(check))
+            return prev;
+        const key = [check.workflowName, check.name, check.context]
+            .filter(isString)
+            .join("/");
+        if (!key)
+            return prev;
+        const current = prev.get(key);
+        if (!current || getCheckTime(check) >= getCheckTime(current))
+            prev.set(key, check);
+        return prev;
+    }, new Map());
+    return [...latest.values()].some(isFailedCheck);
+}
+function isFailedCheck(check) {
+    const regexp = /failure|failed|error|cancelled|timed_out|action_required/i;
+    return ["conclusion", "state", "status"].some((key) => isString(check[key]) && regexp.test(check[key]));
+}
+function getCheckTime(check) {
+    return ["startedAt", "completedAt", "updatedAt"].reduce((prev, key) => {
+        const value = check[key];
+        if (!isString(value))
+            return prev;
+        const time = Date.parse(value);
+        return Number.isNaN(time) ? prev : Math.max(prev, time);
+    }, 0);
+}
+async function waitMergeQueue(enqueuedAt, leftMergeQueue = false, retries = 0) {
+    this.context.abort.throwIfAborted();
+    if (!this.state.pr?.metadata)
+        throw new MagiError("blocked", "PR metadata not found.");
+    const { repository } = await this.graphql.mergeQueueStatus({
+        owner: this.config.github.owner,
+        pr: this.number,
+        repo: this.config.github.repo,
+    });
+    if (!repository?.pullRequest)
+        throw new MagiError("blocked", "Could not fetch merge queue status.");
+    const { isInMergeQueue, mergeQueueEntry, state, timelineItems } = repository.pullRequest;
+    if (state === "MERGED")
+        return "MERGED";
+    const nextLeftMergeQueue = state === "OPEN" && !isInMergeQueue && !mergeQueueEntry;
+    if (leftMergeQueue && nextLeftMergeQueue) {
+        if (await isConflict.call(this)) {
+            await this.updateState({ pr: { automation: "CONFLICT" } });
+            await this.updateEvent("Merge automation found conflicts.");
+            return "CONFLICT";
+        }
+        const removedFromQueue = timelineItems.nodes?.at(-1);
+        if (removedFromQueue?.reason === "failed_checks" &&
+            Date.parse(removedFromQueue.createdAt) >= Date.parse(enqueuedAt)) {
+            if (retries >= this.config.review.checks.retryFailedJobs)
+                throw new MagiError("blocked", `PR left the merge queue after failed checks exceeded ${retries} retries.`);
+            const attempt = retries + 1;
+            const nextEnqueuedAt = new Date().toISOString();
+            await this.updateEvent(`Attempt ${attempt} failed to merge from the merge queue. Retrying...`);
+            await this.graphql.enqueuePullRequest({
+                id: this.state.pr.metadata.node_id,
+            });
+            return await waitMergeQueue.call(this, nextEnqueuedAt, false, attempt);
+        }
+        throw new MagiError("blocked", `PR left the merge queue before merging.`);
+    }
+    await wait(30_000, this.context.abort);
+    return await waitMergeQueue.call(this, enqueuedAt, nextLeftMergeQueue, retries);
+}
+async function isConflict() {
+    if (!this.state.worktree)
+        return false;
+    if (!this.state.pr?.metadata)
+        throw new MagiError("blocked", "PR metadata not found.");
+    const options = { cwd: this.state.worktree.path, signal: this.context.abort };
+    const status = await this.exec(command("git", "status", "--porcelain"), options);
+    if (status)
+        throw new MagiError("blocked", "PR worktree has uncommitted changes.");
+    await this.exec(command("git", "fetch", "--no-tags", quote(this.state.pr.metadata.base.repo.clone_url), quote(`refs/heads/${this.state.pr.metadata.base.ref}`)), options);
+    try {
+        try {
+            await this.exec(command("git", "merge", "--no-commit", "--no-ff", "FETCH_HEAD"), options);
+        }
+        catch (e) {
+            const conflicts = await this.exec(command("git", "diff", "--name-only", "--diff-filter=U"), options);
+            if (!conflicts)
+                throw e;
+            return true;
+        }
+    }
+    finally {
+        try {
+            await this.exec(command("git", "merge", "--abort"), options);
+        }
+        catch { }
+    }
+    return false;
+}