@semalt-ai/code 1.8.5 → 1.20.0

package/lib/ui/theme.js

@@ -1,39 +1,113 @@
 'use strict';
 
-const { bg256, fg256, bgRGB, fgRGB } = require('./ansi');
+// THE single palette table (Output Refactor — Phase 2.5).
+//
+// Every colour the chrome surfaces use is defined here: tool-status lines,
+// the status bar, diff bodies, the web-activity summary, debug/meta blocks,
+// and the legacy message-role palette (`THEME` / `FG_*`) that the rest of the
+// app still imports. `ansi.js` holds only the ANSI *primitives* (the SGR
+// builders + spinners) and re-exports this palette for back-compat.
+//
+// Consolidation note: this module deliberately does NOT `require('./ansi')`.
+// It defines its own private SGR builders below. That keeps the dependency
+// one-directional (ansi.js → theme.js) so the two files never form a require
+// cycle, regardless of which one an entrypoint loads first.
+
+// Private SGR builders — not exported (ansi.js owns the public ones).
+const fg = (n) => `\x1b[38;5;${n}m`;
+const bg = (n) => `\x1b[48;5;${n}m`;
+const fgRGB = (r, g, b) => `\x1b[38;2;${r};${g};${b}m`;
+const bgRGB = (r, g, b) => `\x1b[48;2;${r};${g};${b}m`;
+
+// ── NO_COLOR + non-TTY gate ─────────────────────────────────────────────────
+// The single place colour is switched off. `colorEnabled()` is dynamic (read
+// per call) so the same process can answer differently for a piped child or a
+// test that sets NO_COLOR. Per the NO_COLOR spec, ANY non-empty value disables
+// colour; an empty string does not. `colorize()` is the resolver-side helper —
+// it returns the code when colour is on, '' otherwise.
+function colorEnabled() {
+  return process.stdout.isTTY === true && !process.env.NO_COLOR;
+}
+function colorize(code) {
+  return colorEnabled() ? code : '';
+}
+
+// ── Legacy message-role palette (relocated verbatim from ansi.js) ───────────
+// Values are unchanged — these drive message roles, menus, prompts and syntax
+// chrome, which are out of scope for the Phase 2.5 saturation pass. They live
+// here only so colour has a single home; ansi.js re-exports them.
+const THEME = {
+  user:  '\x1b[36m',
+  agent: '\x1b[32m',
+  sys:   '\x1b[33m',
+  error: '\x1b[31;1m',
+  warn:  '\x1b[33;1m',
+  tool:  '\x1b[35m',
+  dim:   '\x1b[2m',
+  reset: '\x1b[0m',
+};
+
+const FG_GRAY   = fg(245);
+const FG_DARK   = fg(240);
+const FG_BLUE   = fg(75);
+const FG_CYAN   = fg(116);
+const FG_GREEN  = fg(114);
+const FG_YELLOW = fg(222);
+const FG_RED    = fg(203);
+const FG_TEAL   = fg(73);
+
+const FG_CODE_BG     = bg(236);
+const BG_SELECTED    = bg(237);
+const FG_CODE_BORDER = fg(240);
+const FG_CODE_LANG   = fg(75);
+const FG_TAG         = fg(176);
+const FG_FILEPATH    = fg(222);
 
