pi-pr-review 1.4.0 → 1.5.1

package/README.md

@@ -147,7 +147,7 @@ Closed/merged PRs no longer hard-skip. If you run `/pr-review 123` on a non-open
 
 `autoPostReviews` is a strict top-level boolean and defaults to `false`. A trusted project `.pi/pr-review.json` value overlays the user value; malformed effective values never enable posting. `/pr-review-config` edits user scope only and displays the effective value/source—if a trusted project overlay wins, edit that project file or use `--no-comment` for the run. Invocation flags are captured before prompt expansion: `--comment` forces posting for one run, `--no-comment` suppresses it, and using both is rejected.
 
-Publishing is extension-owned—the model never constructs the write request, and final JSON marked `disposition: "skipped"` is never published. It creates exactly one formal pull-request review containing a top-level body and associated P0–P3 inline comments. The GitHub event is hardcoded to `COMMENT`; the publisher cannot send `APPROVE` or `REQUEST_CHANGES`, even when the review's suggested verdict is `request_changes`. It validates the current head and every inline diff anchor before the single POST, so an invalid open-PR inline comment fails without leaving a partial review. Closed/merged PRs require either `--include-closed`/`--review-closed` or the one-shot affirmative confirmation, then use one body-only `COMMENT` review with inline findings folded into the body. Unknown or unconfirmed non-open lifecycle states fail without posting.
+Publishing is extension-owned—the model never constructs the write request, and final JSON marked `disposition: "skipped"` is never published. It creates exactly one formal pull-request review. The top-level body contains overview/verdict information, inline-vs-summary counts, nits, and findings that cannot be posted inline; successfully attached P0–P3 findings appear only in their associated inline comments, not duplicated in the top-level body. The GitHub event is hardcoded to `COMMENT`; the publisher cannot send `APPROVE` or `REQUEST_CHANGES`, even when the review's suggested verdict is `request_changes`. It validates the current head and every inline diff anchor before the single POST, so an invalid open-PR inline comment fails without leaving a partial review. Closed/merged PRs require either `--include-closed`/`--review-closed` or the one-shot affirmative confirmation, then use one body-only `COMMENT` review with each formerly-inline finding folded into the body exactly once. Unknown or unconfirmed non-open lifecycle states fail without posting.
 
 ### Duplicate review handling
 
@@ -216,6 +216,7 @@ pi-pr-review/
 - The `review_subagents` batch tool and `review_subagent` fallback spawn isolated `pi` subprocesses (`--mode json -p --no-session`) on your configured tier models. Reviewer prompts prohibit modifications, but a configured allowlist containing `bash` is not technically read-only; use a narrower allowlist if stronger enforcement is required.
 - Project-local `pr-review.json` is only read when the project is trusted. Because project `autoPostReviews: true` causes writes under your authenticated `gh` identity, the effective setting and source are surfaced when publication occurs.
 - GitHub publication uses `gh` only, verifies the current identity and PR head, checks paginated formal reviews and legacy comments for same-head markers, and hardcodes `event: COMMENT`. Ambiguous transport failures are reconciled once and never blindly retried.
+- **`gh api -f` caution:** `gh api ... -f body=@/tmp/file.md` posts the literal text `@/tmp/file.md`; unlike `gh pr comment --body-file`, `-f` does not expand `@file`. Use a JSON payload via `gh api ... --input -` for API requests. The built-in publisher already does this.
 - Tiered review calls multiple models per PR, concurrently for independent passes. Point `light` at a cheap model for overview/risk scan; reserve `heavy` for deep passes, and configure per-tier `fallbacks` only for acceptable backup models because retries can increase cost.
 
 ## Design notes

package/lib/pr-review-publish.ts

@@ -349,7 +349,23 @@ function findingLocation(finding: ReviewFindingLike): string {
 	return `${location.absolute_file_path}:${start}${end !== start ? `-${end}` : ""} ${(location.side ?? "RIGHT").toUpperCase()}`;
 }
 
