opencode-magi 0.3.0 → 0.5.0

package/README.md

@@ -61,26 +61,33 @@ Add the following content to the configuration file.
 ```json
 {
   "$schema": "https://raw.githubusercontent.com/magi-ai/opencode-magi/main/schema.json",
-  "review": {
-    "agents": [
-      {
-        "account": "your-account-1",
-        "model": "openai/gpt-5.5"
+  "agents": {
+    "refs": {
+      "account-1": {
+        "model": "openai/gpt-5.5",
+        "account": "account-1"
       },
-      {
-        "account": "your-account-2",
-        "model": "anthropic/claude-opus-4-7"
+      "account-2": {
+        "model": "anthropic/claude-opus-4-7",
+        "account": "account-2"
       },
-      {
-        "account": "your-account-3",
-        "model": "opencode/kimi-k2-6"
+      "account-3": {
+        "model": "opencode/kimi-k2-6",
+        "account": "account-3"
       }
+    }
+  },
+  "review": {
+    "agents": [
+      { "ref": "account-1" },
+      { "ref": "account-2" },
+      { "ref": "account-3" }
     ]
   }
 }
 ```
 
-`review.agents[].account` is the GitHub account used to post reviews and approvals. Must be authenticated with `gh auth token --user <account>` and must be unique.
+After refs are expanded, `review.agents[].account` is the GitHub account used to post reviews and approvals. Must be authenticated with `gh auth token --user <account>` and must be unique.
 
 #### Set project config
 
@@ -101,53 +108,54 @@ Add the following content to the configuration file.
     "owner": "your-owner",
     "repo": "your-repo"
   },