-// Shared chrome palette. Used by tool-status lines, debug blocks, meta
-// messages, and any other non-content surface. Diff bodies have their own
-// background palette below. Keep palette choices out of renderers — if a
-// colour is added to a status line, it should come from here.
+// ── Saturated chrome palette (Phase 2.5) ────────────────────────────────────
+// Dark-terminal assumption: full saturation, differentiate categories. Tunable
+// here — every colour the tool line / status bar / web summary read resolves
+// through `resolveLineColors`, so a category that reads wrong is a one-line edit.
 const UI_THEME = {
-  success: fg256(114),  // bright mint
-  warning: fg256(179),  // amber
-  error:   fg256(174),  // salmon
-  info:    fg256(75),   // light blue
-  muted:   fg256(240),  // dim gray — frames, metadata
-  subtle:  fg256(244),  // slightly less dim — secondary text
-  accent:  fg256(141),  // soft purple — tool names, IDs
+  success: fg(40),   // vivid green — ok glyph, replay-success indicator
+  warning: fg(214),  // amber
+  error:   fg(203),  // alarming red (not pink)
+  info:    fg(75),   // light blue
+  muted:   fg(240),  // dim gray — frames, separators
+  subtle:  fg(244),  // secondary text — durations, meta, tokens
+  accent:  fg(141),  // purple — model name, IDs
   default: '\x1b[39m',  // terminal default fg
-  // Per-category accent variations for tool-line chrome. Chosen from the
-  // pastel/light bands (100–180 range) so concurrent pending lines read
-  // as a coordinated palette rather than a rainbow. Keys mirror the
-  // values produced by TOOL_CATEGORIES so a lookup is categories[cat].
+  // Per-category accent. Keyed by the category STRING produced by
+  // `categoryForTag` (shell/file/net/…), so a lookup is `categories[cat]`.
+  // Saturated + differentiated; `git`/`mcp` are first-class (no longer folded
+  // into the `tool` fallback); `tool` is demoted to gray so real categories pop.
   categories: {
-    net:    fg256(110),  // dusty blue    — http, download, upload
-    file:   fg256(151),  // soft sage     — file ops
-    cmd:    fg256(180),  // warm tan      — shell / exec
-    user:   fg256(217),  // pale rose     — ask_user
-    memory: fg256(183),  // light lavender — memory
-    env:    fg256(186),  // pale gold     — env vars
-    system: fg256(109),  // steel blue    — system_info
-    debug:  fg256(244),  // muted gray    — debug blocks
-    tool:   fg256(141),  // accent purple — fallback
+    shell:  fg(214),  // orange
+    file:   fg(77),   // green
+    net:    fg(39),   // bright blue
+    web:    fg(44),   // cyan
+    git:    fg(170),  // magenta-pink
+    mcp:    fg(141),  // purple
+    user:   fg(211),  // pink
+    memory: fg(183),  // lavender
+    env:    fg(186),  // pale gold
+    system: fg(109),  // steel blue
+    debug:  fg(244),  // gray
+    tool:   fg(245),  // gray — fallback, demoted so categories differentiate
   },
 };
 
