@semalt-ai/code 1.8.5 → 1.20.0

package/lib/ui/render-operation.js

@@ -0,0 +1,113 @@
+'use strict';
+
+// Pure renderer for a ToolOperation descriptor (Output Refactor — Phase 1).
+//
+// `renderOperation(descriptor, { mode, phase, maxLines })` → the string for that
+// phase/mode. This is the SINGLE place a tool-call's chrome line is assembled
+// for the interactive path; chat-turn.js builds a descriptor and calls here
+// instead of assembling formatToolLine arguments inline.
+//
+// Phase 1 is a re-routing, not a re-styling: the renderer internally reuses the
+// existing `formatToolLine` (glyph/category/operation/meta assembly) and
+// `buildExecutionDiff` (diff body), so its output is byte-for-byte identical to
+// today's. Do NOT change glyphs, spacing, colours, or wording here — equivalence
+// with the old formatters is the phase's pass/fail.
+//
+// modes:  'ansi'  (interactive) — assembles the chrome line via formatToolLine.
+//         'json'  (Phase 6d-i) — the pure embeddable per-operation object built
+//                 from the shared `operationCore` (descriptor-native names, no
+//                 ANSI/IO/framing); a superset-or-equal of serializeOperation's
+//                 persistable core, minus the `v` persistence tag.
+//         'event' (Phase 6d-i) — the json object plus the `phase` it rendered
+//                 for, for a single per-lifecycle emission. Headless (6d-ii)
+//                 owns any NDJSON envelope / `type` tag around it.
+// phases: 'pending' — the live activity line (with growing timer)
+//         'result'  — the committed final line
+//         'detail'  — the collapsible body (Phase 5): a file-edit diff (expanded
+//                     to maxLines) or a shell/MCP/subagent output preview
+//                     (previewLines + `… N more lines`). Errors carry no detail
+//                     (expanded elsewhere).
+
+const { formatToolLine, formatOutputPreview } = require('./format');
+const { buildExecutionDiff } = require('./diff');
+const { operationCore } = require('./tool-operation');
+
+// Map the descriptor's status vocabulary back to formatToolLine's.
+function _formatStatus(descriptor, phase) {
+  if (phase === 'pending') return 'pending';
+  return descriptor.status === 'error' ? 'failure' : 'success';
+}
+
+// Reconstruct the formatToolLine argument bag from the descriptor. Phase 1
+// guarantees identical output by feeding the same fields the old call sites did.
+function _toolLineArgs(descriptor, phase) {
+  return {
+    status: _formatStatus(descriptor, phase),
+    // Colour is resolved from the descriptor's category (Phase 2.5): the
+    // renderer hands formatToolLine the already-resolved category so colour is
+    // the renderer's job, keyed by the descriptor, not re-derived from the tag.
+    category: descriptor.category,
+    tag: descriptor.tag,
+    arg: descriptor.target,
+    attrs: descriptor.attrs,
+    durationMs: descriptor.durationMs == null ? 0 : descriptor.durationMs,
+    meta: phase === 'pending' ? null : descriptor.meta,
+    error: phase === 'pending' ? null : descriptor.error,
+    noDuration: descriptor.noDuration,
+  };
+}
+
+function _renderAnsi(descriptor, opts) {
+  const phase = opts.phase || 'result';
+  if (phase === 'detail') {
+    // The detail body, COLLAPSED per the Phase 5 policy (keyed by detail-kind):
+    //   - diff   → the file-edit diff, EXPANDED to maxLines (unchanged).
+    //   - output → a shell_preview_lines preview + `… N more lines`. (Errors
+    //              carry no detail — the error body renders expanded on the
+    //              chat-history path.)
+    const detail = descriptor.detail;
+    if (!detail) return '';
+    if (detail.kind === 'diff') {
+      const diffStr = buildExecutionDiff({ diff: detail.payload, maxLines: opts.maxLines });
+      return diffStr || '';
+    }
+    if (detail.kind === 'output') {
+      const { lines, hiddenCount } = formatOutputPreview(detail.payload.body, {
+        previewLines: opts.previewLines,
+        cols: opts.cols,
+      });
+      const out = lines.slice();
+      if (hiddenCount > 0) {
+        out.push(`… ${hiddenCount} more ${hiddenCount === 1 ? 'line' : 'lines'}`);
+      }
+      return out.join('\n');
+    }
+    return '';
+  }
+  return formatToolLine(_toolLineArgs(descriptor, phase));
+}
+
+function renderOperation(descriptor, opts) {
+  if (!descriptor) return '';
+  const o = opts || {};
+  const mode = o.mode || 'ansi';
+  if (mode === 'ansi') return _renderAnsi(descriptor, o);
+  // json/event are PURE structured-data modes (Phase 6d-i): no ANSI, no IO, no
+  // framing. Both derive ONLY from the shared `operationCore` mapping — the same
+  // one `serializeOperation` uses — so there is exactly one descriptor→data
+  // serializer in the codebase.
+  //   - json : the embeddable per-operation object (descriptor-native field
+  //            names; the persistable core WITHOUT the `v` persistence tag).
+  //   - event: the same data shaped for a single per-lifecycle emission — the
+  //            json object plus the `phase` it was rendered for. The consumer
+  //            (headless, Phase 6d-ii) owns any envelope/`type` framing.
+  if (mode === 'json') return operationCore(descriptor);
+  if (mode === 'event') {
+    const core = operationCore(descriptor);
+    return core && { ...core, phase: o.phase || 'result' };
+  }
+  // unknown mode — degrade to empty string (never throw).
+  return '';
+}
+
+module.exports = { renderOperation };

