@semalt-ai/code 1.7.0 → 1.8.0

package/lib/ui/layout.js

@@ -0,0 +1,53 @@
+'use strict';
+
+const { getCols, getRows } = require('./utils');
+
+class LayoutManager {
+  constructor() {
+    this.cols = getCols();
+    this._termRows = getRows();
+    this._rows = this._termRows;
+    this.historyStart = 1;   // first row of the scroll / history region
+    this._contentLines = 0;  // lines written into the history region so far
+    this.inputHeight = 1;
+    this._resizeCb = null;
+    this._heightChangeCb = null;
+    this._handler = () => {
+      this.cols = getCols();
+      this._termRows = getRows();
+      this._rows = this._termRows;
+      if (this._resizeCb) this._resizeCb();
+    };
+    process.stdout.on('resize', this._handler);
+  }
+
+  get rows() { return this._rows; }
+  set rows(n) {
+    const min = this.historyStart + 1 + this.inputHeight + 3;
+    this._rows = Math.max(min, Math.min(n, this._termRows));
+  }
+
+  get historyRows()  { return Math.max(this.historyStart, this._rows - 3 - this.inputHeight); }
+  get statusRow()    { return this._rows - this.inputHeight - 2; }
+  get separatorRow() { return this._rows - this.inputHeight - 1; }
+  get inputRow()     { return this._rows - this.inputHeight; }
+  get hintsRow()     { return this._rows; }
+
+  onResize(cb) { this._resizeCb = cb; }
+  onInputHeightChange(cb) { this._heightChangeCb = cb; }
+
+  setInputHeight(n) {
+    const h = Math.max(1, Math.min(5, n));
+    if (h === this.inputHeight) return;
+    this.inputHeight = h;
+    if (this._heightChangeCb) this._heightChangeCb();
+  }
+
+  moveTo(row, col) { process.stdout.write(`\x1b[${row};${col || 1}H`); }
+
+  destroy() {
+    process.stdout.removeListener('resize', this._handler);
+  }
+}
+
+module.exports = { LayoutManager };

package/lib/ui/legacy.js

