mixdog 0.9.2 → 0.9.4

package/src/tui/markdown/format-token.test.mjs

@@ -1,354 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { marked } from 'marked';
-import stripAnsi from 'strip-ansi';
-import stringWidth from 'string-width';
-import {
-  formatToken,
-  highlightCodeBlockToLines,
-  extraColorizers,
-  _highlightCacheSizeForTests,
-} from './format-token.mjs';
-import { setThemeSetting, theme } from '../theme.mjs';
-
-setThemeSetting('basic', { persist: false });
-
-function rgbSgr(value) {
-  const m = /^rgb\((\d+),\s*(\d+),\s*(\d+)\)$/.exec(String(value || ''));
-  return m ? `38;2;${m[1]};${m[2]};${m[3]}` : null;
-}
-
-function lexFirst(md, type) {
-  const tokens = marked.lexer(md);
-  return tokens.find((t) => t.type === type) ?? tokens[0];
-}
-
-test('fenced code block has no ``` fences and shows a language label row', () => {
-  const token = lexFirst('```js\nconst x = 1;\n```\n', 'code');
-  const out = formatToken(token, 0, null, null, 60);
-  const plain = stripAnsi(out);
-  assert.ok(!plain.includes('```'), 'no literal fence markers');
-  assert.ok(plain.includes('const x = 1;'), 'body present');
-  // The first non-empty row is the subtle language label; its trimmed text is
-  // exactly the bare lang token (gutter trims away).
-  const rows = plain.split('\n').filter((l) => l.trim().length > 0);
-  assert.equal(rows[0].trim(), 'js', 'first row is the language label');
-});
-
-test('short code line is gutter-indented with no background band', () => {
-  const width = 60;
-  const token = lexFirst('```js\nshort\n```\n', 'code');
-  const out = formatToken(token, 0, null, null, width);
-  // No background band: codex/claude-code render code with no `48;2;` bg.
-  assert.ok(!out.includes('48;2;'), 'no background SGR');
-  const bodyLine = stripAnsi(out).split('\n').find((l) => l.includes('short'));
-  assert.ok(bodyLine, 'body line present');
-  assert.ok(bodyLine.startsWith('  short'), 'body is gutter-indented');
-  // Content width only — NOT padded out to the full render width.
-  assert.equal(stringWidth(bodyLine), '  short'.length, 'body row follows content width');
-});
-
-test('code block body lines have no background band and follow content width', () => {
-  const width = 80;
-  const token = lexFirst('```js\na\n\nlonger line\n```\n', 'code');
-  const out = formatToken(token, 0, null, null, width);
-  assert.ok(!out.includes('48;2;'), 'no background SGR anywhere');
-  const plainLines = stripAnsi(out).split('\n').filter((l) => l.length > 0);
-  const widths = plainLines.map((l) => stringWidth(l));
-  assert.ok(widths.length >= 2, 'body lines rendered');
-  // Widths follow content (gutter + visible text), not forced equal to render
-  // width: the longest row stays well under the 80-col render width.
-  assert.ok(Math.max(...widths) < width, 'rows are not padded to the render width');
-});
-
-test('long code line wraps within requested body width', () => {
-  const long = 'a'.repeat(40);
-  const token = lexFirst(`\`\`\`js\n${long}\n\`\`\`\n`, 'code');
-  const width = 20;
-  const out = formatToken(token, 0, null, null, width);
-  const bodyLines = stripAnsi(out).split('\n').filter((l) => l.includes('a'));
-  assert.ok(bodyLines.length > 1, 'long line is wrapped into multiple rows');
-  for (const line of bodyLines) {
-    assert.ok(line.length <= width, `wrapped line "${line}" fits width ${width}`);
-  }
-  assert.equal(bodyLines.join('').replace(/\s/g, ''), long, 'wrapped segments preserve content');
-});
-
-test('fenced code expands tabs so width math matches the terminal', () => {
-  // A raw \t counts as ZERO cells in string-width ("Tabs are ignored by
-  // design"), so without normalization the wrap/row math under-counts a
-  // tab-bearing line and the terminal-expanded line bleeds past the viewport
-  // clip. After normalization every rendered row must contain no raw \t and
-  // its visible width must equal its character length (tabs → spaces).
-  const token = lexFirst('```\n\tindented\n```\n', 'code');
-  const out = formatToken(token, 0, null, null, 60);
-  const plain = stripAnsi(out);
-  assert.ok(!plain.includes('\t'), 'no raw tab survives into the rendered string');
-  const bodyLine = plain.split('\n').find((l) => l.includes('indented'));
-  assert.ok(bodyLine, 'body line present');
-  assert.equal(stringWidth(bodyLine), bodyLine.length, 'visible width equals char length (no zero-width tab)');
-});
-
-test('fenced code strips stray C0 control chars except newline', () => {
-  // A bare \x07 (BELL) etc. measures as zero width but can move the terminal
-  // cursor; replace with a space so ink's row accounting holds.
-  const token = lexFirst('```\na\x07b\n```\n', 'code');
-  const out = formatToken(token, 0, null, null, 60);
-  const plain = stripAnsi(out);
-  assert.ok(!/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/.test(plain), 'no raw C0/DEL control survives');
-  const bodyLine = plain.split('\n').find((l) => l.includes('a') && l.includes('b'));
-  assert.ok(bodyLine, 'body line present');
-  assert.equal(stringWidth(bodyLine), bodyLine.length, 'control char became a real space cell');
-});
-
-test('list item fenced code block respects narrowed width and has no fences', () => {
-  const long = 'b'.repeat(36);
-  const codeTok = lexFirst(`\`\`\`js\n${long}\n\`\`\`\n`, 'code');
-  const listTok = {
-    type: 'list',
-    ordered: false,
-    items: [{ type: 'list_item', tokens: [codeTok] }],
-  };
-  const outerWidth = 22;
-  const out = formatToken(listTok, 0, null, null, outerWidth);
-  const plain = stripAnsi(out);
-  assert.ok(!plain.includes('```'), 'no literal fence markers');
-  const prefixed = plain.split('\n').filter((l) => l.includes('b'));
-  assert.ok(prefixed.length > 1, 'nested list code wraps under narrow width');
-  for (const line of prefixed) {
-    assert.ok(stringWidth(line) <= outerWidth, `line fits outer width: "${line}"`);
-  }
-});
-
-test('blockquote fenced code block respects narrowed width and has no fences', () => {
-  const long = 'c'.repeat(36);
-  const codeTok = lexFirst(`\`\`\`js\n${long}\n\`\`\`\n`, 'code');
-  const quoteTok = { type: 'blockquote', tokens: [codeTok] };
-  const outerWidth = 24;
-  const out = formatToken(quoteTok, 0, null, null, outerWidth);
-  const plain = stripAnsi(out);
-  assert.ok(!plain.includes('```'), 'no literal fence markers');
-  const lines = plain.split('\n').filter((l) => l.includes('c'));
-  assert.ok(lines.length > 1, 'blockquote code wraps under narrow width');
-  for (const line of lines) {
-    assert.ok(stringWidth(line) <= outerWidth, `line fits outer width: "${line}"`);
-  }
-});
-
-test('blockquote fenced code with blank line keeps quote prefix on every code row', () => {
-  const codeTok = lexFirst('```js\na\n\nb\n```\n', 'code');
-  const quoteTok = { type: 'blockquote', tokens: [codeTok] };
-  const outerWidth = 40;
-  const out = formatToken(quoteTok, 0, null, null, outerWidth);
-  const plain = stripAnsi(out);
-  assert.ok(!plain.includes('```'), 'no literal fence markers');
-  const bar = '\u258e';
-  const visibleLines = plain.split('\n').filter((l) => stringWidth(l) > 0);
-  assert.ok(visibleLines.length >= 3, 'two body lines + blank padded row');
-  for (const line of visibleLines) {
-    assert.ok(line.startsWith(bar), `quote bar on every visible row: "${line}"`);
-    assert.ok(stringWidth(line) <= outerWidth, `line fits outer width: "${line}"`);
-  }
-  const blankPadded = visibleLines.find((l) => !l.includes('a') && !l.includes('b'));
-  assert.ok(blankPadded, 'background-padded blank code row is rendered');
-  assert.ok(blankPadded.startsWith(bar), 'blank padded code row keeps quote prefix');
-});
-
-test('two-level nested list code block does not double-subtract list prefix width', () => {
-  const long = 'd'.repeat(40);
-  const codeTok = lexFirst(`\`\`\`js\n${long}\n\`\`\`\n`, 'code');
-  const innerList = {
-    type: 'list',
-    ordered: false,
-    items: [{ type: 'list_item', tokens: [codeTok] }],
-  };
-  const outerList = {
-    type: 'list',
-    ordered: false,
-    items: [{ type: 'list_item', tokens: [innerList] }],
-  };
-  const outerWidth = 30;
-  const singleLevelNested = formatToken(innerList, 2, null, null, outerWidth);
-  const twoLevelNested = formatToken(outerList, 0, null, null, outerWidth);
-  const codeLines = (plain) => plain.split('\n').filter((l) => l.includes('d'));
-  const singleLines = codeLines(stripAnsi(singleLevelNested));
-  const nestedLines = codeLines(stripAnsi(twoLevelNested));
-  assert.equal(
-    nestedLines.length,
-    singleLines.length,
-    'nested list code wraps like one-level nested list at the same outer width',
-  );
-  assert.ok(nestedLines.length > 1, 'code is wrapped under narrow width');
-});
-
-test('js highlighting colors keyword, string, number distinctly', () => {
-  const token = lexFirst('```js\nconst n = 42;\nlet s = "hi";\n```\n', 'code');
-  const out = formatToken(token);
-  assert.ok(out.includes(rgbSgr(theme.syntaxKeyword)), 'keyword colored');
-  assert.ok(out.includes(rgbSgr(theme.syntaxNumber)), 'number colored');
-  assert.ok(out.includes(rgbSgr(theme.syntaxString)), 'string colored');
-});
-
-test('highlight cache serves repeat block highlight without changing output', () => {
-  const c = extraColorizers();
-  const text = `const cacheProbe_${Date.now()} = 1;\nlet y = 2;\n`;
-  const sizeBefore = _highlightCacheSizeForTests();
-  const first = highlightCodeBlockToLines(text, 'js', c);
-  assert.equal(_highlightCacheSizeForTests(), sizeBefore + 1, 'first highlight populates cache');
-  const second = highlightCodeBlockToLines(text, 'js', c);
-  assert.deepEqual(second, first);
-  assert.equal(_highlightCacheSizeForTests(), sizeBefore + 1, 'cache hit does not grow entries');
-  assert.ok(first[0].includes('38;2;'), 'highlighted ANSI present');
-});
-
-test('inline codespan is accent-colored with no background band', () => {
-  const tokens = marked.lexer('`hello`');
-  const codespan = tokens[0].tokens[0];
-  assert.equal(codespan.type, 'codespan');
-  const out = formatToken(codespan);
-  // Inline code uses accent color only — no bg box behind the span (a tinted
-  // band behind inline text reads as awkward against body prose).
-  assert.ok(!out.includes('48;2;'), 'no background SGR');
-  assert.ok(stripAnsi(out).includes('hello'));
-  assert.ok(out.includes(rgbSgr(theme.mdCode)), 'inline code accent');
-});
-
-test('kotlin fence resolves and highlights', () => {
-  const token = lexFirst('```kotlin\nfun main() {}\n```\n', 'code');
-  const out = formatToken(token);
-  assert.ok(out.includes(rgbSgr(theme.syntaxKeyword)) || out.includes(rgbSgr(theme.mdCodeBlock)));
-  assert.ok(stripAnsi(out).includes('fun main'));
-});
-
-test('typescript fence uses typescript highlighter', () => {
-  const token = lexFirst('```ts\nconst x: number = 1;\n```\n', 'code');
-  const out = formatToken(token);
-  assert.ok(out.includes('38;2;'));
-  assert.ok(stripAnsi(out).includes('const x'));
-});
-
-test('diff fenced block colors add/remove/hunk/header separately', () => {
-  const diff = [
-    '```diff',
-    'diff --git a/x b/x',
-    '--- a/x',
-    '+++ b/x',
-    '@@ -1,2 +1,2 @@',
-    '-old line',
-    '+new line',
-    ' context line',
-    '```',
-    '',
-  ].join('\n');
-  const token = lexFirst(diff, 'code');
-  const out = formatToken(token);
-  const added = rgbSgr(theme.mdDiffAdded);
-  const removed = rgbSgr(theme.mdDiffRemoved);
-  const hunk = rgbSgr(theme.mdDiffHunk);
-  const header = rgbSgr(theme.mdDiffHeader);
-  assert.ok(out.includes(added), 'added line color present');
-  assert.ok(out.includes(removed), 'removed line color present');
-  assert.ok(out.includes(hunk), 'hunk line color present');
-  assert.ok(out.includes(header), 'header line color present');
-  assert.equal(new Set([added, removed, hunk, header]).size, 4);
-  assert.ok(out.indexOf('+++ b/x') !== -1);
-});
-
-test('plus/minus file headers are not treated as add/remove', () => {
-  const diff = '```patch\n--- a/f\n+++ b/f\n@@ -0,0 +1 @@\n+x\n```\n';
-  const token = lexFirst(diff, 'code');
-  const out = formatToken(token);
-  const headerSgr = rgbSgr(theme.mdDiffHeader);
-  const addedSgr = rgbSgr(theme.mdDiffAdded);
-  const idxHeader = out.indexOf('+++ b/f');
-  const before = out.slice(0, idxHeader);
-  const lastHeader = before.lastIndexOf(headerSgr);
-  const lastAdded = before.lastIndexOf(addedSgr);
-  assert.ok(lastHeader > lastAdded, 'plus-plus-plus header uses header color, not added');
-});
-
-test('bare unified diff (no lang) is detected and colored', () => {
-  const token = lexFirst('```\n@@ -1 +1 @@\n-a\n+b\n```\n', 'code');
-  const out = formatToken(token);
-  assert.ok(out.includes(rgbSgr(theme.mdDiffHunk)), 'hunk colored on bare diff');
-  assert.ok(out.includes(rgbSgr(theme.mdDiffAdded)), 'add colored on bare diff');
-});
-
-test('unknown language falls back to flat code block color', () => {
-  const token = lexFirst('```foobarlang\nsome text\n```\n', 'code');
-  const out = formatToken(token);
-  assert.ok(out.includes(rgbSgr(theme.mdCodeBlock)), 'flat code-block color used');
-  assert.ok(stripAnsi(out).includes('some text'), 'body is flush-left');
-});
-
-test('inline link emits OSC 8 hyperlink with styled label (URL hidden)', () => {
-  const token = lexFirst('[label](https://example.com)', 'paragraph');
-  const out = formatToken(token);
-  // OSC 8 wraps the visible label; the raw URL lives in the escape, not as
-  // on-screen text, so stripAnsi keeps only the label.
-  assert.ok(out.includes('\x1b]8;;https://example.com\x07'), 'OSC 8 link target present');
-  assert.ok(out.includes('\x1b]8;;\x07'), 'OSC 8 close present');
-  assert.ok(stripAnsi(out).includes('label'), 'link label text visible');
-  assert.ok(out.includes(rgbSgr(theme.mdLinkText)), 'link label colored');
-});
-
-test('bare-url link emits OSC 8 with the URL as visible clickable text', () => {
-  const token = lexFirst('<https://example.com>', 'paragraph');
-  const out = formatToken(token);
-  assert.ok(out.includes('\x1b]8;;https://example.com\x07'), 'OSC 8 link target present');
-  assert.ok(stripAnsi(out).includes('https://example.com'), 'URL visible as text');
-  assert.ok(out.includes(rgbSgr(theme.mdLink)), 'link URL colored');
-});
-
-test('strong and em use distinct mdStrong / mdEmph colors', () => {
-  const strongTok = lexFirst('**bold**', 'paragraph');
-  const emTok = lexFirst('*ital*', 'paragraph');
-  const strongOut = formatToken(strongTok);
-  const emOut = formatToken(emTok);
-  // Bold/italic carry weight/style only — NO color tint (codex/claude-code
-  // convention; a colored strong/em clashes per-theme and reads too loud).
-  assert.ok(strongOut.includes('\x1b[1m'), 'strong is bold');
-  assert.ok(emOut.includes('\x1b[3m'), 'em is italic');
-  assert.ok(!strongOut.includes(rgbSgr(theme.mdStrong)), 'strong is not color-tinted');
-  assert.ok(!emOut.includes(rgbSgr(theme.mdEmph)), 'em is not color-tinted');
-});
-
-test('h1 heading is bold, italic, and underlined', () => {
-  const token = lexFirst('# Title', 'heading');
-  const out = formatToken(token);
-  assert.ok(out.includes('\x1b[1m'), 'h1 is bold');
-  assert.ok(out.includes('\x1b[3m'), 'h1 is italic');
-  assert.ok(out.includes('\x1b[4m'), 'h1 is underlined');
-});
-
-test('ordered list markers follow nesting depth (1. / a. / i.)', () => {
-  const md = [
-    '1. one',
-    '   1. two',
-    '      1. three',
-    '         1. four',
-  ].join('\n');
-  const tokens = marked.lexer(md);
-  const plain = stripAnsi(tokens.map((t) => formatToken(t)).join(''));
-  assert.ok(plain.includes('1. one'), 'depth 0 arabic');
-  assert.ok(plain.includes('1. two'), 'depth 1 arabic');
-  assert.ok(plain.includes('a. three'), 'depth 2 lowercase letter');
-  assert.ok(plain.includes('i. four'), 'depth 3 lowercase roman');
-});
-
-test('every palette defines the full extended key set', () => {
-  const required = [
-    'mdCodeBlockBorder', 'mdCodeBlockBg', 'mdCodeSpanBg', 'mdLink', 'mdLinkText', 'mdStrong', 'mdEmph',
-    'mdDiffAdded', 'mdDiffRemoved', 'mdDiffHunk', 'mdDiffHeader', 'mdDiffContext',
-    'mdDiffAddedBg', 'mdDiffRemovedBg',
-    'syntaxComment', 'syntaxKeyword', 'syntaxFunction', 'syntaxVariable',
-    'syntaxString', 'syntaxNumber', 'syntaxType', 'syntaxOperator', 'syntaxPunctuation',
-  ];
-  for (const id of ['basic', 'indigo', 'warm', 'light', 'teal', 'onedark', 'tokyonight', 'kanagawa', 'catppuccin', 'dracula', 'rosepine', 'nord', 'gruvbox', 'everforest']) {
-    setThemeSetting(id, { persist: false });
-    for (const key of required) {
-      assert.ok(/^rgb\(\d+,\s*\d+,\s*\d+\)$/.test(String(theme[key])), `${id}.${key} is an rgb() string`);
-    }
-  }
-  setThemeSetting('basic', { persist: false });
-});

