@semalt-ai/code 1.7.0 → 1.8.1

package/lib/config.js

@@ -7,6 +7,12 @@ const { CONFIG_PATH, DEFAULT_CONFIG } = require('./constants');
 
 function normalizeConfig(cfg = {}) {
   const merged = { ...DEFAULT_CONFIG, ...cfg };
+  // Ensure every DEFAULT_CONFIG key is present without overwriting existing values
+  for (const key of Object.keys(DEFAULT_CONFIG)) {
+    if (!(key in merged) || merged[key] === undefined) {
+      merged[key] = DEFAULT_CONFIG[key];
+    }
+  }
   const legacyDashboardUrl = typeof cfg.semalt_base_url === 'string' && cfg.semalt_base_url.trim()
     ? cfg.semalt_base_url.trim()
     : '';
@@ -24,6 +30,9 @@ function normalizeConfig(cfg = {}) {
   merged.default_model = typeof merged.default_model === 'string' && merged.default_model.trim()
     ? merged.default_model.trim()
     : DEFAULT_CONFIG.default_model;
+  merged.dashboard_model_id = Number.isInteger(cfg.dashboard_model_id) && cfg.dashboard_model_id > 0
+    ? cfg.dashboard_model_id
+    : null;
   merged.models = Array.isArray(cfg.models)
     ? cfg.models
         .filter((entry) => entry &&
@@ -32,16 +41,26 @@ function normalizeConfig(cfg = {}) {
           typeof entry.model === 'string' &&
           entry.api_base.trim() &&
           entry.model.trim())
-        .map((entry) => ({
-          api_base: entry.api_base.trim(),
-          api_key: entry.api_key,
-          model: entry.model.trim(),
-        }))
+        .map((entry) => {
+          const normalized = {
+            api_base: entry.api_base.trim(),
+            api_key: entry.api_key,
+            model: entry.model.trim(),
+          };
+          if (typeof entry.name === 'string' && entry.name.trim()) {
+            normalized.name = entry.name.trim();
+          }
+          if (Number.isInteger(entry.context_length) && entry.context_length > 0) {
+            normalized.context_length = entry.context_length;
+          }
+          return normalized;
+        })
     : [];
   return merged;
 }
 
 function loadConfig() {
+  fs.mkdirSync(path.dirname(CONFIG_PATH), { recursive: true });
   if (fs.existsSync(CONFIG_PATH)) {
     try {
       const data = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8'));
@@ -56,7 +75,34 @@ function saveConfig(cfg) {
   fs.writeFileSync(CONFIG_PATH, JSON.stringify(normalizeConfig(cfg), null, 2));
 }
 
+function configSet(key, value) {
+  const cfg = loadConfig();
+  cfg[key] = value;
+  saveConfig(cfg);
+  return cfg;
+}
+
+const REDACTED_KEYS = new Set(['api_key', 'auth_token']);
+
+function configShow(systemPromptOverride = null) {
+  const cfg = loadConfig();
+  const lines = ['Config:'];
+  for (const [key, val] of Object.entries(cfg)) {
+    const display = REDACTED_KEYS.has(key) && val ? '****' : JSON.stringify(val);
+    lines.push(`  ${key}: ${display}`);
+  }
+  if (systemPromptOverride) {
+    lines.push(`  system_prompt: [override from ${systemPromptOverride}]`);
+  } else {
+    const { SYSTEM_PROMPT } = require('./prompts');
+    lines.push(`  system_prompt: ${SYSTEM_PROMPT.slice(0, 80)}...`);
+  }
+  return lines.join('\n');
+}
+
 module.exports = {
+  configSet,
+  configShow,
   loadConfig,
   normalizeConfig,
   saveConfig,

package/lib/constants.js

@@ -13,17 +13,89 @@ const DEFAULT_CONFIG = {
   dashboard_url: 'https://cli.semalt.ai',
   auth_token: '',
   default_model: 'default',
+  dashboard_model_id: null,
   temperature: 0.7,
   request_timeout_ms: DEFAULT_API_TIMEOUT_MS,
   stream: true,
   models: [],
+  theme: 'dark',
+  max_file_size_kb: 512,
+  command_timeout_ms: 30000,
+  max_output_lines: 50,
+  show_token_count: true,
+  show_cost: false,
+  system_prompt_mode: 'system_role',
 };
 
 const CONFIG_PATH = path.join(os.homedir(), '.semalt-ai', 'config.json');
 
+const TAG_REGISTRY = {
+  // Rendered visually in chat, never shown as raw text
+  think:      { type: 'visual', streaming: true,  display: 'think_bubble' },
+  reasoning:  { type: 'visual', streaming: true,  display: 'think_bubble' },
+  reflection: { type: 'visual', streaming: true,  display: 'think_bubble' },
+  plan:       { type: 'visual', streaming: true,  display: 'think_bubble' },
+
+  // Executed as tool calls
+  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' },
+  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' },
+  delete_file:      { type: 'tool', streaming: false, label: 'Deleting file' },
+  list_dir:         { type: 'tool', streaming: false, label: 'Listing directory' },
+  make_dir:         { type: 'tool', streaming: false, label: 'Creating directory' },
+  remove_dir:       { type: 'tool', streaming: false, label: 'Removing directory' },
+  move_file:        { type: 'tool', streaming: false, label: 'Moving file' },
+  copy_file:        { type: 'tool', streaming: false, label: 'Copying file' },
+  file_stat:        { type: 'tool', streaming: false, label: 'Inspecting file' },
+  edit_file:        { type: 'tool', streaming: false, label: 'Editing file' },
+  search_files:     { type: 'tool', streaming: false, label: 'Searching files' },
+  search_in_file:   { type: 'tool', streaming: false, label: 'Searching in file' },
+  replace_in_file:  { type: 'tool', streaming: false, label: 'Replacing in file' },
+  get_env:          { type: 'tool', streaming: false, label: 'Reading env var' },
+  set_env:          { type: 'tool', streaming: false, label: 'Setting env var' },
+  download:         { type: 'tool', streaming: false, label: 'Downloading' },
+  upload:           { type: 'tool', streaming: false, label: 'Uploading' },
+  http_get:         { type: 'tool', streaming: false, label: 'Fetching URL' },
+  http_get_next:    { type: 'tool', streaming: false, label: 'Fetching next content chunk' },
+  ask_user:         { type: 'tool', streaming: false, label: 'Asking user' },
+  store_memory:     { type: 'tool', streaming: false, label: 'Storing memory' },
+  recall_memory:    { type: 'tool', streaming: false, label: 'Recalling memory' },
+  list_memories:    { type: 'tool', streaming: false, label: 'Listing memories' },
+  system_info:      { type: 'tool', streaming: false, label: 'Reading system info' },
+
+  // MiniMax-M2 native tool-call wrappers. `extractToolCalls` parses them into
+  // internal calls; classifying them here keeps raw XML out of the UI stream.
+  'minimax:tool_call': { type: 'tool', streaming: false, label: 'Using tool' },
+  invoke:    { type: 'strip' },
+  parameter: { type: 'strip' },
+
+  // Qwen / Hermes native tool-call wrappers. Qwen3-family models emit a
+  // JSON-shaped `<tool_call>{"name":"...","arguments":{...}}</tool_call>`
+  // block inline when the server's tool parser is not applied, and some
+  // finetunes also use the namespaced `<qwen:tool_call>` or the
+  // `<function_call>` spelling. `extractToolCalls` parses all three.
+  'qwen:tool_call': { type: 'tool', streaming: false, label: 'Using tool' },
+  tool_call:       { type: 'tool', streaming: false, label: 'Using tool' },
+  function_call:   { type: 'tool', streaming: false, label: 'Using tool' },
+
+  // Silently stripped — model wrapper artifacts
+  answer:    { type: 'strip' },
+  response:  { type: 'strip' },
+  output:    { type: 'strip' },
+  assistant: { type: 'strip' },
+  message:   { type: 'strip' },
+  text:      { type: 'strip' },
+  result:    { type: 'strip' },
+  code:      { type: 'strip' },
+};
+
 module.exports = {
   CONFIG_PATH,
   DEFAULT_API_TIMEOUT_MS,
   DEFAULT_CONFIG,
   PACKAGE_JSON,
+  TAG_REGISTRY,
 };

package/lib/context.js

@@ -3,13 +3,11 @@
 const fs = require('fs');
 const path = require('path');
 
-function readFileContext(filePaths, ui) {
-  const { FG_GRAY, FG_GREEN, FG_RED, RST } = ui;
+function readFileContext(filePaths) {
   let context = '';
 
   for (const fp of filePaths) {
     if (!fs.existsSync(fp)) {
-      console.log(`  ${FG_RED}✗${RST} ${FG_GRAY}Not found: ${fp}${RST}`);
       continue;
     }
 
@@ -18,9 +16,8 @@ function readFileContext(filePaths, ui) {
       try {
         const content = fs.readFileSync(fp, 'utf8');
         context += `\n--- File: ${fp} ---\n${content}\n`;
-        console.log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}Loaded ${fp} (${content.length} chars)${RST}`);
       } catch (error) {
-        console.log(`  ${FG_RED}✗${RST} ${FG_GRAY}${fp}: ${error.message}${RST}`);
+        // silently skip unreadable files
       }
       continue;
     }
@@ -59,7 +56,6 @@ function readFileContext(filePaths, ui) {
       }
 
       walkDir(fp);
-      console.log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}Loaded ${count} files from ${fp}${RST}`);
     }
   }
 

package/lib/metrics.js

@@ -0,0 +1,94 @@
+'use strict';
+
+const { THEME } = require('./ui');
+
+class Metrics {
+  constructor(modelTokenLimit = null) {
+    this.sessionStart = Date.now();
+    this.turns = [];
+    this.modelTokenLimit = modelTokenLimit;
+  }
+
+  startTurn() {
+    this.turns.push({ start: Date.now(), promptTokens: 0, completionTokens: 0 });
+  }
+
+  endTurn(usage, model) {
+    const last = this.turns[this.turns.length - 1];
+    if (!last) return;
+    last.end = Date.now();
+    last.promptTokens = (usage && usage.prompt_tokens) || 0;
+    last.completionTokens = (usage && usage.completion_tokens) || 0;
+    last.model = model;
+  }
+
+  totalTokens() {
+    return this.turns.reduce((sum, t) => sum + t.promptTokens + t.completionTokens, 0);
+  }
+
+  contextTokens() {
+    if (!this.turns.length) return 0;
+    return this.turns[this.turns.length - 1].promptTokens;
+  }
+
+  tokenLimitStatus() {
+    if (this.modelTokenLimit === null) return null;
+    const used = this.contextTokens();
+    const pct = Math.round((used / this.modelTokenLimit) * 100);
+    const bar = this._buildBar(pct, 10);
+    return { used, limit: this.modelTokenLimit, pct, bar };
+  }
+
+  _buildBar(pct, width) {
+    const filled = Math.min(Math.round((pct / 100) * width), width);
+    const empty = Math.max(0, width - filled);
+    const bar = '█'.repeat(filled) + '░'.repeat(empty);
+    let color;
+    if (pct < 60) color = THEME.agent;
+    else if (pct < 85) color = THEME.warn;
+    else color = THEME.error;
+    return color + bar + THEME.reset;
+  }
+
+  averageLatency() {
+    const completed = this.turns.filter((t) => t.end !== undefined);
+    if (!completed.length) return '0.0s';
+    const avgMs = completed.reduce((sum, t) => sum + (t.end - t.start), 0) / completed.length;
+    return (avgMs / 1000).toFixed(1) + 's';
+  }
+
+  summary() {
+    const totalMs = Date.now() - this.sessionStart;
+    const minutes = Math.floor(totalMs / 60000);
+    const seconds = Math.floor((totalMs % 60000) / 1000);
+    const durationStr = `${minutes}m ${seconds}s`;
+
+    // Inner width between ║ chars = 39
+    // Header: '══ Session Summary ' = 19 chars, fill the rest with ═
+    const IW = 39;
+    const row = (content) => {
+      const pad = ' '.repeat(Math.max(0, IW - content.length));
+      return `║${content}${pad}║`;
+    };
+
+    const lines = [
+      `╔══ Session Summary ${'═'.repeat(IW - 19)}╗`,
+      row(`  Turns:         ${this.turns.length}`),
+      row(`  Total tokens:  ${this.totalTokens()}`),
+    ];
+
+    const status = this.tokenLimitStatus();
+    if (status !== null) {
+      lines.push(row(`  Context used:  ${this.contextTokens()}`));
+      lines.push(row(`  Token limit:   ${status.used}/${status.limit} (${status.pct}%)`));
+    }
+
+    lines.push(row(`  Duration:      ${durationStr}`));
+    lines.push(row(`  Avg latency:   ${this.averageLatency()} / turn`));
+    lines.push(`╚${'═'.repeat(IW)}╝`);
+
+    return lines.join('\n');
+  }
+}
+
+module.exports = { Metrics };

package/lib/permissions.js

@@ -1,72 +1,196 @@
 'use strict';
 
-function createPermissionManager(ui) {
-  const { BOLD, FG_CYAN, FG_DARK, FG_GRAY, FG_GREEN, FG_RED, FG_YELLOW, RST, readInteractiveInput } = ui;
+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'];
+const TIER_SYS = ['system_info', 'get_env', 'set_env'];
+
+const TIER_MAP = { fs: TIER_FS, exec: TIER_EXEC, net: TIER_NET, sys: TIER_SYS };
+const READONLY_BLOCKED = new Set(['write_file', 'append_file', 'delete_file', 'move_file', 'copy_file']);
+
+let _permissionCounter = 0;
+let _permissionQueueTail = Promise.resolve();
+
+function createPermissionManager(ui, { allowedTiers = [], readonly = false } = {}) {
+  const { BOLD, FG_CYAN, FG_DARK, FG_GRAY, FG_GREEN, FG_RED, FG_YELLOW, RST, interactiveSelect } = ui;
+
+  const autoApprovedTags = new Set();
+  for (const tierName of allowedTiers) {
+    const tags = TIER_MAP[tierName] || [];
+    tags.forEach((t) => autoApprovedTags.add(t));
+  }
+
   const state = {
     autoApproveShell: false,
     autoApproveFile: false,
   };
 
-  function askPermissionLine(actionType) {
-    return actionType === 'shell'
-      ? '  1. Yes  2. Yes, always for shell  3. No'
-      : '  1. Yes  2. Yes, always for files  3. No';
+  let uiCallbacks = null;
+
+  function setUICallbacks(callbacks) {
+    uiCallbacks = callbacks;
+  }
+
+  async function captureSelect(menu) {
+    if (uiCallbacks && uiCallbacks.captureSelect) {
+      return uiCallbacks.captureSelect(menu);
+    }
+    return Array.isArray(menu.options) && menu.options.length > 0 ? menu.options[0] : null;
   }
 
-  function readPermissionChoice() {
-    return readInteractiveInput(`  ${FG_YELLOW}?${RST} `, {
-      allowed: ['1', '2', '3'],
-      immediate: true,
-      trim: true,
-    });
+  const MAX_DESC_LINES = 12;
+
+  function requestPermission(description, onAddMessage, onRerenderMessage, onCollapseMessage, onCaptureNavigation) {
+    // Serialize dialogs: each permission waits for the previous one to be answered
+    const myTurn = _permissionQueueTail;
+    let releaseQueue;
+    _permissionQueueTail = new Promise((r) => { releaseQueue = r; });
+
+    return myTurn.then(() => new Promise((resolve) => {
+      const uniqueId = `perm_${++_permissionCounter}`;
+      const options = ['Yes', 'Always', 'No'];
+      let selectedIdx = 0;
+      const descLines = description.split('\n');
+      const truncatable = descLines.length > MAX_DESC_LINES;
+
+      function buildContent() {
+        let visibleDesc;
+        if (truncatable) {
+          visibleDesc = descLines.slice(0, MAX_DESC_LINES).join('\n') +
+            `\n  \x1b[2m… ${descLines.length - MAX_DESC_LINES} more lines\x1b[0m`;
+        } else {
+          visibleDesc = description;
+        }
+        const parts = [visibleDesc, ''];
+        for (let i = 0; i < options.length; i++) {
+          parts.push(i === selectedIdx
+            ? `\x1b[1m\x1b[36m  ►  ${options[i]}\x1b[0m`
+            : `     ${options[i]}`
+          );
+        }
+        return parts.join('\n');
+      }
+
+      const permMsg = { role: 'system', id: uniqueId, content: buildContent() };
+      onAddMessage(permMsg);
+
+      const releaseNav = onCaptureNavigation((action) => {
+        if (action === 'next') {
+          selectedIdx = (selectedIdx + 1) % options.length;
+          permMsg.content = buildContent();
+          onRerenderMessage(uniqueId);
+        } else if (action === 'prev') {
+          selectedIdx = (selectedIdx - 1 + options.length) % options.length;
+          permMsg.content = buildContent();
+          onRerenderMessage(uniqueId);
+        } else if (action === 'select') {
+          const chosen = options[selectedIdx];
+          releaseNav();
+          permMsg.content = chosen === 'No' ? `✗ ${description}` : `✓ ${description}`;
+          onCollapseMessage(uniqueId);
+          releaseQueue();
+          resolve(chosen.toLowerCase());
+        } else if (action === 'cancel') {
+          releaseNav();
+          permMsg.content = `✗ ${description}`;
+          onCollapseMessage(uniqueId);
+          releaseQueue();
+          resolve('no');
+        }
+      });
+    }));
   }
 
-  function askPermission(actionType, description) {
-    return new Promise((resolve) => {
-      if (actionType === 'shell' && state.autoApproveShell) {
+  async function askPermission(actionType, description, tag) {
+    if (tag && autoApprovedTags.has(tag)) {
+      if (uiCallbacks) {
+        uiCallbacks.onAddMessage({ role: 'system', content: `✓ Auto-approved: ${description}` });
+      } else {
         console.log(`  ${FG_GREEN}✓${RST} ${FG_DARK}Auto-approved: ${description}${RST}`);
-        resolve(true);
-        return;
       }
+      return true;
+    }
 
-      if (actionType === 'file' && state.autoApproveFile) {
+    if (actionType === 'shell' && state.autoApproveShell) {
+      if (uiCallbacks) {
+        uiCallbacks.onAddMessage({ role: 'system', content: `✓ Auto-approved: ${description}` });
+      } else {
         console.log(`  ${FG_GREEN}✓${RST} ${FG_DARK}Auto-approved: ${description}${RST}`);
-        resolve(true);
-        return;
       }
+      return true;
+    }
 
-      console.log();
-      console.log(`  ${FG_YELLOW}${BOLD}⚠ Permission required${RST}`);
-      console.log(`  ${FG_GRAY}${actionType}: ${description}${RST}`);
-      console.log();
-      console.log(`  ${FG_CYAN}${askPermissionLine(actionType)}${RST}`);
-      console.log();
-
-      readPermissionChoice().then((result) => {
-        if (result.type === 'sigint' || result.type === 'eof') {
-          console.log(`  ${FG_RED}✗${RST} ${FG_DARK}Denied${RST}`);
-          resolve(false);
-          return;
-        }
+    if (actionType === 'file' && state.autoApproveFile) {
+      if (uiCallbacks) {
+        uiCallbacks.onAddMessage({ role: 'system', content: `✓ Auto-approved: ${description}` });
+      } else {
+        console.log(`  ${FG_GREEN}✓${RST} ${FG_DARK}Auto-approved: ${description}${RST}`);
+      }
+      return true;
+    }
 
-        const choice = (result.value || '').trim().toLowerCase();
-        if (choice === '1' || choice === 'y' || choice === 'yes') {
-          resolve(true);
-          return;
-        }
+    if (!process.stdout.isTTY || !process.stdin.isTTY) {
+      process.stdout.write(`  [non-TTY] Auto-approving: ${description}\n`);
+      return true;
+    }
 
-        if (choice === '2' || choice === 'a' || choice === 'always') {
-          if (actionType === 'shell') state.autoApproveShell = true;
-          else state.autoApproveFile = true;
-          console.log(`  ${FG_GREEN}✓${RST} ${FG_DARK}Auto-approve enabled for ${actionType} operations${RST}`);
-          resolve(true);
-          return;
-        }
+    if (uiCallbacks) {
+      const result = await requestPermission(
+        `${actionType}: ${description}`,
+        uiCallbacks.onAddMessage,
+        uiCallbacks.onRerenderMessage,
+        uiCallbacks.onCollapseMessage,
+        uiCallbacks.onCaptureNavigation,
+      );
 
-        console.log(`  ${FG_RED}✗${RST} ${FG_DARK}Denied${RST}`);
-        resolve(false);
-      });
-    });
+      if (result === 'no') return false;
+
+      if (result === 'always') {
+        if (actionType === 'shell') state.autoApproveShell = true;
+        else state.autoApproveFile = true;
+        uiCallbacks.onAddMessage({ role: 'system', content: `✓ Auto-approve enabled for ${actionType} operations` });
+      }
+
+      return true;
+    }
+
+    // Fallback: legacy TTY interactive select (used outside of chat UI)
+    const alwaysLabel = actionType === 'shell' ? 'Yes, always for shell' : 'Yes, always for files';
+    const choices = ['Yes', alwaysLabel, 'No'];
+
+    console.log();
+    console.log(`  ${FG_YELLOW}${BOLD}⚠ Permission required${RST}`);
+    console.log(`  ${FG_GRAY}${actionType}: ${description}${RST}`);
+
+    const selectedIndex = await interactiveSelect(
+      choices,
+      (label, isSelected) => {
+        const cursor = isSelected ? `${FG_YELLOW}❯${RST}` : ' ';
+        const style = isSelected ? `${FG_CYAN}` : FG_GRAY;
+        return `  ${cursor} ${style}${label}${RST}`;
+      },
+      { initialIndex: 0 },
+    );
+
+    if (selectedIndex === null || selectedIndex === 2) {
+      console.log(`  ${FG_RED}✗${RST} ${FG_DARK}Denied${RST}`);
+      return false;
+    }
+
+    if (selectedIndex === 1) {
+      if (actionType === 'shell') state.autoApproveShell = true;
+      else state.autoApproveFile = true;
+      console.log(`  ${FG_GREEN}✓${RST} ${FG_DARK}Auto-approve enabled for ${actionType} operations${RST}`);
+    }
+
+    return true;
+  }
+
+  function readonlyBlock(tag) {
+    if (readonly && READONLY_BLOCKED.has(tag)) {
+      return { error: 'blocked by --readonly' };
+    }
+    return null;
   }
 
   function clear() {
@@ -82,7 +206,10 @@ function createPermissionManager(ui) {
 
   return {
     askPermission,
+    captureSelect,
     clear,
+    readonlyBlock,
+    setUICallbacks,
     state,
     toggleAll,
   };
@@ -90,4 +217,8 @@ function createPermissionManager(ui) {
 
 module.exports = {
   createPermissionManager,
+  TIER_EXEC,
+  TIER_FS,
+  TIER_NET,
+  TIER_SYS,
 };