@nexrall/code-core 1.4.76 → 1.4.78

package/dist/diff/diffView.js

@@ -0,0 +1,231 @@
+"use strict";
+// `/diff` — the content of your uncommitted changes, not just a file list.
+//
+// Lives in core (moved from the CLI's ui/diffView.ts, 2026-10-04) so the VS Code
+// panel renders the same parse/summary/render; the CLI module re-exports it and
+// keeps only `paintLine` (the ANSI colouring is CLI-only).
+//
+// WHY: `/diff` used to print `git status --short` + `git diff --stat`, so after an agent turn
+// you still had to leave the CLI to see WHAT changed. Claude Code shows the diff itself, and
+// lets you look at one file. This module is the pure half: parse `git diff` output into
+// files/hunks, pick a file by (partial) name, fold long hunks, and produce display lines.
+// No git, no console, no chalk in the parse/render path, so every rule is unit-testable —
+// see test/diffView.test.ts. Colouring is a separate function (`paintLine`).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_UNTRACKED_BYTES = exports.MAX_VIEW_LINES = exports.FOLDED_HUNK_KEEP = exports.MAX_HUNK_LINES = void 0;
+exports.parseUnifiedDiff = parseUnifiedDiff;
+exports.newFileDiff = newFileDiff;
+exports.totals = totals;
+exports.findFiles = findFiles;
+exports.summaryLines = summaryLines;
+exports.renderFile = renderFile;
+exports.renderAll = renderAll;
+exports.capLines = capLines;
+/** A hunk longer than this is folded in the overview (full view never folds hunks). */
+exports.MAX_HUNK_LINES = 40;
+/** Body lines kept from a folded hunk. */
+exports.FOLDED_HUNK_KEEP = 30;
+/** Total lines one rendering may emit before it points at `/diff <file>`. */
+exports.MAX_VIEW_LINES = 400;
+/** Untracked files larger than this are listed, not inlined. */
+exports.MAX_UNTRACKED_BYTES = 200000;
+/** Parse the output of `git diff` (unified, no colour) into files. */
+function parseUnifiedDiff(text) {
+    const files = [];
+    let file = null;
+    let hunk = null;
+    let oldCount = 0;
+    let newCount = 0;
+    for (const raw of text.split('\n')) {
+        const line = raw.replace(/\r$/, '');
+        const head = /^diff --git a\/(.+) b\/(.+)$/.exec(line);
+        // A body line always starts with + - space or \, so it can never match ^diff --git.
+        if (head) {
+            file = { path: head[2], status: 'modified', additions: 0, deletions: 0, hunks: [] };
+            if (head[1] !== head[2])
+                file.oldPath = head[1];
+            files.push(file);
+            hunk = null;
+            continue;
+        }
+        if (!file)
+            continue;
+        if (hunk && (oldCount > 0 || newCount > 0)) {
+            const c = line[0];
+            if (c === '+') {
+                file.additions++;
+                newCount--;
+                hunk.lines.push(line);
+                continue;
+            }
+            if (c === '-') {
+                file.deletions++;
+                oldCount--;
+                hunk.lines.push(line);
+                continue;
+            }
+            if (c === '\\') {
+                hunk.lines.push(line);
+                continue;
+            }
+            // Context line (git writes a leading space; an empty context line may lose it).
+            oldCount--;
+            newCount--;
+            hunk.lines.push(line === '' ? ' ' : line);
+            continue;
+        }
+        if (hunk && line[0] === '\\') {
+            hunk.lines.push(line);
+            continue;
+        }
+        const h = /^@@ -\d+(?:,(\d+))? \+\d+(?:,(\d+))? @@/.exec(line);
+        if (h) {
+            oldCount = h[1] === undefined ? 1 : Number(h[1]);
+            newCount = h[2] === undefined ? 1 : Number(h[2]);
+            hunk = { header: line, lines: [] };
+            file.hunks.push(hunk);
+            continue;
+        }
+        if (line.startsWith('new file mode'))
+            file.status = 'added';
+        else if (line.startsWith('deleted file mode'))
+            file.status = 'deleted';
+        else if (line.startsWith('rename from ')) {
+            file.status = 'renamed';
+            file.oldPath = line.slice(12);
+        }
+        else if (line.startsWith('Binary files ') || line === 'GIT binary patch')
+            file.status = 'binary';
+    }
+    return files;
+}
+/** Synthesise the diff of an untracked (new) text file so `/diff` can show it too. */
+function newFileDiff(path, content) {
+    const lines = content.split('\n');
+    if (lines[lines.length - 1] === '')
+        lines.pop();
+    const binary = content.includes('\u0000');
+    if (binary)
+        return { path, status: 'binary', additions: 0, deletions: 0, hunks: [] };
+    return {
+        path,
+        status: 'added',
+        additions: lines.length,
+        deletions: 0,
+        hunks: lines.length ? [{ header: `@@ -0,0 +1,${lines.length} @@`, lines: lines.map((l) => '+' + l) }] : [],
+    };
+}
+function totals(files) {
+    return {
+        files: files.length,
+        additions: files.reduce((n, f) => n + f.additions, 0),
+        deletions: files.reduce((n, f) => n + f.deletions, 0),
+    };
+}
+/**
+ * Find the file a user means by `/diff <name>`: exact path, then unique suffix
+ * ("chat.ts"), then unique substring. Returns the matches so the caller can say
+ * "ambiguous" instead of silently picking one.
+ */
+function findFiles(files, query) {
+    const q = query.trim().replace(/^\.\//, '');
+    if (!q)
+        return [];
+    const exact = files.filter((f) => f.path === q);
+    if (exact.length)
+        return exact;
+    const suffix = files.filter((f) => f.path.endsWith('/' + q) || f.path === q);
+    if (suffix.length)
+        return suffix;
+    const lower = q.toLowerCase();
+    return files.filter((f) => f.path.toLowerCase().includes(lower));
+}
+const STATUS_LABEL = {
+    modified: 'modified',
+    added: 'new file',
+    deleted: 'deleted',
+    renamed: 'renamed',
+    binary: 'binary',
+};
+/** One summary row per file: `  M  path   +12 −3`. */
+function summaryLines(files) {
+    const out = [];
+    const width = Math.min(60, Math.max(0, ...files.map((f) => f.path.length)));
+    for (const f of files) {
+        const counts = f.status === 'binary' ? 'binary' : `+${f.additions} −${f.deletions}`;
+        const name = f.oldPath && f.status === 'renamed' ? `${f.oldPath} → ${f.path}` : f.path;
+        out.push({
+            kind: 'meta',
+            text: `${name.padEnd(width)}  ${counts}${f.status === 'modified' ? '' : `  (${STATUS_LABEL[f.status]})`}`,
+        });
+    }
+    const t = totals(files);
+    out.push({
+        kind: 'note',
+        text: `${t.files} file${t.files === 1 ? '' : 's'} changed, +${t.additions} −${t.deletions}`,
+    });
+    return out;
+}
+/** Display lines for one file: header, then each hunk, long ones folded when asked. */
+function renderFile(f, opts = {}) {
+    const fold = opts.foldHunks !== false;
+    const out = [];
+    const title = f.oldPath && f.status === 'renamed' ? `${f.oldPath} → ${f.path}` : f.path;
+    out.push({
+        kind: 'file',
+        text: `${title}  (${STATUS_LABEL[f.status]}${f.status === 'binary' ? '' : `, +${f.additions} −${f.deletions}`})`,
+    });
+    if (f.status === 'binary') {
+        out.push({ kind: 'note', text: 'binary file — not shown' });
+        return out;
+    }
+    if (!f.hunks.length) {
+        out.push({ kind: 'note', text: f.status === 'renamed' ? 'renamed, no content changes' : '(no textual changes)' });
+        return out;
+    }
+    for (const h of f.hunks) {
+        out.push({ kind: 'hunk', text: h.header });
+        const folded = fold && h.lines.length > exports.MAX_HUNK_LINES;
+        const shown = folded ? h.lines.slice(0, exports.FOLDED_HUNK_KEEP) : h.lines;
+        for (const l of shown) {
+            const c = l[0];
+            out.push({ kind: c === '+' ? 'add' : c === '-' ? 'del' : 'ctx', text: l });
+        }
+        if (folded)
+            out.push({
+                kind: 'note',
+                text: `… ${h.lines.length - exports.FOLDED_HUNK_KEEP} more lines in this hunk — /diff ${f.path} shows all`,
+            });
+    }
+    return out;
+}
+/** Whole-tree view: every file rendered, capped overall so a big refactor doesn't flood. */
+function renderAll(files, opts = {}) {
+    const cap = opts.maxLines ?? exports.MAX_VIEW_LINES;
+    const out = [];
+    for (let i = 0; i < files.length; i++) {
+        const chunk = renderFile(files[i], opts);
+        if (out.length + chunk.length > cap && out.length > 0) {
+            const rest = files.slice(i);
+            out.push({
+                kind: 'note',
+                text: `… ${rest.length} more file${rest.length === 1 ? '' : 's'} not shown (${rest
+                    .map((f) => f.path)
+                    .slice(0, 3)
+                    .join(', ')}${rest.length > 3 ? ', …' : ''}) — /diff <file> to open one`,
+            });
+            return out;
+        }
+        if (out.length)
+            out.push({ kind: 'ctx', text: '' });
+        out.push(...chunk);
+    }
+    return out;
+}
+/** Cap a single-file view; over the cap, tells the user how many lines were left out. */
+function capLines(lines, max = exports.MAX_VIEW_LINES * 4) {
+    if (lines.length <= max)
+        return lines;
+    return [...lines.slice(0, max), { kind: 'note', text: `… ${lines.length - max} more lines not shown` }];
+}
+//# sourceMappingURL=diffView.js.map

package/dist/diff/reviewQueue.d.ts

@@ -0,0 +1,53 @@
+import type { DiffFile } from './diffView';
+export type Risk = 'high' | 'medium' | 'low';
+export interface ReviewedFile {
+    path: string;
+    risk: Risk;
+    status: DiffFile['status'];
+    additions: number;
+    deletions: number;
+    /** Observable facts behind `risk`, most significant first. Never a bare number. */
+    reasons: string[];
+}
+export interface ReviewGroup {
+    risk: Risk;
+    files: ReviewedFile[];
+    /** How many files this group holds in total — `files` may be a shorter shown slice. */
+    total: number;
+}
+export interface ReviewQueue {
+    groups: ReviewGroup[];
+    totals: {
+        files: number;
+        additions: number;
+        deletions: number;
+        high: number;
+    };
+}
+export declare function isTestPath(filePath: string): boolean;
+/** Churn past which a change stops being reviewable by skimming. */
+export declare const LARGE_CHANGE_LINES = 200;
+export interface ClassifyContext {
+    /** The test files in the same changeset (see `coveringTest`). */
+    tests: DiffFile[];
+}
+export declare function classifyFile(f: DiffFile, ctx: ClassifyContext): ReviewedFile;
+export declare function buildReviewQueue(files: DiffFile[], maxPerGroup?: number): ReviewQueue;
+export declare const REVIEW_HEADINGS: Record<Risk, string>;
+/** `/review --all` lifts the per-group cap; the default keeps the answer on one screen. */
+export declare const DEFAULT_PER_GROUP = 8;
+/**
+ * Below this width the per-file +/- counts are dropped from the rows: at 40 columns the
+ * counts left the reason clipped to "authe…", and the reason is the half that makes the
+ * grouping checkable. The header still carries the totals, so nothing is lost that can't be
+ * had from `/diff`.
+ */
+export declare const COUNTS_MIN_COLUMNS = 60;
+/**
+ * Rows for the queue. `columns` is the terminal width the caller measured: lines are clipped
+ * here rather than left to wrap, because a wrapped row reads as a second entry.
+ */
+export declare function formatReviewQueue(q: ReviewQueue, columns: number, perGroup?: number): string[];
+/** Everything the queue knows about one file — `/review <path>`. */
+export declare function formatReviewDetail(r: ReviewedFile, columns: number): string[];
+//# sourceMappingURL=reviewQueue.d.ts.map

package/dist/diff/reviewQueue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reviewQueue.d.ts","sourceRoot":"","sources":["../../src/diff/reviewQueue.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAG3C,MAAM,MAAM,IAAI,GAAG,MAAM,GAAG,QAAQ,GAAG,KAAK,CAAC;AAE7C,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,IAAI,CAAC;IACX,MAAM,EAAE,QAAQ,CAAC,QAAQ,CAAC,CAAC;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,mFAAmF;IACnF,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,IAAI,CAAC;IACX,KAAK,EAAE,YAAY,EAAE,CAAC;IACtB,uFAAuF;IACvF,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,WAAW,EAAE,CAAC;IACtB,MAAM,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;CAC/E;AAsMD,wBAAgB,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAEpD;AA0BD,oEAAoE;AACpE,eAAO,MAAM,kBAAkB,MAAM,CAAC;AAItC,MAAM,WAAW,eAAe;IAC9B,iEAAiE;IACjE,KAAK,EAAE,QAAQ,EAAE,CAAC;CACnB;AAED,wBAAgB,YAAY,CAAC,CAAC,EAAE,QAAQ,EAAE,GAAG,EAAE,eAAe,GAAG,YAAY,CAmC5E;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,QAAQ,EAAE,EAAE,WAAW,SAA2B,GAAG,WAAW,CAsBvG;AAID,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,IAAI,EAAE,MAAM,CAAkD,CAAC;AAEpG,2FAA2F;AAC3F,eAAO,MAAM,iBAAiB,IAAI,CAAC;AAEnC;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,KAAK,CAAC;AAErC;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,SAAoB,GAAG,MAAM,EAAE,CAgCzG;AAED,oEAAoE;AACpE,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAS7E"}

package/dist/diff/reviewQueue.js

@@ -0,0 +1,349 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COUNTS_MIN_COLUMNS = exports.DEFAULT_PER_GROUP = exports.REVIEW_HEADINGS = exports.LARGE_CHANGE_LINES = void 0;
+exports.isTestPath = isTestPath;
+exports.classifyFile = classifyFile;
+exports.buildReviewQueue = buildReviewQueue;
+exports.formatReviewQueue = formatReviewQueue;
+exports.formatReviewDetail = formatReviewDetail;
+// Smart review queue (spec §63): group the uncommitted changes by how much attention they
+//
+// Lives in core (moved from the CLI's ui/reviewQueue.ts, 2026-10-04) so the VS Code
+// panel renders the same queue; the CLI module is a re-export shim.
+// deserve, so a 40-file diff does not have to be read top to bottom.
+//
+// The spec is explicit that the ranking must come from OBSERVABLE characteristics rather
+// than an opaque score: every file here carries the facts that placed it, and those facts
+// are the only inputs. Nothing consults a model, and nothing guesses at intent.
+//
+// Two independent questions, deliberately kept apart:
+//   • WHAT the path is  — test, documentation, lockfile, auth code, a migration, deploy
+//                         config. Identity decides the baseline; a test file that happens to
+//                         mention auth is a test file, not "auth code".
+//   • HOW BIG the change is — churn and deletion, which apply to every file regardless.
+// Plus one relational fact: whether a matching test file changed alongside it.
+const node_path_1 = __importDefault(require("node:path"));
+const cellWidth_1 = require("../util/cellWidth");
+const RISK_ORDER = ['high', 'medium', 'low'];
+/** Bands a file's identity can pin, checked before any subject is considered. */
+const IDENTITY = [
+    {
+        label: 'a test file',
+        risk: 'low',
+        words: ['test', 'tests', 'spec', 'specs', '__tests__', 'e2e', 'fixture', 'fixtures', 'snapshot', 'snapshots'],
+    },
+    {
+        label: 'documentation',
+        risk: 'low',
+        words: ['docs', 'doc', 'readme', 'changelog', 'license', 'licence', 'contributing', 'authors', 'notes'],
+        exactly: ['readme', 'changelog', 'license', 'licence', 'contributing'],
+    },
+    {
+        // Before the manifest concept: `package-lock.json` must not be read as `package.json`.
+        label: 'a generated lockfile',
+        risk: 'low',
+        words: [],
+        exactly: [
+            'package-lock.json',
+            'yarn.lock',
+            'pnpm-lock.yaml',
+            'bun.lockb',
+            'cargo.lock',
+            'go.sum',
+            'poetry.lock',
+            'composer.lock',
+            'gemfile.lock',
+        ],
+    },
+];
+/** What the file is ABOUT. Only consulted for files whose identity is not already pinned. */
+const SUBJECT = [
+    {
+        label: 'authentication, sessions or access control',
+        risk: 'high',
+        words: [
+            'auth',
+            'authentication',
+            'authorize',
+            'authorization',
+            'login',
+            'logout',
+            'signin',
+            'signup',
+            'oauth',
+            'saml',
+            'sso',
+            'session',
+            'sessions',
+            'token',
+            'tokens',
+            'jwt',
+            'acl',
+            'rbac',
+            'permission',
+            'permissions',
+            'privilege',
+            'privileges',
+            'credential',
+            'credentials',
+            'password',
+            'passwords',
+            'passwd',
+            'mfa',
+            '2fa',
+            'otp',
+            'apikey',
+        ],
+    },
+    {
+        label: 'payments or money handling',
+        risk: 'high',
+        words: [
+            'billing',
+            'payment',
+            'payments',
+            'pay',
+            'invoice',
+            'invoices',
+            'charge',
+            'charges',
+            'checkout',
+            'stripe',
+            'paypal',
+            'refund',
+            'refunds',
+            'subscription',
+            'subscriptions',
+            'pricing',
+            'price',
+            'prices',
+            'ledger',
+            'wallet',
+            'payout',
+            'payouts',
+            'tax',
+            'taxes',
+        ],
+    },
+    {
+        label: 'secrets or key material',
+        risk: 'high',
+        words: ['secrets'],
+        exactly: ['.npmrc', '.pypirc', '.netrc', 'id_rsa', 'id_ed25519', '.htpasswd', 'credentials'],
+        // `.env`, and every `.env.<suffix>` a project may have invented (staging, ci, local…).
+        prefix: ['.env'],
+    },
+    {
+        label: 'database schema or migration',
+        risk: 'high',
+        words: ['migration', 'migrations', 'schema', 'schemas'],
+    },
+    {
+        label: 'deployment or infrastructure configuration',
+        risk: 'high',
+        words: [
+            'k8s',
+            'kubernetes',
+            'helm',
+            'terraform',
+            'ansible',
+            'manifests',
+            'argocd',
+            'deploy',
+            'deployment',
+            'deployments',
+            'cloudformation',
+        ],
+    },
+    {
+        label: 'a dependency manifest',
+        risk: 'medium',
+        words: [],
+        exactly: [
+            'package.json',
+            'pyproject.toml',
+            'cargo.toml',
+            'requirements.txt',
+            'go.mod',
+            'composer.json',
+            'gemfile',
+            'build.gradle',
+            'pom.xml',
+        ],
+    },
+];
+/** A path's segments, without the empty pieces `split` can leave behind. */
+function segmentsOf(filePath) {
+    return filePath.split('/').filter((s) => s !== '' && s !== '.' && s !== '..');
+}
+/** The words a segment is spelled with: split on separators, lower-cased. */
+function wordsOf(segment) {
+    return segment
+        .toLowerCase()
+        .split(/[^a-z0-9+#@]+/)
+        .filter((w) => w !== '');
+}
+function findConcept(filePath, concepts) {
+    const segments = segmentsOf(filePath);
+    for (const concept of concepts) {
+        for (const seg of segments) {
+            const lower = seg.toLowerCase();
+            if (concept.exactly?.includes(lower))
+                return concept;
+            if (concept.prefix?.some((pre) => lower.startsWith(pre)))
+                return concept;
+            if (concept.words.length && wordsOf(seg).some((w) => concept.words.includes(w)))
+                return concept;
+        }
+    }
+    return null;
+}
+// ── what changed ALONGSIDE it ────────────────────────────────────────────────
+function isTestPath(filePath) {
+    return findConcept(filePath, IDENTITY)?.label === 'a test file';
+}
+function stemOf(filePath) {
+    return node_path_1.default.posix
+        .basename(filePath)
+        .toLowerCase()
+        .replace(/\.(test|spec)\.[a-z0-9]+$/, '')
+        .replace(/\.[a-z0-9]+$/, '')
+        .replace(/^(test_|_test)/, '');
+}
+/**
+ * The test file that covers `filePath`, if the changeset contains one. The changeset having
+ * ANY test file is what makes "no test changed" informative: in a repo with no tests at all
+ * the absence says nothing about any individual file, so it is not reported per file.
+ */
+function coveringTest(filePath, tests) {
+    const stem = stemOf(filePath);
+    if (!stem)
+        return null;
+    const dir = node_path_1.default.posix.dirname(filePath);
+    const sameDir = tests.filter((t) => node_path_1.default.posix.dirname(t.path) === dir && stemOf(t.path) === stem);
+    return sameDir[0] ?? tests.find((t) => stemOf(t.path) === stem) ?? null;
+}
+// ── classifying ──────────────────────────────────────────────────────────────
+/** Churn past which a change stops being reviewable by skimming. */
+exports.LARGE_CHANGE_LINES = 200;
+const rank = (r) => RISK_ORDER.indexOf(r);
+function classifyFile(f, ctx) {
+    const reasons = [];
+    let risk = 'low';
+    const raise = (to, reason) => {
+        reasons.push(reason);
+        if (rank(to) < rank(risk))
+            risk = to;
+    };
+    // The two questions are answered one at a time on purpose: a file that IS a test or a doc
+    // is classified by that alone, so `test/auth.test.ts` is never reported as auth code.
+    const identity = findConcept(f.path, IDENTITY);
+    if (identity) {
+        reasons.push(identity.label);
+    }
+    else {
+        const subject = findConcept(f.path, SUBJECT);
+        if (subject)
+            raise(subject.risk, subject.label);
+    }
+    // These apply to every file, whatever it is: a 900-line doc or test change is still a
+    // lot to read, and an identity of "test file" must not hide a deletion.
+    if (f.status === 'deleted')
+        raise('medium', 'file deleted');
+    if (f.status === 'binary')
+        reasons.push('binary — contents are not shown in a diff');
+    const churn = f.additions + f.deletions;
+    if (churn >= exports.LARGE_CHANGE_LINES)
+        raise('medium', `large change (+${f.additions} −${f.deletions})`);
+    // Pairing a source file with its test only means something for non-test files.
+    if (!identity && f.status !== 'deleted') {
+        const test = coveringTest(f.path, ctx.tests);
+        if (test)
+            reasons.push(`covered by ${test.path}`);
+        else if (ctx.tests.length)
+            raise('medium', 'no test file changed for this');
+    }
+    if (!reasons.length)
+        reasons.push('no path or size signal');
+    return { path: f.path, risk, status: f.status, additions: f.additions, deletions: f.deletions, reasons };
+}
+function buildReviewQueue(files, maxPerGroup = Number.POSITIVE_INFINITY) {
+    const ctx = { tests: files.filter((f) => isTestPath(f.path)) };
+    const reviewed = files.map((f) => classifyFile(f, ctx));
+    const groups = RISK_ORDER.map((risk) => {
+        const inGroup = reviewed
+            .filter((r) => r.risk === risk)
+            // Biggest first: inside a band, the file with the most to read is the one to start
+            // with. Path breaks ties, so the order never depends on `git diff`'s own ordering.
+            .sort((a, b) => b.additions + b.deletions - (a.additions + a.deletions) || a.path.localeCompare(b.path));
+        return { risk, files: inGroup.slice(0, maxPerGroup), total: inGroup.length };
+    }).filter((g) => g.total > 0);
+    return {
+        groups,
+        totals: {
+            files: reviewed.length,
+            additions: reviewed.reduce((n, r) => n + r.additions, 0),
+            deletions: reviewed.reduce((n, r) => n + r.deletions, 0),
+            high: reviewed.filter((r) => r.risk === 'high').length,
+        },
+    };
+}
+// ── rendering ────────────────────────────────────────────────────────────────
+exports.REVIEW_HEADINGS = { high: 'HIGH', medium: 'MEDIUM', low: 'LOW' };
+/** `/review --all` lifts the per-group cap; the default keeps the answer on one screen. */
+exports.DEFAULT_PER_GROUP = 8;
+/**
+ * Below this width the per-file +/- counts are dropped from the rows: at 40 columns the
+ * counts left the reason clipped to "authe…", and the reason is the half that makes the
+ * grouping checkable. The header still carries the totals, so nothing is lost that can't be
+ * had from `/diff`.
+ */
+exports.COUNTS_MIN_COLUMNS = 60;
+/**
+ * Rows for the queue. `columns` is the terminal width the caller measured: lines are clipped
+ * here rather than left to wrap, because a wrapped row reads as a second entry.
+ */
+function formatReviewQueue(q, columns, perGroup = exports.DEFAULT_PER_GROUP) {
+    const { totals } = q;
+    const out = [
+        (0, cellWidth_1.truncateCells)(`${totals.files} changed file${totals.files === 1 ? '' : 's'}, +${totals.additions} −${totals.deletions}` +
+            (totals.high ? `  ·  ${totals.high} needing care` : ''), columns),
+    ];
+    if (!q.groups.length)
+        return out;
+    // A shared name column, so the counts line up; capped so a deep path cannot eat the row.
+    const widest = Math.max(0, ...q.groups.flatMap((g) => g.files.map((f) => (0, cellWidth_1.visibleLen)(f.path))));
+    const nameWidth = Math.min(widest, Math.max(12, Math.floor(columns * 0.45)));
+    const withCounts = columns >= exports.COUNTS_MIN_COLUMNS;
+    for (const g of q.groups) {
+        out.push('', (0, cellWidth_1.truncateCells)(`${exports.REVIEW_HEADINGS[g.risk]}  (${g.total})`, columns));
+        for (const f of g.files) {
+            const name = (0, cellWidth_1.visibleLen)(f.path) > nameWidth ? (0, cellWidth_1.truncateCells)(f.path, nameWidth) : f.path;
+            const counts = f.status === 'binary' ? 'binary' : `+${f.additions} −${f.deletions}`;
+            const left = '  ' + name + ' '.repeat(Math.max(1, nameWidth - (0, cellWidth_1.visibleLen)(name) + 2)) + (withCounts ? counts.padEnd(12) : '');
+            // The reason is what makes the grouping checkable, so it is the part that survives
+            // when the row has to be clipped.
+            out.push((0, cellWidth_1.truncateCells)(left + f.reasons[0], columns));
+        }
+        if (g.total > g.files.length) {
+            out.push((0, cellWidth_1.truncateCells)(`  … ${g.total - g.files.length} more (--all to show)`, columns));
+        }
+    }
+    return out;
+}
+/** Everything the queue knows about one file — `/review <path>`. */
+function formatReviewDetail(r, columns) {
+    const out = [
+        (0, cellWidth_1.truncateCells)(`${r.path}  [${exports.REVIEW_HEADINGS[r.risk]}]`, columns),
+        (0, cellWidth_1.truncateCells)(`  ${r.status === 'binary' ? 'binary' : `+${r.additions} −${r.deletions}`}  ·  ${r.status}`, columns),
+        '',
+        '  why:',
+    ];
+    for (const reason of r.reasons)
+        out.push((0, cellWidth_1.truncateCells)('    · ' + reason, columns));
+    return out;
+}
+//# sourceMappingURL=reviewQueue.js.map