limn-review 0.1.123

package/dist/review/post-review.js

@@ -0,0 +1,216 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { ghRestGet, ghRestPost } from '../github/client.js';
+import { buildAnchorIndex, fallbackAnchor, isFindingAnchored, splitDiffByFile, } from '../github/diff-anchor.js';
+const execFileAsync = promisify(execFile);
+// The pure unified-diff anchoring helpers now live in github/diff-anchor.ts (so
+// they're reusable by the on-demand PR write-action paths). Re-export them here
+// so existing importers (agent.ts, routing.ts, claude-review.ts, the review
+// tests) keep their `./post-review.js` import path unchanged.
+export { buildAnchorIndex, buildFileAnchors, extractHunk, fallbackAnchor, HUNK_RE, isFindingAnchored, splitDiffByFile, } from '../github/diff-anchor.js';
+// Drop files matched by `isNoise` (lockfiles/generated) from the diff, returning
+// the stripped diff + the excluded paths (recorded on the run).
+export function stripNoiseFromDiff(diff, isNoise) {
+    const kept = [];
+    const excluded = [];
+    for (const seg of splitDiffByFile(diff)) {
+        if (isNoise(seg.path))
+            excluded.push(seg.path);
+        else
+            kept.push(seg.text);
+    }
+    return { diff: kept.join('\n'), excluded };
+}
+// Truncate a (noise-stripped) unified diff to roughly `maxChars`, cutting only at
+// whole-FILE boundaries (never mid-hunk), for the PROMPT only — routing + anchoring
+// keep the full diff. Whole file segments are kept in order until the next one would
+// blow the budget; the rest are reported as omitted. The first file is always kept
+// (even if it alone exceeds the budget), so a single huge file still gets reviewed.
+export function capDiff(diff, maxChars) {
+    const totalBytes = diff.length;
+    if (totalBytes <= maxChars) {
+        return { diff, capped: false, omittedFiles: [], totalBytes };
+    }
+    const segs = splitDiffByFile(diff);
+    const kept = [];
+    const omittedFiles = [];
+    let used = 0;
+    for (const seg of segs) {
+        const cost = seg.text.length + 1; // +1 for the '\n' join
+        if (kept.length === 0 || used + cost <= maxChars) {
+            kept.push(seg.text);
+            used += cost;
+        }
+        else {
+            omittedFiles.push(seg.path);
+        }
+    }
+    return {
+        diff: kept.join('\n'),
+        capped: omittedFiles.length > 0,
+        omittedFiles,
+        totalBytes,
+    };
+}
+// Appended to a comment placed on a fallback line, so PR readers know the inline
+// position is approximate (the finding's real line isn't part of this diff).
+export const FALLBACK_ANCHOR_NOTE = '_The line this refers to isn’t part of the PR’s diff, so it’s anchored to the file’s first change._';
+// Build the GitHub review payload from the user's authored body/verdict plus the
+// findings they ticked. Each ticked finding is routed:
+//   • anchorable on its own line              → inline comment on that line
+//   • unanchored but its file IS in the diff  → inline comment on the file's first
+//                                                change (with a note)
+//   • its file is NOT in the diff             → a standalone PR-level comment (so a
+//                                                deep review's finding on an unchanged
+//                                                file still posts, marked accordingly)
+export function buildReview(input) {
+    const index = buildAnchorIndex(input.diff);
+    const comments = [];
+    const prComments = [];
+    const inlineFindingIds = [];
+    for (const f of input.includedFindings) {
+        if (f.line != null && isFindingAnchored(index, f.path, f.line, f.side)) {
+            comments.push({
+                path: f.path,
+                line: f.line,
+                side: f.side,
+                body: findingCommentBody(f),
+            });
+            inlineFindingIds.push(f.id);
+            continue;
+        }
+        // The finding's own line isn't an addable diff position — anchor it to the
+        // file's first change (added preferred) so it can still post inline. When the
+        // file itself isn't in the diff there's no diff line to attach to, so it posts
+        // as a standalone PR-level comment marked as outside the PR's diff.
+        const fb = fallbackAnchor(index, f.path);
+        if (fb) {
+            comments.push({
+                path: f.path,
+                line: fb.line,
+                side: fb.side,
+                body: findingCommentBody(f, { fallbackNote: true }),
+            });
+            inlineFindingIds.push(f.id);
+        }
+        else {
+            prComments.push({ findingId: f.id, path: f.path, body: prLevelFindingBody(f) });
+        }
+    }
+    return {
+        preview: {
+            commitId: input.commitId,
+            body: input.body,
+            event: input.event,
+            comments,
+            prComments,
+        },
+        inlineFindingIds,
+    };
+}
+// The hidden provenance stamp on EVERY finding comment Limn posts (inline or PR-level). It is how
+// a later review tells its own comments from other reviewers' (db/review-threads-for-review.ts
+// `isLimnPostedComment`, together with the author being the account's own login — Limn posts as
+// the reader, so neither fact alone is enough). It survives an edit on GitHub, which the old
+// text-prefix match did not. The `pierre:claude-review` prefix is deliberate: it is also the
+// 'pierre' fingerprint (sync/review-fingerprint.ts). ⚠ The spelling is permanent once posted.
+export const FINDING_COMMENT_MARKER = '<!-- pierre:claude-review-finding v=1 -->';
+// A finding's inline comment body: the user's reworded text if they wrote one,
+// else Claude's wording — with an optional fenced ```suggestion block appended
+// (GitHub renders it as an applyable suggestion). Takes a minimal shape so it
+// works for both the wire ClaudeFinding and a raw DB row.
+//
+// `fallbackNote` is set when the comment is posted on a fallback line (the
+// finding's real line isn't in the diff). Then we (a) append FALLBACK_ANCHOR_NOTE
+// and (b) render any suggestion as a PLAIN code block rather than ```suggestion —
+// an applyable suggestion on the wrong line would offer to corrupt that line.
+//
+// `storyLead` is a USER-STORY finding's first line ("BMD-1040 · AC2 (partly met): <criterion>",
+// shared `storyCommentLead`). It is not stored in the body — on screen the card sits under its
+// story — so it is added HERE, the one place every story comment is built (single post and Submit
+// review alike), and GitHub still names the story.
+export function findingCommentBody(f, opts) {
+    const body = f.editedBody && f.editedBody.trim() ? f.editedBody : f.body;
+    const parts = [f.storyLead, body].filter((p) => p != null && p.trim() !== '');
+    if (f.suggestion && f.suggestion.trim()) {
+        parts.push(opts?.fallbackNote
+            ? `\`\`\`\n${f.suggestion}\n\`\`\``
+            : `\`\`\`suggestion\n${f.suggestion}\n\`\`\``);
+    }
+    if (opts?.fallbackNote)
+        parts.push(FALLBACK_ANCHOR_NOTE);
+    parts.push(FINDING_COMMENT_MARKER);
+    return parts.join('\n\n');
+}
+// Note appended to a PR-level comment, so readers know the referenced code is NOT
+// part of this PR's changes (it can't be an inline comment — there's no diff line).
+export const OUTSIDE_DIFF_NOTE = '_This refers to a file that isn’t part of this PR’s diff, so it’s posted as a PR-level comment rather than inline._';
+// Body for a finding posted as a standalone PR-level (issue) comment. Since it
+// isn't attached to a diff line, prefix the file (and line, if known) for context,
+// then the finding text (the user's reword if any, else Claude's), and append a note
+// that it's outside the PR's diff. Any suggestion renders as a PLAIN code block — an
+// applyable ```suggestion only makes sense on a real diff line.
+// A finding with NO file (`path` blank — a user-story finding about the whole change, see
+// claude-review/ticket.ts `storyFindingsFrom`) is about the PR, not about a file outside it: it
+// carries neither the file line nor the outside-the-diff note.
+export function prLevelFindingBody(f) {
+    const body = f.editedBody && f.editedBody.trim() ? f.editedBody : f.body;
+    const hasPath = f.path.trim() !== '';
+    const ref = f.line != null ? `${f.path}:${f.line}` : f.path;
+    // A story finding's lead comes FIRST, so the comment opens on the story it is about.
+    const parts = [f.storyLead, hasPath ? `**\`${ref}\`**` : null, body].filter((p) => p != null && p.trim() !== '');
+    if (f.suggestion && f.suggestion.trim()) {
+        parts.push(`\`\`\`\n${f.suggestion}\n\`\`\``);
+    }
+    if (hasPath)
+        parts.push(OUTSIDE_DIFF_NOTE);
+    parts.push(FINDING_COMMENT_MARKER);
+    return parts.join('\n\n');
+}
+// The PR's current head SHA (to detect head-moved before posting).
+export async function fetchCurrentHeadSha(owner, name, prNumber) {
+    const pull = await ghRestGet(`/repos/${owner}/${name}/pulls/${prNumber}`);
+    return pull.head.sha;
+}
+// The PR's unified diff, via the gh CLI (matches GitHub's 3-dot view and reuses
+// the gh auth/SSO already required by the app). Bounded so a huge PR can't hang.
+export async function fetchPrDiff(owner, name, prNumber) {
+    const { stdout } = await execFileAsync('gh', ['pr', 'diff', String(prNumber), '--repo', `${owner}/${name}`], { maxBuffer: 64 * 1024 * 1024, timeout: 60_000 });
+    return stdout;
+}
+// POST a single PR review with inline comments + body + verdict. Inline comments
+// REQUIRE this REST endpoint. `commit_id` pins the review to the head SHA.
+export async function submitGithubReview(input) {
+    const res = await ghRestPost(`/repos/${input.owner}/${input.name}/pulls/${input.prNumber}/reviews`, {
+        commit_id: input.commitId,
+        body: input.body,
+        event: input.event,
+        comments: input.comments.map((c) => ({
+            path: c.path,
+            line: c.line,
+            side: c.side,
+            body: c.body,
+        })),
+    });
+    return { reviewId: String(res.id) };
+}
+// Post a SINGLE standalone inline review comment (not part of a review draft).
+// `commit_id` pins it to the head SHA; the line must be addable on that side.
+export async function submitGithubComment(input) {
+    const res = await ghRestPost(`/repos/${input.owner}/${input.name}/pulls/${input.prNumber}/comments`, {
+        body: input.body,
+        commit_id: input.commitId,
+        path: input.path,
+        line: input.line,
+        side: input.side,
+    });
+    return { commentId: String(res.id) };
+}
+// Post a SINGLE standalone PR-level (issue) comment. Used for an unanchored finding
+// the user chooses to post individually rather than forcing it onto a diff line.
+// Issue comments aren't pinned to a commit or a line, so there's no commit_id/side.
+export async function submitGithubIssueComment(input) {
+    const res = await ghRestPost(`/repos/${input.owner}/${input.name}/issues/${input.prNumber}/comments`, { body: input.body });
+    return { commentId: String(res.id) };
+}
+//# sourceMappingURL=post-review.js.map

