specrails-desktop 2.64.2 → 2.65.0

package/server/dist/modules/delivery/adapters/review-wip-store.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readReviewWipSnapshot = readReviewWipSnapshot;
+const review_wip_1 = require("../domain/review-wip");
+/** SQLite `datetime('now')` (UTC, no zone) → ISO; ISO input passes through. */
+function toIso(value) {
+    return /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/.test(value) ? `${value.replace(' ', 'T')}Z` : value;
+}
+function parseTicketIds(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        return Array.isArray(parsed) ? parsed.filter((id) => Number.isSafeInteger(id)) : [];
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Outbound adapter: the review WIP snapshot of ONE project's connection. It
+ * reads only top-level rows in a counted decision; the pure domain still
+ * re-applies the rule so the adapter cannot widen it.
+ */
+function readReviewWipSnapshot(db) {
+    const decisions = [...review_wip_1.REVIEW_WIP_DECISIONS];
+    const rows = db.prepare(`SELECT id, rail_index, ticket_ids, decision, parent_delivery_id, created_at
+       FROM rail_pr_deliveries
+      WHERE parent_delivery_id IS NULL AND decision IN (${decisions.map(() => '?').join(', ')})
+      ORDER BY created_at ASC, rowid ASC`).all(...decisions);
+    return rows.map((row) => ({
+        id: row.id,
+        railIndex: row.rail_index,
+        ticketIds: parseTicketIds(row.ticket_ids),
+        decision: row.decision,
+        parentDeliveryId: row.parent_delivery_id,
+        createdAt: toIso(row.created_at),
+    }));
+}

package/server/dist/modules/delivery/domain/review-wip.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REVIEW_WIP_DECISIONS = void 0;
+exports.listPendingReview = listPendingReview;
+exports.countPendingReview = countPendingReview;
+exports.normalizeReviewWipLimit = normalizeReviewWipLimit;
+exports.launchAddsReviewWip = launchAddsReviewWip;
+exports.evaluateReviewWip = evaluateReviewWip;
+exports.reviewWipRejection = reviewWipRejection;
+/**
+ * Review WIP limit (review-wip-limit): how many deliveries may wait for the
+ * user's review at once. Pure: callers supply the snapshot and the limit.
+ *
+ * A delivery counts while it is, or is about to become, review work for a
+ * human:
+ *
+ * - `building`  — admitted and running; it lands on review when it settles.
+ *                 Counting it is what makes the cap hold under parallel
+ *                 launches (otherwise Launch all could overshoot it).
+ * - `on_review` — settled, awaiting the Create PR / Discard decision.
+ * - `pr_draft` / `pr_ready` — a PR the app created (or continued) that is not
+ *                 merged or closed yet; it still needs the user's review.
+ *
+ * Not counted: `no_changes` (nothing to review — acknowledge only),
+ * `implementation_failed` / `pr_failed` (no reviewable result; they need a
+ * retry or discard, and a retry of the same delivery is exempt anyway),
+ * `pr_closed` (closed on GitHub), and every terminal decision.
+ *
+ * Only top-level rows count: the per-repository children of a grouped
+ * delivery are one review item with their parent.
+ */
+exports.REVIEW_WIP_DECISIONS = new Set(['building', 'on_review', 'pr_draft', 'pr_ready']);
+/** The pending review items, oldest first. */
+function listPendingReview(deliveries) {
+    return deliveries
+        .filter((row) => row.parentDeliveryId === null && exports.REVIEW_WIP_DECISIONS.has(row.decision))
+        .map((row) => ({ deliveryId: row.id, railIndex: row.railIndex, ticketIds: [...row.ticketIds], decision: row.decision, since: row.createdAt }))
+        .sort((a, b) => a.since.localeCompare(b.since) || a.railIndex - b.railIndex);
+}
+/** How many deliveries currently count against the review WIP limit. */
+function countPendingReview(deliveries) {
+    return listPendingReview(deliveries).length;
+}
+/** A limit is a positive integer; null (or anything else) means no limit. */
+function normalizeReviewWipLimit(value) {
+    return typeof value === 'number' && Number.isSafeInteger(value) && value >= 1 ? value : null;
+}
+function launchAddsReviewWip(launch) {
+    return !(launch.revisionOfDeliveryId || launch.relaunchOfDelivery || launch.targetsExistingPr || launch.railHasActiveDelivery);
+}
+/**
+ * The admission decision. `reserved` counts launches already admitted by this
+ * project but whose delivery row is not written yet (parallel launches).
+ */
+function evaluateReviewWip(input) {
+    if (!input.addsWip || input.limit === null)
+        return null;
+    const occupied = input.pending.length + (input.reserved ?? 0);
+    if (occupied < input.limit)
+        return null;
+    return reviewWipRejection(input.limit, input.pending);
+}
+function reviewWipRejection(limit, pending) {
+    return {
+        error: 'review_wip_limit_reached',
+        limit,
+        pending: pending.map(({ deliveryId, railIndex, ticketIds, since }) => ({ deliveryId, railIndex, ticketIds: [...ticketIds], since })),
+        detail: `${pending.length} ${pending.length === 1 ? 'delivery is' : 'deliveries are'} waiting for review; this project allows ${limit} at a time. Nothing was launched.`,
+        action: 'Decide a pending delivery (Create PR, merge or discard), or raise the limit in Project settings ▸ Review limit.',
+    };
+}

package/server/dist/modules/delivery/index.js

@@ -1,7 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.actionAllowed = exports.isPrDecisionAction = exports.PR_DECISION_ACTIONS = void 0;
+exports.reviewWipRejection = exports.evaluateReviewWip = exports.launchAddsReviewWip = exports.normalizeReviewWipLimit = exports.countPendingReview = exports.listPendingReview = exports.REVIEW_WIP_DECISIONS = exports.actionAllowed = exports.isPrDecisionAction = exports.PR_DECISION_ACTIONS = void 0;
 var decision_policy_1 = require("./domain/decision-policy");
 Object.defineProperty(exports, "PR_DECISION_ACTIONS", { enumerable: true, get: function () { return decision_policy_1.PR_DECISION_ACTIONS; } });
 Object.defineProperty(exports, "isPrDecisionAction", { enumerable: true, get: function () { return decision_policy_1.isPrDecisionAction; } });
 Object.defineProperty(exports, "actionAllowed", { enumerable: true, get: function () { return decision_policy_1.actionAllowed; } });
+var review_wip_1 = require("./domain/review-wip");
+Object.defineProperty(exports, "REVIEW_WIP_DECISIONS", { enumerable: true, get: function () { return review_wip_1.REVIEW_WIP_DECISIONS; } });
+Object.defineProperty(exports, "listPendingReview", { enumerable: true, get: function () { return review_wip_1.listPendingReview; } });
+Object.defineProperty(exports, "countPendingReview", { enumerable: true, get: function () { return review_wip_1.countPendingReview; } });
+Object.defineProperty(exports, "normalizeReviewWipLimit", { enumerable: true, get: function () { return review_wip_1.normalizeReviewWipLimit; } });
+Object.defineProperty(exports, "launchAddsReviewWip", { enumerable: true, get: function () { return review_wip_1.launchAddsReviewWip; } });
+Object.defineProperty(exports, "evaluateReviewWip", { enumerable: true, get: function () { return review_wip_1.evaluateReviewWip; } });
+Object.defineProperty(exports, "reviewWipRejection", { enumerable: true, get: function () { return review_wip_1.reviewWipRejection; } });

package/server/dist/modules/delivery/runtime/delivery-changes.js

@@ -0,0 +1,355 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultGitRun = exports.FULL_DIFF_LINE_CAP = exports.DEFAULT_DIFF_LINE_CAP = exports.MAX_LISTED_FILES = void 0;
+exports.listChangeSources = listChangeSources;
+exports.resolveChangeTarget = resolveChangeTarget;
+exports.parseRawDiff = parseRawDiff;
+exports.parseNumstat = parseNumstat;
+exports.listChangedFiles = listChangedFiles;
+exports.parseUnifiedDiff = parseUnifiedDiff;
+exports.readFileDiff = readFileDiff;
+exports.parseLocationRef = parseLocationRef;
+exports.collectAnnotations = collectAnnotations;
+exports.composeDeliveryChanges = composeDeliveryChanges;
+exports.composeFileDiff = composeFileDiff;
+/**
+ * In-app review: the Changes tab's read model (feature-gap CD3).
+ *
+ * Answers "what did this delivery change?" from the repository itself: the
+ * delivery's head (the assembled branch, or one unit's branch) against its base,
+ * measured from the merge-base so a base that moved on does not leak unrelated
+ * changes into the review. Read-only — every git call here is a `diff`,
+ * `merge-base` or `rev-parse`, run with the hardened environment of the other
+ * cwd-scoped git readers (no hooks, no fsmonitor, no prompts).
+ *
+ * Two reads, both lazy: the file LIST (paths, status, +/− counts, a content
+ * hash that changes whenever the file's diff does) and ONE file's parsed hunks.
+ * A huge file diff is capped to a bounded number of lines; the caller opts into
+ * the rest with `full`. Annotations (reviewer findings, brief risks, follow-up
+ * comments) are returned raw and anchored by the client against the displayed
+ * lines, so an annotation that no longer maps still renders (unanchored).
+ */
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const file_provenance_1 = require("../../code/runtime/file-provenance");
+const delivery_evidence_1 = require("./delivery-evidence");
+const pr_follow_up_1 = require("./pr-follow-up");
+exports.MAX_LISTED_FILES = 2000;
+exports.DEFAULT_DIFF_LINE_CAP = 4000;
+exports.FULL_DIFF_LINE_CAP = 60_000;
+const GIT_TIMEOUT_MS = 20_000;
+const LIST_MAX_BUFFER = 16 * 1024 * 1024;
+const DIFF_MAX_BUFFER = 32 * 1024 * 1024;
+const FOLLOW_UP_TEXT_CAP = 1200;
+const defaultGitRun = (args, cwd, maxBuffer = LIST_MAX_BUFFER) => new Promise((resolve) => {
+    (0, child_process_1.execFile)('git', ['--literal-pathspecs', '-c', 'core.quotepath=off', ...args], {
+        cwd, env: (0, file_provenance_1.gitExecEnv)(), timeout: GIT_TIMEOUT_MS, maxBuffer, windowsHide: true,
+    }, (err, stdout, stderr) => {
+        const code = err && typeof err.code === 'number' ? err.code : err ? 1 : 0;
+        resolve({ code, stdout: String(stdout ?? ''), stderr: String(stderr ?? '') || (err ? err.message : '') });
+    });
+});
+exports.defaultGitRun = defaultGitRun;
+// ─── Source resolution ──────────────────────────────────────────────────────
+function parseBranches(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        return Array.isArray(parsed) ? parsed.filter((b) => !!b && typeof b === 'object' && typeof b.branch === 'string') : [];
+    }
+    catch {
+        return [];
+    }
+}
+/** A ref from the database must never be read as a git option. */
+function safeRef(ref) {
+    return typeof ref === 'string' && ref.length > 0 && ref.length <= 255 && !ref.startsWith('-') && !/[\0\s]/.test(ref) ? ref : null;
+}
+function listChangeSources(row, repositoryId) {
+    const sources = [];
+    const assembled = safeRef(row.branch);
+    if (assembled)
+        sources.push({ id: 'delivery', ticketId: null, branch: assembled });
+    const units = parseBranches(row.branches)
+        .filter((unit) => (!repositoryId || !unit.repositoryId || unit.repositoryId === repositoryId) && unit.changed !== false && unit.deliveryOutcome !== 'no_changes');
+    // A single-unit delivery without an assembled branch has exactly one source.
+    for (const unit of units) {
+        const ref = safeRef(unit.finalSha ?? unit.branch);
+        if (!ref)
+            continue;
+        if (assembled && unit.branch === assembled)
+            continue;
+        sources.push({ id: `ticket:${unit.ticketId}`, ticketId: unit.ticketId, branch: unit.branch });
+    }
+    return sources;
+}
+async function revParse(git, cwd, ref) {
+    const res = await git(['rev-parse', '--verify', '--quiet', `${ref}^{commit}`], cwd);
+    const sha = res.stdout.trim();
+    return res.code === 0 && /^[0-9a-f]{40,64}$/i.test(sha) ? sha : null;
+}
+async function resolveChangeTarget(input, git = exports.defaultGitRun) {
+    const { row, repoDir } = input;
+    const sources = listChangeSources(row, input.repositoryId);
+    const inside = await git(['rev-parse', '--is-inside-work-tree'], repoDir);
+    if (inside.code !== 0)
+        return { ok: false, reason: 'not_a_repository', sources };
+    const source = input.sourceId ? sources.find((s) => s.id === input.sourceId) : sources[0];
+    if (!source)
+        return { ok: false, reason: 'no_branch', sources };
+    const units = parseBranches(row.branches);
+    const unit = source.ticketId === null ? undefined : units.find((u) => u.ticketId === source.ticketId && u.branch === source.branch);
+    // The settled object wins over the branch name: the ref may have moved since.
+    const headRef = source.ticketId === null ? (safeRef(row.delivery_sha) ?? source.branch) : (safeRef(unit?.finalSha) ?? source.branch);
+    const headSha = await revParse(git, repoDir, headRef) ?? (headRef !== source.branch ? await revParse(git, repoDir, source.branch) : null);
+    if (!headSha)
+        return { ok: false, reason: 'head_missing', sources };
+    const baseName = safeRef(row.base_branch);
+    let baseSha = null;
+    let baseLabel = baseName ?? '';
+    for (const candidate of baseName ? [baseName, `refs/heads/${baseName}`, `origin/${baseName}`] : []) {
+        baseSha = await revParse(git, repoDir, candidate);
+        if (baseSha)
+            break;
+    }
+    if (!baseSha && unit?.initialSha && safeRef(unit.initialSha)) {
+        baseSha = await revParse(git, repoDir, unit.initialSha);
+        baseLabel = unit.initialSha.slice(0, 8);
+    }
+    if (!baseSha)
+        return { ok: false, reason: 'base_missing', sources };
+    const mergeBase = await git(['merge-base', baseSha, headSha], repoDir);
+    const fork = mergeBase.code === 0 && /^[0-9a-f]{40,64}$/i.test(mergeBase.stdout.trim()) ? mergeBase.stdout.trim() : baseSha;
+    const worktree = unit?.worktreePath && fs_1.default.existsSync(unit.worktreePath) ? unit.worktreePath : null;
+    return { ok: true, sources, target: { source, head: source.branch, base: baseLabel, baseSha: fork, headSha, root: worktree ?? repoDir, rootKind: worktree ? 'worktree' : 'repository' } };
+}
+// ─── Listing ────────────────────────────────────────────────────────────────
+const STATUS_BY_LETTER = { A: 'added', M: 'modified', D: 'deleted', R: 'renamed', C: 'copied', T: 'typechange' };
+const DIFF_FLAGS = ['--no-ext-diff', '--no-textconv', '--no-color', '-M'];
+/** Parses `git diff --raw -z --no-abbrev` into entries. Exported for tests. */
+function parseRawDiff(out) {
+    const tokens = out.split('\0');
+    const files = [];
+    for (let i = 0; i < tokens.length; i++) {
+        const meta = tokens[i];
+        if (!meta.startsWith(':'))
+            continue;
+        const fields = meta.slice(1).split(' ');
+        const letter = (fields[4] ?? '')[0] ?? '';
+        const status = STATUS_BY_LETTER[letter];
+        if (!status)
+            continue;
+        if (letter === 'R' || letter === 'C') {
+            const oldPath = tokens[++i];
+            const path = tokens[++i];
+            if (oldPath && path)
+                files.push({ status, path, oldPath, oldSha: fields[2] ?? '', newSha: fields[3] ?? '' });
+        }
+        else {
+            const path = tokens[++i];
+            if (path)
+                files.push({ status, path, oldPath: null, oldSha: fields[2] ?? '', newSha: fields[3] ?? '' });
+        }
+    }
+    return files;
+}
+/** Parses `git diff --numstat -z`; binary files report `-`. Exported for tests. */
+function parseNumstat(out) {
+    const tokens = out.split('\0');
+    const counts = new Map();
+    for (let i = 0; i < tokens.length; i++) {
+        const match = /^(\d+|-)\t(\d+|-)\t(.*)$/s.exec(tokens[i]);
+        if (!match)
+            continue;
+        const additions = match[1] === '-' ? null : Number(match[1]);
+        const deletions = match[2] === '-' ? null : Number(match[2]);
+        // A rename/copy has an empty path here and the old/new paths follow as separate tokens.
+        const path = match[3] === '' ? (i += 2, tokens[i]) : match[3];
+        if (path)
+            counts.set(path, { additions, deletions });
+    }
+    return counts;
+}
+async function listChangedFiles(target, repoDir, git = exports.defaultGitRun) {
+    const range = [target.baseSha, target.headSha];
+    const [raw, numstat] = await Promise.all([
+        git(['diff', '--raw', '-z', '--no-abbrev', ...DIFF_FLAGS, ...range], repoDir),
+        git(['diff', '--numstat', '-z', ...DIFF_FLAGS, ...range], repoDir),
+    ]);
+    if (raw.code !== 0 || numstat.code !== 0)
+        return null;
+    const counts = parseNumstat(numstat.stdout);
+    const entries = parseRawDiff(raw.stdout);
+    const files = entries.slice(0, exports.MAX_LISTED_FILES).map((entry) => {
+        const count = counts.get(entry.path);
+        const binary = count ? count.additions === null && count.deletions === null : false;
+        return {
+            path: entry.path, oldPath: entry.oldPath, status: entry.status,
+            additions: count?.additions ?? null, deletions: count?.deletions ?? null, binary,
+            hash: `${entry.oldSha.slice(0, 16)}..${entry.newSha.slice(0, 16)}`,
+        };
+    });
+    return { files: files.sort((a, b) => a.path.localeCompare(b.path)), truncated: entries.length > exports.MAX_LISTED_FILES };
+}
+// ─── One file ───────────────────────────────────────────────────────────────
+/** Parses a unified diff body (git's `--- / +++` header is skipped). Exported for tests. */
+function parseUnifiedDiff(text, lineCap) {
+    const hunks = [];
+    let current = null;
+    let oldNo = 0;
+    let newNo = 0;
+    let kept = 0;
+    let total = 0;
+    let truncated = false;
+    for (const line of text.split('\n')) {
+        const header = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(.*)$/.exec(line);
+        if (header) {
+            current = {
+                header: line, oldStart: Number(header[1]), oldLines: header[2] === undefined ? 1 : Number(header[2]),
+                newStart: Number(header[3]), newLines: header[4] === undefined ? 1 : Number(header[4]), lines: [],
+            };
+            hunks.push(current);
+            oldNo = current.oldStart;
+            newNo = current.newStart;
+            continue;
+        }
+        if (!current)
+            continue;
+        const marker = line[0];
+        if (marker === '\\') {
+            const previous = current.lines[current.lines.length - 1];
+            if (previous)
+                previous.noNewline = true;
+            continue;
+        }
+        if (marker !== ' ' && marker !== '+' && marker !== '-')
+            continue;
+        total++;
+        if (kept >= lineCap) {
+            truncated = true;
+            continue;
+        }
+        kept++;
+        const textBody = line.slice(1);
+        if (marker === '+')
+            current.lines.push({ type: 'add', oldNo: null, newNo: newNo++, text: textBody });
+        else if (marker === '-')
+            current.lines.push({ type: 'delete', oldNo: oldNo++, newNo: null, text: textBody });
+        else
+            current.lines.push({ type: 'context', oldNo: oldNo++, newNo: newNo++, text: textBody });
+    }
+    return { hunks: hunks.filter((h) => h.lines.length > 0), truncated, totalLines: total };
+}
+async function readFileDiff(input, git = exports.defaultGitRun) {
+    const { file } = input;
+    const base = { path: file.path, oldPath: file.oldPath, status: file.status };
+    if (file.binary)
+        return { ...base, binary: true, hunks: [], truncated: false, totalLines: 0 };
+    const paths = file.oldPath ? [file.oldPath, file.path] : [file.path];
+    const res = await git(['diff', '-U3', ...DIFF_FLAGS, input.target.baseSha, input.target.headSha, '--', ...paths], input.repoDir, DIFF_MAX_BUFFER);
+    if (res.code !== 0)
+        return null;
+    // git marks a binary diff that numstat could not (e.g. attributes) with this line.
+    if (/^Binary files .* differ$/m.test(res.stdout) && !/^@@ /m.test(res.stdout))
+        return { ...base, binary: true, hunks: [], truncated: false, totalLines: 0 };
+    const parsed = parseUnifiedDiff(res.stdout, input.full ? exports.FULL_DIFF_LINE_CAP : exports.DEFAULT_DIFF_LINE_CAP);
+    return { ...base, binary: false, ...parsed };
+}
+// ─── Annotations ────────────────────────────────────────────────────────────
+const REF_RE = /^([^\s:*?"<>|]+?)(?::(\d+)(?:[-–](\d+))?)?$/;
+/** `path[:line[-end]]` from a risk's free-text `ref`; null when it is not a bare location. */
+function parseLocationRef(ref) {
+    const match = ref ? REF_RE.exec(ref.trim()) : null;
+    if (!match || !/[./]/.test(match[1]))
+        return null;
+    const path = match[1].replace(/\\/g, '/').replace(/^\.\//, '');
+    if (path.startsWith('/') || path.split('/').includes('..'))
+        return null;
+    const line = match[2] ? Number(match[2]) : null;
+    const endLine = match[3] ? Number(match[3]) : null;
+    return { path, line: line && line > 0 ? line : null, endLine: line && endLine && endLine > line ? endLine : null };
+}
+function cap(text, max) {
+    return text.length > max ? `${text.slice(0, max - 1)}…` : text;
+}
+/**
+ * Everything the delivery already knows about places in the change: the
+ * reviewer's findings (anchored when Core 5.9 named a location), the review
+ * brief's risks and untested files, and the comments a follow-up was launched
+ * to resolve. Pure over durable rows; unanchored items keep `location: null`.
+ */
+function collectAnnotations(row) {
+    const out = [];
+    const evidence = (0, delivery_evidence_1.readSettleEvidence)(row.settle_evidence);
+    for (const unit of evidence?.units ?? []) {
+        const runtime = unit.runtime;
+        const locations = new Map((runtime?.findingLocations ?? []).map((l) => [l.finding, l]));
+        (runtime?.findings ?? []).forEach((text, index) => {
+            const at = locations.get(index);
+            out.push({
+                id: `finding:${unit.ticketId}:${index}`, source: 'reviewer-finding', text: cap(text, 1200), severity: null, author: null,
+                location: at ? { path: at.path, line: at.line ?? null, endLine: at.endLine ?? null } : null,
+            });
+        });
+        const brief = unit.reviewBrief?.brief;
+        brief?.risks.forEach((risk, index) => {
+            const at = parseLocationRef(risk.ref);
+            out.push({
+                id: `risk:${unit.ticketId}:${index}`, source: 'review-risk', text: cap(risk.whatToLookAt, 1200), severity: risk.severity, author: null,
+                location: at,
+            });
+        });
+        brief?.untested.forEach((item, index) => {
+            const at = parseLocationRef(item.path);
+            if (!at)
+                return;
+            out.push({
+                id: `untested:${unit.ticketId}:${index}`, source: 'review-untested', text: item.why ? cap(item.why, 600) : '', severity: null, author: null,
+                location: { path: at.path, line: null, endLine: null },
+            });
+        });
+    }
+    const followUp = (0, pr_follow_up_1.readFollowUp)(row.follow_up);
+    followUp?.comments.forEach((comment) => {
+        const at = comment.path ? parseLocationRef(comment.path) : null;
+        out.push({
+            id: `comment:${comment.id}`, source: 'follow-up-comment', text: cap(comment.body, FOLLOW_UP_TEXT_CAP), severity: null, author: comment.author,
+            location: at && comment.path ? { path: at.path, line: comment.line, endLine: null } : null,
+        });
+    });
+    return out;
+}
+// ─── Composition ────────────────────────────────────────────────────────────
+async function composeDeliveryChanges(input, git = exports.defaultGitRun) {
+    const annotations = collectAnnotations(input.row);
+    const resolved = await resolveChangeTarget(input, git);
+    if (!resolved.ok)
+        return { available: false, reason: resolved.reason, sources: resolved.sources, annotations };
+    const listing = await listChangedFiles(resolved.target, input.repoDir, git);
+    if (!listing)
+        return { available: false, reason: 'git_failed', sources: resolved.sources, annotations };
+    const totals = listing.files.reduce((sum, file) => ({
+        files: sum.files + 1, additions: sum.additions + (file.additions ?? 0), deletions: sum.deletions + (file.deletions ?? 0),
+    }), { files: 0, additions: 0, deletions: 0 });
+    const { target } = resolved;
+    return {
+        available: true, source: target.source.id, sources: resolved.sources, base: target.base, head: target.head,
+        baseSha: target.baseSha, headSha: target.headSha, root: target.root, rootKind: target.rootKind, files: listing.files, truncated: listing.truncated, totals, annotations,
+    };
+}
+async function composeFileDiff(input, git = exports.defaultGitRun) {
+    const resolved = await resolveChangeTarget(input, git);
+    if (!resolved.ok)
+        return { ok: false, status: 409, error: resolved.reason };
+    const listing = await listChangedFiles(resolved.target, input.repoDir, git);
+    if (!listing)
+        return { ok: false, status: 500, error: 'git_failed' };
+    // Only a path the diff lists is ever handed to git: the query is a lookup key, not a pathspec.
+    const file = listing.files.find((candidate) => candidate.path === input.path);
+    if (!file)
+        return { ok: false, status: 404, error: 'file_not_in_changes' };
+    const diff = await readFileDiff({ target: resolved.target, repoDir: input.repoDir, file, ...(input.full ? { full: true } : {}) }, git);
+    return diff ? { ok: true, diff } : { ok: false, status: 500, error: 'git_failed' };
+}