opencode-magi 0.0.0-dev-20260522220245 → 0.0.0-dev-20260522220355

package/dist/github/commands.js

@@ -392,19 +392,43 @@ export async function removeIssueLabels(exec, repository, issue, labels, account
     return removed;
 }
 export async function fetchPullRequestReviews(exec, repository, pr) {
-    const query = `query($owner: String!, $repo: String!, $pr: Int!) { repository(owner: $owner, name: $repo) { pullRequest(number: $pr) { reviews(first: 100) { nodes { author { login } submittedAt state body commit { oid } comments(first: 100) { nodes { body path line startLine } } } } } } }`;
-    const raw = await exec(`gh api${ghHostOption(repository)} graphql -f query=${shellQuote(query)} -F owner=${shellQuote(repository.github.owner)} -F repo=${shellQuote(repository.github.repo)} -F pr=${pr}`);
-    const data = JSON.parse(raw);
-    return data.data.repository.pullRequest.reviews.nodes.map((review) => ({
+    const query = `query($owner: String!, $repo: String!, $pr: Int!, $cursor: String) { repository(owner: $owner, name: $repo) { pullRequest(number: $pr) { reviews(first: 100, after: $cursor) { nodes { author { login } submittedAt state body commit { oid } comments(first: 100) { nodes { body path line startLine } } } pageInfo { hasNextPage endCursor } } } } }`;
+    const reviews = [];
+    let cursor;
+    for (;;) {
+        const cursorFlag = cursor ? ` -F cursor=${shellQuote(cursor)}` : "";
+        const raw = await exec(`gh api${ghHostOption(repository)} graphql -f query=${shellQuote(query)} -F owner=${shellQuote(repository.github.owner)} -F repo=${shellQuote(repository.github.repo)} -F pr=${pr}${cursorFlag}`);
+        const data = JSON.parse(raw);
+        const connection = data.data.repository.pullRequest.reviews;
+        reviews.push(...connection.nodes);
+        if (!connection.pageInfo?.hasNextPage)
+            break;
+        cursor = connection.pageInfo.endCursor;
+        if (!cursor)
+            throw new Error("GitHub reviews page was truncated");
+    }
+    return reviews.map((review) => ({
         ...review,
         comments: review.comments?.nodes ?? [],
     }));
 }
 export async function fetchPullRequestCommits(exec, repository, pr) {
-    const query = `query($owner: String!, $repo: String!, $pr: Int!) { repository(owner: $owner, name: $repo) { pullRequest(number: $pr) { commits(first: 100) { nodes { commit { oid committedDate parents { totalCount } } } } } } }`;
-    const raw = await exec(`gh api${ghHostOption(repository)} graphql -f query=${shellQuote(query)} -F owner=${shellQuote(repository.github.owner)} -F repo=${shellQuote(repository.github.repo)} -F pr=${pr}`);
-    const data = JSON.parse(raw);
-    return data.data.repository.pullRequest.commits.nodes.map(({ commit }) => ({
+    const query = `query($owner: String!, $repo: String!, $pr: Int!, $cursor: String) { repository(owner: $owner, name: $repo) { pullRequest(number: $pr) { commits(first: 100, after: $cursor) { nodes { commit { oid committedDate parents { totalCount } } } pageInfo { hasNextPage endCursor } } } } }`;
+    const commits = [];
+    let cursor;
+    for (;;) {
+        const cursorFlag = cursor ? ` -F cursor=${shellQuote(cursor)}` : "";
+        const raw = await exec(`gh api${ghHostOption(repository)} graphql -f query=${shellQuote(query)} -F owner=${shellQuote(repository.github.owner)} -F repo=${shellQuote(repository.github.repo)} -F pr=${pr}${cursorFlag}`);
+        const data = JSON.parse(raw);
+        const connection = data.data.repository.pullRequest.commits;
+        commits.push(...connection.nodes);
+        if (!connection.pageInfo?.hasNextPage)
+            break;
+        cursor = connection.pageInfo.endCursor;
+        if (!cursor)
+            throw new Error("GitHub commits page was truncated");
+    }
+    return commits.map(({ commit }) => ({
         committedDate: commit.committedDate,
         oid: commit.oid,
         parentCount: commit.parents.totalCount,
@@ -664,11 +688,49 @@ export async function configureGitIdentity(exec, worktreePath, identity) {
     }
 }
 export async function fetchUnresolvedThreads(exec, repository, pr, author) {
-    const query = `query($owner: String!, $repo: String!, $pr: Int!) { repository(owner: $owner, name: $repo) { pullRequest(number: $pr) { reviewThreads(first: 100) { nodes { id isResolved comments(first: 50) { nodes { databaseId author { login } path line body createdAt } } } } } } }`;
-    const raw = await exec(`gh api${ghHostOption(repository)} graphql -f query=${shellQuote(query)} -F owner=${shellQuote(repository.github.owner)} -F repo=${shellQuote(repository.github.repo)} -F pr=${pr}`);
-    const data = JSON.parse(raw);
-    const threads = data.data.repository.pullRequest.reviewThreads
-        .nodes;
+    const threadQuery = `query($owner: String!, $repo: String!, $pr: Int!, $cursor: String) { repository(owner: $owner, name: $repo) { pullRequest(number: $pr) { reviewThreads(first: 100, after: $cursor) { nodes { id isResolved comments(first: 100) { nodes { databaseId author { login } path line body createdAt } pageInfo { hasNextPage endCursor } } } pageInfo { hasNextPage endCursor } } } } }`;
+    const commentQuery = `query($threadId: ID!, $cursor: String) { node(id: $threadId) { ... on PullRequestReviewThread { comments(first: 100, after: $cursor) { nodes { databaseId author { login } path line body createdAt } pageInfo { hasNextPage endCursor } } } } }`;
+    const threads = [];
+    let cursor;
+    async function fetchRemainingComments(threadId, initialCursor) {
+        const comments = [];
+        let commentsCursor = initialCursor;
+        for (;;) {
+            const raw = await exec(`gh api${ghHostOption(repository)} graphql -f query=${shellQuote(commentQuery)} -F threadId=${shellQuote(threadId)} -F cursor=${shellQuote(commentsCursor)}`);
+            const data = JSON.parse(raw);
+            const connection = data.data.node?.comments;
+            if (!connection)
+                throw new Error("GitHub review thread comments were missing");
+            comments.push(...connection.nodes);
+            if (!connection.pageInfo?.hasNextPage)
+                break;
+            const nextCursor = connection.pageInfo.endCursor;
+            if (!nextCursor)
+                throw new Error("GitHub review thread comments page was truncated");
+            commentsCursor = nextCursor;
+        }
+        return comments;
+    }
+    for (;;) {
+        const cursorFlag = cursor ? ` -F cursor=${shellQuote(cursor)}` : "";
+        const raw = await exec(`gh api${ghHostOption(repository)} graphql -f query=${shellQuote(threadQuery)} -F owner=${shellQuote(repository.github.owner)} -F repo=${shellQuote(repository.github.repo)} -F pr=${pr}${cursorFlag}`);
+        const data = JSON.parse(raw);
+        const connection = data.data.repository.pullRequest.reviewThreads;
+        for (const thread of connection.nodes) {
+            const commentsCursor = thread.comments.pageInfo?.endCursor;
+            if (thread.comments.pageInfo?.hasNextPage) {
+                if (!commentsCursor)
+                    throw new Error("GitHub review thread comments page was truncated");
+                thread.comments.nodes.push(...(await fetchRemainingComments(thread.id, commentsCursor)));
+            }
+        }
+        threads.push(...connection.nodes);
+        if (!connection.pageInfo?.hasNextPage)
+            break;
+        cursor = connection.pageInfo.endCursor;
+        if (!cursor)
+            throw new Error("GitHub review threads page was truncated");
+    }
     return threads.flatMap((thread) => {
         if (thread.isResolved || !thread.comments.nodes.length)
             return [];

package/dist/orchestrator/majority.js

@@ -10,7 +10,7 @@ export function aggregateStringMajority(results, votes) {
     const voters = Object.fromEntries(votes.map((vote) => [vote, []]));
     for (const result of results) {
         counts[result.vote] += 1;
-        voters[result.vote].push(result.reviewer);
+        voters[result.vote].push(result.voter);
     }
     const threshold = majorityThreshold(results.length);
     const vote = votes.find((item) => counts[item] >= threshold);

package/dist/orchestrator/run-manager.js

@@ -1507,56 +1507,56 @@ export class MagiRunManager {
             });
         }
         if (progress.type === "triage_agent_started") {
-            const reviewer = state.reviewers[progress.reviewer];
-            if (reviewer)
-                reviewer.status = "running";
+            const voter = state.reviewers[progress.voter];
+            if (voter)
+                voter.status = "running";
         }
         if (progress.type === "triage_agent_session") {
-            const reviewer = state.reviewers[progress.reviewer];
-            if (reviewer) {
+            const voter = state.reviewers[progress.voter];
+            if (voter) {
                 if (progress.options)
                     this.input.setSessionOptions?.(progress.sessionId, progress.options);
-                reviewer.sessionId = progress.sessionId;
-                reviewer.status = "running";
-                reviewer.lastUpdate = now();
+                voter.sessionId = progress.sessionId;
+                voter.status = "running";
+                voter.lastUpdate = now();
                 this.sessionToRun.set(progress.sessionId, {
-                    agent: progress.reviewer,
+                    agent: progress.voter,
                     runId,
                 });
             }
         }
         if (progress.type === "triage_agent_repair") {
-            const reviewer = state.reviewers[progress.reviewer];
-            if (reviewer) {
-                reviewer.status = "repairing";
-                reviewer.repairAttempts += 1;
-                reviewer.lastUpdate = now();
+            const voter = state.reviewers[progress.voter];
+            if (voter) {
+                voter.status = "repairing";
+                voter.repairAttempts += 1;
+                voter.lastUpdate = now();
             }
         }
         if (progress.type === "triage_agent_response") {
-            const reviewer = state.reviewers[progress.reviewer];
-            if (reviewer) {
-                reviewer.sessionId = progress.sessionId;
-                reviewer.lastUpdate = now();
+            const voter = state.reviewers[progress.voter];
+            if (voter) {
+                voter.sessionId = progress.sessionId;
+                voter.lastUpdate = now();
             }
         }
         if (progress.type === "triage_agent_completed") {
-            const reviewer = state.reviewers[progress.reviewer];
-            if (reviewer) {
-                reviewer.sessionId = progress.sessionId;
-                reviewer.status = "completed";
-                reviewer.verdict = progress.vote;
-                reviewer.rawPath = join(state.outputDir, `${progress.reviewer}.${progress.phase}.raw.txt`);
-                reviewer.parsedPath = join(state.outputDir, `${progress.reviewer}.${progress.phase}.json`);
-                reviewer.lastUpdate = now();
+            const voter = state.reviewers[progress.voter];
+            if (voter) {
+                voter.sessionId = progress.sessionId;
+                voter.status = "completed";
+                voter.verdict = progress.vote;
+                voter.rawPath = join(state.outputDir, `${progress.voter}.${progress.phase}.raw.txt`);
+                voter.parsedPath = join(state.outputDir, `${progress.voter}.${progress.phase}.json`);
+                voter.lastUpdate = now();
             }
         }
         if (progress.type === "triage_agent_failed") {
-            const reviewer = state.reviewers[progress.reviewer];
-            if (reviewer) {
-                reviewer.status = "failed";
-                reviewer.error = redactSecrets(progress.error);
-                reviewer.lastUpdate = now();
+            const voter = state.reviewers[progress.voter];
+            if (voter) {
+                voter.status = "failed";
+                voter.error = redactSecrets(progress.error);
+                voter.lastUpdate = now();
             }
         }
         if (progress.type === "triage_creator_started") {
@@ -1610,16 +1610,16 @@ export class MagiRunManager {
             }));
         }
         if (progress.type === "triage_agent_started") {
-            await this.notify(state, `**Triage agent ${progress.reviewer}** started ${progress.phase} for ${issue}.`);
+            await this.notify(state, `**Triage agent ${progress.voter}** started ${progress.phase} for ${issue}.`);
         }
         if (progress.type === "triage_agent_repair") {
-            await this.notify(state, `**Triage agent ${progress.reviewer}** started JSON regeneration for ${issue}.`);
+            await this.notify(state, `**Triage agent ${progress.voter}** started JSON regeneration for ${issue}.`);
         }
         if (progress.type === "triage_agent_completed") {
-            await this.notify(state, `**Triage agent ${progress.reviewer}** completed ${progress.phase} for ${issue}: ${progress.vote}.`);
+            await this.notify(state, `**Triage agent ${progress.voter}** completed ${progress.phase} for ${issue}: ${progress.vote}.`);
         }
         if (progress.type === "triage_agent_failed") {
-            await this.notify(state, `**Triage agent ${progress.reviewer}** failed ${progress.phase} for ${issue}: ${redactSecrets(progress.error)}`);
+            await this.notify(state, `**Triage agent ${progress.voter}** failed ${progress.phase} for ${issue}: ${redactSecrets(progress.error)}`);
         }
         if (progress.type === "comment_posting") {
             await this.notify(state, `Posting triage comment for ${issue}.`);

package/dist/orchestrator/triage.js

@@ -106,24 +106,24 @@ async function emitTriageModelProgress(input) {
         await emitProgress(input.run, {
             options: input.progress.options,
             phase: input.phase,
-            reviewer: input.reviewer,
             sessionId: input.progress.sessionId,
             type: "triage_agent_session",
+            voter: input.voter,
         });
     }
     if (input.progress.type === "repair") {
         await emitProgress(input.run, {
             phase: input.phase,
-            reviewer: input.reviewer,
             type: "triage_agent_repair",
+            voter: input.voter,
         });
     }
     if (input.progress.type === "response") {
         await emitProgress(input.run, {
             phase: input.phase,
-            reviewer: input.reviewer,
             sessionId: input.progress.sessionId,
             type: "triage_agent_response",
+            voter: input.voter,
         });
     }
 }
@@ -133,12 +133,12 @@ async function runVote(input) {
         directory: input.directory,
         issue: input.issue,
         repository: input.repository,
-        reviewer: input.agent,
+        voter: input.agent,
     });
     await emitProgress(input.run, {
         phase: input.phase,
-        reviewer: input.agent.key,
         type: "triage_agent_started",
+        voter: input.agent.key,
     });
     let result;
     try {
@@ -148,8 +148,8 @@ async function runVote(input) {
             onProgress: (progress) => emitTriageModelProgress({
                 phase: input.phase,
                 progress,
-                reviewer: input.agent.key,
                 run: input.run,
+                voter: input.agent.key,
             }),
             options: input.agent.options,
             parentSessionId: input.run.parentSessionId,
@@ -166,28 +166,28 @@ async function runVote(input) {
         await emitProgress(input.run, {
             error: error instanceof Error ? error.message : String(error),
             phase: input.phase,
-            reviewer: input.agent.key,
             type: "triage_agent_failed",
+            voter: input.agent.key,
         });
         throw error;
     }
     await emitProgress(input.run, {
         phase: input.phase,
-        reviewer: input.agent.key,
         sessionId: result.sessionId,
         type: "triage_agent_completed",
+        voter: input.agent.key,
         vote: result.value.vote,
     });
     return {
         ...result.value,
         promptText: prompt,
         raw: result.raw,
-        reviewer: input.agent.key,
         sessionId: result.sessionId,
+        voter: input.agent.key,
     };
 }
 async function writeVoteArtifacts(input) {
-    const base = join(input.outputDir, `${input.reviewer}.${input.phase}`);
+    const base = join(input.outputDir, `${input.voter}.${input.phase}`);
     await writeFile(`${base}.prompt.txt`, `${input.output.promptText}\n`);
     await writeFile(`${base}.raw.txt`, `${input.output.raw}\n`);
     await writeJson(`${base}.json`, {
@@ -233,14 +233,14 @@ async function runDuplicateVote(input) {
         signal: input.input.signal,
     })));
     const majority = aggregateStringMajority(outputs.map((output, index) => ({
-        reviewer: agents[index].key,
+        voter: agents[index].key,
         vote: output.vote,
     })), DUPLICATE_VOTES);
     await Promise.all(outputs.map((output, index) => writeVoteArtifacts({
         output,
         outputDir: input.outputDir,
         phase: "duplicate",
-        reviewer: agents[index].key,
+        voter: agents[index].key,
     })));
     await Promise.all(outputs.map((output, index) => writeJson(join(input.outputDir, `${agents[index].key}.duplicate.json`), {
         duplicateOf: output.duplicateOf,
@@ -275,14 +275,14 @@ async function runPhaseVote(input) {
         signal: input.input.signal,
     })));
     const majority = aggregateStringMajority(outputs.map((output, index) => ({
-        reviewer: agents[index].key,
+        voter: agents[index].key,
         vote: output.vote,
     })), input.votes);
     await Promise.all(outputs.map((output, index) => writeVoteArtifacts({
         output,
         outputDir: input.outputDir,
         phase: input.phase,
-        reviewer: agents[index].key,
+        voter: agents[index].key,
     })));
     await writeJson(join(input.outputDir, `${input.phase}-majority.json`), majority);
     return { outputs, vote: majority.vote };
@@ -463,7 +463,7 @@ async function classifyMentionReplies(input) {
         directory: input.input.directory,
         issue: input.input.issue,
         repository: input.input.repository,
-        reviewer: agent,
+        voter: agent,
     });
     const result = await runModelWithRepair({
         client: input.input.client,
@@ -533,12 +533,11 @@ function askOutputs(outputs) {
     return (outputs ?? []).filter((output) => output.vote === "ASK");
 }
 function chooseDecisionReason(input) {
-    return (input.outputs?.find((output) => output.reviewer === input.reporter.key &&
+    return (input.outputs?.find((output) => output.voter === input.reporter.key &&
         output.vote === input.vote &&
         output.reason)?.reason ??
         input.outputs?.find((output) => output.vote === input.vote)?.reason ??
-        input.outputs?.find((output) => output.reviewer === input.reporter.key)
-            ?.reason);
+        input.outputs?.find((output) => output.voter === input.reporter.key)?.reason);
 }
 async function postMarkedIssueComment(input) {
     const posted = await postIssueComment(input.exec, input.repository, input.issue, input.account, input.body);
@@ -586,7 +585,7 @@ async function persistProcessedMarker(input) {
 async function postAskComments(input) {
     const urls = [];
     for (const output of askOutputs(input.outputs)) {
-        const agent = agentForKey(input.repository, output.reviewer);
+        const agent = agentForKey(input.repository, output.voter);
         const body = input.mark
             ? `${output.body}\n\n${marker({
                 action: input.action,

package/dist/prompts/compose.js

@@ -333,7 +333,7 @@ async function composeTriageVotePrompt(input) {
     return [
         task,
         languageBlock(input.repository.language),
-        personaBlock(input.reviewer.persona),
+        personaBlock(input.voter.persona),
         input.outputContract,
     ]
         .filter(Boolean)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-magi",
-  "version": "0.0.0-dev-20260522220245",
+  "version": "0.0.0-dev-20260522220355",
   "description": "Multi-agent PR review and merge orchestration plugin for OpenCode.",
   "license": "MIT",
   "author": "Hirotomo Yamada <hirotomo.yamada@avap.co.jp>",