package/src/tui/markdown/render-ansi.test.mjs

@@ -1,108 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import stripAnsi from 'strip-ansi';
-import { assistantBodyWidth } from './table-layout.mjs';
-import { renderTokenAnsiSegments, lexMarkdown, hasMarkdownSyntax } from './render-ansi.mjs';
-import { setThemeSetting } from '../theme.mjs';
-
-setThemeSetting('basic', { persist: false });
-
-// Mirrors the streaming suffix the <Markdown trimPartialFences> path renders.
-const STREAMING = '```js\nconst x = 1;\n`';
-
-function codeBlockVisibleLines(segments) {
-  const codeSeg = segments.find((s) => s.type === 'ansi' && s.token?.type === 'code');
-  assert.ok(codeSeg, 'a fenced code segment is rendered');
-  return stripAnsi(codeSeg.ansi).split('\n');
-}
-
-test('streaming render path drops the partial trailing backtick body line', () => {
-  const segments = renderTokenAnsiSegments(STREAMING, { trimPartialFences: true });
-  const lines = codeBlockVisibleLines(segments);
-  const bodyLines = lines.filter((l) => !/^js$/.test(l.trim()));
-  for (const l of bodyLines) {
-    assert.notEqual(l.trim(), '`', 'no body line is a lone partial fence');
-  }
-  // The real code body is still present.
-  assert.ok(lines.some((l) => l.includes('const x = 1;')), 'code body preserved');
-});
-
-test('without trimPartialFences the partial backtick survives as a body line', () => {
-  // Proves the trim flag is what removes it on the render path (not formatToken).
-  const segments = renderTokenAnsiSegments(STREAMING, { trimPartialFences: false });
-  const lines = codeBlockVisibleLines(segments);
-  const bodyLines = lines.filter((l) => !/^js$/.test(l.trim()));
-  assert.ok(
-    bodyLines.some((l) => l.trim() === '`'),
-    'untrimmed path keeps the partial fence as a body line',
-  );
-});
-
-test('trimPartialFences tokens are not cached (stable text unaffected)', () => {
-  const stable = '```js\nconst y = 2;\n```\n';
-  const a = lexMarkdown(stable, { trimPartialFences: false });
-  const b = lexMarkdown(stable, { trimPartialFences: false });
-  assert.strictEqual(a, b, 'stable content returns the cached token array');
-  // Streaming lex must be a fresh (non-cached) array.
-  const c = lexMarkdown(STREAMING, { trimPartialFences: true });
-  const d = lexMarkdown(STREAMING, { trimPartialFences: true });
-  assert.notStrictEqual(c, d, 'streaming lex is never cached');
-});
-
-test('closed code block renders lang label and body without fence markers', () => {
-  const segments = renderTokenAnsiSegments('```js\nconst z = 3;\n```\n', { trimPartialFences: true });
-  const lines = codeBlockVisibleLines(segments);
-  assert.ok(lines.some((l) => l.includes('const z = 3;')), 'body present');
-  assert.ok(lines.some((l) => l.trim() === 'js'), 'language label present');
-  assert.ok(!lines.some((l) => l.includes('```')), 'no literal fence markers');
-});
-
-test('renderTokenAnsiSegments width matches assistant body width for code pre-wrap', () => {
-  const long = 'z'.repeat(60);
-  const md = `\`\`\`js\n${long}\n\`\`\``;
-  const bodyWidth = assistantBodyWidth(40);
-  const atBody = renderTokenAnsiSegments(md, { width: bodyWidth });
-  const atDefault = renderTokenAnsiSegments(md, { width: 80 });
-  const bodyLines = (seg) => stripAnsi(seg.find((s) => s.token?.type === 'code').ansi)
-    .split('\n')
-    .filter((l) => l.startsWith('  '));
-  assert.ok(bodyLines(atBody).length > bodyLines(atDefault).length,
-    'narrow body width produces more wrapped code rows than width 80');
-});
-
-const PLAIN_PREFIX = 'x'.repeat(501);
-
-test('hasMarkdownSyntax detects strong markers after a 500+ char plain prefix', () => {
-  assert.ok(hasMarkdownSyntax(`${PLAIN_PREFIX}**late bold**`));
-});
-test('hasMarkdownSyntax detects inline code after a 500+ char plain prefix', () => {
-  assert.ok(hasMarkdownSyntax(`${PLAIN_PREFIX}\`late code\``));
-});
-
-test('render path parses fenced code after a 500+ char plain prefix', () => {
-  const input = `${PLAIN_PREFIX}\n\`\`\`js\nconst late = true;\n\`\`\``;
-  const tokens = lexMarkdown(input);
-  assert.ok(
-    tokens.some((t) => t.type === 'code' && String(t.text).includes('const late = true;')),
-    'lexer emits a code token with the fenced body',
-  );
-  const segments = renderTokenAnsiSegments(input);
-  const lines = codeBlockVisibleLines(segments);
-  assert.ok(lines.some((l) => l.includes('const late = true;')), 'code block body is rendered');
-  const visible = segments.map((s) => stripAnsi(s.ansi ?? '')).join('\n');
-  assert.ok(!visible.includes(`${PLAIN_PREFIX}\`\`\`js`), 'prefix is not glued to raw fence markers');
-});
-
-test('render path parses strong after a 500+ char plain prefix (no raw **)', () => {
-  const segments = renderTokenAnsiSegments(`${PLAIN_PREFIX}**rendered**`);
-  const visible = segments.map((s) => stripAnsi(s.ansi ?? '')).join('');
-  assert.ok(visible.includes('rendered'), 'bold text is present');
-  assert.ok(!visible.includes('**'), 'markdown strong markers are not leaked');
-});
-
-test('render path parses inline code after a 500+ char plain prefix (no raw backticks)', () => {
-  const segments = renderTokenAnsiSegments(`${PLAIN_PREFIX}\`snippet\``);
-  const visible = segments.map((s) => stripAnsi(s.ansi ?? '')).join('');
-  assert.ok(visible.includes('snippet'), 'codespan text is present');
-  assert.ok(!visible.includes('`'), 'inline code backticks are not leaked');
-});