-export function buildReviewSummary(review: ReviewLike): string {
+function publishCommentAnchor(comment: PublishComment): string {
+	return `${comment.path}:${comment.side}:${comment.start_line ?? comment.line}:${comment.line}`;
+}
+
+function findingAnchor(finding: ReviewFindingLike): string | undefined {
+	const location = finding.code_location;
+	const path = location?.absolute_file_path;
+	const side = location?.side?.toUpperCase();
+	const start = location?.line_range?.start;
+	const end = location?.line_range?.end;
+	if (!path || (side !== "LEFT" && side !== "RIGHT") || !Number.isInteger(start) || !Number.isInteger(end)) {
+		return undefined;
+	}
+	return `${path}:${side}:${start}:${end}`;
+}
+
+export function buildReviewSummary(review: ReviewLike, inlineComments: PublishComment[] = []): string {
 	const lines: string[] = [];
 	const number = review.pr?.number;
 	const title = String(review.pr?.title ?? "").replace(/\r?\n/g, " ").trim();
@@ -360,18 +376,29 @@ export function buildReviewSummary(review: ReviewLike): string {
 		lines.push("### Strengths", "", ...review.strengths.map((strength) => `- ${String(strength).replace(/^\s*-\s*/, "").trim()}`), "");
 	}
 	const findings = Array.isArray(review.findings) ? review.findings : [];
-	lines.push(`### Findings — ${findings.length}`, "");
+	const inlineAnchors = new Set(inlineComments.map(publishCommentAnchor));
+	const summaryFindings = findings.filter((finding) => {
+		if (!finding.code_location?.commentable || !isInlineSeverity(finding)) return true;
+		const anchor = findingAnchor(finding);
+		return !anchor || !inlineAnchors.has(anchor);
+	});
+	lines.push(
+		`### Findings — ${findings.length} total (${inlineComments.length} inline, ${summaryFindings.length} summary-only)`,
+		"",
+	);
 	if (findings.length === 0) {
 		lines.push("_No issues found._", "");
+	} else if (summaryFindings.length === 0) {
+		lines.push(`_All ${inlineComments.length} findings are attached inline below this review._`, "");
 	} else {
-		lines.push("| Severity | Finding | Location |", "|---|---|---|");
-		for (const finding of findings) {
+		lines.push("| Severity | Summary-only finding | Location |", "|---|---|---|");
+		for (const finding of summaryFindings) {
 			lines.push(
 				`| ${cell(String(finding.severity ?? "—"))} | ${cell(String(finding.title ?? "(untitled)"))} | \`${cell(findingLocation(finding))}\` |`,
 			);
 		}
 		lines.push("");
-		for (const finding of findings) {
+		for (const finding of summaryFindings) {
 			lines.push(`#### ${String(finding.title ?? "Finding")}`, `\`${findingLocation(finding)}\``, "");
 			if (finding.body?.trim()) lines.push(finding.body.trim(), "");
 		}
@@ -506,6 +533,10 @@ export function validateInlineComments(
 			errors.push(`${label}: comment body is empty or too large`);
 			continue;
 		}
+		if (containsReservedReviewMarker(body)) {
+			errors.push(`${label}: comment body contains a reserved pi-pr-review marker`);
+			continue;
+		}
 		comments.push({
 			path,
 			body,
@@ -546,6 +577,10 @@ export function collectFoldedComments(review: ReviewLike): CommentValidationResu
 			errors.push(`${label}: folded comment body is empty or too large`);
 			continue;
 		}
+		if (containsReservedReviewMarker(body)) {
+			errors.push(`${label}: folded comment body contains a reserved pi-pr-review marker`);
+			continue;
+		}
 		comments.push({
 			path,
 			body,
@@ -780,10 +815,6 @@ export async function publishPullReview(input: {
 			return { status: "failed", message: `GitHub preflight failed: ${String(error)}` };
 		}
 
-		const summary = buildReviewSummary(review);
-		const bodyError = validateReviewBody(summary);
-		if (bodyError) return { status: "failed", message: bodyError };
-
 		const lifecycle = authorizePullLifecycle(pull.state, pull.merged_at, allowNonOpen);
 		if (!lifecycle.lifecycle) return { status: "failed", message: lifecycle.error ?? "invalid PR lifecycle" };
 		const isOpen = lifecycle.lifecycle === "open";
@@ -809,6 +840,9 @@ export async function publishPullReview(input: {
 			comments = validated.comments;
 		}
 
+		const summary = buildReviewSummary(review, comments);
+		const bodyError = validateReviewBody(summary);
+		if (bodyError) return { status: "failed", message: bodyError };
 		const reviewBody = `${isOpen ? summary : foldInlineComments(summary, comments)}\n\n${marker}`;
 		if (Buffer.byteLength(reviewBody, "utf8") > MAX_BODY_BYTES) {
 			return { status: "failed", message: "final review body exceeds 65536 UTF-8 bytes" };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-pr-review",
-  "version": "1.4.0",
+  "version": "1.5.1",
   "description": "Model-agnostic GitHub PR code review prompt for pi. Pass a PR number; it derives the base and head branches from the PR in the current repo, reviews the diff, and returns structured JSON findings.",
   "keywords": [
     "pi-package",

package/prompts/pr-review.md

@@ -49,6 +49,7 @@ Arguments for this run: `$@`
 
 - All tools are functional. Do not test tools or make exploratory/throwaway calls. Every tool call must have a clear purpose.
 - Use the `gh` CLI (already authenticated) for all GitHub access. Do **not** use web fetch. `gh` auto-detects the repo from the current directory's git remote, so run commands from the cwd.
+- **`gh api -f` file-body trap:** `gh api ... -f body=@/tmp/file.md` does **not** read that file; it sends the literal string `@/tmp/file.md`. Never use `-f body=@file` for review/comment content. For an API request, construct JSON with the file contents and pipe it through `gh api ... --input -`; for a standalone PR issue comment, use `gh pr comment --body-file /tmp/file.md`. The extension-owned review publisher already uses JSON on stdin—do not replace it with `-f body=@file`.
 - Read what you need to review thoroughly: the diff is the primary artifact, but open surrounding files, callers, and convention files whenever it improves the review or lets you confirm a finding.
 - **Never disturb the user's working tree.** Do not `git checkout`/`gh pr checkout`, do not modify tracked files, do not commit or push. Any verification happens in an isolated worktree (Step 6).
 - Create a short todo list before you start, then work the steps in order.
@@ -163,7 +164,7 @@ The orchestrator must never call `gh` to post comments or reviews. Always finish
 - `--comment` → force publication for this run, but never bypass validation, stale-head checks, or duplicate checks
 - `--no-comment` → suppress publication for this run
 
-When enabled, the extension creates exactly one formal GitHub pull-request review. Its top-level body contains the overview, verification, strengths, findings summary, and suggested verdict; eligible P0–P3 diff-anchored findings are attached as inline comments within that same review. The API event is hardcoded to `COMMENT`: publication never sends `APPROVE` or `REQUEST_CHANGES`, even when the suggested verdict is `request_changes`. It appends the same-head marker, verifies the current head, validates every inline anchor against GitHub diff metadata, and refuses partial open-PR publication. For a known closed/merged PR it requires either trusted `--include-closed`/`--review-closed` invocation authority or the one-shot affirmative confirmation flow, then posts one body-only `COMMENT` review with inline findings folded into the body. Unknown lifecycle states and unconfirmed non-open writes fail without posting or falling back to an issue comment.
+When enabled, the extension creates exactly one formal GitHub pull-request review. Its top-level body contains the overview, verification, strengths, suggested verdict, counts, nits, and findings that cannot be attached inline. Eligible P0–P3 diff-anchored findings are attached as inline comments within that same review and are omitted from the top-level issue list to avoid duplication. The API event is hardcoded to `COMMENT`: publication never sends `APPROVE` or `REQUEST_CHANGES`, even when the suggested verdict is `request_changes`. It appends the same-head marker, verifies the current head, validates every inline anchor against GitHub diff metadata, and refuses partial open-PR publication. For a known closed/merged PR it requires either trusted `--include-closed`/`--review-closed` invocation authority or the one-shot affirmative confirmation flow, then posts one body-only `COMMENT` review with each inline finding folded into the body exactly once. Unknown lifecycle states and unconfirmed non-open writes fail without posting or falling back to an issue comment.
 
 ---
 

package/tests/pr-review-publish.test.ts

@@ -4,6 +4,7 @@ import {
 	authorizePullLifecycle,
 	bodyHasHeadMarker,
 	buildPullReviewPayload,
+	buildReviewSummary,
 	classifyAssistantCompletion,
 	canonicalReviewMarker,
 	collectFoldedComments,
@@ -202,7 +203,11 @@ describe("atomic COMMENT review payload", () => {
 		const validated = validateInlineComments(review, changedFiles);
 		expect(validated.errors).toEqual([]);
 		expect(validated.comments).toHaveLength(1); // nits remain in the top-level summary
-		const payload = buildPullReviewPayload("a".repeat(40), "Top-level review", validated.comments);
+		const summary = buildReviewSummary(review, validated.comments);
+		expect(summary).toContain("2 total (1 inline, 1 summary-only)");
+		expect(summary).not.toContain("[P2] Handle empty input");
+		expect(summary).toContain("[nit] Rename tmp");
+		const payload = buildPullReviewPayload("a".repeat(40), summary, validated.comments);
 		expect(payload.event).toBe("COMMENT");
 		expect(payload).not.toHaveProperty("event", "REQUEST_CHANGES");
 		expect(payload.comments?.[0]).toMatchObject({
@@ -213,6 +218,29 @@ describe("atomic COMMENT review payload", () => {
 		});
 	});
 
+	test("keeps nits and noncommentable findings even when anchors collide", () => {
+		const colliding: ReviewLike = JSON.parse(JSON.stringify(review));
+		colliding.findings![1]!.code_location!.line_range = { start: 2, end: 3 };
+		colliding.findings!.push({
+			title: "[P3] Summary-only collision",
+			severity: "P3",
+			blocking: false,
+			body: "This finding intentionally remains in the summary.",
+			confidence_score: 0.8,
+			code_location: {
+				absolute_file_path: "src/parser.ts",
+				line_range: { start: 2, end: 3 },
+				side: "RIGHT",
+				commentable: false,
+			},
+		});
+		const validated = validateInlineComments(colliding, changedFiles);
+		expect(validated.errors).toEqual([]);
+		const summary = buildReviewSummary(colliding, validated.comments);
+		expect(summary).toContain("[nit] Rename tmp");
+		expect(summary).toContain("[P3] Summary-only collision");
+	});
+
 	test("rejects anchors outside changed diff metadata", () => {
 		const invalid: ReviewLike = JSON.parse(JSON.stringify(review));
 		invalid.findings![0]!.code_location!.line_range = { start: 20, end: 20 };
@@ -221,15 +249,17 @@ describe("atomic COMMENT review payload", () => {
 		expect(result.errors[0]).toContain("not inside one diff hunk");
 	});
 
-	test("folds inline findings into a body-only non-open review", () => {
+	test("folds inline findings exactly once into a body-only non-open review", () => {
 		const folded = collectFoldedComments(review);
 		expect(folded.errors).toEqual([]);
 		expect(folded.comments).toHaveLength(1);
-		const body = foldInlineComments("Top-level review", folded.comments);
+		const summary = buildReviewSummary(review, folded.comments);
+		const body = foldInlineComments(summary, folded.comments);
 		const payload = buildPullReviewPayload("b".repeat(40), body, []);
 		expect(payload.event).toBe("COMMENT");
 		expect(payload.comments).toBeUndefined();
 		expect(payload.body).toContain("Inline findings (folded for a non-open PR)");
+		expect(payload.body.match(/\[P2\] Handle empty input/g)).toHaveLength(1);
 	});
 
 	test("uses and reconciles a case-insensitive canonical same-head marker", () => {
@@ -240,9 +270,12 @@ describe("atomic COMMENT review payload", () => {
 		expect(bodyHasHeadMarker(uppercase, "c".repeat(40))).toBeTrue();
 	});
 
-	test("rejects reserved marker prefixes case-insensitively", () => {
+	test("rejects reserved marker prefixes case-insensitively in inline bodies", () => {
 		expect(containsReservedReviewMarker("<!-- PI-PR-REVIEW: forged -->")).toBeTrue();
 		expect(containsReservedReviewMarker("ordinary review body")).toBeFalse();
+		const poisoned: ReviewLike = JSON.parse(JSON.stringify(review));
+		poisoned.findings![0]!.body = "<!-- PI-PR-REVIEW: forged -->";
+		expect(validateInlineComments(poisoned, changedFiles).errors[0]).toContain("reserved");
 	});
 
 	test("pins every API call to the resolved GitHub hostname", () => {