@kabmo-labs/kabmo 0.0.0-stage → 0.1.0

package/src/shared/lib/fs/document-kind.test.ts

@@ -0,0 +1,189 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The viewer dispatch and the CSV grid parser.
+ *
+ * Both are pure, and both have a decision that fails silently if wrong: a file
+ * sent to the wrong viewer renders a refusal or a blank surface, and a CSV
+ * parsed without quote handling splits one row into three the moment a cell
+ * contains a comma — the exact file a user opens the grid to read.
+ */
+
+import { describe, expect, test } from 'bun:test';
+import { BINARY_VIEWERS, RENDERED_VIEWERS, VIEWER_LABELS, viewerKindFor, type ViewerKind } from '@/shared/lib/fs/document-kind';
+import { MAX_CSV_COLUMNS, MAX_CSV_ROWS, parseCsv, sniffDelimiter } from '@/shared/lib/fs/csv';
+
+describe('viewerKindFor', () => {
+  test('each family maps to its viewer', () => {
+    expect(viewerKindFor('a.md')).toBe('markdown');
+    expect(viewerKindFor('a.markdown')).toBe('markdown');
+    expect(viewerKindFor('a.csv')).toBe('csv');
+    expect(viewerKindFor('a.tsv')).toBe('csv');
+    expect(viewerKindFor('a.png')).toBe('image');
+    expect(viewerKindFor('a.pdf')).toBe('pdf');
+    expect(viewerKindFor('a.docx')).toBe('docx');
+    expect(viewerKindFor('a.xlsx')).toBe('spreadsheet');
+    expect(viewerKindFor('a.xlsm')).toBe('spreadsheet');
+  });
+
+  // SVG is a picture to the eye while its bytes are editable XML text, and
+  // `file-kind` deliberately keeps it on the TEXT path. The viewer must still
+  // route it to the SVG surface, or the eye toggle has nothing to toggle.
+  test('svg is its own viewer, not an image or code', () => {
+    expect(viewerKindFor('logo.svg')).toBe('svg');
+  });
+
+  test('an unrecognised or missing extension is code', () => {
+    expect(viewerKindFor('a.ts')).toBe('code');
+    expect(viewerKindFor('Makefile')).toBe('code');
+    expect(viewerKindFor('')).toBe('code');
+    expect(viewerKindFor(undefined)).toBe('code');
+  });
+
+  // `.xls` is the legacy OLE2 binary the reader refuses outright. Routing it to
+  // the sheet viewer would show a parse error; the honest answer is the code
+  // path's "not text" refusal.
+  test('legacy .xls is not claimed by the sheet viewer', () => {
+    expect(viewerKindFor('legacy.xls')).toBe('code');
+  });
+
+  test('the uppercase extension is recognised', () => {
+    expect(viewerKindFor('REPORT.PDF')).toBe('pdf');
+    expect(viewerKindFor('Data.XLSX')).toBe('spreadsheet');
+  });
+
+  test('every kind has a row in both lookup tables', () => {
+    const kinds: ViewerKind[] = ['code', 'markdown', 'svg', 'csv', 'image', 'pdf', 'docx', 'spreadsheet'];
+    for (const kind of kinds) {
+      expect(kind in BINARY_VIEWERS).toBe(true);
+      expect(kind in RENDERED_VIEWERS).toBe(true);
+      // The status strip's word has to exist for every kind too, or a byte
+      // viewer's footer prints `undefined` where the viewer's name belongs.
+      expect(VIEWER_LABELS[kind].length).toBeGreaterThan(0);
+    }
+    // The binary viewers are exactly the byte-fetching ones, so a new kind
+    // cannot be added to one table and forgotten in the other.
+    expect(BINARY_VIEWERS.pdf).toBe(true);
+    expect(BINARY_VIEWERS.image).toBe(true);
+    expect(BINARY_VIEWERS.csv).toBeUndefined();
+    expect(RENDERED_VIEWERS.csv).toBe(true);
+    expect(RENDERED_VIEWERS.pdf).toBeUndefined();
+    // A byte viewer's label is its document kind, never the language badge the
+    // empty buffer would otherwise produce.
+    expect(VIEWER_LABELS.pdf).toBe('PDF');
+    expect(VIEWER_LABELS.code).toBe('Text');
+  });
+});
+
+describe('sniffDelimiter', () => {
+  test('a .tsv extension wins outright', () => {
+    expect(sniffDelimiter('a,b,c', 'x.tsv')).toBe('\t');
+  });
+
+  test('more tabs than commas on the first line means tab-delimited', () => {
+    expect(sniffDelimiter('a\tb\tc\n1\t2\t3')).toBe('\t');
+  });
+
+  test('a plain CSV is comma-delimited', () => {
+    expect(sniffDelimiter('a,b,c\n1,2,3')).toBe(',');
+  });
+
+  // A quoted field may contain the OTHER delimiter, and counting it would flip
+  // the guess: `"a,b",c,d` has two commas and one tab-like field but is a CSV.
+  test('a delimiter inside a quoted field is not counted', () => {
+    expect(sniffDelimiter('"a\tb",c,d')).toBe(',');
+  });
+});
+
+describe('parseCsv', () => {
+  test('the first row is the header and the rest are data', () => {
+    const table = parseCsv('Name,Qty\nWidget,3\nGadget,1');
+    expect(table.header).toEqual(['Name', 'Qty']);
+    expect(table.rows).toEqual([
+      ['Widget', '3'],
+      ['Gadget', '1'],
+    ]);
+    expect(table.truncated).toBe(false);
+  });
+
+  // The failure this parser exists to prevent: a quoted cell holding the
+  // delimiter must stay ONE cell, not split the row.
+  test('a quoted field keeps its delimiter, newline and doubled quote', () => {
+    const table = parseCsv('a,b\n"x,y","line1\nline2"\n"he said ""hi""",z');
+    expect(table.rows[0]).toEqual(['x,y', 'line1\nline2']);
+    expect(table.rows[1]).toEqual(['he said "hi"', 'z']);
+  });
+
+  test('a trailing newline does not create an empty row', () => {
+    const table = parseCsv('a,b\n1,2\n');
+    expect(table.rows).toEqual([['1', '2']]);
+  });
+
+  test('CRLF row endings are handled', () => {
+    const table = parseCsv('a,b\r\n1,2\r\n3,4');
+    expect(table.header).toEqual(['a', 'b']);
+    expect(table.rows).toEqual([
+      ['1', '2'],
+      ['3', '4'],
+    ]);
+  });
+
+  // A ragged file would otherwise shift every cell after the short row, which
+  // is what makes a grid unreadable.
+  test('a short row is padded to the header width', () => {
+    const table = parseCsv('a,b,c\n1,2\n3,4,5');
+    expect(table.rows[0]).toEqual(['1', '2', '']);
+    expect(table.rows[1]).toEqual(['3', '4', '5']);
+  });
+
+  test('a long row is trimmed to the header width', () => {
+    const table = parseCsv('a,b\n1,2,3,4');
+    expect(table.rows[0]).toEqual(['1', '2']);
+  });
+
+  test('a tab file is parsed with tabs, whatever the extension', () => {
+    const table = parseCsv('a\tb\n1\t2', 'data.tsv');
+    expect(table.header).toEqual(['a', 'b']);
+    expect(table.rows).toEqual([['1', '2']]);
+  });
+
+  test('a file with only a header has no rows', () => {
+    const table = parseCsv('a,b,c');
+    expect(table.header).toEqual(['a', 'b', 'c']);
+    expect(table.rows).toEqual([]);
+  });
+
+  test('an empty file yields an empty table', () => {
+    const table = parseCsv('');
+    expect(table.header).toEqual([]);
+    expect(table.rows).toEqual([]);
+  });
+
+  // The caps are what keep a grid from mounting a table the browser cannot lay
+  // out; crossing either must be REPORTED, not silently short.
+  test('a file past the row cap is truncated and says so', () => {
+    const lines = ['h'];
+    for (let i = 0; i < MAX_CSV_ROWS + 10; i += 1) lines.push(String(i));
+    const table = parseCsv(lines.join('\n'));
+    expect(table.truncated).toBe(true);
+    expect(table.rows.length).toBe(MAX_CSV_ROWS - 1);
+  });
+
+  test('a row past the column cap is cut, and the header too', () => {
+    const wide = Array.from({ length: MAX_CSV_COLUMNS + 5 }, (_, i) => `c${i}`).join(',');
+    const table = parseCsv(`${wide}\n${wide}`);
+    expect(table.header.length).toBe(MAX_CSV_COLUMNS);
+    expect(table.rows[0].length).toBe(MAX_CSV_COLUMNS);
+  });
+
+  test('a file exactly at the row cap is not truncated', () => {
+    const lines = ['h'];
+    for (let i = 0; i < MAX_CSV_ROWS - 1; i += 1) lines.push(String(i));
+    const table = parseCsv(lines.join('\n'));
+    expect(table.truncated).toBe(false);
+    expect(table.rows.length).toBe(MAX_CSV_ROWS - 1);
+  });
+});

