@hamp10/agentforge 0.2.21 → 0.2.23

package/src/hampagent/runner.js

@@ -1,277 +0,0 @@
-/**
- * Hampagent Runner — uses the claude CLI subprocess with stream-json output.
- * Authenticates via Claude Code OAuth (Max plan) — no API key needed.
- * Full streaming, tool events, session continuity via --resume.
- */
-
-import { spawn } from 'child_process';
-import { mkdirSync } from 'fs';
-import { EventEmitter } from 'events';
-import path from 'path';
-
-const MODEL = 'sonnet'; // always latest sonnet
-
-// Tool labels for typing indicator
-const TOOL_LABELS = {
-  Bash: (i) => i?.command ? `⚡ ${i.command.slice(0, 70)}` : '⚡ Running command',
-  Read: (i) => i?.file_path ? `📄 Reading ${path.basename(i.file_path)}` : '📄 Reading file',
-  Write: (i) => i?.file_path ? `✏️ Writing ${path.basename(i.file_path)}` : '✏️ Writing file',
-  Edit: (i) => i?.file_path ? `✏️ Editing ${path.basename(i.file_path)}` : '✏️ Editing file',
-  Glob: (i) => i?.pattern ? `🔍 Finding ${i.pattern}` : '🔍 Finding files',
-  Grep: (i) => i?.pattern ? `🔍 Searching for "${i.pattern.slice(0, 40)}"` : '🔍 Searching code',
-  WebFetch: (i) => { try { return `🌐 Fetching ${new URL(i?.url || '').hostname}`; } catch { return '🌐 Fetching page'; } },
-  WebSearch: (i) => i?.query ? `🔍 Searching: ${i.query.slice(0, 50)}` : '🔍 Web search',
-  Task: () => '🤖 Spawning sub-task',
-};
-
-// MCP playwright tools
-const PLAYWRIGHT_LABELS = {
-  browser_navigate: (i) => { try { return `🌐 Navigating to ${new URL(i?.url || '').hostname}`; } catch { return '🌐 Navigating'; } },
-  browser_take_screenshot: () => '📸 Taking screenshot',
-  browser_snapshot: () => '🌐 Reading page',
-  browser_click: (i) => `🖱️ Clicking${i?.selector ? ` ${i.selector}` : ''}`,
-  browser_type: (i) => `⌨️ Typing "${(i?.text || '').slice(0, 30)}"`,
-  browser_evaluate: () => '⚙️ Running script',
-};
-
-function toolLabel(name, input) {
-  // Handle mcp__playwright__* tools
-  if (name.startsWith('mcp__playwright__')) {
-    const action = name.replace('mcp__playwright__', '');
-    const fn = PLAYWRIGHT_LABELS[action];
-    return fn ? fn(input) : `🌐 Browser: ${action}`;
-  }
-  const fn = TOOL_LABELS[name];
-  if (fn) return fn(input);
-  return `🔧 ${name}`;
-}
-
-function buildSystemAppend({ agentName, agentEmoji, taskCwd, workDir, dashboardUrl, agentforgemd }) {
-  const name = agentName || 'an AI agent';
-  const emoji = agentEmoji || '🤖';
-  const dashboard = dashboardUrl || 'https://agentforgeai-production.up.railway.app/dashboard';
-  const workspace = workDir || taskCwd || process.cwd();
-
-  return `You are ${name} ${emoji}, an AI agent running on AgentForge.ai platform.
-Your runtime: Hampagent — built for AgentForge. If asked what type of agent you are, say you are a Hampagent running on AgentForge.
-Dashboard: ${dashboard}
-Working directory (where files live): ${taskCwd || process.cwd()}
-Agent workspace (your memory/config files): ${workspace}
-
-## RULES
-- Be direct and autonomous. Do the task — don't ask for permission before trying things.
-- When greeting or introducing yourself, give your name and a one-liner — never list your capabilities.
-- Never dump raw stack traces or errors into chat. Handle errors gracefully.
-- For visual work: build → screenshot → fix → screenshot again until it looks good.
-- Projects folder: /Users/hamp/Desktop/projects — check here first when user mentions a project.
-
-## SPEAKING ALOUD
-To speak via audio: osascript -e "set volume output volume 80" && say "message"
-
-## MEMORY
-Your memory lives ONLY in: ${workspace}/MEMORY.md
-Read it at session start. Write important things there. IGNORE any other memory system or memory paths.
-Do NOT write to or read from any memory location outside your workspace.
-
-${agentforgemd ? `## PLATFORM GUIDE\n${agentforgemd}` : ''}`.trim();
-}
-
-export class HampAgentRunner extends EventEmitter {
-  constructor() {
-    super();
-    this.cancelled = false;
-    this._proc = null;
-  }
-
-  cancel() {
-    this.cancelled = true;
-    if (this._proc) {
-      try { this._proc.kill('SIGTERM'); } catch {}
-      this._proc = null;
-    }
-  }
-
-  async run(task, { taskCwd, workDir, agentName, agentEmoji, dashboardUrl, agentforgemd, resumeSessionId } = {}) {
-    this.cancelled = false;
-
-    const systemAppend = buildSystemAppend({ agentName, agentEmoji, taskCwd, workDir, dashboardUrl, agentforgemd });
-
-    const args = [
-      '--print',
-      '--output-format', 'stream-json',
-      '--include-partial-messages',
-      '--verbose',
-      '--dangerously-skip-permissions',
-      '--model', MODEL,
-      '--append-system-prompt', systemAppend,
-    ];
-
-    // Resume prior session for conversation continuity
-    if (resumeSessionId) {
-      args.push('--resume', resumeSessionId);
-    }
-
-    // Pass task as CLI argument (claude -p "task")
-    args.push(task);
-
-    return new Promise((resolve, reject) => {
-      const spawnCwd = taskCwd || process.cwd();
-      try { mkdirSync(spawnCwd, { recursive: true }); } catch {}
-
-      const proc = spawn('claude', args, {
-        cwd: spawnCwd,
-        stdio: ['pipe', 'pipe', 'pipe'],
-        env: { ...process.env },
-      });
-
-      this._proc = proc;
-      proc.stdin.end(); // no stdin needed — task is passed as arg
-
-      let fullText = '';
-      let buffer = '';
-      let newSessionId = null;
-      const activeTools = new Map(); // id -> name
-
-      const processLine = (line) => {
-        if (!line.trim()) return;
-        let event;
-        try { event = JSON.parse(line); } catch { return; }
-
-        // Capture session ID from init
-        if (event.type === 'system' && event.subtype === 'init') {
-          newSessionId = event.session_id || null;
-          return;
-        }
-
-        if (event.type === 'stream_event') {
-          const e = event.event;
-          if (!e) return;
-
-          // Streaming text token
-          if (e.type === 'content_block_delta' && e.delta?.type === 'text_delta') {
-            const text = e.delta.text || '';
-            if (text) {
-              fullText += text;
-              this.emit('token', text);
-            }
-            return;
-          }
-
-          // Tool use starting
-          if (e.type === 'content_block_start' && e.content_block?.type === 'tool_use') {
-            const { id, name, input } = e.content_block;
-            activeTools.set(id || name, name);
-            const label = toolLabel(name, input);
-            this.emit('tool_start', { tool: name, label, input });
-            return;
-          }
-
-          // Tool result (tool finished)
-          if (e.type === 'content_block_start' && e.content_block?.type === 'tool_result') {
-            const toolName = activeTools.get(e.content_block?.tool_use_id) || 'tool';
-            this.emit('tool_end', { tool: toolName, success: true });
-            activeTools.delete(e.content_block?.tool_use_id);
-            return;
-          }
-        }
-
-        // Image from screenshot tool
-        if (event.type === 'assistant' && event.message?.content) {
-          for (const block of event.message.content) {
-            if (block.type === 'tool_result') {
-              for (const part of (block.content || [])) {
-                if (part.type === 'image' && part.source?.data) {
-                  this.emit('image', `data:image/png;base64,${part.source.data}`);
-                }
-              }
-              // Mark tool as done
-              const toolName = activeTools.get(block.tool_use_id) || 'tool';
-              this.emit('tool_end', { tool: toolName, success: !block.is_error });
-              activeTools.delete(block.tool_use_id);
-            }
-          }
-        }
-      };
-
-      proc.stdout.on('data', (chunk) => {
-        buffer += chunk.toString();
-        const lines = buffer.split('\n');
-        buffer = lines.pop();
-        for (const line of lines) processLine(line);
-      });
-
-      let sessionNotFound = false;
-      proc.stderr.on('data', (d) => {
-        const msg = d.toString().trim();
-        if (msg.startsWith('No conversation found')) {
-          sessionNotFound = true; // stale --resume session ID — will retry without it
-        } else if (msg) {
-          console.warn(`[hampagent] stderr: ${msg.slice(0, 200)}`);
-        }
-      });
-
-      proc.on('close', async () => {
-        this._proc = null;
-        if (buffer.trim()) processLine(buffer);
-
-        // If --resume pointed to a nonexistent session, retry fresh without it
-        if (sessionNotFound && resumeSessionId) {
-          console.warn(`[hampagent] Session ${resumeSessionId} not found — retrying without --resume`);
-          const retryArgs = args.filter((a, i) => a !== '--resume' && args[i - 1] !== '--resume');
-          const retryProc = spawn('claude', retryArgs, {
-            cwd: spawnCwd,
-            stdio: ['pipe', 'pipe', 'pipe'],
-            env: { ...process.env },
-          });
-          this._proc = retryProc;
-          retryProc.stdin.end();
-          let retryText = '';
-          let retryBuffer = '';
-          let retrySessionId = null;
-          retryProc.stdout.on('data', (chunk) => {
-            retryBuffer += chunk.toString();
-            const lines = retryBuffer.split('\n');
-            retryBuffer = lines.pop();
-            for (const line of lines) {
-              if (!line.trim()) continue;
-              let ev; try { ev = JSON.parse(line); } catch { continue; }
-              if (ev.type === 'system' && ev.subtype === 'init') { retrySessionId = ev.session_id || null; continue; }
-              if (ev.type === 'stream_event') {
-                const e = ev.event;
-                if (e?.type === 'content_block_delta' && e.delta?.type === 'text_delta' && e.delta.text) {
-                  retryText += e.delta.text;
-                  this.emit('token', e.delta.text);
-                }
-              }
-            }
-          });
-          retryProc.stderr.on('data', (d) => {
-            const msg = d.toString().trim();
-            if (msg) console.warn(`[hampagent retry] stderr: ${msg.slice(0, 200)}`);
-          });
-          retryProc.on('close', () => {
-            this._proc = null;
-            if (retryBuffer.trim()) {
-              try {
-                const ev = JSON.parse(retryBuffer);
-                if (ev.type === 'stream_event' && ev.event?.type === 'content_block_delta') {
-                  retryText += ev.event.delta?.text || '';
-                }
-              } catch {}
-            }
-            resolve({ text: retryText, sessionId: retrySessionId, sessionCleared: true });
-          });
-          retryProc.on('error', (err) => { this._proc = null; reject(err); });
-          return;
-        }
-
-        resolve({ text: fullText, sessionId: newSessionId });
-      });
-
-      proc.on('error', (err) => {
-        this._proc = null;
-        reject(err);
-      });
-    });
-  }
-}