-// Indicator glyphs for status lines. Separated from colour so the renderer
-// can swap either independently (e.g. an ASCII-only fallback later).
+// Status → glyph colour. Saturated; the running indicator is never gray (it's
+// the most time-sensitive element — Phase 3 animates it, but even static it
+// must read as live).
+const STATUS_COLORS = {
+  ok:      fg(40),   // vivid green ✓
+  error:   fg(203),  // red ✗ (alarming, not pink)
+  running: fg(39),   // cyan ● — fallback when a category has no vivid tint
+  warning: fg(214),  // amber ⚠
+};
+
+// Indicator glyphs for status lines. Separated from colour so the renderer can
+// swap either independently (e.g. an ASCII-only fallback later).
 const UI_ICONS = {
   pending: '●',
   success: '✓',
@@ -44,19 +118,19 @@ const UI_ICONS = {
 };
 
 // Diff rendering palette. Each change-type carries both a 256-color and a
-// truecolor background so the renderer can pick based on COLORTERM at start.
-// Only this file names colors — keep magic numbers out of diff.js.
+// truecolor background so the renderer picks based on COLORTERM at start.
+// Foregrounds saturated (Phase 2.5); gutters lifted one step so structure shows.
 const DIFF_THEME = {
   added: {
-    bg256:  bg256(22),            // deep forest green
+    bg256:  bg(22),               // deep forest green
     bgTC:   bgRGB(14, 40, 23),
-    signFg: fg256(114),           // bright mint
+    signFg: fg(40),               // vivid green
     sign:   '+',
   },
   removed: {
-    bg256:  bg256(52),            // deep burgundy
+    bg256:  bg(52),               // deep burgundy
     bgTC:   bgRGB(50, 18, 20),
-    signFg: fg256(174),           // bright salmon
+    signFg: fg(203),              // red
     sign:   '-',
   },
   context: {
@@ -66,20 +140,16 @@ const DIFF_THEME = {
     sign:   ' ',
   },
   gutter:     { bg256: '', bgTC: '' },
-  lineNumber: fg256(240),         // dim gray
+  lineNumber: fg(244),            // lifted from 240 — visible gutter
   code:       '\x1b[39m',         // terminal default fg
   header:     '\x1b[1;38;5;75m',  // bold light blue
-  frame:      fg256(238),         // very dim gray
+  frame:      fg(242),            // lifted from 238 — visible structure
 };
 
-// Maps an agent-loop tool tag onto the short category shown before the
-// operation in a tool line ("file", "net", "shell"). Renderers should
-// fall back to the tag itself if the tag isn't listed here.
-//
-// Keys include BOTH the XML tag names (read_file, write_file, shell) and
-// the internal action names emitted by the native-function mapper (read,
-// write, exec). Normalization happens at lookup time so neither side needs
-// to know about the other's naming.
+// Maps a tool tag onto the short category shown before the operation in a tool
+// line. Keys include BOTH XML tag names (read_file, shell) and native action
+// names (read, exec) — normalized at lookup. `git_*` tags map to `git`; MCP
+// tools (`mcp__server__tool`) resolve via a prefix rule in `categoryForTag`.
 const TOOL_CATEGORIES = {
   exec: 'shell', shell: 'shell', run: 'shell', run_command: 'shell', bash: 'shell',
   read: 'file', write: 'file', append: 'file',
@@ -93,7 +163,83 @@ const TOOL_CATEGORIES = {
   store_memory: 'memory', recall_memory: 'memory', list_memories: 'memory',
   get_env: 'env', set_env: 'env',
   system_info: 'system',
+  git_status: 'git', git_diff: 'git', git_log: 'git', git_add: 'git',
+  git_commit: 'git', git_branch: 'git', git_checkout: 'git', git_worktree: 'git',
   debug: 'debug',
 };
 
-module.exports = { DIFF_THEME, UI_THEME, UI_ICONS, TOOL_CATEGORIES };
+// The XML extractor and native mapper hand *action* names (read, exec) that
+// differ from *tag* names (read_file, shell). Normalize so category lookups
+// resolve regardless of which rail 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';
+}
+
+// Single source of truth for tag → category. Both `tool-operation.js` (the
+// descriptor) and `format.js` (the rendered label) consume this so the
+// descriptor's category and the line's category can never diverge.
+function categoryForTag(tag) {
+  const t = _normalizeTag(tag);
+  if (TOOL_CATEGORIES[t]) return TOOL_CATEGORIES[t];
+  if (t.startsWith('git_')) return 'git';
+  if (t.startsWith('mcp__') || t.startsWith('mcp_')) return 'mcp';
+  return 'tool';
+}
+
+// Normalize an incoming status to the resolver vocabulary. Accepts both the
+// runtime forms ('pending'/'success'/'failure') and the descriptor forms
+// ('pending'/'running'/'ok'/'error').
+function _normStatus(s) {
+  if (s === 'pending' || s === 'running') return s;
+  if (s === 'error' || s === 'failure') return 'error';
+  return 'ok';
+}
+
+// THE colour resolver. Maps a descriptor's {category, status} to the colours
+// for its glyph, category label, operation text, duration and meta. This is the
+// single seam every chrome line goes through — `formatToolLine`,
+// `formatWebSummaryLine`, etc. consume it instead of re-deriving colour inline,
+// which is what makes the palette a one-table change. Honours NO_COLOR/non-TTY
+// via `colorize` — when colour is off, every field resolves to ''.
+function resolveLineColors(category, status) {
+  const cat = category || 'tool';
+  const catColor = colorize(UI_THEME.categories[cat] || UI_THEME.categories.tool);
+  const st = _normStatus(status);
+
+  let glyph;
+  if (st === 'error') glyph = colorize(STATUS_COLORS.error);
+  else if (st === 'ok') glyph = colorize(STATUS_COLORS.ok);
+  else {
+    // pending / running — category-tinted for vivid categories, cyan otherwise.
+    // NEVER gray: the `tool`/`debug` fallbacks would tint gray, so use cyan.
+    glyph = (cat !== 'tool' && cat !== 'debug')
+      ? catColor
+      : colorize(STATUS_COLORS.running);
+  }
+
+  const tail = colorize(st === 'error' ? UI_THEME.error : UI_THEME.subtle);
+  return {
+    glyph,            // status-keyed
+    label: catColor,  // category-keyed (the 5-char label)
+    op: catColor,     // category-keyed (the operation text — painted too)
+    dur: tail,        // subtle, or error red on failure
+    meta: tail,       // subtle, or error red on failure
+  };
+}
+
+module.exports = {
+  // chrome palette + resolver
+  DIFF_THEME, UI_THEME, UI_ICONS, STATUS_COLORS, TOOL_CATEGORIES,
+  categoryForTag, resolveLineColors, colorEnabled, colorize,
+  // legacy palette (re-exported by ansi.js for back-compat)
+  THEME,
+  FG_GRAY, FG_DARK, FG_BLUE, FG_CYAN, FG_GREEN, FG_YELLOW, FG_RED, FG_TEAL,
+  FG_CODE_BG, BG_SELECTED, FG_CODE_BORDER, FG_CODE_LANG, FG_TAG, FG_FILEPATH,
+};

package/lib/ui/tool-operation.js

@@ -0,0 +1,190 @@
+'use strict';
+
+// ToolOperation descriptor (Output Refactor — Phase 1).
+//
+// The single, immutable description of one tool invocation's display state,
+// produced ONCE from the normalized `[action, ...opts]` tuple the agent loop
+// already computes (so it covers the XML and native rails identically — the
+// tuple is their convergence point). It is the display analogue of the
+// `boundToolOutput` token chokepoint: every chrome line for a tool call is
+// rendered from this one descriptor by `render-operation.js`, instead of each
+// call site assembling its own formatToolLine arguments.
+//
+// Phase 1 is a pure RE-ROUTING — the descriptor carries exactly the data the
+// existing formatters consume, so the renderer can reproduce today's output
+// byte-for-byte. Later phases collapse duplicates and fold in web/MCP/replay.
+//
+// Shape (all fields are plain data — no ANSI, no IO):
+//   {
+//     id         invocation id (writer activity-region key), or null
+//     category   short tag for the line ("file", "cmd", "net", …) — display only
+//     glyph      indicator glyph for the status ('●' | '✓' | '✗')
+//     tag        the ORIGINAL tool tag (formatToolLine normalizes it itself)
+//     target     the thing acted on — command / path / url / arg, stated once
+//     attrs      parsed tuple options (the operation detail source)
+//     status     'pending' | 'running' | 'ok' | 'error'
+//     durationMs elapsed/total ms, or null
+//     meta       category-specific tail (exit_code, bytes, count, status_code)
+//     error      error shape ({ message, code }), or null
+//     noDuration suppress the duration segment (blocking tools, e.g. ask_user)
+//     detail     optional body, COLLAPSED per the Phase 5 detail policy:
+//                  { kind: 'diff',   payload: { before, after, path } }
+//                    — file edits; rendered EXPANDED to diff_max_lines.
+//                  { kind: 'output', payload: { body, category } }
+//                    — shell/MCP/subagent SUCCESS output; rendered as a
+//                      shell_preview_lines preview + `… N more lines`.
+//                or null. Errors carry NO detail here — the error body renders
+//                EXPANDED on the existing chat-history error path (unchanged).
+//   }
+
+const { UI_ICONS, categoryForTag } = require('./theme');
+const { extractDisplayBody } = require('./format');
+
+// Category resolution (incl. action→tag normalization and the git_*/mcp__
+// prefix rules) lives in theme.js so the descriptor's `category` and the
+// rendered line's category can never diverge.
+function _categoryFor(tag) {
+  return categoryForTag(tag);
+}
+
+// Normalize an incoming status (runtime forms 'success'/'failure' OR descriptor
+// forms 'ok'/'error') to the descriptor vocabulary. `error` present forces error.
+function _normalizeStatus(status, error) {
+  if (status === 'pending') return 'pending';
+  if (status === 'running') return 'running';
+  if (status === 'error' || status === 'failure' || error) return 'error';
+  return 'ok';
+}
+
+function _glyphFor(status) {
+  if (status === 'pending' || status === 'running') return UI_ICONS.pending;
+  if (status === 'error') return UI_ICONS.error;
+  return UI_ICONS.success;
+}
+
+// Build the detail body per the Phase 5 policy. Order matters: errors carry no
+// preview detail (the error body renders expanded elsewhere); a file edit's diff
+// always wins over an output preview; otherwise a shell/MCP/subagent success
+// with non-empty output gets an output-preview detail.
+function _detailFor(spec, category, status) {
+  if (status === 'error') return null;
+  const { diff } = spec;
+  if (diff && typeof diff.before === 'string' && typeof diff.after === 'string') {
+    return { kind: 'diff', payload: { before: diff.before, after: diff.after, path: diff.path || '' } };
+  }
+  const previewable = category === 'shell' || category === 'mcp' || spec.tag === 'spawn_agent';
+  if (previewable && typeof spec.output === 'string') {
+    const body = extractDisplayBody(spec.output);
+    if (body && body.trim()) return { kind: 'output', payload: { body, category } };
+  }
+  return null;
+}
+
+// Produce the immutable descriptor. `spec` mirrors the data already available
+// at the onToolStart/onToolEnd callbacks:
+//   { id, tag, arg, attrs, status, durationMs, meta, error, diff, noDuration }
+// `tag`/`arg`/`attrs` are the parsed tuple (call[0], call[1], _attrsFromCall).
+function buildToolOperation(spec) {
+  const s = spec || {};
+  const tag = s.tag || 'tool';
+  const status = _normalizeStatus(s.status, s.error);
+  const category = _categoryFor(tag);
+  const descriptor = {
+    id: s.id != null ? s.id : null,
+    category,
+    glyph: _glyphFor(status),
+    tag,
+    target: s.arg != null ? s.arg : '',
+    attrs: s.attrs || null,
+    status,
+    durationMs: Number.isFinite(s.durationMs) ? s.durationMs : null,
+    meta: s.meta || null,
+    error: s.error || null,
+    noDuration: !!s.noDuration,
+    detail: _detailFor(s, category, status),
+  };
+  return Object.freeze(descriptor);
+}
+
+// ── Serialization for replay (Output Refactor — Phase 6) ─────────────────────
+//
+// A built descriptor is transient: it exists only for the duration of one live
+// tool turn. To replay a saved session (/history, /chats, --resume) with the
+// SAME fidelity a fresh turn shows — real diff, real duration, real status —
+// the *terminal-state* core of the descriptor is persisted next to the tool
+// result message (as a sibling `_display` key, see agent.js) and rebuilt here
+// on load. Both helpers are pure data transforms (no ANSI, no IO).
+//
+// `serializeOperation(op)` extracts the plain-data core `renderOperation` reads
+// for a COMPLETED (non-animating) op. The two live/animation-only fields are
+// dropped:
+//   - id    — the live activity-region key, meaningless once the turn ended.
+//   - glyph — recomputed from `status` by the renderer (formatToolLine).
+// Everything the renderer DOES read for phase 'result' / 'detail' is kept:
+// tag, target, attrs (the operation text is derived from attrs by _operation()
+// in format.js — NOT in §1's field list, added here because the result line is
+// not byte-identical without it), category, status, durationMs, meta, error,
+// noDuration (suppresses the duration segment for blocking tools — also beyond
+// §1's list, kept for the same byte-identity reason), and the collapsed detail.
+const DISPLAY_FORMAT_VERSION = 1;
+
+// `operationCore(op)` is the SINGLE descriptor→plain-data mapping shared by
+// `serializeOperation` (persistence/replay) and `renderOperation`'s json/event
+// modes (embeddable output — Phase 6d). It emits the descriptor's own vocabulary
+// (tag/target/attrs/category/status/durationMs/meta/error/noDuration/detail) and
+// nothing else — no `v` version tag (that is a persistence concern added by
+// serializeOperation), no ANSI, no IO, no live/animation fields (id, glyph). The
+// two live-only fields are dropped exactly as serializeOperation always dropped
+// them: `id` (the activity-region key) and `glyph` (recomputed from `status`).
+// Returns null for a non-object op so callers degrade gracefully.
+function operationCore(op) {
+  if (!op || typeof op !== 'object') return null;
+  return {
+    tag: op.tag,
+    target: op.target,
+    attrs: op.attrs || null,
+    category: op.category,
+    status: op.status,
+    durationMs: Number.isFinite(op.durationMs) ? op.durationMs : null,
+    meta: op.meta || null,
+    error: op.error || null,
+    noDuration: !!op.noDuration,
+    detail: op.detail || null,
+  };
+}
+
+function serializeOperation(op) {
+  const core = operationCore(op);
+  if (!core) return null;
+  // `v` first, then the shared core — byte-identical key order to the pre-6d
+  // hand-rolled object (replay/persistence depend on this exact shape).
+  return { v: DISPLAY_FORMAT_VERSION, ...core };
+}
+
+// Rebuild a renderable descriptor from a persisted core. Returns null when the
+// core is absent OR its version is unknown (`v` missing / not 1) — the caller
+// then falls back to the legacy summarizeToolResult path, so old sessions and
+// any future format degrade gracefully instead of crashing. The returned object
+// mirrors buildToolOperation's output shape so renderOperation treats it
+// identically to a fresh descriptor (it is not frozen — replay never mutates it).
+function descriptorFromStored(core) {
+  if (!core || typeof core !== 'object') return null;
+  if (core.v !== DISPLAY_FORMAT_VERSION) return null;
+  const status = core.status || 'ok';
+  return {
+    id: null,
+    category: core.category,
+    glyph: _glyphFor(status),
+    tag: core.tag || 'tool',
+    target: core.target != null ? core.target : '',
+    attrs: core.attrs || null,
+    status,
+    durationMs: Number.isFinite(core.durationMs) ? core.durationMs : null,
+    meta: core.meta || null,
+    error: core.error || null,
+    noDuration: !!core.noDuration,
+    detail: core.detail || null,
+  };
+}
+
+module.exports = { buildToolOperation, operationCore, serializeOperation, descriptorFromStored };

package/lib/ui/utils.js

@@ -45,13 +45,17 @@ function termWidth(str) {
 // Walks the string once; CSI escape sequences (`\x1b[…final`) are copied
 // through verbatim without consuming any visible width. Visible-width math
 // uses _cpWidth, so a 2-col CJK glyph or emoji counts as 2 and combining
-// marks count as 0. Always terminates with `\x1b[0m` so the terminal isn't
-// left in a colored state at the truncation point (safe when no escape
-// preceded the cut — a redundant reset is a no-op).
+// marks count as 0. Terminates with `\x1b[0m` ONLY when the (possibly
+// truncated) output actually contains an escape, so a cut that left an SGR
+// span open is closed without leaving the terminal colored at the cut point.
+// When the output is escape-free we append nothing: a trailing reset on
+// escape-free text is a stray escape that leaks through NO_COLOR. The gate is
+// content-driven (out.indexOf('\x1b')), not flag-driven, so a preview body
+// line carrying a child process's own ANSI is still closed defensively.
 function truncateVisible(str, maxCols) {
   if (!str) return '';
   const max = Math.max(0, maxCols | 0);
-  if (max === 0) return '\x1b[0m';
+  if (max === 0) return '';
   const s = String(str);
   const len = s.length;
   let out = '';
@@ -82,7 +86,7 @@ function truncateVisible(str, maxCols) {
     cols += w;
     i += clen;
   }
-  return out + '\x1b[0m';
+  return out.indexOf('\x1b') !== -1 ? out + '\x1b[0m' : out;
 }
 
 // Repeat a single-column glyph so the visible row is exactly `width` columns.