package/src/shared/lib/fs/document-kind.ts

@@ -0,0 +1,136 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Which VIEWER a file gets, derived from its path alone.
+ *
+ * Separate from `file-kind` on purpose: that module answers "can the editor
+ * open this at all?" (text, image, binary, too large) and is the gate the
+ * server routes apply. This one answers "and which surface draws it?", which
+ * only the client asks. Keeping them apart means the read route never has to
+ * know that a `.csv` is rendered as a grid, and the grid never has to know how
+ * a file was classified.
+ *
+ * Every table here is data with a rule that reads it, never a chain of `if`s at
+ * a call site: a new viewer is a row, and the three surfaces that dispatch on
+ * the answer (the desktop pane, the phone's full-screen editor, the toolbar's
+ * eye button) all read the same tables, so they cannot disagree about which
+ * file has a rendered form.
+ */
+
+import { getFileExtension, getImageMimeType } from '@/shared/lib/fs/file-kind';
+
+/**
+ * The surface that draws a file.
+ *
+ * `code` is the fallback: the syntax-highlighted text surface, which is what
+ * every unrecognised extension gets.
+ */
+export type ViewerKind =
+  | 'code'
+  | 'markdown'
+  | 'svg'
+  | 'csv'
+  | 'image'
+  | 'pdf'
+  | 'docx'
+  | 'spreadsheet';
+
+/** Word-processing documents mammoth reads. */
+const DOCX_EXTENSIONS: Record<string, true> = { docx: true };
+
+/**
+ * Workbooks `read-excel-file` reads. `.xls` is deliberately absent: it is the
+ * legacy OLE2 binary format, the reader refuses it outright with
+ * `XLS_FILE_NOT_SUPPORTED`, and offering the viewer would produce a parse error
+ * where the honest answer is "not text, cannot be shown here".
+ */
+const SHEET_EXTENSIONS: Record<string, true> = { xlsx: true, xlsm: true };
+
+/** Delimited text rendered as a grid. */
+const CSV_EXTENSIONS: Record<string, true> = { csv: true, tsv: true };
+
+/** Markdown, whose preview is the rendered document. */
+const MARKDOWN_EXTENSIONS: Record<string, true> = { md: true, markdown: true, mdx: true };
+
+/**
+ * A viewer that draws BYTES rather than a text buffer.
+ *
+ * The editor keeps no buffer and offers no Save for these: the bytes are
+ * fetched (or read from the tab's live handle) and painted, so a write would
+ * have nothing to write from. `image` is here because it already worked this
+ * way — this is the generalisation, not a second rule.
+ */
+export const BINARY_VIEWERS: Record<ViewerKind, true | undefined> = {
+  image: true,
+  pdf: true,
+  docx: true,
+  spreadsheet: true,
+  code: undefined,
+  markdown: undefined,
+  svg: undefined,
+  csv: undefined,
+};
+
+/**
+ * A viewer with a source ⇄ rendered toggle, which is the toolbar's eye button.
+ *
+ * `csv` is here even though it has no separate "source" surface: the grid IS
+ * the preview and the raw text is the code surface, which is exactly the pair
+ * the toggle switches between. `image` and the document kinds are not — they
+ * have no text form to toggle to.
+ */
+export const RENDERED_VIEWERS: Record<ViewerKind, true | undefined> = {
+  markdown: true,
+  svg: true,
+  csv: true,
+  code: undefined,
+  image: undefined,
+  pdf: undefined,
+  docx: undefined,
+  spreadsheet: undefined,
+};
+
+/**
+ * The word a status strip prints for a viewer kind.
+ *
+ * The phone's footer reads this instead of the language badge, because a byte
+ * viewer has no text buffer: a PDF drawn in an iframe reported `TEXT · 1 lines ·
+ * 0 chars` — the empty buffer's statistics describing a document that is not
+ * text at all. The desktop pane has no such strip, so this label exists for the
+ * surface that does.
+ */
+export const VIEWER_LABELS: Record<ViewerKind, string> = {
+  code: 'Text',
+  markdown: 'Markdown',
+  svg: 'SVG',
+  csv: 'CSV',
+  image: 'Image',
+  pdf: 'PDF',
+  docx: 'Document',
+  spreadsheet: 'Spreadsheet',
+};
+
+/**
+ * The viewer for a path.
+ *
+ * Order is load-bearing in one place: `svg` is checked before the raster-image
+ * table, because an SVG is a picture to the eye while its bytes are editable
+ * XML text — and `file-kind` deliberately leaves it on the text path for that
+ * reason. The viewer still renders it as a picture; the eye toggle is what
+ * gives the source back.
+ */
+export function viewerKindFor(filePath: string | undefined | null): ViewerKind {
+  const ext = getFileExtension(filePath);
+  if (!ext) return 'code';
+  if (ext === 'svg') return 'svg';
+  if (MARKDOWN_EXTENSIONS[ext]) return 'markdown';
+  if (getImageMimeType(filePath)) return 'image';
+  if (ext === 'pdf') return 'pdf';
+  if (DOCX_EXTENSIONS[ext]) return 'docx';
+  if (SHEET_EXTENSIONS[ext]) return 'spreadsheet';
+  if (CSV_EXTENSIONS[ext]) return 'csv';
+  return 'code';
+}