package/src/tui/markdown/stream-fence.test.mjs

@@ -1,26 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { marked } from 'marked';
-import { trimPartialClosingFences } from './stream-fence.mjs';
-
-test('trims a partial closing fence (single backtick) from open code block', () => {
-  const tokens = marked.lexer('```js\nconst x = 1;\n`');
-  trimPartialClosingFences(tokens);
-  const code = tokens.find((t) => t.type === 'code');
-  assert.ok(code, 'code token exists');
-  assert.ok(!code.text.endsWith('`'), 'partial fence trimmed from text');
-  assert.ok(code.text.includes('const x = 1;'), 'real body preserved');
-});
-
-test('leaves a complete closing fence intact', () => {
-  const tokens = marked.lexer('```js\nconst x = 1;\n```\n');
-  const code = tokens.find((t) => t.type === 'code');
-  const before = code.text;
-  trimPartialClosingFences(tokens);
-  assert.equal(code.text, before, 'closed block unchanged');
-});
-
-test('no-op on non-code trailing token', () => {
-  const tokens = marked.lexer('hello world\n');
-  assert.doesNotThrow(() => trimPartialClosingFences(tokens));
-});

package/src/tui/markdown/streaming-markdown.test.mjs

@@ -1,70 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { assistantBodyWidth } from './table-layout.mjs';
-import {
-  measureMarkdownRenderedRows,
-  measureStreamingMarkdownRenderedRows,
-} from './measure-rendered-rows.mjs';
-import { resolveStreamingMarkdownParts, streamingLayoutText } from './streaming-markdown.mjs';
-import { setThemeSetting } from '../theme.mjs';
-
-setThemeSetting('basic', { persist: false });
-
-function measureStreamingLayoutFromParts(text, columns, streamKey) {
-  const parts = resolveStreamingMarkdownParts(text, streamKey);
-  if (parts.plain) {
-    return measureMarkdownRenderedRows(text, columns);
-  }
-  let rows = 0;
-  let childCount = 0;
-  if (parts.stablePrefix) {
-    rows += measureMarkdownRenderedRows(parts.stablePrefix, columns);
-    childCount += 1;
-  }
-  if (parts.unstableSuffix) {
-    rows += measureMarkdownRenderedRows(parts.unstableForRender, columns, { trimPartialFences: true });
-    childCount += 1;
-  }
-  if (childCount === 2) rows += 1;
-  return Math.max(1, rows);
-}
-
-test('streaming row estimate matches shared layout parts at body width', () => {
-  const columns = 40;
-  const bodyWidth = assistantBodyWidth(columns);
-  const cases = [
-    { key: 'bold-wrap', text: `**${'m'.repeat(bodyWidth + 12)}` },
-    { key: 'partial-fence', text: `\`\`\`js\n${'w'.repeat(bodyWidth + 6)}\n\`` },
-  ];
-  for (const { key, text } of cases) {
-    const estimate = measureStreamingMarkdownRenderedRows(text, columns, key);
-    const layout = measureStreamingLayoutFromParts(text, columns, key);
-    assert.strictEqual(estimate, layout, `${key}: estimate must match render layout parts`);
-  }
-});
-
-test('partial code fence streaming measure uses trimPartialFences on unstable suffix', () => {
-  const columns = 48;
-  const bodyWidth = assistantBodyWidth(columns);
-  const streamKey = 'test-stream-fence';
-  const text = `\`\`\`js\n${'n'.repeat(bodyWidth + 8)}\n\``;
-  const estimate = measureStreamingMarkdownRenderedRows(text, columns, streamKey);
-  const parts = resolveStreamingMarkdownParts(text, streamKey);
-  const manual = measureMarkdownRenderedRows(parts.unstableForRender, columns, { trimPartialFences: true });
-  assert.strictEqual(estimate, Math.max(1, manual));
-});
-
-test('leading blank lines do not create an empty stable child or extra gap row', () => {
-  const columns = 40;
-  const streamKey = 'test-leading-blank';
-  const raw = '\n\n**streaming body**';
-  const trimmed = streamingLayoutText(raw);
-  const parts = resolveStreamingMarkdownParts(raw, streamKey);
-  assert.strictEqual(parts.stablePrefix, '', 'leading newlines must not promote whitespace-only stable');
-  assert.ok(parts.unstableSuffix.includes('streaming body'));
-  const estimate = measureStreamingMarkdownRenderedRows(raw, columns, streamKey);
-  const trimmedEstimate = measureStreamingMarkdownRenderedRows(trimmed, columns, streamKey);
-  assert.strictEqual(estimate, trimmedEstimate, 'raw vs trimmed leading newlines must match');
-  const layout = measureStreamingLayoutFromParts(raw, columns, streamKey);
-  assert.strictEqual(estimate, layout);
-});

