@semalt-ai/code 1.19.0 → 1.20.1

package/test/live-height-physical.test.js

@@ -0,0 +1,281 @@
+'use strict';
+
+// Output Refactor · Phase 7a — wrap-aware physical-row live height (fix (B)).
+//
+// THE CHANGE: _liveHeight became a PHYSICAL-row total — the sum of
+// displayRows() over each EMITTED live entry at the current cols — instead of a
+// logical entry count (array.length). Today every emitted entry is pre-fitted
+// to ≤cols-1 by _fitOneRow, so displayRows == 1 per entry and the physical sum
+// EQUALS the old logical count → the erase math (`\x1b[{up}A\r\x1b[J`) emits the
+// identical cursor-up and every compound write is byte-identical. The wrap-aware
+// count only diverges once Phase 7b emits un-truncated multi-row detail.
+//
+// These tests gate that "zero visible change today" claim (byte-identity +
+// numeric no-op across widths), prove the height primitive actually consumes
+// displayRows (multi-row + resize counting), pin displayRows itself, and guard
+// the live-region no-leak invariant the prior phases established.
+
+const { test } = require('node:test');
+const assert = require('node:assert');
+
+const writer = require('../lib/ui/writer');
+const { displayRows } = require('../lib/ui/utils');
+
+// ── Raw-byte capture harness ──────────────────────────────────────────────────
+//
+// Replaces process.stdout.write so we can assert the EXACT bytes the writer
+// emits for a compound write. The writer is a singleton; clearLive() resets its
+// module state between tests so each run starts from _liveHeight=0.
+function withWriter(fn) {
+  const out = process.stdout;
+  const prev = { isTTY: out.isTTY, columns: out.columns, rows: out.rows, write: out.write };
+  let buf = '';
+  out.isTTY = true;
+  out.columns = 80;
+  out.rows = 24;
+  out.write = (s) => { buf += String(s); return true; };
+  const cap = {
+    get: () => buf,
+    reset: () => { buf = ''; },
+    setCols: (n) => { out.columns = n; },
+  };
+  return (async () => {
+    try {
+      await fn(cap);
+    } finally {
+      await writer.clearLive();
+      await writer.flush();
+      out.isTTY = prev.isTTY;
+      out.columns = prev.columns;
+      out.rows = prev.rows;
+      out.write = prev.write;
+    }
+  })();
+}
+
+// A minimal ANSI terminal model (same vocabulary the writer emits) — used only
+// by the no-leak guard at the bottom. `rows.length` is the committed physical
+// footprint; an undercounting erase makes it GROW across repaints.
+function makeVT() {
+  const rows = [''];
+  let r = 0, c = 0;
+  function ensure(row) { while (rows.length <= row) rows.push(''); }
+  function put(ch) {
+    ensure(r);
+    const line = rows[r];
+    rows[r] = line.slice(0, c) + ch + line.slice(c + 1);
+    c++;
+  }
+  function write(s) {
+    let i = 0;
+    while (i < s.length) {
+      const ch = s[i];
+      if (ch === '\x1b' && s[i + 1] === '[') {
+        let j = i + 2;
+        let params = '';
+        while (j < s.length && /[0-9;?<>]/.test(s[j])) { params += s[j]; j++; }
+        const final = s[j];
+        const n = parseInt(params, 10) || 1;
+        if (final === 'A') r = Math.max(0, r - n);
+        else if (final === 'B') { r += n; ensure(r); }
+        else if (final === 'C') c += n;
+        else if (final === 'D') c = Math.max(0, c - n);
+        else if (final === 'J') { ensure(r); rows[r] = rows[r].slice(0, c); rows.length = r + 1; }
+        i = j + 1;
+        continue;
+      }
+      if (ch === '\x1b') { i += 1; continue; }
+      if (ch === '\n') { r++; c = 0; ensure(r); i++; continue; }
+      if (ch === '\r') { c = 0; i++; continue; }
+      put(ch); i++;
+    }
+  }
+  return { rows, write };
+}
+
+// ── Test 1 — byte-identity gate (THE gate) ────────────────────────────────────
+// Guards: every compound write is byte-for-byte what the pre-(B) logical-height
+// code emitted, because the cursor-up count (the only height-dependent byte)
+// equals the entry count while all entries are single-row.
+
+test('byte-identity: setLive emits exact bytes; erase cursor-up == entry count', () =>
+  withWriter(async (cap) => {
+    // Fresh region (_liveHeight=0) → nothing to erase, just hide + draw + LF.
+    await writer.setLive(['hi']);
+    await writer.flush();
+    assert.strictEqual(cap.get(), '\x1b[?25lhi\n', 'first draw: no erase');
+
+    // Second setLive erases exactly 1 physical row (== 1 logical) then redraws.
+    cap.reset();
+    await writer.setLive(['bye']);
+    await writer.flush();
+    assert.strictEqual(cap.get(), '\x1b[?25l\x1b[1A\r\x1b[Jbye\n', 'erase up=1');
+  }));
+
+test('byte-identity: a 3-row live region erases up=3 (logical==physical)', () =>
+  withWriter(async (cap) => {
+    await writer.setLive(['alpha', 'beta', 'gamma']);
+    await writer.flush();
+    assert.strictEqual(writer.getLiveHeight(), 3);
+    cap.reset();
+    await writer.setLive(['delta', 'epsilon', 'zeta']);
+    await writer.flush();
+    assert.strictEqual(cap.get(),
+      '\x1b[?25l\x1b[3A\r\x1b[Jdelta\nepsilon\nzeta\n');
+  }));
+
+test('byte-identity: scrollback erases the exact physical height then redraws', () =>
+  withWriter(async (cap) => {
+    await writer.setLive(['alpha', 'beta', 'gamma']);
+    await writer.flush();
+    cap.reset();
+    await writer.scrollback('note');
+    await writer.flush();
+    assert.strictEqual(cap.get(),
+      '\x1b[?25l\x1b[3A\r\x1b[Jnote\nalpha\nbeta\ngamma\n');
+  }));
+
+test('byte-identity: endActivity commits final line + redraws at exact height', () =>
+  withWriter(async (cap) => {
+    await writer.setLive(['status']);
+    // graceMs:0 → visible immediately; region = [activity, live] → height 2.
+    await writer.startActivity('t1', () => 'running tool', { graceMs: 0 });
+    await writer.flush();
+    assert.strictEqual(writer.getLiveHeight(), 2);
+    cap.reset();
+    await writer.endActivity('t1', 'done tool');
+    await writer.flush();
+    // Erase 2 physical rows, append the final line, redraw remaining live line.
+    assert.strictEqual(cap.get(),
+      '\x1b[?25l\x1b[2A\r\x1b[Jdone tool\nstatus\n');
+  }));
+
+test('byte-identity: identical bytes across terminal widths (short single-row)', () =>
+  withWriter(async (cap) => {
+    // A short entry fits at every width → displayRows==1 → erase up=1 always.
+    for (const cols of [120, 80, 40, 20]) {
+      cap.setCols(cols);
+      await writer.setLive(['x']);
+      await writer.flush();
+      cap.reset();
+      await writer.setLive(['y']);
+      await writer.flush();
+      assert.strictEqual(cap.get(), '\x1b[?25l\x1b[1A\r\x1b[Jy\n', `cols=${cols}`);
+    }
+  }));
+
+// ── Test 2 — numeric no-op proof (7a is a no-op today) ────────────────────────
+// Guards: for all-single-row content, _liveHeight === activity+modal+live entry
+// count (the OLD formula) — i.e. Σ displayRows == array.length for fitted rows.
+
+test('numeric no-op: physical height equals the old logical entry count', () =>
+  withWriter(async (cap) => {
+    for (const cols of [80, 40, 24, 120]) {
+      cap.setCols(cols);
+      await writer.setLive(['one', 'two', 'three']);
+      await writer.flush();
+      assert.strictEqual(writer.getLiveHeight(), 3, `cols=${cols}: live(3)`);
+    }
+    // activity(1) + modal(2) + live(3) = 6 — the full three-contributor sum.
+    await writer.setModal(['m1', 'm2']);
+    await writer.startActivity('a', () => 'act', { graceMs: 0 });
+    await writer.flush();
+    assert.strictEqual(writer.getLiveHeight(), 1 + 2 + 3,
+      'physical sum == activity+modal+live count');
+  }));
+
+// ── Test 3 — physical counting is wired (readiness for 7b) ────────────────────
+// Guards: the height source is Σ displayRows, NOT array.length — a wrapping
+// entry counts as its real physical rows. physicalRows() is the exact primitive
+// _drawLiveSeq calls to set _liveHeight.
+
+test('physical counting: physicalRows sums displayRows, counting wraps (not entry count)', () => {
+  // 50 visible cols at width 40 wraps to 2 physical rows; array.length says 1.
+  assert.strictEqual(writer.physicalRows(['x'.repeat(50)], 40), 2);
+  assert.strictEqual(writer.physicalRows(['y'.repeat(100)], 40), 3); // ceil(100/40)
+  // Mixed: short(1) + wrapping(3) = 4 — proves a SUM, not the 2-entry count.
+  assert.strictEqual(writer.physicalRows(['short', 'z'.repeat(90)], 40), 1 + 3);
+  // Empty array → 0; non-array → 0 (defensive).
+  assert.strictEqual(writer.physicalRows([], 40), 0);
+  assert.strictEqual(writer.physicalRows(null, 40), 0);
+});
+
+// ── Test 4 — resize recompute (the reason (B) exists) ─────────────────────────
+// Guards: the count is taken at the CURRENT cols, so a wrapping entry recomputes
+// to MORE physical rows as the terminal narrows — exactly the recompute
+// _drawLiveSeq performs on every redrawLive() so the next _eraseSeqForHeight()
+// cursor-ups by the correct physical total after a resize.
+
+test('resize recompute: a wrapping entry counts as MORE physical rows at narrower cols', () => {
+  const entry = 'w'.repeat(60);
+  assert.strictEqual(writer.physicalRows([entry], 80), 1); // fits → 1
+  assert.strictEqual(writer.physicalRows([entry], 40), 2); // ceil(60/40)
+  assert.strictEqual(writer.physicalRows([entry], 20), 3); // ceil(60/20)
+});
+
+test('resize recompute (real path): redrawLive recomputes _liveHeight at the new cols', () =>
+  withWriter(async (cap) => {
+    await writer.setLive(['a short line']);
+    await writer.flush();
+    assert.strictEqual(writer.getLiveHeight(), 1);
+    // Shrink the terminal and redraw: the fitted single-row entry stays 1 row,
+    // and the erase cursor-ups by exactly the recomputed physical height.
+    cap.setCols(20);
+    cap.reset();
+    await writer.redrawLive();
+    await writer.flush();
+    assert.strictEqual(writer.getLiveHeight(), 1);
+    assert.ok(cap.get().startsWith('\x1b[?25l\x1b[1A\r\x1b[J'),
+      `erase up == recomputed height: ${JSON.stringify(cap.get())}`);
+  }));
+
+// ── Test 5 — displayRows unit (the underlying primitive) ──────────────────────
+
+test('displayRows: cols-aware ceil, empty line = 1, ANSI-stripped width', () => {
+  assert.strictEqual(displayRows('', 80), 1);              // empty → 1 row
+  assert.strictEqual(displayRows('abc', 80), 1);
+  assert.strictEqual(displayRows('x'.repeat(80), 80), 1);  // exactly fills → 1
+  assert.strictEqual(displayRows('x'.repeat(81), 80), 2);  // one over → 2
+  assert.strictEqual(displayRows('a\nb', 80), 2);          // two logical lines
+  assert.strictEqual(displayRows('a\n\nb', 80), 3);        // blank middle = 1
+  // ANSI/SGR is stripped before width measurement → colored 80-col line is 1.
+  assert.strictEqual(displayRows('\x1b[31m' + 'x'.repeat(80) + '\x1b[0m', 80), 1);
+});
+
+// ── Test 6 — no-leak guard (scroll-fix invariant unchanged) ───────────────────
+// Guards: the live-region erase/redraw still strands ZERO rows in scrollback
+// across repaints. The full status-bar-{driver,pause,resync} and
+// output-heredoc-leak suites cover the anim-driver pause/resume + startup-resync
+// transitions; this re-checks the core no-growth invariant under the new
+// physical-height math directly.
+
+test('no-leak: repeated redraws of single-row content never grow the footprint', () => {
+  const vt = makeVT();
+  const out = process.stdout;
+  const prev = { isTTY: out.isTTY, columns: out.columns, rows: out.rows, write: out.write };
+  out.isTTY = true;
+  out.columns = 80;
+  out.rows = 24;
+  out.write = (s) => { vt.write(String(s)); return true; };
+  return (async () => {
+    try {
+      await writer.setLive(['⣯ Running shell: echo hello']);
+      await writer.flush();
+      const baseline = vt.rows.length;
+      assert.strictEqual(writer.getLiveHeight(), 1);
+      for (let i = 0; i < 12; i++) {
+        await writer.redrawLive();
+        await writer.flush();
+        assert.strictEqual(vt.rows.length, baseline,
+          `repaint ${i + 1}: footprint grew (${vt.rows.length} > ${baseline}) — leak`);
+      }
+    } finally {
+      await writer.clearLive();
+      await writer.flush();
+      out.isTTY = prev.isTTY;
+      out.columns = prev.columns;
+      out.rows = prev.rows;
+      out.write = prev.write;
+    }
+  })();
+});

