@semalt-ai/code 1.19.0 → 1.20.0

package/lib/tool_specs.js

@@ -81,6 +81,25 @@ const TOOL_SPECS = {
     },
   },
 
+  view_image: {
+    description: 'Load a LOCAL image file (PNG, JPEG, GIF, or WebP) into YOUR OWN vision context so you can '
+      + 'analyze it — read text/diagrams in it, inspect a screenshot, compare a mockup, etc. The image is made '
+      + 'visible to YOU (the model) for the next turn; it is NOT displayed to the user, so never say "take a look" '
+      + 'or otherwise refer to the image as something the user can see. To analyze an image that lives at a URL, '
+      + 'first use `download <url>` to save it to the working directory, then call view_image on the saved path. '
+      + 'Unsupported formats, oversized files (image_max_bytes), or missing paths return a clear error, not a crash.',
+    parameters: {
+      type: 'object',
+      properties: {
+        path: {
+          type: 'string',
+          description: 'Absolute or relative path to a local image file (PNG/JPEG/GIF/WebP) to load into vision context',
+        },
+      },
+      required: ['path'],
+    },
+  },
+
   write_file: {
     description: 'Write a file, creating it and any missing parent directories; overwrites existing content.',
     parameters: {
@@ -246,7 +265,7 @@ const TOOL_SPECS = {
   },
 
   edit_file: {
-    description: 'Replace the contents of a single line in a file, identified by 1-based line number.',
+    description: 'Replace a single line, or a contiguous range of lines, in a file by 1-based line number. With end_line set, lines line..end_line are replaced wholesale by content (which may itself span multiple lines) — a regex-free way to swap a block: read the slice with read_file (start_line/end_line + show_line_numbers), then replace that exact range. For large block edits this and a literal replace_in_file are the two supported paths.',
     parameters: {
       type: 'object',
       properties: {
@@ -256,12 +275,17 @@ const TOOL_SPECS = {
         },
         line: {
           type: 'integer',
-          description: '1-based line number of the line to replace',
+          description: '1-based line number of the (first) line to replace',
+          minimum: 1,
+        },
+        end_line: {
+          type: 'integer',
+          description: 'Optional 1-based last line of the range to replace (inclusive). Omit for a single-line edit. Must be >= line and within the file.',
           minimum: 1,
         },
         content: {
           type: 'string',
-          description: 'New text for the target line; trailing newline is added automatically when the file is rejoined',
+          description: 'New text for the target line or range; may contain newlines to expand a range into several lines. Trailing newline is added automatically when the file is rejoined.',
           default: '',
         },
       },
@@ -318,7 +342,7 @@ const TOOL_SPECS = {
         },
         path: {
           type: 'string',
-          description: 'Optional glob limiting which files are searched, e.g. "*.js" or "src/**/*.ts"',
+          description: 'Optional search target: a FILE path (search just that file — absolute or relative, like search_in_file), a DIRECTORY path (search recursively under it), or a GLOB filter limiting which files in the working tree are searched, e.g. "*.js" or "src/**/*.ts". A path that is neither an existing file nor directory is treated as a glob. If a supplied path/glob matches nothing to search, grep returns a diagnostic error rather than a silent zero-match result.',
         },
         ignore_case: {
           type: 'boolean',
@@ -372,7 +396,7 @@ const TOOL_SPECS = {
   },
 
   replace_in_file: {
-    description: 'Regex-replace occurrences of a pattern in a file; returns the number of replacements made.',
+    description: 'Exact string replacement in a file (Claude Code Edit model). The search text is matched LITERALLY by default — byte-for-byte, NO regex — so paste the exact verbatim code, including all whitespace and indentation, even if it contains ( ) { } . [ ] $ etc. The match must be UNIQUE: if the search string is not found the call ERRORS and the file is unchanged; if it appears more than once the call ERRORS (asking you to add surrounding context) unless you set replace_all:true. Returns the honest number of replacements made. Set regex:true to interpret the search as a JavaScript regular expression instead (bounded: long or backtracking-prone regexes are rejected). For block edits by line number, see line-range edit_file.',
     parameters: {
       type: 'object',
       properties: {
@@ -382,16 +406,26 @@ const TOOL_SPECS = {
         },
         search: {
           type: 'string',
-          description: 'JavaScript regular-expression pattern to search for',
+          description: 'Exact text to find. Matched literally (verbatim, no regex) unless regex:true is set. Include enough surrounding context that it appears EXACTLY ONCE in the file, or set replace_all:true.',
         },
         replace: {
           type: 'string',
-          description: 'Replacement string; supports the standard $1, $2, $& back-references',
+          description: 'Replacement string. In literal mode (default) it is inserted as raw text. In regex mode it supports the standard $1, $2, $& back-references.',
           default: '',
         },
+        replace_all: {
+          type: 'boolean',
+          description: 'Replace ALL occurrences instead of requiring a unique match. Without this, matching more than one occurrence is an error. The result reports the actual number replaced.',
+          default: false,
+        },
+        regex: {
+          type: 'boolean',
+          description: 'Opt into regex mode: interpret search as a JavaScript regular expression (bounded by a length cap + nested-quantifier guard). Default false = literal exact match. The uniqueness guard still applies in regex mode (use the g flag or replace_all to replace multiple).',
+          default: false,
+        },
         flags: {
           type: 'string',
-          description: 'Regex flags, any combination of g/i/m/s/u/y; the "g" flag is added automatically if omitted',
+          description: 'Regex flags (only meaningful with regex:true), any combination of g/i/m/s/u/y. Without "g" (and without replace_all) the match must be unique.',
           default: '',
         },
       },

package/lib/tools.js

@@ -122,24 +122,78 @@ function _protectedConfigWriteError(filePath) {
   return { error: `Refused: ${filePath} is a protected config path (under ~/.semalt-ai or a project .semalt dir) that drives execution and cannot be written by the agent. (This guard is not overridable with --allow-anywhere.)` };
 }
 
-// Cheap ReDoS guard. Rejects pathologically long patterns, common
-// catastrophic-backtracking anti-patterns, and pattern×data sizes large
-// enough to hang the regex engine.
-function _checkRegexSafety(pattern, data) {
+// Active (unescaped) regex metacharacters. A search pattern that contains NONE
+// of these — or one the caller explicitly marks `literal` — is a plain literal:
+// matching it (via split/join or indexOf) is O(dataLen) and CANNOT backtrack, so
+// the regex-ReDoS bounds below DO NOT apply. This is what makes the intended
+// copy-a-block-then-replace workflow work at any length (read_file defaults line
+// numbers OFF specifically to keep snippets copyable, lib/agent.js): a long
+// literal block is never rejected for its length.
+const _REGEX_META = new Set(['.', '*', '+', '?', '^', '$', '{', '}', '(', ')', '|', '[', ']']);
+
+function _hasActiveRegexMeta(pattern) {
+  if (typeof pattern !== 'string') return false;
+  for (let i = 0; i < pattern.length; i++) {
+    const ch = pattern[i];
+    if (ch === '\\') { i++; continue; } // the escaped next char is inert, skip it
+    if (_REGEX_META.has(ch)) return true;
+  }
+  return false;
+}
+
+// Decide literal vs regex. A pattern is matched literally when the caller forces
+// it (`literal: true` — for copied code blocks that legitimately contain
+// regex-special chars like `(` or `[`), or when auto-detection finds no active
+// regex metacharacter at all (the pasted plain-text-block case).
+function _isLiteralPattern(pattern, literal) {
+  if (literal === true) return true;
+  return !_hasActiveRegexMeta(pattern);
+}
+
+// ReDoS guard for the REGEX path only. Literals bypass it entirely — they cannot
+// backtrack, so their length is irrelevant. Catastrophic backtracking comes from
+// nested quantifiers (Check B below), NOT from pattern length: the old
+// `dataLen * pattern.length` proxy (Check C) is gone because it penalized exactly
+// the safe dimension — it rejected long *literals* (e.g. any block over ~250
+// chars on a 40 KB file) while a short bomb like `(a+)+$` (length 6) sailed
+// straight past it. For a genuine regex we keep two real protections:
+//   • a sanity length cap — a multi-thousand-char metacharacter-heavy pattern is
+//     suspicious and serves no legitimate purpose (literals use `literal:true`);
+//   • the nested-quantifier detector, which is the actual backtracking guard.
+function _checkRegexSafety(pattern, data, literal) {
   if (typeof pattern !== 'string') return null;
+  if (_isLiteralPattern(pattern, literal)) return null; // literal: O(dataLen), unbounded by length
   if (pattern.length > 1000) {
-    return { error: 'Pattern rejected: length exceeds 1000 chars' };
+    return { error: 'Regex rejected: length exceeds 1000 chars (use literal:true to match a long block verbatim)' };
   }
   if (/(\(.*[+*].*\).*[+*])|(\[.*\].*[+*].*[+*])/.test(pattern)) {
     return { error: 'Pattern rejected: potentially catastrophic backtracking' };
   }
-  const dataLen = typeof data === 'string' ? data.length : 0;
-  if (dataLen * pattern.length > 10_000_000) {
-    return { error: 'Pattern too complex for input size' };
-  }
   return null;
 }
 
+// The single authority for splitting an ask_user question into its menu. A line
+// matching `^\s*\d+[.)]\s+(.+)$` is a numbered OPTION; every other line is
+// PROMPT prose. Returns { prompt, options } where `prompt` is the non-numbered
+// lines joined (trimmed) and `options` is the option labels — but ONLY when
+// there are ≥2 of them (a lone "1." is prose, not a menu), matching the prior
+// _parseNumberedOptions contract. Display-only: the caller still hands the FULL
+// original question to the model. Pure; safe on null/non-string (auto-answer
+// paths pass arbitrary text).
+function parseAskMenu(text) {
+  const options = [];
+  const promptLines = [];
+  for (const line of String(text == null ? '' : text).split('\n')) {
+    const m = line.match(/^\s*\d+[.)]\s+(.+)$/);
+    if (m) options.push(m[1].trim());
+    else promptLines.push(line);
+  }
+  return {
+    prompt: promptLines.join('\n').trim(),
+    options: options.length >= 2 ? options : [],
+  };
+}
+
 function createToolExecutor(permissionManager, ui, getConfig, options = {}) {
   const { BOLD, DIM, FG_DARK, FG_GRAY, FG_GREEN, FG_RED, FG_YELLOW, RST, renderDiff } = ui;
   // Checkpoints & rewind (Task 4.3). When a store is wired, the prior state of a
@@ -174,12 +228,7 @@ function createToolExecutor(permissionManager, ui, getConfig, options = {}) {
   const DIFF_BUBBLE_INSET = 5;
 
   function _parseNumberedOptions(text) {
-    const options = [];
-    for (const line of text.split('\n')) {
-      const m = line.match(/^\s*\d+[.)]\s+(.+)$/);
-      if (m) options.push(m[1].trim());
-    }
-    return options.length >= 2 ? options : [];
+    return parseAskMenu(text).options;
   }
 
   // Build the permission descriptor for a [action, ...args] call tuple.
@@ -446,7 +495,9 @@ function createToolExecutor(permissionManager, ui, getConfig, options = {}) {
     _secretReadError,
     _protectedConfigWriteError,
     _checkRegexSafety,
+    _isLiteralPattern,
     _parseNumberedOptions,
+    _parseAskMenu: parseAskMenu,
     _dryRun,
     _skippedOps,
     MEMORY_PATH,
@@ -678,10 +729,19 @@ function extractToolCalls(text, options = {}) {
     }
   }
 
-  for (const match of text.matchAll(/```(?:shell|bash|sh)\n([\s\S]*?)```/g)) {
-    for (const line of match[1].trim().split('\n')) {
-      const cmd = line.trim();
-      if (cmd && !cmd.startsWith('#')) calls.push(['shell', cmd]);
+  // Bare-code-fence TEXT HEURISTIC: a ```bash/```sh/```shell markdown block with
+  // NO tool tag, each non-comment line inferred as a shell command. This is the
+  // ONLY mechanism that fires on untagged prose, so it is the only one gated by
+  // `skipTextHeuristics` (set on the native rail — see lib/agent.js). Every other
+  // pass in this function requires an EXPLICIT tool tag (<minimax:tool_call>,
+  // <function=…>, <tool_call>, the registered <tool> tags, MCP tags) and stays
+  // active regardless. The heuristic itself is unchanged — it is only skipped.
+  if (!options.skipTextHeuristics) {
+    for (const match of text.matchAll(/```(?:shell|bash|sh)\n([\s\S]*?)```/g)) {
+      for (const line of match[1].trim().split('\n')) {
+        const cmd = line.trim();
+        if (cmd && !cmd.startsWith('#')) calls.push(['shell', cmd]);
+      }
     }
   }
 
@@ -735,6 +795,7 @@ module.exports = {
   isProtectedConfigPath,
   isUIActive,
   mapInvokeToCall,
+  parseAskMenu,
   repairMinimaxMalformedXml,
   setUIActive,
 };

package/lib/ui/anim.js

@@ -0,0 +1,86 @@
+'use strict';
+
+// Single animation driver (Output Refactor — Phase 3).
+//
+// Before Phase 3 the status bar owned TWO independent setIntervals: a 1 Hz
+// clock tick and a 100 ms spinner-glyph cycle. They never coordinated, each
+// repainted the whole live region on its own, and the per-tool running glyph
+// never animated (its elapsed meter only advanced as an accidental side-effect
+// of whichever of the two timers happened to be firing).
+//
+// This driver replaces both with ONE timer. Subscribers register a per-frame
+// callback; the driver advances a single monotonic frame counter at the base
+// interval and, after running every subscriber, performs AT MOST ONE
+// coordinated repaint — so a tick yields a single writer frame, never two
+// competing ones. A subscriber returns truthy to request the repaint this
+// frame; the driver coalesces those requests into one.
+//
+// The base interval is the finer (spinner) cadence — 100 ms. Coarser
+// consumers (the clock, which only needs ~1 s) gate on
+// `frame % TICKS_PER_SECOND === 0` inside their callback rather than owning a
+// second timer.
+//
+// start()/stop() are idempotent (the 5404bd0 lesson — never stack intervals
+// across pause/resume cycles). The owner decides WHEN to run: while there is
+// something to animate (a running tool / streaming / thinking) or while the
+// clock should tick (not idle-paused). When neither holds, the owner stops the
+// driver so idle = no periodic repaint = the viewport scrolls freely.
+
+const BASE_INTERVAL_MS = 100;
+const TICKS_PER_SECOND = Math.round(1000 / BASE_INTERVAL_MS); // 10
+
+class AnimDriver {
+  constructor(intervalMs) {
+    this._interval = Number.isFinite(intervalMs) && intervalMs > 0 ? intervalMs : BASE_INTERVAL_MS;
+    this._timer = null;
+    this._frame = 0;
+    // Subscribers: (frame:number) => boolean. A truthy return requests the
+    // single coordinated repaint for this frame.
+    this._subs = new Set();
+    // The one repaint sink. Set by the owner (the status bar wires it to its
+    // _notify → _updateLive → writer.setLive path, which also re-renders the
+    // activity rows, so a single repaint covers spinner + clock + running op).
+    this._repaint = () => {};
+  }
+
+  get frame() { return this._frame; }
+  get intervalMs() { return this._interval; }
+  isRunning() { return this._timer !== null; }
+
+  // Register the single coordinated-repaint sink. Last writer wins.
+  onRepaint(fn) { this._repaint = typeof fn === 'function' ? fn : () => {}; }
+
+  // Register a per-frame subscriber. Returns an unsubscribe thunk.
+  subscribe(fn) {
+    if (typeof fn !== 'function') return () => {};
+    this._subs.add(fn);
+    return () => this._subs.delete(fn);
+  }
+
+  // Idempotent: a second start() while running is a no-op (never stacks a
+  // timer — the regression 5404bd0 guards against).
+  start() {
+    if (this._timer) return;
+    this._timer = setInterval(() => this._tick(), this._interval);
+    // An animation timer must never hold the process open — the interactive
+    // chat is kept alive by the stdin listener, not by this. unref() so a bar
+    // that's constructed-but-not-destroyed (e.g. in a unit test) can't wedge
+    // event-loop drain at exit. Guarded: mock timers may not implement unref.
+    if (this._timer && typeof this._timer.unref === 'function') this._timer.unref();
+  }
+
+  stop() {
+    if (this._timer) { clearInterval(this._timer); this._timer = null; }
+  }
+
+  _tick() {
+    this._frame++;
+    let dirty = false;
+    for (const fn of this._subs) {
+      try { if (fn(this._frame)) dirty = true; } catch {}
+    }
+    if (dirty) { try { this._repaint(); } catch {} }
+  }
+}
+
+module.exports = { AnimDriver, BASE_INTERVAL_MS, TICKS_PER_SECOND };

package/lib/ui/ansi.js

@@ -1,5 +1,14 @@
 'use strict';
 
+// ANSI primitives ONLY. Colour lives in `theme.js` (the single palette table);
+// this file holds the SGR builders, structural box-drawing characters, the
+// syntax-keyword set and the spinner definitions. The legacy colour palette
+// (`THEME` / `FG_*` / code-block colours) is DEFINED in theme.js and re-exported
+// here for back-compat — this file no longer defines any colour of its own.
+//
+// Dependency is one-directional: ansi.js → theme.js. theme.js does not require
+// ansi.js (it has its own private SGR builders), so the two never form a cycle.
+
 const RST  = '\x1b[0m';
 const BOLD = '\x1b[1m';
 const DIM  = '\x1b[2m';
@@ -15,26 +24,6 @@ function hasTruecolor() {
   return v === 'truecolor' || v === '24bit';
 }
 
-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   = '\x1b[38;5;245m';
-const FG_DARK   = '\x1b[38;5;240m';
-const FG_BLUE   = '\x1b[38;5;75m';
-const FG_CYAN   = '\x1b[38;5;116m';
-const FG_GREEN  = '\x1b[38;5;114m';
-const FG_YELLOW = '\x1b[38;5;222m';
-const FG_RED    = '\x1b[38;5;203m';
-const FG_TEAL   = '\x1b[38;5;73m';
-
 const BOX_H  = '─';
 const BOX_V  = '│';
 const BOX_TL = '╭';
@@ -42,13 +31,6 @@ const BOX_TR = '╮';
 const BOX_BL = '╰';
 const BOX_BR = '╯';
 
-const FG_CODE_BG     = '\x1b[48;5;236m';
-const BG_SELECTED    = '\x1b[48;5;237m';
-const FG_CODE_BORDER = '\x1b[38;5;240m';
-const FG_CODE_LANG   = '\x1b[38;5;75m';
-const FG_TAG         = '\x1b[38;5;176m';
-const FG_FILEPATH    = '\x1b[38;5;222m';
-
 const KEYWORDS = new Set([
   'def', 'class', 'import', 'from', 'return', 'if', 'else', 'elif',
   'for', 'while', 'try', 'except', 'finally', 'with', 'as', 'in',
@@ -67,6 +49,14 @@ const SPINNER_DEFS = {
   waiting_download:  { frames: ['⬇ ','⬇⠂','⬇⠆','⬇⠇','⬇⠧','⬇⠷','⬇⠿','⬇⠾','⬇⠼','⬇⠸','⬇⠰','⬇⠠'], color: '\x1b[38;5;75m' },
 };
 
+// Re-export the colour palette from its single home (theme.js). One-directional
+// require — theme.js never requires this file — so there is no cycle.
+const {
+  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,
+} = require('./theme');
+
 module.exports = {
   RST, BOLD, DIM, EL, THEME,
   bg256, fg256, bgRGB, fgRGB, hasTruecolor,