@semalt-ai/code 1.8.0 → 1.8.3

package/lib/ui/terminal.js

@@ -0,0 +1,58 @@
+'use strict';
+
+// Process-level signal/exit wiring for the TUI. The actual terminal cleanup
+// (erase live region, reset SGR, show cursor, pop modes) lives in
+// writer.teardown() so every exit path runs the exact same single-write
+// sequence. This module just makes sure that sequence runs no matter how
+// the process dies.
+
+const writer = require('./writer');
+
+let _registered = false;
+
+// Kept for backwards compatibility with callers that publish viewport
+// metrics. The live-region writer doesn't need them — teardown computes
+// what to erase from its own live-region height.
+function setCleanupInfo(_info) {}
+
+// Idempotent. Safe to call from synchronous contexts including the 'exit'
+// handler. Delegates to writer.teardown(), which is the single source of
+// truth for what a "clean" terminal state looks like.
+function teardownTerminal() {
+  try { writer.teardown(); } catch {}
+}
+
+// Install process-level handlers. Called once by the entrypoint. Idempotent
+// so library code can also call it defensively without doubling handlers.
+function registerTerminalCleanup() {
+  if (_registered) return;
+  _registered = true;
+
+  // 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 {} });
+
+  // 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); });
+
+  // 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 { console.error(err && err.stack ? err.stack : err); } catch {}
+    process.exit(1);
+  });
+
+  process.on('unhandledRejection', (reason) => {
+    try { writer.teardown(); } catch {}
+    try { console.error(reason && reason.stack ? reason.stack : reason); } catch {}
+    process.exit(1);
+  });
+}
+
+module.exports = { teardownTerminal, registerTerminalCleanup, setCleanupInfo };

package/lib/ui/theme.js

@@ -0,0 +1,78 @@
+'use strict';
+
+const { bg256, fg256, bgRGB, fgRGB } = require('./ansi');
+
+// 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.
+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
+  default: '\x1b[39m',  // terminal default fg
+};
+
+// 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: '✓',
+  error:   '✗',
+  retry:   '⟳',
+  warn:    '⚠',
+  bullet:  '●',
+};
+
+// 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.
+const DIFF_THEME = {
+  added: {
+    bg256:  bg256(22),            // deep forest green
+    bgTC:   bgRGB(14, 40, 23),
+    signFg: fg256(114),           // bright mint
+    sign:   '+',
+  },
+  removed: {
+    bg256:  bg256(52),            // deep burgundy
+    bgTC:   bgRGB(50, 18, 20),
+    signFg: fg256(174),           // bright salmon
+    sign:   '-',
+  },
+  context: {
+    bg256:  '',
+    bgTC:   '',
+    signFg: '',
+    sign:   ' ',
+  },
+  gutter:     { bg256: '', bgTC: '' },
+  lineNumber: fg256(240),         // dim gray
+  code:       '\x1b[39m',         // terminal default fg
+  header:     '\x1b[1;38;5;75m',  // bold light blue
+  frame:      fg256(238),         // very dim gray
+};
+
+// Maps an agent-loop tool tag onto the short category shown before the colon
+// in a tool-status line ("file:", "net:", "cmd:"). Renderers should fall
+// back to the tag itself if the tag isn't listed here.
+const TOOL_CATEGORIES = {
+  exec: 'cmd', shell: 'cmd', run: 'cmd', run_command: 'cmd',
+  read_file: 'file', write_file: 'file', create_file: 'file',
+  append_file: 'file', delete_file: 'file', edit_file: 'file',
+  list_dir: 'file', search_files: 'file', search_in_file: 'file',
+  replace_in_file: 'file', move_file: 'file', copy_file: 'file',
+  file_stat: 'file', make_dir: 'file', remove_dir: 'file',
+  http_get: 'net', download: 'net', upload: 'net',
+  ask_user: 'user',
+  store_memory: 'memory', recall_memory: 'memory', list_memories: 'memory',
+  get_env: 'env', set_env: 'env',
+  system_info: 'system',
+  debug: 'debug',
+};
+
+module.exports = { DIFF_THEME, UI_THEME, UI_ICONS, TOOL_CATEGORIES };

package/lib/ui/utils.js