package/test/max-iterations.test.js

@@ -1,7 +1,7 @@
 'use strict';
 
 // Iteration-cap tests (Pre-Task 4.0a). The primary agent loop must stop at an
-// explicit default (50), be overridable via --max-iterations / config, support
+// explicit default (125), be overridable via --max-iterations / config, support
 // an explicit "unbounded" choice, terminate GRACEFULLY at the cap (clear
 // message + stopReason), and surface that stop reason in headless json output.
 
@@ -133,16 +133,18 @@ test('unbounded (Infinity) runs until the model stops on its own', async () => {
 // 4. Config / flag resolution
 // ---------------------------------------------------------------------------
 
-test('config default max_iterations is 50', () => {
-  assert.strictEqual(DEFAULT_MAX_ITERATIONS, 50);
-  assert.strictEqual(normalizeConfig({}).max_iterations, 50);
+test('config default max_iterations is 125', () => {
+  // Default raised to 125 by design (lib/constants.js DEFAULT_MAX_ITERATIONS).
+  assert.strictEqual(DEFAULT_MAX_ITERATIONS, 125);
+  assert.strictEqual(normalizeConfig({}).max_iterations, 125);
 });
 
 test('normalizeConfig accepts a positive override and falls back on garbage', () => {
   assert.strictEqual(normalizeConfig({ max_iterations: 7 }).max_iterations, 7);
-  assert.strictEqual(normalizeConfig({ max_iterations: -3 }).max_iterations, 50);
-  assert.strictEqual(normalizeConfig({ max_iterations: 'banana' }).max_iterations, 50);
-  assert.strictEqual(normalizeConfig({ max_iterations: 4.5 }).max_iterations, 50);
+  // Negative/garbage/fractional input falls back to the default (125 by design).
+  assert.strictEqual(normalizeConfig({ max_iterations: -3 }).max_iterations, 125);
+  assert.strictEqual(normalizeConfig({ max_iterations: 'banana' }).max_iterations, 125);
+  assert.strictEqual(normalizeConfig({ max_iterations: 4.5 }).max_iterations, 125);
 });
 
 test('0 and "unlimited" normalize to the unlimited sentinel (0)', () => {

package/test/md-stream.test.js

@@ -0,0 +1,183 @@
+'use strict';
+
+// Focused tests for lib/ui/md-stream.js — the line-at-a-time Markdown → ANSI
+// styler that drives both live agent narration and --resume / history replay.
+
+const { test } = require('node:test');
+const assert = require('node:assert');
+
+// The styler gates colour through theme.colorEnabled(), which requires a TTY and
+// no NO_COLOR. Force a colour-on baseline before requiring anything.
+process.stdout.isTTY = true;
+delete process.env.NO_COLOR;
+process.stdout.columns = 80;
+
+const { StreamMarkdown, renderBlock } = require('../lib/ui/md-stream');
+const { ChatHistory } = require('../lib/ui/chat-history');
+
+const stripAnsi = (s) => String(s).replace(/\x1b\[[0-9;]*m/g, '');
+const hasAnsi = (s) => /\x1b\[/.test(String(s));
+
+// Feed a multi-line string through a styler line-by-line, then flush. Returns
+// the array of committed (non-null) styled chunks.
+function feedAll(md, text) {
+  const out = [];
+  for (const line of text.split('\n')) {
+    const s = md.feedLine(line);
+    if (s !== null) out.push(s);
+  }
+  const tail = md.flush();
+  if (tail !== null) out.push(tail);
+  return out;
+}
+
+// ── inline spans within a complete line ──────────────────────────────────────
+
+test('inline: bold, italic, and inline code are styled within a line', () => {
+  const md = new StreamMarkdown();
+  const styled = md.feedLine('a **bold** and *em* and `code` here');
+  assert.ok(hasAnsi(styled), 'emits SGR for inline spans');
+  assert.ok(styled.includes('\x1b[1m'), 'bold open');
+  assert.ok(styled.includes('\x1b[3m'), 'italic open');
+  assert.ok(styled.includes('\x1b[38;5;75m'), 'inline-code fg color');
+  // Markers are consumed; the words survive.
+  const plain = stripAnsi(styled);
+  assert.strictEqual(plain, '  a bold and em and code here');
+});
+
+test('inline: every styled line ends reset so no ANSI bleeds forward', () => {
+  const md = new StreamMarkdown();
+  const styled = md.feedLine('plain **bold**');
+  assert.ok(styled.endsWith('\x1b[0m'), 'line ends with RST');
+});
+
+// ── headings, lists, blockquotes, rules ──────────────────────────────────────
+
+test('block: headings, list items, blockquote, and rule are recognised', () => {
+  const md = new StreamMarkdown();
+  assert.strictEqual(stripAnsi(md.feedLine('# Title')).split('\n')[0], '  Title');
+  assert.match(stripAnsi(md.feedLine('## Sub')), /^ {2}Sub/);
+  assert.match(stripAnsi(md.feedLine('### Small')), /^ {2}Small$/);
+  assert.match(stripAnsi(md.feedLine('- item')), /❯ item/);
+  assert.match(stripAnsi(md.feedLine('1. first')), /1\. first/);
+  assert.match(stripAnsi(md.feedLine('> quoted')), /│ quoted/);
+  assert.match(stripAnsi(md.feedLine('---')), /^ {2}─+$/);
+});
+
+// ── fenced code block with a language ────────────────────────────────────────
+
+test('code: a fenced block with a language emits a box at fence close', () => {
+  const md = new StreamMarkdown();
+  assert.strictEqual(md.feedLine('```python'), null, 'open fence emits nothing');
+  assert.strictEqual(md.feedLine('def f():'), null, 'body buffered, nothing emitted');
+  assert.strictEqual(md.feedLine('    return 1'), null);
+  const box = md.feedLine('```');
+  assert.notStrictEqual(box, null, 'closing fence emits the whole box');
+  const lines = stripAnsi(box).split('\n');
+  assert.match(lines[0], /╭.*python/, 'top border carries the language label');
+  assert.match(box, /\x1b\[38;5;176m/, 'a keyword (def/return) is syntax-highlighted');
+  assert.match(box, /\x1b\[K/, 'code body fills background to edge via EL');
+  assert.match(lines[lines.length - 1], /╰─+$/, 'bottom border closes the box');
+});
+
+test('code: a block split across multiple feedLine calls renders both body lines', () => {
+  const md = new StreamMarkdown();
+  md.feedLine('```js');         // open
+  md.feedLine('const a = 1;');
+  md.feedLine('const b = 2;');
+  const box = md.feedLine('```');
+  const plain = stripAnsi(box);
+  assert.match(plain, /const a = 1;/);
+  assert.match(plain, /const b = 2;/);
+});
+
+// ── flush() with an unclosed fence ───────────────────────────────────────────
+
+test('flush: an UNCLOSED fence is closed cleanly with no stranded SGR', () => {
+  const md = new StreamMarkdown();
+  md.feedLine('```python');
+  md.feedLine('x = 1');
+  const tail = md.flush();
+  assert.notStrictEqual(tail, null, 'flush emits the buffered box');
+  const plain = stripAnsi(tail);
+  assert.match(plain, /╭/, 'top border present');
+  assert.match(plain, /╰/, 'bottom border present (fence closed cleanly)');
+  assert.ok(tail.endsWith('\x1b[0m'), 'no SGR left open at the end');
+  // After flush the styler is back to a clean state.
+  assert.strictEqual(md.inCodeBlock, false);
+  assert.strictEqual(md.feedLine('plain again').includes('╭'), false);
+});
+
+// ── NO_COLOR → plain output, no SGR ──────────────────────────────────────────
+
+test('NO_COLOR: output is plain text with no escape codes', () => {
+  process.env.NO_COLOR = '1';
+  try {
+    const md = new StreamMarkdown();
+    const prose = md.feedLine('a **bold** and `code`');
+    assert.strictEqual(hasAnsi(prose), false, 'no SGR under NO_COLOR');
+    assert.strictEqual(prose, '  a bold and code', 'markers stripped, plain prose');
+    // Code blocks also stay plain (box-drawing chars are not ANSI).
+    md.feedLine('```js');
+    md.feedLine('const a = 1;');
+    const box = md.feedLine('```');
+    assert.strictEqual(hasAnsi(box), false, 'no SGR in the code box under NO_COLOR');
+    assert.match(box, /const a = 1;/);
+  } finally {
+    delete process.env.NO_COLOR;
+  }
+});
+
+// ── live-vs-_buildAI parity (the strongest constraint) ───────────────────────
+
+test('parity: live streaming and _buildAI render the SAME bytes for the same content', () => {
+  const content = [
+    'Here is **bold** and `inline`.',
+    '',
+    '- one',
+    '- two',
+    '',
+    '```python',
+    'def f():',
+    '    return 42',
+    '```',
+    'Done.',
+  ].join('\n');
+
+  // (a) Live path: simulate streamToken receiving the content (plus the trailing
+  // newline the model emits) one chunk, then a finalize/flush. Capture commits.
+  const live = new ChatHistory();
+  const liveOut = [];
+  live._commit = (t) => liveOut.push(t);
+  live.streamToken(content + '\n');
+  live._flushStream();
+  // Drop the header (first commit) and the trailing blank-line commit so we
+  // compare only the styled body, which is what _buildAI's renderBlock produces.
+  const liveBody = liveOut.slice(1, -1).join('');
+
+  // (b) Replay path: _buildAI → renderBlock for the same content.
+  const replay = renderBlock(content);
+  // renderBlock returns the body with no trailing newline; the live path commits
+  // each styled chunk followed by '\n'. Normalise by appending the same '\n'.
+  assert.strictEqual(liveBody, replay + '\n', 'live body bytes == replay body bytes');
+});
+
+test('parity: renderBlock matches a manual feed-then-flush over the same lines', () => {
+  const content = 'alpha\n**beta**\n\n```\ncode\n```';
+  const md = new StreamMarkdown();
+  const manual = feedAll(md, content).join('\n');
+  assert.strictEqual(renderBlock(content), manual);
+});
+
+// ── reset() clears cross-turn state ──────────────────────────────────────────
+
+test('reset: clears an in-progress fenced block between turns', () => {
+  const md = new StreamMarkdown();
+  md.feedLine('```python');
+  md.feedLine('leftover');
+  md.reset();
+  assert.strictEqual(md.inCodeBlock, false);
+  // Next turn's first line is treated as prose, not buffered code.
+  const styled = md.feedLine('fresh line');
+  assert.match(stripAnsi(styled), /^ {2}fresh line$/);
+});