@semalt-ai/code 1.8.1 → 1.8.4

package/lib/ui/diff.js

@@ -1,7 +1,9 @@
 'use strict';
 
-const { FG_DARK, FG_RED, FG_GREEN, FG_GRAY, FG_YELLOW, FG_TEAL, RST, THEME } = require('./ansi');
-const { getCols, stripAnsi } = require('./utils');
+const { FG_DARK, FG_RED, FG_GREEN, FG_GRAY, FG_YELLOW, FG_TEAL, RST, THEME, EL, hasTruecolor } = require('./ansi');
+const { getCols, stripAnsi, termWidth } = require('./utils');
+const { DIFF_THEME, UI_THEME } = require('./theme');
+const writer = require('./writer');
 
 function diffLines(oldLines, newLines) {
   const m = oldLines.length, n = newLines.length;
@@ -37,29 +39,47 @@ function diffLinesHashed(oldLines, newLines) {
   return result;
 }
 
-function renderDiff(oldText, newText, filePath) {
+// Truncate `text` to at most `w` terminal columns. When truncation happens,
+// the last visible column is replaced with '…'. Width is measured in display
+// columns (termWidth), so emoji / CJK consume 2 per char.
+function _truncateByWidth(text, w) {
+  if (w <= 0) return '';
+  if (termWidth(text) <= w) return text;
+  let out = '', used = 0;
+  for (const ch of text) {
+    const chw = termWidth(ch);
+    if (used + chw > w - 1) break;
+    out += ch;
+    used += chw;
+  }
+  return out + '…';
+}
+
+function renderDiff(oldText, newText, filePath, opts) {
   if (oldText.includes('\x00') || newText.includes('\x00')) return '[binary file — diff skipped]';
   const isTTY = process.stdout.isTTY === true;
-  const cols  = getCols();
-
-  // ── Layout constants ───────────────────────────────────────────────────────
-  const INDENT     = '   ';          // left offset from main stream
-  const boxWidth   = Math.max(40, cols - INDENT.length);
-  const innerWidth = boxWidth - 2;   // between ╭ and ╮
-
-  const a  = (code) => isTTY ? code : '';
-  const R  = a(RST);
-
-  // Palette
-  const BORDER   = a(FG_DARK);
-  const DEL_BG   = a('\x1b[48;5;52m');    // dark red background
-  const ADD_BG   = a('\x1b[48;5;22m');    // dark green background
-  const DEL_FG   = a('\x1b[38;5;203m');   // bright red text  (= FG_RED)
-  const ADD_FG   = a('\x1b[38;5;114m');   // bright green text (= FG_GREEN)
-  const NUM_CLR  = a('\x1b[38;5;240m');   // muted line-number gutter
-  const CTX_CLR  = a('\x1b[38;5;245m');   // dim context text
-  const HUNK_CLR = a('\x1b[38;5;73m');    // teal hunk separator
-  const PATH_CLR = a('\x1b[38;5;222m');   // yellow filepath in header
+  // `inset` reserves N columns for an outer wrapper (e.g. the permission
+  // bubble indents continuation lines by 5 spaces). Subtract it from the
+  // effective width so our truncated content still fits on one physical row.
+  const inset = (opts && Number.isInteger(opts.inset) && opts.inset >= 0) ? opts.inset : 0;
+  const cols  = Math.max(20, getCols() - inset);
+
+  // Resolve the palette once per render. Truecolor is used when the terminal
+  // advertises it via COLORTERM; otherwise fall back to 256-color.
+  const useTC = hasTruecolor();
+  const a   = (code) => isTTY ? code : '';
+  const R   = a(RST);
+  const EL_ = a(EL);
+  const pickBg = (t) => useTC && t.bgTC ? t.bgTC : t.bg256;
+  const P = {
+    added:   { bg: a(pickBg(DIFF_THEME.added)),   signFg: a(DIFF_THEME.added.signFg),   sign: DIFF_THEME.added.sign   },
+    removed: { bg: a(pickBg(DIFF_THEME.removed)), signFg: a(DIFF_THEME.removed.signFg), sign: DIFF_THEME.removed.sign },
+    context: { bg: '',                             signFg: '',                            sign: DIFF_THEME.context.sign },
+    ln:      a(DIFF_THEME.lineNumber),
+    code:    a(DIFF_THEME.code),
+    hdr:     a(DIFF_THEME.header),
+    frame:   a(DIFF_THEME.frame),
+  };
 
   const oldLines  = oldText === '' ? [] : oldText.split('\n');
   const newLines  = newText.split('\n');
@@ -69,58 +89,58 @@ function renderDiff(oldText, newText, filePath) {
   if (!isNewFile) {
     diff = (oldLines.length > 200 || newLines.length > 200)
       ? diffLinesHashed(oldLines, newLines) : diffLines(oldLines, newLines);
-    if (!diff.some((d) => d.type !== 'same')) return `${INDENT}  No changes detected`;
+    if (!diff.some((d) => d.type !== 'same')) return '   No changes detected';
   }
 
-  // Gutter width: enough digits for the largest line number
-  const maxLn = Math.max(oldLines.length, newLines.length, 1);
-  const LN_W  = Math.max(2, String(maxLn).length);
-
-  // gutter template: ' NNNN │S ' — LN_W + 5 chars
-  const GUTTER_W = LN_W + 5;
-  const CONT_W   = Math.max(1, innerWidth - GUTTER_W);
-
-  // ── Builders ───────────────────────────────────────────────────────────────
-
-  // One content line inside the box.
-  //   lnStr  – line-number string (right-aligned to LN_W, or '' for unknown)
-  //   symbol – '-', '+', or ' '
-  //   text   – raw source text
-  //   bg     – background ANSI string (or '' for context)
-  //   fg     – foreground ANSI string
-  function makeLine(lnStr, symbol, text, bg, fg) {
-    const num    = lnStr ? lnStr.padStart(LN_W) : ' '.repeat(LN_W);
-    const disp   = text.replace(/\t/g, '  ');
-    const clp    = disp.length > CONT_W ? disp.slice(0, CONT_W - 1) + '…' : disp;
-    const padded = clp.padEnd(CONT_W);
-    // gutter:  ' NUM │S '
-    const gt = ` ${NUM_CLR}${num}${R}${bg}${BORDER} │${R}${bg}${fg}${symbol} ${padded}${R}`;
-    return `${INDENT}${BORDER}│${R}${bg}${gt}${R}${BORDER}│${R}`;
+  // ── Layout ─────────────────────────────────────────────────────────────────
+  // [GUTTER(3) default bg] [LN_W line#] [' '] [sign] [' '] [code] [EL] [RST]
+  // The gutter stays in the terminal's default bg so the dark bg on the
+  // change lines has a visible left edge — no box frame needed.
+  const GUTTER   = '   ';
+  const maxLn    = Math.max(oldLines.length, newLines.length, 1);
+  const LN_W     = Math.max(2, String(maxLn).length);
+  const PREFIX_W = GUTTER.length + LN_W + 3;  // gutter + ln + ' ' + sign + ' '
+  const CODE_W   = Math.max(1, cols - PREFIX_W);
+
+  // Render a single diff line. For added/removed, the dark bg begins right
+  // after the gutter and extends to the physical right edge via EL. Context
+  // lines set no bg so EL is skipped too (no-op but cleaner output).
+  function makeLine(lnStr, kind, text) {
+    const t    = P[kind];
+    const num  = (lnStr || '').padStart(LN_W);
+    const disp = (text || '').replace(/\t/g, '  ');
+    const code = _truncateByWidth(disp, CODE_W);
+
+    let s = GUTTER;
+    s += t.bg;
+    s += P.ln + num;
+    s += ' ';
+    if (t.signFg) s += t.signFg;
+    s += t.sign;
+    s += P.code;
+    s += ' ';
+    s += code;
+    if (t.bg) s += EL_;
+    s += R;
+    return s;
   }
 
-  // Hunk separator: ···· @@ -x,y +a,b @@ ····
   function hunkSep(label) {
-    const body  = ` ${label} `;
-    const total = innerWidth - 2;  // 2 for leading/trailing ·
-    const half  = Math.max(0, Math.floor((total - body.length) / 2));
-    const right = Math.max(0, total - body.length - half);
-    return `${INDENT}${BORDER}│${R}${HUNK_CLR} ${'·'.repeat(half)}${body}${'·'.repeat(right)} ${R}${BORDER}│${R}`;
+    return `${GUTTER}${P.frame}${label}${R}`;
   }
 
   const out = [];
+  // Minimal file header — bold blue path, no box. The surrounding UI owns
+  // any tool-label framing; this line is the only header the diff emits.
+  out.push(`${GUTTER}${P.hdr}${filePath}${R}`);
 
-  // ── Header ─────────────────────────────────────────────────────────────────
-  const pathPart  = ` ${filePath} `;
-  const fillRight = Math.max(1, innerWidth - 1 - pathPart.length);  // 1 for leading ─
-  out.push(`${INDENT}${BORDER}╭─${PATH_CLR}${pathPart}${R}${BORDER}${'─'.repeat(fillRight)}╮${R}`);
-
-  // ── Body ───────────────────────────────────────────────────────────────────
   if (isNewFile) {
-    out.push(hunkSep('new file'));
+    // Meta-label "(new file)" rendered in the shared subtle palette so it
+    // recedes relative to the hunk marker itself.
+    const subtle = a(UI_THEME.subtle);
+    out.push(`${GUTTER}${P.frame}@@ -0,0 +1,${newLines.length} @@ ${R}${subtle}(new file)${R}`);
     let ln = 1;
-    for (const line of newLines) {
-      out.push(makeLine(String(ln++), '+', line, ADD_BG, ADD_FG));
-    }
+    for (const line of newLines) out.push(makeLine(String(ln++), 'added', line));
   } else {
     let oldLn = 1, newLn = 1;
     const annotated = diff.map((d) => {
@@ -153,26 +173,19 @@ function renderDiff(oldText, newText, filePath) {
       out.push(hunkSep(`@@ -${oldStart},${oldCnt} +${newStart},${newCnt} @@`));
 
       for (const e of hunk) {
-        if (e.type === 'del') {
-          out.push(makeLine(String(e.oldLine), '-', e.text, DEL_BG, DEL_FG));
-        } else if (e.type === 'add') {
-          out.push(makeLine(String(e.newLine), '+', e.text, ADD_BG, ADD_FG));
-        } else {
-          out.push(makeLine(String(e.newLine), ' ', e.text, '', CTX_CLR));
-        }
+        if (e.type === 'del')      out.push(makeLine(String(e.oldLine), 'removed', e.text));
+        else if (e.type === 'add') out.push(makeLine(String(e.newLine), 'added',   e.text));
+        else                       out.push(makeLine(String(e.newLine), 'context', e.text));
       }
     }
   }
 
-  // ── Footer ─────────────────────────────────────────────────────────────────
-  out.push(`${INDENT}${BORDER}╰${'─'.repeat(innerWidth)}╯${R}`);
-
   const MAX = 120;
   if (out.length > MAX) {
     const extra  = out.length - MAX;
     const result = out.slice(0, MAX);
     result.push(isTTY
-      ? `${INDENT}${FG_DARK}  … ${extra} more lines${RST}`
+      ? `${GUTTER}${P.frame}… ${extra} more lines${R}`
       : `… ${extra} more lines`);
     return result.join('\n');
   }
@@ -194,7 +207,7 @@ function _mdInline(text) {
 }
 
 function renderMarkdown(text) {
-  if (!process.stdout.isTTY) { process.stdout.write(text); return; }
+  if (!process.stdout.isTTY) { writer.scrollback(text); return; }
   const { loadConfig } = require('../config');
   const maxLines = (loadConfig().max_output_lines) || 50;
   const cols = getCols();
@@ -236,8 +249,8 @@ function renderMarkdown(text) {
   }
   let overflow = 0, printLines = output;
   if (output.length > maxLines) { overflow = output.length - maxLines; printLines = output.slice(0, maxLines); }
-  for (const l of printLines) process.stdout.write(l + '\n');
-  if (overflow > 0) process.stdout.write(THEME.dim + '[... ' + overflow + ' more lines]' + THEME.reset + '\n');
+  if (printLines.length > 0) writer.scrollback(printLines.join('\n'));
+  if (overflow > 0) writer.scrollback(THEME.dim + '[... ' + overflow + ' more lines]' + THEME.reset);
 }
 
 module.exports = { renderDiff, renderMarkdown, _mdInline };

package/lib/ui/format.js

@@ -0,0 +1,247 @@
+'use strict';
+
+// Pure formatters for the tool-line chrome. Kept zero-dep and side-effect
+// free: every function maps inputs → string, does not touch stdout, and does
+// not read config or state. Consumed by:
+//   - commands.js — builds pending + final activity lines
+//   - writer.js   — nothing (writer is layout-only)
+//
+// Layout contract for a tool line (all four segments are " · "-joined):
+//
+//   <glyph> <category> · <operation> · <duration> · <meta>
+//
+//   glyph     ● pending (muted) / ✓ success / ✗ failure
+//   category  5-col padded short tag ("net  ", "file ", "shell", …)
+//   operation verb + target ("GET https://x", "write /tmp/x", "npm install")
+//   duration  formatDuration(ms), pending lines trail with "…"
+//   meta      type-specific tail — exit codes, byte counts, match counts, …
+
+const { RST, DIM } = require('./ansi');
+const { UI_THEME, UI_ICONS, TOOL_CATEGORIES } = require('./theme');
+
+// Adaptive precision. ms < 1s shows "Nms", under a minute shows "N.Ns"
+// (sub-10s) or "Ns", under an hour shows "MmSs", above uses "HhMm". Never
+// returns the empty string for a valid number — callers strip the value
+// when they want no duration rendered.
+function formatDuration(ms) {
+  if (ms == null || !Number.isFinite(ms)) return '';
+  const v = ms < 0 ? 0 : ms;
+  if (v < 1000) return `${Math.round(v)}ms`;
+  if (v < 60_000) {
+    const s = v / 1000;
+    return s < 10 ? `${s.toFixed(1)}s` : `${Math.round(s)}s`;
+  }
+  if (v < 3_600_000) {
+    const totalSec = Math.floor(v / 1000);
+    return `${Math.floor(totalSec / 60)}m${totalSec % 60}s`;
+  }
+  const totalMin = Math.floor(v / 60_000);
+  return `${Math.floor(totalMin / 60)}h${totalMin % 60}m`;
+}
+
+// Human-readable byte count. Single decimal below 10, none above. Scales
+// through KB/MB/GB. Rejects NaN/negative by returning '' so callers can
+// drop the meta fragment entirely.
+function formatBytes(n) {
+  if (n == null || !Number.isFinite(n) || n < 0) return '';
+  if (n < 1024) return `${Math.round(n)} B`;
+  const kb = n / 1024;
+  if (kb < 1024) return kb < 10 ? `${kb.toFixed(1)} KB` : `${Math.round(kb)} KB`;
+  const mb = kb / 1024;
+  if (mb < 1024) return mb < 10 ? `${mb.toFixed(1)} MB` : `${Math.round(mb)} MB`;
+  const gb = mb / 1024;
+  return gb < 10 ? `${gb.toFixed(1)} GB` : `${Math.round(gb)} GB`;
+}
+
+// Short tag for HTTP / network errors. Prefers Node's err.code when
+// available (authoritative) and falls back to substring matches against
+// err.message for non-Node-originated errors (our own "Request timeout"
+// sentinel, for example).
+function formatHttpErrorTag(err) {
+  if (!err) return 'error';
+  const code = err.code || '';
+  const msg = String(err.message || err).toLowerCase();
+  if (code === 'ETIMEDOUT' || /timed out|timeout/.test(msg)) return 'timeout';
+  if (code === 'ECONNREFUSED' || /refused/.test(msg)) return 'refused';
+  if (code === 'ENOTFOUND' || code === 'EAI_AGAIN' || /getaddrinfo|dns/.test(msg)) return 'dns';
+  if (code === 'ECONNRESET' || /reset by peer|econnreset/.test(msg)) return 'reset';
+  if (code === 'CERT_HAS_EXPIRED' || code === 'UNABLE_TO_VERIFY_LEAF_SIGNATURE' || /certificate|cert/.test(msg)) return 'cert';
+  if (code === 'EHOSTUNREACH' || /unreachable/.test(msg)) return 'unreachable';
+  return 'error';
+}
+
+// The XML-tag extractor and native-function mapper hand the agent loop
+// *action* names (read, write, append) that differ from the *tag* names
+// (read_file, write_file, append_file) indexed by TAG_REGISTRY and
+// TOOL_CATEGORIES. Normalize here so downstream category/label lookups
+// resolve regardless of which code path produced the call tuple.
+const ACTION_TO_TAG = {
+  read:   'read_file',
+  write:  'write_file',
+  append: 'append_file',
+  exec:   'shell',
+};
+
+function _normalizeTag(tag) {
+  return ACTION_TO_TAG[tag] || tag || 'tool';
+}
+
+// 5-column label. Wider than "net"/"file" so concurrent lines align their
+// operation columns; category names of 5 chars ("shell") fit exactly.
+const CATEGORY_WIDTH = 5;
+
+function _categoryLabel(tag) {
+  const cat = TOOL_CATEGORIES[_normalizeTag(tag)] || 'tool';
+  return cat.length >= CATEGORY_WIDTH ? cat.slice(0, CATEGORY_WIDTH) : cat.padEnd(CATEGORY_WIDTH);
+}
+
+function _truncate(text, max) {
+  if (text == null) return '';
+  const s = String(text);
+  if (s.length <= max) return s;
+  return s.slice(0, Math.max(0, max - 1)) + '…';
+}
+
+// Verb + target string. Never more than ~80 chars visible — longer URLs,
+// commands, paths are head-tail truncated so the line stays on one row
+// even in 120-col terminals with metadata appended.
+function _operation(tag, arg, attrs) {
+  const a = attrs || {};
+  const max = 80;
+  const pathOrArg = (k) => a[k] || arg || '';
+  switch (_normalizeTag(tag)) {
+    case 'http_get':         return _truncate(`GET ${a.url || arg || ''}`, max);
+    case 'download':         return _truncate(`download ${a.url || arg || ''}`, max);
+    case 'upload':           return _truncate(`upload ${a.path || arg || ''}`, max);
+    case 'shell':            return _truncate(a.command || arg || '', max);
+    case 'read_file':        return _truncate(`read ${pathOrArg('path')}`, max);
+    case 'write_file':       return _truncate(`write ${pathOrArg('path')}`, max);
+    case 'create_file':      return _truncate(`create ${pathOrArg('path')}`, max);
+    case 'append_file':      return _truncate(`append ${pathOrArg('path')}`, max);
+    case 'delete_file':      return _truncate(`delete ${pathOrArg('path')}`, max);
+    case 'list_dir':         return _truncate(`list ${pathOrArg('path') || '.'}`, max);
+    case 'make_dir':         return _truncate(`mkdir ${pathOrArg('path')}`, max);
+    case 'remove_dir':       return _truncate(`rmdir ${pathOrArg('path')}`, max);
+    case 'move_file':        return _truncate(`move ${a.src || ''} → ${a.dst || ''}`, max);
+    case 'copy_file':        return _truncate(`copy ${a.src || ''} → ${a.dst || ''}`, max);
+    case 'edit_file':        return _truncate(`edit ${a.path || ''}:${a.line || ''}`, max);
+    case 'search_files':     return _truncate(`search ${a.pattern || arg || ''}${a.dir && a.dir !== '.' ? ` in ${a.dir}` : ''}`, max);
+    case 'search_in_file':   return _truncate(`search-in ${a.path || arg || ''}`, max);
+    case 'replace_in_file':  return _truncate(`replace ${a.path || arg || ''}`, max);
+    case 'file_stat':        return _truncate(`stat ${pathOrArg('path')}`, max);
+    case 'get_env':          return _truncate(`get $${a.name || arg || ''}`, max);
+    case 'set_env':          return _truncate(`set $${a.name || ''}`, max);
+    case 'ask_user':         return _truncate(`ask ${a.question || arg || ''}`, max);
+    case 'store_memory':     return _truncate(`store ${a.key || ''}`, max);
+    case 'recall_memory':    return _truncate(`recall ${a.key || arg || ''}`, max);
+    case 'list_memories':    return 'list memories';
+    case 'system_info':      return 'system info';
+    default:                 return _truncate(arg ? `${tag} ${arg}` : tag, max);
+  }
+}
+
+// Type-specific meta tail. Split into sub-parts so the 4-segment joiner
+// renders e.g. "200 · 42 KB" with its own " · " between them. Returns an
+// array of strings; the caller joins them with " · ".
+function _metaParts(tag, meta, error) {
+  const out = [];
+  const normalized = _normalizeTag(tag);
+  if (error && (normalized === 'http_get' || normalized === 'download')) {
+    out.push(formatHttpErrorTag(error));
+    return out;
+  }
+  switch (normalized) {
+    case 'http_get':
+    case 'download':
+      if (meta && typeof meta.status_code === 'number') out.push(String(meta.status_code));
+      if (meta && typeof meta.bytes === 'number' && meta.bytes >= 0) out.push(formatBytes(meta.bytes));
+      break;
+    case 'shell':
+      if (meta && typeof meta.exit_code === 'number') out.push(`exit ${meta.exit_code}`);
+      break;
+    case 'read_file':
+    case 'write_file':
+    case 'create_file':
+    case 'append_file':
+    case 'upload':
+      if (meta && typeof meta.bytes === 'number' && meta.bytes >= 0) out.push(formatBytes(meta.bytes));
+      break;
+    case 'search_files':
+    case 'search_in_file':
+      if (meta && typeof meta.count === 'number') {
+        out.push(`${meta.count} ${meta.count === 1 ? 'match' : 'matches'}`);
+      }
+      break;
+    case 'replace_in_file':
+      if (meta && typeof meta.count === 'number') out.push(`${meta.count} replaced`);
+      break;
+    case 'list_dir':
+      if (meta && typeof meta.count === 'number') out.push(`${meta.count} ${meta.count === 1 ? 'entry' : 'entries'}`);
+      break;
+    case 'file_stat':
+      if (meta && typeof meta.bytes === 'number' && meta.bytes >= 0) out.push(formatBytes(meta.bytes));
+      if (meta && meta.kind) out.push(meta.kind);
+      break;
+  }
+  return out;
+}
+
+// Build the full styled 4-segment tool line. `status` is one of
+// 'pending' | 'success' | 'failure'. For 'failure', caller may pass an
+// Error-shaped `error` and/or partial `meta` — we format both when
+// present (e.g. a failed HTTP fetch that still yielded a status code).
+function formatToolLine(args) {
+  const {
+    status,
+    tag,
+    arg,
+    attrs,
+    durationMs,
+    meta,
+    error,
+  } = args || {};
+
+  let glyph;
+  let glyphColor;
+  if (status === 'pending') {
+    glyph = UI_ICONS.pending;
+    glyphColor = UI_THEME.muted;
+  } else if (status === 'failure' || error) {
+    glyph = UI_ICONS.error;
+    glyphColor = UI_THEME.error;
+  } else {
+    glyph = UI_ICONS.success;
+    glyphColor = UI_THEME.success;
+  }
+
+  const cat = _categoryLabel(tag);
+  const catColor = (UI_THEME.categories && UI_THEME.categories[_normalizeTag(tag) && (TOOL_CATEGORIES[_normalizeTag(tag)] || 'tool')]) || UI_THEME.accent;
+
+  const op = _operation(tag, arg, attrs);
+  const durStr = formatDuration(durationMs || 0) + (status === 'pending' ? '…' : '');
+  const metaParts = _metaParts(tag, meta, error);
+
+  // Segment-by-segment styling. Each fragment carries its own ANSI codes
+  // so the " · " separator — neutral DIM — can sit between them without
+  // leaking the surrounding color into the separator itself.
+  const sep = ` ${DIM}·${RST} `;
+
+  const durColor = status === 'failure' ? UI_THEME.error : UI_THEME.muted;
+  const metaColor = status === 'failure' ? UI_THEME.error : UI_THEME.subtle;
+
+  const segments = [];
+  segments.push(`  ${glyphColor}${glyph}${RST} ${catColor}${cat}${RST}`);
+  segments.push(`${UI_THEME.default}${op}${RST}`);
+  segments.push(`${durColor}${durStr}${RST}`);
+  for (const m of metaParts) {
+    if (m) segments.push(`${metaColor}${m}${RST}`);
+  }
+  return segments.join(sep);
+}
+
+module.exports = {
+  formatDuration,
+  formatBytes,
+  formatHttpErrorTag,
+  formatToolLine,
+};