package/lib/ui/select.js

@@ -11,7 +11,7 @@ const writer = require('./writer');
 // Two input paths:
 //   * TUI:     opts.captureNavigation(handler) → release fn. Mirrors the
 //              permission picker. The host (input-field) routes prev/next/
-//              select/cancel/expand actions to handler; release detaches.
+//              select/cancel actions to handler; release detaches.
 //   * Non-TUI: direct raw stdin. Used by cmdModels and the permission-
 //              prompt fallback in non-chat command flows.
 //
@@ -59,8 +59,6 @@ async function interactiveSelect(items, renderItem, options) {
           writer.clearModal();
           if (typeof releaseNav === 'function') releaseNav();
           resolve(action === 'select' ? idx : null);
-        } else if (action === 'expand') {
-          if (typeof opts.onExpand === 'function') opts.onExpand();
         }
       });
     });
@@ -93,7 +91,6 @@ async function interactiveSelect(items, renderItem, options) {
     const onData = (chunk) => {
       if (done) return;
       const data = chunk.toString('utf8');
-      if (data[0] === '\x0f') { if (typeof opts.onExpand === 'function') opts.onExpand(); return; }
       if (data === '\x03' || data === '\x1b' || data === 'q') { finish(null); return; }
       if (data === '\r' || data === '\n') { finish(idx); return; }
       if (data === '\x1b[A' || data === 'k') {

package/lib/ui/status-bar.js

@@ -1,8 +1,26 @@
 'use strict';
 
-const { RST, DIM, FG_RED, FG_DARK, SPINNER_DEFS } = require('./ansi');
-const { UI_THEME } = require('./theme');
+const { RST, DIM, SPINNER_DEFS } = require('./ansi');
+const { UI_THEME, FG_RED, FG_DARK, colorEnabled } = require('./theme');
 const { stripAnsi, termWidth } = require('./utils');
+const { AnimDriver, TICKS_PER_SECOND } = require('./anim');
+
+// States that animate the status-bar spinner (and, in the live region below,
+// the per-tool running glyph + elapsed meter). While in one of these the
+// single driver repaints at the base (100 ms) cadence; otherwise it only
+// repaints for the clock (1 Hz), and when idle-paused it stops entirely.
+const ANIM_STATES = new Set(['thinking', 'streaming', 'tool', 'waiting_download']);
+
+// Compact token count for the estimated split (Variant B): the base/working
+// estimates are shown abbreviated (e.g. 12k, 5.6k, 200k) to keep the row short
+// — they are estimates, so sub-thousand precision is noise. The real measured
+// total is rendered separately with full toLocaleString precision (no ~).
+function abbrevTokens(n) {
+  const v = Math.max(0, Math.round(Number(n) || 0));
+  if (v < 1000) return String(v);
+  const k = v / 1000;
+  return (k < 10 ? k.toFixed(1) : String(Math.round(k))) + 'k';
+}
 
 // Status bar is a *content producer* only. It builds a single line string
 // and hands it to the UI orchestrator via the onChange callback; the
@@ -27,31 +45,85 @@ class FullStatusBar {
     this._reportedContext = 0;
     this._pendingDelta = 0;
     this._contextLimit = null;
+    // Estimated base/working split (Variant B, display-only). Both are char/4
+    // estimates of the same measured prompt; rendered ~-prefixed alongside the
+    // real total. 0 until the agent loop reports the first estimate.
+    this._baseEst = 0;
+    this._workingEst = 0;
     this._speed = 0;
     this._streamStart = null;
     this._streamTokens = 0;
     this._tokensSinceUpdate = 0;
     this._animIdx = 0;
-    this._animTimer = null;
     this._paused = false;
-    // Clock tick drives the `HH:MM:SS` part of the right-hand side. Every
-    // tick just notifies the orchestrator to re-push the live region — the
-    // compound erase+redraw goes through the writer's queue so a tick
-    // falling mid-bubble can't produce a torn frame.
-    this._clockTimer = setInterval(() => this._notify(), 1000);
+    this._destroyed = false;
+    // Single animation driver (Phase 3). Replaces the two independent
+    // setIntervals (1 Hz clock + 100 ms spinner) with one timer. Both the
+    // clock field and the spinner glyph are now *subscribers*: each tick the
+    // driver advances one frame counter, runs both subscribers, and performs
+    // exactly one coordinated repaint (through _notify → the orchestrator →
+    // writer.setLive, which also re-renders the live-region activity rows, so
+    // the per-tool running glyph + elapsed meter ride the same repaint). The
+    // driver runs while there's something to animate OR while the clock should
+    // tick; when idle-paused with nothing animating it STOPS — preserving the
+    // 5404bd0 idle-scroll fix (no periodic redraw → the viewport scrolls).
+    this._driver = new AnimDriver();
+    this._driver.onRepaint(() => this._notify());
+    // Clock subscriber: request a repaint once per second, and only while not
+    // idle-paused (the clock tick is what fought user scrollback).
+    this._driver.subscribe((frame) => !this._paused && (frame % TICKS_PER_SECOND === 0));
+    // Spinner subscriber: while in an animating state, advance the glyph frame
+    // every tick and request the repaint (the fine 100 ms cadence).
+    this._driver.subscribe((frame) => {
+      if (!ANIM_STATES.has(this._state)) return false;
+      this._animIdx = frame;
+      return true;
+    });
+    this._syncDriver();
   }
 
-  pause()  { this._paused = true; }
-  resume() { this._paused = false; this._notify(); }
+  // Start/stop the single driver to match the current need: run while there is
+  // something to animate (ANIM_STATES) OR while the clock should tick (not
+  // idle-paused); stop when neither holds. Idempotent (start()/stop() guard
+  // against stacking), so repeated pause/resume cycles never leak a timer.
+  _syncDriver() {
+    if (this._destroyed) return;
+    const animating = ANIM_STATES.has(this._state);
+    if (!this._paused || animating) this._driver.start();
+    else this._driver.stop();
+  }
+
+  // pause() halts the periodic 1 Hz clock repaint so a forced redraw no longer
+  // snaps the viewport to the bottom while the user scrolls up. If a tool is
+  // mid-flight (an ANIM_STATE) the driver keeps running for the spinner — but
+  // the clock subscriber goes quiet, so there's no 1 Hz scroll-fighting tick.
+  // When nothing is animating, _syncDriver stops the driver outright (idle =
+  // no periodic repaint). Event-driven redraws (update/updateMetrics/setCost)
+  // are unaffected — they call _notify directly. resume() restarts the driver
+  // and forces one repaint so the viewport returns to the input prompt.
+  pause()  { this._paused = true;  this._syncDriver(); }
+  resume() { this._paused = false; this._syncDriver(); this._notify(); }
 
   setModel(name) {
     this._model = name || '';
     this._notify();
   }
 
+  // Session cost string (e.g. "$0.0123" or "unknown"), shown when show_cost is
+  // on (Task 2.6). null/'' hides the field. The caller computes the value from
+  // the price table × usage; the bar just renders it.
+  setCost(str) {
+    this._cost = str || null;
+    this._notify();
+  }
+
   update(state, label) {
     this._state = state || 'idle';
     if (label !== undefined) this._label = label;
+    // A state change means work is happening — keep the not-paused ⇒
+    // driver-running invariant. (update('idle') unconditionally restarts the
+    // driver; the startup re-sync in chat.js re-pauses it if the field is
+    // already idle — see status-bar-resync.test.js.)
     this._paused = false;
 
     if (state === 'streaming') {
@@ -60,12 +132,13 @@ class FullStatusBar {
       this._streamStart = null; this._streamTokens = 0; this._speed = 0;
     }
 
-    const animStates = ['thinking', 'streaming', 'tool', 'waiting_download'];
-    if (animStates.includes(state) && !this._animTimer) {
-      this._animTimer = setInterval(() => { this._animIdx++; this._notify(); }, 100);
-    } else if (!animStates.includes(state) && this._animTimer) {
-      clearInterval(this._animTimer); this._animTimer = null; this._animIdx = 0;
-    }
+    // Leaving an animating state resets the spinner frame so the next run
+    // starts at frame 0 rather than wherever the counter happened to be.
+    if (!ANIM_STATES.has(this._state)) this._animIdx = 0;
+    // One driver, started/stopped as a unit (no per-state timer). The spinner
+    // subscriber animates while in an ANIM_STATE; the clock subscriber ticks
+    // at 1 Hz while not paused.
+    this._syncDriver();
     this._notify();
   }
 
@@ -92,6 +165,10 @@ class FullStatusBar {
       this._reportedContext = data.contextTokens;
       this._pendingDelta = 0;
     }
+    // Estimated split (Variant B) — recomputed per request by the api client and
+    // threaded through here, so it tracks MCP-connect / plan-mode / native-vs-XML.
+    if (typeof data.baseEst === 'number') this._baseEst = data.baseEst;
+    if (typeof data.workingEst === 'number') this._workingEst = data.workingEst;
     if (data.tokenLimit && typeof data.tokenLimit.limit === 'number') {
       this._contextLimit = data.tokenLimit.limit;
     }
@@ -122,9 +199,9 @@ class FullStatusBar {
   // to build the live region. ALWAYS returns a string — the status row is a
   // permanent fixture of the live region, never omitted. Missing data
   // renders as a short placeholder ("—") so the row width is stable.
-  // `_paused` is honored by suppressing the `_notify` *tick* (no forced
-  // redraws while idle) but the row itself is still present when the
-  // composer asks for it.
+  // Pausing (idle scroll) stops the periodic *tick* (the driver is stopped)
+  // but the row itself is still produced whenever the composer asks for it —
+  // an event-driven _notify still repaints normally.
   renderLine() {
     const layout = this._layout;
     const cols = layout.cols;
@@ -163,18 +240,31 @@ class FullStatusBar {
     // tokens, keeping the model name readable to the last. Never chop a
     // field mid-character.
     const tokenField = this._buildTokenField();
+    // Per-field colour (Phase 2.5): the right chrome is no longer wholesale-DIM
+    // — the persistent footer was the single most washed-out region. The model
+    // (the field that matters most) renders in accent; tokens/time/cost/speed
+    // are subtle (one step up from dim). Only the separators stay DIM. Under
+    // NO_COLOR/non-TTY every field colour resolves to ''.
+    const on = colorEnabled();
+    const cSubtle = on ? UI_THEME.subtle : '';
+    const cModel  = on ? UI_THEME.accent : '';
     const fields = [
-      { visible: timePart,           ansi: timePart,           priority: 2 },
-      { visible: this._model || '—', ansi: this._model || '—', priority: 4 },
-      { visible: tokenField.visible, ansi: tokenField.ansi,    priority: 3 },
+      { visible: timePart,           ansi: timePart,           color: cSubtle, priority: 2 },
+      { visible: this._model || '—', ansi: this._model || '—', color: cModel,  priority: 4 },
+      { visible: tokenField.visible, ansi: tokenField.ansi,    color: cSubtle, priority: 3 },
     ];
+    if (this._cost) {
+      const c = `${this._cost}`;
+      fields.push({ visible: c, ansi: c, color: cSubtle, priority: 2 });
+    }
     if (state === 'streaming' && this._speed > 0) {
       const s = `${this._speed} t/s`;
-      fields.push({ visible: s, ansi: s, priority: 1 });
+      fields.push({ visible: s, ansi: s, color: cSubtle, priority: 1 });
     }
 
     const sep = ' · ';
-    const sepAnsi = ` ${RST}${DIM}·${RST}${DIM} `;
+    // Separators stay DIM; fields carry their own colour (no outer DIM wrap).
+    const sepAnsi = on ? ` ${DIM}·${RST} ` : ' · ';
     const leftWidth = termWidth(stripAnsi(left));
     // Keep at least one space between left and right chrome when left is
     // non-empty; when idle (left == '') the right can sit at column 0.
@@ -208,7 +298,8 @@ class FullStatusBar {
     }
 
     const rightWidth = widthOf(keep);
-    const rightAnsi = `${DIM}${keep.map((f) => f.ansi).join(sepAnsi)}${RST}`;
+    const R = on ? RST : '';
+    const rightAnsi = keep.map((f) => `${f.color || ''}${f.ansi}${R}`).join(sepAnsi);
     const padding = Math.max(gap > 0 ? gap : 0, maxCols - leftWidth - rightWidth);
     return left + ' '.repeat(padding) + rightAnsi;
   }
@@ -221,21 +312,35 @@ class FullStatusBar {
   _buildTokenField() {
     const used = Math.max(0, (this._reportedContext | 0) + (this._pendingDelta | 0));
     const usedStr = used.toLocaleString();
+    // Estimated split prefix (Variant B): "~Nk working · ~Nk base · ". Working
+    // first (it's the part that grows and matters), base second (fixed-ish
+    // reference). Both carry ~ — they're char/4 estimates. The measured
+    // total/limit/percent that follows carries NO ~ (it's the truth anchor).
+    // Shown only once an estimate has arrived, so a fresh bar has no ~ noise.
+    let estPrefix = '';
+    if (this._workingEst > 0 || this._baseEst > 0) {
+      estPrefix = `~${abbrevTokens(this._workingEst)} working · ~${abbrevTokens(this._baseEst)} base · `;
+    }
     if (!this._contextLimit) {
-      const s = `${usedStr} tok`;
+      const s = `${estPrefix}${usedStr} tok`;
       return { visible: s, ansi: s };
     }
     const limit = this._contextLimit;
     const pct = limit > 0 ? Math.round((used / limit) * 100) : 0;
     const limitStr = limit.toLocaleString();
-    const visible = `${usedStr} / ${limitStr} tok (${pct}%)`;
+    const visible = `${estPrefix}${usedStr} / ${limitStr} tok (${pct}%)`;
+    // The pct override resets and restores the field's base colour (subtle),
+    // not the old outer DIM. Gated on colour: under NO_COLOR/non-TTY the field
+    // is plain text so no ANSI leaks into a piped status read.
     let pctAnsi = `${pct}%`;
-    if (pct >= 90) {
-      pctAnsi = `${RST}${UI_THEME.error}${pct}%${RST}${DIM}`;
-    } else if (pct >= 70) {
-      pctAnsi = `${RST}${UI_THEME.warning}${pct}%${RST}${DIM}`;
+    if (colorEnabled()) {
+      if (pct >= 90) {
+        pctAnsi = `${RST}${UI_THEME.error}${pct}%${RST}${UI_THEME.subtle}`;
+      } else if (pct >= 70) {
+        pctAnsi = `${RST}${UI_THEME.warning}${pct}%${RST}${UI_THEME.subtle}`;
+      }
     }
-    const ansi = `${usedStr} / ${limitStr} tok (${pctAnsi})`;
+    const ansi = `${estPrefix}${usedStr} / ${limitStr} tok (${pctAnsi})`;
     return { visible, ansi };
   }
 
@@ -244,7 +349,8 @@ class FullStatusBar {
   // affecting surrounding rows.
   renderSeparator() {
     const cols = this._layout.cols;
-    return `${FG_DARK}${'─'.repeat(Math.max(0, cols - 1))}${RST}`;
+    const rule = '─'.repeat(Math.max(0, cols - 1));
+    return colorEnabled() ? `${FG_DARK}${rule}${RST}` : rule;
   }
 
   // Back-compat: older call sites (command.js, create-ui.js) call
@@ -255,13 +361,17 @@ class FullStatusBar {
   _renderBar()    { this._notify(); }
 
   _notify() {
-    if (this._paused) { this._onChange(); return; }
+    // Every redraw — the driver's coordinated tick AND event-driven
+    // (update/updateMetrics/setCost) — flows through here. Pausing is done by
+    // stopping the driver (see pause/_syncDriver), NOT by gating here: a guard
+    // would also suppress the event-driven repaints that must keep working
+    // while idle scroll is paused.
     this._onChange();
   }
 
   destroy() {
-    if (this._animTimer) { clearInterval(this._animTimer); this._animTimer = null; }
-    if (this._clockTimer) { clearInterval(this._clockTimer); this._clockTimer = null; }
+    this._destroyed = true;
+    this._driver.stop();
   }
 }
 

package/lib/ui/stream.js

@@ -8,6 +8,24 @@ const writer = require('./writer');
 
 const THINK_OPEN = '<think>', THINK_CLOSE = '</think>';
 
+// Per-line syntax highlight for a code-block body line. Module-level (uses no
+// instance state) so the TUI styler (lib/ui/md-stream.js) can compose the SAME
+// highlighter the non-TUI StreamRenderer uses — one implementation, no drift.
+// Resets to `${RST}${FG_CODE_BG}` after each span so the caller's code-block
+// background survives to the end of the line (where an EL fills it to the edge).
+function 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;
+}
+
 class StreamRenderer {
   constructor(options) {
     const opts = options || {};
@@ -137,18 +155,7 @@ class StreamRenderer {
     writer.scrollback(`  ${FG_TAG}◆ ${name}${RST} ${FG_DARK}${preview}${RST}`);
   }
 
-  _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;
-  }
+  _colorizeCode(line) { return colorizeCode(line); }
 }
 
-module.exports = { StreamRenderer };
+module.exports = { StreamRenderer, colorizeCode };