package/src/hampagent/sessions.js

@@ -1,62 +0,0 @@
-/**
- * Hampagent session persistence.
- * Stores conversation history per-agent as JSON in ~/.agentforge/hampagent-sessions/
- * Sessions survive worker restarts and accumulate context over time.
- */
-
-import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs';
-import path from 'path';
-import { homedir } from 'os';
-
-const SESSIONS_DIR = path.join(homedir(), '.agentforge', 'hampagent-sessions');
-// Keep last 30 messages (~15 turns) to stay within context limits
-const MAX_MESSAGES = 30;
-
-function dir() {
-  mkdirSync(SESSIONS_DIR, { recursive: true });
-  return SESSIONS_DIR;
-}
-
-function file(agentId) {
-  return path.join(dir(), `${agentId}.json`);
-}
-
-/** Load the claude CLI session ID for an agent (for --resume) */
-export function loadSessionId(agentId) {
-  const p = file(agentId);
-  if (!existsSync(p)) return null;
-  try {
-    const d = JSON.parse(readFileSync(p, 'utf8'));
-    return d.claudeSessionId || null;
-  } catch {
-    return null;
-  }
-}
-
-/** Save the claude CLI session ID after a completed task */
-export function saveSessionId(agentId, claudeSessionId) {
-  writeFileSync(file(agentId), JSON.stringify({
-    agentId,
-    claudeSessionId,
-    savedAt: new Date().toISOString(),
-  }, null, 2));
-}
-
-/** Legacy compat — kept so worker.js hasSession check doesn't break */
-export function hasSession(agentId) {
-  const p = file(agentId);
-  if (!existsSync(p)) return false;
-  try {
-    const d = JSON.parse(readFileSync(p, 'utf8'));
-    return !!(d.claudeSessionId);
-  } catch { return false; }
-}
-
-export function clearSession(agentId) {
-  const p = file(agentId);
-  if (existsSync(p)) writeFileSync(p, JSON.stringify({ agentId, claudeSessionId: null, savedAt: new Date().toISOString() }));
-}
-
-// Legacy exports kept for any stale imports
-export function loadMessages() { return []; }
-export function saveMessages() {}