package/src/tui/prompt-history-store.test.mjs

@@ -1,52 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, rmSync } from 'node:fs';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-import {
-  appendPromptHistory,
-  buildMergedPromptHistory,
-  loadPromptHistory,
-  pushSessionPromptHistory,
-  promptHistoryKey,
-} from './prompt-history-store.mjs';
-
-test('promptHistoryKey normalizes whitespace', () => {
-  assert.equal(promptHistoryKey('  hello   world  '), 'hello world');
-  assert.equal(promptHistoryKey('   '), '');
-});
-
-test('buildMergedPromptHistory prefers session order and dedupes', () => {
-  const merged = buildMergedPromptHistory(
-    ['newest', 'older'],
-    ['stale', 'newest', 'from-disk'],
-    50,
-  );
-  assert.deepEqual(merged, ['newest', 'older', 'from-disk', 'stale']);
-});
-
-test('appendPromptHistory persists per cwd across reload', () => {
-  const dataDir = mkdtempSync(join(tmpdir(), 'mixdog-prompt-history-'));
-  const previous = process.env.MIXDOG_DATA_DIR;
-  process.env.MIXDOG_DATA_DIR = dataDir;
-  try {
-    const cwd = join(dataDir, 'project-a');
-    assert.deepEqual(appendPromptHistory(cwd, 'first prompt'), ['first prompt']);
-    assert.deepEqual(appendPromptHistory(cwd, 'second prompt'), ['first prompt', 'second prompt']);
-    assert.deepEqual(appendPromptHistory(cwd, 'first   prompt'), ['second prompt', 'first   prompt']);
-    const loaded = loadPromptHistory(cwd);
-    assert.deepEqual(loaded, ['second prompt', 'first   prompt']);
-  } finally {
-    if (previous === undefined) delete process.env.MIXDOG_DATA_DIR;
-    else process.env.MIXDOG_DATA_DIR = previous;
-    rmSync(dataDir, { recursive: true, force: true });
-  }
-});
-
-test('pushSessionPromptHistory is cwd-session newest-first with dedupe', () => {
-  let session = pushSessionPromptHistory([], 'alpha');
-  session = pushSessionPromptHistory(session, 'beta');
-  session = pushSessionPromptHistory(session, 'alpha');
-  assert.deepEqual(session, ['alpha', 'beta']);
-});
-