@semalt-ai/code 1.6.0 → 1.8.0

package/lib/tools.js

@@ -1,81 +1,837 @@
 'use strict';
 
 const fs = require('fs');
+const http = require('http');
+const https = require('https');
+const os = require('os');
 const path = require('path');
 const { spawnSync } = require('child_process');
 
-function createToolExecutor(permissionManager, ui) {
-  const { FG_DARK, FG_GRAY, FG_GREEN, FG_RED, RST } = ui;
+const { logToolCall } = require('./audit');
+
+const MEMORY_PATH = path.join(os.homedir(), '.semalt-ai', 'memory.json');
+
+const _dryRun = process.argv.includes('--dry-run');
+const _skippedOps = [];
+function getSkippedOps() { return _skippedOps.slice(); }
+
+// When the full TUI is active, suppress direct console.log writes — the UI
+// handles all tool-status display via onToolEnd callbacks instead.
+let _uiActive = false;
+function setUIActive(v) { _uiActive = v; }
+function _log(...args) { if (!_uiActive) console.log(...args); }
+
+// Chunk store for large http_get responses.
+// Maps URL → { chunks: string[], total: number, delivered: number }
+const _httpChunkStore = new Map();
+const HTTP_CHUNK_CHARS = 10000;
+
+function createToolExecutor(permissionManager, ui, getConfig) {
+  const { BOLD, DIM, FG_DARK, FG_GRAY, FG_GREEN, FG_RED, FG_YELLOW, RST, renderDiff } = ui;
+
+  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 : [];
+  }
 
   async function agentExecShell(command) {
-    const approved = await permissionManager.askPermission('shell', command);
+    if (_dryRun) {
+      _log(`  ${FG_DARK}[dry-run] $ ${command}${RST}`);
+      _skippedOps.push({ category: 'cmd', symbol: '▶', desc: command });
+      logToolCall('exec', { command }, false, 'dry-run');
+      return { exit_code: 0, stdout: '', stderr: 'dry-run: command skipped' };
+    }
+
+    const approved = await permissionManager.askPermission('shell', command, 'exec');
     if (!approved) {
+      logToolCall('exec', { command }, false, 'denied');
       return { exit_code: -1, stdout: '', stderr: 'Permission denied by user' };
     }
 
-    console.log(`  ${FG_DARK}$ ${command}${RST}`);
     try {
-      const result = spawnSync(command, { shell: true, encoding: 'utf8', timeout: 60000 });
+      const cfg = getConfig ? getConfig() : {};
+      const timeout = cfg.command_timeout_ms || 30000;
+      const result = spawnSync(command, { shell: true, encoding: 'utf8', timeout });
       const stdout = result.stdout || '';
       const stderr = result.stderr || '';
-      const combined = stdout + (stderr ? `\n${stderr}` : '');
-      const lines = combined.trim().split('\n').filter((line) => line !== '');
-
-      if (lines.length > 20) {
-        lines.slice(0, 15).forEach((line) => console.log(`  ${FG_GRAY}${line}${RST}`));
-        console.log(`  ${FG_DARK}... (${lines.length - 15} more lines)${RST}`);
-      } else {
-        lines.forEach((line) => console.log(`  ${FG_GRAY}${line}${RST}`));
-      }
-      console.log();
-
-      return { exit_code: result.status ?? 0, stdout, stderr };
+      const exitCode = result.status ?? 0;
+      logToolCall('exec', { command }, true, exitCode === 0 ? 'ok' : 'error');
+      return { exit_code: exitCode, stdout, stderr };
     } catch (error) {
-      console.log(`  ${FG_RED}✗ ${error.message}${RST}`);
+      _log(`  ${FG_RED}✗ ${error.message}${RST}`);
+      logToolCall('exec', { command }, true, 'error');
       return { exit_code: -1, stdout: '', stderr: error.message };
     }
   }
 
-  async function agentExecFile(action, filePath, content = null) {
-    if (action === 'read') {
-      const approved = await permissionManager.askPermission('file', `Read ${filePath}`);
-      if (!approved) return { error: 'Permission denied' };
+  async function agentExecFile(action, ...args) {
+    const [arg0 = null, arg1 = null, arg2 = null, arg3 = null] = args;
 
+    if (action === 'read') {
+      const filePath = arg0;
+      try {
+        const stat = fs.statSync(filePath);
+        const cfg = getConfig ? getConfig() : {};
+        const maxBytes = (cfg.max_file_size_kb || 512) * 1024;
+        if (stat.size > maxBytes) {
+          const kb = (stat.size / 1024).toFixed(0);
+          logToolCall('read_file', { path: filePath }, false, 'error');
+          return { error: `File too large: ${kb} KB exceeds max_file_size_kb=${cfg.max_file_size_kb || 512}` };
+        }
+      } catch {
+        // file doesn't exist yet — readFileSync will report it
+      }
+      const approved = await permissionManager.askPermission('file', `Read ${filePath}`, 'read_file');
+      if (!approved) {
+        logToolCall('read_file', { path: filePath }, false, 'denied');
+        return { error: 'Permission denied' };
+      }
       try {
         const data = fs.readFileSync(filePath, 'utf8');
         const lines = data.split('\n').length;
         if (lines > 10) {
-          console.log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}Read ${filePath} (${lines} lines, ${data.length} chars)${RST}`);
+          _log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}Read ${filePath} (${lines} lines, ${data.length} chars)${RST}`);
         } else {
-          console.log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}Read ${filePath}${RST}`);
+          _log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}Read ${filePath}${RST}`);
         }
+        logToolCall('read_file', { path: filePath }, true, 'ok');
         return { content: data, path: filePath };
       } catch (error) {
-        console.log(`  ${FG_RED}✗ ${error.message}${RST}`);
+        _log(`  ${FG_RED}✗ ${error.message}${RST}`);
+        logToolCall('read_file', { path: filePath }, true, 'error');
         return { error: error.message };
       }
     }
 
     if (action === 'write' || action === 'append') {
+      const filePath = arg0;
+      const content = arg1;
+      const tag = action === 'write' ? 'write_file' : 'append_file';
+
+      const blocked = permissionManager.readonlyBlock(tag);
+      if (blocked) {
+        logToolCall(tag, { path: filePath, content }, false, 'denied');
+        return blocked;
+      }
+
+      // Read existing content for diff display
+      let existing = '';
+      try { existing = fs.readFileSync(filePath, 'utf8'); } catch {}
+
+      // For append the final state is existing + new content
+      const finalContent = action === 'write' ? (content || '') : (existing + (content || ''));
+
+      const diffOutput = renderDiff(existing, finalContent, filePath);
+      process.stdout.write(diffOutput + '\n');
+
+      // Dry-run: record the skipped op and return without writing
+      if (_dryRun) {
+        const verb = action === 'write' ? 'write' : 'append';
+        _skippedOps.push({ category: 'file', symbol: '✎', desc: `${verb} ${filePath}` });
+        logToolCall(tag, { path: filePath }, false, 'dry-run');
+        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
       let desc = `${action === 'write' ? 'Write' : 'Append to'} ${filePath}`;
       if (content) desc += ` (${content.length} chars)`;
-      const approved = await permissionManager.askPermission('file', desc);
-      if (!approved) return { error: 'Permission denied' };
-
+      const approved = await permissionManager.askPermission('file', desc, tag);
+      if (!approved) {
+        logToolCall(tag, { path: filePath, content }, false, 'denied');
+        return { error: 'Permission denied' };
+      }
       try {
         const dir = path.dirname(filePath);
         if (dir && dir !== '.') fs.mkdirSync(dir, { recursive: true });
         if (action === 'write') fs.writeFileSync(filePath, content || '');
         else fs.appendFileSync(filePath, content || '');
         const verb = action === 'write' ? 'Wrote' : 'Appended to';
-        console.log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}${verb} ${filePath}${RST}`);
+        _log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}${verb} ${filePath}${RST}`);
+        logToolCall(tag, { path: filePath, content }, true, 'ok');
         return { status: 'ok', path: filePath, bytes: (content || '').length };
       } catch (error) {
-        console.log(`  ${FG_RED}✗ ${error.message}${RST}`);
+        _log(`  ${FG_RED}✗ ${error.message}${RST}`);
+        logToolCall(tag, { path: filePath, content }, true, 'error');
+        return { error: error.message };
+      }
+    }
+
+    if (action === 'list_dir') {
+      const dirPath = arg0;
+      const approved = await permissionManager.askPermission('file', `List ${dirPath}`, 'list_dir');
+      if (!approved) {
+        logToolCall('list_dir', { path: dirPath }, false, 'denied');
+        return { error: 'Permission denied' };
+      }
+      try {
+        const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+        const items = entries.map((e) => {
+          if (e.isSymbolicLink()) return `[L] ${e.name}`;
+          if (e.isDirectory()) return `[D] ${e.name}`;
+          return `[F] ${e.name}`;
+        });
+        _log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}Listed ${dirPath} (${items.length} items)${RST}`);
+        logToolCall('list_dir', { path: dirPath }, true, 'ok');
+        return { items, path: dirPath };
+      } catch (error) {
+        _log(`  ${FG_RED}✗ ${error.message}${RST}`);
+        logToolCall('list_dir', { path: dirPath }, true, 'error');
+        return { error: error.message };
+      }
+    }
+
+    if (action === 'delete_file') {
+      const filePath = arg0;
+
+      const blocked = permissionManager.readonlyBlock('delete_file');
+      if (blocked) {
+        logToolCall('delete_file', { path: filePath }, false, 'denied');
+        return blocked;
+      }
+
+      _log(`  ${FG_YELLOW}${BOLD}⚠ Deleting: ${filePath}${RST}`);
+
+      const approved = await permissionManager.askPermission('file', `Delete ${filePath}`, 'delete_file');
+      if (!approved) {
+        logToolCall('delete_file', { path: filePath }, false, 'denied');
+        return { error: 'Permission denied' };
+      }
+      try {
+        fs.unlinkSync(filePath);
+        _log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}Deleted ${filePath}${RST}`);
+        logToolCall('delete_file', { path: filePath }, true, 'ok');
+        return { status: 'ok', path: filePath };
+      } catch (error) {
+        _log(`  ${FG_RED}✗ ${error.message}${RST}`);
+        logToolCall('delete_file', { path: filePath }, true, 'error');
+        return { error: error.message };
+      }
+    }
+
+    if (action === 'make_dir') {
+      const dirPath = arg0;
+      const approved = await permissionManager.askPermission('file', `Create directory ${dirPath}`, 'make_dir');
+      if (!approved) {
+        logToolCall('make_dir', { path: dirPath }, false, 'denied');
+        return { error: 'Permission denied' };
+      }
+      try {
+        fs.mkdirSync(dirPath, { recursive: true });
+        _log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}Created directory ${dirPath}${RST}`);
+        logToolCall('make_dir', { path: dirPath }, true, 'ok');
+        return { status: 'ok', path: dirPath };
+      } catch (error) {
+        _log(`  ${FG_RED}✗ ${error.message}${RST}`);
+        logToolCall('make_dir', { path: dirPath }, true, 'error');
+        return { error: error.message };
+      }
+    }
+
+    if (action === 'remove_dir') {
+      const dirPath = arg0;
+      const approved = await permissionManager.askPermission('file', `Remove directory ${dirPath}`, 'remove_dir');
+      if (!approved) {
+        logToolCall('remove_dir', { path: dirPath }, false, 'denied');
+        return { error: 'Permission denied' };
+      }
+      try {
+        fs.rmSync(dirPath, { recursive: true, force: true });
+        _log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}Removed directory ${dirPath}${RST}`);
+        logToolCall('remove_dir', { path: dirPath }, true, 'ok');
+        return { status: 'ok', path: dirPath };
+      } catch (error) {
+        _log(`  ${FG_RED}✗ ${error.message}${RST}`);
+        logToolCall('remove_dir', { path: dirPath }, true, 'error');
+        return { error: error.message };
+      }
+    }
+
+    if (action === 'move_file') {
+      const src = arg0;
+      const dst = arg1;
+
+      const blocked = permissionManager.readonlyBlock('move_file');
+      if (blocked) {
+        logToolCall('move_file', { src, dst }, false, 'denied');
+        return blocked;
+      }
+
+      _log(`  ${FG_YELLOW}${BOLD}⚠ Moving: ${src} → ${dst}${RST}`);
+
+      const approved = await permissionManager.askPermission('file', `Move ${src} to ${dst}`, 'move_file');
+      if (!approved) {
+        logToolCall('move_file', { src, dst }, false, 'denied');
+        return { error: 'Permission denied' };
+      }
+      try {
+        const dstDir = path.dirname(dst);
+        if (dstDir && dstDir !== '.') fs.mkdirSync(dstDir, { recursive: true });
+        const cfg = getConfig ? getConfig() : {};
+        const timeout = cfg.command_timeout_ms || 30000;
+        const mvResult = spawnSync('mv', [src, dst], { encoding: 'utf8', timeout });
+        if (mvResult.error && mvResult.error.code === 'ENOENT') throw new Error('mv not available');
+        if (mvResult.error) throw mvResult.error;
+        if (mvResult.status !== 0) throw new Error((mvResult.stderr || 'mv failed').trim());
+        _log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}Moved ${src} → ${dst}${RST}`);
+        logToolCall('move_file', { src, dst }, true, 'ok');
+        return { status: 'ok', src, dst };
+      } catch (mvErr) {
+        // Fallback: JS rename (works only within same filesystem)
+        try {
+          fs.renameSync(src, dst);
+          _log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}Moved ${src} → ${dst}${RST}`);
+          logToolCall('move_file', { src, dst }, true, 'ok');
+          return { status: 'ok', src, dst };
+        } catch (error) {
+          _log(`  ${FG_RED}✗ ${error.message}${RST}`);
+          logToolCall('move_file', { src, dst }, true, 'error');
+          return { error: error.message };
+        }
+      }
+    }
+
+    if (action === 'copy_file') {
+      const src = arg0;
+      const dst = arg1;
+
+      const blocked = permissionManager.readonlyBlock('copy_file');
+      if (blocked) {
+        logToolCall('copy_file', { src, dst }, false, 'denied');
+        return blocked;
+      }
+
+      const approved = await permissionManager.askPermission('file', `Copy ${src} to ${dst}`, 'copy_file');
+      if (!approved) {
+        logToolCall('copy_file', { src, dst }, false, 'denied');
+        return { error: 'Permission denied' };
+      }
+      try {
+        const dstDir = path.dirname(dst);
+        if (dstDir && dstDir !== '.') fs.mkdirSync(dstDir, { recursive: true });
+        fs.cpSync(src, dst, { recursive: true });
+        _log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}Copied ${src} → ${dst}${RST}`);
+        logToolCall('copy_file', { src, dst }, true, 'ok');
+        return { status: 'ok', src, dst };
+      } catch (error) {
+        _log(`  ${FG_RED}✗ ${error.message}${RST}`);
+        logToolCall('copy_file', { src, dst }, true, 'error');
+        return { error: error.message };
+      }
+    }
+
+    if (action === 'edit_file') {
+      const filePath = arg0;
+      const lineNum = arg1;
+      const newContent = arg2;
+      const approved = await permissionManager.askPermission('file', `Edit line ${lineNum} in ${filePath}`, 'edit_file');
+      if (!approved) {
+        logToolCall('edit_file', { path: filePath, line: lineNum }, false, 'denied');
+        return { error: 'Permission denied' };
+      }
+      try {
+        const data = fs.readFileSync(filePath, 'utf8');
+        const lines = data.split('\n');
+        if (lineNum < 1 || lineNum > lines.length) {
+          logToolCall('edit_file', { path: filePath, line: lineNum }, true, 'error');
+          return { error: `Line ${lineNum} out of range (file has ${lines.length} lines)` };
+        }
+        lines[lineNum - 1] = newContent;
+        fs.writeFileSync(filePath, lines.join('\n'));
+        _log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}Edited line ${lineNum} in ${filePath}${RST}`);
+        logToolCall('edit_file', { path: filePath, line: lineNum }, true, 'ok');
+        return { status: 'ok', path: filePath, line: lineNum };
+      } catch (error) {
+        _log(`  ${FG_RED}✗ ${error.message}${RST}`);
+        logToolCall('edit_file', { path: filePath, line: lineNum }, true, 'error');
+        return { error: error.message };
+      }
+    }
+
+    if (action === 'search_in_file') {
+      const filePath = arg0;
+      const pattern = arg1;
+      const approved = await permissionManager.askPermission('file', `Search in ${filePath}`, 'search_in_file');
+      if (!approved) {
+        logToolCall('search_in_file', { path: filePath, pattern }, false, 'denied');
+        return { error: 'Permission denied' };
+      }
+      try {
+        const cfg = getConfig ? getConfig() : {};
+        const timeout = cfg.command_timeout_ms || 30000;
+        const gr = spawnSync('grep', ['-n', '-E', '--', pattern, filePath], { encoding: 'utf8', timeout });
+        if (gr.error && gr.error.code === 'ENOENT') throw new Error('grep not available');
+        if (gr.error) throw gr.error;
+        // grep exit 1 = no matches (not an error), 2 = real error
+        if (gr.status === 2) throw new Error((gr.stderr || '').trim() || 'grep error');
+        const matches = (gr.stdout || '').split('\n').filter(Boolean).map(line => {
+          const colon = line.indexOf(':');
+          return colon === -1 ? null : { line: parseInt(line.slice(0, colon), 10), content: line.slice(colon + 1) };
+        }).filter(Boolean);
+        _log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}Found ${matches.length} match(es) in ${filePath}${RST}`);
+        logToolCall('search_in_file', { path: filePath, pattern }, true, 'ok');
+        return { matches, path: filePath };
+      } catch (grepErr) {
+        // Fallback: JS regex search
+        try {
+          const data = fs.readFileSync(filePath, 'utf8');
+          const regex = new RegExp(pattern);
+          const matches = data.split('\n')
+            .map((content, idx) => regex.test(content) ? { line: idx + 1, content } : null)
+            .filter(Boolean);
+          _log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}Found ${matches.length} match(es) in ${filePath}${RST}`);
+          logToolCall('search_in_file', { path: filePath, pattern }, true, 'ok');
+          return { matches, path: filePath };
+        } catch (error) {
+          _log(`  ${FG_RED}✗ ${error.message}${RST}`);
+          logToolCall('search_in_file', { path: filePath, pattern }, true, 'error');
+          return { error: error.message };
+        }
+      }
+    }
+
+    if (action === 'replace_in_file') {
+      const filePath = arg0;
+      const searchStr = arg1;
+      const replaceStr = arg2;
+      const flags = arg3 || '';
+      const approved = await permissionManager.askPermission('file', `Replace in ${filePath}`, 'replace_in_file');
+      if (!approved) {
+        logToolCall('replace_in_file', { path: filePath, search: searchStr }, false, 'denied');
+        return { error: 'Permission denied' };
+      }
+      try {
+        const data = fs.readFileSync(filePath, 'utf8');
+        const safeFlags = flags.replace(/[^gimsuy]/g, '');
+        const countFlags = safeFlags.includes('g') ? safeFlags : safeFlags + 'g';
+        const count = (data.match(new RegExp(searchStr, countFlags)) || []).length;
+        const regex = new RegExp(searchStr, safeFlags || undefined);
+        const newData = data.replace(regex, replaceStr);
+        fs.writeFileSync(filePath, newData);
+        _log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}Replaced ${count} occurrence(s) in ${filePath}${RST}`);
+        logToolCall('replace_in_file', { path: filePath, search: searchStr }, true, 'ok');
+        return { status: 'ok', path: filePath, count };
+      } catch (error) {
+        _log(`  ${FG_RED}✗ ${error.message}${RST}`);
+        logToolCall('replace_in_file', { path: filePath, search: searchStr }, true, 'error');
+        return { error: error.message };
+      }
+    }
+
+    if (action === 'search_files') {
+      const pattern = arg0;
+      const searchDir = arg1 || '.';
+      const approved = await permissionManager.askPermission('file', `Search files: ${pattern} in ${searchDir}`, 'search_files');
+      if (!approved) {
+        logToolCall('search_files', { pattern, dir: searchDir }, false, 'denied');
+        return { error: 'Permission denied' };
+      }
+      try {
+        const cfg = getConfig ? getConfig() : {};
+        const timeout = cfg.command_timeout_ms || 30000;
+        // Split glob: "src/**/*.js" → root=searchDir/src, nameGlob="*.js"
+        const parts = pattern.split('/');
+        const nameGlob = parts[parts.length - 1];
+        const subDirs = parts.slice(0, -1).filter(p => p !== '**' && p !== '');
+        const searchRoot = subDirs.length > 0 ? path.join(searchDir, ...subDirs) : searchDir;
+        const fr = spawnSync('find', [searchRoot, '-type', 'f', '-name', nameGlob], { encoding: 'utf8', timeout });
+        if (fr.error && fr.error.code === 'ENOENT') throw new Error('find not available');
+        if (fr.error) throw fr.error;
+        const files = (fr.stdout || '').split('\n').filter(Boolean)
+          .map(f => path.relative(searchDir, f))
+          .filter(Boolean)
+          .sort();
+        _log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}Found ${files.length} file(s) matching "${pattern}"${RST}`);
+        logToolCall('search_files', { pattern, dir: searchDir }, true, 'ok');
+        return { files, pattern, dir: searchDir };
+      } catch (_findErr) {
+        // Fallback: JS glob walker
+        try {
+          let regStr = pattern.replace(/[.+^${}()|[\]\\]/g, '\\$&');
+          regStr = regStr.replace(/\*\*/g, '\x00');
+          regStr = regStr.replace(/\*/g, '[^/]*');
+          regStr = regStr.replace(/\x00\//g, '(?:.*/)?');
+          regStr = regStr.replace(/\x00/g, '.*');
+          const regex = new RegExp(`^${regStr}$`);
+          const matchName = !pattern.includes('/');
+          const files = [];
+          function walk(dir, rel) {
+            let entries;
+            try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch { return; }
+            for (const entry of entries) {
+              const relPath = rel ? `${rel}/${entry.name}` : entry.name;
+              if (regex.test(matchName ? entry.name : relPath)) files.push(relPath);
+              if (entry.isDirectory()) walk(path.join(dir, entry.name), relPath);
+            }
+          }
+          walk(searchDir, '');
+          _log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}Found ${files.length} file(s) matching "${pattern}"${RST}`);
+          logToolCall('search_files', { pattern, dir: searchDir }, true, 'ok');
+          return { files, pattern, dir: searchDir };
+        } catch (error) {
+          _log(`  ${FG_RED}✗ ${error.message}${RST}`);
+          logToolCall('search_files', { pattern, dir: searchDir }, true, 'error');
+          return { error: error.message };
+        }
+      }
+    }
+
+    if (action === 'file_stat') {
+      const filePath = arg0;
+      const approved = await permissionManager.askPermission('file', `Stat ${filePath}`, 'file_stat');
+      if (!approved) {
+        logToolCall('file_stat', { path: filePath }, false, 'denied');
+        return { error: 'Permission denied' };
+      }
+      try {
+        const stat = fs.statSync(filePath);
+        const type = stat.isDirectory() ? 'directory' : stat.isSymbolicLink() ? 'symlink' : 'file';
+        const size_kb = (stat.size / 1024).toFixed(2);
+        const mode = '0o' + stat.mode.toString(8);
+        const mtime = stat.mtime.toISOString();
+        _log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}Stat ${filePath}${RST}`);
+        logToolCall('file_stat', { path: filePath }, true, 'ok');
+        return { path: filePath, size_kb, mtime, type, mode };
+      } catch (error) {
+        _log(`  ${FG_RED}✗ ${error.message}${RST}`);
+        logToolCall('file_stat', { path: filePath }, true, 'error');
+        return { error: error.message };
+      }
+    }
+
+    if (action === 'get_env') {
+      const varName = arg0;
+      const value = process.env[varName];
+      _log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}Got env ${varName}${RST}`);
+      logToolCall('get_env', { name: varName }, true, 'ok');
+      return { name: varName, value: value !== undefined ? value : null };
+    }
+
+    if (action === 'set_env') {
+      const varName = arg0;
+      const value = arg1 || '';
+      const approved = await permissionManager.askPermission('shell', `Set env ${varName}=${value}`, 'set_env');
+      if (!approved) {
+        logToolCall('set_env', { name: varName }, false, 'denied');
+        return { error: 'Permission denied' };
+      }
+      process.env[varName] = value;
+      _log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}Set env ${varName}${RST}`);
+      logToolCall('set_env', { name: varName }, true, 'ok');
+      return { status: 'ok', name: varName };
+    }
+
+    if (action === 'download') {
+      const url = arg0;
+      if (_dryRun) {
+        _skippedOps.push({ category: 'net', symbol: '↓', desc: `download ${url}` });
+        logToolCall('download', { url }, false, 'dry-run');
+        return { status: 'dry-run', message: 'dry-run: network call skipped' };
+      }
+      let fileName;
+      try {
+        fileName = path.basename(new URL(url).pathname) || 'download';
+      } catch {
+        fileName = 'download';
+      }
+      const outPath = path.join(process.cwd(), fileName);
+      const approved = await permissionManager.askPermission('shell', `Download ${url}`, 'download');
+      if (!approved) {
+        logToolCall('download', { url }, false, 'denied');
+        return { error: 'Permission denied' };
+      }
+      const dlResult = spawnSync('curl', ['-sLo', outPath, url], { encoding: 'utf8', timeout: 120000 });
+      if (!dlResult.error || dlResult.error.code !== 'ENOENT') {
+        if (dlResult.error || dlResult.status !== 0) {
+          try { fs.unlinkSync(outPath); } catch {}
+          const msg = dlResult.error ? dlResult.error.message : (dlResult.stderr || 'curl failed').trim();
+          _log(`  ${FG_RED}✗ ${msg}${RST}`);
+          logToolCall('download', { url }, true, 'error');
+          return { error: msg };
+        }
+        _log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}Downloaded to ${outPath}${RST}`);
+        logToolCall('download', { url }, true, 'ok');
+        return { status: 'ok', path: outPath };
+      }
+      // Fallback: Node.js http/https
+      return new Promise((resolve) => {
+        const proto = url.startsWith('https') ? https : http;
+        const file = fs.createWriteStream(outPath);
+        proto.get(url, (res) => {
+          res.pipe(file);
+          file.on('finish', () => {
+            file.close();
+            _log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}Downloaded to ${outPath}${RST}`);
+            logToolCall('download', { url }, true, 'ok');
+            resolve({ status: 'ok', path: outPath });
+          });
+        }).on('error', (err) => {
+          fs.unlink(outPath, () => {});
+          _log(`  ${FG_RED}✗ ${err.message}${RST}`);
+          logToolCall('download', { url }, true, 'error');
+          resolve({ error: err.message });
+        });
+      });
+    }
+
+    if (action === 'upload') {
+      const filePath = arg0;
+      const encodedContent = arg1 || '';
+      const approved = await permissionManager.askPermission('file', `Upload to ${filePath}`, 'upload');
+      if (!approved) {
+        logToolCall('upload', { path: filePath }, false, 'denied');
+        return { error: 'Permission denied' };
+      }
+      try {
+        const dir = path.dirname(filePath);
+        if (dir && dir !== '.') fs.mkdirSync(dir, { recursive: true });
+        const buffer = Buffer.from(encodedContent.trim(), 'base64');
+        fs.writeFileSync(filePath, buffer);
+        _log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}Uploaded ${buffer.length} bytes to ${filePath}${RST}`);
+        logToolCall('upload', { path: filePath }, true, 'ok');
+        return { status: 'ok', path: filePath, bytes: buffer.length };
+      } catch (error) {
+        _log(`  ${FG_RED}✗ ${error.message}${RST}`);
+        logToolCall('upload', { path: filePath }, true, 'error');
+        return { error: error.message };
+      }
+    }
+
+    function buildHttpResult(url, statusCode, body, raw) {
+      // Strip HTML markup so the LLM receives readable text instead of raw HTML.
+      // Reduces a typical 150k-char page to ~25-40k chars, cutting chunk count
+      // from ~16 to ~3 and preventing context-overflow re-fetch loops.
+      // Pass raw=true to skip stripping (e.g. when the agent needs to parse markup).
+      const looksLikeHtml = !raw && (/^\s*<!doctype\s+html/i.test(body) || /^\s*<html[\s>]/i.test(body));
+      const processedBody = looksLikeHtml
+        ? body
+            .replace(/<script[\s\S]*?<\/script>/gi, ' ')
+            .replace(/<style[\s\S]*?<\/style>/gi, ' ')
+            .replace(/<[^>]+>/g, ' ')
+            .replace(/&nbsp;/gi, ' ')
+            .replace(/&amp;/gi, '&')
+            .replace(/&lt;/gi, '<')
+            .replace(/&gt;/gi, '>')
+            .replace(/&quot;/gi, '"')
+            .replace(/&#x?[\da-f]+;/gi, ' ')
+            .replace(/\s{2,}/g, ' ')
+            .trim()
+        : body;
+
+      if (processedBody.length > HTTP_CHUNK_CHARS) {
+        const chunks = [];
+        for (let i = 0; i < processedBody.length; i += HTTP_CHUNK_CHARS) {
+          chunks.push(processedBody.slice(i, i + HTTP_CHUNK_CHARS));
+        }
+        _httpChunkStore.set(url, { chunks: chunks.slice(1), total: chunks.length, delivered: 1 });
+        return { status_code: statusCode, body: chunks[0], chunked: true, part: 1, total_parts: chunks.length, key: url };
+      }
+      _httpChunkStore.delete(url);
+      return { status_code: statusCode, body: processedBody };
+    }
+
+    if (action === 'http_get_next') {
+      const key = arg0;
+      const store = _httpChunkStore.get(key);
+      if (!store || store.chunks.length === 0) {
+        _httpChunkStore.delete(key);
+        return { key, body: '', part: null, total_parts: null, done: true };
+      }
+      const nextChunk = store.chunks[0];
+      store.chunks = store.chunks.slice(1);
+      store.delivered += 1;
+      const done = store.chunks.length === 0;
+      if (done) _httpChunkStore.delete(key);
+      return { key, body: nextChunk, part: store.delivered, total_parts: store.total, done };
+    }
+
+    if (action === 'http_get') {
+      const url = arg0;
+      const rawHtml = arg1 === 'true';
+      if (_dryRun) {
+        _skippedOps.push({ category: 'net', symbol: '↓', desc: `GET ${url}` });
+        logToolCall('http_get', { url }, false, 'dry-run');
+        return { status: 'dry-run', message: 'dry-run: network call skipped' };
+      }
+      const approved = await permissionManager.askPermission('shell', `HTTP GET ${url}`, 'http_get');
+      if (!approved) {
+        logToolCall('http_get', { url }, false, 'denied');
+        return { error: 'Permission denied' };
+      }
+      const httpCfg = getConfig ? getConfig() : {};
+      const curlTimeout = Math.max(15, Math.floor((httpCfg.request_timeout_ms || 15000) / 1000));
+      // Try curl first: -sL follows redirects; -w appends status code on its own line
+      const curlResult = spawnSync(
+        'curl', ['-sL', '--max-time', String(curlTimeout), '-w', '\n%{http_code}', url],
+        { encoding: 'utf8', timeout: (curlTimeout + 5) * 1000 }
+      );
+      if (!curlResult.error || curlResult.error.code !== 'ENOENT') {
+        if (curlResult.error) {
+          _log(`  ${FG_RED}✗ ${curlResult.error.message}${RST}`);
+          logToolCall('http_get', { url }, true, 'error');
+          return { error: curlResult.error.message };
+        }
+        const stdout = curlResult.stdout || '';
+        const lastNl = stdout.lastIndexOf('\n');
+        const body = lastNl >= 0 ? stdout.slice(0, lastNl) : stdout;
+        const statusCode = parseInt((lastNl >= 0 ? stdout.slice(lastNl + 1) : '').trim(), 10) || 0;
+        _log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}HTTP GET ${url} (${statusCode}, ${body.length} chars)${RST}`);
+        logToolCall('http_get', { url }, true, statusCode < 400 ? 'ok' : 'error');
+        return buildHttpResult(url, statusCode, body, rawHtml);
+      }
+      // Fallback: Node.js http/https
+      return new Promise((resolve) => {
+        function doGet(target, redirectsLeft) {
+          const proto = target.startsWith('https') ? https : http;
+          const req = proto.get(target, (res) => {
+            if ([301, 302, 303, 307, 308].includes(res.statusCode) && redirectsLeft > 0 && res.headers.location) {
+              return doGet(res.headers.location, redirectsLeft - 1);
+            }
+            let data = '';
+            res.setEncoding('utf8');
+            res.on('data', (chunk) => { data += chunk; });
+            res.on('end', () => {
+              _log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}HTTP GET ${target} (${res.statusCode}, ${data.length} chars)${RST}`);
+              logToolCall('http_get', { url: target }, true, res.statusCode < 400 ? 'ok' : 'error');
+              resolve(buildHttpResult(url, res.statusCode, data, rawHtml));
+            });
+          });
+          req.on('error', (err) => {
+            _log(`  ${FG_RED}✗ ${err.message}${RST}`);
+            logToolCall('http_get', { url: target }, true, 'error');
+            resolve({ error: err.message });
+          });
+          req.setTimeout(15000, () => { req.destroy(); logToolCall('http_get', { url: target }, true, 'error'); resolve({ error: 'Request timeout' }); });
+        }
+        doGet(url, 3);
+      });
+    }
+
+    if (action === 'ask_user') {
+      const question = arg0;
+      const approved = await permissionManager.askPermission('shell', `Ask user: ${question}`, 'ask_user');
+      if (!approved) {
+        logToolCall('ask_user', { question }, false, 'denied');
+        return { error: 'Permission denied' };
+      }
+      const options = _parseNumberedOptions(question);
+      if (options.length >= 2) {
+        const selected = await permissionManager.captureSelect({ options });
+        logToolCall('ask_user', { question }, true, 'ok');
+        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`);
+        logToolCall('ask_user', { question }, true, 'ok');
+        return { question, answer: 'y' };
+      }
+      process.stdout.write(`\n  ${FG_YELLOW}?${RST} ${question}\n  ${FG_GRAY}>${RST} `);
+      const buf = Buffer.alloc(4096);
+      let input = '';
+      while (true) {
+        const n = fs.readSync(0, buf, 0, 1);
+        if (n === 0) break;
+        const ch = buf[0];
+        if (ch === 0x0a) break;
+        if (ch === 0x0d) continue;
+        input += String.fromCharCode(ch);
+      }
+      _log();
+      logToolCall('ask_user', { question }, true, 'ok');
+      return { question, answer: input };
+    }
+
+    if (action === 'store_memory') {
+      const key = arg0;
+      const value = arg1 || '';
+      const approved = await permissionManager.askPermission('file', `Store memory: ${key}`, 'store_memory');
+      if (!approved) {
+        logToolCall('store_memory', { key }, false, 'denied');
+        return { error: 'Permission denied' };
+      }
+      try {
+        let mem = {};
+        try { mem = JSON.parse(fs.readFileSync(MEMORY_PATH, 'utf8')); } catch {}
+        mem[key] = value;
+        fs.mkdirSync(path.dirname(MEMORY_PATH), { recursive: true });
+        fs.writeFileSync(MEMORY_PATH, JSON.stringify(mem, null, 2));
+        _log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}Stored memory: ${key}${RST}`);
+        logToolCall('store_memory', { key }, true, 'ok');
+        return { status: 'ok', key };
+      } catch (error) {
+        _log(`  ${FG_RED}✗ ${error.message}${RST}`);
+        logToolCall('store_memory', { key }, true, 'error');
+        return { error: error.message };
+      }
+    }
+
+    if (action === 'recall_memory') {
+      const key = arg0;
+      const approved = await permissionManager.askPermission('file', `Recall memory: ${key}`, 'recall_memory');
+      if (!approved) {
+        logToolCall('recall_memory', { key }, false, 'denied');
+        return { error: 'Permission denied' };
+      }
+      try {
+        let mem = {};
+        try { mem = JSON.parse(fs.readFileSync(MEMORY_PATH, 'utf8')); } catch {}
+        const found = key in mem;
+        const value = found ? mem[key] : null;
+        _log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}Recalled memory: ${key}${RST}`);
+        logToolCall('recall_memory', { key }, true, 'ok');
+        return { key, value, found };
+      } catch (error) {
+        _log(`  ${FG_RED}✗ ${error.message}${RST}`);
+        logToolCall('recall_memory', { key }, true, 'error');
+        return { error: error.message };
+      }
+    }
+
+    if (action === 'list_memories') {
+      const approved = await permissionManager.askPermission('file', 'List memories', 'list_memories');
+      if (!approved) {
+        logToolCall('list_memories', {}, false, 'denied');
+        return { error: 'Permission denied' };
+      }
+      try {
+        let mem = {};
+        try { mem = JSON.parse(fs.readFileSync(MEMORY_PATH, 'utf8')); } catch {}
+        const keys = Object.keys(mem);
+        _log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}Listed ${keys.length} memory key(s)${RST}`);
+        logToolCall('list_memories', {}, true, 'ok');
+        return { keys };
+      } catch (error) {
+        _log(`  ${FG_RED}✗ ${error.message}${RST}`);
+        logToolCall('list_memories', {}, true, 'error');
         return { error: error.message };
       }
     }
 
+    if (action === 'system_info') {
+      const approved = await permissionManager.askPermission('shell', 'System info', 'system_info');
+      if (!approved) {
+        logToolCall('system_info', {}, false, 'denied');
+        return { error: 'Permission denied' };
+      }
+      const info = {
+        platform: os.platform(),
+        arch: os.arch(),
+        hostname: os.hostname(),
+        user: process.env.USER || process.env.USERNAME || '',
+        total_mem_mb: Math.round(os.totalmem() / 1024 / 1024),
+        free_mem_mb: Math.round(os.freemem() / 1024 / 1024),
+        node_version: process.version,
+        cwd: process.cwd(),
+      };
+      _log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}System info: ${info.platform}/${info.arch}${RST}`);
+      logToolCall('system_info', {}, true, 'ok');
+      return info;
+    }
+
+    logToolCall(action, { action }, false, 'error');
     return { error: `Unknown action: ${action}` };
   }
 