@@ -0,0 +1,130 @@
+'use strict';
+
+const readline = require('readline');
+
+const { RST, THEME } = require('./ansi');
+const { getCols } = require('./utils');
+
+// ─── StatusBar ─────────────────────────────────────────────────────────────────
+// Used by cmdCode and cmdEdit for non-TUI status display.
+// Also holds the static StatusBar.current shim wired by createUI.
+
+class StatusBar {
+  constructor() {
+    this._fields = { status: 'idle', model: '', tokens: '', ctx: '', latency: '', elapsed: '' };
+    this._animFrames = ['⠋','⠙','⠹','⠸','⠼','⠴','⠦','⠧','⠇','⠏'];
+    this._animIdx = 0; this._animTimer = null;
+    this._onResize = () => this._handleResize();
+    if (process.stdout.isTTY) { process.stdout.on('resize', this._onResize); this._reserveBottom(); }
+    StatusBar.current = this;
+  }
+  _rows() { return process.stdout.rows || 24; }
+  _reserveBottom() { const rows = this._rows(); process.stdout.write(`\x1b7\x1b[1;${rows - 1}r\x1b8`); this.render(); }
+  _handleResize() { const rows = this._rows(); process.stdout.write(`\x1b7\x1b[1;${rows - 1}r\x1b8`); this.render(); }
+  _startAnim() { if (this._animTimer) return; this._animTimer = setInterval(() => { this._animIdx = (this._animIdx + 1) % this._animFrames.length; this.render(); }, 100); }
+  _stopAnim() { if (this._animTimer) { clearInterval(this._animTimer); this._animTimer = null; } this._animIdx = 0; }
+  render() {
+    if (!process.stdout.isTTY) return;
+    const { loadConfig } = require('../config');
+    const showTokens = loadConfig().show_token_count !== false;
+    const parts = [];
+    if (this._fields.status) {
+      if (this._fields.status === 'streaming' || this._fields.status === 'thinking') {
+        parts.push(`${THEME.tool}${this._animFrames[this._animIdx]}${THEME.reset} ${THEME.dim}${this._fields.status === 'thinking' ? 'Thinking…' : 'Streaming…'}${THEME.reset}`);
+      } else { parts.push(`${THEME.dim}${this._fields.status}${THEME.reset}`); }
+    }
+    if (this._fields.model) parts.push(`${THEME.sys}${this._fields.model}${THEME.reset}`);
+    if (showTokens && this._fields.tokens) parts.push(`${THEME.dim}${this._fields.tokens}${THEME.reset}`);
+    if (showTokens && this._fields.ctx) parts.push(this._fields.ctx);
+    if (this._fields.latency) parts.push(`${THEME.dim}${this._fields.latency}${THEME.reset}`);
+    if (this._fields.elapsed) parts.push(`${THEME.dim}${this._fields.elapsed}${THEME.reset}`);
+    const line = parts.join(` ${THEME.dim}│${THEME.reset} `);
+    const rows = this._rows();
+    process.stdout.write(`\x1b7\x1b[${rows};0H\x1b[K${line}\x1b8`);
+  }
+  update(fields) {
+    if (!process.stdout.isTTY) return;
+    Object.assign(this._fields, fields);
+    if (this._fields.status === 'streaming' || this._fields.status === 'thinking') this._startAnim();
+    else this._stopAnim();
+    this.render();
+  }
+  liveUpdate(fields) { if (!process.stdout.isTTY) return; Object.assign(this._fields, fields); }
+  destroy() {
+    if (!process.stdout.isTTY) return;
+    this._stopAnim();
+    process.stdout.removeListener('resize', this._onResize);
+    const rows = this._rows();
+    process.stdout.write(`\x1b7\x1b[${rows};0H\x1b[K\x1b[r\x1b8`);
+    if (StatusBar.current === this) StatusBar.current = null;
+  }
+}
+StatusBar.current = null;
+
+// ─── interactiveSelect ────────────────────────────────────────────────────────
+
+async function interactiveSelect(items, renderItem, options) {
+  const opts = options || {};
+  const { initialIndex = 0 } = opts;
+  return new Promise((resolve) => {
+    if (!process.stdout.isTTY || !process.stdin.isTTY) { resolve(null); return; }
+    let selectedIndex = Math.max(0, Math.min(initialIndex, items.length - 1));
+    let done = false;
+    const wasRaw = typeof process.stdin.isRaw === 'boolean' ? process.stdin.isRaw : false;
+    const render = () => {
+      readline.moveCursor(process.stdout, 0, -items.length);
+      for (let i = 0; i < items.length; i++) {
+        readline.cursorTo(process.stdout, 0); readline.clearLine(process.stdout, 0);
+        const line = renderItem(items[i], i === selectedIndex);
+        process.stdout.write(line + '\n');
+      }
+    };
+    for (let i = 0; i < items.length; i++) {
+      const line = renderItem(items[i], i === selectedIndex);
+      process.stdout.write(line + '\n');
+    }
+    process.stdin.setRawMode(true); process.stdin.resume();
+    const finish = (result) => {
+      if (done) return; done = true;
+      process.stdin.setRawMode(wasRaw); process.stdin.removeListener('data', onData); process.stdin.pause();
+      // Collapse: show only the selected item, clear the rest
+      const displayIdx = result !== null ? result : items.length - 1;
+      readline.moveCursor(process.stdout, 0, -items.length);
+      readline.cursorTo(process.stdout, 0);
+      process.stdout.write('\x1b[2K' + renderItem(items[displayIdx], true, true) + '\x1b[J\n');
+      resolve(result);
+    };
+    const onData = (chunk) => {
+      if (done) return;
+      const data = chunk.toString('utf8');
+      if (data[0] === '\x0f') { if (opts.onExpand) opts.onExpand(); return; }
+      if (data === '\x03' || data === '\x1b' || data === 'q') { finish(null); return; }
+      if (data === '\r' || data === '\n') { finish(selectedIndex); return; }
+      if (data === '\x1b[A' || data === 'k') { selectedIndex = Math.max(0, selectedIndex - 1); render(); return; }
+      if (data === '\x1b[B' || data === 'j') { selectedIndex = Math.min(items.length - 1, selectedIndex + 1); render(); return; }
+    };
+    process.stdin.on('data', onData);
+  });
+}
+
+// ─── SelectMenu ───────────────────────────────────────────────────────────────
+
+class SelectMenu {
+  constructor(options) {
+    this.options = options;
+    this.selectedIdx = 0;
+  }
+
+  moveUp()  { this.selectedIdx = Math.max(0, this.selectedIdx - 1); }
+  moveDown() { this.selectedIdx = Math.min(this.options.length - 1, this.selectedIdx + 1); }
+  current() { return this.options[this.selectedIdx]; }
+
+  render() {
+    return this.options.map((opt, i) => {
+      if (i === this.selectedIdx) return `  \x1b[7m › ${opt} \x1b[27m`;
+      return `    ${opt}`;
+    }).join('\n');
+  }
+}
+
+module.exports = { StatusBar, interactiveSelect, SelectMenu };

