vibehacker 4.1.0

package/src/tools.js

@@ -0,0 +1,588 @@
+'use strict';
+
+const fs = require('fs').promises;
+const fsSync = require('fs');
+const path = require('path');
+const { exec } = require('child_process');
+const { promisify } = require('util');
+const execAsync = promisify(exec);
+
+// ── File State Management ────────────────────────────────────────────────────
+// Tracks read files, file mtimes, and edit history for undo support.
+
+const _fileState = {
+  read:    new Set(),           // abs paths that have been read
+  mtimes:  new Map(),           // abs path → mtime at last read
+  edits:   [],                  // edit journal: [{ path, before, after, timestamp }]
+  modified: new Set(),          // files modified this session
+};
+
+function markRead(absPath, mtime) {
+  _fileState.read.add(absPath);
+  if (mtime) _fileState.mtimes.set(absPath, mtime);
+}
+
+function hasBeenRead(absPath) { return _fileState.read.has(absPath); }
+
+function recordEdit(absPath, before, after) {
+  _fileState.edits.push({ path: absPath, before, after, ts: Date.now() });
+  _fileState.modified.add(absPath);
+  // Keep last 50 edits only
+  if (_fileState.edits.length > 50) _fileState.edits.shift();
+}
+
+function getModifiedFiles() { return [..._fileState.modified]; }
+function getLastEdit() { return _fileState.edits[_fileState.edits.length - 1] || null; }
+
+// ── Tool Call Parser — extracts ALL tool calls from response ─────────────────
+
+const TOOL_PATTERNS = [
+  {
+    name: 'read_file',
+    regex: /<read_file>\s*<path>([\s\S]*?)<\/path>(?:\s*<offset>([\s\S]*?)<\/offset>)?(?:\s*<limit>([\s\S]*?)<\/limit>)?\s*<\/read_file>/g,
+    extract: (m) => ({ path: m[1].trim(), offset: m[2] ? parseInt(m[2].trim(), 10) : undefined, limit: m[3] ? parseInt(m[3].trim(), 10) : undefined }),
+  },
+  {
+    name: 'edit_file',
+    regex: /<edit_file>\s*<path>([\s\S]*?)<\/path>\s*<old_string>([\s\S]*?)<\/old_string>\s*<new_string>([\s\S]*?)<\/new_string>(?:\s*<replace_all>([\s\S]*?)<\/replace_all>)?\s*<\/edit_file>/g,
+    extract: (m) => ({ path: m[1].trim(), old_string: m[2], new_string: m[3], replace_all: m[4]?.trim() === 'true' }),
+  },
+  {
+    name: 'write_file',
+    regex: /<write_file>\s*<path>([\s\S]*?)<\/path>\s*<content>([\s\S]*?)<\/content>\s*<\/write_file>/g,
+    extract: (m) => ({ path: m[1].trim(), content: m[2] }),
+  },
+  {
+    name: 'execute_command',
+    regex: /<execute_command>\s*<command>([\s\S]*?)<\/command>\s*<\/execute_command>/g,
+    extract: (m) => ({ command: m[1].trim() }),
+  },
+  {
+    name: 'glob',
+    regex: /<glob>\s*<pattern>([\s\S]*?)<\/pattern>(?:\s*<path>([\s\S]*?)<\/path>)?\s*<\/glob>/g,
+    extract: (m) => ({ pattern: m[1].trim(), path: m[2]?.trim() }),
+  },
+  {
+    name: 'grep',
+    regex: /<grep>\s*<pattern>([\s\S]*?)<\/pattern>(?:\s*<path>([\s\S]*?)<\/path>)?(?:\s*<file_pattern>([\s\S]*?)<\/file_pattern>)?\s*<\/grep>/g,
+    extract: (m) => ({ pattern: m[1].trim(), path: m[2]?.trim(), filePattern: m[3]?.trim() }),
+  },
+  {
+    name: 'list_files',
+    regex: /<list_files>\s*<path>([\s\S]*?)<\/path>(?:\s*<recursive>([\s\S]*?)<\/recursive>)?\s*<\/list_files>/g,
+    extract: (m) => ({ path: m[1].trim(), recursive: m[2]?.trim() === 'true' }),
+  },
+  {
+    name: 'search_files',
+    regex: /<search_files>\s*<path>([\s\S]*?)<\/path>\s*<pattern>([\s\S]*?)<\/pattern>(?:\s*<file_pattern>([\s\S]*?)<\/file_pattern>)?\s*<\/search_files>/g,
+    extract: (m) => ({ path: m[1].trim(), pattern: m[2].trim(), filePattern: m[3]?.trim() }),
+  },
+  {
+    name: 'create_directory',
+    regex: /<create_directory>\s*<path>([\s\S]*?)<\/path>\s*<\/create_directory>/g,
+    extract: (m) => ({ path: m[1].trim() }),
+  },
+  {
+    name: 'delete_file',
+    regex: /<delete_file>\s*<path>([\s\S]*?)<\/path>\s*<\/delete_file>/g,
+    extract: (m) => ({ path: m[1].trim() }),
+  },
+];
+
+// Export tool names for XmlStreamFilter sync
+const TOOL_TAG_NAMES = TOOL_PATTERNS.map(p => p.name);
+
+function parseToolCalls(text) {
+  const calls = [];
+  const seen  = new Set();
+  for (const p of TOOL_PATTERNS) {
+    p.regex.lastIndex = 0;
+    let match;
+    while ((match = p.regex.exec(text)) !== null) {
+      if (seen.has(match[0])) continue;
+      seen.add(match[0]);
+      calls.push({ name: p.name, args: p.extract(match), raw: match[0], index: match.index });
+    }
+  }
+  calls.sort((a, b) => a.index - b.index);
+  return calls;
+}
+
+function parseToolCall(text) {
+  const calls = parseToolCalls(text);
+  return calls.length > 0 ? calls[0] : null;
+}
+
+// ── Tool Execution ───────────────────────────────────────────────────────────
+
+async function executeTool(toolCall, cwd) {
+  const { name, args } = toolCall;
+  const resolvePath = (p) => path.resolve(cwd, p);
+
+  try {
+    switch (name) {
+
+      case 'read_file': {
+        const fullPath = resolvePath(args.path);
+        let stat;
+        try { stat = await fs.stat(fullPath); } catch (e) {
+          return `[Error] File not found: ${args.path}\nCheck the path and try again. Use glob or list_files to find the correct path.`;
+        }
+        markRead(fullPath, stat.mtimeMs);
+
+        const content = await fs.readFile(fullPath, 'utf8');
+        let lines = content.split('\n');
+        const totalLines = lines.length;
+
+        const offset = args.offset ? Math.max(0, args.offset - 1) : 0;
+        const limit  = args.limit  || (stat.size > 500 * 1024 ? 300 : lines.length);
+
+        if (offset > 0 || limit < lines.length) {
+          lines = lines.slice(offset, offset + limit);
+        }
+
+        const pad = String(offset + lines.length).length;
+        const numbered = lines.map((line, i) => `${String(offset + i + 1).padStart(pad)}│ ${line}`).join('\n');
+        const rangeNote = (offset > 0 || limit < totalLines)
+          ? ` | lines ${offset + 1}-${offset + lines.length} of ${totalLines}`
+          : '';
+
+        return `[File: ${args.path} | ${totalLines} lines | ${stat.size} bytes${rangeNote}]\n${numbered}`;
+      }
+
+      case 'edit_file': {
+        const fullPath = resolvePath(args.path);
+
+        // Check file exists
+        let stat;
+        try { stat = await fs.stat(fullPath); } catch (_) {
+          return `[Error] File not found: ${args.path}\nUse write_file to create new files. Use glob to find existing files.`;
+        }
+
+        // Enforce read-before-edit
+        if (!hasBeenRead(fullPath)) {
+          return `[Error] Must read_file before editing: ${args.path}\nRead the file first so you can see its current contents and craft an accurate edit.`;
+        }
+
+        // Conflict detection — check if file changed since we last read it
+        const lastMtime = _fileState.mtimes.get(fullPath);
+        if (lastMtime && stat.mtimeMs > lastMtime + 1000) {
+          markRead(fullPath, stat.mtimeMs); // update mtime
+          return `[Error] File changed on disk since last read: ${args.path}\nAnother process modified this file. Read it again to see the current contents.`;
+        }
+
+        const content = await fs.readFile(fullPath, 'utf8');
+
+        if (args.old_string === args.new_string) {
+          return `[Error] old_string and new_string are identical — no change needed.`;
+        }
+
+        if (args.replace_all) {
+          if (!content.includes(args.old_string)) {
+            return `[Error] old_string not found in ${args.path}\nThe text you're trying to replace doesn't exist. Read the file again — the content may have changed.`;
+          }
+          const newContent = content.split(args.old_string).join(args.new_string);
+          const count = content.split(args.old_string).length - 1;
+          recordEdit(fullPath, content, newContent);
+          await fs.writeFile(fullPath, newContent, 'utf8');
+          markRead(fullPath, Date.now());
+          return `[Edited: ${args.path} | replaced ${count} occurrence${count > 1 ? 's' : ''}]`;
+        }
+
+        // Single replacement
+        const firstIdx = content.indexOf(args.old_string);
+        if (firstIdx === -1) {
+          // Help the agent recover
+          const suggestion = args.old_string.length > 50
+            ? 'Try using a shorter, more specific snippet from the file.'
+            : 'Check whitespace, indentation (tabs vs spaces), and line endings.';
+          return `[Error] old_string not found in ${args.path}\n${suggestion}\nRead the file again to see exact current contents.`;
+        }
+        const lastIdx = content.lastIndexOf(args.old_string);
+        if (firstIdx !== lastIdx) {
+          return `[Error] old_string matches ${content.split(args.old_string).length - 1} locations in ${args.path}\nInclude more surrounding context to make it unique, or use <replace_all>true</replace_all>.`;
+        }
+
+        const newContent = content.substring(0, firstIdx) + args.new_string + content.substring(firstIdx + args.old_string.length);
+        recordEdit(fullPath, content, newContent);
+        await fs.writeFile(fullPath, newContent, 'utf8');
+        markRead(fullPath, Date.now());
+
+        // Generate unified diff
+        const oldLines = args.old_string.split('\n');
+        const newLines = args.new_string.split('\n');
+        const editLineStart = content.substring(0, firstIdx).split('\n').length;
+
+        let diff = `[Edited: ${args.path}]\n`;
+        diff += `--- ${args.path}\n+++ ${args.path}\n`;
+        diff += `@@ -${editLineStart},${oldLines.length} +${editLineStart},${newLines.length} @@\n`;
+        for (const l of oldLines) diff += `- ${l}\n`;
+        for (const l of newLines) diff += `+ ${l}\n`;
+
+        return diff;
+      }
+
+      case 'write_file': {
+        const fullPath = resolvePath(args.path);
+
+        // Warn if overwriting unread file
+        let existed = false;
+        try {
+          await fs.stat(fullPath);
+          existed = true;
+          if (!hasBeenRead(fullPath)) {
+            // Record old content for undo
+            try {
+              const old = await fs.readFile(fullPath, 'utf8');
+              recordEdit(fullPath, old, args.content);
+            } catch (_) {}
+          }
+        } catch (_) {}
+
+        await fs.mkdir(path.dirname(fullPath), { recursive: true });
+        await fs.writeFile(fullPath, args.content, 'utf8');
+        markRead(fullPath, Date.now());
+        if (!existed) recordEdit(fullPath, null, args.content);
+
+        const bytes = Buffer.byteLength(args.content, 'utf8');
+        const lines = args.content.split('\n').length;
+        return `[${existed ? 'Overwritten' : 'Created'}: ${args.path} | ${lines} lines | ${bytes} bytes]`;
+      }
+
+      case 'execute_command': {
+        const startTime = Date.now();
+        try {
+          const { stdout, stderr } = await execAsync(args.command, {
+            cwd,
+            timeout: 120000,
+            maxBuffer: 8 * 1024 * 1024,
+            env: { ...process.env, FORCE_COLOR: '0', NO_COLOR: '1' },
+          });
+          const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+          let out = '';
+          if (stdout) out += stdout;
+          if (stderr) out += (out ? '\n[stderr]\n' : '[stderr]\n') + stderr;
+          if (out.length > 24000) {
+            out = out.substring(0, 12000) + '\n\n[... truncated ...]\n\n' + out.substring(out.length - 8000);
+          }
+          return `[Command: ${args.command} | ${elapsed}s | exit 0]\n${out || '(no output)'}`;
+        } catch (err) {
+          const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+          let errOut = `[Command failed: ${args.command} | ${elapsed}s | exit ${err.code || 1}]\n`;
+          if (err.killed) errOut += '[Timed out after 2 minutes]\n';
+          if (err.stdout) errOut += err.stdout.substring(0, 12000);
+          if (err.stderr) errOut += '\n[stderr]\n' + err.stderr.substring(0, 8000);
+          if (!err.stdout && !err.stderr) errOut += err.message;
+          return errOut.substring(0, 24000);
+        }
+      }
+
+      case 'glob': {
+        const searchPath = args.path ? resolvePath(args.path) : cwd;
+        const results = await globSearch(searchPath, args.pattern);
+        if (!results.length) return `[Glob: ${args.pattern} in ${args.path || '.'}]\nNo files matched. Try a broader pattern like **/* or check the path.`;
+        const rel = results.map(f => path.relative(cwd, f));
+        return `[Glob: ${args.pattern} | ${rel.length} files]\n${rel.join('\n')}`;
+      }
+
+      case 'grep': {
+        const searchPath = args.path ? resolvePath(args.path) : cwd;
+        const results = await grepSearch(searchPath, args.pattern, args.filePattern || '*', cwd);
+        if (!results.length) return `[Grep: "${args.pattern}" in ${args.path || '.'}]\nNo matches. Try a different pattern or broader file filter.`;
+        const truncNote = results.length >= 200 ? '\n[... results capped at 200]' : '';
+        return `[Grep: "${args.pattern}" | ${results.length} matches]\n${results.slice(0, 200).join('\n')}${truncNote}`;
+      }
+
+      case 'list_files': {
+        const fullPath = resolvePath(args.path);
+        try { await fs.stat(fullPath); } catch (_) {
+          return `[Error] Directory not found: ${args.path}`;
+        }
+        if (args.recursive) {
+          const files = await walkDir(fullPath, cwd);
+          return `[Directory: ${args.path} | ${files.length} entries]\n${files.join('\n')}`;
+        }
+        const entries = await fs.readdir(fullPath, { withFileTypes: true });
+        const formatted = entries.map(e => `${e.isDirectory() ? '📁' : '📄'} ${e.name}`);
+        return `[Directory: ${args.path} | ${entries.length} items]\n${formatted.join('\n')}`;
+      }
+
+      case 'search_files': {
+        const fullPath = resolvePath(args.path);
+        const results = await grepSearch(fullPath, args.pattern, args.filePattern || '*', cwd);
+        if (!results.length) return `[Search: "${args.pattern}" in ${args.path}]\nNo matches found.`;
+        return `[Search: "${args.pattern}" | ${results.length} matches]\n${results.slice(0, 200).join('\n')}`;
+      }
+
+      case 'create_directory': {
+        const fullPath = resolvePath(args.path);
+        await fs.mkdir(fullPath, { recursive: true });
+        return `[Created: ${args.path}]`;
+      }
+
+      case 'delete_file': {
+        const fullPath = resolvePath(args.path);
+        let stat;
+        try { stat = await fs.stat(fullPath); } catch (_) {
+          return `[Error] Path not found: ${args.path}`;
+        }
+        if (stat.isDirectory()) {
+          await fs.rm(fullPath, { recursive: true, force: true });
+          return `[Deleted directory: ${args.path}]`;
+        }
+        // Record for undo
+        try {
+          const old = await fs.readFile(fullPath, 'utf8');
+          recordEdit(fullPath, old, null);
+        } catch (_) {}
+        await fs.unlink(fullPath);
+        return `[Deleted: ${args.path}]`;
+      }
+
+      default:
+        return `[Error] Unknown tool: ${name}`;
+    }
+  } catch (err) {
+    return `[Error: ${name}] ${err.message}\nIf this is unexpected, try a different approach.`;
+  }
+}
+
+// ── Glob Search ──────────────────────────────────────────────────────────────
+
+async function globSearch(dir, pattern) {
+  const results = [];
+  const SKIP = new Set(['.git', 'node_modules', '.next', '__pycache__', '.venv', 'venv', 'env',
+    'dist', 'build', '.cache', 'coverage', '.tox', '.mypy_cache', '.pytest_cache',
+    'vendor', 'target', '.gradle', '.idea', '.vs', '.vscode']);
+
+  const parts    = pattern.replace(/\\/g, '/').split('/');
+  const isDeep   = parts.includes('**');
+  const filePart = parts[parts.length - 1];
+
+  async function walk(currentDir, depth) {
+    let entries;
+    try { entries = await fs.readdir(currentDir, { withFileTypes: true }); } catch (_) { return; }
+    for (const entry of entries) {
+      if (SKIP.has(entry.name)) continue;
+      if (entry.name.startsWith('.') && entry.name !== '.env' && entry.name !== '.gitignore' && entry.name !== '.eslintrc.js') continue;
+      const full = path.join(currentDir, entry.name);
+      if (entry.isDirectory()) {
+        if (isDeep || depth === 0) await walk(full, depth + 1);
+      } else {
+        if (matchGlob(entry.name, filePart)) results.push(full);
+      }
+      if (results.length > 500) return;
+    }
+  }
+  await walk(dir, 0);
+  return results;
+}
+
+// ── Grep Search — Parallel File I/O ──────────────────────────────────────────
+
+const BINARY_EXTS = new Set(['.png','.jpg','.jpeg','.gif','.ico','.bmp','.webp','.svg',
+  '.woff','.woff2','.ttf','.eot','.otf','.mp3','.mp4','.avi','.mov','.zip',
+  '.gz','.tar','.rar','.7z','.pdf','.exe','.dll','.so','.dylib','.o','.obj',
+  '.class','.pyc','.wasm','.db','.sqlite','.lock']);
+
+async function grepSearch(dir, pattern, filePattern, baseCwd) {
+  const results = [];
+  const SKIP = new Set(['.git', 'node_modules', '.next', '__pycache__', '.venv', 'dist', 'build', '.cache',
+    'coverage', 'vendor', 'target', '.gradle', '.idea', '.vs']);
+
+  if (typeof pattern !== 'string' || pattern.length > 300) return ['[grep: pattern too long]'];
+  if (/(\([^)]*[+*][^)]*\))[+*]/.test(pattern)) return ['[grep: pattern rejected — ReDoS risk]'];
+  let regex;
+  try { regex = new RegExp(pattern, 'gi'); } catch (e) { return [`[grep: invalid regex — ${e.message}]`]; }
+
+  // Phase 1: Collect all candidate file paths (fast walk, no reads)
+  const candidates = [];
+  async function collectFiles(currentDir) {
+    let entries;
+    try { entries = await fs.readdir(currentDir, { withFileTypes: true }); } catch (_) { return; }
+    for (const entry of entries) {
+      if (SKIP.has(entry.name) || (entry.name.startsWith('.') && entry.name !== '.env')) continue;
+      const fullPath = path.join(currentDir, entry.name);
+      if (entry.isDirectory()) { await collectFiles(fullPath); }
+      else {
+        if (!matchGlob(entry.name, filePattern)) continue;
+        if (BINARY_EXTS.has(path.extname(entry.name).toLowerCase())) continue;
+        candidates.push(fullPath);
+      }
+      if (candidates.length > 2000) return; // cap file count
+    }
+  }
+  await collectFiles(dir);
+
+  // Phase 2: Read and search files in parallel batches (8 concurrent)
+  const BATCH = 8;
+  for (let i = 0; i < candidates.length && results.length < 200; i += BATCH) {
+    const batch = candidates.slice(i, i + BATCH);
+    const reads = batch.map(async (fullPath) => {
+      try {
+        const stat = await fs.stat(fullPath);
+        if (stat.size > 3 * 1024 * 1024) return; // skip >3MB
+        const content = await fs.readFile(fullPath, 'utf8');
+        if (content.includes('\0')) return; // binary check
+        const lines = content.split('\n');
+        const rel = path.relative(baseCwd || dir, fullPath);
+        // Use fresh regex per file (avoid shared lastIndex issues)
+        const localRegex = new RegExp(pattern, 'gi');
+        for (let j = 0; j < lines.length; j++) {
+          const line = lines[j].length > 500 ? lines[j].substring(0, 500) : lines[j];
+          if (localRegex.test(line)) {
+            results.push(`${rel}:${j + 1}: ${line.trim().substring(0, 150)}`);
+            localRegex.lastIndex = 0;
+            if (results.length >= 200) return;
+          }
+        }
+      } catch (_) {}
+    });
+    await Promise.all(reads);
+  }
+
+  return results;
+}
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+async function walkDir(dir, cwd) {
+  let entries;
+  try { entries = await fs.readdir(dir, { withFileTypes: true }); } catch (_) { return []; }
+  const results = [];
+  const SKIP = new Set(['.git', 'node_modules', '.next', '__pycache__', '.venv', 'dist', 'build', '.cache', 'coverage']);
+  for (const entry of entries) {
+    if (entry.name.startsWith('.') && entry.name !== '.env') continue;
+    if (SKIP.has(entry.name)) continue;
+    const rel = path.relative(cwd, path.join(dir, entry.name));
+    if (entry.isDirectory()) {
+      results.push(`📁 ${rel}/`);
+      if (results.length < 800) results.push(...await walkDir(path.join(dir, entry.name), cwd));
+    } else {
+      results.push(`📄 ${rel}`);
+    }
+    if (results.length > 1000) { results.push('... (truncated)'); break; }
+  }
+  return results;
+}
+
+function matchGlob(filename, pattern) {
+  if (!pattern || pattern === '*') return true;
+  if (pattern.startsWith('*.')) return filename.endsWith(pattern.slice(1));
+  const braceMatch = pattern.match(/^\*\.\{(.+)\}$/);
+  if (braceMatch) {
+    return braceMatch[1].split(',').some(e => filename.endsWith('.' + e.trim()));
+  }
+  return filename === pattern;
+}
+
+// ── Tool Documentation ──────────────────────────────────────────────────────
+
+const TOOL_DOCS = `
+## Available Tools
+
+Use XML blocks to interact with the filesystem and shell. You may use MULTIPLE tools in a single response.
+
+### read_file
+Read file contents with line numbers. Use offset/limit for large files.
+\`\`\`xml
+<read_file>
+<path>src/main.js</path>
+</read_file>
+\`\`\`
+Partial read:
+\`\`\`xml
+<read_file>
+<path>src/main.js</path>
+<offset>50</offset>
+<limit>50</limit>
+</read_file>
+\`\`\`
+
+### edit_file ← PREFERRED for modifying existing files
+Surgical string replacement. MUST read_file first. old_string must be unique.
+\`\`\`xml
+<edit_file>
+<path>src/main.js</path>
+<old_string>const x = 1;</old_string>
+<new_string>const x = 42;</new_string>
+</edit_file>
+\`\`\`
+Replace all occurrences:
+\`\`\`xml
+<edit_file>
+<path>src/main.js</path>
+<old_string>oldName</old_string>
+<new_string>newName</new_string>
+<replace_all>true</replace_all>
+</edit_file>
+\`\`\`
+
+### write_file
+Create new files or complete rewrites only. Prefer edit_file for modifications.
+\`\`\`xml
+<write_file>
+<path>src/new-file.js</path>
+<content>
+// complete file contents
+</content>
+</write_file>
+\`\`\`
+
+### execute_command
+Run shell commands (2 min timeout). Non-interactive only.
+\`\`\`xml
+<execute_command>
+<command>npm test</command>
+</execute_command>
+\`\`\`
+
+### grep
+Fast regex content search across files.
+\`\`\`xml
+<grep>
+<pattern>function main</pattern>
+<path>src</path>
+<file_pattern>*.js</file_pattern>
+</grep>
+\`\`\`
+
+### glob
+Find files by pattern.
+\`\`\`xml
+<glob>
+<pattern>**/*.js</pattern>
+<path>src</path>
+</glob>
+\`\`\`
+
+### list_files
+List directory contents.
+\`\`\`xml
+<list_files>
+<path>.</path>
+<recursive>true</recursive>
+</list_files>
+\`\`\`
+
+### search_files
+Search file contents (alias for grep).
+
+### create_directory
+Create directories recursively.
+\`\`\`xml
+<create_directory>
+<path>src/utils</path>
+</create_directory>
+\`\`\`
+
+### delete_file
+Delete a file or directory.
+\`\`\`xml
+<delete_file>
+<path>temp/old-file.txt</path>
+</delete_file>
+\`\`\`
+`;
+
+module.exports = { parseToolCall, parseToolCalls, executeTool, TOOL_DOCS, TOOL_TAG_NAMES, getModifiedFiles, getLastEdit };