mixdog 0.9.1 → 0.9.2

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

@@ -18,6 +18,7 @@
  */
 import stringWidth from 'string-width';
 import stripAnsi from 'strip-ansi';
+import { displayWidth } from '../display-width.mjs';
 import {
   extraColorizers,
   highlightCodeLine,
@@ -114,6 +115,77 @@ const URL_RE = /https?:\/\/[^\s"'<>\x1b\\)\]]+/g;
 // eslint-disable-next-line no-control-regex
 const ANSI_ESCAPE_RE = /\x1b(?:\[[0-9;]*m|\][\s\S]*?(?:\x07|\x1b\\))/g;
 
+// Visible-text tab stop for expanded tool output (cosmetic; what matters is that
+// no raw \t survives the width math).
+const TOOL_OUTPUT_TAB_SIZE = 2;
+// Match ONE CSI-SGR or OSC sequence anchored at the string start (for the
+// ANSI-aware control normalizer below). Kept separate from the global
+// ANSI_ESCAPE_RE so neither one's lastIndex perturbs the other.
+// eslint-disable-next-line no-control-regex
+const ANSI_SEQ_AT_START_RE = /^\x1b(?:\[[0-9;]*m|\][\s\S]*?(?:\x07|\x1b\\))/;
+
+/**
+ * ANSI-aware control normalization for expanded tool output.
+ *
+ * Why: string-width counts a raw \t (and other C0 controls) as ZERO cells, so
+ * `wrapExpandedResultLines` under-wraps a tab-bearing line; the row then renders
+ * past the truncate width and the terminal EXPANDS the surviving tab to a tab
+ * stop, bleeding the line THROUGH the bottom prompt box on scroll. We must
+ * expand tabs / strip stray controls in the VISIBLE text — but tool output can
+ * also carry legitimate color (SGR) and OSC-8 hyperlink escapes, so those
+ * sequences are copied through verbatim (zero visible columns) instead of being
+ * mangled. CRLF/lone CR → LF; other C0 + DEL (except LF) → a single space.
+ */
+function normalizeToolOutputControls(text) {
+  const input = String(text ?? '');
+  if (input.length === 0) return input;
+  let out = '';
+  let col = 0;
+  let i = 0;
+  while (i < input.length) {
+    const ch = input[i];
+    if (ch === '\x1b') {
+      // Copy a recognized SGR/OSC escape verbatim (no visible width); only a
+      // lone/unknown ESC falls through to the control-strip branch below.
+      const m = ANSI_SEQ_AT_START_RE.exec(input.slice(i));
+      if (m) {
+        out += m[0];
+        i += m[0].length;
+        continue;
+      }
+    }
+    if (ch === '\n') { out += '\n'; col = 0; i += 1; continue; }
+    if (ch === '\r') {
+      // CR or CRLF → a single LF.
+      out += '\n'; col = 0; i += 1;
+      if (input[i] === '\n') i += 1;
+      continue;
+    }
+    if (ch === '\t') {
+      const advance = TOOL_OUTPUT_TAB_SIZE - (col % TOOL_OUTPUT_TAB_SIZE);
+      out += ' '.repeat(advance);
+      col += advance;
+      i += 1;
+      continue;
+    }
+    const cp = input.codePointAt(i);
+    const step = cp > 0xffff ? 2 : 1;
+    if (cp <= 0x1f || cp === 0x7f) {
+      // Remaining C0 control / DEL (and lone ESC): a space so it cannot move the
+      // terminal cursor after ink has already accounted for the row.
+      out += ' ';
+      col += 1;
+      i += step;
+      continue;
+    }
+    const chr = String.fromCodePoint(cp);
+    out += chr;
+    col += stringWidth(chr);
+    i += step;
+  }
+  return out;
+}
+
 
 /** Infer a highlighter family from a read/grep path arg's extension. */
 export function inferLangFamily(pathArg) {
@@ -267,6 +339,13 @@ export function formatExpandedResult(text, { pathArg = '', isShell = false } = {
   }
 
   const carriesAnsi = hasAnsi(src);
+  // Expand tabs / strip stray controls so a tab-bearing line cannot bleed
+  // through the bottom prompt box on scroll (string-width measures \t as zero
+  // cells; the terminal expands it after ink's row accounting). ANSI-aware:
+  // SGR/OSC escapes are preserved verbatim, so this runs unconditionally —
+  // colored shell output and OSC-8 links keep their escapes while their VISIBLE
+  // text is normalized.
+  src = normalizeToolOutputControls(src);
   // JSON pretty only when the text is not already colored (don't reflow ANSI).
   if (!carriesAnsi) src = tryFormatJson(src);
 
@@ -395,21 +474,17 @@ function splitAnsiByPlainWidth(text, plainTarget) {
   while (i < src.length) {
     if (plain >= target) break;
     if (src[i] === '\x1b') {
-      const rest = src.slice(i);
-      const sgr = rest.match(/^\x1b\[[0-9;]*m/);
-      if (sgr) {
-        i += sgr[0].length;
-        continue;
-      }
-      const osc = rest.match(/^\x1b\]8;;[^\x07]*\x07/);
-      if (osc) {
-        i += osc[0].length;
+      // Recognize SGR + OSC-8 (BEL- OR ST-terminated) via the shared matcher so
+      // the split never lands inside an escape sequence for either terminator.
+      const m = ANSI_SEQ_AT_START_RE.exec(src.slice(i));
+      if (m) {
+        i += m[0].length;
         continue;
       }
     }
     const cp = src.codePointAt(i);
     const ch = String.fromCodePoint(cp);
-    plain += stringWidth(ch);
+    plain += displayWidth(ch);
     i += cp > 0xffff ? 2 : 1;
   }
   return [src.slice(0, i), src.slice(i)];
@@ -417,30 +492,88 @@ function splitAnsiByPlainWidth(text, plainTarget) {
 
 function leadingPrefixPlainWidth(plainLine) {
   const rm = READ_LINE_RE.exec(plainLine);
-  if (rm) return stringWidth(rm[1] + rm[2] + rm[3]);
+  if (rm) return displayWidth(rm[1] + rm[2] + rm[3]);
   const gm = GREP_LINE_RE.exec(plainLine);
-  if (gm) return stringWidth(gm[1] + gm[2] + gm[3]);
+  if (gm) return displayWidth(gm[1] + gm[2] + gm[3]);
   return 0;
 }
 
+/**
+ * Hard-cut an ANSI string so its VISIBLE (displayWidth) width is <= maxWidth.
+ * ANSI/OSC-8 escapes are preserved verbatim (zero visible width) and never cut
+ * mid-sequence. This is the final safety clamp: `wrapText` measures with
+ * string-width, so an arrow-bearing row it accepts as fitting can still render
+ * 1+ cells wider under the wide policy — this guarantees no emitted row can
+ * exceed maxWidth in real terminal cells and trigger terminal autowrap.
+ *
+ * Single forward pass: accumulate visible code points until the next one would
+ * overflow `max`, then drop the remaining VISIBLE glyphs while still copying
+ * every trailing escape (SGR resets, OSC-8 closers) verbatim — so a clamped
+ * colored/hyperlinked row can never leak an unbalanced/open sequence into later
+ * TUI cells. Escapes are zero-width, so keeping all of them can never push the
+ * result past `max`; the pass always terminates (i advances every iteration).
+ */
+function clampRowToDisplayWidth(row, maxWidth) {
+  const src = String(row ?? '');
+  const max = Math.max(0, Math.floor(Number(maxWidth) || 0));
+  if (max <= 0) return src;
+  if (displayWidth(src) <= max) return src;
+  let out = '';
+  let plain = 0;
+  let overflowed = false;
+  let i = 0;
+  while (i < src.length) {
+    if (src[i] === '\x1b') {
+      // Copy any recognized escape (SGR / OSC-8 BEL or ST) verbatim — including
+      // trailing resets/closers AFTER the visible cut point.
+      const m = ANSI_SEQ_AT_START_RE.exec(src.slice(i));
+      if (m) {
+        out += m[0];
+        i += m[0].length;
+        continue;
+      }
+    }
+    const cp = src.codePointAt(i);
+    const step = cp > 0xffff ? 2 : 1;
+    if (!overflowed) {
+      const ch = String.fromCodePoint(cp);
+      const w = displayWidth(ch);
+      if (plain + w > max) {
+        // This glyph would overflow: stop emitting visible text but keep
+        // scanning so trailing escapes are still preserved.
+        overflowed = true;
+      } else {
+        out += ch;
+        plain += w;
+      }
+    }
+    i += step;
+  }
+  return out;
+}
+
 function wrapOneExpandedLogicalLine(line, maxWidth) {
   const src = String(line ?? '');
   if (!src) return [' '];
-  if (stringWidth(src) <= maxWidth) return [src];
+  if (displayWidth(src) <= maxWidth) return [src];
 
   const prefixPlainW = leadingPrefixPlainWidth(stripAnsi(src));
   const [prefix, body] = prefixPlainW > 0
     ? splitAnsiByPlainWidth(src, prefixPlainW)
     : ['', src];
-  const prefixW = stringWidth(prefix);
+  const prefixW = displayWidth(prefix);
   const bodyBudget = Math.max(1, maxWidth - prefixW);
   const bodyPieces = wrapText(body, bodyBudget, { hard: true });
-  if (bodyPieces.length <= 1) return [src];
+  // wrapText measures with string-width, so even the single-piece fast path can
+  // exceed maxWidth under the wide policy — always run the display-width clamp.
+  if (bodyPieces.length <= 1) return [clampRowToDisplayWidth(src, maxWidth)];
 
   const out = [];
   for (let i = 0; i < bodyPieces.length; i++) {
-    if (i === 0) out.push(`${prefix}${bodyPieces[i]}`);
-    else out.push(`${padDisplaySpaces(prefixW)}${bodyPieces[i]}`);
+    const row = i === 0
+      ? `${prefix}${bodyPieces[i]}`
+      : `${padDisplaySpaces(prefixW)}${bodyPieces[i]}`;
+    out.push(clampRowToDisplayWidth(row, maxWidth));
   }
   return out;
 }
@@ -456,11 +589,16 @@ export function wrapExpandedResultLines(logicalLines, columns = 80, { isShell =
   const lines = Array.isArray(logicalLines) ? logicalLines : [];
   const out = [];
 
+  // Safety net: EVERY emitted row (including omitted/oversize markers that
+  // bypass wrapOneExpandedLogicalLine) must satisfy the display-width clamp so
+  // no physical row can exceed maxWidth and trigger terminal autowrap.
+  const clampAll = (rows) => rows.map((row) => clampRowToDisplayWidth(row, maxWidth));
+
   if (!capOn) {
     for (const line of lines) {
       for (const row of wrapOneExpandedLogicalLine(line, maxWidth)) out.push(row);
     }
-    return out.length > 0 ? out : [' '];
+    return out.length > 0 ? clampAll(out) : [' '];
   }
 
   if (isShell) {
@@ -474,7 +612,7 @@ export function wrapExpandedResultLines(logicalLines, columns = 80, { isShell =
         }
       }
     }
-    return finalizeShellPhysicalCap(out, omitted, maxRows);
+    return clampAll(finalizeShellPhysicalCap(out, omitted, maxRows));
   }
 
   // Non-shell surfaces keep the head of the expanded body (read/grep/json).
@@ -493,7 +631,7 @@ export function wrapExpandedResultLines(logicalLines, columns = 80, { isShell =
     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 ? clampAll(out.slice(0, maxRows)) : [' '];
   }
-  return out.length > 0 ? out : [' '];
+  return out.length > 0 ? clampAll(out) : [' '];
 }

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

@@ -10,6 +10,7 @@ import {
   tryFormatJson,
 } from './tool-output-format.mjs';
 import stringWidth from 'string-width';
+import { displayWidthWith } from '../display-width.mjs';
 
 const stripAnsi = (s) => String(s).replace(/\x1b\[[0-9;]*m/g, '').replace(/\x1b\]8;;[^\x07]*\x07/g, '');
 
@@ -46,6 +47,41 @@ 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('non-ANSI tool output expands tabs so width math matches the terminal', () => {
+  // A raw \t is ZERO-width to string-width, so wrapExpandedResultLines would
+  // under-wrap a tab-bearing line and the terminal-expanded tab would bleed
+  // the row through the bottom prompt box on scroll. formatExpandedResult must
+  // normalize tabs to spaces for non-ANSI output.
+  const out = formatExpandedResult('\tindented line', { pathArg: 'a.txt' });
+  const plain = stripAnsi(out.join('\n'));
+  assert.ok(!plain.includes('\t'), 'no raw tab survives non-ANSI tool output');
+  const body = plain.split('\n').find((l) => l.includes('indented line'));
+  assert.ok(body, 'body line present');
+  assert.equal(stringWidth(body), body.length, 'visible width equals char length');
+});
+
+test('shell ANSI output keeps raw control bytes (not normalized)', () => {
+  // ANSI/shell output legitimately carries control bytes in escape sequences;
+  // normalization must be skipped so those survive verbatim.
+  const sh = '\x1b[31mred\x1b[0m';
+  const out = formatExpandedResult(sh, { isShell: true });
+  assert.ok(out.join('').includes('\x1b['), 'escape sequences preserved');
+});
+
+test('colored shell output still expands visible tabs (ANSI-aware normalize)', () => {
+  // A colored line with a raw \t in its VISIBLE text: the SGR escapes must be
+  // preserved verbatim while the tab is expanded, so the visible width matches
+  // the terminal and the row cannot bleed through the prompt box on scroll.
+  const sh = '\x1b[32m\tgreen tabbed\x1b[0m';
+  const out = formatExpandedResult(sh, { isShell: true });
+  const joined = out.join('\n');
+  assert.ok(joined.includes('\x1b['), 'color escapes preserved');
+  assert.ok(!joined.includes('\t'), 'visible tab expanded even in colored output');
+  const body = stripAnsi(joined).split('\n').find((l) => l.includes('green tabbed'));
+  assert.ok(body, 'body line present');
+  assert.equal(stringWidth(body), body.length, 'visible width equals char length');
+});
+
 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);
@@ -310,3 +346,54 @@ test('shell logical truncation marker precedes retained tail', () => {
   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'));
 });
+
+test('wide policy OFF: displayWidth is byte-for-byte identical to string-width for arrow lines', () => {
+  // Guards the "non-WT terminals unchanged" invariant: with the policy OFF
+  // (default in this test process — no WT_SESSION, no override), the arrow is
+  // still 1 cell, so wrap output must be identical to the string-width world.
+  const arrowLine = '  12\u2192const x = 1; \u2190 done';
+  assert.equal(displayWidthWith(arrowLine, false), stringWidth(arrowLine),
+    'policy OFF must equal plain string-width');
+  const logical = formatExpandedResult(arrowLine, { pathArg: 'a.mjs' });
+  const physical = wrapExpandedResultLines(logical, 40);
+  const maxW = expandedResultBodyWidth(40);
+  for (const row of physical) {
+    assert.ok(stringWidth(stripAnsi(row)) <= maxW,
+      `row width ${stringWidth(stripAnsi(row))} exceeds ${maxW} (policy OFF)`);
+  }
+});
+
+test('wide policy ON (forced): every emitted arrow row fits the display-width budget', async () => {
+  // The policy is resolved ONCE at module load, so forcing it requires a fresh
+  // process. Spawn a child with MIXDOG_TUI_AMBIGUOUS_WIDE=1 and assert that
+  // every wrapped read row (containing U+2192) measures <= expandedResultBodyWidth
+  // under the SAME wide policy the terminal will use. Without the clamp,
+  // string-width accepts arrow rows as fitting while the terminal renders them
+  // one cell wider, bleeding into the prompt box.
+  const { execFileSync } = await import('node:child_process');
+  const { fileURLToPath } = await import('node:url');
+  const modUrl = new URL('./tool-output-format.mjs', import.meta.url).href;
+  const dwUrl = new URL('../display-width.mjs', import.meta.url).href;
+  const script = `
+    import { formatExpandedResult, wrapExpandedResultLines, expandedResultBodyWidth } from ${JSON.stringify(modUrl)};
+    import { displayWidth, AMBIGUOUS_WIDE } from ${JSON.stringify(dwUrl)};
+    const strip = (s) => String(s).replace(/\\x1b\\[[0-9;]*m/g, '').replace(/\\x1b\\]8;;[^\\x07]*\\x07/g, '');
+    if (AMBIGUOUS_WIDE !== true) { console.log('POLICY_OFF'); process.exit(2); }
+    const columns = 30;
+    // Many arrows so a naive string-width fit accepts an over-wide row.
+    const body = 'x'.repeat(24) + ' ' + '\\u2192'.repeat(12) + ' tail';
+    const logical = formatExpandedResult('42\\u2192' + body, { pathArg: 'a.mjs' });
+    const physical = wrapExpandedResultLines(logical, columns);
+    const maxW = expandedResultBodyWidth(columns);
+    let bad = 0;
+    for (const row of physical) {
+      if (displayWidth(strip(row)) > maxW) bad++;
+    }
+    console.log(bad === 0 ? 'OK ' + physical.length : 'BAD ' + bad);
+  `;
+  const out = execFileSync(process.execPath, ['--input-type=module', '-e', script], {
+    env: { ...process.env, MIXDOG_TUI_AMBIGUOUS_WIDE: '1', WT_SESSION: '' },
+    encoding: 'utf8',
+  }).trim();
+  assert.ok(out.startsWith('OK'), `expected all rows within budget, got: ${out}`);
+});

package/src/tui/display-width.mjs

@@ -0,0 +1,69 @@
+/**
+ * display-width.mjs — shared visible display-width helper for the assistant
+ * render path.
+ *
+ * Why this exists: string-width@8 defaults East-Asian-Width "Ambiguous" glyphs
+ * to NARROW (1 cell). A specific, common problem set renders 2 cells wide in
+ * Windows Terminal — circled digits / enclosed alphanumerics (U+2460–U+24FF)
+ * and arrows (U+2190–U+21FF). When our width math counts them as 1 but the
+ * terminal draws 2, following text overlaps.
+ *
+ * Policy (narrow + gated + consistent):
+ *   - Widen ONLY the two problem ranges below. NEVER widen box-drawing
+ *     (U+2500–U+257F └ │ ⎿ ─), block elements, or the figures.mjs glyphs —
+ *     those are also EAW-ambiguous but must stay 1 cell.
+ *   - Enabled by default ONLY under Windows Terminal (WT_SESSION set).
+ *   - MIXDOG_TUI_AMBIGUOUS_WIDE overrides the default: '1' forces on, '0'
+ *     forces off; the override always wins.
+ *   - When OFF, behaviour is byte-for-byte identical to plain string-width.
+ *
+ * IMPORTANT: vendor/ink/build/display-width.js replicates this exact policy so
+ * ink's MEASUREMENT agrees with OUR wrap/row math. If you change the ranges or
+ * the gate here, change them THERE too (see the sync note in that file).
+ */
+import stringWidth from 'string-width';
+
+/**
+ * True for code points we treat as wide (2 cells) when the policy is ON:
+ *   - U+2460–U+24FF Enclosed Alphanumerics (① ② ③ …)
+ *   - U+2190–U+21FF Arrows (→ ← ↑ ↓ …)
+ * Deliberately excludes box-drawing / blocks / figures.
+ */
+export function isProblemCodePoint(cp) {
+  return (cp >= 0x2460 && cp <= 0x24ff) || (cp >= 0x2190 && cp <= 0x21ff);
+}
+
+/** Resolve the wide policy from env. Override wins over the WT_SESSION default. */
+export function resolveAmbiguousWidePolicy(env = process.env) {
+  const override = env?.MIXDOG_TUI_AMBIGUOUS_WIDE;
+  if (override === '1') return true;
+  if (override === '0') return false;
+  return Boolean(env?.WT_SESSION);
+}
+
+/** Resolved once at module load (matches the "computed once" requirement). */
+export const AMBIGUOUS_WIDE = resolveAmbiguousWidePolicy();
+
+/**
+ * Pure width with an explicit policy flag (used by tests and by `displayWidth`).
+ * base = string-width (ANSI-aware). When `wide` is on, add +1 for each problem
+ * code point that string-width counted as a single cell, turning it into 2.
+ * ANSI escape bytes are all ASCII and never fall in the problem ranges, so the
+ * raw code-point scan adds nothing for them.
+ */
+export function displayWidthWith(str, wide) {
+  const s = String(str ?? '');
+  const base = stringWidth(s);
+  if (!wide) return base;
+  let extra = 0;
+  for (const ch of s) {
+    const cp = ch.codePointAt(0);
+    if (isProblemCodePoint(cp) && stringWidth(ch) === 1) extra += 1;
+  }
+  return base + extra;
+}
+
+/** Visible display width under the resolved policy. */
+export function displayWidth(str) {
+  return displayWidthWith(str, AMBIGUOUS_WIDE);
+}

package/src/tui/display-width.test.mjs

@@ -0,0 +1,35 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import stringWidth from 'string-width';
+import { displayWidthWith, isProblemCodePoint } from './display-width.mjs';
+
+// Policy ON: the two problem ranges become 2 cells; everything else unchanged.
+test('policy ON widens circled digits and arrows only', () => {
+  assert.equal(displayWidthWith('\u2460', true), 2); // ① circled digit
+  assert.equal(displayWidthWith('\u2192', true), 2); // → rightwards arrow
+  assert.equal(displayWidthWith('a', true), 1); // ASCII unchanged
+  // Box-drawing / figures must NOT be widened by the policy.
+  assert.equal(displayWidthWith('\u2514', true), stringWidth('\u2514')); // └
+  assert.equal(displayWidthWith('\u2502', true), stringWidth('\u2502')); // │
+  assert.equal(displayWidthWith('\u2500', true), stringWidth('\u2500')); // ─
+  assert.equal(displayWidthWith('\u25cf', true), stringWidth('\u25cf')); // ●
+  // Mixed string: base + one +1 per problem code point.
+  assert.equal(displayWidthWith('a\u2460b\u2192', true), stringWidth('a\u2460b\u2192') + 2);
+});
+
+// Policy OFF: byte-for-byte identical to plain string-width.
+test('policy OFF equals string-width', () => {
+  for (const s of ['\u2460', '\u2192', 'a', '\u2514', 'hello \u2192 world', '']) {
+    assert.equal(displayWidthWith(s, false), stringWidth(s));
+  }
+});
+
+test('problem range membership', () => {
+  assert.equal(isProblemCodePoint(0x2460), true);
+  assert.equal(isProblemCodePoint(0x24ff), true);
+  assert.equal(isProblemCodePoint(0x2190), true);
+  assert.equal(isProblemCodePoint(0x21ff), true);
+  assert.equal(isProblemCodePoint(0x2500), false); // box-drawing
+  assert.equal(isProblemCodePoint(0x245f), false); // just below range
+  assert.equal(isProblemCodePoint(0x2200), false); // just above arrows
+});