package/src/shared/lib/fs/excerpt-diff.test.ts

@@ -0,0 +1,130 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * omp's excerpt diff is not a unified diff, and a unified-diff renderer paints
+ * its `-43|` gutter as code — measured in the browser, the number survived into
+ * the code cell and the header named a path called `diff`.
+ *
+ * These pin the conversion in both directions: the gutter is stripped, the
+ * numbers come back as `oldLine`/`newLine`, and the classification refuses to
+ * mistake a real unified diff (or a git-format one) for an excerpt.
+ */
+
+import { describe, expect, test } from 'bun:test';
+import {
+  excerptDiffStats,
+  excerptDiffToUnified,
+  isExcerptDiff,
+  parseExcerptDiff,
+} from '@/shared/lib/fs/excerpt-diff';
+
+/** Verbatim from a real `edit` toolResult (`details.diff`). */
+const EXCERPT = [
+  ' 41|',
+  ' 42|function readEntryFile(entry: FileSystemFileEntry): Promise<File | null> {',
+  '-43|  return new Promise((resolve) => entry.file(resolve, () => resolve(null)));',
+  '+43|  const { promise, resolve } = Promise.withResolvers<File | null>();',
+  '+44|  entry.file(resolve, () => resolve(null));',
+  ' 45|}',
+].join('\n');
+
+const UNIFIED = [
+  'diff --git a/x.ts b/x.ts',
+  'index 111..222 100644',
+  '--- a/x.ts',
+  '+++ b/x.ts',
+  '@@ -41,3 +41,4 @@',
+  ' context',
+  '-old',
+  '+new',
+].join('\n');
+
+describe('isExcerptDiff', () => {
+  test('recognizes omp excerpt rows', () => {
+    expect(isExcerptDiff(EXCERPT)).toBe(true);
+  });
+
+  test('refuses a git unified diff', () => {
+    expect(isExcerptDiff(UNIFIED)).toBe(false);
+  });
+
+  test('refuses a headerless unified diff', () => {
+    expect(isExcerptDiff('@@ -1,2 +1,2 @@\n-a\n+b')).toBe(false);
+  });
+
+  test('refuses free text with no gutter', () => {
+    expect(isExcerptDiff('Applied 3 replacements\nDone.')).toBe(false);
+  });
+
+  test('refuses an empty payload', () => {
+    expect(isExcerptDiff('')).toBe(false);
+  });
+});
+
+describe('parseExcerptDiff', () => {
+  test('strips the gutter and classifies each row', () => {
+    const rows = parseExcerptDiff(EXCERPT);
+    expect(rows.map((row) => row.type)).toEqual(['context', 'context', 'del', 'add', 'add', 'context']);
+    // The bug: the gutter used to stay welded to the code.
+    expect(rows[2].text).toBe('  return new Promise((resolve) => entry.file(resolve, () => resolve(null)));');
+    expect(rows[3].text).toBe('  const { promise, resolve } = Promise.withResolvers<File | null>();');
+  });
+
+  test('recovers the file line numbers the gutter carried', () => {
+    const rows = parseExcerptDiff(EXCERPT);
+    expect(rows[2]).toMatchObject({ type: 'del', oldLine: 43 });
+    expect(rows[3]).toMatchObject({ type: 'add', newLine: 43 });
+    expect(rows[5]).toMatchObject({ type: 'context', oldLine: 45, newLine: 45 });
+  });
+
+  test('keeps a bare blank-line row as an empty context row', () => {
+    const rows = parseExcerptDiff(' 12|');
+    expect(rows).toEqual([{ type: 'context', text: '', oldLine: 12, newLine: 12 }]);
+  });
+
+  test('keeps an elision marker as meta rather than dropping it', () => {
+    const rows = parseExcerptDiff([' 1|a', '…', ' 9|b'].join('\n'));
+    expect(rows.map((row) => row.type)).toEqual(['context', 'meta', 'context']);
+    expect(rows[1].text).toBe('…');
+  });
+
+  test('never drops an unparsable line', () => {
+    const rows = parseExcerptDiff([' 1|a', 'Could not find a close enough match', ' 2|b'].join('\n'));
+    expect(rows).toHaveLength(3);
+    expect(rows[1]).toMatchObject({ type: 'meta', text: 'Could not find a close enough match' });
+  });
+});
+
+describe('excerptDiffToUnified', () => {
+  test('emits a hunk header whose counts match the rows', () => {
+    const unified = excerptDiffToUnified(EXCERPT);
+    const [header] = unified.split('\n');
+    // 4 rows exist in the old file (3 context + 1 del), 5 in the new.
+    expect(header).toBe('@@ -41,4 +41,5 @@');
+  });
+
+  test('emits standard markers a unified renderer can read', () => {
+    const body = excerptDiffToUnified(EXCERPT).split('\n').slice(1);
+    expect(body).toContain('-  return new Promise((resolve) => entry.file(resolve, () => resolve(null)));');
+    expect(body).toContain('+  const { promise, resolve } = Promise.withResolvers<File | null>();');
+    // No gutter survives anywhere.
+    expect(excerptDiffToUnified(EXCERPT)).not.toContain('43|');
+  });
+
+  test('falls back to the input when there is nothing to convert', () => {
+    expect(excerptDiffToUnified('')).toBe('');
+  });
+});
+
+describe('excerptDiffStats', () => {
+  test('counts added and removed rows', () => {
+    expect(excerptDiffStats(EXCERPT)).toEqual({ added: 2, removed: 1 });
+  });
+
+  test('counts nothing for context-only input', () => {
+    expect(excerptDiffStats(' 1|a\n 2|b')).toEqual({ added: 0, removed: 0 });
+  });
+});

