@semalt-ai/code 1.8.5 → 1.19.0

package/lib/ui/format.js

@@ -153,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;
   }
 }
 

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/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

package/lib/ui/web-activity.js

@@ -0,0 +1,218 @@
+'use strict';
+
+// Web-activity process summary (Task W.3, Part 1).
+//
+// A web task runs `web_search` (find candidate pages) then targeted `http_get`
+// (read the relevant ones). By default each operation printed its own tool line
+// (one "tool · web_search" / "net · GET …" row per call), which reads as a noisy
+// list rather than one coherent process. This module collapses a run of
+// consecutive web operations into a SINGLE compact process-summary line —
+//
+//     ✓ web · search "коррупционные скандалы…" · 2 queries · 3 sources read · 1 blocked
+//
+// — while `--debug` keeps the full per-operation lines (in debug mode chat-turn.js
+// bypasses this collapser and renders each op the normal way).
+//
+// Display only: the audit log still records every individual operation (that
+// happens in the executors, untouched here), and NON-web tools render exactly as
+// before. Scope: `web_search` + `http_get`. `download` is a file-save, not a page
+// read for the search→fetch flow, so it keeps its own line.
+
+const { UI_THEME, UI_ICONS } = require('./theme');
+const { RST, DIM } = require('./ansi');
+const { formatDuration } = require('./format');
+
+// The tools collapsed into the web-activity summary.
+const WEB_TOOLS = new Set(['web_search', 'http_get']);
+
+function isWebTool(tag) { return WEB_TOOLS.has(tag); }
+
+function _truncate(text, max) {
+  const s = String(text == null ? '' : text).replace(/\s+/g, ' ').trim();
+  if (s.length <= max) return s;
+  return s.slice(0, Math.max(0, max - 1)) + '…';
+}
+
+// Whether a finished web op counts as a success. A `web_search` is ok unless the
+// executor flagged an error (backend down). An `http_get` is ok only when it both
+// avoided a transport error (timeout/DNS — surfaced as `op.error`) AND the server
+// answered < 400: a 403/406 is a real "blocked" even though the fetch itself
+// completed and returned a status code.
+function opSucceeded(op) {
+  if (!op) return false;
+  if (op.error) return false;
+  if (op.tag === 'http_get' && typeof op.status === 'number' && op.status >= 400) return false;
+  return true;
+}
+
+// Pure: fold the recorded op list into the counts the summary needs.
+function aggregateWebOps(ops) {
+  const state = {
+    searchCount: 0, searchFailed: 0, queries: [],
+    fetchCount: 0, fetchOk: 0, fetchFailed: 0,
+  };
+  for (const op of (ops || [])) {
+    if (!op) continue;
+    const ok = opSucceeded(op);
+    if (op.tag === 'web_search') {
+      state.searchCount += 1;
+      if (!ok) state.searchFailed += 1;
+      if (op.query) state.queries.push(op.query);
+    } else if (op.tag === 'http_get') {
+      state.fetchCount += 1;
+      if (ok) state.fetchOk += 1; else state.fetchFailed += 1;
+    }
+  }
+  return state;
+}
+
+// Pure: the plain-text segments of the summary (no ANSI). Each segment is tagged
+// with a `kind` so the styled renderer can colour failures distinctly. Exposed
+// for tests and reused by the styled renderer. Failures (a blocked source / a
+// failed search) are ALWAYS represented so the compact view never silently drops
+// a source that didn't load.
+function webSummarySegments(state) {
+  const segs = [];
+  if (state.searchCount > 0) {
+    const q = state.queries[0] ? `"${_truncate(state.queries[0], 48)}"` : '';
+    segs.push({ kind: 'lead', text: `search ${q}`.trim() });
+    if (state.searchCount > 1) segs.push({ kind: 'count', text: `${state.searchCount} queries` });
+    if (state.searchFailed > 0) {
+      segs.push({ kind: 'fail', text: `${state.searchFailed} search${state.searchFailed === 1 ? '' : 'es'} failed` });
+    }
+  }
+  if (state.fetchCount > 0) {
+    segs.push({ kind: state.searchCount > 0 ? 'count' : 'lead', text: `${state.fetchOk} ${state.fetchOk === 1 ? 'source' : 'sources'} read` });
+    if (state.fetchFailed > 0) segs.push({ kind: 'fail', text: `${state.fetchFailed} blocked` });
+  }
+  if (segs.length === 0) segs.push({ kind: 'lead', text: 'web' });
+  return segs;
+}
+
+// Plain-text one-liner (no ANSI). The text the tests assert on.
+function webSummaryText(state) {
+  return webSummarySegments(state).map((s) => s.text).join(' · ');
+}
+
+// Styled, chrome-consistent line for the writer's activity region / scrollback.
+// Mirrors formatToolLine's "<glyph> <category> · <segments…>" layout so the
+// summary reads as a peer of the other tool lines, not a foreign widget.
+function formatWebSummaryLine(state, opts) {
+  const { pending = false, durationMs = 0 } = opts || {};
+  const glyph = pending ? UI_ICONS.pending : UI_ICONS.success;
+  const glyphColor = pending ? UI_THEME.muted : UI_THEME.success;
+  const cat = 'web'.padEnd(5);
+  const catColor = (UI_THEME.categories && UI_THEME.categories.web) || UI_THEME.accent;
+  const sep = ` ${DIM}·${RST} `;
+
+  const out = [`  ${glyphColor}${glyph}${RST} ${catColor}${cat}${RST}`];
+  for (const seg of webSummarySegments(state)) {
+    let color = UI_THEME.subtle;
+    if (seg.kind === 'lead') color = UI_THEME.default;
+    else if (seg.kind === 'fail') color = UI_THEME.warning;
+    out.push(`${color}${seg.text}${RST}`);
+  }
+  if (pending) out.push(`${UI_THEME.muted}${formatDuration(durationMs)}…${RST}`);
+  return out.join(sep);
+}
+
+// Batch renderer / policy seam (used by tests, and documents the runtime split):
+//   debug   → one full per-operation tool line per op (nothing hidden), built
+//             with the SAME formatToolLine the runtime uses.
+//   default → a single collapsed summary line.
+function renderWebActivity(ops, opts) {
+  const { debug = false, formatToolLine } = opts || {};
+  if (debug) {
+    return (ops || []).map((op) => formatToolLine({
+      status: opSucceeded(op) ? 'success' : 'failure',
+      tag: op.tag,
+      arg: op.query || op.url || '',
+      attrs: op.tag === 'web_search' ? { query: op.query } : { url: op.url },
+      durationMs: op.durationMs,
+      meta: op.tag === 'http_get' ? { status_code: op.status, bytes: op.bytes } : null,
+      error: op.error ? { message: String(op.error) } : null,
+    }));
+  }
+  return [formatWebSummaryLine(aggregateWebOps(ops), { pending: false })];
+}
+
+// Stateful runtime collapser. Owns one writer "activity" entry per group of
+// consecutive web ops, updating it in place as ops complete and committing a
+// single final summary line to scrollback on flush(). Tools run sequentially in
+// the agent loop, so at most one group is ever open and there is no concurrency.
+function createWebActivityTracker(deps) {
+  const { writerModule } = deps || {};
+  let groupId = null;
+  let seq = 0;
+  let ended = [];
+  let current = null; // the in-flight op, shown in the pending line before it ends
+
+  function _render(durationMs) {
+    const state = aggregateWebOps(current ? ended.concat([current]) : ended);
+    return formatWebSummaryLine(state, { pending: true, durationMs });
+  }
+
+  function _refresh() {
+    if (groupId === null) return;
+    writerModule.updateActivity(groupId, (elapsedMs) => _render(elapsedMs));
+  }
+
+  return {
+    isWeb: isWebTool,
+    isOpen() { return groupId !== null; },
+
+    start(tag, input) {
+      current = {
+        tag,
+        query: tag === 'web_search' ? input : undefined,
+        url: tag === 'http_get' ? input : undefined,
+      };
+      if (groupId === null) {
+        groupId = `web-${seq++}`;
+        writerModule.startActivity(groupId, (elapsedMs) => _render(elapsedMs));
+      } else {
+        _refresh();
+      }
+    },
+
+    end(tag, result, durationMs, toolCtx) {
+      const meta = toolCtx && toolCtx.meta;
+      const attrs = toolCtx && toolCtx.attrs;
+      ended.push({
+        tag,
+        durationMs,
+        query: (attrs && attrs.query) || (current && current.query),
+        url: (attrs && attrs.url) || (current && current.url),
+        status: meta && typeof meta.status_code === 'number' ? meta.status_code : undefined,
+        bytes: meta && typeof meta.bytes === 'number' ? meta.bytes : undefined,
+        error: toolCtx && toolCtx.error ? (toolCtx.error.message || String(toolCtx.error)) : undefined,
+      });
+      current = null;
+      _refresh();
+    },
+
+    // Commit the collapsed summary for the current group to scrollback and reset.
+    // A no-op when no group is open.
+    flush() {
+      if (groupId === null) return;
+      const id = groupId;
+      const line = formatWebSummaryLine(aggregateWebOps(ended), { pending: false });
+      groupId = null;
+      ended = [];
+      current = null;
+      writerModule.endActivity(id, line);
+    },
+  };
+}
+
+module.exports = {
+  WEB_TOOLS,
+  isWebTool,
+  opSucceeded,
+  aggregateWebOps,
+  webSummarySegments,
+  webSummaryText,
+  formatWebSummaryLine,
+  renderWebActivity,
+  createWebActivityTracker,
+};