mixdog 0.9.0 → 0.9.1

package/src/tui/components/tool-output-format.mjs

@@ -21,6 +21,7 @@ import stripAnsi from 'strip-ansi';
 import {
   extraColorizers,
   highlightCodeLine,
+  highlightCodeBlockToLines,
   colorizeDiffLine,
   looksLikeUnifiedDiff,
   LANG_FAMILY,
@@ -35,13 +36,72 @@ const DEFAULT_MARKDOWN_WIDTH = 80;
 // Hard ceilings so a pathological tool result can never lock the render loop.
 // CC uses ~MAX_LINES*width*4 for the collapsed fold; for the EXPANDED body we
 // cap total characters processed and total lines kept, with an explicit marker.
-const MAX_EXPANDED_CHARS = 256 * 1024; // 256 KB of text gets per-line processing
-const MAX_EXPANDED_LINES = 80; // keep at most this many rendered lines
+export const MAX_EXPANDED_CHARS = 256 * 1024; // 256 KB of text gets per-line processing
+const MAX_EXPANDED_LINES = 4000; // logical-line safety ceiling; physical mount cap is separate
 const MAX_JSON_FORMAT_LENGTH = 10_000; // mirror CC's tryJsonFormatContent cap
 const MAX_HIGHLIGHT_LINE_CHARS = 2000; // skip token-scan on absurdly long lines
 // Lockstep with ToolExecution collapsed fit budget (MIN_RESULT_LINE_CHARS).
 const MIN_EXPANDED_BODY_COLS = 24;
 
+// Hard cap on the number of PHYSICAL (wrapped) rows a single expanded tool /
+// script body may mount. MAX_EXPANDED_LINES bounds LOGICAL lines, but a single
+// very long line with no newlines (minified JSON, a 256 KB single-line blob)
+// wraps into thousands of physical rows — and EACH physical row is a mounted
+// Ink <Text> node that ink re-serializes every frame even while clipped off-
+// screen (clipping only trims write coords, not the serialize pass). So a lone
+// huge expanded item could mount thousands of nodes and stall typing/drag even
+// though it is the only visible transcript item. This cap bounds the mounted
+// node count regardless of line shape; the omitted tail gets a clear marker.
+// It is set generously above what any viewport needs so normal multi-line
+// output (already capped at MAX_EXPANDED_LINES logical lines) is byte-for-byte
+// unchanged — only pathological wide/unwrapped blobs are trimmed. Env-tunable
+// via MIXDOG_TUI_TOOL_OUTPUT_MAX_RENDER_LINES (0 disables); legacy
+// MIXDOG_TUI_EXPANDED_MAX_ROWS is still honored when the primary var is unset.
+export function resolveToolOutputMaxRenderLines() {
+  const raw = process.env.MIXDOG_TUI_TOOL_OUTPUT_MAX_RENDER_LINES;
+  if (raw !== undefined && String(raw).trim() !== '') {
+    const v = Number(raw);
+    if (Number.isFinite(v) && v <= 0) return 0;
+    if (Number.isFinite(v) && v > 0) return Math.floor(v);
+  }
+  const legacy = process.env.MIXDOG_TUI_EXPANDED_MAX_ROWS;
+  if (legacy !== undefined && String(legacy).trim() !== '') {
+    const v = Number(legacy);
+    if (Number.isFinite(v) && v > 0) return Math.floor(v);
+  }
+  return 600;
+}
+
+function omittedPhysicalRowsMarker(omitted, isShell) {
+  if (isShell) {
+    const n = Math.max(1, Math.floor(Number(omitted) || 0));
+    return `\u2026 [${n} line${n === 1 ? '' : 's'} omitted above \u2014 showing newest output below]`;
+  }
+  return '\u2026 [output truncated for display \u2014 collapse (ctrl+o) or re-read a narrower range]';
+}
+
+function shellLogicalOmittedMarker({ omittedLines = 0, omittedChars = false }, c) {
+  if (omittedLines > 0) {
+    return c.synComment(omittedPhysicalRowsMarker(omittedLines, true));
+  }
+  if (omittedChars) {
+    return c.synComment('\u2026 [earlier output omitted above \u2014 showing newest output below]');
+  }
+  return null;
+}
+
+function finalizeShellPhysicalCap(buffer, omitted, maxRows) {
+  const bodySlots = Math.max(0, maxRows - 1);
+  if (omitted <= 0) {
+    return buffer.length > 0 ? buffer : [' '];
+  }
+  const tail = bodySlots > 0 ? buffer.slice(-bodySlots) : [];
+  const extraHidden = Math.max(0, buffer.length - bodySlots);
+  const totalOmitted = omitted + extraHidden;
+  const out = [omittedPhysicalRowsMarker(totalOmitted, true), ...tail];
+  return out.length > 0 ? out.slice(0, maxRows) : [' '];
+}
+
 // `<n>→<content>` (read) OR `<n>:<content>` / `<path>:<n>:<content>` (grep).
 const READ_LINE_RE = /^(\s*)(\d+)(\u2192)(.*)$/;
 // Gutter ends with `:<line>:`. Windows absolute paths use `X:\...` so the drive
@@ -198,9 +258,12 @@ export function formatExpandedResult(text, { pathArg = '', isShell = false } = {
 
   // Oversized guard: slice before any O(n) per-line work, append a marker.
   let truncatedChars = false;
+  let shellOmittedLines = 0;
+  let shellOmittedChars = false;
   if (src.length > MAX_EXPANDED_CHARS) {
-    src = src.slice(0, MAX_EXPANDED_CHARS);
-    truncatedChars = true;
+    src = isShell ? src.slice(-MAX_EXPANDED_CHARS) : src.slice(0, MAX_EXPANDED_CHARS);
+    if (isShell) shellOmittedChars = true;
+    else truncatedChars = true;
   }
 
   const carriesAnsi = hasAnsi(src);
@@ -210,8 +273,9 @@ export function formatExpandedResult(text, { pathArg = '', isShell = false } = {
   let lines = src.split('\n');
   let truncatedLines = false;
   if (lines.length > MAX_EXPANDED_LINES) {
-    lines = lines.slice(0, MAX_EXPANDED_LINES);
-    truncatedLines = true;
+    if (isShell) shellOmittedLines = lines.length - MAX_EXPANDED_LINES;
+    lines = isShell ? lines.slice(-MAX_EXPANDED_LINES) : lines.slice(0, MAX_EXPANDED_LINES);
+    if (!isShell) truncatedLines = true;
   }
 
   const c = extraColorizers();
@@ -223,29 +287,31 @@ export function formatExpandedResult(text, { pathArg = '', isShell = false } = {
   if (shouldRenderExpandedMarkdown({ src, lines, carriesAnsi, isShell, diffMode, family })) {
     out = formatExpandedMarkdownLines(src);
     if (out.length > MAX_EXPANDED_LINES) {
-      out = out.slice(0, MAX_EXPANDED_LINES);
-      truncatedLines = true;
+      if (isShell) shellOmittedLines += out.length - MAX_EXPANDED_LINES;
+      out = isShell ? out.slice(-MAX_EXPANDED_LINES) : out.slice(0, MAX_EXPANDED_LINES);
+      if (!isShell) truncatedLines = true;
     }
   } else {
-    out = lines.map((line) => formatLine(line, { c, family, diffMode, carriesAnsi, isShell }));
+    if (family && family !== 'md' && !diffMode && !carriesAnsi && !isShell) {
+      out = formatSyntaxBlock(lines, { c, family });
+    } else {
+      out = lines.map((line) => formatLine(line, { c, family, diffMode, carriesAnsi, isShell }));
+    }
   }
 
+  if (isShell) {
+    const marker = shellLogicalOmittedMarker({ omittedLines: shellOmittedLines, omittedChars: shellOmittedChars }, c);
+    if (marker) return [marker, ...out];
+    return out;
+  }
   if (truncatedChars || truncatedLines) {
     out.push(c.synComment('… [output truncated for display — re-read a narrower range]'));
   }
   return out;
 }
 
-/** Format ONE line: split line-number gutter, then highlight/linkify the body. */
-function formatLine(line, { c, family, diffMode, carriesAnsi, isShell }) {
-  // Shell / already-colored output: keep ANSI verbatim, only fix underline leaks
-  // and linkify URLs. No gutter split (shell has no <n>→ prefix).
-  if (carriesAnsi || isShell) {
-    return linkifyUrls(stripUnderlineAnsi(line));
-  }
-
-  // Split a read (`<n>→`) or grep (`<file>:<n>:` / `<n>:`) gutter into a dim
-  // column so the body can be highlighted independently.
+/** Split read/grep line-number gutter from body (shared by per-line and block highlight). */
+function splitGutter(line) {
   let indent = '';
   let gutter = '';
   let body = line;
@@ -262,6 +328,35 @@ function formatLine(line, { c, family, diffMode, carriesAnsi, isShell }) {
       body = gm[4];
     }
   }
+  return { indent, gutter, body };
+}
+
+/** Block syntax highlight for non-diff code bodies (multi-line tokens color correctly). */
+function formatSyntaxBlock(lines, { c, family }) {
+  const parts = lines.map(splitGutter);
+  const bodies = parts.map((p) =>
+    p.body.length > MAX_HIGHLIGHT_LINE_CHARS ? '' : p.body,
+  );
+  const highlighted = highlightCodeBlockToLines(bodies.join('\n'), family, c);
+  return parts.map((p, i) => {
+    const rawBody = p.body;
+    const bodyOut = rawBody.length > MAX_HIGHLIGHT_LINE_CHARS
+      ? c.body(rawBody)
+      : (highlighted[i] ?? '');
+    const linked = linkifyUrls(bodyOut);
+    return p.gutter ? `${p.indent}${c.synComment(p.gutter)}${linked}` : linked;
+  });
+}
+
+/** Format ONE line: split line-number gutter, then highlight/linkify the body. */
+function formatLine(line, { c, family, diffMode, carriesAnsi, isShell }) {
+  // Shell / already-colored output: keep ANSI verbatim, only fix underline leaks
+  // and linkify URLs. No gutter split (shell has no <n>→ prefix).
+  if (carriesAnsi || isShell) {
+    return linkifyUrls(stripUnderlineAnsi(line));
+  }
+
+  const { indent, gutter, body } = splitGutter(line);
 
   const coloredBody = highlightBody(body, { c, family, diffMode });
   const linked = linkifyUrls(coloredBody);
@@ -354,12 +449,51 @@ function wrapOneExpandedLogicalLine(line, maxWidth) {
  * Turn logical expanded lines into physical rows that fit the body column.
  * One output row per left-rail row in ToolExecution (lockstep with App row est.).
  */
-export function wrapExpandedResultLines(logicalLines, columns = 80) {
+export function wrapExpandedResultLines(logicalLines, columns = 80, { isShell = false } = {}) {
+  const maxRows = resolveToolOutputMaxRenderLines();
+  const capOn = maxRows > 0;
   const maxWidth = expandedResultBodyWidth(columns);
   const lines = Array.isArray(logicalLines) ? logicalLines : [];
   const out = [];
-  for (const line of lines) {
-    out.push(...wrapOneExpandedLogicalLine(line, maxWidth));
+
+  if (!capOn) {
+    for (const line of lines) {
+      for (const row of wrapOneExpandedLogicalLine(line, maxWidth)) out.push(row);
+    }
+    return out.length > 0 ? out : [' '];
+  }
+
+  if (isShell) {
+    let omitted = 0;
+    for (const line of lines) {
+      for (const row of wrapOneExpandedLogicalLine(line, maxWidth)) {
+        out.push(row);
+        if (out.length > maxRows) {
+          out.shift();
+          omitted += 1;
+        }
+      }
+    }
+    return finalizeShellPhysicalCap(out, omitted, maxRows);
+  }
+
+  // Non-shell surfaces keep the head of the expanded body (read/grep/json).
+  let truncated = false;
+  outer: for (const line of lines) {
+    for (const row of wrapOneExpandedLogicalLine(line, maxWidth)) {
+      if (out.length < maxRows) {
+        out.push(row);
+      } else {
+        truncated = true;
+        break outer;
+      }
+    }
+  }
+  if (truncated) {
+    const bodySlots = Math.max(0, maxRows - 1);
+    if (out.length > bodySlots) out.length = bodySlots;
+    if (maxRows > 0) out.push(omittedPhysicalRowsMarker(1, false));
+    return out.length > 0 ? out.slice(0, maxRows) : [' '];
   }
   return out.length > 0 ? out : [' '];
 }

package/src/tui/components/tool-output-format.test.mjs

@@ -13,6 +13,21 @@ import stringWidth from 'string-width';
 
 const stripAnsi = (s) => String(s).replace(/\x1b\[[0-9;]*m/g, '').replace(/\x1b\]8;;[^\x07]*\x07/g, '');
 
+function withRenderLineCap(cap, fn) {
+  const prev = process.env.MIXDOG_TUI_TOOL_OUTPUT_MAX_RENDER_LINES;
+  const legacy = process.env.MIXDOG_TUI_EXPANDED_MAX_ROWS;
+  process.env.MIXDOG_TUI_TOOL_OUTPUT_MAX_RENDER_LINES = String(cap);
+  delete process.env.MIXDOG_TUI_EXPANDED_MAX_ROWS;
+  try {
+    return fn();
+  } finally {
+    if (prev === undefined) delete process.env.MIXDOG_TUI_TOOL_OUTPUT_MAX_RENDER_LINES;
+    else process.env.MIXDOG_TUI_TOOL_OUTPUT_MAX_RENDER_LINES = prev;
+    if (legacy === undefined) delete process.env.MIXDOG_TUI_EXPANDED_MAX_ROWS;
+    else process.env.MIXDOG_TUI_EXPANDED_MAX_ROWS = legacy;
+  }
+}
+
 test('inferLangFamily maps known extensions, null otherwise', () => {
   assert.equal(inferLangFamily('src/x.mjs'), 'js');
   assert.equal(inferLangFamily('a.py'), 'py');
@@ -31,6 +46,22 @@ test('read line-number gutter is split into a dim column and body is highlighted
   assert.ok(out[0].includes('\x1b['), 'first line carries color escapes');
 });
 
+test('block syntax highlight skips tokenizer for over-long lines (index aligned)', () => {
+  // MAX_HIGHLIGHT_LINE_CHARS is 2000 in tool-output-format.mjs
+  const giant = 'x'.repeat(2001);
+  const read = `1\u2192const a = 1;\n2\u2192${giant}\n3\u2192const b = 2;`;
+  const out = formatExpandedResult(read, { pathArg: 'a.mjs' });
+  assert.equal(out.length, 3);
+  assert.ok(out[0].includes('\x1b['), 'short line before giant is highlighted');
+  assert.ok(out[2].includes('\x1b['), 'short line after giant is highlighted');
+  const plainMid = stripAnsi(out[1]);
+  assert.ok(plainMid.startsWith('2\u2192'), 'gutter preserved on giant line');
+  assert.ok(plainMid.endsWith(giant), 'giant body preserved');
+  const hljsSpans = (out[1].match(/\x1b\[[0-9;]*m/g) || []).length;
+  const shortSpans = (out[0].match(/\x1b\[[0-9;]*m/g) || []).length;
+  assert.ok(hljsSpans <= shortSpans + 2, 'giant line not fully tokenized like normal code');
+});
+
 test('grep file:line: gutter is split too', () => {
   const grep = 'src/a.mjs:5581:  value: foo,';
   const out = formatExpandedResult(grep, { pathArg: 'src/a.mjs' });
@@ -105,9 +136,13 @@ test('unified diff is colored by line class', () => {
 test('oversize output is capped with a truncation marker', () => {
   const many = Array.from({ length: 5000 }, (_, i) => `line${i}`).join('\n');
   const out = formatExpandedResult(many, {});
-  assert.ok(out.length <= 81);
+  assert.ok(out.length <= 4001, 'logical cap keeps at most MAX_EXPANDED_LINES plus marker');
   assert.ok(/truncated/.test(stripAnsi(out[out.length - 1])));
 
+  const sixHundred = Array.from({ length: 600 }, (_, i) => `row${i}`).join('\n');
+  const out600 = formatExpandedResult(sixHundred, {});
+  assert.equal(out600.length, 600, 'normal expanded output is not truncated at 80 logical lines');
+
   const huge = 'x'.repeat(300 * 1024);
   const out2 = formatExpandedResult(huge, {});
   assert.ok(/truncated/.test(stripAnsi(out2[out2.length - 1])));
@@ -218,3 +253,60 @@ test('read gutter lines skip markdown mode and keep syntax highlight', () => {
   assert.ok(visible.some((l) => l.includes('const y = 2;')), 'read body preserved');
   assert.ok(out.some((l) => stripAnsi(l).includes('const y = 2;') && l.includes('\x1b[')), 'code line still highlighted');
 });
+
+test('shell physical cap keeps newest rows across logical lines', () => {
+  withRenderLineCap(5, () => {
+    const long = 'W'.repeat(240);
+    const logical = formatExpandedResult(`${long}\nNEWEST_TAIL_LINE`, { isShell: true });
+    const physical = wrapExpandedResultLines(logical, 32, { isShell: true });
+    const visible = physical.map(stripAnsi);
+    assert.ok(visible.some((l) => l.includes('NEWEST_TAIL_LINE')), 'newest logical line survives rolling cap');
+    assert.ok(physical.length <= 5);
+    assert.ok(visible.some((l) => /omitted above/i.test(l)));
+  });
+});
+
+test('exact physical cap row count is not truncated', () => {
+  withRenderLineCap(10, () => {
+    const logical = Array.from({ length: 10 }, (_, i) => `row-${i}`).map((l) => formatExpandedResult(l, { isShell: true })[0]);
+    const physical = wrapExpandedResultLines(logical, 80, { isShell: true });
+    assert.equal(physical.length, 10);
+    assert.ok(!physical.some((l) => /omitted above/i.test(stripAnsi(l))));
+  });
+});
+
+test('physical cap of 1 never returns more than one row', () => {
+  withRenderLineCap(1, () => {
+    const physical = wrapExpandedResultLines(formatExpandedResult('a\nb\nc', { isShell: true }), 80, { isShell: true });
+    assert.ok(physical.length <= 1);
+    const physicalNonShell = wrapExpandedResultLines(formatExpandedResult('a\nb\nc', {}), 80, { isShell: false });
+    assert.ok(physicalNonShell.length <= 1);
+  });
+});
+
+test('shell physical cap omitted count includes marker slot', () => {
+  withRenderLineCap(5, () => {
+    const logical = ['r0', 'r1', 'r2', 'r3', 'r4', 'r5'].map((l) => formatExpandedResult(l, { isShell: true })[0]);
+    const physical = wrapExpandedResultLines(logical, 80, { isShell: true });
+    const visible = physical.map(stripAnsi);
+    assert.equal(physical.length, 5);
+    assert.match(visible[0], /2 lines omitted above/);
+    assert.deepEqual(visible.slice(1), ['r2', 'r3', 'r4', 'r5']);
+  });
+  withRenderLineCap(1, () => {
+    const logical = Array.from({ length: 6 }, (_, i) => `row${i}`).map((l) => formatExpandedResult(l, { isShell: true })[0]);
+    const physical = wrapExpandedResultLines(logical, 80, { isShell: true });
+    assert.equal(physical.length, 1);
+    assert.match(stripAnsi(physical[0]), /6 lines omitted above/);
+  });
+});
+
+test('shell logical truncation marker precedes retained tail', () => {
+  const many = Array.from({ length: 5000 }, (_, i) => `line${i}`).join('\n');
+  const out = formatExpandedResult(many, { isShell: true });
+  const visible = out.map(stripAnsi);
+  assert.ok(visible.length <= 4001);
+  assert.ok(/omitted above/i.test(visible[0]), 'shell marker is first row');
+  assert.ok(visible[visible.length - 1].includes('line4999'), 'newest logical line is last');
+  assert.ok(!visible[visible.length - 1].includes('re-read a narrower range'));
+});