@@ -95,11 +851,7 @@ function extractToolCalls(text) {
     }
   }
 
-  for (const match of text.matchAll(/<shell>([\s\S]*?)<\/shell>/g)) {
-    calls.push(['shell', match[1].trim()]);
-  }
-
-  for (const match of text.matchAll(/<exec>([\s\S]*?)<\/exec>/g)) {
+  for (const match of text.matchAll(/<(?:shell|exec|run_command|run)>([\s\S]*?)<\/(?:shell|exec|run_command|run)>/g)) {
     calls.push(['shell', match[1].trim()]);
   }
 
@@ -107,14 +859,123 @@ function extractToolCalls(text) {
     calls.push(['read', match[1].trim()]);
   }
 
+  for (const match of text.matchAll(/<read_file\s+path="([^"]+)"\s*\/?>/g)) {
+    calls.push(['read', match[1]]);
+  }
+
   for (const match of text.matchAll(/<write_file\s+path="([^"]+)">([\s\S]*?)<\/write_file>/g)) {
     calls.push(['write', match[1], match[2]]);
   }
 
+  for (const match of text.matchAll(/<create_file\s+path="([^"]+)">([\s\S]*?)<\/create_file>/g)) {
+    calls.push(['write', match[1], match[2]]);
+  }
+
+  for (const match of text.matchAll(/<append_file\s+path="([^"]+)">([\s\S]*?)<\/append_file>/g)) {
+    calls.push(['append', match[1], match[2]]);
+  }
+
+  for (const match of text.matchAll(/<list_dir>([\s\S]*?)<\/list_dir>/g)) {
+    calls.push(['list_dir', match[1].trim()]);
+  }
+
+  for (const match of text.matchAll(/<search_files>([\s\S]*?)<\/search_files>/g)) {
+    calls.push(['search_files', match[1].trim(), '.']);
+  }
+
+  for (const match of text.matchAll(/<search_files\s+pattern="([^"]+)"(?:\s+dir="([^"]*)")?\s*(?:><\/search_files>|\/>)/g)) {
+    calls.push(['search_files', match[1], match[2] || '.']);
+  }
+
+  for (const match of text.matchAll(/<delete_file>([\s\S]*?)<\/delete_file>/g)) {
+    calls.push(['delete_file', match[1].trim()]);
+  }
+
+  for (const match of text.matchAll(/<make_dir>([\s\S]*?)<\/make_dir>/g)) {
+    calls.push(['make_dir', match[1].trim()]);
+  }
+
+  for (const match of text.matchAll(/<remove_dir>([\s\S]*?)<\/remove_dir>/g)) {
+    calls.push(['remove_dir', match[1].trim()]);
+  }
+
+  for (const match of text.matchAll(/<get_env>([\s\S]*?)<\/get_env>/g)) {
+    calls.push(['get_env', match[1].trim()]);
+  }
+
+  for (const match of text.matchAll(/<set_env\s+name="([^"]+)"\s+value="([^"]*)"\s*(?:><\/set_env>|\/>)/g)) {
+    calls.push(['set_env', match[1], match[2]]);
+  }
+
+  for (const match of text.matchAll(/<move_file\s+src="([^"]+)"\s+dst="([^"]+)"\s*(?:><\/move_file>|\/>)/g)) {
+    calls.push(['move_file', match[1], match[2]]);
+  }
+
+  for (const match of text.matchAll(/<copy_file\s+src="([^"]+)"\s+dst="([^"]+)"\s*(?:><\/copy_file>|\/>)/g)) {
+    calls.push(['copy_file', match[1], match[2]]);
+  }
+
+  for (const match of text.matchAll(/<edit_file\s+path="([^"]+)"\s+line="(\d+)">([\s\S]*?)<\/edit_file>/g)) {
+    calls.push(['edit_file', match[1], parseInt(match[2], 10), match[3]]);
+  }
+
+  for (const match of text.matchAll(/<search_in_file\s+path="([^"]+)">([\s\S]*?)<\/search_in_file>/g)) {
+    calls.push(['search_in_file', match[1], match[2].trim()]);
+  }
+
+  for (const match of text.matchAll(/<replace_in_file\s+path="([^"]+)"\s+search="([^"]*)"\s+replace="([^"]*)">([\s\S]*?)<\/replace_in_file>/g)) {
+    calls.push(['replace_in_file', match[1], match[2], match[3], match[4].trim()]);
+  }
+
+  for (const match of text.matchAll(/<download>([\s\S]*?)<\/download>/g)) {
+    calls.push(['download', match[1].trim()]);
+  }
+
+  for (const match of text.matchAll(/<upload\s+path="([^"]+)">([\s\S]*?)<\/upload>/g)) {
+    calls.push(['upload', match[1], match[2]]);
+  }
+
+  for (const match of text.matchAll(/<file_stat>([\s\S]*?)<\/file_stat>/g)) {
+    calls.push(['file_stat', match[1].trim()]);
+  }
+
+  for (const match of text.matchAll(/<http_get\b([^>]*?)(?:><\/http_get>|\/>)/g)) {
+    const attrStr = match[1];
+    const urlMatch = attrStr.match(/url="([^"]+)"/);
+    const rawMatch = attrStr.match(/raw="([^"]+)"/);
+    if (urlMatch) calls.push(['http_get', urlMatch[1], rawMatch ? rawMatch[1] : '']);
+  }
+
+  for (const match of text.matchAll(/<http_get_next\s+key="([^"]+)"\s*(?:><\/http_get_next>|\/>)/g)) {
+    calls.push(['http_get_next', match[1]]);
+  }
+
+  for (const match of text.matchAll(/<ask_user\s+question="([^"]+)"\s*(?:><\/ask_user>|\/>)/g)) {
+    calls.push(['ask_user', match[1]]);
+  }
+
+  for (const match of text.matchAll(/<store_memory\s+key="([^"]+)">([\s\S]*?)<\/store_memory>/g)) {
+    calls.push(['store_memory', match[1], match[2]]);
+  }
+
+  for (const match of text.matchAll(/<recall_memory\s+key="([^"]+)"\s*(?:><\/recall_memory>|\/>)/g)) {
+    calls.push(['recall_memory', match[1]]);
+  }
+
+  for (const match of text.matchAll(/<list_memories\s*(?:><\/list_memories>|\/>)/g)) {
+    calls.push(['list_memories']);
+  }
+
+  for (const match of text.matchAll(/<system_info\s*(?:><\/system_info>|\/>)/g)) {
+    calls.push(['system_info']);
+  }
+
   return calls;
 }
 
 module.exports = {
   createToolExecutor,
   extractToolCalls,
+  getSkippedOps,
+  setUIActive,
 };