opencode-magi 0.2.0 → 0.4.0

package/dist/orchestrator/merge.js

@@ -1,11 +1,12 @@
 import { mkdir, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { prRunOutputDir } from "../config/output";
-import { closePullRequest, configureGitIdentity, fetchMergeQueueRequirement, fetchPullRequest, fetchUnresolvedThreads, mergePullRequest, postApproval, postChangesRequested, postCloseComment, postReply, pushHead, removeWorktree, resolveThread, waitForMergeQueue, } from "../github/commands";
+import { closePullRequest, configureGitIdentity, fetchMergeQueueRequirement, fetchPullRequest, fetchUnresolvedThreads, mergePullRequest, postApproval, postChangesRequested, postCloseComment, postReply, pushHead, removeWorktree, resolveThread, shellQuote, waitForMergeQueue, } from "../github/commands";
 import { composeEditPrompt, composeRereviewCloseReconsiderationPrompt, composeRereviewPrompt, } from "../prompts/compose";
 import { parseEditOutput, parseRereviewCloseReconsiderationOutput, parseRereviewOutput, } from "../prompts/output";
 import { throwIfAborted, withAbortSignal } from "./abort";
 import { waitForChecksWithClassification } from "./ci";
+import { parseRightSideDiffTargets, validateInlineCommentTargets, } from "./inline-comments";
 import { closeMinorityReviewers, mergeVerdictForPolicy } from "./majority";
 import { runModelWithRepair } from "./model";
 import { mapPool } from "./pool";
@@ -49,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");
@@ -63,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,
     });
@@ -144,21 +146,72 @@ async function postRereviewOutput(input, reviewerKey, output) {
     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 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,
+            ...(finding.line == null ? {} : { line: finding.line }),
             startLine: finding.startLine,
-        })));
+        })), output.requirementFindings);
     }
     return replies[0] ?? "";
 }
+function parseRereviewOutputWithInlineTargets(text, targets) {
+    const output = parseRereviewOutput(text);
+    validateInlineCommentTargets(output.newFindings, targets, "newFindings");
+    return output;
+}
+function newFindingToEditorFinding(reviewer, finding) {
+    return {
+        body: finding.body,
+        fix: "Please address this before merging.",
+        path: finding.path,
+        reviewer,
+        ...(finding.line == null ? {} : { line: finding.line }),
+        ...(finding.startLine == null ? {} : { startLine: finding.startLine }),
+        type: finding.line == null ? "file" : "inline",
+    };
+}
+export function blockingReviewFindings(outputs) {
+    return Object.entries(outputs).flatMap(([reviewer, output]) => {
+        if (output.verdict !== "CHANGES_REQUESTED")
+            return [];
+        const requirementFindings = output.requirementFindings.map((finding) => ({
+            evidence: finding.evidence,
+            fix: finding.fix,
+            issueNumber: finding.issueNumber,
+            requirement: finding.requirement,
+            reviewer,
+            type: "requirement",
+        }));
+        if ("findings" in output) {
+            return [
+                ...output.findings.map((finding) => ({
+                    fix: finding.fix,
+                    issue: finding.issue,
+                    path: finding.path,
+                    reviewer,
+                    ...(finding.line == null ? {} : { line: finding.line }),
+                    ...(finding.startLine == null
+                        ? {}
+                        : { startLine: finding.startLine }),
+                    type: finding.line == null ? "file" : "inline",
+                })),
+                ...requirementFindings,
+            ];
+        }
+        return [
+            ...output.newFindings.map((finding) => newFindingToEditorFinding(reviewer, finding)),
+            ...requirementFindings,
+        ];
+    });
+}
 async function runRereview(input, worktreePath, previousHeadSha, cycle, sessionIds, ciFailureContext, options = {}) {
     throwIfAborted(input.signal);
     const meta = await fetchPullRequest(input.exec, input.repository, input.pr);
     const headSha = options.dryRunHeadSha ?? meta.headRefOid;
+    const inlineCommentTargets = parseRightSideDiffTargets(await input.exec(`git diff --no-ext-diff --unified=3 ${shellQuote(meta.baseRefOid)} ${shellQuote(headSha)}`, { cwd: worktreePath }));
     const artifactDir = outputDir(input);
     let entries = await mapPool(input.repository.agents.reviewers, input.repository.concurrency.reviewers, async (reviewer) => {
         throwIfAborted(input.signal);
@@ -213,7 +266,7 @@ async function runRereview(input, worktreePath, previousHeadSha, cycle, sessionI
                     }
                 },
                 options: reviewer.options,
-                parse: parseRereviewOutput,
+                parse: (text) => parseRereviewOutputWithInlineTargets(text, inlineCommentTargets),
                 permission: reviewer.permission,
                 prompt,
                 repairAttempts: input.config.output?.repairAttempts ?? 3,
@@ -296,7 +349,11 @@ async function runRereview(input, worktreePath, previousHeadSha, cycle, sessionI
                         }
                     },
                     options: reviewer.options,
-                    parse: parseRereviewCloseReconsiderationOutput,
+                    parse: (text) => {
+                        const output = parseRereviewCloseReconsiderationOutput(text);
+                        validateInlineCommentTargets(output.newFindings, inlineCommentTargets, "newFindings");
+                        return output;
+                    },
                     permission: reviewer.permission,
                     prompt,
                     repairAttempts: input.config.output?.repairAttempts ?? 3,
@@ -359,6 +416,7 @@ async function finishMergeRun(input, result, reportInput) {
         editorOutputs: reportInput.editorOutputs,
         outputs: reportInput.outputs,
         posted: reportInput.posted,
+        pr: input.pr,
         repository: input.repository,
         status: result.status,
     });
