@celljs/ta-web 0.0.0-stage → 4.6.1

package/src/browser/util/markdown.spec.ts

@@ -0,0 +1,133 @@
+import { describe, expect, it } from 'bun:test';
+import { MarkdownUtil } from './markdown';
+
+describe('MarkdownUtil', () => {
+    it('splits blocks: headings, fenced code, lists, quotes, rules and paragraphs', () => {
+        const blocks = MarkdownUtil.blocks(
+            ['# Title', '', 'Some *text*', 'goes on', '', '```ts', 'const a = 1;', '```', '- one', '- two', '1. first', '> quoted', '---'].join('\n'),
+        );
+        expect(blocks).toEqual([
+            { type: 'heading', level: 1, text: 'Title' },
+            { type: 'paragraph', text: 'Some *text*\ngoes on' },
+            { type: 'code', language: 'ts', code: 'const a = 1;' },
+            { type: 'list', ordered: false, items: ['one', 'two'] },
+            { type: 'list', ordered: true, items: ['first'] },
+            { type: 'quote', text: 'quoted' },
+            { type: 'rule' },
+        ]);
+    });
+
+    it('runs an unclosed fence to the end, as while a reply streams', () => {
+        expect(MarkdownUtil.blocks('```js\nlet x')).toEqual([{ type: 'code', language: 'js', code: 'let x' }]);
+    });
+
+    it('reads tables', () => {
+        expect(MarkdownUtil.blocks('| a | b |\n|---|:-:|\n| 1 | 2 |')).toEqual([{ type: 'table', header: ['a', 'b'], rows: [['1', '2']] }]);
+    });
+
+    it('parses emphasis, code spans and links inside a block', () => {
+        expect(MarkdownUtil.inline('a **b** *c* `d*e` [f](https://x.dev)')).toEqual([
+            { type: 'text', text: 'a ' },
+            { type: 'strong', children: [{ type: 'text', text: 'b' }] },
+            { type: 'text', text: ' ' },
+            { type: 'em', children: [{ type: 'text', text: 'c' }] },
+            { type: 'text', text: ' ' },
+            { type: 'code', text: 'd*e' },
+            { type: 'text', text: ' ' },
+            { type: 'link', href: 'https://x.dev', children: [{ type: 'text', text: 'f' }] },
+        ]);
+    });
+
+    it('keeps only safe link targets, and underscores inside words', () => {
+        expect(MarkdownUtil.inline('[x](javascript:alert)')).toEqual([{ type: 'text', text: 'x' }]);
+        expect(MarkdownUtil.inline('[x](data:text/html,hi)')).toEqual([{ type: 'text', text: 'x' }]);
+        expect(MarkdownUtil.inline('[x](command:reload)')).toEqual([{ type: 'text', text: 'x' }]);
+        expect(MarkdownUtil.inline('[x](javascript:alert(1))。')).toEqual([{ type: 'text', text: 'x。' }]);
+        expect(MarkdownUtil.inline('[A](https://en.wikipedia.org/wiki/A_(b))')).toEqual([
+            { type: 'link', href: 'https://en.wikipedia.org/wiki/A_(b)', children: [{ type: 'text', text: 'A' }] },
+        ]);
+        expect(MarkdownUtil.inline('[a](src/a.ts#L3) [b](<docs/my notes.md>)')).toEqual([
+            { type: 'link', href: 'src/a.ts#L3', children: [{ type: 'text', text: 'a' }] },
+            { type: 'text', text: ' ' },
+            { type: 'link', href: 'docs/my notes.md', children: [{ type: 'text', text: 'b' }] },
+        ]);
+        expect(MarkdownUtil.inline('snake_case_name')).toEqual([{ type: 'text', text: 'snake_case_name' }]);
+    });
+
+    it('makes links of URLs in the text, and of <URL>', () => {
+        expect(MarkdownUtil.inline('see https://x.dev/a. or <http://localhost:3000>')).toEqual([
+            { type: 'text', text: 'see ' },
+            { type: 'link', href: 'https://x.dev/a', children: [{ type: 'text', text: 'https://x.dev/a' }] },
+            { type: 'text', text: '. or ' },
+            { type: 'link', href: 'http://localhost:3000', children: [{ type: 'text', text: 'http://localhost:3000' }] },
+        ]);
+        expect(MarkdownUtil.inline('打开 https://x.dev，然后')).toMatchObject([{ text: '打开 ' }, { type: 'link', href: 'https://x.dev' }, { text: '，然后' }]);
+        // Inside a word or a path, and in code, it stays text.
+        expect(MarkdownUtil.inline('xhttps://x.dev')).toEqual([{ type: 'text', text: 'xhttps://x.dev' }]);
+        expect(MarkdownUtil.inline('`https://x.dev`')).toEqual([{ type: 'code', text: 'https://x.dev' }]);
+    });
+
+    it('reads formulas on lines of their own: $$, \\[ \\] and math fences, unclosed while they stream', () => {
+        expect(MarkdownUtil.blocks('Euler:\n$$\ne^{i\\pi} + 1 = 0\n$$\nafter')).toEqual([
+            { type: 'paragraph', text: 'Euler:' },
+            { type: 'math', tex: 'e^{i\\pi} + 1 = 0', closed: true },
+            { type: 'paragraph', text: 'after' },
+        ]);
+        expect(MarkdownUtil.blocks('$$ a^2 $$')).toEqual([{ type: 'math', tex: 'a^2', closed: true }]);
+        expect(MarkdownUtil.blocks('\\[\nx = 1\n\\]')).toEqual([{ type: 'math', tex: 'x = 1', closed: true }]);
+        expect(MarkdownUtil.blocks('```math\n\\sum_i x_i\n```')).toEqual([{ type: 'math', tex: '\\sum_i x_i', closed: true }]);
+        expect(MarkdownUtil.blocks('$$\n\\frac{1}{')).toEqual([{ type: 'math', tex: '\\frac{1}{', closed: false }]);
+        expect(MarkdownUtil.blocks('```math\nx')).toEqual([{ type: 'math', tex: 'x', closed: false }]);
+        // Text after the closing $$ makes it inline math of a paragraph.
+        expect(MarkdownUtil.blocks('$$x$$ is x')[0].type).toBe('paragraph');
+    });
+
+    it('reads inline formulas, and leaves prices and escaped dollars as text', () => {
+        expect(MarkdownUtil.inline('so $a+b$ and \\(c\\) or $$d$$ and \\[e\\]')).toEqual([
+            { type: 'text', text: 'so ' },
+            { type: 'math', tex: 'a+b', display: false },
+            { type: 'text', text: ' and ' },
+            { type: 'math', tex: 'c', display: false },
+            { type: 'text', text: ' or ' },
+            { type: 'math', tex: 'd', display: true },
+            { type: 'text', text: ' and ' },
+            { type: 'math', tex: 'e', display: true },
+        ]);
+        expect(MarkdownUtil.inline('costs $5 and $10')).toEqual([{ type: 'text', text: 'costs $5 and $10' }]);
+        expect(MarkdownUtil.inline('\\$x\\$ and \\*y\\*')).toEqual([{ type: 'text', text: '$x$ and *y*' }]);
+        expect(MarkdownUtil.inline('`$x$`')).toEqual([{ type: 'code', text: '$x$' }]);
+    });
+
+    it('reads images and videos: from the web, data URLs and files of the workspace', () => {
+        expect(MarkdownUtil.inline('![chart](https://x.dev/a.png) ![](<out/demo clip.mp4>) ![x](data:image/png;base64,AA==)')).toEqual([
+            { type: 'media', src: 'https://x.dev/a.png', alt: 'chart' },
+            { type: 'text', text: ' ' },
+            { type: 'media', src: 'out/demo clip.mp4', alt: '' },
+            { type: 'text', text: ' ' },
+            { type: 'media', src: 'data:image/png;base64,AA==', alt: 'x' },
+        ]);
+        expect(MarkdownUtil.inline('![x](javascript:alert(1))')).toEqual([{ type: 'text', text: 'x)' }]);
+        expect(MarkdownUtil.inline('![x](data:text/html,hi)')).toEqual([{ type: 'text', text: 'x' }]);
+        // A link to a picture or a video of the workspace shows it; to other files it is a link to open.
+        expect(MarkdownUtil.inline('[shot](out/shot.png) [notes](docs/notes.md)')).toEqual([
+            { type: 'media', src: 'out/shot.png', alt: 'shot' },
+            { type: 'text', text: ' ' },
+            { type: 'link', href: 'docs/notes.md', children: [{ type: 'text', text: 'notes' }] },
+        ]);
+    });
+
+    it('tells what a target shows and which file it names', () => {
+        expect(MarkdownUtil.media('https://x.dev/v.webm?t=1')).toBe('video');
+        expect(MarkdownUtil.media('https://x.dev/image')).toBe('image');
+        expect(MarkdownUtil.media('a/b.MP3')).toBe('audio');
+        expect(MarkdownUtil.media('data:video/mp4;base64,AA')).toBe('video');
+        expect(MarkdownUtil.media('docs/a.md', false)).toBeUndefined();
+        expect(MarkdownUtil.media('mailto:a@b.c')).toBeUndefined();
+        expect(MarkdownUtil.localPath('file:///tmp/a%20b.png')).toBe('/tmp/a b.png');
+        expect(MarkdownUtil.localPath('file://localhost/tmp/a.png')).toBe('/tmp/a.png');
+        expect(MarkdownUtil.localPath('file://host/tmp/a.png')).toBeUndefined();
+        expect(MarkdownUtil.localPath('./img/a.png#x')).toBe('./img/a.png');
+        expect(MarkdownUtil.localPath('https://x.dev/a.png')).toBeUndefined();
+        expect(MarkdownUtil.localPath('//x.dev/a.png')).toBeUndefined();
+    });
+});

