opencode-magi 0.0.0-dev-20260520045400 → 0.0.0-dev-20260520064744

package/dist/commands.js

@@ -3,6 +3,10 @@ export const MAGI_COMMANDS = {
         description: "Clear inactive Magi runs, sessions, worktrees, and outputs",
         template: "Call the `magi_clear` tool.",
     },
+    "magi:cancel": {
+        description: "Cancel a Magi background run",
+        template: [`Call the \`magi_cancel\` tool.`, "Selector: $ARGUMENTS"].join("\n"),
+    },
     "magi:merge": {
         description: "Review and merge pull requests with Magi",
         template: [`Call the \`magi_merge\` tool.`, "PR: $ARGUMENTS"].join("\n"),
@@ -15,6 +19,14 @@ export const MAGI_COMMANDS = {
         description: "Review pull requests with Magi",
         template: [`Call the \`magi_review\` tool.`, "PR: $ARGUMENTS"].join("\n"),
     },
+    "magi:output": {
+        description: "Show Magi run output artifacts",
+        template: [`Call the \`magi_output\` tool.`, "Selector: $ARGUMENTS"].join("\n"),
+    },
+    "magi:status": {
+        description: "Show Magi background run status",
+        template: [`Call the \`magi_status\` tool.`, "Selector: $ARGUMENTS"].join("\n"),
+    },
     "magi:validate": {
         description: "Validate Magi config",
         template: "Call the `magi_validate` tool.",

package/dist/github/commands.js

@@ -1,6 +1,14 @@
 import { mkdir, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
+function normalizeRelatedPullRequestState(state) {
+    const normalized = state?.toUpperCase();
+    if (normalized === "MERGED")
+        return "MERGED";
+    if (normalized === "CLOSED")
+        return "CLOSED";
+    return "OPEN";
+}
 const WORKTREE_CHECKOUT_RETRY_ATTEMPTS = 5;
 const WORKTREE_CHECKOUT_RETRY_DELAY_MS = 100;
 const worktreeCreateLocks = new Map();
@@ -157,9 +165,7 @@ export async function fetchRelatedPullRequests(exec, repository, issue) {
             continue;
         const state = source.mergedAt
             ? "MERGED"
-            : source.state === "CLOSED"
-                ? "CLOSED"
-                : "OPEN";
+            : normalizeRelatedPullRequestState(source.state);
         prs.set(source.number, {
             author: source.author?.login ?? "",
             body: source.body,
@@ -170,25 +176,86 @@ export async function fetchRelatedPullRequests(exec, repository, issue) {
             url: source.url,
         });
     }
+    const searchQuery = `repo:${repoSlug(repository)} is:pr ${issue}`;
+    const searchRaw = await exec(`gh search prs ${shellQuote(searchQuery)} --json number,title,url,state,body,author --limit 10`).catch(() => "[]");
+    const searchData = JSON.parse(searchRaw);
+    const closingReference = new RegExp(`\\b(?:close[sd]?|fix(?:e[sd])?|resolve[sd]?)\\s+#${issue}\\b`, "i");
+    for (const item of searchData) {
+        if (!closingReference.test(item.body ?? ""))
+            continue;
+        prs.set(item.number, {
+            author: item.author?.login ?? "",
+            body: item.body,
+            number: item.number,
+            state: normalizeRelatedPullRequestState(item.state),
+            title: item.title,
+            url: item.url,
+        });
+    }
     return [...prs.values()];
 }
+function duplicateReferences(text) {
+    const refs = new Set();
+    const pattern = /duplicate(?:s)?\s+(?:of\s+)?#(\d+)/gi;
+    for (const match of text.matchAll(pattern))
+        refs.add(Number(match[1]));
+    return [...refs];
+}
+async function fetchIssueCandidate(exec, repository, number, whyCandidate) {
+    const raw = await exec(`gh issue view ${number} --repo ${shellQuote(repoSpecifier(repository))} --json number,title,url,state,body,createdAt`).catch(() => undefined);
+    if (!raw)
+        return undefined;
+    const data = JSON.parse(raw);
+    return { ...data, whyCandidate };
+}
 export async function searchDuplicateIssues(exec, repository, issue, limit = 5) {
     const query = `${issue.title} repo:${repoSlug(repository)} is:issue -${issue.number}`;
+    const explicitCandidates = await Promise.all(duplicateReferences(issue.body)
+        .filter((number) => number !== issue.number)
+        .map((number) => fetchIssueCandidate(exec, repository, number, "Issue body explicitly references a duplicate target.")));
     const raw = await exec(`gh search issues ${shellQuote(query)} --json number,title,url,state,body --limit ${limit}`);
     const data = JSON.parse(raw);
-    return data
+    const candidates = new Map();
+    for (const candidate of explicitCandidates) {
+        if (candidate)
+            candidates.set(candidate.number, candidate);
+    }
+    for (const item of data
         .filter((item) => item.number !== issue.number)
         .map((item) => ({
         ...item,
         whyCandidate: "GitHub issue search matched the title.",
-    }));
+    }))) {
+        if (!candidates.has(item.number))
+            candidates.set(item.number, item);
+    }
+    return [...candidates.values()].slice(0, limit);
 }
 export async function postIssueComment(exec, repository, issue, account, body) {
     const token = await ghToken(exec, repository, account);
     const payloadPath = join(tmpdir(), `magi-issue-${process.pid}-${Date.now()}.json`);
     await writeFile(payloadPath, JSON.stringify({ body }));
     try {
-        return await exec(`gh api${ghHostOption(repository)} repos/${repository.github.owner}/${repository.github.repo}/issues/${issue}/comments --method POST --input ${shellQuote(payloadPath)} --jq .html_url`, ghTokenEnv(token));
+        const raw = await exec(`gh api${ghHostOption(repository)} repos/${repository.github.owner}/${repository.github.repo}/issues/${issue}/comments --method POST --input ${shellQuote(payloadPath)} --jq '{id: .id, url: .html_url}'`, ghTokenEnv(token));
+        const data = JSON.parse(raw);
+        if (!data.id || !data.url)
+            throw new Error("GitHub issue comment response did not include id and url");
+        return { id: data.id, url: data.url };
+    }
+    finally {
+        await rm(payloadPath, { force: true });
+    }
+}
+export async function updateIssueComment(exec, repository, commentId, account, body) {
+    const token = await ghToken(exec, repository, account);
+    const payloadPath = join(tmpdir(), `magi-issue-comment-${process.pid}-${Date.now()}.json`);
+    await writeFile(payloadPath, JSON.stringify({ body }));
+    try {
+        const raw = await exec(`gh api${ghHostOption(repository)} repos/${repository.github.owner}/${repository.github.repo}/issues/comments/${commentId} --method PATCH --input ${shellQuote(payloadPath)} --jq '{id: .id, url: .html_url}'`, ghTokenEnv(token));
+        const data = JSON.parse(raw);
+        if (!data.id || !data.url)
+            throw new Error("GitHub issue comment response did not include id and url");
+        return { id: data.id, url: data.url };
     }
     finally {
         await rm(payloadPath, { force: true });

package/dist/index.js

@@ -13,7 +13,6 @@ import { validateConfig } from "./config/validate";
 import { withGitHubApiRetry } from "./github/retry";
 import { mapPool } from "./orchestrator/pool";
 import { MagiRunManager } from "./orchestrator/run-manager";
-import { runTriage } from "./orchestrator/triage";
 const execAsync = promisify(nodeExec);
 const GLOBAL_CONFIG_PATH = join(homedir(), ".config", "opencode", "magi.json");
 const PROJECT_CONFIG_PATH = join(".opencode", "magi.json");
@@ -119,6 +118,11 @@ function parseOptionalPr(value) {
         return undefined;
     return parsePrToken(value);
 }
+function parseOptionalIssue(value) {
+    if (!value?.trim())
+        return undefined;
+    return parseIssueToken(value);
+}
 function clearFlag(value) {
     return typeof value === "boolean" ? value : undefined;
 }
@@ -161,6 +165,11 @@ function prMarkdownLink(repository, pr) {
     const url = `https://${host}/${repository.github.owner}/${repository.github.repo}/pull/${pr}`;
     return `[#${pr}](${url})`;
 }
+function issueMarkdownLink(repository, issue) {
+    const host = repository.github.host || "github.com";
+    const url = `https://${host}/${repository.github.owner}/${repository.github.repo}/issues/${issue}`;
+    return `[#${issue}](${url})`;
+}
 function isPlainObject(value) {
     return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
@@ -391,27 +400,28 @@ export const MagiPlugin = async ({ client, directory }) => {
                     const repository = resolveRepository(loaded.config);
                     if (!repository.triage)
                         return JSON.stringify({ errors: ["triage configuration is required"], ok: false }, null, 2);
-                    const results = await mapPool(parsed.issues, repository.triage.concurrency.runs, (issue) => runTriage({
-                        client: modelClient,
+                    const states = await mapPool(parsed.issues, repository.triage.concurrency.runs, (issue) => runManager.startTriage({
                         config: loaded.config,
-                        directory,
                         dryRun: parsed.dryRun,
-                        exec: retryingExec,
                         issue,
+                        parentSessionId: context.sessionID,
                         repository,
                         signal: context.abort,
                     }), { signal: context.abort });
-                    return results.map((result) => result.report).join("\n\n");
+                    return states
+                        .map((state) => `Started triaging ${issueMarkdownLink(repository, state.issue)}.`)
+                        .join("\n");
                 },
             }),
             magi_status: tool({
                 description: [
-                    "Show Magi background run status. Optionally filter by runId or PR and wait for completion.",
+                    "Show Magi background run status. Optionally filter by runId, PR, or issue and wait for completion.",
                     INTERNAL_FOLLOW_UP_TOOL_NOTE,
                 ].join(" "),
                 args: {
                     runId: tool.schema.string().optional(),
                     pr: tool.schema.string().optional(),
+                    issue: tool.schema.string().optional(),
                     block: tool.schema.boolean().optional(),
                     timeoutSeconds: tool.schema.number().optional(),
                     verbose: tool.schema.boolean().optional(),
@@ -419,6 +429,7 @@ export const MagiPlugin = async ({ client, directory }) => {
                 async execute(args) {
                     const states = await runManager.status({
                         block: args.block,
+                        issue: parseOptionalIssue(args.issue),
                         outputDir: await configuredOutputDir(),
                         pr: parseOptionalPr(args.pr),
                         runId: args.runId,
@@ -433,22 +444,24 @@ export const MagiPlugin = async ({ client, directory }) => {
             }),
             magi_output: tool({
                 description: [
-                    "Show artifacts and details for a Magi background run by runId or PR, optionally for a single reviewer.",
+                    "Show artifacts and details for a Magi background run by runId, PR, or issue, optionally for a single reviewer.",
                     INTERNAL_FOLLOW_UP_TOOL_NOTE,
                 ].join(" "),
                 args: {
                     runId: tool.schema.string().optional(),
                     pr: tool.schema.string().optional(),
+                    issue: tool.schema.string().optional(),
                     reviewer: tool.schema.string().optional(),
                 },
                 async execute(args) {
-                    if (!args.runId && !args.pr)
-                        return "Specify runId or pr.";
+                    if (!args.runId && !args.pr && !args.issue)
+                        return "Specify runId, pr, or issue.";
                     const outputDir = await configuredOutputDir();
                     if (outputDir)
                         await runManager.status({ outputDir });
                     return runManager.output({
                         outputDir,
+                        issue: parseOptionalIssue(args.issue),
                         pr: parseOptionalPr(args.pr),
                         reviewer: args.reviewer,
                         runId: args.runId,
@@ -456,19 +469,22 @@ export const MagiPlugin = async ({ client, directory }) => {
                 },
             }),
             magi_cancel: tool({
-                description: "Cancel a Magi background run by runId or PR.",
+                description: "Cancel a Magi background run by runId, PR, or issue.",
                 args: {
                     runId: tool.schema.string().optional(),
                     pr: tool.schema.string().optional(),
+                    issue: tool.schema.string().optional(),
                 },
                 async execute(args) {
-                    if (!args.runId && !args.pr)
-                        return "Specify runId or pr.";
+                    if (!args.runId && !args.pr && !args.issue)
+                        return "Specify runId, pr, or issue.";
                     const outputDir = await configuredOutputDir();
                     if (outputDir)
                         await runManager.status({ outputDir });
                     const pr = parseOptionalPr(args.pr);
+                    const issue = parseOptionalIssue(args.issue);
                     const state = await runManager.cancel({
+                        issue,
                         outputDir,
                         pr,
                         runId: args.runId,
@@ -476,7 +492,9 @@ export const MagiPlugin = async ({ client, directory }) => {
                     if (!state) {
                         return args.runId
                             ? `Magi run not found: ${args.runId}`
-                            : `Magi run not found for PR #${pr}`;
+                            : issue
+                                ? `Magi run not found for issue #${issue}`
+                                : `Magi run not found for PR #${pr}`;
                     }
                     return runManager.formatStates([state]);
                 },
@@ -486,6 +504,7 @@ export const MagiPlugin = async ({ client, directory }) => {
                 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(),
@@ -511,6 +530,7 @@ export const MagiPlugin = async ({ client, directory }) => {
                     };
                     return runManager.clear({
                         options,
+                        issue: parseOptionalIssue(args.issue),
                         outputDir: loaded
                             ? outputBaseDirs(directory, loaded.config)
                             : undefined,

package/dist/orchestrator/run-manager.js

@@ -1,12 +1,13 @@
 import { randomUUID } from "node:crypto";
 import { mkdir, readFile, readdir, rm, rmdir, writeFile, } from "node:fs/promises";
 import { dirname, isAbsolute, join, relative, resolve } from "node:path";
-import { outputBaseDirs, prRunOutputDir } from "../config/output";
+import { issueRunOutputDir, outputBaseDirs, prRunOutputDir, } from "../config/output";
 import { worktreeBaseDirs } from "../config/worktree";
 import { removeBranch, removeWorktree, } from "../github/commands";
 import { withGitHubApiRetry } from "../github/retry";
 import { runMerge, } from "./merge";
 import { runReview } from "./review";
+import { runTriage } from "./triage";
 const EVENT_LAST_UPDATE_THROTTLE_MS = 5_000;
 const DEFAULT_CLEAR_OPTIONS = {
     branch: true,
@@ -75,13 +76,28 @@ function prUrl(repository, pr) {
     const host = repository.github.host || "github.com";
     return `https://${host}/${repository.github.owner}/${repository.github.repo}/pull/${pr}`;
 }
+function issueUrl(repository, issue) {
+    const host = repository.github.host || "github.com";
+    return `https://${host}/${repository.github.owner}/${repository.github.repo}/issues/${issue}`;
+}
 function prMarkdownLink(state) {
     if (state.pr == null)
         return state.runId;
     return state.prUrl ? `[#${state.pr}](${state.prUrl})` : `#${state.pr}`;
 }
+function issueMarkdownLink(state) {
+    if (state.issue == null)
+        return state.runId;
+    return state.issueUrl
+        ? `[#${state.issue}](${state.issueUrl})`
+        : `#${state.issue}`;
+}
 function runLabel(state) {
-    return state.pr == null ? state.runId : prMarkdownLink(state);
+    if (state.pr != null)
+        return prMarkdownLink(state);
+    if (state.issue != null)
+        return issueMarkdownLink(state);
+    return state.runId;
 }
 function reviewerCompletionText(input) {
     const reviewer = `**Reviewer ${input.reviewer}**`;
@@ -477,6 +493,55 @@ export class MagiRunManager {
         });
         return state;
     }
+    async startTriage(input) {
+        const runId = createRunId();
+        const outputDir = issueRunOutputDir({
+            config: input.config,
+            directory: this.input.directory,
+            issue: input.issue,
+            runId,
+        });
+        const createdAt = now();
+        const state = {
+            command: "triage",
+            createdAt,
+            dryRun: input.dryRun,
+            issue: input.issue,
+            issueUrl: issueUrl(input.repository, input.issue),
+            outputDir,
+            parentSessionId: input.parentSessionId,
+            phase: "queued",
+            repository: input.repository.alias,
+            reviewers: Object.fromEntries((input.repository.agents.triage ?? []).map((agent) => [
+                agent.key,
+                {
+                    account: "",
+                    repairAttempts: 0,
+                    status: "pending",
+                    toolCalls: 0,
+                },
+            ])),
+            runId,
+            status: "preparing",
+            updatedAt: createdAt,
+        };
+        this.active.set(runId, state);
+        this.runPaths.set(runId, join(outputDir, "state.json"));
+        for (const dir of outputBaseDirs(this.input.directory, input.config))
+            this.outputDirs.add(dir);
+        await this.persist(state);
+        await this.notify(state, `Started Magi triage for ${issueMarkdownLink(state)}.`);
+        const controller = new AbortController();
+        this.controllers.set(runId, controller);
+        void this.executeTriage({
+            ...input,
+            runId,
+            signal: controller.signal,
+        }).catch(async (error) => {
+            await this.failRun(runId, error);
+        });
+        return state;
+    }
     async status(input = {}) {
         const timeoutMs = Math.min(input.timeoutMs ?? 60_000, 600_000);
         const startedAt = Date.now();
@@ -1173,6 +1238,45 @@ export class MagiRunManager {
         this.active.delete(input.runId);
         this.controllers.delete(input.runId);
     }
+    async executeTriage(input) {
+        const state = this.active.get(input.runId);
+        if (state) {
+            state.status = "running";
+            state.phase = "triaging";
+            await this.persist(state);
+        }
+        const result = await runTriage({
+            client: this.input.client,
+            config: input.config,
+            directory: this.input.directory,
+            dryRun: input.dryRun,
+            exec: withGitHubApiRetry(this.input.exec, input.config.github?.apiRetryAttempts ?? 3),
+            issue: input.issue,
+            repository: input.repository,
+            runId: input.runId,
+            signal: input.signal,
+        });
+        const completed = this.active.get(input.runId);
+        if (!completed || completed.status === "cancelled")
+            return;
+        completed.status = result.result === "FAILED" ? "failed" : "completed";
+        completed.phase = result.result;
+        completed.completedAt = now();
+        completed.verdict = result.result;
+        completed.reportPath = join(completed.outputDir, "report.md");
+        for (const agent of Object.values(completed.reviewers)) {
+            if (agent.status === "pending")
+                agent.status = "completed";
+        }
+        await this.persist(completed);
+        await this.notify(completed, [
+            `Finished triage for ${issueMarkdownLink(completed)}.`,
+            "",
+            result.report,
+        ].join("\n"), { reply: true });
+        this.active.delete(input.runId);
+        this.controllers.delete(input.runId);
+    }
     async applyReviewProgress(runId, progress) {
         const state = this.active.get(runId);
         if (!state)
@@ -1556,6 +1660,7 @@ export class MagiRunManager {
             : await this.listStates(input.outputDir);
         return states
             .filter((state) => input.command == null || state.command === input.command)
+            .filter((state) => input.issue == null || state.issue === input.issue)
             .filter((state) => input.pr == null || state.pr === input.pr)
             .sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
     }
@@ -1569,6 +1674,8 @@ export class MagiRunManager {
             return input.runId;
         if (input.pr != null)
             return `PR #${input.pr}`;
+        if (input.issue != null)
+            return `issue #${input.issue}`;
         return "all runs";
     }
     absoluteOutputDir(dir) {