package/dist/review/post-seam.js

@@ -0,0 +1,161 @@
+import { isNoiseFile } from './prepare.js';
+import { buildAnchorIndex, fallbackAnchor, fetchCurrentHeadSha, fetchPrDiff, findingCommentBody, isFindingAnchored, prLevelFindingBody, stripNoiseFromDiff, submitGithubComment, submitGithubIssueComment, submitGithubReview, } from './post-review.js';
+// The GitHub-write half of the ctx.review seam. Security-sensitive (per-account gh token +
+// line-anchoring), so it stays CORE — the plugin hands over the user's ticked findings (read
+// from the core tables) + body/verdict, and core re-checks the head, re-anchors against the
+// live diff, and submits. GitHub errors THROW (the plugin's route maps them to 502); a moved
+// head returns { headMoved: true } (→ 409). Findings' `body` is pre-resolved (editedBody ??
+// body) by the plugin, so findingCommentBody sees editedBody=null and uses `body` as-is.
+// ctx.review.postReview — submit ONE GitHub review (inline comments + body + verdict), pinned
+// to reviewHeadSha. dryRun returns the preview instead of posting.
+export async function postReview(args) {
+    const currentHead = await fetchCurrentHeadSha(args.owner, args.name, args.prNumber);
+    if (currentHead !== args.reviewHeadSha)
+        return { headMoved: true };
+    const { diff } = stripNoiseFromDiff(await fetchPrDiff(args.owner, args.name, args.prNumber), isNoiseFile);
+    const index = buildAnchorIndex(diff);
+    const comments = [];
+    const prComments = [];
+    const inlineFindingIds = [];
+    for (const f of args.includedFindings) {
+        const shape = { body: f.body, editedBody: null, suggestion: f.suggestion, storyLead: f.storyLead };
+        // Anchorable on its own line → inline comment there.
+        if (f.line != null && isFindingAnchored(index, f.path, f.line, f.side)) {
+            comments.push({ path: f.path, line: f.line, side: f.side, body: findingCommentBody(shape) });
+            inlineFindingIds.push(f.id);
+            continue;
+        }
+        // Its own line isn't addable → anchor to the file's first change if the file is in the
+        // diff (inline, with a note); else post as a standalone PR-level comment.
+        const fb = fallbackAnchor(index, f.path);
+        if (fb) {
+            comments.push({
+                path: f.path,
+                line: fb.line,
+                side: fb.side,
+                body: findingCommentBody(shape, { fallbackNote: true }),
+            });
+            inlineFindingIds.push(f.id);
+        }
+        else {
+            prComments.push({
+                findingId: f.id,
+                path: f.path,
+                body: prLevelFindingBody({
+                    path: f.path,
+                    line: f.line,
+                    body: f.body,
+                    editedBody: null,
+                    suggestion: f.suggestion,
+                    storyLead: f.storyLead,
+                }),
+            });
+        }
+    }
+    // Bot-Triage WS2c — the Limn provenance stamp. UNCONDITIONAL, and that is the point: this hidden,
+    // invisible, idempotent HTML marker is the ONLY producer of the 'pierre' AutomatedReviewerKind
+    // (`sync/review-fingerprint.ts` matches exactly this string). Everything downstream of that
+    // sentinel — the Bot-ROI "Limn · Claude" row, the ai_verbatim-vs-human_curated provenance,
+    // BotPrsDetail's 'pierre' tab, the bot_only_review risk flag — goes dark without it, so the
+    // account setting that used to gate it was a switch for silently deleting an analytics lane.
+    // DO NOT re-gate this. `PostReviewArgs.pierreMarker?`/`pierreFooter?` remain DECLARED on the
+    // contract (both sides, back-compat) but nothing passes them any more; the visible
+    // "🤖 Reviewed with Limn + Claude" footer appeared in no detector and is gone.
+    const finalBody = args.body + '\n\n<!-- pierre:claude-review v=1 -->';
+    const preview = {
+        commitId: args.reviewHeadSha,
+        body: finalBody,
+        event: args.verdict,
+        comments,
+        prComments,
+    };
+    if (args.dryRun)
+        return { preview };
+    const { reviewId: ghReviewId } = await submitGithubReview({
+        owner: args.owner,
+        name: args.name,
+        prNumber: args.prNumber,
+        commitId: args.reviewHeadSha,
+        body: finalBody,
+        event: args.verdict,
+        comments,
+    });
+    // Off-diff findings post as standalone PR-level comments alongside the review. Each is
+    // best-effort: a single failed comment must NOT strand the already-posted (irreversible)
+    // review — collect what lands; the caller stamps only those.
+    const prCommentResults = [];
+    for (const pc of prComments) {
+        try {
+            const { commentId } = await submitGithubIssueComment({
+                owner: args.owner,
+                name: args.name,
+                prNumber: args.prNumber,
+                body: pc.body,
+            });
+            prCommentResults.push({ findingId: pc.findingId, commentId });
+        }
+        catch {
+            /* best-effort — leave the finding un-posted rather than strand the posted review */
+        }
+    }
+    return {
+        postedReviewId: ghReviewId,
+        inlineFindingIds,
+        prComments: prCommentResults,
+        commentCount: comments.length,
+        prCommentCount: prCommentResults.length,
+    };
+}
+// ctx.review.postFinding — post ONE finding as a standalone inline / PR-level comment. Uses
+// the stored `anchored` to short-circuit to an on-line inline comment; else consults the live
+// diff to re-anchor (inline) or fall back to a PR-level comment.
+export async function postFinding(args) {
+    const { owner, name, prNumber, reviewHeadSha, finding: f } = args;
+    const currentHead = await fetchCurrentHeadSha(owner, name, prNumber);
+    if (currentHead !== reviewHeadSha)
+        return { headMoved: true };
+    const shape = { body: f.body, editedBody: null, suggestion: f.suggestion, storyLead: f.storyLead };
+    if (f.line != null && f.anchored) {
+        const { commentId } = await submitGithubComment({
+            owner,
+            name,
+            prNumber,
+            commitId: reviewHeadSha,
+            path: f.path,
+            line: f.line,
+            side: f.side,
+            body: findingCommentBody(shape),
+        });
+        return { commentId, postedCommentKind: 'inline' };
+    }
+    const { diff } = stripNoiseFromDiff(await fetchPrDiff(owner, name, prNumber), isNoiseFile);
+    const fb = fallbackAnchor(buildAnchorIndex(diff), f.path);
+    if (fb) {
+        const { commentId } = await submitGithubComment({
+            owner,
+            name,
+            prNumber,
+            commitId: reviewHeadSha,
+            path: f.path,
+            line: fb.line,
+            side: fb.side,
+            body: findingCommentBody(shape, { fallbackNote: true }),
+        });
+        return { commentId, postedCommentKind: 'inline' };
+    }
+    const { commentId } = await submitGithubIssueComment({
+        owner,
+        name,
+        prNumber,
+        body: prLevelFindingBody({
+            path: f.path,
+            line: f.line,
+            body: f.body,
+            editedBody: null,
+            suggestion: f.suggestion,
+            storyLead: f.storyLead,
+        }),
+    });
+    return { commentId, postedCommentKind: 'pr_comment' };
+}
+//# sourceMappingURL=post-seam.js.map

