opencode-magi 0.7.0 → 0.9.0

package/dist/orchestrator/merge.js

@@ -1,8 +1,8 @@
 import { mkdir, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { prRunOutputDir } from "../config/output";
-import { closePullRequest, configureGitIdentity, fetchMergeQueueRequirement, fetchPullRequest, fetchUnresolvedThreads, mergePullRequest, postApproval, postChangesRequested, postCloseComment, postReply, pushHead, removeWorktree, resolveThread, waitForAutoMerge, waitForMergeQueue, } from "../github/commands";
-import { composeEditPrompt, composeRereviewCloseReconsiderationPrompt, composeRereviewPrompt, } from "../prompts/compose";
+import { abortMerge, closePullRequest, configureGitIdentity, currentHeadSha, fetchBaseBranch, fetchMergeQueueRequirement, fetchPullRequest, fetchUnresolvedThreads, listUnmergedFiles, mergePullRequest, mergeBaseNoCommit, postApproval, postChangesRequested, postCloseComment, postReply, pushHead, removeWorktree, resolveThread, waitForAutoMerge, waitForMergeQueue, } from "../github/commands";
+import { composeEditPrompt, composeMergeConflictPrompt, composeRereviewCloseReconsiderationPrompt, composeRereviewPrompt, } from "../prompts/compose";
 import { parseEditOutput, parseRereviewCloseReconsiderationOutput, parseRereviewOutput, } from "../prompts/output";
 import { throwIfAborted, withAbortSignal } from "./abort";
 import { waitForChecksWithClassification } from "./ci";
@@ -11,7 +11,7 @@ import { closeMinorityReviewers, mergeVerdictForPolicy } from "./majority";
 import { runModelWithRepair } from "./model";
 import { mapPool } from "./pool";
 import { formatMergeReport } from "./report";
-import { inlineCommentTargetsForDiff, runReview, } from "./review";
+import { inlineCommentTargetsForDiff, assignThreadsByReviewFindingMarker, formatReviewMarker, postSingleConsensusReview, runReview, reviewPostingAccount, } from "./review";
 import { checkSafetyGate, hasSafetyGate } from "./safety";
 function outputDir(input) {
     return prRunOutputDir({
@@ -131,6 +131,7 @@ async function postRereviewOutput(input, reviewerKey, output) {
     const reviewer = input.repository.agents.reviewers.find((item) => item.key === reviewerKey);
     if (!reviewer)
         throw new Error(`Unknown reviewer: ${reviewerKey}`);
+    const account = reviewPostingAccount(input.repository, reviewer);
     if (input.dryRun) {
         if (output.verdict === "MERGE")
             return `dry-run:would-approve:${reviewerKey}`;
@@ -139,16 +140,16 @@ async function postRereviewOutput(input, reviewerKey, output) {
         }
         return `dry-run:would-request-changes:${reviewerKey}`;
     }
-    await Promise.all(output.resolve.map((item) => resolveThread(input.exec, input.repository, reviewer.account, item.threadId)));
-    const replies = await Promise.all(output.followUps.map((item) => postReply(input.exec, input.repository, input.pr, reviewer.account, item.commentId, item.body)));
+    await Promise.all(output.resolve.map((item) => resolveThread(input.exec, input.repository, account, item.threadId)));
+    const replies = await Promise.all(output.followUps.map((item) => postReply(input.exec, input.repository, input.pr, account, item.commentId, item.body)));
     if (output.verdict === "MERGE") {
-        return postApproval(input.exec, input.repository, input.pr, reviewer.account);
+        return postApproval(input.exec, input.repository, input.pr, account);
     }
     if (output.verdict === "CLOSE") {
-        return postCloseComment(input.exec, input.repository, input.pr, reviewer.account, output.reason ?? "Close requested.");
+        return postCloseComment(input.exec, input.repository, input.pr, account, output.reason ?? "Close requested.");
     }
     if (output.newFindings.length) {
-        return postChangesRequested(input.exec, input.repository, input.pr, reviewer.account, output.newFindings.map((finding) => ({
+        return postChangesRequested(input.exec, input.repository, input.pr, account, output.newFindings.map((finding) => ({
             fix: "Please address this before merging.",
             issue: finding.body,
             path: finding.path,
@@ -212,10 +213,23 @@ async function runRereview(input, worktreePath, previousHeadSha, cycle, sessionI
         worktreePath,
     });
     const artifactDir = outputDir(input);
+    const singleReviewMode = input.repository.review?.mode !== "multi";
+    const reviewerKeys = input.repository.agents.reviewers.map((reviewer) => reviewer.key);
+    const singleModeThreads = singleReviewMode
+        ? assignThreadsByReviewFindingMarker({
+            fallbackReviewerKeys: reviewerKeys,
+            pr: input.pr,
+            reviewerKeys,
+            threads: options.dryRunThreads == null
+                ? await fetchUnresolvedThreads(input.exec, input.repository, input.pr, input.repository.review?.account ?? "")
+                : Object.values(options.dryRunThreads).flat(),
+        })
+        : undefined;
     let entries = await mapPool(input.repository.agents.reviewers, input.repository.concurrency.reviewers, async (reviewer) => {
         throwIfAborted(input.signal);
-        const unresolved = options.dryRunThreads?.[reviewer.key] ??
-            (await fetchUnresolvedThreads(input.exec, input.repository, input.pr, reviewer.account));
+        const unresolved = singleModeThreads?.[reviewer.key] ??
+            options.dryRunThreads?.[reviewer.key] ??
+            (await fetchUnresolvedThreads(input.exec, input.repository, input.pr, reviewPostingAccount(input.repository, reviewer)));
         const hasReviewerSession = Boolean(sessionIds[reviewer.key]);
         const prompt = await composeRereviewPrompt({
             baseSha: meta.baseRefOid,
@@ -388,14 +402,44 @@ async function runRereview(input, worktreePath, previousHeadSha, cycle, sessionI
             };
         }));
     }
-    const posted = Object.fromEntries(await Promise.all(entries.map(async (entry) => [
-        entry.reviewer,
-        await postRereviewOutput(input, entry.reviewer, entry.output),
-    ])));
     const verdict = mergeVerdictForPolicy(entries.map((entry) => ({
         reviewer: entry.reviewer,
         verdict: entry.verdict,
     })), input.repository.merge.approvalPolicy);
+    const outputs = Object.fromEntries(entries.map((entry) => [entry.reviewer, entry.output]));
+    const posted = singleReviewMode
+        ? input.dryRun
+            ? { consensus: `dry-run:would-post-single-review:${verdict}` }
+            : {
+                consensus: await (async () => {
+                    const account = input.repository.review?.account ?? "";
+                    await Promise.all(entries.flatMap((entry) => entry.output.resolve.map((item) => resolveThread(input.exec, input.repository, account, item.threadId))));
+                    await Promise.all(entries.flatMap((entry) => entry.output.followUps.map((item) => postReply(input.exec, input.repository, input.pr, account, item.commentId, [
+                        `**Reviewer:** ${entry.reviewer}`,
+                        "",
+                        item.body,
+                        "",
+                        formatReviewMarker({
+                            head: headSha,
+                            pr: input.pr,
+                            reviewer: entry.reviewer,
+                            verdict: entry.output.verdict,
+                        }),
+                    ].join("\n")))));
+                    return postSingleConsensusReview({
+                        exec: input.exec,
+                        headSha,
+                        outputs,
+                        pr: input.pr,
+                        repository: input.repository,
+                        verdict,
+                    });
+                })(),
+            }
+        : Object.fromEntries(await Promise.all(entries.map(async (entry) => [
+            entry.reviewer,
+            await postRereviewOutput(input, entry.reviewer, entry.output),
+        ])));
     await writeFile(join(artifactDir, `rereview-majority.cycle-${cycle}.json`), JSON.stringify({
         approvalPolicy: input.repository.merge.approvalPolicy,
         verdict,
@@ -405,7 +449,7 @@ async function runRereview(input, worktreePath, previousHeadSha, cycle, sessionI
         })),
     }, null, 2));
     return {
-        outputs: Object.fromEntries(entries.map((entry) => [entry.reviewer, entry.output])),
+        outputs,
         posted,
         verdict,
     };
@@ -433,6 +477,224 @@ async function mergeWithQueue(input, exec, editorAccount) {
     }
     return waitForMergeQueue(exec, input.repository, input.pr);
 }
+async function runConflictEditor(input) {
+    const editor = input.run.repository.agents.editor;
+    if (!editor)
+        throw new Error("merge.editor is required for magi_merge");
+    await configureGitIdentity(input.run.exec, input.worktreePath, {
+        email: editor.author?.email,
+        name: editor.author?.name,
+    });
+    const artifactDir = outputDir(input.run);
+    const prompt = await composeMergeConflictPrompt({
+        baseBranch: input.baseBranch,
+        baseSha: input.baseSha,
+        conflictedFiles: JSON.stringify(input.conflictedFiles, null, 2),
+        directory: input.run.directory,
+        headSha: input.headSha,
+        pr: input.run.pr,
+        repository: input.run.repository,
+        worktreePath: input.worktreePath,
+    });
+    await input.run.onProgress?.({ cycle: input.cycle, type: "editor_started" });
+    const result = await withEditorFailureProgress({
+        cycle: input.cycle,
+        onProgress: input.run.onProgress,
+        run: () => runModelWithRepair({
+            client: input.run.client,
+            model: editor.model,
+            onProgress: async (progress) => {
+                if (progress.type === "session_created") {
+                    await input.run.onProgress?.({
+                        cycle: input.cycle,
+                        options: progress.options,
+                        sessionId: progress.sessionId,
+                        type: "editor_session",
+                    });
+                }
+                if (progress.type === "repair") {
+                    await input.run.onProgress?.({
+                        cycle: input.cycle,
+                        type: "editor_repair",
+                    });
+                }
+                if (progress.type === "response") {
+                    await input.run.onProgress?.({
+                        cycle: input.cycle,
+                        sessionId: progress.sessionId,
+                        type: "editor_response",
+                    });
+                }
+            },
+            options: editor.options,
+            parentSessionId: input.run.parentSessionId,
+            parse: parseEditOutput,
+            permission: editor.permission,
+            prompt,
+            repairAttempts: input.run.config.output?.repairAttempts ?? 3,
+            schemaName: "edit",
+            signal: input.run.signal,
+            title: `magi resolve conflict ${input.run.repository.alias}#${input.run.pr}`,
+        }),
+    });
+    await writeFile(join(artifactDir, "editor.conflict.prompt.txt"), prompt);
+    await writeFile(join(artifactDir, "editor.conflict.raw.txt"), result.raw);
+    await writeFile(join(artifactDir, "editor.conflict.json"), JSON.stringify(result.value, null, 2));
+    await input.run.onProgress?.({ cycle: input.cycle, type: "editor_completed" });
+    return result.value;
+}
+async function recoverMergeQueueConflict(input) {
+    await input.run.onProgress?.({
+        phase: "checking merge queue conflict",
+        type: "phase",
+    });
+    const meta = await fetchPullRequest(input.exec, input.run.repository, input.run.pr);
+    if (meta.state && meta.state.toUpperCase() !== "OPEN")
+        return undefined;
+    await fetchBaseBranch(input.exec, input.run.repository, meta, input.worktreePath);
+    await mergeBaseNoCommit(input.exec, meta.baseRefOid, input.worktreePath);
+    const conflictedFiles = await listUnmergedFiles(input.exec, input.worktreePath);
+    if (!conflictedFiles.length) {
+        await abortMerge(input.exec, input.worktreePath);
+        return undefined;
+    }
+    await input.run.onProgress?.({
+        phase: "resolving merge conflict",
+        type: "phase",
+    });
+    const editorOutput = await runConflictEditor({
+        baseBranch: meta.baseRefName,
+        baseSha: meta.baseRefOid,
+        conflictedFiles,
+        cycle: input.cycle,
+        headSha: input.previousHeadSha,
+        run: input.run,
+        worktreePath: input.worktreePath,
+    });
+    if (editorOutput.mode !== "EDITED") {
+        return {
+            ciReports: input.ciReports,
+            editorOutput,
+            headSha: input.previousHeadSha,
+            outputs: {},
+            posted: {},
+            status: "changes_unresolved",
+        };
+    }
+    const remainingConflicts = await listUnmergedFiles(input.exec, input.worktreePath);
+    const editedHeadSha = await currentHeadSha(input.exec, input.worktreePath);
+    if (remainingConflicts.length || editedHeadSha === input.previousHeadSha) {
+        return {
+            ciReports: input.ciReports,
+            editorOutput,
+            headSha: input.previousHeadSha,
+            outputs: {},
+            posted: {},
+            status: "changes_unresolved",
+        };
+    }
+    const editor = input.run.repository.agents.editor;
+    if (!editor)
+        throw new Error("merge.editor is required for magi_merge");
+    const headOwner = meta.headRepositoryOwner?.login;
+    const headRepo = meta.headRepository?.name;
+    if (!headOwner || !headRepo) {
+        throw new Error("Pull request head repository is missing");
+    }
+    await pushHead(input.exec, input.run.repository, input.worktreePath, editor.account, { owner: headOwner, ref: meta.headRefName, repo: headRepo });
+    const ciReports = [...input.ciReports];
+    let ciFailureContext = "";
+    await input.run.onProgress?.({
+        phase: "waiting for checks after conflict resolution",
+        type: "phase",
+    });
+    const checkResult = await waitForChecksWithClassification({
+        afterEdit: {
+            cycle: input.cycle,
+            headSha: editedHeadSha,
+            previousHeadSha: input.previousHeadSha,
+            worktreePath: input.worktreePath,
+        },
+        client: input.run.client,
+        directory: input.run.directory,
+        exec: input.exec,
+        headSha: editedHeadSha,
+        onProgress: (phase) => input.run.onProgress?.({ phase, type: "phase" }),
+        parentSessionId: input.run.parentSessionId,
+        pr: input.run.pr,
+        repairAttempts: input.run.config.output?.repairAttempts ?? 3,
+        repository: input.run.repository,
+        signal: input.run.signal,
+        wait: input.run.repository.checks.waitAfterEdit,
+    });
+    ciFailureContext = checkResult?.ciFailureContext ?? "";
+    if (checkResult &&
+        (checkResult.report.scopeOutsideRecovered.length ||
+            checkResult.report.scopeOutsideUnresolved.length ||
+            checkResult.report.scopeInside.length)) {
+        ciReports.push(checkResult.report);
+        await input.run.onProgress?.({
+            report: checkResult.report,
+            type: "ci_report",
+        });
+    }
+    await input.run.onProgress?.({
+        phase: "rereview after conflict resolution",
+        type: "phase",
+    });
+    const rereview = await runRereview(input.run, input.worktreePath, input.previousHeadSha, input.cycle, input.sessionIds, ciFailureContext);
+    if (rereview.verdict === "CLOSE") {
+        if (!input.run.repository.automation.close) {
+            return {
+                ciReports,
+                editorOutput,
+                headSha: editedHeadSha,
+                outputs: rereview.outputs,
+                posted: rereview.posted,
+                status: "close_requested",
+            };
+        }
+        await input.run.onProgress?.({ phase: "closing PR", type: "phase" });
+        await closePullRequest(input.exec, input.run.repository, input.run.pr, editor.account);
+        return {
+            ciReports,
+            editorOutput,
+            headSha: editedHeadSha,
+            outputs: rereview.outputs,
+            posted: rereview.posted,
+            status: "closed",
+        };
+    }
+    if (rereview.verdict === "MERGE") {
+        if (hasBlockingCiReports(ciReports)) {
+            return {
+                ciReports,
+                editorOutput,
+                headSha: editedHeadSha,
+                outputs: rereview.outputs,
+                posted: rereview.posted,
+                status: "ci_unresolved",
+            };
+        }
+        await input.run.onProgress?.({ phase: "re-enqueueing PR", type: "phase" });
+        const status = await mergeWithQueue(input.run, input.exec, editor.account);
+        return {
+            ciReports,
+            editorOutput,
+            headSha: editedHeadSha,
+            outputs: rereview.outputs,
+            posted: rereview.posted,
+            status,
+        };
+    }
+    return {
+        ciReports,
+        editorOutput,
+        headSha: editedHeadSha,
+        outputs: rereview.outputs,
+        posted: rereview.posted,
+    };
+}
 export function hasBlockingCiReports(reports) {
     return reports.some((report) => report.scopeInside.length || report.scopeOutsideUnresolved.length);
 }
@@ -656,6 +918,28 @@ export async function runMerge(input) {
             outputs: reportOutputs,
             posted: reportPosted,
         });
+        let previousHeadSha = review.headSha;
+        const ciReports = [...review.ciReports];
+        const threadAttempts = {};
+        let dryRunThreads = input.dryRun
+            ? syntheticReviewThreads(reportOutputs)
+            : undefined;
+        let conflictRecoveryAttempted = false;
+        const applyConflictRecovery = (recovery) => {
+            editorOutputs.push({
+                ...recovery.editorOutput,
+                label: "Conflict recovery",
+            });
+            ciReports.length = 0;
+            ciReports.push(...recovery.ciReports);
+            reportCiReports = [...recovery.ciReports];
+            if (Object.keys(recovery.outputs).length)
+                reportOutputs = recovery.outputs;
+            if (Object.keys(recovery.posted).length)
+                reportPosted = recovery.posted;
+            previousHeadSha = recovery.headSha;
+            dryRunThreads = undefined;
+        };
         if (review.verdict === "SAFETY_BLOCKED") {
             await input.onProgress?.({
                 status: "safety_blocked",
@@ -693,15 +977,45 @@ export async function runMerge(input) {
             }
             await input.onProgress?.({ phase: "merging PR", type: "phase" });
             const status = await mergeWithQueue(input, exec, editor.account);
-            await input.onProgress?.({ status, type: "merge_completed" });
-            return complete({ cycles: 0, pr: input.pr, status });
+            if (status === "dequeued" &&
+                input.repository.automation.conflict &&
+                input.repository.merge.mergeQueue) {
+                if (!review.worktreePath)
+                    throw new Error("Review worktree is missing");
+                conflictRecoveryAttempted = true;
+                const recovery = await recoverMergeQueueConflict({
+                    ciReports,
+                    cycle: 1,
+                    exec,
+                    previousHeadSha,
+                    run: abortableInput,
+                    sessionIds: review.sessionIds,
+                    worktreePath: review.worktreePath,
+                });
+                if (recovery) {
+                    applyConflictRecovery(recovery);
+                    if (recovery.status) {
+                        await input.onProgress?.({
+                            status: recovery.status,
+                            type: "merge_completed",
+                        });
+                        return complete({
+                            cycles: 1,
+                            pr: input.pr,
+                            status: recovery.status,
+                        });
+                    }
+                }
+                else {
+                    await input.onProgress?.({ status, type: "merge_completed" });
+                    return complete({ cycles: 0, pr: input.pr, status });
+                }
+            }
+            else {
+                await input.onProgress?.({ status, type: "merge_completed" });
+                return complete({ cycles: 0, pr: input.pr, status });
+            }
         }
-        let previousHeadSha = review.headSha;
-        const ciReports = [...review.ciReports];
-        const threadAttempts = {};
-        let dryRunThreads = input.dryRun
-            ? syntheticReviewThreads(reportOutputs)
-            : undefined;
         for (let cycle = 1;; cycle += 1) {
             const unresolvedThreads = input.dryRun
                 ? flattenSyntheticThreads(dryRunThreads ?? {})
@@ -886,6 +1200,36 @@ export async function runMerge(input) {
                 }
                 await input.onProgress?.({ phase: "merging PR", type: "phase" });
                 const status = await mergeWithQueue(input, exec, editor.account);
+                if (status === "dequeued" &&
+                    input.repository.automation.conflict &&
+                    input.repository.merge.mergeQueue &&
+                    !conflictRecoveryAttempted) {
+                    conflictRecoveryAttempted = true;
+                    const recovery = await recoverMergeQueueConflict({
+                        ciReports,
+                        cycle: cycle + 1,
+                        exec,
+                        previousHeadSha,
+                        run: abortableInput,
+                        sessionIds: review.sessionIds,
+                        worktreePath: review.worktreePath,
+                    });
+                    if (recovery) {
+                        applyConflictRecovery(recovery);
+                        if (recovery.status) {
+                            await input.onProgress?.({
+                                status: recovery.status,
+                                type: "merge_completed",
+                            });
+                            return complete({
+                                cycles: cycle + 1,
+                                pr: input.pr,
+                                status: recovery.status,
+                            });
+                        }
+                        continue;
+                    }
+                }
                 await input.onProgress?.({ status, type: "merge_completed" });
                 return complete({ cycles: cycle, pr: input.pr, status });
             }

package/dist/orchestrator/report.js

@@ -138,7 +138,7 @@ function editorLines(outputs) {
     return [
         "- **Editor**:",
         ...outputs.flatMap((output, index) => {
-            const label = `  - Cycle ${index + 1}`;
+            const label = `  - ${output.label ?? `Cycle ${index + 1}`}`;
             if (output.mode === "REPLIED") {
                 return [
                     `${label}: replied without code changes`,