@@ -7,6 +7,38 @@ function stripAnsi(str) {
   return str.replace(/\x1b\[[^m]*m/g, '');
 }
 
+// Display-column width of a string. Handles ASCII/Latin/Cyrillic (1 col),
+// CJK ideographs + hiragana/katakana (2 cols), emoji in SMP pictograph
+// blocks and the dingbat/misc-symbols range (2 cols), and zero-width joiners,
+// combining marks, variation selectors (0 cols). Out-of-scope scripts
+// (Hangul, Thai, RTL) fall through as 1 col.
+function termWidth(str) {
+  if (!str) return 0;
+  let w = 0;
+  for (const ch of str) {
+    const cp = ch.codePointAt(0);
+    if (cp === 0) continue;
+    if ((cp >= 0x0300 && cp <= 0x036F) ||
+        (cp >= 0x200B && cp <= 0x200F) ||
+        cp === 0x2060 ||
+        (cp >= 0xFE00 && cp <= 0xFE0F) ||
+        (cp >= 0xE0100 && cp <= 0xE01EF)) {
+      continue;
+    }
+    if ((cp >= 0x3040 && cp <= 0x33FF) ||
+        (cp >= 0x3400 && cp <= 0x4DBF) ||
+        (cp >= 0x4E00 && cp <= 0x9FFF) ||
+        (cp >= 0xF900 && cp <= 0xFAFF) ||
+        (cp >= 0x2600 && cp <= 0x27BF) ||
+        (cp >= 0x1F300 && cp <= 0x1FAFF)) {
+      w += 2;
+      continue;
+    }
+    w += 1;
+  }
+  return w;
+}
+
 function hr(char, color) {
   const { FG_DARK, RST } = require('./ansi');
   const c = char || '─';
@@ -14,6 +46,36 @@ function hr(char, color) {
   process.stdout.write(`${col}${c.repeat(getCols())}${RST}\n`);
 }
 
+// Repeat a single-column glyph so the visible row is exactly `width` columns.
+// Accepts an optional `used` arg (columns already occupied) to fill the
+// remainder — handy for header lines like " LABEL ══════…" that need to
+// reach the right edge regardless of terminal size.
+function repeatToWidth(char, width, used) {
+  const w = Math.max(0, (width || 0) - (used || 0));
+  return (char || '─').repeat(w);
+}
+
+// Number of *physical* terminal rows that `text` occupies at the given
+// width. Uses termWidth (display columns) so emoji / CJK / combining marks
+// are counted correctly, and ceils each logical line's wrap count. An
+// empty line still occupies 1 row. This is the number to use whenever the
+// redraw logic cursor-ups to erase or when the layout grows to hold new
+// content — counting `text.split('\n').length` undercounts wrapped lines
+// and lets the trailing physical row leak into scrollback on the next
+// redraw (TUI duplicate-frame bug).
+function displayRows(text, termCols) {
+  if (text === undefined || text === null) return 0;
+  const cols = Math.max(1, termCols | 0);
+  const raw = stripAnsi(String(text));
+  const lines = raw.split('\n');
+  let rows = 0;
+  for (const line of lines) {
+    const w = termWidth(line);
+    rows += w === 0 ? 1 : Math.ceil(w / cols);
+  }
+  return rows;
+}
+
 function boxLine(text, width) {
   const { FG_DARK, RST, BOX_V } = require('./ansi');
   const w = width || (getCols() - 4);
@@ -42,4 +104,4 @@ function isPrintableKey(str, key) {
   return !/[\x00-\x1f\x7f]/.test(str);
 }
 
-module.exports = { getCols, getRows, stripAnsi, hr, boxLine, insertCharAt, removeCharAt, isPrintableKey };
+module.exports = { getCols, getRows, stripAnsi, termWidth, displayRows, hr, repeatToWidth, boxLine, insertCharAt, removeCharAt, isPrintableKey };

package/lib/ui/writer.js

@@ -0,0 +1,255 @@
+'use strict';
+
+// Single owner of process.stdout for the TUI. All bubble rendering, status
+// bar ticks, and prompt redraws go through this module so their writes can
+// never interleave mid-frame.
+//
+// Layout (bottom-up):
+//   SCROLLBACK   — everything the writer emits via scrollback(). Immutable
+//                  after the call resolves. Flows into terminal scrollback
+//                  naturally as the cursor advances past the bottom.
+//   MODAL REGION — optional. 0–N lines pushed via setModal(); cleared via
+//                  clearModal(). Used for permission pickers, confirmation
+//                  dialogs, and other modal widgets that must redraw in
+//                  place on every keystroke without landing in scrollback.
+//   STATUS REGION— 1–N lines at the bottom of the viewport. Redrawn in
+//                  place whenever setLive() is called. Each live line is
+//                  truncated to (cols − 1) so it occupies exactly one
+//                  physical row; combined height is modalLines.length +
+//                  statusLines.length and precise.
+//
+// Invariant: after any operation resolves, the cursor is at column 0 of the
+// row immediately below the status region. Every operation erases the
+// combined modal+status region first (cursor-up + \x1b[J), writes any
+// scrollback content, then redraws modal then status, then leaves the
+// cursor below them.
+//
+// Serialization is a plain Promise chain. process.stdout.write on a TTY is
+// synchronous, so each task's compound write is emitted in one burst and
+// can't interleave with another task's writes.
+
+const { stripAnsi } = require('./utils');
+
+let _queue = Promise.resolve();
+let _liveLines = [];
+let _modalLines = [];
+let _liveHeight = 0;
+let _destroyed = false;
+
+function _cols() { return process.stdout.columns || 80; }
+
+// ANSI-aware truncate to (cols-1) visible columns so each rendered live
+// line occupies exactly one physical terminal row — no wrap, no height
+// mis-count. Visible width uses stripAnsi (ASCII/basic). Live-region chrome
+// is short and single-line; if it ever overflows we lose the tail, which
+// is fine for chrome.
+function _fitOneRow(line) {
+  const max = Math.max(0, _cols() - 1);
+  if (!line) return '';
+  if (stripAnsi(line).length <= max) return line;
+  let out = '';
+  let vis = 0;
+  let i = 0;
+  while (i < line.length && vis < max) {
+    if (line[i] === '\x1b' && line[i + 1] === '[') {
+      const m = line.slice(i).match(/^\x1b\[[0-9;?]*[a-zA-Z]/);
+      if (m) { out += m[0]; i += m[0].length; continue; }
+    }
+    out += line[i];
+    vis++;
+    i++;
+  }
+  return out + '\x1b[0m';
+}
+
+function _eraseLiveSeq() {
+  if (_liveHeight <= 0) return '';
+  return `\x1b[${_liveHeight}A\r\x1b[J`;
+}
+
+function _drawLiveSeq() {
+  const total = _modalLines.length + _liveLines.length;
+  if (total === 0) { _liveHeight = 0; return ''; }
+  let out = '';
+  for (let i = 0; i < _modalLines.length; i++) {
+    out += _fitOneRow(_modalLines[i]);
+    out += '\n';
+  }
+  for (let i = 0; i < _liveLines.length; i++) {
+    out += _fitOneRow(_liveLines[i]);
+    out += '\n';
+  }
+  _liveHeight = total;
+  return out;
+}
+
+function _writeSync(s) {
+  if (!s) return;
+  try { process.stdout.write(s); } catch {}
+}
+
+function _enqueue(task) {
+  _queue = _queue.then(() => {
+    if (_destroyed) return;
+    try { task(); } catch {}
+  });
+  return _queue;
+}
+
+// Append text to scrollback (above the live region). The compound write
+// erases the live region, emits text, redraws the live region — all in a
+// single process.stdout.write so nothing can interleave.
+function scrollback(text) {
+  if (text === undefined || text === null || text === '') return _queue;
+  return _enqueue(() => {
+    let out = String(text);
+    if (!out.endsWith('\n')) out += '\n';
+    _writeSync(_eraseLiveSeq() + out + _drawLiveSeq());
+  });
+}
+
+// Replace the live region with `lines` (array of strings, usually 1–10).
+// Each line is truncated to cols-1 and occupies exactly one physical row.
+function setLive(lines) {
+  return _enqueue(() => {
+    _liveLines = Array.isArray(lines) ? lines.map((l) => (l == null ? '' : String(l))) : [];
+    _writeSync(_eraseLiveSeq() + _drawLiveSeq());
+  });
+}
+
+// Erase the live region entirely — used on teardown and when handing the
+// terminal off to a sub-renderer (e.g. interactive menus). Drops the modal
+// too so the sub-renderer doesn't paint over a ghost modal.
+function clearLive() {
+  return _enqueue(() => {
+    _writeSync(_eraseLiveSeq());
+    _liveLines = [];
+    _modalLines = [];
+    _liveHeight = 0;
+  });
+}
+
+// Replace the modal region with `lines`. Modal sits above status and below
+// scrollback. Used for permission pickers, confirm dialogs, text input
+// prompts, etc. — any widget that must redraw on every keystroke without
+// filling scrollback. Status region is untouched; scrollback is untouched.
+function setModal(lines) {
+  return _enqueue(() => {
+    _modalLines = Array.isArray(lines) ? lines.map((l) => (l == null ? '' : String(l))) : [];
+    _writeSync(_eraseLiveSeq() + _drawLiveSeq());
+  });
+}
+
+// Remove the modal region. Status region stays where it was.
+function clearModal() {
+  return _enqueue(() => {
+    if (_modalLines.length === 0) return;
+    _modalLines = [];
+    _writeSync(_eraseLiveSeq() + _drawLiveSeq());
+  });
+}
+
+function hasModal() { return _modalLines.length > 0; }
+
+// Re-emit the current live region at the current terminal width. Called on
+// resize: the truncation window changes but the underlying line data is the
+// same.
+function redrawLive() {
+  return _enqueue(() => {
+    _writeSync(_eraseLiveSeq() + _drawLiveSeq());
+  });
+}
+
+// Resolve once every enqueued task has run. Used at exit / hand-off points.
+function flush() { return _queue; }
+
+// Enqueue an arbitrary synchronous side-effect so it runs in order with
+// writes. Handy for terminal mode toggles (cursor show/hide, bracketed
+// paste on/off) that must not land inside another task's compound write.
+// The callback can use process.stdout.write directly for raw escapes but
+// must not produce scrollback output — use scrollback() for that.
+function enqueue(fn) {
+  return _enqueue(() => { fn(); });
+}
+
+function getLiveHeight() { return _liveHeight; }
+function getLiveLines()  { return _liveLines.slice(); }
+
+function destroy() { _destroyed = true; }
+
+// Synchronous, single-write cleanup for every exit path. Erases the live
+// region (which is chrome, not content), resets the terminal modes the TUI
+// turned on at startup, and lands the cursor at column 0 of the row
+// immediately below the last scrollback line — so the shell prompt prints
+// cleanly under the session's last visible content.
+//
+// Must be idempotent: 'exit' fires after handlers that already called
+// teardown manually, and signal handlers may overlap during a fast Ctrl+C.
+//
+// Must be a single process.stdout.write of one pre-built string. Anything
+// else risks interleaving with a queued task that hadn't drained yet, or
+// with another writer-bypassing module emitting partial output. Setting
+// _destroyed before the write turns every queued task into a no-op so they
+// can't repaint over our cleanup.
+let _torn = false;
+function teardown() {
+  if (_torn) return;
+  _torn = true;
+  _destroyed = true;
+
+  // Non-TTY: no escape sequences were ever emitted, nothing to clean up.
+  if (!process.stdout.isTTY) return;
+
+  const parts = [];
+
+  // Erase the live region. Cursor invariant places it at the row immediately
+  // below the live region; cursor-up by N lands on the first live row, then
+  // \x1b[J wipes from there to end of screen. After this the cursor is at
+  // column 0 of the row immediately after the last scrollback line — exactly
+  // where the shell prompt should appear.
+  if (_liveHeight > 0) {
+    parts.push(`\x1b[${_liveHeight}A\r\x1b[J`);
+  } else {
+    // No live region active: ensure cursor is at column 0 so a shell prompt
+    // doesn't print mid-line if some upstream write left the cursor drifting.
+    parts.push('\r');
+  }
+
+  parts.push('\x1b[0m');     // reset all SGR attributes
+  parts.push('\x1b[?25h');   // show OS cursor
+  parts.push('\x1b[r');      // reset DECSTBM scroll region (no-op if unset)
+  parts.push('\x1b[<u');     // pop kitty keyboard protocol
+  parts.push('\x1b[>4;0m');  // reset xterm modifyOtherKeys
+  parts.push('\x1b[?2004l'); // disable bracketed paste
+
+  _liveLines = [];
+  _modalLines = [];
+  _liveHeight = 0;
+
+  try { process.stdout.write(parts.join('')); } catch {}
+
+  // Restore stdin to cooked mode so the shell receives keystrokes normally.
+  // Done after the stdout write so a slow/blocking setRawMode can't delay
+  // the visible cleanup.
+  try {
+    if (process.stdin.isTTY && typeof process.stdin.setRawMode === 'function') {
+      process.stdin.setRawMode(false);
+    }
+  } catch {}
+}
+
+module.exports = {
+  scrollback,
+  setLive,
+  clearLive,
+  setModal,
+  clearModal,
+  hasModal,
+  redrawLive,
+  flush,
+  enqueue,
+  getLiveHeight,
+  getLiveLines,
+  destroy,
+  teardown,
+};

package/lib/ui.js

@@ -10,6 +10,7 @@ const history  = require('./ui/chat-history');
 const statusB  = require('./ui/status-bar');
 const input    = require('./ui/input-field');
 const createUi = require('./ui/create-ui');
+const terminal = require('./ui/terminal');
 
 module.exports = {
   // ANSI constants
@@ -44,4 +45,8 @@ module.exports = {
 
   // Factory
   createUI: createUi.createUI,
+
+  // Terminal teardown
+  teardownTerminal: terminal.teardownTerminal,
+  registerTerminalCleanup: terminal.registerTerminalCleanup,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@semalt-ai/code",
-  "version": "1.8.0",
+  "version": "1.8.3",
   "description": "Self-hosted AI Coding Assistant CLI",
   "main": "index.js",
   "bin": {