package/src/browser/util/markdown.ts

@@ -0,0 +1,347 @@
+import { LinkUtil } from './link';
+
+/** A block of markdown. */
+export type MarkdownBlock =
+    | { type: 'paragraph'; text: string }
+    | { type: 'heading'; level: number; text: string }
+    | { type: 'code'; language: string; code: string }
+    | { type: 'quote'; text: string }
+    | { type: 'list'; ordered: boolean; items: string[] }
+    | { type: 'table'; header: string[]; rows: string[][] }
+    /** TeX shown on a line of its own; not `closed` while a reply streams it. */
+    | { type: 'math'; tex: string; closed: boolean }
+    | { type: 'rule' };
+
+/** A run of text inside a block. */
+export type MarkdownInline =
+    | { type: 'text'; text: string }
+    | { type: 'code'; text: string }
+    | { type: 'strong'; children: MarkdownInline[] }
+    | { type: 'em'; children: MarkdownInline[] }
+    /** `href` as written; LinkUtil.parse tells what it opens. */
+    | { type: 'link'; href: string; children: MarkdownInline[] }
+    | { type: 'math'; tex: string; display: boolean }
+    /** An image, a video or a sound: what the target is tells which (MarkdownUtil.media). */
+    | { type: 'media'; src: string; alt: string };
+
+/** What a target of `![...](...)` shows. */
+export type MediaKind = 'image' | 'video' | 'audio';
+
+const FENCE = /^\s*(`{3,}|~{3,})\s*([\w+-]*)/;
+const HEADING = /^(#{1,6})\s+(.*)$/;
+const RULE = /^\s*([-*_])(\s*\1){2,}\s*$/;
+const BULLET = /^\s*[-*+]\s+(.*)$/;
+const NUMBERED = /^\s*\d+[.)]\s+(.*)$/;
+const TABLE_SEPARATOR = /^\s*\|?\s*:?-+:?\s*(\|\s*:?-+:?\s*)*\|?\s*$/;
+const SCHEME = /^[a-z][a-z\d+.-]*:/i;
+/** Data URLs of media, which show without a request; scripts in an SVG image do not run. */
+const DATA_MEDIA = /^data:(image|video|audio)\/[\w.+-]+[;,]/i;
+const EXTENSIONS: Record<string, MediaKind> = {
+    png: 'image',
+    jpg: 'image',
+    jpeg: 'image',
+    gif: 'image',
+    webp: 'image',
+    avif: 'image',
+    svg: 'image',
+    bmp: 'image',
+    ico: 'image',
+    mp4: 'video',
+    m4v: 'video',
+    webm: 'video',
+    mov: 'video',
+    ogv: 'video',
+    mp3: 'audio',
+    m4a: 'audio',
+    wav: 'audio',
+    ogg: 'audio',
+    oga: 'audio',
+    flac: 'audio',
+    aac: 'audio',
+};
+const IMAGE = /^!\[([^\]]*)\]\(\s*(?:<([^>]+)>|([^)\s]+))(?:\s+"[^"]*")?\s*\)/;
+/** A target may hold parentheses in pairs, as `https://en.wikipedia.org/wiki/A_(b)`. */
+const LINK = /^\[([^\]]+)\]\(\s*(?:<([^>]+)>|((?:[^()\s]|\([^()\s]*\))+))(?:\s+"[^"]*")?\s*\)/;
+const AUTOLINK = /^<(https?:\/\/[^>\s]+)>/i;
+/** What may come right before a bare URL: not a letter, a digit or a part of a path. */
+const BEFORE_URL = /[\w/.@:-]/;
+/** `$x$`: no space inside the dollars, no digit after the closing one, so that `$5 and $10` stays text. */
+const INLINE_MATH = /^\$(?=[^\s$])([^$]*?[^\s$\\])\$(?!\d)/;
+const PUNCTUATION = /[!-/:-@[-`{-~]/;
+
+/**
+ * The markdown models write: fenced code, headings, lists, quotes, tables, emphasis, code spans, links,
+ * images and videos, and TeX between `$`, `$$`, `\\(\\)` or `\\[\\]`. Its output is data for React to
+ * render, never HTML, so text from the model cannot inject markup; links keep only http(s) and mailto
+ * URLs and paths of files (LinkUtil.parse), and URLs in the text are links too. An unclosed fence or
+ * formula, as while a reply streams, runs to the end.
+ */
+export namespace MarkdownUtil {
+    export function blocks(source: string): MarkdownBlock[] {
+        const lines = source.replace(/\r\n?/g, '\n').split('\n');
+        const blocks: MarkdownBlock[] = [];
+        let paragraph: string[] = [];
+        const flush = () => {
+            if (paragraph.length) {
+                blocks.push({ type: 'paragraph', text: paragraph.join('\n') });
+                paragraph = [];
+            }
+        };
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            const fence = FENCE.exec(line);
+            if (fence) {
+                flush();
+                const code: string[] = [];
+                const close = new RegExp(`^\\s*${fence[1][0]}{${fence[1].length},}\\s*$`);
+                for (i++; i < lines.length && !close.test(lines[i]); i++) {
+                    code.push(lines[i]);
+                }
+                if (fence[2].toLowerCase() === 'math') {
+                    blocks.push({ type: 'math', tex: code.join('\n'), closed: i < lines.length });
+                } else {
+                    blocks.push({ type: 'code', language: fence[2], code: code.join('\n') });
+                }
+                continue;
+            }
+            const math = mathBlock(lines, i);
+            if (math) {
+                flush();
+                blocks.push(math.block);
+                i = math.end;
+                continue;
+            }
+            if (!line.trim()) {
+                flush();
+                continue;
+            }
+            const heading = HEADING.exec(line);
+            if (heading) {
+                flush();
+                blocks.push({ type: 'heading', level: heading[1].length, text: heading[2].replace(/\s+#+\s*$/, '') });
+                continue;
+            }
+            if (RULE.test(line) && !paragraph.length) {
+                blocks.push({ type: 'rule' });
+                continue;
+            }
+            if (line.trimStart().startsWith('>')) {
+                flush();
+                const quote: string[] = [];
+                for (; i < lines.length && lines[i].trimStart().startsWith('>'); i++) {
+                    quote.push(lines[i].trimStart().replace(/^>\s?/, ''));
+                }
+                i--;
+                blocks.push({ type: 'quote', text: quote.join('\n') });
+                continue;
+            }
+            const item = BULLET.exec(line) ?? NUMBERED.exec(line);
+            if (item) {
+                flush();
+                const ordered = !BULLET.test(line);
+                const pattern = ordered ? NUMBERED : BULLET;
+                const items: string[] = [];
+                for (; i < lines.length; i++) {
+                    const next = pattern.exec(lines[i]);
+                    if (next) {
+                        items.push(next[1]);
+                    } else if (items.length && lines[i].trim() && /^\s{2,}/.test(lines[i])) {
+                        items[items.length - 1] += `\n${lines[i].trim()}`;
+                    } else {
+                        break;
+                    }
+                }
+                i--;
+                blocks.push({ type: 'list', ordered, items });
+                continue;
+            }
+            if (line.includes('|') && TABLE_SEPARATOR.test(lines[i + 1] ?? '') && !paragraph.length) {
+                const header = cells(line);
+                const rows: string[][] = [];
+                for (i += 2; i < lines.length && lines[i].includes('|') && lines[i].trim(); i++) {
+                    rows.push(cells(lines[i]));
+                }
+                i--;
+                blocks.push({ type: 'table', header, rows });
+                continue;
+            }
+            paragraph.push(line);
+        }
+        flush();
+        return blocks;
+    }
+
+    export function inline(text: string): MarkdownInline[] {
+        const out: MarkdownInline[] = [];
+        let plain = '';
+        const push = (node: MarkdownInline) => {
+            if (plain) {
+                out.push({ type: 'text', text: plain });
+                plain = '';
+            }
+            out.push(node);
+        };
+        for (let i = 0; i < text.length; ) {
+            const rest = text.slice(i);
+            if (text[i] === '\\') {
+                const close = rest[1] === '(' ? '\\)' : rest[1] === '[' ? '\\]' : undefined;
+                const end = close ? rest.indexOf(close, 2) : -1;
+                if (close && end > 2) {
+                    push({ type: 'math', tex: rest.slice(2, end).trim(), display: close === '\\]' });
+                    i += end + 2;
+                    continue;
+                }
+                if (PUNCTUATION.test(rest[1] ?? '')) {
+                    plain += rest[1];
+                    i += 2;
+                    continue;
+                }
+            }
+            if (text[i] === '$') {
+                const display = /^\$\$([\s\S]+?)\$\$/.exec(rest);
+                const math = display ?? INLINE_MATH.exec(rest);
+                if (math?.[1].trim()) {
+                    push({ type: 'math', tex: math[1].trim(), display: !!display });
+                    i += math[0].length;
+                    continue;
+                }
+            }
+            const image = text[i] === '!' ? IMAGE.exec(rest) : null;
+            if (image) {
+                const src = image[2] ?? image[3];
+                if (media(src)) {
+                    push({ type: 'media', src, alt: image[1] });
+                } else {
+                    plain += image[1];
+                }
+                i += image[0].length;
+                continue;
+            }
+            const code = /^(`+)([\s\S]*?[^`])\1(?!`)/.exec(rest);
+            if (code) {
+                push({ type: 'code', text: code[2].trim() || code[2] });
+                i += code[0].length;
+                continue;
+            }
+            const strong = /^(\*\*|__)(?=\S)([\s\S]*?\S)\1/.exec(rest);
+            if (strong) {
+                push({ type: 'strong', children: inline(strong[2]) });
+                i += strong[0].length;
+                continue;
+            }
+            const em = /^([*_])(?=\S)([\s\S]*?\S)\1(?![*_\w])/.exec(rest);
+            if (em && (em[1] === '*' || !/\w/.test(text[i - 1] ?? ''))) {
+                push({ type: 'em', children: inline(em[2]) });
+                i += em[0].length;
+                continue;
+            }
+            const link = text[i] === '[' ? LINK.exec(rest) : null;
+            if (link) {
+                const href = link[2] ?? link[3];
+                const target = LinkUtil.parse(href);
+                if (target?.type === 'path' && !target.selection && localPath(href) !== undefined && media(href, false)) {
+                    // A link to a picture or a video of the workspace shows it.
+                    push({ type: 'media', src: href, alt: link[1] });
+                } else if (target) {
+                    push({ type: 'link', href, children: inline(link[1]) });
+                } else {
+                    plain += link[1];
+                }
+                i += link[0].length;
+                continue;
+            }
+            const autolink = text[i] === '<' ? AUTOLINK.exec(rest) : null;
+            if (autolink) {
+                push({ type: 'link', href: autolink[1], children: [{ type: 'text', text: autolink[1] }] });
+                i += autolink[0].length;
+                continue;
+            }
+            const url = (text[i] === 'h' || text[i] === 'H') && !BEFORE_URL.test(text[i - 1] ?? '') ? LinkUtil.bareUrl(rest) : undefined;
+            if (url) {
+                push({ type: 'link', href: url, children: [{ type: 'text', text: url }] });
+                i += url.length;
+                continue;
+            }
+            plain += text[i++];
+        }
+        if (plain) {
+            out.push({ type: 'text', text: plain });
+        }
+        return out;
+    }
+
+    /**
+     * What a target of an image shows: by the type of a data URL, else by the extension of its path; an
+     * http(s) URL or a path without a known extension is taken for an image. Undefined for targets that
+     * show nothing, as `javascript:`; without `guess`, also for a target whose extension is not known.
+     */
+    export function media(src: string, guess = true): MediaKind | undefined {
+        const data = DATA_MEDIA.exec(src);
+        if (data) {
+            return data[1].toLowerCase() as MediaKind;
+        }
+        if (!/^https?:/i.test(src) && localPath(src) === undefined) {
+            return undefined;
+        }
+        const extension = /\.(\w+)$/.exec(src.split(/[?#]/)[0])?.[1].toLowerCase();
+        return (extension && EXTENSIONS[extension]) || (guess ? 'image' : undefined);
+    }
+
+    /**
+     * The path of a file a target names: a relative or absolute path, or a `file:` URL of this machine;
+     * undefined for URLs, which the page loads as they are.
+     */
+    export function localPath(src: string): string | undefined {
+        let path = src;
+        if (/^file:/i.test(src)) {
+            const url = /^file:\/\/(?:localhost)?(\/[^?#]*)/i.exec(src);
+            if (!url) {
+                return undefined;
+            }
+            path = url[1];
+        } else if (SCHEME.test(src) || src.startsWith('//')) {
+            return undefined;
+        }
+        path = path.split(/[?#]/)[0];
+        try {
+            path = decodeURI(path);
+        } catch {
+            // Kept as written.
+        }
+        return path || undefined;
+    }
+
+    /** `$$` or `\\[` starting at line `start`: its block and the line it ends on. */
+    function mathBlock(lines: string[], start: number): { block: MarkdownBlock; end: number } | undefined {
+        const first = lines[start].trim();
+        const [open, close] = first.startsWith('$$') ? ['$$', '$$'] : first.startsWith('\\[') ? ['\\[', '\\]'] : [];
+        if (!open || !close) {
+            return undefined;
+        }
+        const head = first.slice(open.length);
+        // On one line, $$ x $$; text after it makes it inline math of a paragraph.
+        if (head.includes(close)) {
+            const at = head.indexOf(close);
+            return head.slice(at + close.length).trim() ? undefined : { block: { type: 'math', tex: head.slice(0, at).trim(), closed: true }, end: start };
+        }
+        const tex = head.trim() ? [head] : [];
+        for (let i = start + 1; i < lines.length; i++) {
+            const line = lines[i].trimEnd();
+            if (line.endsWith(close)) {
+                tex.push(line.slice(0, -close.length));
+                return { block: { type: 'math', tex: tex.join('\n').trim(), closed: true }, end: i };
+            }
+            tex.push(lines[i]);
+        }
+        return { block: { type: 'math', tex: tex.join('\n').trim(), closed: false }, end: lines.length - 1 };
+    }
+
+    function cells(row: string): string[] {
+        return row
+            .trim()
+            .replace(/^\|/, '')
+            .replace(/\|$/, '')
+            .split('|')
+            .map(cell => cell.trim());
+    }
+}

package/src/browser/util/message.spec.ts

@@ -0,0 +1,63 @@
+import { describe, expect, it } from 'bun:test';
+import type { SessionMessage } from '@celljs/ta-client';
+import { MessageUtil } from './message';
+
+describe('MessageUtil', () => {
+    it('pairs tool results with their calls', () => {
+        const result = { role: 'toolResult', toolCallId: 'c1', content: [{ type: 'text', text: 'ok' }] };
+        expect(MessageUtil.results([result as unknown as SessionMessage]).get('c1')).toBe(result as never);
+    });
+
+    it('prefers the live run, which has the diffs, over the message', () => {
+        const message = { content: [{ type: 'text', text: 'saved' }] };
+        const run = { toolName: 'edit', args: {}, status: 'done' as const, result: { content: [], details: { diff: '+1 a' } } };
+        expect(MessageUtil.output(run, message)?.details).toEqual({ diff: '+1 a' });
+        expect(MessageUtil.output(undefined, message)).toBe(message);
+        expect(MessageUtil.status(undefined, undefined)).toBe('running');
+        expect(MessageUtil.status(undefined, { isError: true })).toBe('error');
+    });
+
+    it('drops the header of a codemode result', () => {
+        expect(MessageUtil.scriptOutput('Script completed\nWall time 0.1 seconds\nOutput:\nhello')).toBe('hello');
+    });
+
+    it('keeps the last lines of long output', () => {
+        expect(MessageUtil.tail('a\nb\nc', 2)).toEqual({ text: 'b\nc', hidden: 1 });
+        expect(MessageUtil.basename('/home/me/project/')).toBe('project');
+        expect(MessageUtil.shortPath('/home/me/work/project')).toBe('…/work/project');
+        expect(MessageUtil.shortPath('/srv')).toBe('/srv');
+    });
+
+    it('finds the entry of a message by its role and time, the newest first', () => {
+        const entries = [
+            { id: 'a', type: 'message', message: { role: 'user', timestamp: 1 } },
+            { id: 'b', type: 'model_change' },
+            { id: 'c', type: 'message', message: { role: 'assistant', timestamp: 1 } },
+        ];
+        expect(MessageUtil.entryId(entries, { role: 'assistant', timestamp: 1 } as never)).toBe('c');
+        expect(MessageUtil.entryId(entries, { role: 'user', timestamp: 1 } as never)).toBe('a');
+        expect(MessageUtil.entryId(entries, { role: 'user', timestamp: 2 } as never)).toBeUndefined();
+        expect(MessageUtil.entryId(entries, { role: 'user' } as never)).toBeUndefined();
+    });
+
+    it('sums what the models of a turn took, the cached context with the rest', () => {
+        const messages = [
+            { role: 'assistant', usage: { input: 100, cacheRead: 900, output: 20, cost: { total: 0.001 } } },
+            { role: 'toolResult', usage: { input: 5 } },
+            { role: 'assistant', usage: { input: 50, cacheWrite: 50, output: 30, cost: { total: 0.002 } } },
+        ];
+        const usage = MessageUtil.usage(messages as never);
+        expect(usage).toMatchObject({ input: 1100, output: 50 });
+        expect(MessageUtil.cost(usage.cost)).toBe('$0.0030');
+        expect(MessageUtil.cost(1.234)).toBe('$1.23');
+    });
+
+    it('says when a message came as short as it can: the time today, yesterday and the day before by their word, else the date', () => {
+        const now = new Date(2026, 10, 10, 0, 30).getTime();
+        expect(MessageUtil.when(new Date(2026, 10, 10, 0, 5).getTime(), now)).toEqual({ day: 'today', time: '00:05' });
+        expect(MessageUtil.when(new Date(2026, 10, 9, 23, 59).getTime(), now)).toEqual({ day: 'yesterday', time: '23:59' });
+        expect(MessageUtil.when(new Date(2026, 10, 8, 18, 51).getTime(), now)).toEqual({ day: 'dayBefore', time: '18:51' });
+        expect(MessageUtil.when(new Date(2026, 10, 7, 9, 0).getTime(), now)).toEqual({ day: 'date', date: '11-07', time: '09:00' });
+        expect(MessageUtil.when(new Date(2025, 0, 2, 3, 4).getTime(), now)).toEqual({ day: 'date', date: '2025-01-02', time: '03:04' });
+    });
+});