opencode-magi 0.9.0 → 0.11.0

package/dist/tools/merge/editor.js

@@ -0,0 +1,264 @@
+import { MagiError } from "@/magi";
+import { Prompt } from "@/prompts";
+import { getMetadata } from "@/tools/review/check";
+import { command, filterDuplicates, filterEmpty, quote, retry } from "@/utils";
+export async function edit() {
+    this.context.abort.throwIfAborted();
+    await this.updateEvent(`Editing.`);
+    await setAccount.call(this);
+    const unresolvedThreads = await getUnresolvedThreads.call(this);
+    const threads = this.state.dryRun
+        ? [...createSyntheticThreads.call(this), ...unresolvedThreads]
+        : unresolvedThreads;
+    if (!threads.length)
+        throw new MagiError("blocked", "No editable review threads found.");
+    const cycle = (this.state.editor.outputs?.length ?? 0) + 1;
+    const prompt = await Prompt.init(this.magi, this.config, "merge/edit");
+    const taskMessage = await prompt.create(this.config.merge.prompts?.edit, [
+        "output_contract",
+        ["unresolved_threads", JSON.stringify(threads, null, 2)],
+    ], {
+        owner: this.config.github.owner,
+        pr: this.number.toString(),
+        repo: this.config.github.repo,
+        worktreePath: this.state.worktree.path,
+    });
+    const output = await retry(async (count, e) => {
+        const raw = await this.magi.promptSession(this.state.editor.sessionId, count === 1 ? taskMessage : await prompt.repair(e), this.context.abort);
+        await this.createAgentFile("edit", "editor", raw, count, cycle);
+        const parsed = prompt.parse(raw);
+        if (!prompt.validate(parsed))
+            throw new Error("Invalid output for editor.");
+        const output = {
+            ...parsed,
+            filesTouched: parsed.filesTouched ?? [],
+        };
+        if (output.mode === "EDITED") {
+            const head = await this.exec(command("git", "rev-parse", "HEAD"), {
+                cwd: this.state.worktree.path,
+                signal: this.context.abort,
+            });
+            if (head !== output.commitSha)
+                throw new Error(`Editor reported commit ${output.commitSha}, but worktree HEAD is ${head}.`);
+        }
+        return output;
+    }, {
+        error: async (e, count) => {
+            if (e instanceof MagiError)
+                throw e;
+            await this.updateEvent(`Attempt ${count} failed to edit. Retrying...`);
+        },
+        retries: this.config.output.repairAttempts,
+        signal: this.context.abort,
+    });
+    if (!output)
+        throw new MagiError("blocked", "Invalid output for editor.");
+    await this.updateState({
+        editor: { outputs: [...(this.state.editor.outputs ?? []), output] },
+    });
+    await this.updateEvent(filterEmpty([
+        `Finished editing.`,
+        `Result: ${output.mode.toLocaleLowerCase()}.`,
+        output.commitSha
+            ? `Commit: ${output.commitSha}${output.commitMessage ? ` ${output.commitMessage}` : ""}`
+            : undefined,
+        output.filesTouched.length
+            ? `Files touched:\n${output.filesTouched.map((file) => `- ${file}`).join("\n")}`
+            : undefined,
+        output.responses.length
+            ? `Responses:\n${output.responses
+                .map(({ action, body, commentId }) => `- ${action} comment ${commentId}: ${body}`)
+                .join("\n")}`
+            : undefined,
+    ]).join("\n\n"));
+    if (output.mode === "EDITED")
+        if (this.state.dryRun) {
+            await this.updateState({
+                pr: {
+                    files: filterDuplicates([
+                        ...(this.state.pr?.files ?? []),
+                        ...output.filesTouched,
+                    ]),
+                    metadata: { head: { sha: output.commitSha } },
+                },
+            });
+            await this.updateEvent(`Skipped pushing editor changes during dry run.`);
+        }
+        else {
+            await this.updateEvent(`Pushing editor changes.`);
+            const pr = await push.call(this);
+            await this.updateState({ pr });
+            await this.updateEvent(`Finished pushing editor changes.`);
+        }
+    return output.mode === "EDITED" && !this.state.dryRun;
+}
+export async function resolveConflict() {
+    this.context.abort.throwIfAborted();
+    await this.updateEvent(`Resolving merge conflicts.`);
+    if (!this.state.pr?.metadata)
+        throw new MagiError("blocked", "PR metadata not found.");
+    const options = { cwd: this.state.worktree.path, signal: this.context.abort };
+    await setAccount.call(this);
+    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);
+    const conflictedFiles = await getConflictedFiles.call(this);
+    if (!conflictedFiles.length)
+        throw new MagiError("blocked", "No merge conflicts found in worktree.");
+    const cycle = (this.state.editor.outputs?.length ?? 0) + 1;
+    const prompt = await Prompt.init(this.magi, this.config, "merge/conflict");
+    const taskMessage = await prompt.create(undefined, [
+        "output_contract",
+        ["conflicted_files", JSON.stringify(conflictedFiles, null, 2)],
+    ], {
+        owner: this.config.github.owner,
+        pr: this.number.toString(),
+        repo: this.config.github.repo,
+        worktreePath: this.state.worktree.path,
+    });
+    const output = await retry(async (count, e) => {
+        const raw = await this.magi.promptSession(this.state.editor.sessionId, count === 1 ? taskMessage : await prompt.repair(e), this.context.abort);
+        await this.createAgentFile("conflict", "editor", raw, count, cycle);
+        const parsed = prompt.parse(raw);
+        if (!prompt.validate(parsed))
+            throw new Error("Invalid output for conflict editor.");
+        const diff = await this.exec(command("git", "diff", "--name-only", "--diff-filter=U"), options);
+        if (diff)
+            throw new Error("Merge conflicts remain.");
+        const commitSha = await this.exec(command("git", "rev-parse", "HEAD"), options);
+        if (commitSha === this.state.pr.metadata.head.sha)
+            throw new Error("Conflict editor did not create a commit.");
+        const parents = await this.exec(command("git", "rev-list", "--parents", "-n", "1", "HEAD"), options);
+        if (parents.split(" ").length < 3)
+            throw new Error("Conflict editor did not create a merge commit.");
+        const commitMessage = await this.exec(command("git", "log", "-1", "--pretty=%s"), options);
+        return {
+            commitMessage,
+            commitSha,
+            filesTouched: conflictedFiles,
+            mode: "RESOLVED",
+            responses: [],
+        };
+    }, {
+        error: async (e, count) => {
+            if (e instanceof MagiError)
+                throw e;
+            await this.updateEvent(`Attempt ${count} failed to resolve conflicts. Retrying...`);
+        },
+        retries: this.config.output.repairAttempts,
+        signal: this.context.abort,
+    });
+    if (!output)
+        throw new MagiError("blocked", "Invalid output for conflict editor.");
+    await this.updateState({
+        editor: { outputs: [...(this.state.editor.outputs ?? []), output] },
+    });
+    await this.updateEvent(`Finished resolving merge conflicts.`);
+    if (this.state.dryRun) {
+        await this.updateState({
+            pr: {
+                files: filterDuplicates([
+                    ...(this.state.pr.files ?? []),
+                    ...output.filesTouched,
+                ]),
+                metadata: { head: { sha: output.commitSha } },
+            },
+        });
+        await this.updateEvent(`Skipped pushing conflict resolution during dry run.`);
+    }
+    else {
+        await this.updateEvent(`Pushing conflict resolution.`);
+        const pr = await push.call(this);
+        await this.updateState({ pr });
+        await this.updateEvent(`Finished pushing conflict resolution.`);
+    }
+}
+async function setAccount() {
+    if (!this.state.editor?.sessionId)
+        throw new MagiError("blocked", "Editor session ID not found.");
+    if (!this.state.editor.author)
+        throw new MagiError("blocked", "Editor author not found.");
+    if (!this.state.worktree)
+        throw new MagiError("blocked", "PR worktree not found.");
+    const options = { cwd: this.state.worktree.path, signal: this.context.abort };
+    await this.exec(command("git", "config", "user.name", quote(this.state.editor.author.name)), options);
+    await this.exec(command("git", "config", "user.email", quote(this.state.editor.author.email)), options);
+}
+async function push() {
+    if (!this.state.editor?.account)
+        throw new MagiError("blocked", "Editor account 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 token = await this.magi.getGhToken(this.state.editor.account, this.context.abort);
+    const url = `https://${this.config.github.host}/${this.state.pr.metadata.head.repo.owner.login}/${this.state.pr.metadata.head.repo.name}.git`;
+    const ref = `HEAD:refs/heads/${this.state.pr.metadata.head.ref}`;
+    await this.exec(command("git", "push", quote(url), quote(ref)), {
+        cwd: this.state.worktree.path,
+        env: {
+            GIT_CONFIG_COUNT: "2",
+            GIT_CONFIG_KEY_0: "credential.helper",
+            GIT_CONFIG_KEY_1: "credential.helper",
+            GIT_CONFIG_VALUE_0: "",
+            GIT_CONFIG_VALUE_1: "!f() { echo username=git; echo password=$GIT_PASSWORD; }; f",
+            GIT_PASSWORD: token,
+            GIT_TERMINAL_PROMPT: "0",
+        },
+        signal: this.context.abort,
+    });
+    return getMetadata.call(this);
+}
+async function getConflictedFiles() {
+    if (!this.state.worktree)
+        throw new MagiError("blocked", "PR worktree not found.");
+    const options = { cwd: this.state.worktree.path, signal: this.context.abort };
+    try {
+        await this.exec(command("git", "merge", "--no-commit", "--no-ff", "FETCH_HEAD"), options);
+        await this.exec(command("git", "merge", "--abort"), options);
+        return [];
+    }
+    catch {
+        const result = await this.exec(command("git", "diff", "--name-only", "--diff-filter=U"), options);
+        if (!result) {
+            await this.exec(command("git", "merge", "--abort"), options);
+            return [];
+        }
+        return result.split("\n");
+    }
+}
+async function getUnresolvedThreads() {
+    const data = await this.graphql.paginate(this.graphql.reviewThreads, {
+        owner: this.config.github.owner,
+        pr: this.number,
+        repo: this.config.github.repo,
+    });
+    return (data.repository?.pullRequest?.reviewThreads.nodes ?? []).flatMap((node) => {
+        if (!node || node.isResolved)
+            return [];
+        return [{ ...node, comments: filterEmpty(node.comments.nodes ?? []) }];
+    });
+}
+function createSyntheticThreads() {
+    const findings = Object.entries(this.state.reviewers ?? {}).flatMap(([reviewer, { outputs }]) => {
+        const output = outputs?.at(-1);
+        if (output?.verdict !== "CHANGES_REQUESTED")
+            return [];
+        const findings = output.findings ?? output.newFindings ?? [];
+        return findings.map((finding) => ({ ...finding, reviewer }));
+    });
+    return findings.map(({ body, line, path, reviewer, state }, index) => ({
+        comments: [
+            {
+                author: { login: reviewer },
+                body,
+                createdAt: new Date(0).toISOString(),
+                databaseId: -(index + 1),
+                url: "",
+            },
+        ],
+        id: `dry-run:${reviewer}:${index + 1}`,
+        isResolved: false,
+        line,
+        path,
+        state,
+    }));
+}

package/dist/tools/merge/index.js

@@ -0,0 +1,151 @@
+import { tool } from "@opencode-ai/plugin";
+import { parsePrs, split, Worker } from "@/utils";
+import { Merge } from "./merge";
+async function editCycle(run, { conflict, cycle } = {}) {
+    if (!run.state.editor?.sessionId)
+        await run.createSession();
+    if (!run.state.worktree)
+        await run.createWorktree();
+    const reviewers = Object.entries(run.state.reviewers ?? {});
+    const hasSessions = reviewers.length && reviewers.every(([_, { sessionId }]) => sessionId);
+    const edited = cycle === 1 && conflict ? true : await run.edit();
+    if (cycle === 1 && conflict)
+        await run.resolveConflict();
+    else
+        await run.postReplies();
+    if (edited)
+        await run.checkCi(run.config.merge.checks.wait);
+    if (!hasSessions)
+        await run.createSessions();
+    if (edited) {
+        await run.classifyChecks();
+        await run.rerunChecks();
+        await run.checkExistingReviews();
+    }
+    await run.fetchMergeContext();
+    if (!edited)
+        await run.markRepliedReviewers();
+    await run.review();
+    await run.validateFindings();
+    await run.reconsiderClose();
+    const verdict = await run.resolveVerdict();
+    await run.postReviews();
+    return verdict;
+}
+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.merge.automation.merge = true;
+                break;
+            case "--no-merge":
+                config.merge.automation.merge = false;
+                break;
+            case "--close":
+                config.merge.automation.close = true;
+                break;
+            case "--no-close":
+                config.merge.automation.close = false;
+                break;
+            case "--max-cycles":
+                config.merge.maxThreadResolutionCycles = parseInt(value);
+                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;
+            case "--wait-checks-after-edit":
+                config.merge.checks.wait = true;
+                break;
+            case "--no-wait-checks-after-edit":
+                config.merge.checks.wait = false;
+                break;
+        }
+    }
+    return { config, dryRun };
+}
+export const merge = function (magi) {
+    return {
+        magi_merge: tool({
+            args: {
+                dryRun: tool.schema.boolean().optional(),
+                prs: tool.schema.string(),
+            },
+            description: "Review, fix, and merge one or more pull requests.",
+            async execute(args, context) {
+                const prs = parsePrs(args.prs);
+                const { config, dryRun } = overrideConfig(await magi.getConfig({ editor: true, 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 Merge.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();
+                            }
+                            const verdict = await run.resolveVerdict();
+                            if (!skip)
+                                await run.postReviews();
+                            if (verdict === "CHANGES_REQUESTED")
+                                await run.editCycles(async () => editCycle(run));
+                            const automation = await run.automate();
+                            if (automation === "CONFLICT" &&
+                                run.config.merge.automation.conflict) {
+                                await run.editCycles(async (cycle) => editCycle(run, { conflict: true, cycle }));
+                                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/merge/index.type.js

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

package/dist/tools/merge/merge.js

@@ -0,0 +1,42 @@
+import { join } from "node:path";
+import { MagiError } from "@/magi";
+import { Review } from "@/tools/review/review";
+import { editCycles, postReplies } from "./action";
+import { fetchMergeContext, markRepliedReviewers } from "./context";
+import { edit, resolveConflict } from "./editor";
+import { createReport } from "./report";
+export class Merge extends Review {
+    static async init(number, magi, config, context, options) {
+        const { exec, graphql, octokit, ...rest } = await this.setup(number, magi, config, context);
+        const editor = {
+            account: config.merge.editor.account,
+            author: config.merge.editor.author,
+            model: config.merge.editor.model,
+            permissions: config.merge.editor.permissions,
+        };
+        const state = await magi.createState(join(config.review.output, number.toString()), { ...options, ...rest, command: "merge", editor });
+        await magi.updateEvent(state.output, `Started merging.`);
+        return new Merge(number, magi, config, context, octokit, graphql, exec, state);
+    }
+    createReport = createReport;
+    editCycles = editCycles;
+    edit = edit;
+    fetchMergeContext = fetchMergeContext;
+    markRepliedReviewers = markRepliedReviewers;
+    postReplies = postReplies;
+    resolveConflict = resolveConflict;
+    async createSession() {
+        this.context.abort.throwIfAborted();
+        if (!this.state.editor)
+            throw new MagiError("blocked", "Editor not found.");
+        await this.updateEvent(`Creating editor session.`);
+        const editor = {
+            sessionId: await this.magi.createSession(this.state.sessionId, `magi merge #${this.number} editor`, {
+                model: this.state.editor.model,
+                permissions: this.state.editor.permissions,
+            }, this.context.abort),
+        };
+        await this.updateState({ editor });
+        await this.updateEvent(`Finished creating editor session.`);
+    }
+}

package/dist/tools/merge/report.js

@@ -0,0 +1,73 @@
+import { writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { MagiError } from "@/magi";
+import { createCheckContent, createMetaContent, createReviewerContent, } from "@/tools/review/report";
+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),
+        ...createEditorContent.call(this),
+    ]).join("\n");
+}
+function createEditorContent() {
+    if (!this.state.editor?.outputs?.length)
+        return [];
+    return [
+        [
+            "- **Editor**:",
+            ...this.state.editor.outputs.flatMap((output, index) => {
+                const lines = [
+                    `  - **Cycle ${index + 1}**: ${toTitleCase(output.mode.toLocaleLowerCase())}`,
+                ];
+                if (output.commitSha)
+                    lines.push(`    - **Commit**: \`${output.commitSha}\` ${output.commitMessage}`);
+                if (output.filesTouched.length) {
+                    lines.push("    - **Files touched**:");
+                    for (const file of output.filesTouched)
+                        lines.push(`      - \`${file}\``);
+                }
+                if (output.responses.length) {
+                    lines.push("    - **Responses**:");
+                    for (const { action, body, commentId } of output.responses) {
+                        const thread = this.state.pr?.threads?.find(({ comments }) => comments.some(({ databaseId }) => databaseId === commentId));
+                        const prefix = thread
+                            ? `${thread.path}:${thread.line ?? "N/A"}`
+                            : commentId;
+                        lines.push(`      - **${toTitleCase(action.toLocaleLowerCase())}** \`${prefix}\`: ${body}`);
+                    }
+                }
+                return lines;
+            }),
+        ].join("\n"),
+    ];
+}