package/lib/ui/status-bar.js

@@ -0,0 +1,130 @@
+'use strict';
+
+const { RST, DIM, FG_RED, SPINNER_DEFS } = require('./ansi');
+const { stripAnsi } = require('./utils');
+
+class FullStatusBar {
+  constructor(layout) {
+    this._layout = layout;
+    this._state = 'idle';
+    this._label = 'Ready';
+    this._model = '';
+    this._totalTokens = 0;
+    this._speed = 0;
+    this._streamStart = null;
+    this._streamTokens = 0;
+    this._tokensSinceUpdate = 0;
+    this._animIdx = 0;
+    this._animTimer = null;
+    this._paused = false;
+    this._clockTimer = setInterval(() => this._renderBar(), 1000);
+  }
+
+  pause()  { this._paused = true; }
+  resume() { this._paused = false; this._renderBar(); }
+
+  setModel(name) {
+    this._model = name || '';
+    this._renderBar();
+  }
+
+  update(state, label) {
+    this._state = state || 'idle';
+    if (label !== undefined) this._label = label;
+
+    // An explicit update must always be visible — unpause so _renderBar() runs.
+    // The pause flag only suppresses timer-driven clock/spinner redraws.
+    this._paused = false;
+
+    if (state === 'streaming') {
+      if (!this._streamStart) { this._streamStart = Date.now(); this._streamTokens = 0; }
+    } else {
+      this._streamStart = null; this._streamTokens = 0; this._speed = 0;
+    }
+
+    const animStates = ['thinking', 'streaming', 'tool'];
+    if (animStates.includes(state) && !this._animTimer) {
+      this._animTimer = setInterval(() => { this._animIdx++; this._renderBar(); }, 100);
+    } else if (!animStates.includes(state) && this._animTimer) {
+      clearInterval(this._animTimer); this._animTimer = null; this._animIdx = 0;
+    }
+    if (state === 'idle') this.drawSeparator();
+    this._renderBar();
+  }
+
+  onToken() {
+    this._streamTokens++;
+    this._tokensSinceUpdate++;
+    if (this._tokensSinceUpdate >= 10) {
+      this._tokensSinceUpdate = 0;
+      if (this._streamStart) {
+        const elapsed = (Date.now() - this._streamStart) / 1000;
+        this._speed = elapsed > 0 ? Math.round(this._streamTokens / elapsed) : 0;
+      }
+      this._renderBar();
+    }
+  }
+
+  updateMetrics(data) {
+    if (data && data.totalTokens !== undefined) this._totalTokens = data.totalTokens;
+    this._renderBar();
+  }
+
+  liveUpdate(fields) {
+    if (fields && fields.tokens) {
+      const n = parseInt(String(fields.tokens), 10);
+      if (!isNaN(n)) this._totalTokens = n;
+    }
+    this._renderBar();
+  }
+
+  _renderBar() {
+    if (this._paused) return;
+    const layout = this._layout;
+    const cols = layout.cols;
+    const row = layout.statusRow;
+    let left = '';
+    const state = this._state;
+
+    if (state === 'idle') {
+      left = '';
+    } else if (state === 'waiting') {
+      left = `${DIM}● Waiting for input${RST}`;
+    } else if (state === 'error') {
+      left = `${FG_RED}✕ ${this._label}${RST}`;
+    } else {
+      const sp = SPINNER_DEFS[state] || SPINNER_DEFS.thinking;
+      const frame = sp.frames[this._animIdx % sp.frames.length];
+      left = `${sp.color}${frame}${RST} ${this._label}`;
+    }
+
+    const now = new Date();
+    const timePart = `${String(now.getHours()).padStart(2,'0')}:${String(now.getMinutes()).padStart(2,'0')}:${String(now.getSeconds()).padStart(2,'0')}`;
+    const rightParts = [timePart];
+    if (this._model) rightParts.push(this._model);
+    if (this._totalTokens > 0) rightParts.push(`${this._totalTokens.toLocaleString()} tok`);
+    if (state === 'streaming' && this._speed > 0) rightParts.push(`${this._speed} t/s`);
+
+    const rightVisible = rightParts.join(' · ');
+    const rightAnsi = `${DIM}${rightParts.join(` ${DIM}·${RST}${DIM} `)}${RST}`;
+    const leftLen = stripAnsi(left).length;
+    const rightLen = rightVisible.length;
+    const padding = Math.max(1, cols - leftLen - rightLen);
+    const line = left + ' '.repeat(padding) + rightAnsi;
+
+    process.stdout.write(`\x1b7\x1b[${row};1H\x1b[2K${line}\x1b8`);
+  }
+
+  drawSeparator() {
+    const layout = this._layout;
+    const { FG_DARK } = require('./ansi');
+    process.stdout.write(`\x1b7\x1b[${layout.separatorRow};1H\x1b[2K${FG_DARK}${'─'.repeat(layout.cols)}${RST}\x1b8`);
+  }
+
+  destroy() {
+    if (this._animTimer) { clearInterval(this._animTimer); this._animTimer = null; }
+    if (this._clockTimer) { clearInterval(this._clockTimer); this._clockTimer = null; }
+  }
+}
+
+module.exports = { FullStatusBar };

