opencode-magi 0.0.0-dev-20260520165753 → 0.0.0-dev-20260520173258

package/dist/orchestrator/review-context.js

@@ -0,0 +1,309 @@
+import { fetchIssue, fetchIssueCommentPage, fetchPullRequestClosingIssues, fetchPullRequestCommentPage, fetchPullRequestReviewThreadPage, fetchPullRequestSafetyMeta, } from "../github/commands";
+const LIMITS = {
+    closingIssueComments: 20,
+    commentBody: 4000,
+    prComments: 20,
+    referencedIssueComments: 10,
+    reviewThreadComments: 20,
+    reviewThreads: 50,
+};
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function truncateBody(body) {
+    if (body.length <= LIMITS.commentBody)
+        return { body };
+    return {
+        body: `${body.slice(0, LIMITS.commentBody)}\n[truncated after ${LIMITS.commentBody} characters]`,
+        truncated: true,
+    };
+}
+function boundedComments(comments, limit) {
+    return [...comments]
+        .sort((a, b) => a.createdAt.localeCompare(b.createdAt))
+        .slice(-limit)
+        .map((comment) => ({
+        author: comment.author,
+        createdAt: comment.createdAt,
+        id: comment.id,
+        url: comment.url,
+        ...truncateBody(comment.body),
+    }));
+}
+function omittedCommentCount(input) {
+    return input.omitted + Math.max(0, input.comments.length - input.limit);
+}
+function quoteEvidence(value) {
+    const compact = value.replaceAll(/\s+/g, " ").trim();
+    return compact.length > 120 ? `${compact.slice(0, 117)}...` : compact;
+}
+function issueReferencePattern(repository) {
+    const host = escapeRegExp(repository.github.host || "github.com");
+    const owner = escapeRegExp(repository.github.owner);
+    const repo = escapeRegExp(repository.github.repo);
+    return new RegExp(`(?:https?://${host}/${owner}/${repo}/issues/(\\d+)|#(\\d+))`, "gi");
+}
+function issueNumberFromMatch(match) {
+    return Number(match[1] ?? match[2]);
+}
+function addRelationship(relationships, number, relationship, source) {
+    const current = relationships.get(number);
+    const nextRelationship = current?.relationship === "closing" || relationship === "closing"
+        ? "closing"
+        : "referenced";
+    const sources = current?.sources ?? [];
+    relationships.set(number, {
+        number,
+        relationship: nextRelationship,
+        sources: sources.includes(source) ? sources : [...sources, source],
+    });
+}
+function scanRelationshipText(input) {
+    const referencePattern = issueReferencePattern(input.repository);
+    const closingPattern = new RegExp(`\\b(?:close|closes|closed|fix|fixes|fixed|resolve|resolves|resolved)\\b[\\s\\S]{0,80}?${referencePattern.source}`, "gi");
+    for (const match of input.text.matchAll(referencePattern)) {
+        const number = issueNumberFromMatch(match);
+        if (number === input.currentPr)
+            continue;
+        addRelationship(input.relationships, number, "referenced", `${input.label} "${quoteEvidence(match[0])}"`);
+    }
+    for (const match of input.text.matchAll(closingPattern)) {
+        const number = Number(match[1] ?? match[2]);
+        if (!number || number === input.currentPr)
+            continue;
+        addRelationship(input.relationships, number, "closing", `${input.label} "${quoteEvidence(match[0])}"`);
+    }
+}
+export function collectIssueRelationships(input) {
+    const relationships = new Map();
+    for (const issue of input.closingIssues) {
+        if (issue.number === input.pr.number)
+            continue;
+        addRelationship(relationships, issue.number, "closing", "GitHub closingIssuesReferences");
+    }
+    scanRelationshipText({
+        currentPr: input.pr.number,
+        label: "PR title",
+        relationships,
+        repository: input.repository,
+        text: input.pr.title,
+    });
+    scanRelationshipText({
+        currentPr: input.pr.number,
+        label: "PR body",
+        relationships,
+        repository: input.repository,
+        text: input.pr.body ?? "",
+    });
+    for (const comment of input.prComments) {
+        scanRelationshipText({
+            currentPr: input.pr.number,
+            label: `PR comment ${comment.id}`,
+            relationships,
+            repository: input.repository,
+            text: comment.body,
+        });
+    }
+    for (const thread of input.reviewThreads) {
+        for (const comment of thread.comments) {
+            scanRelationshipText({
+                currentPr: input.pr.number,
+                label: `review thread ${thread.threadId} comment ${comment.commentId}`,
+                relationships,
+                repository: input.repository,
+                text: comment.body,
+            });
+        }
+    }
+    return [...relationships.values()].sort((a, b) => a.number - b.number);
+}
+async function contextIssue(input) {
+    const issue = input.issue ??
+        (await fetchIssue(input.exec, input.repository, input.relationship.number));
+    const commentPage = await fetchIssueCommentPage(input.exec, input.repository, issue.number, input.limit);
+    return {
+        author: issue.author,
+        body: issue.body,
+        comments: boundedComments(commentPage.comments, input.limit),
+        commentsOmitted: omittedCommentCount({
+            comments: commentPage.comments,
+            limit: input.limit,
+            omitted: commentPage.omitted,
+        }),
+        number: issue.number,
+        relationship: input.relationship.relationship,
+        source: input.relationship.sources.join("; "),
+        state: issue.state,
+        title: issue.title,
+        url: issue.url,
+    };
+}
+function orderReviewThreads(threads) {
+    return [...threads]
+        .sort((a, b) => {
+        if (a.isResolved !== b.isResolved)
+            return a.isResolved ? 1 : -1;
+        const aLatest = a.comments.at(-1)?.createdAt ?? "";
+        const bLatest = b.comments.at(-1)?.createdAt ?? "";
+        return bLatest.localeCompare(aLatest);
+    })
+        .slice(0, LIMITS.reviewThreads)
+        .map((thread) => ({
+        ...thread,
+        comments: thread.comments
+            .slice(-LIMITS.reviewThreadComments)
+            .map((comment) => ({
+            ...comment,
+            ...truncateBody(comment.body),
+        })),
+    }));
+}
+export async function buildReviewContextSnapshot(input) {
+    const [prCommentPage, reviewThreadPage, safetyMeta, closingIssues] = await Promise.all([
+        fetchPullRequestCommentPage(input.exec, input.repository, input.pr.number, LIMITS.prComments),
+        fetchPullRequestReviewThreadPage(input.exec, input.repository, input.pr.number, LIMITS.reviewThreads, LIMITS.reviewThreadComments),
+        fetchPullRequestSafetyMeta(input.exec, input.repository, input.pr.number),
+        fetchPullRequestClosingIssues(input.exec, input.repository, input.pr.number).catch(() => []),
+    ]);
+    const prComments = prCommentPage.comments;
+    const orderedReviewThreads = orderReviewThreads(reviewThreadPage.threads);
+    const prCommentsOmitted = omittedCommentCount({
+        comments: prComments,
+        limit: LIMITS.prComments,
+        omitted: prCommentPage.omitted,
+    });
+    const relationships = collectIssueRelationships({
+        closingIssues,
+        pr: input.pr,
+        prComments,
+        repository: input.repository,
+        reviewThreads: orderedReviewThreads,
+    });
+    const closingIssueMap = new Map(closingIssues.map((issue) => [issue.number, issue]));
+    const closingRelationships = relationships.filter((relationship) => relationship.relationship === "closing");
+    const referencedRelationships = relationships.filter((relationship) => relationship.relationship === "referenced");
+    return {
+        closingIssues: await Promise.all(closingRelationships.map((relationship) => contextIssue({
+            exec: input.exec,
+            issue: closingIssueMap.get(relationship.number),
+            limit: LIMITS.closingIssueComments,
+            relationship,
+            repository: input.repository,
+        }))),
+        pullRequest: {
+            author: input.pr.author?.login ?? safetyMeta.author,
+            baseRef: input.pr.baseRefName,
+            baseSha: input.pr.baseRefOid,
+            body: input.pr.body ?? "",
+            changedFiles: safetyMeta.files,
+            comments: boundedComments(prComments, LIMITS.prComments),
+            commentsOmitted: prCommentsOmitted,
+            headRef: input.pr.headRefName,
+            headSha: input.pr.headRefOid,
+            number: input.pr.number,
+            relationship: "target",
+            source: "/magi:review input",
+            state: input.pr.state ?? "",
+            title: input.pr.title,
+            url: input.pr.url,
+        },
+        referencedIssues: await Promise.all(referencedRelationships.map((relationship) => contextIssue({
+            exec: input.exec,
+            limit: LIMITS.referencedIssueComments,
+            relationship,
+            repository: input.repository,
+        }))),
+        reviewDiscussion: {
+            prComments: boundedComments(prComments, LIMITS.prComments),
+            prCommentsOmitted,
+            reviewThreads: orderedReviewThreads,
+            reviewThreadsOmitted: reviewThreadPage.omitted,
+        },
+    };
+}
+function indented(value) {
+    return value.trim() ? value : "(empty)";
+}
+function renderOmissionNote(omitted, label, limit) {
+    return omitted > 0
+        ? `\n[omitted ${omitted} older ${label} due to limit ${limit}]`
+        : "";
+}
+function renderComments(comments, omitted = 0, limit = comments.length) {
+    if (!comments.length)
+        return `(none)${renderOmissionNote(omitted, "comments", limit)}`;
+    return (comments
+        .map((comment) => {
+        const suffix = comment.truncated ? " [truncated]" : "";
+        return `- ${comment.createdAt} @${comment.author} (${comment.id})${suffix}\n${indented(comment.body)}`;
+    })
+        .join("\n") + renderOmissionNote(omitted, "comments", limit));
+}
+function renderIssue(issue) {
+    return `<issue>
+number: ${issue.number}
+title: ${issue.title}
+url: ${issue.url}
+state: ${issue.state}
+author: ${issue.author}
+relationship: ${issue.relationship}
+source: ${issue.source}
+body:
+${indented(issue.body)}
+comments:
+${renderComments(issue.comments, issue.commentsOmitted, issue.relationship === "closing" ? LIMITS.closingIssueComments : LIMITS.referencedIssueComments)}
+</issue>`;
+}
+function renderThreads(threads, omitted = 0) {
+    if (!threads.length) {
+        return `(none)${renderOmissionNote(omitted, "review threads", LIMITS.reviewThreads)}`;
+    }
+    return (threads
+        .map((thread) => {
+        const comments = thread.comments
+            .map((comment) => {
+            const suffix = comment.truncated ? " [truncated]" : "";
+            return `  - ${comment.createdAt} @${comment.author} (${comment.commentId})${suffix}\n${indented(comment.body)}`;
+        })
+            .join("\n") +
+            renderOmissionNote(thread.omittedComments ?? 0, "thread comments", LIMITS.reviewThreadComments);
+        return `- threadId: ${thread.threadId}\n  resolved: ${Boolean(thread.isResolved)}\n  path: ${thread.path}:${thread.line}\n  comments:\n${comments}`;
+    })
+        .join("\n") +
+        renderOmissionNote(omitted, "review threads", LIMITS.reviewThreads));
+}
+export function renderReviewContext(snapshot) {
+    return [
+        `<pull_request_context>
+number: ${snapshot.pullRequest.number}
+title: ${snapshot.pullRequest.title}
+url: ${snapshot.pullRequest.url}
+state: ${snapshot.pullRequest.state}
+author: ${snapshot.pullRequest.author}
+relationship: ${snapshot.pullRequest.relationship}
+source: ${snapshot.pullRequest.source}
+baseRef: ${snapshot.pullRequest.baseRef}
+headRef: ${snapshot.pullRequest.headRef}
+baseSha: ${snapshot.pullRequest.baseSha}
+headSha: ${snapshot.pullRequest.headSha}
+body:
+${indented(snapshot.pullRequest.body)}
+comments:
+${renderComments(snapshot.pullRequest.comments, snapshot.pullRequest.commentsOmitted, LIMITS.prComments)}
+changedFiles:
+${snapshot.pullRequest.changedFiles.length ? snapshot.pullRequest.changedFiles.map((file) => `- ${file}`).join("\n") : "(none)"}
+</pull_request_context>`,
+        `<closing_issues>
+${snapshot.closingIssues.length ? snapshot.closingIssues.map(renderIssue).join("\n") : "(none)"}
+</closing_issues>`,
+        `<referenced_issues>
+${snapshot.referencedIssues.length ? snapshot.referencedIssues.map(renderIssue).join("\n") : "(none)"}
+</referenced_issues>`,
+        `<review_discussion>
+prComments:
+${renderComments(snapshot.reviewDiscussion.prComments, snapshot.reviewDiscussion.prCommentsOmitted, LIMITS.prComments)}
+reviewThreads:
+${renderThreads(snapshot.reviewDiscussion.reviewThreads, snapshot.reviewDiscussion.reviewThreadsOmitted)}
+</review_discussion>`,
+    ].join("\n\n");
+}

