opencode-magi 0.6.1 → 0.8.0

package/dist/github/commands.js

@@ -404,6 +404,15 @@ export async function assignIssue(exec, repository, issue, account) {
     const token = await ghToken(exec, repository, account);
     return exec(`gh issue edit ${issue} --repo ${shellQuote(repoSpecifier(repository))} --add-assignee ${shellQuote(account)}`, ghTokenEnv(token));
 }
+export async function addIssueLabels(exec, repository, issue, labels, account) {
+    const token = await ghToken(exec, repository, account);
+    const added = [];
+    for (const label of labels) {
+        await exec(`gh issue edit ${issue} --repo ${shellQuote(repoSpecifier(repository))} --add-label ${shellQuote(label)}`, ghTokenEnv(token));
+        added.push(label);
+    }
+    return added;
+}
 export async function removeIssueLabels(exec, repository, issue, labels, account) {
     const token = await ghToken(exec, repository, account);
     const removed = [];
@@ -685,6 +694,29 @@ export async function waitForAutoMerge(exec, repository, pr, intervalMs = 30_000
         await new Promise((resolve) => setTimeout(resolve, intervalMs));
     }
 }
+export async function fetchBaseBranch(exec, repository, meta, worktreePath) {
+    await exec(`git fetch --no-tags ${shellQuote(repositoryGitUrl(repository, repository.github.owner, repository.github.repo))} ${shellQuote(`refs/heads/${meta.baseRefName}`)}`, { cwd: worktreePath });
+}
+export async function mergeBaseNoCommit(exec, baseSha, worktreePath) {
+    await exec(`git merge --no-commit --no-ff ${shellQuote(baseSha)}`, {
+        cwd: worktreePath,
+    }).catch(() => undefined);
+}
+export async function listUnmergedFiles(exec, worktreePath) {
+    const output = await exec("git diff --name-only --diff-filter=U", {
+        cwd: worktreePath,
+    });
+    return output
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean);
+}
+export async function abortMerge(exec, worktreePath) {
+    await exec("git merge --abort", { cwd: worktreePath }).catch(() => undefined);
+}
+export async function currentHeadSha(exec, worktreePath) {
+    return (await exec("git rev-parse HEAD", { cwd: worktreePath })).trim();
+}
 export async function closePullRequest(exec, repository, pr, account) {
     const token = await ghToken(exec, repository, account);
     return exec(`gh pr close ${pr} --repo ${shellQuote(repoSpecifier(repository))}`, ghTokenEnv(token));

package/dist/index.js

@@ -9,7 +9,7 @@ import { loadConfig, mergeMagiConfig } from "./config/load";
 import { outputBaseDirs } from "./config/output";
 import { worktreeBaseDirs } from "./config/worktree";
 import { resolveRepository } from "./config/resolve";
-import { validateConfig } from "./config/validate";
+import { validateConfig, } from "./config/validate";
 import { withGitHubApiRetry } from "./github/retry";
 import { mapPool } from "./orchestrator/pool";
 import { MagiRunManager } from "./orchestrator/run-manager";
@@ -286,23 +286,6 @@ function parseOptionalIssue(value) {
 function clearFlag(value) {
     return typeof value === "boolean" ? value : undefined;
 }
-function clearToolFlag(value) {
-    if (value === true || value === "true")
-        return true;
-    if (value === "false")
-        return false;
-    return undefined;
-}
-function hasBlankSelector(args) {
-    return !args.runId?.trim() && !args.pr?.trim();
-}
-function hasDefaultedFalseClearFlags(args) {
-    return (hasBlankSelector(args) &&
-        args.branch === "false" &&
-        args.output === "false" &&
-        args.session === "false" &&
-        args.worktree === "false");
-}
 function parseQuestionAnswers(value) {
     const trimmed = value.trim();
     if (!trimmed)
@@ -334,6 +317,9 @@ function issueMarkdownLink(repository, issue) {
     const url = `https://${host}/${repository.github.owner}/${repository.github.repo}/issues/${issue}`;
     return `[#${issue}](${url})`;
 }
+function validationError(validation) {
+    return new Error(JSON.stringify(validation, null, 2));
+}
 function isPlainObject(value) {
     return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
@@ -395,7 +381,8 @@ export async function validateMagiConfigFiles(directory, options = {}) {
                 ? withGitHubApiRetry(options.exec, mergedConfig.github?.apiRetryAttempts ?? 3)
                 : undefined,
             modelCatalog: options.modelCatalog,
-            requireGithub: hasProjectConfig && Boolean(mergedConfig.review?.agents),
+            requireGithub: hasProjectConfig && Boolean(mergedConfig.review?.reviewers),
+            requireModelCatalog: true,
             requireWorktreeConfig: true,
         });
         loadedFrom = existing.map((status) => status.path).join(", ");
@@ -447,7 +434,8 @@ export const MagiPlugin = async ({ client, directory }) => {
             .then(extractModelCatalog)
             .catch(() => catalogClient.provider
             ?.list({ query: { directory } })
-            .then(extractModelCatalog));
+            .then(extractModelCatalog))
+            .catch(() => undefined);
         return modelCatalogPromise;
     }
     return {
@@ -492,9 +480,10 @@ export const MagiPlugin = async ({ client, directory }) => {
                         exec: retryingExec,
                         modelCatalog: await modelCatalog(),
                         requireEditor: true,
+                        requireModelCatalog: true,
                     });
                     if (!validation.ok)
-                        return JSON.stringify(validation, null, 2);
+                        throw validationError(validation);
                     const repository = resolveRepository(config);
                     const sync = parsed.sync || args.sync === true;
                     const states = await mapPool(parsed.prs, repository.concurrency.runs, (pr) => runManager.startMerge({
@@ -534,9 +523,10 @@ export const MagiPlugin = async ({ client, directory }) => {
                         directory,
                         exec: retryingExec,
                         modelCatalog: await modelCatalog(),
+                        requireModelCatalog: true,
                     });
                     if (!validation.ok)
-                        return JSON.stringify(validation, null, 2);
+                        throw validationError(validation);
                     const repository = resolveRepository(config);
                     const sync = parsed.sync || args.sync === true;
                     const states = await mapPool(parsed.prs, repository.concurrency.runs, (pr) => runManager.startReview({
@@ -557,7 +547,7 @@ export const MagiPlugin = async ({ client, directory }) => {
                 },
             }),
             magi_triage: tool({
-                description: "Triage one or more GitHub issues with configured Magi triage agents.",
+                description: "Triage one or more GitHub issues with configured Magi triage voters.",
                 args: {
                     issues: tool.schema.string(),
                     dryRun: tool.schema.boolean().optional(),
@@ -574,12 +564,13 @@ export const MagiPlugin = async ({ client, directory }) => {
                         exec: retryingExec,
                         modelCatalog: await modelCatalog(),
                         requireEditor: config.triage?.automation?.merge === true,
+                        requireModelCatalog: true,
                         requireReview: config.triage?.automation?.review === true ||
                             config.triage?.automation?.merge === true,
                         requireTriage: true,
                     });
                     if (!validation.ok)
-                        return JSON.stringify(validation, null, 2);
+                        throw validationError(validation);
                     const repository = resolveRepository(config);
                     if (!repository.triage)
                         return JSON.stringify({ errors: ["triage configuration is required"], ok: false }, null, 2);
@@ -692,41 +683,21 @@ export const MagiPlugin = async ({ client, directory }) => {
             }),
             magi_clear: tool({
                 description: "Clear all inactive Magi runs by deleting configured sessions, worktrees, branches, and output artifacts.",
-                args: {
-                    runId: tool.schema.string().optional(),
-                    pr: tool.schema.string().optional(),
-                    issue: tool.schema.string().optional(),
-                    branch: tool.schema.enum(["true", "false"]).optional(),
-                    output: tool.schema.enum(["true", "false"]).optional(),
-                    session: tool.schema.enum(["true", "false"]).optional(),
-                    worktree: tool.schema.enum(["true", "false"]).optional(),
-                },
-                async execute(args) {
+                args: {},
+                async execute() {
                     const loaded = await loadConfig(directory).catch(() => undefined);
                     const clear = loaded?.config.clear;
-                    const useConfiguredDefaults = hasDefaultedFalseClearFlags(args);
                     const options = {
-                        branch: (useConfiguredDefaults
-                            ? undefined
-                            : clearToolFlag(args.branch)) ?? clearFlag(clear?.branch),
-                        output: (useConfiguredDefaults
-                            ? undefined
-                            : clearToolFlag(args.output)) ?? clearFlag(clear?.output),
-                        session: (useConfiguredDefaults
-                            ? undefined
-                            : clearToolFlag(args.session)) ?? clearFlag(clear?.session),
-                        worktree: (useConfiguredDefaults
-                            ? undefined
-                            : clearToolFlag(args.worktree)) ?? clearFlag(clear?.worktree),
+                        branch: clearFlag(clear?.branch),
+                        output: clearFlag(clear?.output),
+                        session: clearFlag(clear?.session),
+                        worktree: clearFlag(clear?.worktree),
                     };
                     return runManager.clear({
                         options,
-                        issue: parseOptionalIssue(args.issue),
                         outputDir: loaded
                             ? outputBaseDirs(directory, loaded.config)
                             : undefined,
-                        pr: parseOptionalPr(args.pr),
-                        runId: args.runId,
                         worktreeDir: loaded
                             ? worktreeBaseDirs(directory, loaded.config)
                             : undefined,

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";
@@ -433,6 +433,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 +874,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 +933,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 +1156,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`,