@semalt-ai/code 1.19.0 → 1.20.1

package/lib/constants.js

@@ -14,7 +14,7 @@ const DEFAULT_API_TIMEOUT_MS = 15 * 60 * 1000;
 // even a caller that omits the value gets a real cap rather than an unbounded
 // loop. A config value of 0 (the "unlimited" sentinel) opts out — see
 // resolveMaxIterations in lib/config.js.
-const DEFAULT_MAX_ITERATIONS = 50;
+const DEFAULT_MAX_ITERATIONS = 125;
 
 // Self-verification (Task 4.2). When the agent declares a task done, an optional
 // configured shell command (e.g. `npm test`) is run and its result fed back.
@@ -110,6 +110,28 @@ const OUTPUT_HEAD_RATIO = 0.6;
 // line-bounded output — it only catches the pathological few-but-huge-lines case.
 const DEFAULT_OUTPUT_MAX_TOKENS = 10000;
 
+// File-edit diff display bound (execution-time diff rendering). Every mutating
+// file edit (write/append/edit_file/replace_in_file) renders its diff at the
+// moment it executes — decoupled from the permission modal, so an auto-approved
+// edit shows its changes just like a manually-approved one. `diff_max_lines`
+// caps the number of CHANGED (+/-) lines shown: a small edit (or a series of
+// small edits) renders in full; one large edit shows head+tail of the changed
+// lines with a `… K more changed lines (N total)` notice (mirrors the W.6
+// shell head+tail discipline). Operator-overridable via config.diff_max_lines.
+const DEFAULT_DIFF_MAX_LINES = 50;
+
+// Collapsed output-preview bound (Output Refactor — Phase 5). Shell / MCP /
+// subagent output is shown in MODERATION in the chrome: the first
+// `shell_preview_lines` lines render below the result line, then a static
+// `… N more lines` hint. There is no in-terminal way to expand — full viewing is
+// deferred to the planned transcript viewer. This is DISPLAY-ONLY — the model
+// still receives the full output via boundToolOutput; this cap never touches
+// context.
+// Diffs (file edits) are NOT subject to this — they render expanded to
+// `diff_max_lines` (the user explicitly wants to see diffs). Operator-overridable
+// via config.shell_preview_lines.
+const DEFAULT_SHELL_PREVIEW_LINES = 5;
+
 // MCP & subagent result context bounds (Task W.8). MCP tool results
 // (lib/mcp/client.js mcpResultToText) and subagent final text (lib/subagents.js)
 // were the last two UNBOUNDED paths into context — both are fenced as untrusted,
