opencode-magi 0.9.0 → 0.11.0

package/dist/tools/review/check.js

@@ -0,0 +1,295 @@
+import picomatch from "picomatch";
+import { MagiError } from "@/magi";
+import { Prompt } from "@/prompts";
+import { command, filterEmpty, isNumber, omitNullish, quote, retry, Worker, } from "@/utils";
+const ci = {
+    isExcluded(exclude, { name }) {
+        return exclude.some((pattern) => {
+            if (pattern.startsWith("/") &&
+                pattern.endsWith("/") &&
+                pattern.length > 1)
+                return new RegExp(pattern.slice(1, -1)).test(name);
+            return pattern === name;
+        });
+    },
+    isFailed(check) {
+        return check.bucket === "fail" || check.state === "FAILURE";
+    },
+    isPassed(check) {
+        return check.bucket === "pass" || check.state === "SUCCESS";
+    },
+    isPending(check) {
+        return !this.isFailed(check) && !this.isPassed(check);
+    },
+};
+export async function checkPr() {
+    this.context.abort.throwIfAborted();
+    await this.updateState({ status: "running" });
+    await this.updateEvent(`Checking PR.`);
+    const { files, metadata } = await getMetadata.call(this);
+    if (metadata.state !== "open")
+        throw new MagiError("blocked", `PR is not open.`);
+    if (metadata.draft)
+        throw new MagiError("blocked", `PR is a draft.`);
+    const errors = [];
+    if (this.config.review.safety.allowAuthors.length)
+        if (!this.config.review.safety.allowAuthors.includes(metadata.user.login))
+            errors.push(`Author is not allowed: ${metadata.user.login}.`);
+    if (this.config.review.safety.requiredLabels.length) {
+        const missingLabels = this.config.review.safety.requiredLabels.filter((label) => !metadata.labels.some(({ name }) => name === label));
+        if (missingLabels.length)
+            errors.push(`Required labels missing: ${missingLabels.join(", ")}.`);
+    }
+    if (isNumber(this.config.review.safety.maxChangedFiles) &&
+        metadata.changed_files > this.config.review.safety.maxChangedFiles)
+        errors.push(`Changed files exceed limit: ${metadata.changed_files} > ${this.config.review.safety.maxChangedFiles}.`);
+    if (this.config.review.safety.blockedPaths.length) {
+        const isBlocked = picomatch(this.config.review.safety.blockedPaths, {
+            dot: true,
+        });
+        const blocked = files.filter((file) => isBlocked(file));
+        if (blocked.length)
+            errors.push(`Blocked paths changed: ${blocked.join(", ")}.`);
+    }
+    if (errors.length)
+        throw new MagiError("blocked", `PR is safety blocked. ${errors.join(" ")}`);
+    if (this.config.mode === "single") {
+        if (this.config.account === metadata.user.login)
+            throw new MagiError("blocked", `Single mode account ${this.config.account} cannot review because it opened the pull request. Configure account to a different account.`);
+    }
+    else {
+        const accounts = Object.values(this.state.reviewers ?? {})
+            .filter(({ account }) => account === metadata.user.login)
+            .map(({ account }) => account);
+        if (accounts.length)
+            throw new MagiError("blocked", `Multi mode accounts ${accounts.join(", ")} cannot review because they opened the pull request. Configure accounts to different accounts.`);
+    }
+    await this.updateState({ pr: { files, metadata } });
+    await this.updateEvent(`Finished checking PR.`);
+}
+export async function checkCi(wait = this.config.review.checks.wait) {
+    this.context.abort.throwIfAborted();
+    await this.updateEvent(`Checking CI.`);
+    if (wait)
+        await watchChecks.call(this);
+    const checks = await getChecks.call(this);
+    await this.updateState({ pr: { checks } });
+    await this.updateEvent(`Finished checking CI.`);
+}
+export async function classifyChecks() {
+    this.context.abort.throwIfAborted();
+    if (!this.state.pr?.checks?.failed.length)
+        return;
+    await this.updateEvent(`Classifying CI checks.`);
+    if (!this.state.pr.metadata)
+        throw new MagiError("blocked", "PR metadata not found.");
+    if (!this.state.worktree)
+        throw new MagiError("blocked", "PR worktree not found.");
+    const worker = new Worker(this.config.review.concurrency.reviewers);
+    const classifiedChecks = Object.fromEntries(this.state.pr.checks.failed.map(({ id }) => [id, {}]));
+    const command = this.state.command === "merge" ? "merge" : "review";
+    const prompt = await Prompt.init(this.magi, this.config, `${command}/ci-classification`);
+    const taskMessage = await prompt.create(this.config[command].prompts?.ciClassification, [
+        "output_contract",
+        ["failed_checks", JSON.stringify(this.state.pr.checks.failed, null, 2)],
+    ], {
+        baseSha: this.state.pr.metadata[this.state.command === "merge" ? "head" : "base"]
+            .sha,
+        headSha: this.state.pr.metadata.head.sha,
+        owner: this.config.github.owner,
+        pr: this.number.toString(),
+        repo: this.config.github.repo,
+        worktreePath: this.state.worktree.path,
+    });
+    await Promise.all(Object.entries(this.state.reviewers ?? {}).map(([id, { sessionId }]) => worker.run(async () => {
+        if (!sessionId)
+            throw new Error(`No session ID found for reviewer ${id}.`);
+        await this.updateEvent(`Classifying CI checks with reviewer ${id}.`);
+        const output = await retry(async (count, e) => {
+            const raw = await this.magi.promptSession(sessionId, count === 1 ? taskMessage : await prompt.repair(e), this.context.abort);
+            await this.createAgentFile("ci-classification", id, raw, count);
+            const parsed = prompt.parse(raw);
+            if (!prompt.validate(parsed))
+                throw new Error(`Invalid output for reviewer ${id}.`);
+            return parsed;
+        }, {
+            error: async (e, count) => {
+                if (e instanceof MagiError)
+                    throw e;
+                await this.updateEvent(`Attempt ${count} failed to classify CI checks with reviewer ${id}. Retrying...`);
+            },
+            retries: this.config.output.repairAttempts,
+            signal: this.context.abort,
+        });
+        if (!output)
+            throw new MagiError("blocked", `Invalid output for reviewer ${id}.`);
+        output.checks.forEach((data) => {
+            classifiedChecks[data.id][id] = {
+                comment: data.comment,
+                scope: data.classification === "SCOPE_IN",
+            };
+        });
+    })));
+    const failed = this.state.pr.checks.failed.map((check) => {
+        const classifieds = classifiedChecks[check.id];
+        const values = Object.values(classifieds);
+        const scope = values.reduce((acc, { scope }) => acc + (scope ? 1 : 0), 0) >
+            values.length / 2;
+        return { ...check, classifieds, scope };
+    });
+    await Promise.all(failed.map(async ({ classifieds, name, scope }) => {
+        const reasons = {
+            in: Object.entries(classifieds)
+                .filter(([, { scope }]) => scope)
+                .map(([id, { comment }]) => `- ${id}: ${comment}`),
+            out: Object.entries(classifieds)
+                .filter(([, { scope }]) => !scope)
+                .map(([id, { comment }]) => `- ${id}: ${comment}`),
+        };
+        await this.updateEvent(filterEmpty([
+            scope
+                ? `Check ${name} was classified as in scope by majority vote.`
+                : `Check ${name} was classified as out of scope by majority vote. Rerunning it.`,
+            reasons.in.length
+                ? `In scope reasons:\n${reasons.in.join("\n")}`
+                : undefined,
+            reasons.out.length
+                ? `Out of scope reasons:\n${reasons.out.join("\n")}`
+                : undefined,
+        ]).join("\n\n"));
+    }));
+    await this.updateState({ pr: { checks: { failed } } });
+    await this.updateEvent(`Finished classifying CI checks.`);
+}
+export async function rerunChecks() {
+    this.context.abort.throwIfAborted();
+    if (!this.state.pr?.checks)
+        throw new MagiError("blocked", "PR checks not found.");
+    const checks = {
+        failed: this.state.pr.checks.failed,
+        passed: this.state.pr.checks.passed,
+    };
+    const failedChecks = checks.failed.filter(({ scope }) => !scope);
+    if (!failedChecks.length)
+        return;
+    await this.updateEvent(`Rerunning CI checks.`);
+    let label = failedChecks.map(({ name }) => name).join(", ");
+    if (this.state.dryRun) {
+        checks.passed = [
+            ...checks.passed,
+            ...checks.failed.filter(({ scope }) => !scope),
+        ];
+        checks.failed = checks.failed.filter(({ scope }) => scope);
+    }
+    else {
+        await retry(async () => {
+            await this.updateEvent(`Rerunning checks ${label}.`);
+            await Promise.all(checks.failed
+                .filter(({ scope }) => !scope)
+                .map(async ({ id }) => rerunCheck.call(this, id)));
+            await watchChecks.call(this);
+            const { failed, passed } = await getChecks.call(this);
+            checks.passed = passed.map((check) => {
+                const { classifieds, scope } = checks.failed.find(({ name, workflow }) => check.name === name && check.workflow === workflow) ?? {};
+                return omitNullish({ ...check, classifieds, scope });
+            });
+            checks.failed = failed.map((check) => {
+                const { classifieds, scope } = checks.failed.find(({ name, workflow }) => check.name === name && check.workflow === workflow) ?? {};
+                return omitNullish({ ...check, classifieds, scope });
+            });
+            const failedChecks = checks.failed.filter(({ scope }) => !scope);
+            if (!failedChecks.length)
+                return;
+            label = failedChecks.map(({ name }) => name).join(", ");
+            throw new Error(`Checks ${label} still failed.`);
+        }, {
+            error: (_, count) => this.updateEvent(`Attempt ${count} failed to rerun checks ${label}. Retrying...`),
+            retries: this.config.review.checks.retryFailedJobs,
+            signal: this.context.abort,
+        });
+    }
+    const passedChecksAfterRerun = checks.passed.filter((check) => "scope" in check && !check.scope);
+    const failedChecksAfterRerun = checks.failed.filter(({ scope }) => !scope);
+    const message = filterEmpty([
+        passedChecksAfterRerun.length
+            ? `Reran checks ${passedChecksAfterRerun.map(({ name }) => name).join(", ")} passed.`
+            : undefined,
+        failedChecksAfterRerun.length
+            ? `Reran checks ${failedChecksAfterRerun.map(({ name }) => name).join(", ")} failed.`
+            : undefined,
+    ]).join("\n");
+    if (message)
+        await this.updateEvent(message);
+    await this.updateState({ pr: { checks } });
+    await this.updateEvent(`Finished rerunning checks.`);
+}
+export async function getMetadata() {
+    const [{ data }, files] = await Promise.all([
+        this.octokit.rest.pulls.get({
+            owner: this.config.github.owner,
+            pull_number: this.number,
+            repo: this.config.github.repo,
+        }),
+        this.octokit.paginate(this.octokit.rest.pulls.listFiles, {
+            owner: this.config.github.owner,
+            pull_number: this.number,
+            repo: this.config.github.repo,
+        }),
+    ]);
+    return {
+        files: files.map(({ filename }) => filename),
+        metadata: data,
+    };
+}
+async function getChecks() {
+    const fields = "name,state,bucket,link,workflow";
+    const checks = {
+        excluded: [],
+        failed: [],
+        passed: [],
+        pending: [],
+    };
+    try {
+        const raw = await this.exec(command("gh", "pr", "checks", this.number, "--repo", this.state.repo, "--json", fields, "--required"), { signal: this.context.abort });
+        const data = JSON.parse(raw);
+        await Promise.all(data.map(async (check) => {
+            check.id = check.link.match(/\/actions\/runs\/\d+\/job\/(\d+)/)[1];
+            if (ci.isExcluded(this.config.review.checks.exclude, check)) {
+                checks.excluded.push(check);
+            }
+            else if (ci.isFailed(check)) {
+                const log = await getCheckLog.call(this, check.id);
+                checks.failed.push({ ...check, log });
+            }
+            else if (ci.isPassed(check)) {
+                checks.passed.push(check);
+            }
+            else if (ci.isPending(check)) {
+                checks.pending.push(check);
+            }
+        }));
+    }
+    catch (e) {
+        if (!/no (required )?checks reported on the '.+' branch/i.test(String(e)))
+            throw e;
+    }
+    return checks;
+}
+async function getCheckLog(id) {
+    const log = await this.exec(command("gh", "run", "view", "--repo", this.state.repo, "--job", quote(id), "--log-failed"), { signal: this.context.abort });
+    return (log
+        // oxlint-disable-next-line no-control-regex
+        .replaceAll(/\u001B\[[0-9;]*m/g, "")
+        .split("\n")
+        .filter((line) => line.trim())
+        .join("\n"));
+}
+async function rerunCheck(id) {
+    await this.exec(command("gh", "run", "rerun", "--repo", this.state.repo, "--job", quote(id)), { signal: this.context.abort });
+}
+async function watchChecks() {
+    try {
+        await this.exec(command("gh", "pr", "checks", this.number, "--repo", this.state.repo, "--watch", "--required"), { signal: this.context.abort });
+    }
+    catch { }
+}

package/dist/tools/review/context.js

@@ -0,0 +1,258 @@
+import { MagiError } from "@/magi";
+import { command, filterEmpty, marker, quote } from "@/utils";
+export async function checkExistingReviews() {
+    this.context.abort.throwIfAborted();
+    await this.updateEvent(`Fetching existing reviews.`);
+    if (!this.state.pr?.metadata)
+        throw new MagiError("blocked", "PR metadata not found.");
+    if (!this.config.review.reviewers?.length)
+        throw new MagiError("blocked", "No reviewers configured.");
+    const [reviews, commits, threads] = await Promise.all([
+        getReviews.call(this),
+        getCommits.call(this),
+        getReviewThreads.call(this),
+    ]);
+    await this.updateState({ pr: { commits, reviews, threads } });
+    const latestNonMergeCommit = commits
+        .toReversed()
+        .find(({ parents }) => parents.length < 2);
+    const reviewers = Object.fromEntries(this.config.review.reviewers.map(({ account, id }) => {
+        const targetReviews = filterEmpty(reviews.map((review) => {
+            if (this.config.mode === "single") {
+                if (review.user.login !== this.config.account)
+                    return;
+                const markers = marker.parse(review.body);
+                const { body, reviewer, verdict } = markers.find(({ reviewer }) => reviewer === id) ?? {};
+                if (reviewer !== id || !verdict)
+                    return;
+                try {
+                    return {
+                        ...review,
+                        body: body ? decodeURIComponent(body) : "",
+                        state: verdict,
+                    };
+                }
+                catch {
+                    return { ...review, body: "", state: verdict };
+                }
+            }
+            else {
+                if (review.user.login !== account)
+                    return;
+                if (review.state === "APPROVED")
+                    return review;
+                if (review.state === "CHANGES_REQUESTED")
+                    return review;
+                if (review.state !== "COMMENTED")
+                    return;
+                const markers = marker.parse(review.body);
+                const { reviewer, verdict } = markers[0] ?? {};
+                if (reviewer !== id || verdict !== "CLOSED")
+                    return;
+                return { ...review, state: "CLOSED" };
+            }
+        }));
+        if (!targetReviews.length) {
+            return [id, { account, status: "initial" }];
+        }
+        else {
+            const latestReviews = targetReviews.filter(({ submitted_at }) => latestNonMergeCommit?.commit.author?.date &&
+                submitted_at &&
+                submitted_at.localeCompare(latestNonMergeCommit.commit.author.date) >= 0);
+            const review = targetReviews.at(-1);
+            if (latestReviews.length)
+                return [id, { account, review, status: "skip" }];
+            else
+                return [id, { account, review, status: "rereview" }];
+        }
+    }));
+    for (const [id, reviewer] of Object.entries(reviewers)) {
+        if (reviewer.status !== "skip")
+            continue;
+        if (!reviewer.review)
+            throw new MagiError("blocked", `No review found for reviewer ${id}.`);
+        const single = this.config.mode === "single";
+        const author = single ? this.config.account : reviewer.account;
+        const hasUserReply = threads.some(({ comments, isResolved }) => {
+            if (isResolved)
+                return false;
+            const belongsToReviewer = single
+                ? comments.some(({ body }) => marker
+                    .parse(body)
+                    .some(({ reviewer }) => reviewer === id))
+                : comments.some(({ author }) => author?.login === reviewer.account);
+            if (!belongsToReviewer)
+                return false;
+            const last = comments.at(-1);
+            return (!!last &&
+                last.author?.login !== author &&
+                (!reviewer.review?.submitted_at ||
+                    last.createdAt.localeCompare(reviewer.review.submitted_at) > 0));
+        });
+        if (hasUserReply) {
+            reviewer.status = "rereview";
+        }
+        else {
+            const verdict = reviewer.review.state;
+            reviewer.outputs = [...(reviewer.outputs ?? []), { verdict }];
+        }
+    }
+    const skip = Object.values(reviewers).every(({ status }) => status === "skip");
+    await this.updateState({ reviewers });
+    await this.updateEvent(`Finished fetching existing reviews.`);
+    return skip;
+}
+export async function fetchReviewContext() {
+    this.context.abort.throwIfAborted();
+    await this.updateEvent(`Fetching review context.`);
+    const [comments, issues, threads] = await Promise.all([
+        getComments.call(this),
+        getClosingIssues.call(this),
+        getReviewThreads.call(this),
+    ]);
+    const inlineCommentTargets = await getInlineCommentTargets.call(this);
+    await this.updateState({
+        pr: { comments, inlineCommentTargets, issues, threads },
+    });
+    await this.updateEvent(`Finished fetching review context.`);
+}
+export async function getComments() {
+    return await this.octokit.paginate(this.octokit.rest.issues.listComments, {
+        issue_number: this.number,
+        owner: this.config.github.owner,
+        repo: this.config.github.repo,
+    });
+}
+async function getReviews() {
+    return await this.octokit.paginate(this.octokit.rest.pulls.listReviews, {
+        owner: this.config.github.owner,
+        pull_number: this.number,
+        repo: this.config.github.repo,
+    });
+}
+async function getCommits() {
+    return await this.octokit.paginate(this.octokit.rest.pulls.listCommits, {
+        owner: this.config.github.owner,
+        pull_number: this.number,
+        repo: this.config.github.repo,
+    });
+}
+export async function getClosingIssues() {
+    const data = await this.graphql.paginate(this.graphql.closingIssues, {
+        owner: this.config.github.owner,
+        pr: this.number,
+        repo: this.config.github.repo,
+    });
+    return filterEmpty(data.repository?.pullRequest?.closingIssuesReferences?.nodes?.map((node) => node && { ...node, comments: filterEmpty(node.comments.nodes ?? []) }) ?? []);
+}
+export async function getReviewThreads() {
+    const data = await this.graphql.paginate(this.graphql.reviewThreads, {
+        owner: this.config.github.owner,
+        pr: this.number,
+        repo: this.config.github.repo,
+    });
+    return filterEmpty(data.repository?.pullRequest?.reviewThreads.nodes?.map((node) => node && { ...node, comments: filterEmpty(node.comments.nodes ?? []) }) ?? []);
+}
+export async function getInlineCommentTargets() {
+    if (!this.state.reviewers)
+        throw new MagiError("blocked", "Reviewers not found.");
+    if (!this.state.pr?.metadata)
+        throw new MagiError("blocked", "PR metadata not found.");
+    if (!this.state.worktree)
+        throw new MagiError("blocked", "PR worktree not found.");
+    const get = async (from, to) => {
+        const inlineCommentTargets = {};
+        const [fromSource, fromSha] = from;
+        const [toSource, toSha] = to;
+        const commits = [
+            { label: "from", sha: fromSha, source: fromSource },
+            { label: "to", sha: toSha, source: toSource },
+        ];
+        const missing = filterEmpty(await Promise.all(commits.map(async (commit) => {
+            if (!(await hasCommit.call(this, commit.sha)))
+                return commit;
+        })));
+        const sources = new Set(missing.map(({ source }) => source));
+        for (const source of sources) {
+            const ref = source === "base"
+                ? this.state.pr.metadata.base.ref
+                : this.state.pr.metadata.head.ref;
+            const url = source === "base"
+                ? this.state.pr.metadata.base.repo.clone_url
+                : this.state.pr.metadata.head.repo.clone_url;
+            await this.exec(command("git", "fetch", "--no-tags", quote(url), quote(`refs/heads/${ref}`)), { cwd: this.state.worktree.path, signal: this.context.abort });
+        }
+        for (const commit of missing) {
+            if (await hasCommit.call(this, commit.sha))
+                continue;
+            const ref = commit.source === "base"
+                ? this.state.pr.metadata.base.ref
+                : this.state.pr.metadata.head.ref;
+            throw new MagiError("blocked", `${commit.label} commit ${commit.sha} is unavailable after fetching ${commit.source} ref ${ref}.`);
+        }
+        const diff = await this.exec(command("git", "diff", "--no-ext-diff", "--unified=3", quote(`${fromSha}...${toSha}`)), { cwd: this.state.worktree.path, signal: this.context.abort });
+        let path;
+        let line;
+        for (const entry of diff.split("\n")) {
+            if (entry.startsWith("+++ ")) {
+                let value = entry.slice(4);
+                if (value === "/dev/null")
+                    continue;
+                if (value.startsWith('"') && value.endsWith('"'))
+                    try {
+                        value = JSON.parse(value);
+                    }
+                    catch {
+                        value = value.slice(1, -1);
+                    }
+                path = value.startsWith("b/") ? value.slice(2) : value;
+                line = undefined;
+                continue;
+            }
+            if (entry.startsWith("@@ ")) {
+                const match = entry.match(/\+(\d+)(?:,\d+)?/);
+                line = match ? Number(match[1]) : undefined;
+                continue;
+            }
+            if (!path || line == null)
+                continue;
+            if (entry.startsWith("+") || entry.startsWith(" ")) {
+                const lines = inlineCommentTargets[path] ?? [];
+                lines.push(line);
+                inlineCommentTargets[path] = lines;
+                line += 1;
+            }
+        }
+        return inlineCommentTargets;
+    };
+    const baseSha = this.state.pr.metadata.base.sha;
+    const headSha = this.state.pr.metadata.head.sha;
+    const inlineCommentTargets = {
+        [baseSha]: await get(["base", baseSha], ["head", headSha]),
+    };
+    const reviewers = Object.entries(this.state.reviewers);
+    for (const [id, { review, status }] of reviewers) {
+        if (status !== "rereview")
+            continue;
+        if (!review?.commit_id)
+            throw new MagiError("blocked", `Missing previous review commit for reviewer ${id}.`);
+        const previousHeadSha = review.commit_id;
+        if (!inlineCommentTargets[previousHeadSha])
+            inlineCommentTargets[previousHeadSha] = await get(["head", previousHeadSha], ["head", headSha]);
+    }
+    return inlineCommentTargets;
+}
+async function hasCommit(sha) {
+    if (!this.state.worktree)
+        throw new MagiError("blocked", "PR worktree not found.");
+    try {
+        await this.exec(command("git", "cat-file", "-e", quote(`${sha}^{commit}`)), {
+            cwd: this.state.worktree.path,
+            signal: this.context.abort,
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/tools/review/index.js

@@ -0,0 +1,104 @@
+import { tool } from "@opencode-ai/plugin";
+import { parsePrs, split, Worker } from "@/utils";
+import { Review } from "./review";
+function overrideConfig(config, args, dryRun = false) {
+    for (let index = 0; index < args.length; index++) {
+        const arg = args[index];
+        const value = args[index + 1];
+        if (!arg.startsWith("--"))
+            continue;
+        switch (arg) {
+            case "--dry-run":
+                dryRun = true;
+                break;
+            case "--retry-api-attempts":
+                config.github.retryApiAttempts = parseInt(value);
+                break;
+            case "--language":
+                config.language = value;
+                break;
+            case "--merge":
+                config.review.automation.merge = true;
+                break;
+            case "--no-merge":
+                config.review.automation.merge = false;
+                break;
+            case "--close":
+                config.review.automation.close = true;
+                break;
+            case "--no-close":
+                config.review.automation.close = false;
+                break;
+            case "--retry-failed-jobs":
+                config.review.checks.retryFailedJobs = parseInt(value);
+                break;
+            case "--concurrency-reviewers":
+                config.review.concurrency.reviewers = parseInt(value);
+                break;
+            case "--concurrency-runs":
+                config.review.concurrency.runs = parseInt(value);
+                break;
+            case "--wait-checks":
+                config.review.checks.wait = true;
+                break;
+            case "--no-wait-checks":
+                config.review.checks.wait = false;
+                break;
+        }
+    }
+    return { config, dryRun };
+}
+export const review = function (magi) {
+    return {
+        magi_review: tool({
+            args: {
+                dryRun: tool.schema.boolean().optional(),
+                prs: tool.schema.string(),
+            },
+            description: "Review one or more pull requests and post the reviews.",
+            async execute(args, context) {
+                const prs = parsePrs(args.prs);
+                const { config, dryRun } = overrideConfig(await magi.getConfig({ reviewers: true }), split(args.prs), args.dryRun);
+                const worker = new Worker(config.review.concurrency.runs);
+                const reports = await Promise.all(prs.map(async (pr) => {
+                    context.abort.throwIfAborted();
+                    return worker.run(async () => {
+                        const run = await Review.init(pr, magi, config, context, {
+                            dryRun,
+                        });
+                        try {
+                            await run.checkPr();
+                            const skip = await run.checkExistingReviews();
+                            await run.checkCi();
+                            if (!skip) {
+                                await run.createSessions();
+                                await run.createWorktree();
+                                await run.classifyChecks();
+                                await run.rerunChecks();
+                                await run.fetchReviewContext();
+                                await run.review();
+                                await run.validateFindings();
+                                await run.reconsiderClose();
+                            }
+                            await run.resolveVerdict();
+                            if (!skip)
+                                await run.postReviews();
+                            await run.automate();
+                            return { error: false, report: await run.createReport() };
+                        }
+                        catch (e) {
+                            return { error: true, report: await run.createReport(e) };
+                        }
+                        finally {
+                            await run.cleanup();
+                        }
+                    });
+                }));
+                const errors = reports.filter(({ error }) => error);
+                if (errors.length)
+                    throw new Error(errors.map(({ report }) => report).join("\n\n"));
+                return reports.map(({ report }) => report).join("\n\n");
+            },
+        }),
+    };
+};

package/dist/tools/review/index.type.js

@@ -0,0 +1 @@
+export {};