opencode-magi 0.10.0 → 0.12.0

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

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

package/dist/tools/review/report.js

@@ -0,0 +1,143 @@
+import { writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { MagiError } from "@/magi";
+import { filterEmpty, toTitleCase } from "@/utils";
+export async function createReport(e) {
+    this.context.abort.throwIfAborted();
+    if (!e) {
+        const status = "completed";
+        const text = await createContent.call(this, { status });
+        await writeFile(join(this.state.output, "report.md"), `${text}\n`);
+        await this.updateState({
+            completedAt: new Date().toISOString(),
+            status,
+        });
+        return text;
+    }
+    else {
+        const error = e instanceof Error ? e.message : "Unknown error";
+        const status = e instanceof MagiError
+            ? e.status
+            : this.context.abort.aborted
+                ? "cancelled"
+                : "failed";
+        const text = await createContent.call(this, { error, status });
+        await writeFile(join(this.state.output, "report.md"), `${text}\n`);
+        await this.updateState({
+            completedAt: new Date().toISOString(),
+            status,
+        });
+        return text;
+    }
+}
+async function createContent(input) {
+    return filterEmpty([
+        ...(await createMetaContent.call(this, input)),
+        ...createCheckContent.call(this),
+        ...createReviewerContent.call(this),
+    ]).join("\n");
+}
+export async function createMetaContent(input) {
+    const events = await this.getEvents();
+    const lastAction = events.at(-1)?.message;
+    const rows = [
+        `- **Pull Request:** [${this.state.pr.number}](${this.state.pr.url})`,
+        `- **Mode**: ${toTitleCase(this.config.mode)}`,
+        `- **Dry run**: ${this.state.dryRun ? "Yes" : "No"}`,
+        `- **Status**: ${toTitleCase(input.status)}`,
+        `- **Automation**: ${this.state.pr?.automation ? toTitleCase(this.state.pr.automation.toLocaleLowerCase()) : "none"}`,
+    ];
+    if (this.state.pr?.verdict)
+        rows.push(`- **Verdict**: ${toTitleCase(this.state.pr.verdict.toLocaleLowerCase())}`);
+    if (lastAction)
+        rows.push(`- **Last action**: ${lastAction}`);
+    if (input.error)
+        rows.push(`- **Error**: ${input.error}`);
+    return rows;
+}
+export function createCheckContent() {
+    const checks = this.state.pr?.checks;
+    if (!checks)
+        return [];
+    const failures = [
+        ...checks.failed.map((check) => ({
+            comments: Object.entries(check.classifieds ?? {}).map(([reviewer, { comment, scope }]) => ({ comment, reviewer, scope })),
+            detail: check.scope == null
+                ? "Failed"
+                : check.scope
+                    ? "In-scope failure"
+                    : "Out-of-scope failure",
+            name: check.name,
+        })),
+        ...checks.pending.map((check) => ({
+            comments: [],
+            detail: "Pending",
+            name: check.name,
+        })),
+    ];
+    if (failures.length)
+        return [
+            "- **Check**: Failure",
+            ...failures.flatMap(({ comments, detail, name }) => [
+                `  - **${name}**: ${detail}`,
+                ...comments.map(({ comment, reviewer, scope }) => `    - **${reviewer}**: ${scope ? "In scope" : "Out of scope"}. ${comment}`),
+            ]),
+        ];
+    else
+        return ["- **Check**: Pass"];
+}
+export function createReviewerContent() {
+    const reviewers = Object.entries(this.state.reviewers ?? {});
+    if (!reviewers.length)
+        return [];
+    return [
+        [
+            "- **Reviewer**:",
+            ...reviewers.flatMap(([id, { outputs, posted, review }]) => {
+                if (!outputs?.length)
+                    return [];
+                const output = outputs.at(-1);
+                const url = posted ?? review?.html_url;
+                const status = toTitleCase(output.verdict.toLocaleLowerCase());
+                const prevStatuses = outputs
+                    .slice(0, -1)
+                    .map(({ verdict }) => toTitleCase(verdict.toLocaleLowerCase()))
+                    .reduce((prev, current) => {
+                    if (prev.at(-1) !== current)
+                        prev.push(current);
+                    return prev;
+                }, []);
+                const lines = [
+                    `  - **${id}**: ${[...prevStatuses, url ? `[${status}](${url})` : status].join(" -> ")}`,
+                    ...outputs.flatMap((output, index) => {
+                        const lines = [
+                            `    - **Verdict**: ${toTitleCase(output.verdict.toLocaleLowerCase())}`,
+                        ];
+                        const latest = index === outputs.length - 1;
+                        const findings = output.findings ?? output.newFindings ?? [];
+                        if (output.verdict === "CLOSED")
+                            lines.push(`      - **Comment**: ${latest ? "" : "~~"}${output.comment ?? review?.body}${latest ? "" : "~~"}`);
+                        if (findings.length) {
+                            lines.push("      - **Findings**:");
+                            for (const { body, line, path, startLine, state } of findings) {
+                                const discarded = state === "discarded";
+                                const prefix = `${path}:${startLine != null ? `${startLine}-` : ""}${line}`;
+                                lines.push(`        - ${discarded ? "~~" : ""}\`${prefix}\`: ${body}${discarded ? "~~" : ""}`);
+                            }
+                        }
+                        if (output.followUps?.length) {
+                            lines.push("      - **FollowUps**:");
+                            for (const { body, commentId } of output.followUps) {
+                                const thread = this.state.pr?.threads?.find(({ comments }) => comments.some(({ databaseId }) => databaseId === commentId));
+                                const prefix = `${thread?.path ?? "unknown"}:${thread?.line ?? "N/A"}`;
+                                lines.push(`        - \`${prefix}\`: ${body}`);
+                            }
+                        }
+                        return lines;
+                    }),
+                ];
+                return lines;
+            }),
+        ].join("\n"),
+    ];
+}

package/dist/tools/review/review.js

@@ -0,0 +1,146 @@
+import { join } from "node:path";
+import { MagiError } from "@/magi";
+import { createExecWithGitHubApiRetry, quote } from "@/utils";
+import { automate, isAutomationEnabled, postReviews } from "./action";
+import { checkCi, checkPr, classifyChecks, rerunChecks } from "./check";
+import { checkExistingReviews, fetchReviewContext } from "./context";
+import { createReport } from "./report";
+import { reconsiderClose, review, validateFindings } from "./reviewer";
+export class Review {
+    number;
+    magi;
+    config;
+    context;
+    octokit;
+    graphql;
+    exec;
+    state;
+    constructor(number, magi, config, context, octokit, graphql, exec, state) {
+        this.number = number;
+        this.magi = magi;
+        this.config = config;
+        this.context = context;
+        this.octokit = octokit;
+        this.graphql = graphql;
+        this.exec = exec;
+        this.exec = createExecWithGitHubApiRetry(this.magi.exec, this.config.github.retryApiAttempts);
+        this.state = state;
+    }
+    static async init(number, magi, config, context, options) {
+        const { exec, graphql, octokit, ...rest } = await this.setup(number, magi, config, context);
+        const state = await magi.createState(join(config.review.output, number.toString()), { ...options, ...rest, command: "review" });
+        await magi.updateEvent(state.output, `Started reviewing.`);
+        return new Review(number, magi, config, context, octokit, graphql, exec, state);
+    }
+    static async setup(number, magi, config, context) {
+        const url = `${config.github.url}/pull/${number}`;
+        const octokit = await magi.createOctokit(config, context.abort);
+        const graphql = magi.createGraphql(octokit);
+        const reviewers = Object.fromEntries(config.review.reviewers.map(({ account, id, model, permissions }) => [id, { account, model, permissions }]));
+        const operator = config.review.operator
+            ? config.review.reviewers.find(({ id }) => id === config.review.operator)
+            : config.review.reviewers[Math.abs(number) % config.review.reviewers.length];
+        const exec = createExecWithGitHubApiRetry(magi.exec, config.github.retryApiAttempts);
+        return {
+            exec,
+            graphql,
+            octokit,
+            operator,
+            pr: { number, url },
+            repo: quote(`${config.github.owner}/${config.github.repo}`),
+            reviewers,
+            sessionId: context.sessionID,
+        };
+    }
+    checkPr = checkPr;
+    checkExistingReviews = checkExistingReviews;
+    checkCi = checkCi;
+    classifyChecks = classifyChecks;
+    rerunChecks = rerunChecks;
+    fetchReviewContext = fetchReviewContext;
+    review = review;
+    validateFindings = validateFindings;
+    reconsiderClose = reconsiderClose;
+    postReviews = postReviews;
+    isAutomationEnabled = isAutomationEnabled;
+    automate = automate;
+    createReport = createReport;
+    async cleanup() {
+        if (this.context.abort.aborted &&
+            ["preparing", "running"].includes(this.state.status))
+            await this.updateState({
+                completedAt: new Date().toISOString(),
+                status: "cancelled",
+            });
+        if (this.state.worktree?.path)
+            await this.magi.deleteWorktree(this.state.worktree.path);
+    }
+    async updateState(next) {
+        this.state = await this.magi.updateState(this.state.output, next);
+    }
+    async updateEvent(message) {
+        await this.magi.updateEvent(this.state.output, message);
+    }
+    async getEvents() {
+        return await this.magi.getEvents(this.state.output);
+    }
+    async createAgentFile(phase, id, content, attempt, cycle) {
+        await this.magi.createAgentFile(this.state.output, phase, id, content, attempt, cycle);
+    }
+    async createSessions() {
+        this.context.abort.throwIfAborted();
+        if (!this.state.reviewers)
+            throw new MagiError("blocked", "Reviewers not found.");
+        if (!this.state.operator)
+            throw new MagiError("blocked", "Operator not found.");
+        const reviewers = Object.fromEntries(await Promise.all(Object.entries(this.state.reviewers).map(async ([id, { model, permissions }]) => [
+            id,
+            {
+                sessionId: await this.magi.createSession(this.state.sessionId, `magi review #${this.number} ${id}`, { model, permissions }, this.context.abort),
+            },
+        ])));
+        const operator = {
+            sessionId: await this.magi.createSession(this.state.sessionId, `magi review #${this.number} operator`, {
+                model: this.state.operator.model,
+                permissions: this.state.operator.permissions,
+            }, this.context.abort),
+        };
+        await this.updateState({ operator, reviewers });
+    }
+    async createWorktree() {
+        this.context.abort.throwIfAborted();
+        await this.updateEvent(`Creating worktree.`);
+        const worktree = await this.magi.createWorktree(this.config.review.worktree, this.number, this.state.id, this.context.abort);
+        await this.updateState({ worktree });
+        await this.updateEvent(`Finished creating worktree.`);
+    }
+    async resolveVerdict() {
+        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 counts = Object.entries(this.state.reviewers).reduce((prev, [id, { outputs }]) => {
+            const output = outputs?.at(-1);
+            if (!output)
+                throw new MagiError("blocked", `No output found for reviewer ${id}.`);
+            prev[output.verdict] += 1;
+            return prev;
+        }, {
+            APPROVED: 0,
+            CHANGES_REQUESTED: 0,
+            CLOSED: 0,
+        });
+        const length = this.config.review.reviewers.length;
+        const threshold = Math.floor(length / 2) + 1;
+        const majority = this.config.review.merge.approvalPolicy === "majority";
+        const verdict = counts.CLOSED >= threshold
+            ? "CLOSED"
+            : (!majority && counts.APPROVED === length) ||
+                (majority && counts.APPROVED >= threshold)
+                ? "APPROVED"
+                : "CHANGES_REQUESTED";
+        await this.updateState({ pr: { verdict } });
+        await this.updateEvent(`Final verdict is ${verdict}.`);
+        return verdict;
+    }
+}