@semalt-ai/code 1.8.3 → 1.8.4

package/lib/permissions.js

@@ -1,5 +1,8 @@
 'use strict';
 
+const writer = require('./ui/writer');
+const messages = require('./ui/messages');
+
 const TIER_FS = ['read_file', 'write_file', 'append_file', 'delete_file', 'list_dir', 'make_dir', 'move_file', 'copy_file', 'file_stat', 'search_files', 'store_memory', 'recall_memory'];
 const TIER_EXEC = ['exec'];
 const TIER_NET = ['http_get', 'download'];
@@ -117,7 +120,7 @@ function createPermissionManager(ui, { allowedTiers = [], readonly = false } = {
     if (uiCallbacks) {
       uiCallbacks.onAddMessage({ role: 'system', content: `✓ Auto-approved: ${description}` });
     } else {
-      console.log(`  ${FG_GREEN}✓${RST} ${FG_DARK}Auto-approved: ${description}${RST}`);
+      messages.sysSuccess(`Auto-approved: ${description}`);
     }
   }
 
@@ -133,7 +136,7 @@ function createPermissionManager(ui, { allowedTiers = [], readonly = false } = {
     }
 
     if (!process.stdout.isTTY || !process.stdin.isTTY) {
-      process.stdout.write(`  [non-TTY] Auto-approving: ${description}\n`);
+      writer.scrollback(`  [non-TTY] Auto-approving: ${description}`);
       return true;
     }
 
@@ -155,13 +158,11 @@ function createPermissionManager(ui, { allowedTiers = [], readonly = false } = {
       return true;
     }
 
-    // Fallback: legacy TTY interactive select (used outside of chat UI)
+    // Fallback: TTY interactive select (used outside of chat UI)
     const alwaysLabel = tag ? `Yes, always for <${tag}>` : 'Yes, always';
     const choices = ['Yes', alwaysLabel, 'No'];
 
-    console.log();
-    console.log(`  ${FG_YELLOW}${BOLD}⚠ Permission required${RST}`);
-    console.log(`  ${FG_GRAY}${actionType}: ${description}${RST}`);
+    writer.scrollback(`\n  ${FG_YELLOW}${BOLD}⚠ Permission required${RST}\n  ${FG_GRAY}${actionType}: ${description}${RST}`);
 
     const selectedIndex = await interactiveSelect(
       choices,
@@ -174,13 +175,13 @@ function createPermissionManager(ui, { allowedTiers = [], readonly = false } = {
     );
 
     if (selectedIndex === null || selectedIndex === 2) {
-      console.log(`  ${FG_RED}✗${RST} ${FG_DARK}Denied${RST}`);
+      writer.scrollback(`  ${FG_RED}✗${RST} ${FG_DARK}Denied${RST}`);
       return false;
     }
 
     if (selectedIndex === 1 && tag) {
       state.sessionApprovedTags.add(tag);
-      console.log(`  ${FG_GREEN}✓${RST} ${FG_DARK}Auto-approve enabled for <${tag}> this session${RST}`);
+      writer.scrollback(`  ${FG_GREEN}✓${RST} ${FG_DARK}Auto-approve enabled for <${tag}> this session${RST}`);
     }
 
     return true;

package/lib/prompts.js

@@ -94,12 +94,9 @@ ${TAG_INVENTORY}
 7. Be concise. Provide working solutions. Use markdown for code blocks in explanations.
 8. Current working directory: __CWD__
 
-Response contract (strict):
-Every response must end with exactly one of:
-  (a) a tool call, using one of the XML tags listed above; OR
-  (b) <final_answer>...</final_answer> containing your answer to the user.
-A response containing neither is invalid and will be rejected.
-Do not describe actions in prose outside these two forms. Either call the tool, or wrap your final reply in <final_answer>.`;
+Response contract:
+- If the task requires an action, emit the appropriate tool tag(s) — do not narrate intended actions in prose without the tag.
+- If the task is complete or the user's question can be answered directly without running a tool, reply in plain prose. No special wrapper is needed.`;
 
 const NATIVE_SYSTEM_PROMPT_TEMPLATE = `You are Semalt.AI, an expert AI coding assistant running in the user's terminal. Use the provided tools to execute shell commands and file operations; do not just print instructions. Each call is approved by the user before execution, and the result is returned to you for the next step.
 
@@ -107,7 +104,7 @@ Use \`<think>...</think>\` for internal reasoning (runtime-handled; never emit a
 
 Be concise. Use markdown for code blocks in explanations. Current working directory: __CWD__
 
-Response contract: every response must end with either (a) one or more tool calls, or (b) <final_answer>...</final_answer> containing your answer to the user. Prose outside those two forms is invalid.`;
+Response contract: if the task requires an action, emit one or more tool calls — do not narrate intended actions in prose without the tool call. Otherwise, answer in plain prose; no special wrapper is needed.`;
 
 function getSystemPrompt(nativeTools = false) {
   const template = nativeTools ? NATIVE_SYSTEM_PROMPT_TEMPLATE : SYSTEM_PROMPT_TEMPLATE;

package/lib/tools.js

@@ -9,6 +9,7 @@ const path = require('path');
 const { spawn } = require('child_process');
 
 const { logToolCall } = require('./audit');
+const writer = require('./ui/writer');
 
 const MEMORY_PATH = path.join(os.homedir(), '.semalt-ai', 'memory.json');
 
@@ -22,6 +23,7 @@ function getSkippedOps() { return _skippedOps.slice(); }
 let _uiActive = false;
 function setUIActive(v) { _uiActive = v; }
 function isUIActive() { return _uiActive; }
+// audit: allowed — fires only when TUI is inactive (one-shot non-TUI commands), no live region to protect.
 function _log(...args) { if (!_uiActive) console.log(...args); }
 
 // Reject writes outside the project CWD and in sensitive system/home dirs
@@ -164,7 +166,7 @@ function createToolExecutor(permissionManager, ui, getConfig) {
           _log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}Read ${filePath}${RST}`);
         }
         logToolCall('read_file', { path: filePath }, true, 'ok');
-        return { content: data, path: filePath };
+        return { content: data, path: filePath, bytes: Buffer.byteLength(data, 'utf8') };
       } catch (error) {
         _log(`  ${FG_RED}✗ ${error.message}${RST}`);
         logToolCall('read_file', { path: filePath }, true, 'error');
@@ -202,7 +204,7 @@ function createToolExecutor(permissionManager, ui, getConfig) {
       const diffOutput = _uiActive
         ? renderDiff(existing, finalContent, filePath, { inset: DIFF_BUBBLE_INSET })
         : renderDiff(existing, finalContent, filePath);
-      if (!_uiActive) process.stdout.write(diffOutput + '\n');
+      if (!_uiActive) writer.scrollback(diffOutput);
 
       // Dry-run: record the skipped op and return without writing
       if (_dryRun) {
@@ -212,7 +214,7 @@ function createToolExecutor(permissionManager, ui, getConfig) {
         return { status: 'dry-run', message: 'dry-run: write skipped', path: filePath };
       }
 
-      // Permission check — routes through TUI dialog in chat mode, interactiveSelect in legacy CLI mode
+      // Permission check — routes through TUI dialog in chat mode, interactiveSelect in non-TUI flows
       let desc = `${action === 'write' ? 'Write' : 'Append to'} ${filePath}`;
       if (content) desc += ` (${content.length} chars)`;
       if (_uiActive) desc = `${desc}\n${diffOutput}`;
@@ -715,18 +717,21 @@ function createToolExecutor(permissionManager, ui, getConfig) {
               }
               _log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}HTTP GET ${target} (${res.statusCode}, ${totalBytes} bytes${capped ? `, truncated to ${keptBytes}` : ''})${RST}`);
               logToolCall('http_get', { url: target }, true, res.statusCode < 400 ? 'ok' : 'error');
-              resolve({ status_code: res.statusCode, body });
+              // `bytes` is the total transferred payload length (pre-cap);
+              // consumers that want to know the wire size without parsing
+              // the appended truncation note rely on this.
+              resolve({ status_code: res.statusCode, body, bytes: totalBytes });
             });
           });
           req.on('error', (err) => {
             _log(`  ${FG_RED}✗ ${err.message}${RST}`);
             logToolCall('http_get', { url: target }, true, 'error');
-            resolve({ error: err.message });
+            resolve({ error: err.message, error_code: err.code });
           });
           req.setTimeout(reqTimeoutMs, () => {
             req.destroy();
             logToolCall('http_get', { url: target }, true, 'error');
-            resolve({ error: 'Request timeout' });
+            resolve({ error: 'Request timeout', error_code: 'ETIMEDOUT' });
           });
         }
         doGet(url, 5);
@@ -747,10 +752,12 @@ function createToolExecutor(permissionManager, ui, getConfig) {
         return { question, answer: selected || options[0] };
       }
       if (!process.stdout.isTTY || process.stdin.isRaw) {
-        process.stdout.write(`\n  ${FG_YELLOW}?${RST} ${question}\n  ${DIM}[auto-answering 'y']${RST}\n`);
+        writer.scrollback(`\n  ${FG_YELLOW}?${RST} ${question}\n  ${DIM}[auto-answering 'y']${RST}`);
         logToolCall('ask_user', { question }, true, 'ok');
         return { question, answer: 'y' };
       }
+      // audit: allowed — inline prompt without trailing newline; unreachable when TUI writer is active
+      // (process.stdin.isRaw is true while the TUI input field holds raw mode).
       process.stdout.write(`\n  ${FG_YELLOW}?${RST} ${question}\n  ${FG_GRAY}>${RST} `);
       const buf = Buffer.alloc(4096);
       let input = '';

package/lib/ui/chat-history.js

@@ -142,14 +142,24 @@ class ChatHistory {
       }
       out += '\n';
     } else if (msg.role === 'tool') {
-      const indicator = msg.isError
-        ? `${UI_THEME.error}${UI_ICONS.error}${RST}`
-        : `${UI_THEME.success}${UI_ICONS.success}${RST}`;
-      const category = TOOL_CATEGORIES[msg.tag] || msg.tag || 'tool';
-      const head = `${UI_THEME.accent}${category}${UI_THEME.muted}:${RST}`;
-      const desc = _dimPaths(content);
-      out = `  ${indicator} ${head} ${desc}\n`;
-      lineCount = 1;
+      // Tool summary header. The writer's activity region now commits the
+      // primary "glyph · category · op · duration · meta" line directly to
+      // 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) {
+        const indicator = msg.isError
+          ? `${UI_THEME.error}${UI_ICONS.error}${RST}`
+          : `${UI_THEME.success}${UI_ICONS.success}${RST}`;
+        const category = TOOL_CATEGORIES[msg.tag] || msg.tag || 'tool';
+        const head = `${UI_THEME.accent}${category}${UI_THEME.muted}:${RST}`;
+        const desc = _dimPaths(content);
+        out = `  ${indicator} ${head} ${desc}\n`;
+        lineCount = 1;
+      } else {
+        out = '';
+        lineCount = 0;
+      }
       if (msg.output) {
         const wrapAt = Math.max(60, getCols() - 8);
         const outLines = [];
@@ -309,6 +319,7 @@ class ChatHistory {
     // the clear can't land inside a pending scrollback burst, then redraw
     // the live region under the new cursor.
     writer.enqueue(() => {
+      // audit: allowed — viewport clear inside writer.enqueue (sanctioned escape hatch).
       try { process.stdout.write('\x1b[3J\x1b[2J\x1b[H'); } catch {}
     });
     writer.redrawLive();

package/lib/ui/create-ui.js

@@ -2,7 +2,7 @@
 
 const readline = require('readline');
 
-const { RST, DIM, FG_YELLOW, FG_CYAN, FG_GRAY, BG_SELECTED } = require('./ansi');
+const { RST, FG_YELLOW, FG_CYAN, FG_GRAY } = require('./ansi');
 const { ChatHistory } = require('./chat-history');
 const writer = require('./writer');
 const { registerTerminalCleanup } = require('./terminal');
@@ -10,9 +10,11 @@ const { registerTerminalCleanup } = require('./terminal');
 function _createNoOpUI() {
   const chatHistory = {
     addMessage: (msg) => {
+      // audit: allowed — non-TUI no-op UI fallback, no live region to protect.
       if (msg.role === 'assistant' || msg.role === 'user')
         process.stdout.write(`[${msg.role}] ${msg.content || ''}\n`);
     },
+    // audit: allowed — non-TUI no-op UI fallback, no live region to protect.
     streamToken: (token) => process.stdout.write(token),
     clearStreamingContent: () => {},
     finalizeLastMessage: () => {},
@@ -25,8 +27,9 @@ function _createNoOpUI() {
   };
   const statusBar = {
     update: () => {}, updateMetrics: () => {}, onToken: () => {},
-    drawSeparator: () => {}, liveUpdate: () => {}, _renderBar: () => {},
-    setModel: () => {}, destroy: () => {},
+    drawSeparator: () => {}, _renderBar: () => {},
+    setModel: () => {}, setContextLimit: () => {}, setReportedContext: () => {},
+    addPendingTokens: () => {}, destroy: () => {},
   };
   let _submitCb = null;
   const inputField = {
@@ -59,7 +62,7 @@ function createUI(opts) {
   const { LayoutManager } = require('./layout');
   const { FullStatusBar } = require('./status-bar');
   const { InputField } = require('./input-field');
-  const { interactiveSelect } = require('./legacy');
+  const { interactiveSelect } = require('./select');
 
   const layout = new LayoutManager();
   const chatHistory = new ChatHistory();
@@ -93,24 +96,38 @@ function createUI(opts) {
     // chrome has a visible top edge.
     if (_sb) lines.push(_sb.renderSeparator());
 
-    // Status bar.
-    if (_sb) {
-      const statusLine = _sb.renderLine();
-      if (statusLine !== null && statusLine !== undefined) {
-        lines.push(statusLine);
-      }
-    }
+    // Status bar. ALWAYS pushed — the row is a permanent fixture of the
+    // live region so the input and hint rows below it keep a stable
+    // vertical position. `renderLine()` is contractually non-null; missing
+    // data (model, tokens) renders as a short placeholder inside the row.
+    if (_sb) lines.push(_sb.renderLine());
 
     // Input row(s).
+    let caret = null;
     if (_inputField) {
-      for (const row of _inputField.renderInputLines()) {
+      const inputLines = _inputField.renderInputLines();
+      for (const row of inputLines) {
         lines.push(row);
       }
       // Hints row.
       lines.push(_inputField.renderHintsLine());
+
+      // Caret: translate the input-local { line, col } into the live
+      // region's "rows up from the cursor's post-draw position". The
+      // post-draw cursor lands one row below the final hints row, so:
+      //   rowsFromBottom = 1 (for hints) + (inputLines.length - caret.line)
+      // Leaving caret null keeps the OS cursor hidden — used while input
+      // is disabled or a navigation capture is active.
+      const inCaret = _inputField.getCaretPosition && _inputField.getCaretPosition();
+      if (inCaret && inputLines.length > 0) {
+        caret = {
+          rowsFromBottom: 1 + (inputLines.length - inCaret.line),
+          col: inCaret.col,
+        };
+      }
     }
 
-    writer.setLive(lines);
+    writer.setLive(lines, caret);
   }
 
   _sb = new FullStatusBar(layout, _updateLive);
@@ -136,31 +153,34 @@ function createUI(opts) {
 
   // ── captureSelect (modal menu) ───────────────────────────────────────────────
   //
-  // Interactive menus need to take over the bottom of the screen. Clear
-  // the live region, let interactiveSelect draw into scrollback-like space,
-  // then rebuild live on resume.
+  // Numbered-options picker for tools like ask_user. interactiveSelect
+  // renders each frame into the writer's modal region (above status,
+  // below scrollback) and routes keys through the input field's
+  // captureNavigation API — so the menu cohabits with the live region
+  // instead of taking over the screen, and Enter/Esc resolve in place.
   inputField.captureSelect = (menu) => new Promise((resolve) => {
     if (!process.stdin.isTTY) {
       resolve(menu.options[0]);
       return;
     }
-    inputField.suspend();
-    writer.clearLive().then(() => {
-      interactiveSelect(
-        menu.options,
-        (opt, isSelected, isFinal) => {
-          if (isSelected && !isFinal)
-            return `  ${FG_YELLOW}❯${RST} ${BG_SELECTED}${FG_CYAN}${opt}${RST}`;
-          if (isSelected)
-            return `  ${FG_YELLOW}❯${RST} ${FG_CYAN}${opt}${RST}`;
-          return `   ${FG_GRAY}${opt}${RST}`;
+    interactiveSelect(
+      menu.options,
+      (opt, isSelected) => isSelected
+        ? `  ${FG_YELLOW}❯${RST} ${FG_CYAN}${opt}${RST}`
+        : `   ${FG_GRAY}${opt}${RST}`,
+      {
+        initialIndex: 0,
+        onExpand: () => chatHistory.toggleLastExpand(),
+        captureNavigation: (handler) => {
+          inputField.captureNavigation(handler);
+          return () => inputField.releaseNavigation();
         },
-        { initialIndex: 0, onExpand: () => chatHistory.toggleLastExpand() }
-      ).then((idx) => {
-        inputField.resume();
-        _updateLive();
-        resolve(idx === null ? menu.options[menu.options.length - 1] : menu.options[idx]);
-      });
+      }
+    ).then((idx) => {
+      // Cancel returns null. Match the prior contract: pick the last
+      // option (typically "No"/decline) so callers don't need to
+      // special-case cancellation.
+      resolve(idx === null ? menu.options[menu.options.length - 1] : menu.options[idx]);
     });
   });
 
@@ -181,6 +201,7 @@ function createUI(opts) {
   // starts in a known state, then paint the first live frame below a fresh
   // cursor position.
   writer.enqueue(() => {
+    // audit: allowed — terminal-mode raw escape inside writer.enqueue (sanctioned escape hatch).
     try { process.stdout.write('\x1b[2J\x1b[3J\x1b[H\x1b[?25l'); } catch {}
   });
   // Pre-render both input and hints so the first _updateLive has valid
@@ -198,17 +219,21 @@ function createUI(opts) {
   // ── Destroy ──────────────────────────────────────────────────────────────────
   // Stop timers + stdin listeners FIRST so no further writes can be queued,
   // then run writer.teardown(). teardown is a single synchronous stdout
-  // write that erases the live region and resets terminal state. After it
-  // returns, the cursor sits at column 0 of the row immediately below the
-  // last scrollback line — so any subsequent console.log (goodbye banner,
-  // metrics summary, resume hint) lands cleanly under the session content.
-  function destroy() {
+  // write that erases the live region, emits any end-of-session artifacts
+  // passed in (session summary, resume hint, goodbye) as regular scrollback
+  // content, and resets terminal state. After it returns, the cursor sits
+  // at column 0 of the row immediately below those artifacts — ready for
+  // the shell prompt. Callers that want artifacts emitted at exit must
+  // pass them here rather than console.log-ing after destroy(); doing it
+  // after destroy races with terminal-mode restoration and can leave
+  // artifacts overlaid on scrollback with the cursor drifting mid-viewport.
+  function destroy(teardownOpts) {
     if (_destroyCalled) return;
     _destroyCalled = true;
     try { inputField.destroy(); } catch {}
     try { sb.destroy(); } catch {}
     try { layout.destroy(); } catch {}
-    writer.teardown();
+    writer.teardown(teardownOpts);
   }
 
   return { chatHistory, statusBar: sb, inputField, layout, destroy, redrawFixed: _updateLive };

package/lib/ui/diff.js

@@ -3,6 +3,7 @@
 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;
@@ -206,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();
@@ -248,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 };