package/lib/ui/stream.js

@@ -0,0 +1,158 @@
+'use strict';
+
+const readline = require('readline');
+
+const { RST, DIM, FG_DARK, FG_CODE_BG, FG_CODE_BORDER, FG_CODE_LANG, FG_TAG, FG_FILEPATH, KEYWORDS } = require('./ansi');
+const { renderMarkdown, _mdInline } = require('./diff');
+
+const THINK_OPEN = '<think>', THINK_CLOSE = '</think>';
+
+class StreamRenderer {
+  constructor(options) {
+    const opts = options || {};
+    this.buffer = ''; this.inCodeBlock = false; this.codeLang = '';
+    this.inThinkBlock = false; this._thinkDotCount = 0;
+    this._showThink = opts.showThink || false;
+    this.inToolCall = null;
+    this._firstLinePrefix = opts.firstLinePrefix || null;
+    this._firstLineDone = false; this._firstToken = false;
+    this._streamedText = ''; this._hasToolCall = false; this._linesWritten = 0;
+  }
+
+  _write(str) {
+    for (let i = 0; i < str.length; i++) if (str[i] === '\n') this._linesWritten++;
+    process.stdout.write(str);
+  }
+
+  feed(chunk) {
+    if (!this._firstToken && chunk) {
+      this._firstToken = true;
+      const { StatusBar } = require('./legacy');
+      if (StatusBar.current) StatusBar.current.update({ status: 'streaming' });
+    }
+    this._streamedText += chunk;
+    this.buffer += chunk;
+    while (this.buffer.includes('\n')) {
+      const idx = this.buffer.indexOf('\n');
+      const line = this.buffer.slice(0, idx);
+      this.buffer = this.buffer.slice(idx + 1);
+      this._renderLine(line);
+    }
+  }
+
+  flush() {
+    if (this.buffer) { this._renderLine(this.buffer); this.buffer = ''; }
+    if (this.inThinkBlock) { if (this._showThink) this._write(`${FG_DARK}⟨/thinking⟩${RST}\n`); this.inThinkBlock = false; }
+    if (this.inToolCall) { this._renderToolCall(this.inToolCall); this.inToolCall = null; }
+    if (this.inCodeBlock) { this._write(`  ${FG_CODE_BORDER}╰${'─'.repeat(50)}${RST}\n`); this.inCodeBlock = false; }
+    const { StatusBar } = require('./legacy');
+    if (StatusBar.current) StatusBar.current.update({ status: 'idle' });
+    if (process.stdout.isTTY && !this._hasToolCall && !this._showThink && this._streamedText.trim()) {
+      let prose = this._streamedText;
+      let ts = prose.indexOf(THINK_OPEN);
+      while (ts !== -1) { const te = prose.indexOf(THINK_CLOSE, ts); if (te !== -1) { prose = prose.slice(0, ts) + prose.slice(te + THINK_CLOSE.length); ts = prose.indexOf(THINK_OPEN); } else { prose = prose.slice(0, ts); break; } }
+      prose = prose.split(THINK_CLOSE).join('');
+      if (prose.trim()) {
+        if (this._linesWritten > 0) { readline.moveCursor(process.stdout, 0, -this._linesWritten); readline.cursorTo(process.stdout, 0); process.stdout.write('\x1b[0J'); }
+        renderMarkdown(prose);
+      }
+    }
+  }
+
+  _emitFirstPrefix() { if (this._firstLinePrefix && !this._firstLineDone) { this._firstLineDone = true; return this._firstLinePrefix; } return null; }
+
+  _renderLine(line) {
+    if (line.trim() === '') return;
+    if (this.inThinkBlock) {
+      const closeIdx = line.indexOf(THINK_CLOSE);
+      if (closeIdx !== -1) {
+        const before = line.slice(0, closeIdx), afterClose = line.slice(closeIdx + THINK_CLOSE.length);
+        if (this._showThink && before.trim()) this._write(`  ${DIM}${FG_DARK}◆ ${before}${RST}\n`);
+        this.inThinkBlock = false;
+        if (this._showThink) this._write(`${FG_DARK}⟨/thinking⟩${RST}\n`);
+        if (afterClose.trim()) this._renderLine(afterClose);
+      } else { if (this._showThink && line.trim()) this._write(`  ${DIM}${FG_DARK}◆ ${line}${RST}\n`); }
+      return;
+    }
+    const thinkOpenIdx = line.indexOf(THINK_OPEN);
+    if (thinkOpenIdx !== -1) {
+      const before = line.slice(0, thinkOpenIdx);
+      if (before.trim()) this._renderLine(before);
+      const after = line.slice(thinkOpenIdx + THINK_OPEN.length);
+      const closeIdx = after.indexOf(THINK_CLOSE);
+      if (this._showThink) this._write(`\n  ${FG_DARK}${DIM}⟨thinking⟩${RST}`);
+      if (closeIdx !== -1) {
+        const content = after.slice(0, closeIdx);
+        if (this._showThink) { if (content.trim()) this._write(` ${DIM}${FG_DARK}${content}${RST}`); this._write(`${FG_DARK}⟨/thinking⟩${RST}\n`); }
+        const afterClose = after.slice(closeIdx + THINK_CLOSE.length);
+        if (afterClose.trim()) this._renderLine(afterClose);
+      } else { this.inThinkBlock = true; this._thinkDotCount = 0; if (this._showThink && after.trim()) this._write(`\n  ${DIM}${FG_DARK}◆ ${after}${RST}`); }
+      return;
+    }
+    if (line.trim() === THINK_CLOSE) return;
+    if (/^<\/(exec|shell|run_command|run|read_file|write_file|append_file|echo|list_dir|search_files|delete_file|make_dir|remove_dir|get_env|download|move_file|copy_file|set_env|edit_file|search_in_file|replace_in_file|upload)>/.test(line.trim())) return;
+    if (this.inToolCall) {
+      const closeTag = `</${this.inToolCall.name}>`;
+      const closeIdx = line.indexOf(closeTag);
+      if (closeIdx !== -1) { const before = line.slice(0, closeIdx); if (before.trim()) this.inToolCall.contentLines.push(before); this._renderToolCall(this.inToolCall); this.inToolCall = null; }
+      else { this.inToolCall.contentLines.push(line); }
+      return;
+    }
+    const wm = line.match(/^<write_file\s+path="([^"]+)">([\s\S]*)/);
+    if (wm) {
+      const pfx = this._emitFirstPrefix(); if (pfx) this._write(`  ${pfx}\n`);
+      const filePath = wm[1], rest = wm[2], closeIdx = rest.indexOf('</write_file>');
+      if (closeIdx !== -1) this._renderToolCall({ name: 'write_file', filePath, contentLines: rest.slice(0, closeIdx).split('\n') });
+      else { this.inToolCall = { name: 'write_file', filePath, contentLines: rest ? [rest] : [] }; this._hasToolCall = true; }
+      return;
+    }
+    const tm = line.match(/^<(exec|shell|run_command|run|read_file|append_file|echo|list_dir|search_files|delete_file|make_dir|remove_dir|get_env|download|move_file|copy_file|set_env|edit_file|search_in_file|replace_in_file|upload)>([\s\S]*)/);
+    if (tm) {
+      const pfx = this._emitFirstPrefix(); if (pfx) this._write(`  ${pfx}\n`);
+      const tagName = tm[1], rest = tm[2], closeTag = `</${tagName}>`, closeIdx = rest.indexOf(closeTag);
+      if (closeIdx !== -1) this._renderToolCall({ name: tagName, contentLines: rest.slice(0, closeIdx) ? [rest.slice(0, closeIdx)] : [] });
+      else { this.inToolCall = { name: tagName, contentLines: rest ? [rest] : [] }; this._hasToolCall = true; }
+      return;
+    }
+    if (!this.inCodeBlock && line.length >= 3 && line[0] === '`' && line[1] === '`' && line[2] === '`') {
+      const pfx = this._emitFirstPrefix(); if (pfx) this._write(`  ${pfx}\n`);
+      this.codeLang = line.slice(3).trim();
+      const label = this.codeLang ? ` ${this.codeLang} ` : '';
+      const barLen = Math.max(1, 30 - label.length);
+      this._write(`  ${FG_CODE_BORDER}╭${'─'.repeat(20)}${RST}${FG_CODE_LANG}${label}${RST}${FG_CODE_BORDER}${'─'.repeat(barLen)}${RST}\n`);
+      this.inCodeBlock = true; return;
+    }
+    if (this.inCodeBlock) {
+      if (line.trim() === '```') { this._write(`  ${FG_CODE_BORDER}╰${'─'.repeat(50)}${RST}\n`); this.inCodeBlock = false; }
+      else { this._write(`  ${FG_CODE_BORDER}│${RST} ${FG_CODE_BG}${this._colorizeCode(line)}${RST}\n`); }
+      return;
+    }
+    const pfx = this._emitFirstPrefix(); if (pfx) this._write(`  ${pfx}`);
+    this._write(`  ${_mdInline(line)}\n`);
+  }
+
+  _renderToolCall(call) {
+    this._hasToolCall = true;
+    const name = call.name, lines = call.contentLines || [], content = lines.join('\n').trim();
+    if (name === 'write_file') { process.stdout.write(`  ${FG_TAG}◆ write_file${RST} ${FG_FILEPATH}${call.filePath || ''}${RST} ${FG_DARK}(${lines.length} lines)${RST}\n`); return; }
+    if (name === 'read_file') { process.stdout.write(`  ${FG_TAG}◆ read_file${RST} ${FG_FILEPATH}${content}${RST}\n`); return; }
+    if (name === 'exec' || name === 'shell' || name === 'run_command' || name === 'run') { process.stdout.write(`  ${FG_TAG}◆ exec${RST} ${FG_DARK}${content}${RST}\n`); return; }
+    const preview = content.length > 80 ? content.slice(0, 77) + '...' : content;
+    process.stdout.write(`  ${FG_TAG}◆ ${name}${RST} ${FG_DARK}${preview}${RST}\n`);
+  }
+
+  _colorizeCode(line) {
+    const C_KW = '\x1b[38;5;176m', C_STR = '\x1b[38;5;114m', C_CMT = '\x1b[38;5;242m', C_NUM = '\x1b[38;5;215m', C_RST = `${RST}${FG_CODE_BG}`;
+    let result = '', i = 0;
+    while (i < line.length) {
+      if (line[i] === '#' || (line[i] === '/' && line[i+1] === '/')) { result += `${C_CMT}${line.slice(i)}${C_RST}`; break; }
+      if (line[i] === '"' || line[i] === "'") { const quote = line[i]; let j = i+1; while (j < line.length && line[j] !== quote) { if (line[j] === '\\') j++; j++; } j = Math.min(j+1, line.length); result += `${C_STR}${line.slice(i,j)}${C_RST}`; i = j; continue; }
+      if (/[a-zA-Z_]/.test(line[i])) { let j = i; while (j < line.length && /\w/.test(line[j])) j++; const word = line.slice(i,j); result += KEYWORDS.has(word) ? `${C_KW}${word}${C_RST}` : word; i = j; continue; }
+      if (/\d/.test(line[i])) { let j = i; while (j < line.length && /[\d.]/.test(line[j])) j++; result += `${C_NUM}${line.slice(i,j)}${C_RST}`; i = j; continue; }
+      result += line[i++];
+    }
+    return result;
+  }
+}
+
+module.exports = { StreamRenderer };