package/dist/orchestrator/review.js

@@ -13,6 +13,7 @@ import { closeMinorityReviewers, mergeVerdictForPolicy, } from "./majority";
 import { runModelWithRepair } from "./model";
 import { mapPool } from "./pool";
 import { formatReviewReport } from "./report";
+import { buildReviewContextSnapshot, renderReviewContext, } from "./review-context";
 import { checkSafetyGate, hasSafetyGate } from "./safety";
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
@@ -38,7 +39,7 @@ async function postReviewOutput(input, reviewerKey, output) {
         return postApproval(input.exec, input.repository, input.pr, reviewer.account);
     if (output.verdict === "CLOSE")
         return postCloseComment(input.exec, input.repository, input.pr, reviewer.account, output.reason ?? "Close requested.");
-    return postChangesRequested(input.exec, input.repository, input.pr, reviewer.account, output.findings);
+    return postChangesRequested(input.exec, input.repository, input.pr, reviewer.account, output.findings, output.requirementFindings);
 }
 function dryRunReviewPost(key, output) {
     if (output.verdict === "MERGE")
@@ -137,8 +138,13 @@ function parseRereviewOutputWithInlineTargets(text, targets) {
 function reviewOutputFromState(review) {
     const verdict = reviewStateToVerdict(review.state);
     return verdict === "CLOSE"
-        ? { findings: [], reason: review.body || "Close requested.", verdict }
-        : { findings: [], verdict };
+        ? {
+            findings: [],
+            reason: review.body || "Close requested.",
+            requirementFindings: [],
+            verdict,
+        }
+        : { findings: [], requirementFindings: [], verdict };
 }
 export function hasPendingThreadReply(threads, reviewerAccount) {
     return threads.some((thread) => {
@@ -162,7 +168,7 @@ async function postRereviewOutput(input, reviewerKey, output) {
         return postApproval(input.exec, input.repository, input.pr, reviewer.account);
     if (output.verdict === "CLOSE")
         return postCloseComment(input.exec, input.repository, input.pr, reviewer.account, output.reason ?? "Close requested.");
-    if (!output.newFindings.length)
+    if (!output.newFindings.length && !output.requirementFindings.length)
         return "";
     return postChangesRequested(input.exec, input.repository, input.pr, reviewer.account, output.newFindings.map((finding) => ({
         fix: "Please address this before merging.",
@@ -170,7 +176,7 @@ async function postRereviewOutput(input, reviewerKey, output) {
         line: finding.line,
         path: finding.path,
         startLine: finding.startLine,
-    })));
+    })), output.requirementFindings);
 }
 function isReviewOutput(output) {
     return "findings" in output;
@@ -202,6 +208,7 @@ async function runFindingValidation(input) {
             includeSessionContext: !hasReviewerSession,
             pr: input.reviewInput.pr,
             repository: input.reviewInput.repository,
+            reviewContext: input.reviewContext,
             reviewer,
             worktreePath: input.worktreePath,
         });
@@ -314,6 +321,7 @@ async function runCloseReconsideration(input) {
             includeSessionContext: !hasReviewerSession,
             pr: input.reviewInput.pr,
             repository: input.reviewInput.repository,
+            reviewContext: input.reviewContext,
             reviewer,
             worktreePath: input.worktreePath,
         });
@@ -464,6 +472,15 @@ export async function runReview(input) {
         pr: input.pr,
     }), ...(input.runId ? [input.runId] : []));
     await mkdir(outputDir, { recursive: true });
