@semalt-ai/code 1.8.1 → 1.8.4

package/lib/ui/ansi.js

@@ -3,6 +3,17 @@
 const RST  = '\x1b[0m';
 const BOLD = '\x1b[1m';
 const DIM  = '\x1b[2m';
+const EL   = '\x1b[K';    // erase-to-end-of-line using current bg
+
+function bg256(n)        { return `\x1b[48;5;${n}m`; }
+function fg256(n)        { return `\x1b[38;5;${n}m`; }
+function bgRGB(r, g, b)  { return `\x1b[48;2;${r};${g};${b}m`; }
+function fgRGB(r, g, b)  { return `\x1b[38;2;${r};${g};${b}m`; }
+
+function hasTruecolor() {
+  const v = process.env.COLORTERM;
+  return v === 'truecolor' || v === '24bit';
+}
 
 const THEME = {
   user:  '\x1b[36m',
@@ -57,7 +68,8 @@ const SPINNER_DEFS = {
 };
 
 module.exports = {
-  RST, BOLD, DIM, THEME,
+  RST, BOLD, DIM, EL, THEME,
+  bg256, fg256, bgRGB, fgRGB, hasTruecolor,
   FG_GRAY, FG_DARK, FG_BLUE, FG_CYAN, FG_GREEN, FG_YELLOW, FG_RED, FG_TEAL,
   BOX_H, BOX_V, BOX_TL, BOX_TR, BOX_BL, BOX_BR,
   FG_CODE_BG, BG_SELECTED, FG_CODE_BORDER, FG_CODE_LANG, FG_TAG, FG_FILEPATH,

package/lib/ui/chat-history.js

@@ -2,6 +2,8 @@
 
 const { RST, DIM, BOLD, FG_CYAN, FG_GREEN, FG_YELLOW, FG_RED, FG_DARK, FG_GRAY } = require('./ansi');
 const { getCols, stripAnsi } = require('./utils');
+const { UI_THEME, UI_ICONS, TOOL_CATEGORIES } = require('./theme');
+const writer = require('./writer');
 
 
 function safeContent(text) {
@@ -9,6 +11,8 @@ function safeContent(text) {
   return text.replace(/<\/?[a-zA-Z_][a-zA-Z0-9_]*(\s[^>]*)?>/g, '');
 }
 
+// Legacy per-tag icons kept as a fallback only. New chrome uses a single
+// status glyph (✓/✗/●) picked by outcome, not by tool kind.
 const TOOL_ICONS = {
   exec: '▶', shell: '▶', run_command: '▶', run: '▶',
   read_file: '[R]', write_file: '✎',
@@ -18,6 +22,24 @@ const TOOL_ICONS = {
   store_memory: '◆', recall_memory: '◆', list_memories: '◆',
 };
 
+// Dim any path/URL-like substring so it recedes when scanning a list of
+// tool operations.
+function _dimPaths(text) {
+  return text.replace(/(\S*\/\S+)/g, (m) => {
+    const trail = m.match(/[`"'),.;:!?\]]+$/);
+    if (trail) {
+      const core = m.slice(0, -trail[0].length);
+      if (!core) return m;
+      return `${UI_THEME.subtle}${core}${UI_THEME.default}${trail[0]}`;
+    }
+    return `${UI_THEME.subtle}${m}${UI_THEME.default}`;
+  });
+}
+
+function _isAutoApproveMeta(content) {
+  return /auto-approv/i.test(content);
+}
+
 function _fmtTime(ts) {
   const d = ts instanceof Date ? ts : (ts ? new Date(ts) : new Date());
   return `${String(d.getHours()).padStart(2, '0')}:${String(d.getMinutes()).padStart(2, '0')}`;
@@ -25,47 +47,68 @@ function _fmtTime(ts) {
 
 const BG_USER = '\x1b[48;5;237m';
 
-function _printUser(content, ts) {
+// Build renderers return a single string ending with \n (or empty). The
+// caller commits it to scrollback in one write so nothing interleaves mid-
+// bubble — the whole user/assistant/tool block reaches the terminal as one
+// atomic chunk.
+function _buildUser(content, ts) {
   const time = _fmtTime(ts);
-  process.stdout.write(`\n${FG_CYAN}▸ You${RST}  ${DIM}${time}${RST}\n`);
+  let out = `\n${FG_CYAN}▸ You${RST}  ${DIM}${time}${RST}\n`;
   for (const line of (content || '').split('\n')) {
-    process.stdout.write(`${BG_USER}  ${line}\x1b[K${RST}\n`);
+    out += `${BG_USER}  ${line}\x1b[K${RST}\n`;
   }
-  process.stdout.write('\n');
+  out += '\n';
+  return out;
 }
 
-function _printAI(content, ts) {
+function _buildAI(content, ts) {
   const time = _fmtTime(ts);
-  process.stdout.write(`\n${FG_GREEN}▸ AI-agent${RST}  ${DIM}${time}${RST}\n`);
+  let out = `\n${FG_GREEN}▸ AI-agent${RST}  ${DIM}${time}${RST}\n`;
   for (const line of (content || '').split('\n')) {
-    process.stdout.write(`  ${line}\n`);
+    out += `  ${line}\n`;
   }
-  process.stdout.write('\n');
+  out += '\n';
+  return out;
 }
 
 const MAX_TOOL_DISPLAY = 15;
 
 class ChatHistory {
   constructor() {
-    this._streamWritten = false;
+    this._streamActive = false;
+    this._streamPartial = '';
     this._streamStart = null;
+    this._didStream = false;
     this._msgById = {};
     this._msgLineCount = {};
-    this._pendingWs = '';
-    this._didStream = false;
     this._toolExpanded = {};
     this._lastExpandableId = null;
     this._toolIdCounter = 0;
     this._messages = [];
+    // Callback into the UI orchestrator to refresh the live region (so the
+    // in-progress streaming line and chrome re-render together). Set by
+    // createUI; safe to leave null for headless/test contexts.
+    this._onLiveUpdate = null;
   }
 
-  _flush() {
-    this._pendingWs = '';
-    if (this._streamWritten) {
-      process.stdout.write('\n\n');
-      this._streamWritten = false;
-      this._streamStart = null;
-      this._didStream = true;
+  // Return the in-progress streaming line as it should appear inside the
+  // live region. Null when no stream is active or the partial is empty —
+  // the live composer then omits the streaming row entirely.
+  getStreamingLiveLine() {
+    if (!this._streamActive) return null;
+    if (!this._streamPartial) return null;
+    // Render leading-whitespace-only partials as an empty space so the
+    // cursor sits on a visible row, not a bare \n.
+    return '  ' + this._streamPartial.replace(/\n/g, ' ');
+  }
+
+  isStreaming() { return this._streamActive; }
+
+  _commit(text) { writer.scrollback(text); }
+
+  _notifyLive() {
+    if (this._onLiveUpdate) {
+      try { this._onLiveUpdate(); } catch {}
     }
   }
 
@@ -74,36 +117,55 @@ class ChatHistory {
     const content = safeContent(msg.content || '');
     if ((msg.role === 'assistant' || msg.role === 'system') && !content.trim()) return;
 
-    this._flush();
+    // Any in-progress stream must close before we emit a new scrollback
+    // block — otherwise the stream's partial line would sit between the
+    // header and body of the new bubble.
+    this._flushStream();
 
     if (msg.id) this._msgById[msg.id] = msg;
 
+    let out = '';
+    let lineCount = 0;
+
     if (msg.role === 'user') {
-      _printUser(content, msg.ts);
+      out = _buildUser(content, msg.ts);
     } else if (msg.role === 'assistant') {
-      _printAI(content, msg.ts);
+      out = _buildAI(content, msg.ts);
     } else if (msg.role === 'shell') {
       const cmd = msg.cmd || '';
-      const out = safeContent(msg.content || '');
-      process.stdout.write(`\n${DIM}  $ ${cmd}${RST}\n`);
-      if (out.trim()) {
-        for (const line of out.split('\n')) {
-          if (line.trim()) process.stdout.write(`${DIM}    ${line}${RST}\n`);
+      const shellOut = safeContent(msg.content || '');
+      out = `\n${DIM}  $ ${cmd}${RST}\n`;
+      if (shellOut.trim()) {
+        for (const line of shellOut.split('\n')) {
+          if (line.trim()) out += `${DIM}    ${line}${RST}\n`;
         }
       }
-      process.stdout.write('\n');
+      out += '\n';
     } else if (msg.role === 'tool') {
-      const icon = TOOL_ICONS[msg.tag] || '⚙';
-      process.stdout.write(`${DIM}  ${icon}  ${content}${RST}\n`);
-      let lc = 1;
+      // Tool summary header. The writer's activity region now commits the
+      // primary "glyph · category · op · duration · meta" line directly to
+      // scrollback via endActivity — when a caller supplies an empty
+      // `content` they're signalling that the header is already present
+      // and only the expandable output body should render here.
+      if (content) {
+        const indicator = msg.isError
+          ? `${UI_THEME.error}${UI_ICONS.error}${RST}`
+          : `${UI_THEME.success}${UI_ICONS.success}${RST}`;
+        const category = TOOL_CATEGORIES[msg.tag] || msg.tag || 'tool';
+        const head = `${UI_THEME.accent}${category}${UI_THEME.muted}:${RST}`;
+        const desc = _dimPaths(content);
+        out = `  ${indicator} ${head} ${desc}\n`;
+        lineCount = 1;
+      } else {
+        out = '';
+        lineCount = 0;
+      }
       if (msg.output) {
-        // Wrap long lines so char-heavy single-line output (e.g. minified HTML)
-        // is treated the same as multi-line output for truncation purposes.
         const wrapAt = Math.max(60, getCols() - 8);
         const outLines = [];
         for (const raw of msg.output.split('\n')) {
           if (!raw.trim()) continue;
-          if (raw.length <= wrapAt) {
+          if (msg.tag === 'debug' || raw.length <= wrapAt) {
             outLines.push(raw);
           } else {
             for (let i = 0; i < raw.length; i += wrapAt) {
@@ -125,70 +187,150 @@ class ChatHistory {
         const visible = (truncatable && !expanded) ? outLines.slice(0, MAX_TOOL_DISPLAY) : outLines;
         const remaining = outLines.length - visible.length;
 
-        for (const ol of visible) { process.stdout.write(`${DIM}     ${ol}${RST}\n`); lc++; }
+        const outerOpen = msg.tag === 'debug' ? '  ' : `${DIM}     `;
+        const outerClose = msg.tag === 'debug' ? '' : RST;
+        for (const ol of visible) { out += `${outerOpen}${ol}${outerClose}\n`; lineCount++; }
         if (remaining > 0) {
-          process.stdout.write(`${DIM}     … ${remaining} more lines  ${FG_DARK}(ctrl+o to expand ${remaining} rows)${RST}\n`);
-          lc++;
+          out += `${DIM}     … ${remaining} more lines  ${FG_DARK}(ctrl+o to expand ${remaining} rows)${RST}\n`;
+          lineCount++;
         } else if (truncatable && expanded) {
-          process.stdout.write(`${DIM}     ${FG_DARK}(ctrl+o to collapse)${RST}\n`);
-          lc++;
+          out += `${DIM}     ${FG_DARK}(ctrl+o to collapse)${RST}\n`;
+          lineCount++;
         }
       }
-      if (msg.id) this._msgLineCount[msg.id] = lc;
     } else if (msg.role === 'permission') {
-      process.stdout.write(`\n${FG_YELLOW}  ⚠ Permission required: ${content}${RST}\n`);
+      out = `\n  ${UI_THEME.warning}${UI_ICONS.warn}${RST} ${UI_THEME.warning}Permission required${RST}${UI_THEME.muted}:${RST} ${content}\n`;
     } else {
-      const isErr = !!msg.isError && !msg.isWarning;
-      const color = isErr ? FG_RED : FG_YELLOW;
-      const prefix = isErr ? '✕' : '⚠';
+      // Fallback for role: 'system' and anything unrecognised.
       const lines = content.split('\n');
-      process.stdout.write(`${color}  ${prefix}  ${lines[0]}${RST}\n`);
+      const first = lines[0] || '';
+      const stripGlyph = (s) => s.replace(/^[✓✗✕⚠]\s*/, '');
+      let rendered;
+      if (msg.isError && !msg.isWarning) {
+        rendered = `  ${UI_THEME.error}${UI_ICONS.error}${RST} ${UI_THEME.error}${stripGlyph(first)}${RST}`;
+      } else if (msg.isWarning) {
+        rendered = `  ${UI_THEME.warning}${UI_ICONS.warn}${RST} ${UI_THEME.warning}${stripGlyph(first)}${RST}`;
+      } else if (_isAutoApproveMeta(first)) {
+        const body = first.replace(/(auto-approv\w*)/gi, (m) => `${UI_THEME.warning}${m}${UI_THEME.subtle}`);
+        rendered = `  ${UI_THEME.subtle}${body}${RST}`;
+      } else if (first.startsWith('✓')) {
+        rendered = `  ${UI_THEME.success}${UI_ICONS.success}${RST} ${first.slice(1).trimStart()}`;
+      } else if (first.startsWith('✗')) {
+        rendered = `  ${UI_THEME.error}${UI_ICONS.error}${RST} ${UI_THEME.error}${first.slice(1).trimStart()}${RST}`;
+      } else {
+        rendered = `  ${UI_THEME.subtle}${UI_ICONS.bullet}${RST} ${UI_THEME.subtle}${first}${RST}`;
+      }
+      out = `${rendered}\n`;
+      const contColor = (msg.isError && !msg.isWarning) ? UI_THEME.error
+                      : msg.isWarning ? UI_THEME.warning
+                      : UI_THEME.subtle;
       for (let i = 1; i < lines.length; i++) {
-        process.stdout.write(`${color}     ${lines[i]}${RST}\n`);
+        out += `     ${contColor}${lines[i]}${RST}\n`;
       }
-      if (msg.id) this._msgLineCount[msg.id] = lines.length;
+      lineCount = lines.length;
     }
+
+    if (out) this._commit(out);
+    if (msg.id && lineCount > 0) this._msgLineCount[msg.id] = lineCount;
+    this._messages.push(msg);
+    this._notifyLive();
   }
 
+  // Streaming path. Accumulates tokens until a newline, then commits each
+  // complete line to scrollback. The unfinished partial line is exposed via
+  // getStreamingLiveLine() so the UI composer can show it at the top of
+  // the live region while it's still in-flight.
   streamToken(token) {
-    if (!this._streamWritten) {
-      if (!token.trim()) {
-        this._pendingWs += token;
-        return;
-      }
+    if (!token) return;
+    if (!this._streamActive) {
+      // Emit header immediately so users see the new AI turn before any
+      // tokens arrive. No blank line before the header since scrollback
+      // flows continuously.
       const time = _fmtTime(new Date());
-      process.stdout.write(`\n${FG_GREEN}▸ AI-agent${RST}  ${DIM}${time}${RST}\n  `);
-      this._streamWritten = true;
+      this._commit(`\n${FG_GREEN}▸ AI-agent${RST}  ${DIM}${time}${RST}\n`);
+      this._streamActive = true;
       this._streamStart = new Date();
-      this._pendingWs = '';
+      this._streamPartial = '';
+    }
+    this._streamPartial += token;
+    let nlIdx;
+    while ((nlIdx = this._streamPartial.indexOf('\n')) >= 0) {
+      const line = this._streamPartial.slice(0, nlIdx);
+      this._commit('  ' + line + '\n');
+      this._streamPartial = this._streamPartial.slice(nlIdx + 1);
     }
-    process.stdout.write(token.replace(/\n/g, '\n  '));
+    this._notifyLive();
+  }
+
+  _flushStream() {
+    if (!this._streamActive) return;
+    if (this._streamPartial !== '') {
+      this._commit('  ' + this._streamPartial + '\n');
+      this._streamPartial = '';
+    }
+    this._commit('\n');
+    this._streamActive = false;
+    this._streamStart = null;
+    this._didStream = true;
   }
 
   clearStreamingContent() {
-    this._flush();
+    this._flushStream();
+    this._notifyLive();
   }
 
   finalizeLastMessage(cleanContent) {
-    if (this._streamWritten) {
-      this._flush();
+    const wasStreaming = this._streamActive;
+    const streamStart = this._streamStart;
+    if (wasStreaming) {
+      this._flushStream();
+      if (cleanContent && cleanContent.trim()) {
+        this._messages.push({
+          role: 'assistant',
+          content: cleanContent,
+          ts: streamStart || new Date(),
+        });
+      }
     } else if (!this._didStream && cleanContent && cleanContent.trim()) {
-      _printAI(cleanContent, new Date());
+      // Non-streaming path — synthesise an assistant bubble from the final
+      // content.
+      this._commit(_buildAI(cleanContent, new Date()));
+      this._messages.push({
+        role: 'assistant',
+        content: cleanContent,
+        ts: new Date(),
+      });
     }
     this._didStream = false;
+    this._notifyLive();
   }
 
   clearMessages() {
-    this._streamWritten = false;
-    this._pendingWs = '';
+    this._streamActive = false;
+    this._streamPartial = '';
     this._didStream = false;
     this._msgById = {};
     this._msgLineCount = {};
     this._toolExpanded = {};
     this._lastExpandableId = null;
     this._messages = [];
+    // Wipe the terminal's visible scrollback and the saved scrollback buffer
+    // so the cleared state feels clean. Serialized through the writer so
+    // the clear can't land inside a pending scrollback burst, then redraw
+    // the live region under the new cursor.
+    writer.enqueue(() => {
+      // audit: allowed — viewport clear inside writer.enqueue (sanctioned escape hatch).
+      try { process.stdout.write('\x1b[3J\x1b[2J\x1b[H'); } catch {}
+    });
+    writer.redrawLive();
+    this._notifyLive();
   }
 
+  // In append-only scrollback we cannot rewrite a previous bubble in place;
+  // these methods now simply re-render the updated version as new
+  // scrollback. Expand/collapse prints the full (or summary) view below the
+  // prior truncated view. This is a small visual regression from the old
+  // scroll-region mode in exchange for eliminating the torn-frame race.
   toggleLastExpand() {
     const id = this._lastExpandableId;
     if (!id) return;
@@ -204,9 +346,18 @@ class ChatHistory {
     this.addMessage(msg);
   }
 
+  collapseById(id) {
+    // Nothing to erase in the append-only model — drop the tracking so a
+    // future expand toggle doesn't target the stale entry.
+    delete this._msgById[id];
+    delete this._msgLineCount[id];
+    if (this._lastExpandableId === id) this._lastExpandableId = null;
+  }
+
   removeById(id) {
     delete this._msgById[id];
     delete this._msgLineCount[id];
+    if (this._lastExpandableId === id) this._lastExpandableId = null;
   }
 
   invalidateCache() {}