package/dist/review/prepare.js

@@ -0,0 +1,168 @@
+import { config } from '../config.js';
+import { capDiff, fetchPrDiff, splitDiffByFile, stripNoiseFromDiff, } from './post-review.js';
+// Core diff-prep for the Claude Review seam (ctx.review.prepareReview). Everything that
+// touches the diff lives in CORE so the mode-routing metrics the plugin consumes and the
+// run-time/post-time line-anchoring all derive from the SAME noise-stripped diff (anchoring
+// drift would corrupt inline comments). The plugin gets DATA back (a PreparedReview) and
+// only runs the pure routing decision + prompt formatting. (The noise matcher moved here
+// from prompt.ts and analyzeDiff from routing.ts — both were CORE-only helpers.)
+// ---- Noise-file matcher (lockfiles / generated / vendored artifacts) ----
+// Globs for files whose diffs are noise to a human reviewer: stripped from the diff so the
+// agent spends its budget on real code, not a 4000-line lockfile churn. Only the three glob
+// shapes below are supported (exact basename, `*.ext` suffix, `**​/segment/**` path segment).
+//
+// ⚠ THIS LIST IS A PAID AGENT'S DIFF BUDGET — DO NOT WIDEN IT FOR ANOTHER FEATURE. It deliberately
+// keeps `.md`, `.yml`, `.json` and `docs/` IN the diff, because a review agent reading a config
+// change is doing its job. The large-PR flag needs a much broader "is this code?" answer, and it
+// has its OWN classifier for exactly that reason: `isNonCodeFile` in `db/code-loc.ts`, which
+// documents how the two (and the frontend's narrower `isLockFile`) relate. Editing this list to
+// satisfy that feature would silently change what Claude Review reviews, with no test to catch it.
+export const NOISE_GLOBS = [
+    'package-lock.json',
+    'pnpm-lock.yaml',
+    'yarn.lock',
+    'npm-shrinkwrap.json',
+    'Cargo.lock',
+    'poetry.lock',
+    'Gemfile.lock',
+    'composer.lock',
+    'go.sum',
+    '*.lock',
+    '*.min.js',
+    '*.min.css',
+    '*.map',
+    '*.snap',
+    '**/dist/**',
+    '**/build/**',
+    '**/node_modules/**',
+    '**/__snapshots__/**',
+];
+function normalizePath(path) {
+    let p = path.replace(/\\/g, '/');
+    if (p.startsWith('./'))
+        p = p.slice(2);
+    return p;
+}
+function basename(path) {
+    const p = normalizePath(path);
+    const idx = p.lastIndexOf('/');
+    return idx === -1 ? p : p.slice(idx + 1);
+}
+function matchesGlob(glob, fullPath, base) {
+    const segMatch = /^\*\*\/(.+)\/\*\*$/.exec(glob);
+    if (segMatch) {
+        const segment = segMatch[1];
+        if (!segment)
+            return false;
+        const needle = `/${segment}/`;
+        return fullPath === segment || fullPath.startsWith(`${segment}/`) || fullPath.includes(needle);
+    }
+    if (glob.startsWith('*.')) {
+        const suffix = glob.slice(1);
+        return base.length > suffix.length && base.endsWith(suffix);
+    }
+    return base === glob;
+}
+// True if `path` looks like a lockfile / generated / vendored artifact to hide from review.
+export function isNoiseFile(path) {
+    const full = normalizePath(path);
+    const base = basename(full);
+    for (const glob of NOISE_GLOBS) {
+        if (matchesGlob(glob, full, base))
+            return true;
+    }
+    return false;
+}
+// ---- Per-file diff analysis (feeds the plugin's decideReviewMode via PreparedReview) ----
+// Path shapes that ARE an interface/contract definition (editing one is very likely a
+// cross-cutting change whose consumers live outside the diff). Matched on the path.
+export const API_PATH_PATTERNS = [
+    /\.(proto|thrift|graphql|gql)$/i,
+    /\.d\.ts$/i,
+    /(^|\/)(openapi|swagger)[^/]*\.(ya?ml|json)$/i,
+    /(^|\/)migrations?\//i,
+];
+// Markers that, on a REMOVED or MODIFIED diff line, indicate a change to an exported/public
+// symbol (a signature/removal — the risky case). Over-matching only over-routes (safe).
+export const EXPORT_MARKERS = [
+    /\bexport\b/,
+    /\bmodule\.exports\b|\bexports\.\w/,
+    /\bpub(\s+|\()/,
+    /\b(public|protected)\s+\w/,
+    /\bfunc\b\s*(\([^)]*\)\s*)?[A-Z]\w*\s*\(/,
+    /\b(type|const|var)\s+[A-Z]\w*/,
+    /\b__all__\b/,
+];
+function lineTouchesApi(content) {
+    return EXPORT_MARKERS.some((re) => re.test(content));
+}
+function pathTouchesApi(path) {
+    return API_PATH_PATTERNS.some((re) => re.test(path));
+}
+// Walk one noise-stripped unified diff into per-file change metrics. Header lines
+// (diff/index/---/+++/@@/mode/rename/binary) are skipped; only real body +/- lines count.
+export function analyzeDiff(diff) {
+    const out = [];
+    for (const seg of splitDiffByFile(diff)) {
+        let additions = 0;
+        let deletions = 0;
+        let isNew = false;
+        let apiTouch = pathTouchesApi(seg.path);
+        let inHunk = false;
+        for (const line of seg.text.split('\n')) {
+            if (line.startsWith('@@')) {
+                inHunk = true;
+                continue;
+            }
+            if (!inHunk) {
+                if (line.startsWith('new file mode') ||
+                    (line.startsWith('--- ') && line.slice(4).trim() === '/dev/null')) {
+                    isNew = true;
+                }
+                continue;
+            }
+            const marker = line[0];
+            if (marker === '+') {
+                additions += 1;
+            }
+            else if (marker === '-') {
+                deletions += 1;
+                if (!apiTouch && lineTouchesApi(line.slice(1)))
+                    apiTouch = true;
+            }
+        }
+        out.push({ path: seg.path, additions, deletions, isNew, apiTouch });
+    }
+    return out;
+}
+// ctx.review.prepareReview — fetch the PR's diff (gh CLI), strip noise, analyze per-file
+// metrics, and cap the prompt diff. Returns everything the plugin needs to route + prompt
+// WITHOUT any diff primitive leaving core.
+export async function prepareReview(args) {
+    const rawDiff = await fetchPrDiff(args.owner, args.name, args.prNumber);
+    const { diff: strippedDiff, excluded } = stripNoiseFromDiff(rawDiff, isNoiseFile);
+    const fileMetrics = analyzeDiff(strippedDiff);
+    const changedFiles = fileMetrics.map((f) => f.path);
+    // Diff-size cap (feature-flagged): shrink only the PROMPT's diff body at a whole-file
+    // boundary. Routing ran on the full stripped diff and anchoring still uses it.
+    let promptDiff = strippedDiff;
+    let omittedFiles = [];
+    let diffCapped = false;
+    if (config.reviewDiffCapEnabled) {
+        const capped = capDiff(strippedDiff, config.reviewDiffCapChars);
+        promptDiff = capped.diff;
+        omittedFiles = capped.omittedFiles;
+        diffCapped = capped.capped;
+    }
+    return {
+        strippedDiff,
+        promptDiff,
+        changedFiles,
+        excludedFiles: excluded,
+        omittedFiles,
+        fileMetrics,
+        diffBytes: strippedDiff.length,
+        diffCapped,
+    };
+}
+//# sourceMappingURL=prepare.js.map

package/dist/review/pricing.js

@@ -0,0 +1,17 @@
+const RATES = {
+    // Opus 5.5 — the Claude Review AND AI Fix default. $4 in / $20 out; cache write $5 (1.25×),
+    // read $0.20.
+    'claude-opus-5-5': { input: 4, output: 20, cacheWrite: 5, cacheRead: 0.2 },
+    // Sonnet 5 (≤200K tier) — Sonnet pricing, near-Opus quality.
+    'claude-sonnet-5': { input: 3, output: 15, cacheWrite: 3.75, cacheRead: 0.3 },
+};
+/** A running USD estimate from accumulated turn usage. Falls back to Sonnet rates. */
+export function estimateCostUsd(model, u) {
+    const r = RATES[model] ?? RATES['claude-sonnet-5'];
+    return ((u.inputTokens * r.input +
+        u.outputTokens * r.output +
+        u.cacheReadTokens * r.cacheRead +
+        u.cacheCreationTokens * r.cacheWrite) /
+        1_000_000);
+}
+//# sourceMappingURL=pricing.js.map