opencode-magi 0.0.0-dev-20260702001022 → 0.0.0-dev-20260714064227

package/dist/commands.js

@@ -1,8 +1,4 @@
 export const commands = {
-    "magi:cancel": {
-        description: "Cancel active background Magi runs",
-        template: ["Call the `magi_cancel` tool.", "PR or Issue: $ARGUMENTS"].join("\n"),
-    },
     "magi:clear": {
         description: [
             "Clear inactive Magi runs, sessions, worktrees, and outputs",

package/dist/magi.js

@@ -1,14 +1,13 @@
 import { createOpencodeClient } from "@opencode-ai/sdk/v2";
 import { print } from "graphql";
 import { randomUUID } from "node:crypto";
-import { mkdir, readdir, readFile, rm, rmdir, writeFile, } from "node:fs/promises";
+import { appendFile, mkdir, readdir, readFile, rm, rmdir, writeFile, } from "node:fs/promises";
 import { dirname, isAbsolute, join, relative } from "node:path";
 import { Octokit } from "octokit";
 import { getConfig, resolvePermissions, validateConfig } from "@/config";
 import { graphql } from "@/graphql";
 import { command, createExec, filterEmpty, isArray, isNumber, isObject, merge, quote, } from "@/utils";
 const active = new Set(["preparing", "running"]);
-const backgrounds = new Map();
 export class MagiError extends Error {
     status;
     constructor(status, message) {
@@ -55,45 +54,6 @@ export class Magi {
     createGraphql(octokit) {
         return graphql((document, variables) => octokit.graphql(print(document), variables));
     }
-    registerBackground(number, controller) {
-        if (backgrounds.has(number))
-            this.cancelBackground(number);
-        backgrounds.set(number, controller);
-    }
-    unregisterBackground(number, signal) {
-        if (backgrounds.get(number)?.signal === signal)
-            backgrounds.delete(number);
-    }
-    cancelBackgrounds(numbers) {
-        const results = {
-            cancelled: [],
-            missing: [],
-        };
-        if (!numbers?.length)
-            numbers = [...backgrounds.keys()];
-        for (const number of numbers) {
-            const cancelled = this.cancelBackground(number);
-            results[cancelled ? "cancelled" : "missing"].push(number);
-        }
-        return results;
-    }
-    cancelBackground(number) {
-        const controller = backgrounds.get(number);
-        if (controller) {
-            controller.abort();
-            backgrounds.delete(number);
-            return true;
-        }
-        else {
-            return false;
-        }
-    }
-    async notify(sessionID, text) {
-        await this.input.client.session.promptAsync({
-            parts: [{ synthetic: true, text, type: "text" }],
-            sessionID,
-        });
-    }
     async clear(config) {
         const summary = {
             branch: 0,
@@ -177,10 +137,7 @@ export class Magi {
             updatedAt: createdAt,
             ...initialState,
         };
-        const values = [this.createStateFile(state)];
-        if (!state.sync && state.text)
-            values.push(this.notify(state.sessionId, state.text));
-        await Promise.all(values);
+        await this.createStateFile(state);
         return state;
     }
     async createStateFile(state) {
@@ -200,12 +157,30 @@ export class Magi {
         next.updatedAt = new Date().toISOString();
         const prev = await this.getState(dir);
         const state = merge(prev, next);
-        const values = [this.createStateFile(state)];
-        if (!state.sync && next.text)
-            values.push(this.notify(prev.sessionId, next.text));
-        await Promise.all(values);
+        await this.createStateFile(state);
         return state;
     }
+    async updateEvent(output, message) {
+        const event = {
+            createdAt: new Date().toISOString(),
+            message,
+        };
+        await appendFile(join(output, "events.jsonl"), `${JSON.stringify(event)}\n`);
+    }
+    async getEvents(output) {
+        try {
+            const content = await readFile(join(output, "events.jsonl"), "utf8");
+            return content
+                .split("\n")
+                .filter(Boolean)
+                .map((line) => JSON.parse(line));
+        }
+        catch (e) {
+            if (e instanceof Error && "code" in e && e.code === "ENOENT")
+                return [];
+            throw e;
+        }
+    }
     getSessionIds(state) {
         return [
             state.sessionId,

package/dist/tools/index.js

@@ -1,11 +1,9 @@
-import { cancel } from "./cancel";
 import { clear } from "./clear";
 import { merge } from "./merge";
 import { review } from "./review";
 import { triage } from "./triage";
 import { validate } from "./validate";
 export const tools = {
-    cancel,
     clear,
     merge,
     review,

package/dist/tools/merge/action.js

@@ -12,12 +12,12 @@ export async function editCycles(callback) {
         error: async (e, count) => {
             if (e !== error)
                 throw e;
-            await this.notify(`Attempt ${count} failed to edit cycles for ${this.getLink()}. Retrying...`);
+            await this.updateEvent(`Attempt ${count} failed to edit cycles. Retrying...`);
         },
         retries: this.config.merge.maxThreadResolutionCycles,
     });
     if (!verdict || verdict === "CHANGES_REQUESTED")
-        throw new MagiError("blocked", `Reached maximum edit cycles for ${this.getLink()}.`);
+        throw new MagiError("blocked", `Reached maximum edit cycles.`);
 }
 export async function postReplies() {
     this.context.abort.throwIfAborted();
@@ -28,9 +28,7 @@ export async function postReplies() {
         throw new MagiError("blocked", "Editor output not found.");
     if (!output.responses.length)
         return;
-    this.state = await this.magi.updateState(this.state.output, {
-        text: `Posting editor replies for ${this.getLink()}.`,
-    });
+    await this.updateEvent(`Posting editor replies.`);
     if (!this.state.editor?.account)
         throw new MagiError("blocked", "Editor account not found.");
     const octokit = await this.magi.createOctokit(this.config, this.context.abort, this.state.editor.account);
@@ -44,7 +42,5 @@ export async function postReplies() {
         body,
         comment_id: commentId,
     })));
-    this.state = await this.magi.updateState(this.state.output, {
-        text: `Finished posting editor replies for ${this.getLink()}.`,
-    });
+    await this.updateEvent(`Finished posting editor replies.`);
 }

package/dist/tools/merge/context.js

@@ -6,16 +6,14 @@ export async function fetchMergeContext() {
     const output = this.state.editor?.outputs?.at(-1);
     if (!output)
         throw new MagiError("blocked", "Editor output not found.");
-    this.state = await this.magi.updateState(this.state.output, {
-        text: `Fetching merge context for ${this.getLink()}.`,
-    });
+    await this.updateEvent(`Fetching merge context.`);
     const [comments, issues, threads] = await Promise.all([
         getComments.call(this),
         getClosingIssues.call(this),
         getReviewThreads.call(this),
     ]);
     const inlineCommentTargets = await getInlineCommentTargets.call(this);
-    this.state = await this.magi.updateState(this.state.output, {
+    await this.updateState({
         pr: {
             comments,
             inlineCommentTargets,
@@ -27,14 +25,12 @@ export async function fetchMergeContext() {
                 ])
                 : threads,
         },
-        text: `Finished fetching merge context for ${this.getLink()}.`,
     });
+    await this.updateEvent(`Finished fetching merge context.`);
 }
 export async function markRepliedReviewers() {
     this.context.abort.throwIfAborted();
-    this.state = await this.magi.updateState(this.state.output, {
-        text: `Marking replied reviewers for ${this.getLink()}.`,
-    });
+    await this.updateEvent(`Marking replied reviewers.`);
     const output = this.state.editor?.outputs?.at(-1);
     if (!output)
         throw new MagiError("blocked", "Editor output not found.");
@@ -60,10 +56,8 @@ export async function markRepliedReviewers() {
         id,
         { status: replied.includes(id) ? "reply" : "skip" },
     ]));
-    this.state = await this.magi.updateState(this.state.output, {
-        reviewers,
-        text: `Finished marking replied reviewers for ${this.getLink()}.`,
-    });
+    await this.updateState({ reviewers });
+    await this.updateEvent(`Finished marking replied reviewers.`);
 }
 function createSyntheticThreads() {
     const findings = Object.entries(this.state.reviewers ?? {}).flatMap(([reviewer, { account, outputs }]) => {

package/dist/tools/merge/editor.js

@@ -4,9 +4,7 @@ import { getMetadata } from "@/tools/review/check";
 import { command, filterDuplicates, filterEmpty, quote, retry } from "@/utils";
 export async function edit() {
     this.context.abort.throwIfAborted();
-    this.state = await this.magi.updateState(this.state.output, {
-        text: `Editing ${this.getLink()}.`,
-    });
+    await this.updateEvent(`Editing.`);
     await setAccount.call(this);
     const unresolvedThreads = await getUnresolvedThreads.call(this);
     const threads = this.state.dryRun
@@ -46,17 +44,17 @@ export async function edit() {
         }
         return output;
     }, {
-        error: (_, count) => this.notify(`Attempt ${count} failed to edit ${this.getLink()}. Retrying...`),
+        error: (_, count) => this.updateEvent(`Attempt ${count} failed to edit. Retrying...`),
         retries: this.config.output.repairAttempts,
     });
     if (!output)
         throw new MagiError("blocked", "Invalid output for editor.");
-    this.state = await this.magi.updateState(this.state.output, {
+    await this.updateState({
         editor: { outputs: [...(this.state.editor.outputs ?? []), output] },
-        text: `Finished editing ${this.getLink()}.`,
     });
-    await this.notify(filterEmpty([
-        `Editor ${output.mode === "EDITED" ? "edited" : "replied to"} ${this.getLink()}.`,
+    await this.updateEvent(`Finished editing.`);
+    await this.updateEvent(filterEmpty([
+        `Editor ${output.mode.toLocaleLowerCase()}.`,
         output.commitSha
             ? `Commit: ${output.commitSha}${output.commitMessage ? ` ${output.commitMessage}` : ""}`
             : undefined,
@@ -71,7 +69,7 @@ export async function edit() {
     ]).join("\n\n"));
     if (output.mode === "EDITED")
         if (this.state.dryRun) {
-            this.state = await this.magi.updateState(this.state.output, {
+            await this.updateState({
                 pr: {
                     files: filterDuplicates([
                         ...(this.state.pr?.files ?? []),
@@ -79,26 +77,20 @@ export async function edit() {
                     ]),
                     metadata: { head: { sha: output.commitSha } },
                 },
-                text: `Skipped pushing editor changes for ${this.getLink()} during dry run.`,
             });
+            await this.updateEvent(`Skipped pushing editor changes during dry run.`);
         }
         else {
-            this.state = await this.magi.updateState(this.state.output, {
-                text: `Pushing editor changes for ${this.getLink()}.`,
-            });
+            await this.updateEvent(`Pushing editor changes.`);
             const pr = await push.call(this);
-            this.state = await this.magi.updateState(this.state.output, {
-                pr,
-                text: `Finished pushing editor changes for ${this.getLink()}.`,
-            });
+            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();
-    this.state = await this.magi.updateState(this.state.output, {
-        text: `Resolving merge conflicts for ${this.getLink()}.`,
-    });
+    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 };
@@ -143,36 +135,32 @@ export async function resolveConflict() {
             responses: [],
         };
     }, {
-        error: (_, count) => this.notify(`Attempt ${count} failed to resolve conflicts for ${this.getLink()}. Retrying...`),
+        error: (_, count) => this.updateEvent(`Attempt ${count} failed to resolve conflicts. Retrying...`),
         retries: this.config.output.repairAttempts,
     });
     if (!output)
         throw new MagiError("blocked", "Invalid output for conflict editor.");
-    this.state = await this.magi.updateState(this.state.output, {
+    await this.updateState({
         editor: { outputs: [...(this.state.editor.outputs ?? []), output] },
-        text: `Finished resolving merge conflicts for ${this.getLink()}.`,
     });
+    await this.updateEvent(`Finished resolving merge conflicts.`);
     if (this.state.dryRun) {
-        this.state = await this.magi.updateState(this.state.output, {
+        await this.updateState({
             pr: {
                 files: filterDuplicates([
-                    ...(this.state.pr?.files ?? []),
+                    ...(this.state.pr.files ?? []),
                     ...output.filesTouched,
                 ]),
                 metadata: { head: { sha: output.commitSha } },
             },
-            text: `Skipped pushing conflict resolution for ${this.getLink()} during dry run.`,
         });
+        await this.updateEvent(`Skipped pushing conflict resolution during dry run.`);
     }
     else {
-        this.state = await this.magi.updateState(this.state.output, {
-            text: `Pushing conflict resolution for ${this.getLink()}.`,
-        });
+        await this.updateEvent(`Pushing conflict resolution.`);
         const pr = await push.call(this);
-        this.state = await this.magi.updateState(this.state.output, {
-            pr,
-            text: `Finished pushing conflict resolution for ${this.getLink()}.`,
-        });
+        await this.updateState({ pr });
+        await this.updateEvent(`Finished pushing conflict resolution.`);
     }
 }
 async function setAccount() {

package/dist/tools/merge/index.js

@@ -1,5 +1,5 @@
 import { tool } from "@opencode-ai/plugin";
-import { filterEmpty, parsePrs, split, Worker } from "@/utils";
+import { parsePrs, split, Worker } from "@/utils";
 import { Merge } from "./merge";
 async function editCycle(run, { conflict, cycle } = {}) {
     if (!run.state.editor?.sessionId)
@@ -32,7 +32,7 @@ async function editCycle(run, { conflict, cycle } = {}) {
     await run.postReviews();
     return verdict;
 }
-function overrideConfig(config, args, dryRun = false, sync = false) {
+function overrideConfig(config, args, dryRun = false) {
     for (let index = 0; index < args.length; index++) {
         const arg = args[index];
         const value = args[index + 1];
@@ -42,9 +42,6 @@ function overrideConfig(config, args, dryRun = false, sync = false) {
             case "--dry-run":
                 dryRun = true;
                 break;
-            case "--sync":
-                sync = true;
-                break;
             case "--retry-api-attempts":
                 config.github.retryApiAttempts = parseInt(value);
                 break;
@@ -89,7 +86,7 @@ function overrideConfig(config, args, dryRun = false, sync = false) {
                 break;
         }
     }
-    return { config, dryRun, sync };
+    return { config, dryRun };
 }
 export const merge = function (magi) {
     return {
@@ -97,23 +94,18 @@ export const merge = function (magi) {
             args: {
                 dryRun: tool.schema.boolean().optional(),
                 prs: tool.schema.string(),
-                sync: tool.schema.boolean().optional(),
             },
-            description: "Start background Magi merge runs for one or more pull requests with configured Magi agents. After starting, monitor progress yourself when useful; do not tell users to call follow-up tools by name.",
+            description: "Review, fix, and merge one or more pull requests.",
             async execute(args, context) {
                 const prs = parsePrs(args.prs);
-                const { config, dryRun, sync } = overrideConfig(await magi.getConfig({ editor: true, reviewers: true }), split(args.prs), args.dryRun, args.sync);
+                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 states = [];
-                const tasks = [];
-                for (const pr of prs) {
+                const reports = await Promise.all(prs.map(async (pr) => {
                     context.abort.throwIfAborted();
-                    const run = await Merge.init(pr, magi, config, context, {
-                        dryRun,
-                        sync,
-                    });
-                    states.push(run.state);
-                    const task = worker.run(async () => {
+                    return worker.run(async () => {
+                        const run = await Merge.init(pr, magi, config, context, {
+                            dryRun,
+                        });
                         try {
                             await run.checkPr();
                             const skip = await run.checkExistingReviews();
@@ -148,20 +140,8 @@ export const merge = function (magi) {
                             await run.cleanup();
                         }
                     });
-                    tasks.push(task);
-                    if (!sync)
-                        void task;
-                }
-                if (sync) {
-                    const results = await Promise.all(tasks);
-                    const output = filterEmpty(results.map(({ text }) => text)).join("\n\n");
-                    if (results.some(({ status }) => status === "failed" || status === "cancelled"))
-                        throw new Error(output);
-                    return output;
-                }
-                else {
-                    return filterEmpty(states.map(({ text }) => text)).join("\n");
-                }
+                }));
+                return reports.join("\n\n");
             },
         }),
     };

package/dist/tools/merge/merge.js

@@ -8,11 +8,6 @@ import { edit, resolveConflict } from "./editor";
 import { createReport } from "./report";
 export class Merge extends Review {
     static async init(number, magi, config, context, options) {
-        if (!options.sync) {
-            const controller = new AbortController();
-            context = { ...context, abort: controller.signal };
-            magi.registerBackground(number, controller);
-        }
         const url = `${config.github.url}/pull/${number}`;
         const octokit = await magi.createOctokit(config, context.abort);
         const graphql = magi.createGraphql(octokit);
@@ -35,8 +30,8 @@ export class Merge extends Review {
             repo: quote(`${config.github.owner}/${config.github.repo}`),
             reviewers,
             sessionId: context.sessionID,
-            text: `Started merging [#${number}](${url}).`,
         });
+        await magi.updateEvent(state.output, `Started merging.`);
         const exec = createExecWithGitHubApiRetry(magi.exec, config.github.retryApiAttempts);
         return new Merge(number, magi, config, context, octokit, graphql, exec, state);
     }
@@ -51,18 +46,14 @@ export class Merge extends Review {
         this.context.abort.throwIfAborted();
         if (!this.state.editor)
             throw new MagiError("blocked", "Editor not found.");
-        this.state = await this.magi.updateState(this.state.output, {
-            text: `Creating editor session for ${this.getLink()}.`,
-        });
+        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.state = await this.magi.updateState(this.state.output, {
-            editor,
-            text: `Finished creating editor session for ${this.getLink()}.`,
-        });
+        await this.updateState({ editor });
+        await this.updateEvent(`Finished creating editor session.`);
     }
 }

package/dist/tools/merge/report.js

@@ -6,13 +6,13 @@ import { filterEmpty, toTitleCase } from "@/utils";
 export async function createReport(e) {
     if (!e) {
         const status = "completed";
-        const text = createContent.call(this, { status });
+        const text = await createContent.call(this, { status });
         await writeFile(join(this.state.output, "report.md"), `${text}\n`);
-        return this.magi.updateState(this.state.output, {
+        await this.updateState({
             completedAt: new Date().toISOString(),
             status,
-            text,
         });
+        return text;
     }
     else {
         const error = e instanceof Error ? e.message : "Unknown error";
@@ -21,19 +21,18 @@ export async function createReport(e) {
             : this.context.abort.aborted
                 ? "cancelled"
                 : "failed";
-        const text = createContent.call(this, { error, status });
+        const text = await createContent.call(this, { error, status });
         await writeFile(join(this.state.output, "report.md"), `${text}\n`);
-        return this.magi.updateState(this.state.output, {
+        await this.updateState({
             completedAt: new Date().toISOString(),
-            error,
             status,
-            text: `${toTitleCase(status)} merging ${this.getLink()}.\n\n${text}`,
         });
+        return text;
     }
 }
-function createContent(input) {
+async function createContent(input) {
     return filterEmpty([
-        ...createMetaContent.call(this, input),
+        ...(await createMetaContent.call(this, input)),
         ...createCheckContent.call(this),
         ...createReviewerContent.call(this),
         ...createEditorContent.call(this),