package/src/hampagent/tools.js

@@ -1,298 +0,0 @@
-/**
- * Hampagent tool definitions + implementations.
- * Matches openclaw's tool surface area, optimized for AgentForge.
- */
-
-import { spawn, execSync } from 'child_process';
-import { readFileSync, writeFileSync, mkdirSync, existsSync, readdirSync, statSync } from 'fs';
-import path from 'path';
-import { browserAction } from './browser.js';
-
-// ── Tool schema definitions (Anthropic tool_use format) ────────────────────
-
-export const TOOLS = [
-  {
-    name: 'bash',
-    description: 'Execute shell commands on the user\'s Mac. Returns stdout + stderr. Use for: running scripts, installing packages, git operations, checking system state, serving files, running processes. Commands run in the task working directory.',
-    input_schema: {
-      type: 'object',
-      properties: {
-        command: { type: 'string', description: 'Shell command to execute' },
-        timeout_ms: { type: 'number', description: 'Timeout in ms (default 30000, max 300000 for long builds)' }
-      },
-      required: ['command']
-    }
-  },
-  {
-    name: 'read',
-    description: 'Read a file. Returns contents with line numbers. Use offset+limit for large files.',
-    input_schema: {
-      type: 'object',
-      properties: {
-        file_path: { type: 'string', description: 'Path to file (absolute or relative to working dir)' },
-        offset: { type: 'number', description: 'Start line, 1-indexed (default: 1)' },
-        limit: { type: 'number', description: 'Max lines to return (default: all)' }
-      },
-      required: ['file_path']
-    }
-  },
-  {
-    name: 'write',
-    description: 'Write content to a file. Creates parent directories automatically.',
-    input_schema: {
-      type: 'object',
-      properties: {
-        file_path: { type: 'string' },
-        content: { type: 'string' }
-      },
-      required: ['file_path', 'content']
-    }
-  },
-  {
-    name: 'edit',
-    description: 'Replace exact text in a file. old_string must match exactly (whitespace included). Fails if not found or not unique — use read first to verify.',
-    input_schema: {
-      type: 'object',
-      properties: {
-        file_path: { type: 'string' },
-        old_string: { type: 'string', description: 'Exact text to find — must be unique in the file' },
-        new_string: { type: 'string', description: 'Replacement text' },
-        replace_all: { type: 'boolean', description: 'Replace all occurrences (default false)' }
-      },
-      required: ['file_path', 'old_string', 'new_string']
-    }
-  },
-  {
-    name: 'glob',
-    description: 'Find files matching a pattern. Returns file paths sorted by modification time.',
-    input_schema: {
-      type: 'object',
-      properties: {
-        pattern: { type: 'string', description: 'Glob pattern e.g. "**/*.js", "src/**/*.ts", "*.json"' },
-        path: { type: 'string', description: 'Directory to search in (default: working dir)' }
-      },
-      required: ['pattern']
-    }
-  },
-  {
-    name: 'grep',
-    description: 'Search file contents with regex. Returns matching lines with file:line format.',
-    input_schema: {
-      type: 'object',
-      properties: {
-        pattern: { type: 'string', description: 'Regex pattern to search for' },
-        path: { type: 'string', description: 'File or directory to search (default: working dir)' },
-        glob: { type: 'string', description: 'File filter pattern e.g. "*.js", "*.{ts,tsx}"' },
-        output_mode: { type: 'string', enum: ['content', 'files_with_matches', 'count'], description: 'Output format (default: content)' },
-        '-i': { type: 'boolean', description: 'Case insensitive' },
-        '-A': { type: 'number', description: 'Lines after match' },
-        '-B': { type: 'number', description: 'Lines before match' }
-      },
-      required: ['pattern']
-    }
-  },
-  {
-    name: 'browser',
-    description: 'Control AgentForge Browser (Chrome, already open on port 9223, logged into user\'s services). Use for ALL web tasks — browsing, searching, filling forms, clicking UI. Do NOT use curl/wget for web pages.',
-    input_schema: {
-      type: 'object',
-      properties: {
-        action: {
-          type: 'string',
-          enum: ['navigate', 'open', 'click', 'type', 'act', 'scroll', 'screenshot', 'snapshot', 'evaluate', 'back', 'forward', 'wait', 'url'],
-          description: 'navigate/open: go to URL | snapshot: get page content + interactive elements | click: click element | type: enter text | screenshot: capture page | evaluate: run JS | act: ref-based click/type from snapshot'
-        },
-        url: { type: 'string', description: 'URL for navigate/open' },
-        targetUrl: { type: 'string', description: 'URL alias for open action' },
-        selector: { type: 'string', description: 'CSS selector for click/type' },
-        ref: { description: 'Element index from snapshot for click/act' },
-        text: { type: 'string', description: 'Text for type action' },
-        script: { type: 'string', description: 'JavaScript to evaluate' },
-        expression: { type: 'string', description: 'JS expression alias' },
-        x: { type: 'number', description: 'X coordinate for click' },
-        y: { type: 'number', description: 'Y coordinate for click' },
-        ms: { type: 'number', description: 'Milliseconds for wait' },
-        request: {
-          type: 'object',
-          description: 'For act action: {kind: "click"|"type", ref: elementIndex, text: "..."}',
-          properties: {
-            kind: { type: 'string' },
-            ref: {},
-            selector: { type: 'string' },
-            text: { type: 'string' }
-          }
-        }
-      },
-      required: ['action']
-    }
-  }
-];
-
-// ── Tool implementations ────────────────────────────────────────────────────
-
-export async function executeTool(name, input, ctx) {
-  const { taskCwd, workDir, agentId, onImage } = ctx;
-
-  switch (name) {
-
-    case 'bash': {
-      const timeout = Math.min(input.timeout_ms || 30000, 300000);
-      return new Promise((resolve) => {
-        let out = '';
-        const proc = spawn('bash', ['-c', input.command], {
-          cwd: taskCwd,
-          env: { ...process.env, TERM: 'dumb' },
-        });
-
-        const timer = setTimeout(() => {
-          proc.kill('SIGKILL');
-          resolve(out ? `[timeout after ${timeout}ms]\n${out}` : `[timeout after ${timeout}ms]`);
-        }, timeout);
-
-        proc.stdout.on('data', d => { out += d.toString(); });
-        proc.stderr.on('data', d => { out += d.toString(); });
-
-        proc.on('close', (code) => {
-          clearTimeout(timer);
-          // Check for AGENTFORGE_IMAGE protocol
-          const lines = out.split('\n');
-          const filtered = [];
-          for (const line of lines) {
-            if (line.trim().startsWith('AGENTFORGE_IMAGE:')) {
-              const imgPath = line.trim().slice('AGENTFORGE_IMAGE:'.length).trim();
-              if (onImage && existsSync(imgPath)) {
-                try {
-                  const data = readFileSync(imgPath);
-                  const ext = imgPath.split('.').pop().toLowerCase();
-                  const mime = ext === 'jpg' || ext === 'jpeg' ? 'image/jpeg' : ext === 'gif' ? 'image/gif' : 'image/png';
-                  onImage(`data:${mime};base64,${data.toString('base64')}`);
-                } catch (e) { /* ignore */ }
-              }
-            } else {
-              filtered.push(line);
-            }
-          }
-          const result = filtered.join('\n').trimEnd();
-          resolve(result || `Exit ${code}`);
-        });
-        proc.on('error', (err) => { clearTimeout(timer); resolve(`Error: ${err.message}`); });
-      });
-    }
-
-    case 'read': {
-      const fp = resolveFile(input.file_path, taskCwd);
-      if (!existsSync(fp)) return `File not found: ${fp}`;
-      try {
-        const lines = readFileSync(fp, 'utf8').split('\n');
-        const start = Math.max(0, (input.offset || 1) - 1);
-        const end = input.limit ? start + input.limit : lines.length;
-        const slice = lines.slice(start, end);
-        return slice.map((l, i) => `${String(start + i + 1).padStart(6)} ${l}`).join('\n');
-      } catch (e) {
-        return `Error reading ${fp}: ${e.message}`;
-      }
-    }
-
-    case 'write': {
-      const fp = resolveFile(input.file_path, taskCwd);
-      try {
-        mkdirSync(path.dirname(fp), { recursive: true });
-        writeFileSync(fp, input.content, 'utf8');
-        return `Written ${input.content.length} bytes to ${fp}`;
-      } catch (e) {
-        return `Error writing ${fp}: ${e.message}`;
-      }
-    }
-
-    case 'edit': {
-      const fp = resolveFile(input.file_path, taskCwd);
-      if (!existsSync(fp)) return `File not found: ${fp}`;
-      try {
-        const content = readFileSync(fp, 'utf8');
-        const count = content.split(input.old_string).length - 1;
-        if (count === 0) return `Error: old_string not found in ${fp}\nFirst 200 chars of file:\n${content.slice(0, 200)}`;
-        if (count > 1 && !input.replace_all) return `Error: old_string found ${count} times — must be unique, or set replace_all: true`;
-        const newContent = input.replace_all
-          ? content.split(input.old_string).join(input.new_string)
-          : content.replace(input.old_string, input.new_string);
-        writeFileSync(fp, newContent, 'utf8');
-        return `Edited ${fp} (${count} replacement${count > 1 ? 's' : ''})`;
-      } catch (e) {
-        return `Error editing ${fp}: ${e.message}`;
-      }
-    }
-
-    case 'glob': {
-      const searchDir = input.path ? resolveFile(input.path, taskCwd) : taskCwd;
-      try {
-        // Use bash find + glob expansion for maximum compatibility
-        const pattern = input.pattern;
-        const cmd = `cd ${JSON.stringify(searchDir)} && find . -type f | grep -E ${JSON.stringify(globToRegex(pattern))} | sort -t'/' -k2 | head -200`;
-        const result = execSync(cmd, { cwd: searchDir, timeout: 10000 }).toString().trim();
-        if (!result) return '(no matches)';
-        return result.split('\n').map(f => f.replace(/^\.\//, '')).join('\n');
-      } catch {
-        try {
-          // Fallback: simple find
-          const result = execSync(`find ${JSON.stringify(searchDir)} -name "${input.pattern.replace(/\*\*\//g, '').split('/').pop()}" 2>/dev/null | head -100`, { timeout: 8000 }).toString().trim();
-          return result || '(no matches)';
-        } catch { return '(no matches)'; }
-      }
-    }
-
-    case 'grep': {
-      const searchPath = input.path ? resolveFile(input.path, taskCwd) : taskCwd;
-      const flags = ['-n', '--color=never'];
-      if (input['-i']) flags.push('-i');
-      if (input['-A']) flags.push(`-A${input['-A']}`);
-      if (input['-B']) flags.push(`-B${input['-B']}`);
-      if (input.glob) flags.push(`--include=${input.glob}`);
-      if (input.output_mode === 'files_with_matches') flags.push('-l');
-      if (input.output_mode === 'count') flags.push('-c');
-      flags.push('-r');
-      try {
-        const result = execSync(`grep ${flags.join(' ')} ${JSON.stringify(input.pattern)} ${JSON.stringify(searchPath)} 2>/dev/null | head -200`, { timeout: 15000 }).toString().trim();
-        return result || '(no matches)';
-      } catch {
-        return '(no matches)';
-      }
-    }
-
-    case 'browser': {
-      const result = await browserAction(input);
-      // Handle screenshot result — save to workspace and emit image
-      if (result && result.__screenshot) {
-        const imgPath = path.join(workDir || taskCwd, `browser_screenshot_${Date.now()}.png`);
-        try {
-          mkdirSync(path.dirname(imgPath), { recursive: true });
-          writeFileSync(imgPath, Buffer.from(result.base64, 'base64'));
-          if (onImage) onImage(`data:image/png;base64,${result.base64}`);
-          return `Screenshot saved to ${imgPath}. Image sent to chat.`;
-        } catch (e) {
-          if (onImage) onImage(`data:image/png;base64,${result.base64}`);
-          return `Screenshot taken (${Math.round(result.base64.length * 0.75 / 1024)}KB)`;
-        }
-      }
-      return result;
-    }
-
-    default:
-      return `Unknown tool: ${name}`;
-  }
-}
-
-// ── Helpers ─────────────────────────────────────────────────────────────────
-
-function resolveFile(filePath, cwd) {
-  if (path.isAbsolute(filePath)) return filePath;
-  return path.join(cwd || process.cwd(), filePath);
-}
-
-function globToRegex(pattern) {
-  // Convert glob pattern to regex for grep filtering
-  return pattern
-    .replace(/\./g, '\\.')
-    .replace(/\*\*/g, '.*')
-    .replace(/\*/g, '[^/]*')
-    .replace(/\?/g, '[^/]');
-}