-  "review": {
-    "agents": [
-      {
-        "account": "your-account-1",
-        "model": "openai/gpt-5.5"
+  "agents": {
+    "refs": {
+      "account-1": {
+        "model": "openai/gpt-5.5",
+        "account": "account-1"
       },
-      {
-        "account": "your-account-2",
-        "model": "anthropic/claude-opus-4-7"
+      "account-2": {
+        "model": "anthropic/claude-opus-4-7",
+        "account": "account-2"
       },
-      {
-        "account": "your-account-3",
-        "model": "opencode/kimi-k2-6"
+      "account-3": {
+        "model": "opencode/kimi-k2-6",
+        "account": "account-3"
+      },
+      "account-4": {
+        "model": "openai/gpt-5.5",
+        "account": "account-4",
+        "author": {
+          "name": "account-4",
+          "email": "your-email@example.com"
+        }
       }
+    }
+  },
+  "review": {
+    "agents": [
+      { "ref": "account-1" },
+      { "ref": "account-2" },
+      { "ref": "account-3" }
     ]
   },
   "merge": {
-    "editor": {
-      "account": "your-editor-account",
-      "model": "openai/gpt-5.5",
-      "author": {
-        "name": "your-account",
-        "email": "your-email@example.com"
-      }
-    }
+    "editor": { "ref": "account-4" }
   },
   "triage": {
-    "account": "your-triage-account",
+    "account": "account-5",
     "agents": [
-      {
-        "id": "general",
-        "model": "openai/gpt-5.5"
-      },
-      {
-        "id": "maintenance",
-        "model": "anthropic/claude-opus-4-7"
-      },
-      {
-        "id": "product",
-        "model": "opencode/kimi-k2-6"
-      }
+      { "ref": "account-1" },
+      { "ref": "account-2" },
+      { "ref": "account-3" }
     ]
   }
 }
 ```
 
-`review.agents[].account` is the GitHub account used to post reviews and approvals. Must be authenticated with `gh auth token --user <account>` and must be unique. `merge.editor.account` is used by `/magi:merge` to push fixes, close PRs, and merge PRs.
+Entries with `ref` are expanded from `agents.refs`. Fields set alongside `ref` override fields from the preset.
+
+After refs are expanded, `review.agents[].account` is the GitHub account used to post reviews and approvals. Must be authenticated with `gh auth token --user <account>` and must be unique. `merge.editor.account` is used by `/magi:merge` to push fixes, close PRs, and merge PRs.
 
 #### Validate config
 

package/dist/config/validate.js

@@ -157,6 +157,56 @@ function ghHostOption(config) {
 function isPlainObject(value) {
     return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
+function expandAgentRefUse(value, path, refs, refsInvalid, errors) {
+    if (!isPlainObject(value) || !Object.hasOwn(value, "ref"))
+        return value;
+    const use = { ...value };
+    const ref = use.ref;
+    delete use.ref;
+    if (typeof ref !== "string") {
+        errors.push(`${path}.ref must be a string`);
+        return use;
+    }
+    if (refsInvalid) {
+        errors.push(`agents.refs must be an object to resolve ${path}.ref`);
+        return use;
+    }
+    const preset = refs?.[ref];
+    if (preset == null) {
+        errors.push(`${path}.ref references unknown agents.refs preset: ${ref}`);
+        return use;
+    }
+    if (!isPlainObject(preset)) {
+        errors.push(`agents.refs.${ref} must be an object when referenced by ${path}.ref`);
+        return use;
+    }
+    const presetFields = { ...preset };
+    delete presetFields.ref;
+    return { ...presetFields, ...use };
+}
+function expandAgentRefs(config, errors) {
+    if (!config || typeof config !== "object")
+        return;
+    const magiConfig = config;
+    const agents = magiConfig.agents;
+    const refsValue = isPlainObject(agents) ? agents.refs : undefined;
+    const refsInvalid = refsValue != null && !isPlainObject(refsValue);
+    const refs = isPlainObject(refsValue) ? refsValue : undefined;
+    if (Array.isArray(magiConfig.review?.agents)) {
+        magiConfig.review.agents = magiConfig.review.agents.map((agent, index) => expandAgentRefUse(agent, `review.agents[${index}]`, refs, refsInvalid, errors));
+    }
+    if (isPlainObject(magiConfig.merge?.editor)) {
+        magiConfig.merge.editor = expandAgentRefUse(magiConfig.merge.editor, "merge.editor", refs, refsInvalid, errors);
+    }
+    if (Array.isArray(magiConfig.triage?.agents)) {
+        magiConfig.triage.agents = magiConfig.triage.agents.map((agent, index) => expandAgentRefUse(agent, `triage.agents[${index}]`, refs, refsInvalid, errors));
+    }
+    if (isPlainObject(magiConfig.triage?.creator)) {
+        magiConfig.triage.creator = expandAgentRefUse(magiConfig.triage.creator, "triage.creator", refs, refsInvalid, errors);
+    }
+    if (isPlainObject(magiConfig.agents))
+        delete magiConfig.agents.refs;
+}
 function validateKnownKeys(value, path, keys, errors) {
     if (!isPlainObject(value))
         return;
@@ -792,6 +842,7 @@ export async function validateConfig(config, options = {}) {
     const warnings = [];
     if (!config || typeof config !== "object")
         errors.push("config must be an object");
+    expandAgentRefs(config, errors);
     if (config && typeof config === "object")
         validateJsonSchema(config, errors);
     validateKnownKeys(config, "config", CONFIG_KEYS, errors);

package/dist/github/commands.js

@@ -246,6 +246,12 @@ function duplicateReferences(text) {
         refs.add(Number(match[1]));
     return [...refs];
 }
+function issueTitleSearchQuery(title, fallback) {
+    return (title
+        .replaceAll(/[^\p{L}\p{N}_]+/gu, " ")
+        .replaceAll(/\s+/g, " ")
+        .trim() || fallback);
+}
 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)
@@ -254,7 +260,7 @@ async function fetchIssueCandidate(exec, repository, number, whyCandidate) {
     return { ...data, whyCandidate };
 }
 export async function searchDuplicateIssues(exec, repository, issue, limit = 5) {
-    const query = issue.title;
+    const query = issueTitleSearchQuery(issue.title, String(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.")));
@@ -522,20 +528,15 @@ function findingComment(finding) {
     }
     return comment;
 }
-function requirementFindingSummary(finding) {
-    return [
-        `- Missing issue #${finding.issueNumber} requirement: ${finding.requirement}`,
-        `  Evidence: ${finding.evidence}`,
-        `  Fix: ${finding.fix}`,
-    ].join("\n");
+function changesRequestedBody(findings) {
+    return findings.length === 1
+        ? "Changes requested: 1 inline comment."
+        : `Changes requested: ${findings.length} inline comments.`;
 }
-export async function postChangesRequested(exec, repository, pr, account, findings, requirementFindings = []) {
+export async function postChangesRequested(exec, repository, pr, account, findings) {
     const token = await ghToken(exec, repository, account);
     const payloadPath = join(tmpdir(), `magi-review-${process.pid}-${Date.now()}.json`);
-    const body = findings
-        .map((finding) => `- ${finding.issue.split("\n")[0]}`)
-        .concat(requirementFindings.map(requirementFindingSummary))
-        .join("\n");
+    const body = changesRequestedBody(findings);
     await writeFile(payloadPath, JSON.stringify({
         body,
         comments: findings.map(findingComment),

package/dist/index.js

@@ -95,12 +95,17 @@ export function parseRunArguments(value, dryRun = false, command = "review") {
     const tokens = value.split(/[\s,]+/).filter(Boolean);
     const configOverrides = {};
     const prTokens = [];
+    let sync = false;
     for (let index = 0; index < tokens.length; index++) {
         const token = tokens[index];
         if (token === "--dry-run") {
             dryRun = true;
             continue;
         }
+        if (token === "--sync") {
+            sync = true;
+            continue;
+        }
         switch (token) {
             case "--language":
                 setConfigOverride(configOverrides, ["language"], nextFlagValue(tokens, ++index, token));
@@ -146,18 +151,23 @@ export function parseRunArguments(value, dryRun = false, command = "review") {
                 prTokens.push(token);
         }
     }
-    return { configOverrides, dryRun, prs: parsePrs(prTokens.join(" ")) };
+    return { configOverrides, dryRun, prs: parsePrs(prTokens.join(" ")), sync };
 }
 export function parseIssueRunArguments(value, dryRun = false) {
     const tokens = value.split(/[\s,]+/).filter(Boolean);
     const configOverrides = {};
     const issueTokens = [];
+    let sync = false;
     for (let index = 0; index < tokens.length; index++) {
         const token = tokens[index];
         if (token === "--dry-run") {
             dryRun = true;
             continue;
         }
+        if (token === "--sync") {
+            sync = true;
+            continue;
+        }
         switch (token) {
             case "--language":
                 setConfigOverride(configOverrides, ["language"], nextFlagValue(tokens, ++index, token));
@@ -195,7 +205,12 @@ export function parseIssueRunArguments(value, dryRun = false) {
                 issueTokens.push(token);
         }
     }
-    return { configOverrides, dryRun, issues: parseIssues(issueTokens.join(" ")) };
+    return {
+        configOverrides,
+        dryRun,
+        issues: parseIssues(issueTokens.join(" ")),
+        sync,
+    };
 }
 function nextFlagValue(tokens, index, flag) {
     const value = tokens[index];
@@ -203,6 +218,15 @@ function nextFlagValue(tokens, index, flag) {
         throw new Error(`${flag} requires a value.`);
     return value;
 }
+async function syncResult(runManager, states) {
+    const output = await runManager.formatStatesWithReports(states, {
+        verbose: true,
+    });
+    const failed = states.filter((state) => state.status !== "completed");
+    if (failed.length)
+        throw new Error(output);
+    return output;
+}
 function parseIntegerFlag(value, flag, minimum) {
     const parsed = Number.parseInt(value, 10);
     if (!Number.isInteger(parsed) ||
@@ -432,6 +456,7 @@ export const MagiPlugin = async ({ client, directory }) => {
                 args: {
                     prs: tool.schema.string(),
                     dryRun: tool.schema.boolean().optional(),
+                    sync: tool.schema.boolean().optional(),
                 },
                 async execute(args, context) {
                     const parsed = parseRunArguments(args.prs, args.dryRun ?? false, "merge");
@@ -448,6 +473,7 @@ export const MagiPlugin = async ({ client, directory }) => {
                     if (!validation.ok)
                         return JSON.stringify(validation, null, 2);
                     const repository = resolveRepository(config);
+                    const sync = parsed.sync || args.sync === true;
                     const states = await mapPool(parsed.prs, repository.concurrency.runs, (pr) => runManager.startMerge({
                         config,
                         dryRun: parsed.dryRun,
@@ -455,7 +481,10 @@ export const MagiPlugin = async ({ client, directory }) => {
                         pr,
                         parentSessionId: context.sessionID,
                         signal: context.abort,
+                        sync,
                     }), { signal: context.abort });
+                    if (sync)
+                        return syncResult(runManager, states);
                     return states
                         .map((state) => `Started reviewing ${prMarkdownLink(repository, state.pr)}.`)
                         .join("\n");
@@ -469,6 +498,7 @@ export const MagiPlugin = async ({ client, directory }) => {
                 args: {
                     prs: tool.schema.string(),
                     dryRun: tool.schema.boolean().optional(),
+                    sync: tool.schema.boolean().optional(),
                 },
                 async execute(args, context) {
                     const parsed = parseRunArguments(args.prs, args.dryRun ?? false);
@@ -484,6 +514,7 @@ export const MagiPlugin = async ({ client, directory }) => {
                     if (!validation.ok)
                         return JSON.stringify(validation, null, 2);
                     const repository = resolveRepository(config);
+                    const sync = parsed.sync || args.sync === true;
                     const states = await mapPool(parsed.prs, repository.concurrency.runs, (pr) => runManager.startReview({
                         config,
                         dryRun: parsed.dryRun,
@@ -491,7 +522,10 @@ export const MagiPlugin = async ({ client, directory }) => {
                         pr,
                         parentSessionId: context.sessionID,
                         signal: context.abort,
+                        sync,
                     }), { signal: context.abort });
+                    if (sync)
+                        return syncResult(runManager, states);
                     return states
                         .map((state) => `Started reviewing ${prMarkdownLink(repository, state.pr)}.`)
                         .join("\n");
@@ -502,6 +536,7 @@ export const MagiPlugin = async ({ client, directory }) => {
                 args: {
                     issues: tool.schema.string(),
                     dryRun: tool.schema.boolean().optional(),
+                    sync: tool.schema.boolean().optional(),
                 },
                 async execute(args, context) {
                     const parsed = parseIssueRunArguments(args.issues, args.dryRun ?? false);
@@ -523,6 +558,7 @@ export const MagiPlugin = async ({ client, directory }) => {
                     const repository = resolveRepository(config);
                     if (!repository.triage)
                         return JSON.stringify({ errors: ["triage configuration is required"], ok: false }, null, 2);
+                    const sync = parsed.sync || args.sync === true;
                     const states = await mapPool(parsed.issues, repository.triage.concurrency.runs, (issue) => runManager.startTriage({
                         config,
                         dryRun: parsed.dryRun,
@@ -530,7 +566,10 @@ export const MagiPlugin = async ({ client, directory }) => {
                         parentSessionId: context.sessionID,
                         repository,
                         signal: context.abort,
+                        sync,
                     }), { signal: context.abort });
+                    if (sync)
+                        return syncResult(runManager, states);
                     return states
                         .map((state) => `Started triaging ${issueMarkdownLink(repository, state.issue)}.`)
                         .join("\n");

package/dist/orchestrator/findings.js

@@ -58,10 +58,9 @@ export function applyFindingValidation(input) {
             discarded.push(target);
             return false;
         });
-        next[reviewer] =
-            findings.length || output.requirementFindings.length
-                ? { ...output, findings }
-                : { findings: [], requirementFindings: [], verdict: "MERGE" };
+        next[reviewer] = findings.length
+            ? { ...output, findings }
+            : { findings: [], verdict: "MERGE" };
     }
     return { outputs: next, summary: { discarded, kept } };
 }

package/dist/orchestrator/merge.js

@@ -50,7 +50,7 @@ async function withReviewerFailureProgress(input) {
         throw error;
     }
 }
-async function runEditor(input, worktreePath, cycle, unresolvedThreads) {
+async function runEditor(input, worktreePath, cycle, reviewFindings, unresolvedThreads) {
     const editor = input.repository.agents.editor;
     if (!editor)
         throw new Error("agents.editor is required for magi_merge");
@@ -64,6 +64,7 @@ async function runEditor(input, worktreePath, cycle, unresolvedThreads) {
         directory: input.directory,
         pr: input.pr,
         repository: input.repository,
+        reviewFindings: JSON.stringify(reviewFindings, null, 2),
         unresolvedThreads: JSON.stringify(unresolvedThreads, null, 2),
         worktreePath,
     });
@@ -149,8 +150,8 @@ async function postRereviewOutput(input, reviewerKey, output) {
         return postChangesRequested(input.exec, input.repository, input.pr, reviewer.account, output.newFindings.map((finding) => ({
             fix: "Please address this before merging.",
             issue: finding.body,
-            line: finding.line,
             path: finding.path,
+            line: finding.line,
             startLine: finding.startLine,
         })));
     }
@@ -161,6 +162,35 @@ function parseRereviewOutputWithInlineTargets(text, targets) {
     validateInlineCommentTargets(output.newFindings, targets, "newFindings");
     return output;
 }
+function newFindingToEditorFinding(reviewer, finding) {
+    return {
+        body: finding.body,
+        fix: "Please address this before merging.",
+        line: finding.line,
+        path: finding.path,
+        reviewer,
+        ...(finding.startLine == null ? {} : { startLine: finding.startLine }),
+        type: "inline",
+    };
+}
+export function blockingReviewFindings(outputs) {
+    return Object.entries(outputs).flatMap(([reviewer, output]) => {
+        if (output.verdict !== "CHANGES_REQUESTED")
+            return [];
+        if ("findings" in output) {
+            return output.findings.map((finding) => ({
+                fix: finding.fix,
+                issue: finding.issue,
+                line: finding.line,
+                path: finding.path,
+                reviewer,
+                ...(finding.startLine == null ? {} : { startLine: finding.startLine }),
+                type: "inline",
+            }));
+        }
+        return output.newFindings.map((finding) => newFindingToEditorFinding(reviewer, finding));
+    });
+}
 async function runRereview(input, worktreePath, previousHeadSha, cycle, sessionIds, ciFailureContext, options = {}) {
     throwIfAborted(input.signal);
     const meta = await fetchPullRequest(input.exec, input.repository, input.pr);
@@ -460,15 +490,38 @@ function syntheticReviewThreads(outputs) {
     const threads = {};
     for (const [reviewer, output] of Object.entries(outputs)) {
         if ("findings" in output) {
-            threads[reviewer] = output.findings.map((finding) => {
+            threads[reviewer] = output.findings.flatMap((finding) => {
                 const commentId = nextCommentId--;
-                return {
-                    body: `Issue: ${finding.issue}\n\nFix: ${finding.fix}`,
+                return [
+                    {
+                        body: `Issue: ${finding.issue}\n\nFix: ${finding.fix}`,
+                        commentId,
+                        comments: [
+                            {
+                                author: reviewer,
+                                body: `Issue: ${finding.issue}\n\nFix: ${finding.fix}`,
+                                commentId,
+                                createdAt: new Date(0).toISOString(),
+                            },
+                        ],
+                        line: finding.line,
+                        path: finding.path,
+                        threadId: `dry-run:${reviewer}:${Math.abs(commentId)}`,
+                    },
+                ];
+            });
+            continue;
+        }
+        threads[reviewer] = output.newFindings.flatMap((finding) => {
+            const commentId = nextCommentId--;
+            return [
+                {
+                    body: finding.body,
                     commentId,
                     comments: [
                         {
                             author: reviewer,
-                            body: `Issue: ${finding.issue}\n\nFix: ${finding.fix}`,
+                            body: finding.body,
                             commentId,
                             createdAt: new Date(0).toISOString(),
                         },
@@ -476,27 +529,8 @@ function syntheticReviewThreads(outputs) {
                     line: finding.line,
                     path: finding.path,
                     threadId: `dry-run:${reviewer}:${Math.abs(commentId)}`,
-                };
-            });
-            continue;
-        }
-        threads[reviewer] = output.newFindings.map((finding) => {
-            const commentId = nextCommentId--;
-            return {
-                body: finding.body,
-                commentId,
-                comments: [
-                    {
-                        author: reviewer,
-                        body: finding.body,
-                        commentId,
-                        createdAt: new Date(0).toISOString(),
-                    },
-                ],
-                line: finding.line,
-                path: finding.path,
-                threadId: `dry-run:${reviewer}:${Math.abs(commentId)}`,
-            };
+                },
+            ];
         });
     }
     return threads;
@@ -666,7 +700,12 @@ export async function runMerge(input) {
                 maxThreadResolutionCycles: input.repository.merge.maxThreadResolutionCycles,
                 threads: unresolvedThreads,
             });
-            if (!editableThreads.length) {
+            const editorFindings = blockingReviewFindings(reportOutputs);
+            const editableFindings = editableThreads.length ? editorFindings : [];
+            const findingAttemptsExhausted = input.repository.merge.maxThreadResolutionCycles !== 0 &&
+                cycle > input.repository.merge.maxThreadResolutionCycles;
+            if (!editableThreads.length &&
+                (!editableFindings.length || findingAttemptsExhausted)) {
                 await input.onProgress?.({
                     status: "changes_unresolved",
                     type: "merge_completed",
@@ -693,7 +732,7 @@ export async function runMerge(input) {
             });
             if (!review.worktreePath)
                 throw new Error("Review worktree is missing");
-            const editorOutput = await runEditor(abortableInput, review.worktreePath, cycle, editableThreads);
+            const editorOutput = await runEditor(abortableInput, review.worktreePath, cycle, editableFindings, editableThreads);
             editorOutputs.push(editorOutput);
             dryRunThreads = input.dryRun
                 ? appendDryRunEditorResponses({

package/dist/orchestrator/report.js

@@ -27,9 +27,6 @@ function formatRereviewFinding(finding) {
         : `${finding.path}:${finding.startLine}-${finding.line}`;
     return `\`${line}\`: ${finding.body}`;
 }
-function formatRequirementFinding(finding) {
-    return `Issue #${finding.issueNumber}: ${finding.requirement}`;
-}
 function isReviewOutput(output) {
     return "findings" in output;
 }
@@ -81,10 +78,7 @@ function reviewerDetailLines(output) {
             return output.reason ? [output.reason] : [];
         if (output.verdict !== "CHANGES_REQUESTED")
             return [];
-        return [
-            ...output.findings.map(formatFinding),
-            ...output.requirementFindings.map(formatRequirementFinding),
-        ];
+        return output.findings.map(formatFinding);
     }
     if (output.verdict === "CLOSE")
         return output.reason ? [output.reason] : [];
@@ -92,7 +86,6 @@ function reviewerDetailLines(output) {
         return [];
     return [
         ...output.newFindings.map(formatRereviewFinding),
-        ...output.requirementFindings.map(formatRequirementFinding),
         ...output.followUps.map((item) => `Comment #${item.commentId}: ${item.body}`),
     ];
 }