+    await input.onProgress?.({ phase: "fetching review context", type: "phase" });
+    const reviewContextSnapshot = await buildReviewContextSnapshot({
+        exec,
+        pr: meta,
+        repository: input.repository,
+    });
+    const reviewContext = renderReviewContext(reviewContextSnapshot);
+    await writeFile(join(outputDir, "review-context.json"), JSON.stringify(reviewContextSnapshot, null, 2));
+    await writeFile(join(outputDir, "review-context.md"), `${reviewContext}\n`);
     await input.onProgress?.({ phase: "waiting for checks", type: "phase" });
     const checkResult = await waitForChecksWithClassification({
         client: input.client,
@@ -565,6 +582,7 @@ export async function runReview(input) {
                     previousReview: previousReviewText(previous),
                     previousHeadSha: previous.commit.oid,
                     repository: input.repository,
+                    reviewContext,
                     reviewer,
                     unresolvedThreads: JSON.stringify(unresolved, null, 2),
                     worktreePath,
@@ -631,6 +649,7 @@ export async function runReview(input) {
                 headSha: meta.headRefOid,
                 pr: input.pr,
                 repository: input.repository,
+                reviewContext,
                 reviewer,
                 worktreePath,
             });
@@ -727,6 +746,7 @@ export async function runReview(input) {
             inlineCommentTargets,
             meta,
             outputDir,
+            reviewContext,
             reviewInput: { ...input, exec },
             sessionIds,
             targets: closeTargets,
@@ -736,6 +756,7 @@ export async function runReview(input) {
             entries,
             meta,
             outputDir,
+            reviewContext,
             reviewInput: { ...input, exec },
             sessionIds,
             worktreePath,

package/dist/orchestrator/run-manager.js

@@ -1273,10 +1273,12 @@ export class MagiRunManager {
         const completed = this.active.get(input.runId);
         if (!completed || completed.status === "cancelled")
             return;
-        completed.status = result.result === "FAILED" ? "failed" : "completed";
-        completed.phase = result.result;
+        const triageResult = JSON.stringify(result.result);
+        completed.status =
+            result.result.disposition === "failed" ? "failed" : "completed";
+        completed.phase = triageResult;
         completed.completedAt = now();
-        completed.verdict = result.result;
+        completed.verdict = triageResult;
         completed.reportPath = join(completed.outputDir, "report.md");
         for (const agent of Object.values(completed.reviewers)) {
             if (agent.status === "pending")