@semalt-ai/code 1.8.4 → 1.19.0

package/lib/ui/chat-history.js

@@ -3,6 +3,7 @@
 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 { summarizeToolResult } = require('./format');
 const writer = require('./writer');
 
 
@@ -147,7 +148,24 @@ class ChatHistory {
       // 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) {
+      //
+      // History-loaded tool messages arrive with the raw stored payload as
+      // `content` and no `output` — collapse them through summarizeToolResult
+      // to a single live-activity-style line. Callers that pass `output`
+      // (debug blocks, live-activity error pass-through) keep the legacy
+      // header chrome.
+      if (msg.content && !msg.output) {
+        const summary = safeContent(summarizeToolResult(msg.content));
+        if (summary) {
+          const indicator = msg.isError
+            ? `${UI_THEME.error}${UI_ICONS.error}${RST}`
+            : `${UI_THEME.success}${UI_ICONS.success}${RST}`;
+          const sep = ` ${DIM}·${RST} `;
+          const styled = summary.split(' · ').map((p) => _dimPaths(p)).join(sep);
+          out = `  ${indicator} ${styled}\n`;
+          lineCount = 1;
+        }
+      } else if (content) {
         const indicator = msg.isError
           ? `${UI_THEME.error}${UI_ICONS.error}${RST}`
           : `${UI_THEME.success}${UI_ICONS.success}${RST}`;

package/lib/ui/format.js

@@ -95,11 +95,28 @@ function _categoryLabel(tag) {
   return cat.length >= CATEGORY_WIDTH ? cat.slice(0, CATEGORY_WIDTH) : cat.padEnd(CATEGORY_WIDTH);
 }
 
-function _truncate(text, max) {
+// Display-only normalizer for tool argument text. Collapses every run of
+// whitespace (including \n from heredocs and `\<NL>` line continuations)
+// to a single space and trims the ends, so the summary line never spills
+// across multiple physical rows. Pure: never mutates the value used for
+// execution or sent to the model.
+function normalizeCmdForDisplay(text) {
   if (text == null) return '';
-  const s = String(text);
+  return String(text).replace(/\s+/g, ' ').trim();
+}
+
+// Truncate to fit `max` visible chars, normalizing first so a multi-line
+// command becomes a single visual line. When the cut would land mid-word,
+// back up to the nearest space — but only if it doesn't sacrifice more
+// than ~30% of the available width (otherwise prefer the harder cut).
+function _truncate(text, max) {
+  const s = normalizeCmdForDisplay(text);
   if (s.length <= max) return s;
-  return s.slice(0, Math.max(0, max - 1)) + '…';
+  const cap = Math.max(0, max - 1);
+  let cut = s.slice(0, cap);
+  const lastSpace = cut.lastIndexOf(' ');
+  if (lastSpace > cap * 0.7) cut = cut.slice(0, lastSpace);
+  return cut + '…';
 }
 
 // Verb + target string. Never more than ~80 chars visible — longer URLs,
@@ -136,7 +153,28 @@ function _operation(tag, arg, attrs) {
     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);
+    default:
+      if (_normalizeTag(tag).startsWith('git_')) return _truncate(_gitOperation(_normalizeTag(tag), a), max);
+      // arg may be a structured options object for newer tools — avoid rendering
+      // "[object Object]" by only appending string/number args.
+      return _truncate((arg && typeof arg !== 'object') ? `${tag} ${arg}` : tag, max);
+  }
+}
+
+// Human-readable one-liner for the native git tools (Task 5.1). `a` is the
+// options object (attrs) carried by the call.
+function _gitOperation(tag, a) {
+  const paths = Array.isArray(a.paths) ? a.paths.join(' ') : (a.paths || '');
+  switch (tag) {
+    case 'git_status':   return 'git status';
+    case 'git_diff':     return `git diff${a.staged ? ' --staged' : ''}${a.path ? ' ' + a.path : ''}`;
+    case 'git_log':      return `git log${a.count ? ' -n ' + a.count : ''}${a.path ? ' ' + a.path : ''}`;
+    case 'git_add':      return `git add ${a.all ? '-A' : paths}`.trim();
+    case 'git_commit':   return `git commit${a.all ? ' -a' : ''} -m "${normalizeCmdForDisplay(a.message || '')}"`;
+    case 'git_branch':   return a.name ? `git branch ${a.delete ? '-d ' : ''}${a.name}` : 'git branch';
+    case 'git_checkout': return `git checkout ${a.create ? '-b ' : ''}${a.name || ''}`.trim();
+    case 'git_worktree': return `git worktree ${a.op || 'list'}${a.path ? ' ' + a.path : ''}`;
+    default:             return tag;
   }
 }
 
@@ -199,6 +237,7 @@ function formatToolLine(args) {
     durationMs,
     meta,
     error,
+    noDuration,
   } = args || {};
 
   let glyph;
@@ -218,7 +257,6 @@ function formatToolLine(args) {
   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
@@ -232,16 +270,73 @@ function formatToolLine(args) {
   const segments = [];
   segments.push(`  ${glyphColor}${glyph}${RST} ${catColor}${cat}${RST}`);
   segments.push(`${UI_THEME.default}${op}${RST}`);
-  segments.push(`${durColor}${durStr}${RST}`);
+  if (!noDuration) {
+    const durStr = formatDuration(durationMs || 0) + (status === 'pending' ? '…' : '');
+    segments.push(`${durColor}${durStr}${RST}`);
+  }
   for (const m of metaParts) {
     if (m) segments.push(`${metaColor}${m}${RST}`);
   }
   return segments.join(sep);
 }
 
+// Collapse a stored tool-result string to a single-line summary in the same
+// shape as the live activity bubble ("net · GET https://x · 200 · 256 KB").
+// Pure: no ANSI, no IO, no allocation beyond the returned string. Idempotent
+// — a value that already looks like a summary is returned untouched so the
+// helper survives double-application once a separate display field lands in
+// storage.
+function summarizeToolResult(content) {
+  if (typeof content !== 'string' || !content) return '';
+  const trimmed = content.trim();
+  if (!trimmed) return '';
+
+  if (!trimmed.includes('\n') && trimmed.includes(' · ') && trimmed.length < 200) {
+    return trimmed;
+  }
+
+  // HTTP: agent.js formats as `HTTP <VERB> <url> (<status>):\n<body>`.
+  const httpMatch = content.match(/^HTTP\s+(\w+)\s+(\S+)\s+\((\d+)\)/);
+  if (httpMatch) {
+    const parts = ['net', `${httpMatch[1]} ${httpMatch[2]}`, httpMatch[3]];
+    const bytes = formatBytes(Buffer.byteLength(content, 'utf8'));
+    if (bytes) parts.push(bytes);
+    return parts.join(' · ');
+  }
+
+  // Exec: `Command \`<cmd>\`:\nExit code: <N>\n<output>`. The cmd may span
+  // multiple lines if the user passed a heredoc — non-greedy capture stops
+  // at the first `\`:` boundary, then we collapse whitespace for the preview.
+  const cmdMatch = content.match(/^Command `([\s\S]+?)`:/);
+  const exitMatch = content.match(/^Exit code: (-?\d+)$/m);
+  if (cmdMatch && exitMatch) {
+    const cmd = cmdMatch[1].replace(/\s+/g, ' ').trim();
+    const preview = cmd.length > 60 ? cmd.slice(0, 59) + '…' : cmd;
+    return `exec · ${preview} · exit ${exitMatch[1]}`;
+  }
+
+  const lines = content.split('\n');
+  if (lines.length <= 3 && /^(Wrote|Read|Created|Deleted|Moved|Renamed)\b/.test(lines[0])) {
+    return lines[0];
+  }
+
+  if (lines.length > 1 || content.length > 120) {
+    const firstLine = lines[0] || '';
+    const preview = firstLine.length > 100 ? firstLine.slice(0, 99) + '…' : firstLine;
+    const parts = ['tool', preview];
+    const bytes = formatBytes(Buffer.byteLength(content, 'utf8'));
+    if (bytes) parts.push(bytes);
+    return parts.join(' · ');
+  }
+
+  return trimmed;
+}
+
 module.exports = {
   formatDuration,
   formatBytes,
   formatHttpErrorTag,
   formatToolLine,
+  summarizeToolResult,
+  normalizeCmdForDisplay,
 };

package/lib/ui/input-field.js

@@ -7,10 +7,13 @@ const { RST, DIM, FG_CYAN, FG_GREEN, FG_YELLOW } = require('./ansi');
 const { stripAnsi, termWidth } = require('./utils');
 const writer = require('./writer');
 
-const SLASH_CMDS = [
-  '/help','/file','/new','/model','/models','/shell','/compact',
-  '/clear','/approve','/debug','/config','/history','/login','/whoami','/logout','/chats',
-];
+// Tab-completion command list is generated from the slash-command registry —
+// the single source of truth — so it can never drift from the dispatcher.
+// Resolved LIVE (not snapshotted at load) so commands registered after this
+// module loads — notably the Markdown custom commands discovered at chat
+// startup (Task 3.1) — appear in completion. The exported `SLASH_CMDS` is kept
+// for back-compat (since 1.3) but backed by the same live getter.
+const { completionNames } = require('../commands/registry');
 
 // ─── Key sequence parser ──────────────────────────────────────────────────────
 
@@ -571,7 +574,7 @@ class InputField extends EventEmitter {
       sources.push({ type: 'history', text });
     for (const item of this._searchExtraItems)
       sources.push(item);
-    for (const cmd of SLASH_CMDS)
+    for (const cmd of completionNames())
       sources.push({ type: 'command', text: cmd });
     return sources;
   }
@@ -635,7 +638,7 @@ class InputField extends EventEmitter {
     }
 
     if (!val.startsWith('/')) return;
-    const matches = SLASH_CMDS.filter(c => c.startsWith(val));
+    const matches = completionNames().filter(c => c.startsWith(val));
     if (!matches.length) return;
     if (matches.length === 1) {
       this._setValue(matches[0] + ' ');
@@ -1266,4 +1269,10 @@ class InputField extends EventEmitter {
   }
 }
 
-module.exports = { InputField, parseKeySequence, SLASH_CMDS };
+module.exports = { InputField, parseKeySequence };
+// SLASH_CMDS kept for back-compat (since 1.3), but now a live getter so callers
+// reading it after custom-command registration see the current set.
+Object.defineProperty(module.exports, 'SLASH_CMDS', {
+  enumerable: true,
+  get() { return completionNames(); },
+});

package/lib/ui/status-bar.js

@@ -4,6 +4,17 @@ const { RST, DIM, FG_RED, FG_DARK, SPINNER_DEFS } = require('./ansi');
 const { UI_THEME } = require('./theme');
 const { stripAnsi, termWidth } = require('./utils');
 
+// 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
 // orchestrator composes the full live region (status + input + hints) and
@@ -27,6 +38,11 @@ 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;
@@ -37,22 +53,53 @@ class FullStatusBar {
     // 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.
+    // falling mid-bubble can't produce a torn frame. The tick is what fights
+    // user scrollback while idle, so pause()/resume() START/STOP this timer
+    // (see _startClock/_stopClock) rather than gating _notify with a flag.
+    this._clockTimer = null;
+    this._startClock();
+  }
+
+  // Idempotent clock control. pause() stops the once-per-second redraw so the
+  // terminal viewport can scroll freely while idle; resume() restarts it.
+  // Guarded so repeated pause()/resume() cycles never stack a second timer.
+  _startClock() {
+    if (this._clockTimer) return;
     this._clockTimer = setInterval(() => this._notify(), 1000);
   }
 
-  pause()  { this._paused = true; }
-  resume() { this._paused = false; this._notify(); }
+  _stopClock() {
+    if (this._clockTimer) { clearInterval(this._clockTimer); this._clockTimer = null; }
+  }
+
+  // pause() genuinely halts the periodic redraw (clears the clock timer) so a
+  // forced redraw no longer snaps the viewport to the bottom while the user
+  // scrolls up. Event-driven redraws (update/updateMetrics/setCost/spinner)
+  // are unaffected — they call _notify directly. resume() restarts the clock
+  // and forces one repaint so the viewport returns to the input prompt.
+  pause()  { this._paused = true;  this._stopClock(); }
+  resume() { this._paused = false; this._startClock(); 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 ⇒
+    // clock-running invariant (idempotent, so no stacked timer).
     this._paused = false;
+    this._startClock();
 
     if (state === 'streaming') {
       if (!this._streamStart) { this._streamStart = Date.now(); this._streamTokens = 0; }
@@ -92,6 +139,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 +173,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 clock timer is
+  // cleared) 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;
@@ -168,6 +219,10 @@ class FullStatusBar {
       { visible: this._model || '—', ansi: this._model || '—', priority: 4 },
       { visible: tokenField.visible, ansi: tokenField.ansi,    priority: 3 },
     ];
+    if (this._cost) {
+      const c = `${this._cost}`;
+      fields.push({ visible: c, ansi: c, priority: 2 });
+    }
     if (state === 'streaming' && this._speed > 0) {
       const s = `${this._speed} t/s`;
       fields.push({ visible: s, ansi: s, priority: 1 });
@@ -221,21 +276,30 @@ 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}%)`;
     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}`;
     }
-    const ansi = `${usedStr} / ${limitStr} tok (${pctAnsi})`;
+    const ansi = `${estPrefix}${usedStr} / ${limitStr} tok (${pctAnsi})`;
     return { visible, ansi };
   }
 
@@ -255,13 +319,17 @@ class FullStatusBar {
   _renderBar()    { this._notify(); }
 
   _notify() {
-    if (this._paused) { this._onChange(); return; }
+    // Every redraw — periodic tick AND event-driven (update/updateMetrics/
+    // setCost/spinner) — flows through here. Pausing is done by stopping the
+    // clock timer (see pause/_stopClock), 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._stopClock();
   }
 }
 

package/lib/ui/terminal.js

@@ -7,6 +7,7 @@
 // the process dies.
 
 const writer = require('./writer');
+const dbg = require('../debug');
 
 let _registered = false;
 
@@ -30,20 +31,24 @@ function registerTerminalCleanup() {
 
   // Normal exit + process.exit(): fires synchronously, last thing Node does.
   // Catches every path that doesn't already manually call teardown.
-  process.on('exit', () => { try { writer.teardown(); } catch {} });
+  process.on('exit', () => {
+    try { writer.teardown(); } catch {}
+    try { dbg.close(); } catch {}
+  });
 
   // Signals that should terminate the app. Cleanup first, then exit with
   // the conventional 128+signum code. In TUI raw mode, Ctrl+C is consumed
   // at the byte level and SIGINT is not delivered, so this handler only
   // trips in non-raw contexts (one-shot commands, readline prompts, etc.).
-  process.on('SIGINT',  () => { try { writer.teardown(); } catch {} process.exit(130); });
-  process.on('SIGTERM', () => { try { writer.teardown(); } catch {} process.exit(143); });
-  process.on('SIGHUP',  () => { try { writer.teardown(); } catch {} process.exit(129); });
+  process.on('SIGINT',  () => { try { writer.teardown(); } catch {} try { dbg.close(); } catch {} process.exit(130); });
+  process.on('SIGTERM', () => { try { writer.teardown(); } catch {} try { dbg.close(); } catch {} process.exit(143); });
+  process.on('SIGHUP',  () => { try { writer.teardown(); } catch {} try { dbg.close(); } catch {} process.exit(129); });
 
   // Last-chance net: if something throws outside a try/catch, still
   // restore terminal state before the stack trace prints.
   process.on('uncaughtException', (err) => {
     try { writer.teardown(); } catch {}
+    try { dbg.close(); } catch {}
     // audit: allowed — crash handler stderr after writer teardown.
     try { console.error(err && err.stack ? err.stack : err); } catch {}
     process.exit(1);
@@ -51,6 +56,7 @@ function registerTerminalCleanup() {
 
   process.on('unhandledRejection', (reason) => {
     try { writer.teardown(); } catch {}
+    try { dbg.close(); } catch {}
     // audit: allowed — crash handler stderr after writer teardown.
     try { console.error(reason && reason.stack ? reason.stack : reason); } catch {}
     process.exit(1);

package/lib/ui/theme.js

@@ -21,6 +21,7 @@ const UI_THEME = {
   // values produced by TOOL_CATEGORIES so a lookup is categories[cat].
   categories: {
     net:    fg256(110),  // dusty blue    — http, download, upload
+    web:    fg256(80),   // aqua          — collapsed web-activity summary (W.3)
     file:   fg256(151),  // soft sage     — file ops
     cmd:    fg256(180),  // warm tan      — shell / exec
     user:   fg256(217),  // pale rose     — ask_user