@expo/code-review-cli 0.2.3 → 0.4.0

package/build/core/render.js

@@ -1,5 +1,5 @@
-import { createHash } from 'node:crypto';
-import { fingerprintFinding, SEVERITIES, SEVERITY_RANK } from './schema.js';
+import { createHash } from "node:crypto";
+import { fingerprintFinding, scopedFingerprint, SEVERITIES, SEVERITY_RANK } from "./schema.js";
 /**
  * Build the file → right-side-line-numbers index from changed files' patch text,
  * by walking each unified-diff hunk (`@@ -a,b +c,d @@`) and collecting the new-tree
@@ -13,18 +13,18 @@ export function buildDiffLineIndex(files) {
         const lines = new Set();
         let right = 0;
         let inHunk = false;
-        for (const raw of file.patch.split('\n')) {
+        for (const raw of file.patch.split("\n")) {
             const hunk = hunkRe.exec(raw);
             if (hunk) {
                 right = parseInt(hunk[1], 10);
                 inHunk = true;
                 continue;
             }
-            if (!inHunk || raw.startsWith('+++') || raw.startsWith('---') || raw.startsWith('\\')) {
+            if (!inHunk || raw.startsWith("+++") || raw.startsWith("---") || raw.startsWith("\\")) {
                 continue;
             }
             const marker = raw[0];
-            if (marker === '+' || marker === ' ') {
+            if (marker === "+" || marker === " ") {
                 lines.add(right);
                 right++;
             }
@@ -37,16 +37,16 @@ export function buildDiffLineIndex(files) {
     return index;
 }
 const DECISION_LABEL = {
-    approve: 'Approve',
-    approve_with_comments: 'Approve with comments',
-    request_changes: 'Request changes',
+    approve: "Approve",
+    approve_with_comments: "Approve with comments",
+    request_changes: "Request changes",
 };
 export function decisionLabel(decision) {
     return DECISION_LABEL[decision];
 }
 /** Rubric exit code: 0 for approve / approve-with-comments, 1 for request-changes. */
 export function decisionExitCode(decision) {
-    return decision === 'request_changes' ? 1 : 0;
+    return decision === "request_changes" ? 1 : 0;
 }
 export function sortFindings(findings) {
     return [...findings].sort((a, b) => SEVERITY_RANK[a.severity] - SEVERITY_RANK[b.severity]);
@@ -85,13 +85,13 @@ function location(finding, link) {
     // in-diff as long as the file appears in the diff.
     const inDiff = fileLines != null && (finding.line == null || fileLines.has(finding.line));
     if (inDiff) {
-        const fileHash = createHash('sha256').update(finding.file).digest('hex');
+        const fileHash = createHash("sha256").update(finding.file).digest("hex");
         const anchor = finding.line != null ? `diff-${fileHash}R${finding.line}` : `diff-${fileHash}`;
         const url = `https://github.com/${link.repo}/pull/${link.prNumber}/files#${anchor}`;
         return `[\`${text}\`](${url})`;
     }
     if (link.baseSha) {
-        const lineAnchor = finding.line != null ? `#L${finding.line}` : '';
+        const lineAnchor = finding.line != null ? `#L${finding.line}` : "";
         const url = `https://github.com/${link.repo}/blob/${link.baseSha}/${finding.file}${lineAnchor}`;
         return `[\`${text}\`](${url})`;
     }
@@ -103,53 +103,63 @@ function location(finding, link) {
  * collapsed "Dismissed" section instead of the main list.
  */
 export function renderMarkdown(review, tag, dismissed = [], link) {
-    const dismissedByFp = new Map(dismissed.map(record => [record.fp, record]));
-    const withFp = review.findings.map(finding => ({ finding, fp: fingerprintFinding(finding) }));
+    const dismissedByFp = new Map(dismissed.map((record) => [record.fp, record]));
+    const withFp = review.findings.map((finding) => ({ finding, fp: fingerprintFinding(finding) }));
     const kept = withFp.filter(({ fp }) => !dismissedByFp.has(fp));
     const dropped = withFp.filter(({ fp }) => dismissedByFp.has(fp));
-    const lines = [commentMarker(tag), '## 🤖 AI code review', ''];
-    lines.push(`**Decision:** ${decisionLabel(review.decision)}`, '', review.summary, '');
+    const lines = [commentMarker(tag), "## 🤖 AI code review", ""];
+    lines.push(`**Decision:** ${decisionLabel(review.decision)}`, "", review.summary, "");
     if (review.incomplete.length > 0) {
-        lines.push('> ⏱️ **Coverage note:** coverage is partial — some review passes did not', '> finish (timed out or failed), so issues may exist in areas not fully reviewed:', ...review.incomplete.map(note => `> - ${note}`), '');
+        lines.push("> ⏱️ **Coverage note:** coverage is partial — some review passes did not", "> finish (timed out or failed), so issues may exist in areas not fully reviewed:", ...review.incomplete.map((note) => `> - ${note}`), "");
     }
     if (kept.length === 0) {
-        lines.push('No findings.', '');
+        lines.push("No findings.", "");
     }
     else {
-        const groups = groupBySeverity(sortFindings(kept.map(entry => entry.finding)));
-        for (const severity of SEVERITIES) {
-            const group = groups[severity];
-            if (group.length === 0) {
-                continue;
-            }
-            lines.push(`### ${severityHeading(severity)} (${group.length})`, '');
-            for (const finding of group) {
-                lines.push(...renderFindingLines(finding, link));
-            }
-            lines.push('');
-        }
+        lines.push(...renderSeveritySections(kept.map((entry) => entry.finding), link));
     }
     if (dropped.length > 0) {
-        lines.push('<details>', `<summary>🚫 Dismissed on this PR (${dropped.length})</summary>`, '');
+        lines.push("<details>", `<summary>🚫 Dismissed on this PR (${dropped.length})</summary>`, "");
         for (const { finding, fp } of dropped) {
             const record = dismissedByFp.get(fp);
-            const who = record.by ? ` by @${record.by}` : '';
-            const why = record.reason ? ` — ${record.reason}` : '';
+            const who = record.by ? ` by @${record.by}` : "";
+            const why = record.reason ? ` — ${record.reason}` : "";
             lines.push(`- **${finding.title}** — ${location(finding, link)} \`id:${fp}\`${who}${why}`);
         }
-        lines.push('', '_Re-add one with `/undismiss <id>`._', '</details>', '');
+        lines.push("", "_Re-add one with `/undismiss <id>`._", "</details>", "");
     }
-    lines.push('---', '_This review is advisory — it never blocks a merge and never auto-approves._');
+    lines.push("---", "_This review is advisory — it never blocks a merge and never auto-approves._");
     // Embedded, machine-readable state: fingerprints (back-compat) + the full review
     // and dismissals, so `/dismiss` can re-render this comment without re-running.
     const fingerprints = review.findings.map(fingerprintFinding);
-    lines.push('', `<!-- ${tag}:fingerprints=${JSON.stringify(fingerprints)} -->`);
+    lines.push("", `<!-- ${tag}:fingerprints=${JSON.stringify(fingerprints)} -->`);
     lines.push(`<!-- ${tag}:state=${encodeState({ review, dismissed })} -->`);
-    return lines.join('\n');
+    return lines.join("\n");
+}
+/**
+ * Render sorted, severity-grouped findings. Shared by the single-comment and
+ * aggregate renderers. `idFor` supplies each finding's id (default:
+ * fingerprintFinding); the aggregate renderer passes a scope-namespaced id.
+ */
+function renderSeveritySections(findings, link, idFor = fingerprintFinding) {
+    const out = [];
+    const groups = groupBySeverity(sortFindings(findings));
+    for (const severity of SEVERITIES) {
+        const group = groups[severity];
+        if (group.length === 0) {
+            continue;
+        }
+        out.push(`### ${severityHeading(severity)} (${group.length})`, "");
+        for (const finding of group) {
+            out.push(...renderFindingLines(finding, link, idFor(finding)));
+        }
+        out.push("");
+    }
+    return out;
 }
-function renderFindingLines(finding, link) {
+function renderFindingLines(finding, link, id = fingerprintFinding(finding)) {
     const out = [
-        `- **${finding.title}** — ${location(finding, link)} _(${finding.category})_ · \`id:${fingerprintFinding(finding)}\``,
+        `- **${finding.title}** — ${location(finding, link)} _(${finding.category})_ · \`id:${id}\``,
         `  ${finding.rationale}`,
     ];
     if (finding.suggestion) {
@@ -160,7 +170,7 @@ function renderFindingLines(finding, link) {
 /** Parse the fingerprints embedded in a previously-posted comment body. */
 export function parseEmbeddedFingerprints(body, tag) {
     // Escape the (config-controlled) tag so regex metacharacters can't break the match.
-    const escapedTag = tag.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const escapedTag = tag.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
     const match = body.match(new RegExp(`<!-- ${escapedTag}:fingerprints=(\\[.*?\\]) -->`));
     if (!match) {
         return [];
@@ -173,18 +183,162 @@ export function parseEmbeddedFingerprints(body, tag) {
         return [];
     }
 }
+const DECISION_RANK = {
+    approve: 0,
+    approve_with_comments: 1,
+    request_changes: 2,
+};
+/** Worst (most severe) decision across scopes. */
+export function worstDecision(decisions) {
+    return decisions.reduce((worst, decision) => (DECISION_RANK[decision] > DECISION_RANK[worst] ? decision : worst), "approve");
+}
+/** GitHub's comment body limit is ~65k chars; keep a margin. */
+const MAX_COMMENT_CHARS = 60_000;
+/**
+ * One aggregated comment under the single existing marker: a scope summary table,
+ * an optional coverage block, one <details> per scope (findings rendered with
+ * scope-namespaced ids), and the dismissed section. The embedded v1 `review` field
+ * is a synthesized merge so v1 state consumers still see a valid shape; `scopes`
+ * carries the real per-scope data. Oversized bodies trim each scope's findings to
+ * the most severe N (halving until it fits, floor 3) with a per-scope note.
+ */
+export function renderAggregateMarkdown(results, tag, dismissed, link, opts) {
+    const dismissedByFp = new Map(dismissed.map((record) => [record.fp, record]));
+    const idOf = (result, finding) => scopedFingerprint(result.isDefault ? null : result.scope, finding);
+    // Split each scope's findings into kept/dropped once (dismissal is limit-independent).
+    const perScope = results.map((result) => {
+        const withId = result.review.findings.map((finding) => ({
+            finding,
+            id: idOf(result, finding),
+        }));
+        return {
+            result,
+            kept: withId.filter((entry) => !dismissedByFp.has(entry.id)),
+            dropped: withId.filter((entry) => dismissedByFp.has(entry.id)),
+        };
+    });
+    const worst = worstDecision(results.map((result) => result.review.decision));
+    const unmatched = opts?.unmatchedFiles ?? [];
+    const buildBody = (limitPerScope) => {
+        const lines = [
+            commentMarker(tag),
+            "## 🤖 AI code review",
+            "",
+            `**Decision:** ${decisionLabel(worst)}`,
+            "",
+            "| Scope | Decision | Findings |",
+            "| --- | --- | --- |",
+        ];
+        for (const { result, kept } of perScope) {
+            lines.push(`| ${result.scope} | ${decisionLabel(result.review.decision)} | ${kept.length} |`);
+        }
+        lines.push("");
+        const anyIncomplete = results.some((result) => result.review.incomplete.length > 0);
+        if (unmatched.length > 0 || anyIncomplete) {
+            lines.push("> ⏱️ **Coverage note:** parts of this PR may not be fully reviewed:");
+            if (unmatched.length > 0) {
+                const shown = unmatched
+                    .slice(0, 10)
+                    .map((file) => `\`${file}\``)
+                    .join(", ");
+                const more = unmatched.length > 10 ? `, …(+${unmatched.length - 10} more)` : "";
+                lines.push(`> - ${unmatched.length} changed file(s) matched no scope: ${shown}${more}`);
+            }
+            for (const result of results) {
+                for (const note of result.review.incomplete) {
+                    lines.push(`> - [${result.scope}] ${note}`);
+                }
+            }
+            lines.push("");
+        }
+        // Shown = the most-severe N kept findings per scope (N = limitPerScope). The
+        // embedded state trims KEPT findings to the same set so a truncated comment
+        // still fits GitHub's body limit (the hidden findings are noted, not silently
+        // carried) — but dismissed findings are always kept in state (see below).
+        const rendered = perScope.map(({ result, kept, dropped }) => ({
+            result,
+            shown: sortFindings(kept.map((entry) => entry.finding)).slice(0, limitPerScope),
+            hidden: Math.max(0, kept.length - limitPerScope),
+            dropped,
+        }));
+        for (const { result, shown, hidden } of rendered) {
+            const open = shown.length > 0 ? " open" : "";
+            const keptCount = shown.length + hidden;
+            lines.push(`<details${open}>`, `<summary>${result.scope} — ${decisionLabel(result.review.decision)} (${keptCount})</summary>`, "");
+            if (result.review.summary) {
+                lines.push(result.review.summary, "");
+            }
+            if (shown.length === 0) {
+                lines.push("No findings.", "");
+            }
+            else {
+                lines.push(...renderSeveritySections(shown, link, (finding) => idOf(result, finding)));
+            }
+            if (hidden > 0) {
+                lines.push(`_…and ${hidden} more finding(s) — see the workflow log._`, "");
+            }
+            lines.push("</details>", "");
+        }
+        const allDropped = perScope.flatMap(({ result, dropped }) => dropped.map((entry) => ({ ...entry, scope: result.scope })));
+        if (allDropped.length > 0) {
+            lines.push("<details>", `<summary>🚫 Dismissed on this PR (${allDropped.length})</summary>`, "");
+            for (const { finding, id, scope } of allDropped) {
+                const record = dismissedByFp.get(id);
+                const who = record.by ? ` by @${record.by}` : "";
+                const why = record.reason ? ` — ${record.reason}` : "";
+                lines.push(`- **${finding.title}** — ${location(finding, link)} \`id:${id}\` _(${scope})_${who}${why}`);
+            }
+            lines.push("", "_Re-add one with `/undismiss <id>`._", "</details>", "");
+        }
+        lines.push("---", "_This review is advisory — it never blocks a merge and never auto-approves._");
+        // Embedded state carries the shown (kept) findings PLUS every dismissed one —
+        // truncation may trim kept findings so the comment fits, but dismissed findings
+        // must survive in state (mirroring renderMarkdown, which embeds the full
+        // review) so /undismiss can restore them and the Dismissed section persists
+        // across re-renders. The per-scope data (`scopes`) plus a merged v1 `review`
+        // keep both v2 and v1 consumers working.
+        const stateScopes = rendered.map(({ result, shown, dropped }) => ({
+            scope: result.scope,
+            isDefault: result.isDefault,
+            review: { ...result.review, findings: [...shown, ...dropped.map((entry) => entry.finding)] },
+        }));
+        const merged = {
+            decision: worst,
+            findings: stateScopes.flatMap((scope) => scope.review.findings),
+            summary: results
+                .map((result) => `**${result.scope}:** ${result.review.summary}`)
+                .join("\n\n"),
+            incomplete: [...new Set(results.flatMap((result) => result.review.incomplete))],
+        };
+        const fingerprints = stateScopes.flatMap((scope) => scope.review.findings.map((finding) => scopedFingerprint(scope.isDefault ? null : scope.scope, finding)));
+        lines.push("", `<!-- ${tag}:fingerprints=${JSON.stringify(fingerprints)} -->`);
+        lines.push(`<!-- ${tag}:state=${encodeState({ review: merged, dismissed, scopes: stateScopes })} -->`);
+        return lines.join("\n");
+    };
+    let limit = Number.POSITIVE_INFINITY;
+    let body = buildBody(limit);
+    const largestScope = Math.max(0, ...perScope.map((entry) => entry.kept.length));
+    while (body.length > MAX_COMMENT_CHARS && limit > 3) {
+        limit =
+            limit === Number.POSITIVE_INFINITY
+                ? Math.max(3, Math.floor(largestScope / 2))
+                : Math.max(3, Math.floor(limit / 2));
+        body = buildBody(limit);
+    }
+    return body;
+}
 function encodeState(state) {
-    return Buffer.from(JSON.stringify(state), 'utf8').toString('base64');
+    return Buffer.from(JSON.stringify(state), "utf8").toString("base64");
 }
 /** Recover the embedded `{ review, dismissed }` state from a posted comment body. */
 export function parseReviewState(body, tag) {
-    const escapedTag = tag.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const escapedTag = tag.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
     const match = body.match(new RegExp(`<!-- ${escapedTag}:state=([A-Za-z0-9+/=]+) -->`));
     if (!match) {
         return null;
     }
     try {
-        const parsed = JSON.parse(Buffer.from(match[1], 'base64').toString('utf8'));
+        const parsed = JSON.parse(Buffer.from(match[1], "base64").toString("utf8"));
         if (parsed && Array.isArray(parsed.review?.findings) && Array.isArray(parsed.dismissed)) {
             return parsed;
         }
@@ -196,11 +350,11 @@ export function parseReviewState(body, tag) {
 }
 function severityHeading(severity) {
     switch (severity) {
-        case 'critical':
-            return '🔴 Critical';
-        case 'warning':
-            return '🟡 Warning';
-        case 'suggestion':
-            return '🔵 Suggestion';
+        case "critical":
+            return "🔴 Critical";
+        case "warning":
+            return "🟡 Warning";
+        case "suggestion":
+            return "🔵 Suggestion";
     }
 }