@@ -448,15 +506,42 @@ 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) => {
+                if (finding.line == null)
+                    return [];
                 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) => {
+            if (finding.line == null)
+                return [];
+            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(),
                         },
@@ -464,27 +549,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;
@@ -542,6 +608,7 @@ export async function runMerge(input) {
                 editorOutputs: [],
                 outputs: {},
                 posted: {},
+                pr: input.pr,
                 repository: input.repository,
                 safety,
                 status: "safety_blocked",
@@ -653,7 +720,14 @@ export async function runMerge(input) {
                 maxThreadResolutionCycles: input.repository.merge.maxThreadResolutionCycles,
                 threads: unresolvedThreads,
             });
-            if (!editableThreads.length) {
+            const editorFindings = blockingReviewFindings(reportOutputs);
+            const editableFindings = editableThreads.length
+                ? editorFindings
+                : editorFindings.filter((finding) => finding.type !== "inline");
+            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",
@@ -680,7 +754,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

@@ -10,18 +10,30 @@ function reportUrl(value) {
 function linkOrText(text, url) {
     return url ? `[${text}](${url})` : text;
 }
+function pullRequestLine(input) {
+    const host = input.repository.github.host || "github.com";
+    const url = `https://${host}/${input.repository.github.owner}/${input.repository.github.repo}/pull/${input.pr}`;
+    return `- **Pull Request**: [#${input.pr}](${url})`;
+}
 function formatFinding(finding) {
-    const line = finding.startLine == null
-        ? `${finding.path}:${finding.line}`
-        : `${finding.path}:${finding.startLine}-${finding.line}`;
+    const line = finding.line == null
+        ? finding.path
+        : finding.startLine == null
+            ? `${finding.path}:${finding.line}`
+            : `${finding.path}:${finding.startLine}-${finding.line}`;
     return `\`${line}\`: ${finding.issue}`;
 }
 function formatRereviewFinding(finding) {
-    const line = finding.startLine == null
-        ? `${finding.path}:${finding.line}`
-        : `${finding.path}:${finding.startLine}-${finding.line}`;
+    const line = finding.line == null
+        ? finding.path
+        : finding.startLine == null
+            ? `${finding.path}:${finding.line}`
+            : `${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;
 }
@@ -73,7 +85,10 @@ function reviewerDetailLines(output) {
             return output.reason ? [output.reason] : [];
         if (output.verdict !== "CHANGES_REQUESTED")
             return [];
-        return output.findings.map(formatFinding);
+        return [
+            ...output.findings.map(formatFinding),
+            ...output.requirementFindings.map(formatRequirementFinding),
+        ];
     }
     if (output.verdict === "CLOSE")
         return output.reason ? [output.reason] : [];
@@ -81,6 +96,7 @@ function reviewerDetailLines(output) {
         return [];
     return [
         ...output.newFindings.map(formatRereviewFinding),
+        ...output.requirementFindings.map(formatRequirementFinding),
         ...output.followUps.map((item) => `Comment #${item.commentId}: ${item.body}`),
     ];
 }
@@ -150,6 +166,7 @@ function editorLines(outputs) {
 }
 export function formatReviewReport(input) {
     return [
+        pullRequestLine(input),
         ...dryRunLines(input.dryRun),
         ...safetyLines(input.safety),
         ...checkLines(input.ciReports),
@@ -158,6 +175,7 @@ export function formatReviewReport(input) {
 }
 export function formatMergeReport(input) {
     return [
+        pullRequestLine(input),
         ...mergeStatusLines(input.status),
         ...dryRunLines(input.dryRun),
         ...safetyLines(input.safety),

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");
+}