package/src/shared/lib/fs/excerpt-diff.ts

@@ -0,0 +1,127 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * omp's excerpt diff → a unified diff.
+ *
+ * The diff omp puts on an `edit` result's `details.diff` is NOT unified: every
+ * row carries the file's own line number as a gutter, and a change is marked by
+ * a sign in front of that number rather than at the start of the line.
+ *
+ *   ' 41|'                          context
+ *   '-43|  return new Promise(…);'  removed
+ *   '+43|  const { promise, … };'   added
+ *
+ * Rendered by a unified-diff parser that gutter is simply code: the row reads
+ * `-43|  return …` and the line numbers the reader needs are inside the text
+ * they are trying to read (measured in the browser: the `43|` prefix survived
+ * into the code cell). This module drops the gutter and emits the standard
+ * shape, so ONE parser and ONE renderer serve both omp's excerpt and git's own
+ * unified diff.
+ *
+ * The gutter numbers are also recovered as `oldLine`/`newLine`, which is what
+ * lets the renderer draw real line numbers instead of `...`.
+ */
+
+export interface ExcerptDiffLine {
+  type: 'add' | 'del' | 'context' | 'meta';
+  text: string;
+  /** Line number in the pre-change file, when the row has one. */
+  oldLine?: number;
+  /** Line number in the post-change file, when the row has one. */
+  newLine?: number;
+}
+
+/** `-43|text` / `+43|text` / ` 43|text` — sign, line number, bar, content. */
+const ROW_RE = /^([-+ ]?)\s*(\d+)\|(.*)$/;
+/** A bare gutter row omp prints for a blank line: `' 44|'`. */
+const BARE_ROW_RE = /^([-+ ]?)\s*(\d+)\|$/;
+
+/**
+ * True when `text` looks like omp's excerpt diff rather than a unified one.
+ *
+ * Both shapes contain `+`/`-` rows, so the test has to be positive: a unified
+ * diff opens with `---`/`+++`/`@@` headers, and an excerpt carries neither.
+ * Getting this wrong in either direction is silent — a misclassified unified
+ * diff would have its `-`/`+` signs eaten, and a misclassified excerpt would
+ * keep rendering its gutter as code.
+ */
+export function isExcerptDiff(text: string): boolean {
+  const lines = text.split(/\r?\n/).filter((line) => line.trim() !== '');
+  if (lines.length === 0) return false;
+  for (const line of lines) {
+    if (line.startsWith('---') || line.startsWith('+++') || line.startsWith('@@') || line.startsWith('diff --git')) {
+      return false;
+    }
+  }
+  // At least one row must carry the gutter, or this is something else entirely.
+  return lines.some((line) => ROW_RE.test(line) || BARE_ROW_RE.test(line));
+}
+
+/**
+ * Parse an omp excerpt diff into typed rows. Every row of the input becomes one
+ * row of the output — an unparsable line is kept as context text rather than
+ * dropped, because a reader losing a line is worse than a reader seeing one
+ * unlabelled.
+ */
+export function parseExcerptDiff(text: string): ExcerptDiffLine[] {
+  const out: ExcerptDiffLine[] = [];
+  for (const raw of text.split(/\r?\n/)) {
+    const bare = BARE_ROW_RE.exec(raw);
+    if (bare) {
+      out.push(rowFor(bare[1], Number(bare[2]), ''));
+      continue;
+    }
+    const match = ROW_RE.exec(raw);
+    if (!match) {
+      // Not a gutter row: an elision marker (`…`), a note, or a stray blank.
+      if (raw.trim() === '') continue;
+      out.push({ type: 'meta', text: raw });
+      continue;
+    }
+    out.push(rowFor(match[1], Number(match[2]), match[3]));
+  }
+  return out;
+}
+
+function rowFor(sign: string, lineNumber: number, content: string): ExcerptDiffLine {
+  if (sign === '-') return { type: 'del', text: content, oldLine: lineNumber };
+  if (sign === '+') return { type: 'add', text: content, newLine: lineNumber };
+  return { type: 'context', text: content, oldLine: lineNumber, newLine: lineNumber };
+}
+
+/**
+ * A standard unified diff for a renderer that only speaks that dialect.
+ *
+ * The excerpt has no hunk header of its own, so one is synthesized for the
+ * whole run: a reader of the unified form needs the `@@` line to know the rows
+ * belong together, and the counts must match the rows actually emitted.
+ */
+export function excerptDiffToUnified(text: string): string {
+  const rows = parseExcerptDiff(text);
+  if (rows.length === 0) return text;
+  const oldLines = rows.filter((row) => row.type !== 'add').length;
+  const newLines = rows.filter((row) => row.type !== 'del').length;
+  const firstOld = rows.find((row) => row.oldLine !== undefined)?.oldLine ?? 1;
+  const firstNew = rows.find((row) => row.newLine !== undefined)?.newLine ?? 1;
+  const body = rows.map((row) => {
+    if (row.type === 'add') return `+${row.text}`;
+    if (row.type === 'del') return `-${row.text}`;
+    if (row.type === 'meta') return ` ${row.text}`;
+    return ` ${row.text}`;
+  });
+  return [`@@ -${firstOld},${oldLines} +${firstNew},${newLines} @@`, ...body].join('\n');
+}
+
+/** Added/removed row counts, for a card that wants the change size without parsing. */
+export function excerptDiffStats(text: string): { added: number; removed: number } {
+  let added = 0;
+  let removed = 0;
+  for (const row of parseExcerptDiff(text)) {
+    if (row.type === 'add') added++;
+    else if (row.type === 'del') removed++;
+  }
+  return { added, removed };
+}