@@ -185,6 +207,11 @@ const DEFAULT_CONFIG = {
   // head+tail line cap (max_output_lines) bounds the common case; this bounds the
   // pathological few-but-huge-lines case (a single minified line, a binary cat).
   max_output_tokens: DEFAULT_OUTPUT_MAX_TOKENS,
+  // Changed-line cap for execution-time file-edit diffs (see DEFAULT_DIFF_MAX_LINES).
+  diff_max_lines: DEFAULT_DIFF_MAX_LINES,
+  // Preview-line count for shell/MCP/subagent output chrome (see
+  // DEFAULT_SHELL_PREVIEW_LINES). Display-only — never affects model context.
+  shell_preview_lines: DEFAULT_SHELL_PREVIEW_LINES,
   // Max agent-loop iterations per user turn. A positive integer caps the loop;
   // 0 means deliberately unbounded (power-user choice). Default 50.
   max_iterations: DEFAULT_MAX_ITERATIONS,
@@ -359,6 +386,7 @@ const TAG_REGISTRY = {
   exec:             { type: 'tool', streaming: false, label: 'Running command' },
   shell:            { type: 'tool', streaming: false, label: 'Running shell' },
   read_file:        { type: 'tool', streaming: false, label: 'Reading file' },
+  view_image:       { type: 'tool', streaming: false, label: 'Viewing image' },
   write_file:       { type: 'tool', streaming: false, label: 'Writing file' },
   create_file:      { type: 'tool', streaming: false, label: 'Creating file' },
   append_file:      { type: 'tool', streaming: false, label: 'Appending to file' },
@@ -510,6 +538,7 @@ module.exports = {
   DEFAULT_MAX_OUTPUT_LINES,
   OUTPUT_HEAD_RATIO,
   DEFAULT_OUTPUT_MAX_TOKENS,
+  DEFAULT_DIFF_MAX_LINES,
   DEFAULT_MCP_MAX_RESULT_TOKENS,
   DEFAULT_SUBAGENT_MAX_RESULT_TOKENS,
   DEFAULT_WEB_MAX_CONTENT_TOKENS,

package/lib/headless.js

@@ -26,6 +26,8 @@
 const { setUIActive, isUIActive } = require('./tools');
 const { priceForModel, computeCost } = require('./pricing');
 const { DEFAULT_MAX_ITERATIONS } = require('./constants');
+const { buildToolOperation } = require('./ui/tool-operation');
+const { renderOperation } = require('./ui/render-operation');
 
 const MACHINE_MODES = new Set(['json', 'stream-json']);
 
@@ -89,7 +91,40 @@ function createHeadlessSink(mode, emitLine, { model = null, priceOverrides = nul
       const call = meta && Array.isArray(meta.call) ? meta.call : null;
       const args = call ? call.slice(1) : [];
       const ok = !(meta && meta.error);
-      const rec = { tool: tag, args, ok, ms };
+      // Legacy per-tool fields — computed EXACTLY as before so their names,
+      // types, and values can never drift (the contract pin).
+      const legacy = { tool: tag, args, ok, ms };
+      // Phase 6d-ii — sink-local descriptor build (option A): build the same
+      // ToolOperation the interactive sink builds (chat-turn.js) from the `meta`
+      // already passed, then merge its json-mode core (descriptor-native plain
+      // data: status/category/durationMs/detail/meta/target/attrs/…) ADDITIVELY
+      // BENEATH the legacy fields. `legacy` spreads last so tool/args/ok/ms win
+      // on any name clash → byte-identical to pre-6d-ii. Web ops are ordinary
+      // tools here (NO web-activity collapse — N per-op events is the contract).
+      let core = null;
+      try {
+        const attrs = meta ? meta.attrs : null;
+        const operation = buildToolOperation({
+          id: meta ? meta.id : null,
+          tag,
+          arg: attrs ? (attrs.command || attrs.path || attrs.url || attrs.src || attrs.key || attrs.name || attrs.pattern) : '',
+          attrs,
+          status: ok ? 'ok' : 'error',
+          durationMs: ms,
+          meta: meta ? meta.meta : null,
+          error: meta ? meta.error : null,
+          diff: meta ? meta.diff : null,
+          // Model-facing result → lets the descriptor derive an output-preview
+          // detail (shell/MCP/subagent). Chrome-only; context is untouched.
+          output: typeof resultStr === 'string' ? resultStr : null,
+          noDuration: tag === 'ask_user',
+        });
+        core = renderOperation(operation, { mode: 'json' });
+      } catch (_e) {
+        // No-descriptor safety: fall back to the bare legacy-only rec, never crash.
+        core = null;
+      }
+      const rec = core ? { ...core, ...legacy } : { ...legacy };
       toolCalls.push(rec);
       if (mode === 'stream-json') emitLine({ type: 'tool', ...rec });
     };

package/lib/images.js

@@ -162,8 +162,14 @@ function selectImageFormat(config = {}, model = '') {
 // to these can never work, so we fail loud rather than send a doomed payload.
 const KNOWN_TEXT_ONLY = /(?:^|[-/_])(?:text-embedding|embedding|embed|whisper|tts|moderation|rerank|reranker)/i;
 // Well-known vision-capable families: a positive signal so an attach proceeds
-// without needing per-profile config.
-const KNOWN_VISION = /(gpt-4o|gpt-4\.1|gpt-4-vision|gpt-4-turbo|claude-3|claude-opus|claude-sonnet|claude-haiku|claude-fable|claude-4|gemini|llava|qwen[\d.]*-?vl|pixtral|llama[-\d.]*(?:-)?vision|internvl|minicpm-v|-vl\b|vision|multimodal)/i;
+// without needing per-profile config. `minimax` is here because a live probe
+// confirmed MiniMax-M3 accepts OpenAI image_url/data-URI vision input — so the
+// attach proceeds (true) rather than relying on a speculative endpoint round-trip
+// (null). This is the family-signal mechanism (like gpt-4o / claude-3 / gemini);
+// per-profile `vision:true` remains for private/local profiles. NOTE: the qwen
+// entry is deliberately narrow (`qwen…-vl` only) — plain Qwen coder models are
+// NOT confirmed vision-capable and must stay null.
+const KNOWN_VISION = /(gpt-4o|gpt-4\.1|gpt-4-vision|gpt-4-turbo|claude-3|claude-opus|claude-sonnet|claude-haiku|claude-fable|claude-4|gemini|llava|qwen[\d.]*-?vl|pixtral|llama[-\d.]*(?:-)?vision|internvl|minicpm-v|minimax|-vl\b|vision|multimodal)/i;
 
 // Determine vision capability from config/model metadata where available.
 //   true  — accept the image

package/lib/permissions.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const writer = require('./ui/writer');
-const messages = require('./ui/messages');
+const dbg = require('./debug');
 const { resolvePermission, normalizeCall } = require('./permission-rules');
 
 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'];
@@ -81,10 +81,10 @@ function createPermissionManager(ui, { allowedTiers = [], readonly = false, skip
   // The picker renders into the writer's modal region — a live band above
   // the status bar that redraws in place on every keystroke. Arrow-key
   // navigation rebuilds the lines array and calls onShowModal again; nothing
-  // lands in scrollback until the user confirms. On resolve/cancel the
-  // modal is cleared and a single summary line is emitted to scrollback
-  // (for multi-line descriptions — e.g. a file-write diff — the full body
-  // is retained so the user can still see what was approved).
+  // lands in scrollback until the user confirms. On resolve/cancel the modal
+  // is simply cleared — NO summary line is emitted (Output Refactor Phase 2,
+  // D1): the execution result line is the single post-approval confirmation,
+  // so an echo here would just duplicate it.
   function requestPermission(description, onShowModal, onCloseModal, onCaptureNavigation) {
     // Serialize dialogs: each permission waits for the previous one to be answered
     const myTurn = _permissionQueueTail;
@@ -124,12 +124,13 @@ function createPermissionManager(ui, { allowedTiers = [], readonly = false, skip
 
       function finish(result) {
         const chosen = result === 'cancel' ? 'no' : options[selectedIdx].toLowerCase();
-        const glyph = (chosen === 'no') ? '✗' : '✓';
-        // The full `description` is preserved in the summary so multi-line
-        // bodies (e.g. file-write diffs) remain visible in scrollback after
-        // the modal closes. chatHistory's system-message renderer styles the
-        // first line by the leading glyph and indents continuations.
-        onCloseModal(`${glyph} ${description}`);
+        // Output Refactor Phase 2 (D1): close the modal WITHOUT emitting a
+        // post-close summary line. The execution result line (the descriptor's
+        // `result` phase via renderOperation) is the single confirmation of the
+        // operation, so a `✓ shell: ls` / `✓ file: Edit line N` echo here just
+        // duplicated it. Manual-approve now produces the same post-execution
+        // output as auto-approve: only the result line.
+        onCloseModal();
         releaseQueue();
         resolve(chosen);
       }
@@ -152,12 +153,18 @@ function createPermissionManager(ui, { allowedTiers = [], readonly = false, skip
     }));
   }
 
+  // Per-auto-approved-command breadcrumb. By DEFAULT this writes nothing to
+  // scrollback/UI: the per-command result line (command + outcome + duration,
+  // emitted for every tool) and the one-time "Auto-approve enabled for `tag`"
+  // grant line already cover it — a per-command `✓ Auto-approved: <cmd>` line
+  // just duplicates the command and reads as auto-approve chatter on every call.
+  // The diagnostic detail (incl. the `[rule: …]` / `[--dangerously-skip-...]`
+  // context the call sites embed in `description`) is preserved under
+  // --debug, routed through dbg.log — which is silent in 'off' mode (the
+  // default), scrollback in --debug, and the file in --debug-file. The audit
+  // log records every tool call independently, so nothing is lost regardless.
   function _emitAutoApproved(description) {
-    if (uiCallbacks) {
-      uiCallbacks.onAddMessage({ role: 'system', content: `✓ Auto-approved: ${description}` });
-    } else {
-      messages.sysSuccess(`Auto-approved: ${description}`);
-    }
+    dbg.log(`[permission] auto-approved: ${description}`);
   }
 
   async function askPermission(actionType, description, tag, ruleVerdict = null) {

package/lib/prompts.js

@@ -20,6 +20,7 @@ const TOOL_TAG_SPECS = {
   exec:            { attrs: [],                     purpose: 'Run a shell command (inline content).' },
   shell:           { attrs: [],                     purpose: 'Run a shell command (inline content).' },
   read_file:       { attrs: ['path?', 'start_line?', 'end_line?', 'show_line_numbers?'], purpose: 'Read a file, paginated (~2000 lines); start_line/end_line for a slice, show_line_numbers for edit refs.' },
+  view_image:      { attrs: ['path?'],              purpose: 'Load a LOCAL image (PNG/JPEG/GIF/WebP) into YOUR OWN vision context to analyze it (inline content or path attr = image path). Makes it visible to you, the model — NOT to the user. For a URL image, download it first, then view_image the saved path.' },
   write_file:      { attrs: ['path'],               purpose: 'Write file with inline content (overwrites).' },
   create_file:     { attrs: ['path'],               purpose: 'Create file with inline content.' },
   append_file:     { attrs: ['path'],               purpose: 'Append inline content to file.' },
@@ -30,19 +31,19 @@ const TOOL_TAG_SPECS = {
   move_file:       { attrs: ['src', 'dst'],         purpose: 'Move or rename a file.' },
   copy_file:       { attrs: ['src', 'dst'],         purpose: 'Copy a file.' },
   file_stat:       { attrs: [],                     purpose: 'Stat a file (inline content = path).' },
-  edit_file:       { attrs: ['path', 'line'],       purpose: 'Replace a single line in a file (inline content = new line).' },
+  edit_file:       { attrs: ['path', 'line', 'end_line?'], purpose: 'Replace a single line in a file (inline content = new line). Add end_line to replace the whole line range line..end_line with the inline content (a regex-free block edit; pairs with a numbered read_file slice).' },
   search_files:    { attrs: ['pattern?', 'dir?'],   purpose: 'Find files by glob pattern.' },
   grep:            { attrs: ['pattern', 'path?', 'ignore_case?', 'output_mode?', 'head_limit?', 'offset?'], purpose: 'Regex search file contents; returns file:line:text so you can read just the matching slice. output_mode="content" (default file:line:text), "files_with_matches" (paths only), or "count" (how many). Bounded by head_limit (default 100) with a truncation notice. Honors .gitignore, skips binaries and node_modules.' },
   glob:            { attrs: ['pattern', 'path?', 'head_limit?', 'offset?'],    purpose: 'List files matching a glob (relative paths), bounded by head_limit (default 100) with a truncation notice.' },
   search_in_file:  { attrs: ['path'],               purpose: 'Regex search inside a file (inline content = pattern).' },
-  replace_in_file: { attrs: ['path', 'search', 'replace'], purpose: 'Regex replace inside a file; inline content is interpreted as regex flags (e.g. g, i, gi).' },
+  replace_in_file: { attrs: ['path', 'search', 'replace', 'regex?', 'replace_all?'], purpose: 'Exact string replace (Claude Code Edit model): search is matched LITERALLY by default — paste verbatim code incl. ( ) { } . [ ]. The match must be UNIQUE: not-found ERRORS (file unchanged); >1 match ERRORS unless replace_all="true". Set regex="true" for regex mode (inline content = flags). Returns the honest replaced count.' },
   get_env:         { attrs: [],                     purpose: 'Read an env var (inline content = name).' },
   set_env:         { attrs: ['name', 'value'],      purpose: 'Set an env var for this process.' },
   download:        { attrs: ['path'],               purpose: 'HTTP download (inline content = URL). Saves to the CWD by default; optional path attr sets the destination (confined to the CWD; size-capped).' },
   upload:          { attrs: ['path'],               purpose: 'Write base64-encoded content to file.' },
   http_get:        { attrs: ['url', 'mode?', 'intent?'], purpose: 'HTTP GET → web-fetch pipeline. mode="summarized" (default) extracts main content → Markdown → secondary-model summary; "extracted" = main-content Markdown, no summary; "raw" = original HTML/content (for analyzing markup/CSS/JS). Token-capped in every mode. To extract specific VALUES (colors, versions, IDs), prefer download+grep instead — see web-extraction guidance below.' },
   web_search:      { attrs: ['query'],              purpose: 'Search the web; returns a compact list of {title,url,snippet}. Pick the relevant result(s) and fetch them with http_get — do NOT fetch every result.' },
-  ask_user:        { attrs: ['question'],           purpose: 'Ask the user a question and receive an answer.' },
+  ask_user:        { attrs: ['question'],           purpose: 'Ask the user a question and receive their answer. To present a choice, include a numbered list in the question — two or more lines formatted "1. Option A" / "2. Option B" — and it renders as an arrow-key menu returning the chosen option; without a numbered list it takes a free-text reply.' },
   store_memory:    { attrs: ['key'],                purpose: 'Persist a key/value to local memory (inline content = value).' },
   recall_memory:   { attrs: ['key'],                purpose: 'Read a key from local memory.' },
   list_memories:   { attrs: [],                     purpose: 'List memory keys.' },
@@ -98,12 +99,21 @@ const LOCAL_NAVIGATION_NOTICE = `## Navigating a codebase efficiently:
 
 To explore code, LOCATE FIRST with \`grep\`/\`glob\` — don't read whole files hunting for something. Use \`grep\` output_mode="files_with_matches" to find WHICH files mention a symbol, output_mode="count" for HOW MANY, and the default content mode (file:line:text) to see the matching lines in place. Then \`read_file\` only the relevant slice with \`start_line\`/\`end_line\` (add \`show_line_numbers\` when you need line refs to drive \`edit_file\`) — reading an entire large file dumps it into context and is paginated anyway. For large command output, redirect it to a file and \`grep\` that file rather than letting the whole output enter context.`;
 
+// Guidance: view_image makes a LOCAL image visible to the MODEL (not the user),
+// and the URL→vision path is a deliberate two-step (download, then view_image) —
+// the same split Claude Code uses (fetch ≠ view). Kept brief on purpose.
+const IMAGE_VIEW_NOTICE = `## Viewing images:
+
+\`view_image <path>\` loads a LOCAL image file (PNG/JPEG/GIF/WebP) into YOUR OWN vision context so you can analyze it. It makes the image visible to YOU (the model), NOT to the user — never say "take a look" or describe it as something the user can see. To analyze an image from a URL, first \`download\` it to the working directory, then \`view_image\` the saved path.`;
+
 const SYSTEM_PROMPT_TEMPLATE = `You are Semalt.AI, an expert AI coding assistant running in the user's terminal. You have the ability to execute shell commands and file operations.
 
 ${UNTRUSTED_CONTENT_NOTICE}
 
 ${WEB_EXTRACTION_NOTICE}
 
+${IMAGE_VIEW_NOTICE}
+
 ${LOCAL_NAVIGATION_NOTICE}
 
 ## Available tool tags:
@@ -146,6 +156,8 @@ ${UNTRUSTED_CONTENT_NOTICE}
 
 ${WEB_EXTRACTION_NOTICE}
 
+${IMAGE_VIEW_NOTICE}
+
 ${LOCAL_NAVIGATION_NOTICE}
 
 Use \`<think>...</think>\` for internal reasoning (runtime-handled; never emit as an action). Use \`<plan>...</plan>\` to record a short plan for the agent framework.