package/lib/ui/utils.js

@@ -0,0 +1,45 @@
+'use strict';
+
+function getCols() { return process.stdout.columns || 80; }
+function getRows() { return process.stdout.rows || 24; }
+
+function stripAnsi(str) {
+  return str.replace(/\x1b\[[^m]*m/g, '');
+}
+
+function hr(char, color) {
+  const { FG_DARK, RST } = require('./ansi');
+  const c = char || '─';
+  const col = color || FG_DARK;
+  process.stdout.write(`${col}${c.repeat(getCols())}${RST}\n`);
+}
+
+function boxLine(text, width) {
+  const { FG_DARK, RST, BOX_V } = require('./ansi');
+  const w = width || (getCols() - 4);
+  const visible = stripAnsi(text).length;
+  const pad = Math.max(0, w - visible);
+  return `  ${FG_DARK}${BOX_V}${RST} ${text}${' '.repeat(pad)}${FG_DARK}${BOX_V}${RST}`;
+}
+
+function insertCharAt(text, index, value) {
+  const chars = Array.from(text || '');
+  chars.splice(index, 0, value);
+  return chars.join('');
+}
+
+function removeCharAt(text, index) {
+  const chars = Array.from(text || '');
+  chars.splice(index, 1);
+  return chars.join('');
+}
+
+function isPrintableKey(str, key) {
+  const k = key || {};
+  if (!str || k.ctrl || k.meta) return false;
+  if (k.name === 'return' || k.name === 'enter' || k.name === 'tab') return false;
+  if (k.name && ['up','down','left','right','home','end','pageup','pagedown','escape','delete','backspace'].includes(k.name)) return false;
+  return !/[\x00-\x1f\x7f]/.test(str);
+}
+
+module.exports = { getCols, getRows, stripAnsi, hr, boxLine, insertCharAt, removeCharAt, isPrintableKey };