koneck 1.0.0

package/dist/tools.js

@@ -0,0 +1,713 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { globby } from 'globby';
+import { execa } from 'execa';
+import * as diffLib from 'diff';
+import { validateCode } from './astValidator.js';
+import { tui } from './tui.js';
+import { appendMemory } from './memory.js';
+import { GIT_TOOL_DEFINITIONS, dispatchGitTool } from './git-tools.js';
+export const TOOL_DEFINITIONS = [
+    {
+        name: 'read_files',
+        description: 'Read one or more files concurrently. Returns content with line numbers. Use for any file inspection.',
+        parameters: {
+            type: 'object',
+            properties: {
+                paths: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'File paths to read (absolute or relative to cwd)',
+                },
+            },
+            required: ['paths'],
+        },
+    },
+    {
+        name: 'write_file',
+        description: 'Write full content to a file. For TypeScript/JavaScript files, syntax is validated before writing. Creates parent directories as needed.',
+        parameters: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'Target file path' },
+                content: { type: 'string', description: 'Complete file content to write' },
+            },
+            required: ['path', 'content'],
+        },
+    },
+    {
+        name: 'apply_diff',
+        description: 'Apply a unified diff patch to a file for surgical line-level modifications. Preferred over write_file for partial changes.',
+        parameters: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'File path to patch' },
+                diff: {
+                    type: 'string',
+                    description: 'Unified diff content in --- a/file +++ b/file @@ ... format',
+                },
+            },
+            required: ['path', 'diff'],
+        },
+    },
+    {
+        name: 'execute_command',
+        description: 'Run a shell command with configurable timeout. Captures stdout+stderr. Use for builds, tests, installs, git ops.',
+        parameters: {
+            type: 'object',
+            properties: {
+                command: { type: 'string', description: 'Bash command to execute' },
+                timeout: {
+                    type: 'number',
+                    description: 'Timeout in milliseconds (default 30000)',
+                },
+                cwd: {
+                    type: 'string',
+                    description: 'Working directory override (relative to project cwd)',
+                },
+            },
+            required: ['command'],
+        },
+    },
+    {
+        name: 'list_dir',
+        description: 'List directory contents. Set recursive=true for full tree view.',
+        parameters: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'Directory path to list' },
+                recursive: {
+                    type: 'boolean',
+                    description: 'List recursively (default false)',
+                },
+            },
+            required: ['path'],
+        },
+    },
+    {
+        name: 'glob_search',
+        description: 'Search for files matching a glob pattern. Respects .gitignore. Returns matching paths.',
+        parameters: {
+            type: 'object',
+            properties: {
+                pattern: {
+                    type: 'string',
+                    description: 'Glob pattern e.g. "src/**/*.ts", "**/*.json"',
+                },
+                cwd: {
+                    type: 'string',
+                    description: 'Base directory for search (default: project cwd)',
+                },
+            },
+            required: ['pattern'],
+        },
+    },
+    {
+        name: 'grep_search',
+        description: 'Search file contents for a regex or literal pattern. Uses ripgrep when available, falls back to grep. Returns file:line:match results.',
+        parameters: {
+            type: 'object',
+            properties: {
+                pattern: { type: 'string', description: 'Search pattern (regex or literal string)' },
+                path: {
+                    type: 'string',
+                    description: 'Directory or file to search (default: project cwd)',
+                },
+                file_pattern: {
+                    type: 'string',
+                    description: 'Glob to restrict file types e.g. "*.ts"',
+                },
+                case_sensitive: {
+                    type: 'boolean',
+                    description: 'Case-sensitive match (default: false)',
+                },
+                max_results: {
+                    type: 'number',
+                    description: 'Maximum lines to return (default: 50)',
+                },
+            },
+            required: ['pattern'],
+        },
+    },
+    {
+        name: 'move_file',
+        description: 'Move or rename a file or directory. Creates destination parent dirs as needed.',
+        parameters: {
+            type: 'object',
+            properties: {
+                source: { type: 'string', description: 'Source path' },
+                destination: { type: 'string', description: 'Destination path' },
+            },
+            required: ['source', 'destination'],
+        },
+    },
+    {
+        name: 'delete_file',
+        description: 'Delete a file or directory. Requires recursive=true to delete directories.',
+        parameters: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'Path to delete' },
+                recursive: {
+                    type: 'boolean',
+                    description: 'Delete directory and all contents (default: false)',
+                },
+            },
+            required: ['path'],
+        },
+    },
+    {
+        name: 'search_replace',
+        description: 'Find an exact string in a file and replace it. More reliable than apply_diff for targeted edits. ' +
+            'The search string must match exactly — whitespace and indentation included. ' +
+            'Returns an error if the search string is not found.',
+        parameters: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'File to edit' },
+                search: {
+                    type: 'string',
+                    description: 'Exact string to find (must match character-for-character)',
+                },
+                replace: {
+                    type: 'string',
+                    description: 'String to substitute in place of the search string',
+                },
+                replace_all: {
+                    type: 'boolean',
+                    description: 'Replace every occurrence, not just the first (default: false)',
+                },
+            },
+            required: ['path', 'search', 'replace'],
+        },
+    },
+    {
+        name: 'fetch_url',
+        description: 'Fetch the content of a URL. HTML is stripped to readable text. ' +
+            'Use to look up documentation, GitHub issues, changelogs, or any web resource.',
+        parameters: {
+            type: 'object',
+            properties: {
+                url: { type: 'string', description: 'URL to fetch (http or https)' },
+                max_chars: {
+                    type: 'number',
+                    description: 'Maximum characters to return (default: 20000)',
+                },
+            },
+            required: ['url'],
+        },
+    },
+    {
+        name: 'remember',
+        description: 'Persist a fact or decision to .koneck/MEMORY.md so it is available in future sessions. ' +
+            'Use for architecture decisions, recurring commands, project conventions, known bugs, or anything worth retaining across sessions.',
+        parameters: {
+            type: 'object',
+            properties: {
+                content: { type: 'string', description: 'The information to remember' },
+                category: {
+                    type: 'string',
+                    description: 'Category tag: architecture | commands | conventions | bugs | notes (default: notes)',
+                },
+            },
+            required: ['content'],
+        },
+    },
+    {
+        name: 'web_search',
+        description: 'Search the web for current information: docs, package changelogs, error messages, RFCs. ' +
+            'Requires BRAVE_API_KEY or SERPER_API_KEY environment variable.',
+        parameters: {
+            type: 'object',
+            properties: {
+                query: { type: 'string', description: 'Search query' },
+                num_results: {
+                    type: 'number',
+                    description: 'Number of results to return (default: 5, max: 10)',
+                },
+            },
+            required: ['query'],
+        },
+    },
+    {
+        name: 'spawn_agents',
+        description: 'Fan out up to 8 parallel sub-agents, each working on an independent task in its own git worktree. ' +
+            'Use for large refactors that can be split into independent pieces running concurrently. ' +
+            'Each agent result is returned as a summary. Cannot be called from within a sub-agent.',
+        parameters: {
+            type: 'object',
+            properties: {
+                tasks: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'List of task descriptions — one per agent (max 8)',
+                },
+                use_worktrees: {
+                    type: 'boolean',
+                    description: 'Create an isolated git worktree per agent (default: true, requires git repo)',
+                },
+                max_turns: {
+                    type: 'number',
+                    description: 'Max turns per sub-agent (default: inherits parent)',
+                },
+            },
+            required: ['tasks'],
+        },
+    },
+    ...GIT_TOOL_DEFINITIONS,
+];
+// ─── Tool handlers ────────────────────────────────────────────────────────────
+export async function readFiles(args, cwd) {
+    const results = await Promise.allSettled(args.paths.map(async (filePath) => {
+        const abs = path.resolve(cwd, filePath);
+        const content = await fs.readFile(abs, 'utf-8');
+        const numbered = content
+            .split('\n')
+            .map((line, i) => `${String(i + 1).padStart(5)} │ ${line}`)
+            .join('\n');
+        return `=== ${filePath} (${content.split('\n').length} lines) ===\n${numbered}`;
+    }));
+    return results
+        .map((r, i) => r.status === 'fulfilled'
+        ? r.value
+        : `=== ${args.paths[i]} ===\nERROR: ${r.reason instanceof Error ? r.reason.message : String(r.reason)}`)
+        .join('\n\n');
+}
+export async function writeFile(args, cwd, requireApproval) {
+    const abs = path.resolve(cwd, args.path);
+    const validation = validateCode(args.content, abs);
+    if (!validation.valid) {
+        return [
+            `ERROR: AST validation failed — ${args.path} was NOT written.`,
+            ...validation.errors.map(e => `  • ${e}`),
+        ].join('\n');
+    }
+    if (requireApproval) {
+        const approved = await tui.confirmWrite(args.path, args.content);
+        if (!approved)
+            return `Write to ${args.path} cancelled by user.`;
+    }
+    await fs.mkdir(path.dirname(abs), { recursive: true });
+    await fs.writeFile(abs, args.content, 'utf-8');
+    const lines = args.content.split('\n').length;
+    return `Wrote ${lines} lines to ${args.path}`;
+}
+export async function applyDiff(args, cwd, requireApproval) {
+    const abs = path.resolve(cwd, args.path);
+    let original = '';
+    try {
+        original = await fs.readFile(abs, 'utf-8');
+    }
+    catch {
+        // new file — empty original is valid for a diff that adds everything
+    }
+    const patched = diffLib.applyPatch(original, args.diff);
+    if (patched === false) {
+        return (`ERROR: Patch failed to apply cleanly to ${args.path}. ` +
+            `The file may have changed since the diff was generated. ` +
+            `Use read_files to get the current content and generate a fresh diff.`);
+    }
+    const validation = validateCode(patched, abs);
+    if (!validation.valid) {
+        return [
+            `ERROR: Patched result has syntax errors in ${args.path} — diff NOT applied.`,
+            ...validation.errors.map(e => `  • ${e}`),
+        ].join('\n');
+    }
+    if (requireApproval) {
+        tui.renderDiff(original, patched, args.path);
+        const approved = await tui.confirmDiff(args.path);
+        if (!approved)
+            return `Diff to ${args.path} cancelled by user.`;
+    }
+    await fs.mkdir(path.dirname(abs), { recursive: true });
+    await fs.writeFile(abs, patched, 'utf-8');
+    const changes = diffLib.diffLines(original, patched);
+    const added = changes.filter(c => c.added).reduce((n, c) => n + (c.count ?? 0), 0);
+    const removed = changes.filter(c => c.removed).reduce((n, c) => n + (c.count ?? 0), 0);
+    return `Applied diff to ${args.path}: +${added} -${removed} lines`;
+}
+export async function executeCommand(args, cwd, requireApproval) {
+    if (requireApproval) {
+        const approved = await tui.confirmCommand(args.command);
+        if (!approved)
+            return `Command cancelled by user: ${args.command}`;
+    }
+    const execCwd = args.cwd ? path.resolve(cwd, args.cwd) : cwd;
+    try {
+        const result = await execa('bash', ['-c', args.command], {
+            cwd: execCwd,
+            timeout: args.timeout ?? 30_000,
+            all: true,
+            reject: false,
+        });
+        const output = (result.all ?? '').trim();
+        const code = result.exitCode;
+        if (code !== 0) {
+            return `Exit code ${code}:\n${output || '(no output)'}`;
+        }
+        return output || '(command succeeded with no output)';
+    }
+    catch (err) {
+        if (err instanceof Error && err.message.includes('timed out')) {
+            return `ERROR: Command timed out after ${args.timeout ?? 30_000}ms`;
+        }
+        return `ERROR: ${err instanceof Error ? err.message : String(err)}`;
+    }
+}
+export async function listDir(args, cwd) {
+    const abs = path.resolve(cwd, args.path);
+    try {
+        if (args.recursive) {
+            const entries = await globby('**', {
+                cwd: abs,
+                dot: true,
+                gitignore: true,
+                onlyFiles: false,
+                markDirectories: true,
+            });
+            return entries.length > 0
+                ? entries.join('\n')
+                : '(empty directory)';
+        }
+        const entries = await fs.readdir(abs, { withFileTypes: true });
+        if (entries.length === 0)
+            return '(empty directory)';
+        const lines = await Promise.all(entries.map(async (e) => {
+            const type = e.isDirectory() ? 'd' : e.isSymbolicLink() ? 'l' : '-';
+            let size = '';
+            if (e.isFile()) {
+                try {
+                    const stat = await fs.stat(path.join(abs, e.name));
+                    size = ` (${formatBytes(stat.size)})`;
+                }
+                catch {
+                    /* best-effort */
+                }
+            }
+            return `${type} ${e.name}${e.isDirectory() ? '/' : ''}${size}`;
+        }));
+        return lines.join('\n');
+    }
+    catch (err) {
+        return `ERROR: ${err instanceof Error ? err.message : String(err)}`;
+    }
+}
+export async function globSearch(args, cwd) {
+    const base = args.cwd ? path.resolve(cwd, args.cwd) : cwd;
+    try {
+        const files = await globby(args.pattern, {
+            cwd: base,
+            dot: true,
+            gitignore: true,
+        });
+        if (files.length === 0) {
+            return `No files match: ${args.pattern}`;
+        }
+        return `${files.length} match(es):\n${files.join('\n')}`;
+    }
+    catch (err) {
+        return `ERROR: ${err instanceof Error ? err.message : String(err)}`;
+    }
+}
+function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes}B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)}KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}
+function isENOENT(err) {
+    return (err instanceof Error &&
+        'code' in err &&
+        err.code === 'ENOENT');
+}
+export async function grepSearch(args, cwd) {
+    const searchPath = args.path ? path.resolve(cwd, args.path) : cwd;
+    const maxResults = args.max_results ?? 50;
+    // Try ripgrep first — much faster on large repos
+    try {
+        const rgArgs = ['--line-number', '--no-heading', '--color=never'];
+        if (!args.case_sensitive)
+            rgArgs.push('--ignore-case');
+        if (args.file_pattern)
+            rgArgs.push('--glob', args.file_pattern);
+        rgArgs.push(args.pattern, searchPath);
+        const result = await execa('rg', rgArgs, { reject: false, all: true });
+        const lines = (result.all ?? '').split('\n').filter(Boolean);
+        if (result.exitCode === 1 && lines.length === 0)
+            return 'No matches found.';
+        if (result.exitCode === 0 || lines.length > 0) {
+            const truncated = lines.slice(0, maxResults);
+            const suffix = lines.length > maxResults ? `\n(showing ${maxResults} of ${lines.length} matches)` : '';
+            return truncated.join('\n') + suffix;
+        }
+    }
+    catch (err) {
+        if (!isENOENT(err)) {
+            return `ERROR: ${err instanceof Error ? err.message : String(err)}`;
+        }
+        // ripgrep not installed — fall through to grep
+    }
+    // Fallback: POSIX grep
+    try {
+        const grepArgs = ['-rn', '--color=never'];
+        if (!args.case_sensitive)
+            grepArgs.push('-i');
+        if (args.file_pattern)
+            grepArgs.push(`--include=${args.file_pattern}`);
+        grepArgs.push(args.pattern, searchPath);
+        const result = await execa('grep', grepArgs, { reject: false, all: true });
+        const lines = (result.all ?? '').split('\n').filter(Boolean);
+        if (result.exitCode === 1 && lines.length === 0)
+            return 'No matches found.';
+        const truncated = lines.slice(0, maxResults);
+        const suffix = lines.length > maxResults ? `\n(showing ${maxResults} of ${lines.length} matches)` : '';
+        return truncated.join('\n') + suffix;
+    }
+    catch (err) {
+        return `ERROR: ${err instanceof Error ? err.message : String(err)}`;
+    }
+}
+export async function moveFile(args, cwd) {
+    const src = path.resolve(cwd, args.source);
+    const dst = path.resolve(cwd, args.destination);
+    try {
+        await fs.mkdir(path.dirname(dst), { recursive: true });
+        await fs.rename(src, dst);
+        return `Moved ${args.source} → ${args.destination}`;
+    }
+    catch (err) {
+        if (err instanceof Error &&
+            'code' in err &&
+            err.code === 'EXDEV') {
+            // Cross-device: copy then delete
+            await fs.copyFile(src, dst);
+            await fs.unlink(src);
+            return `Moved ${args.source} → ${args.destination}`;
+        }
+        return `ERROR: ${err instanceof Error ? err.message : String(err)}`;
+    }
+}
+export async function deleteFile(args, cwd, requireApproval) {
+    const abs = path.resolve(cwd, args.path);
+    try {
+        const stat = await fs.stat(abs);
+        if (stat.isDirectory() && !args.recursive) {
+            return `ERROR: ${args.path} is a directory. Pass recursive=true to delete it.`;
+        }
+    }
+    catch {
+        return `ERROR: ${args.path} does not exist.`;
+    }
+    if (requireApproval) {
+        const approved = await tui.confirmDelete(args.path, args.recursive ?? false);
+        if (!approved)
+            return `Delete of ${args.path} cancelled by user.`;
+    }
+    try {
+        const stat = await fs.stat(abs);
+        if (stat.isDirectory()) {
+            await fs.rm(abs, { recursive: true, force: true });
+            return `Deleted directory ${args.path}`;
+        }
+        await fs.unlink(abs);
+        return `Deleted ${args.path}`;
+    }
+    catch (err) {
+        return `ERROR: ${err instanceof Error ? err.message : String(err)}`;
+    }
+}
+function countOccurrences(text, search) {
+    let count = 0;
+    let pos = 0;
+    while (true) {
+        pos = text.indexOf(search, pos);
+        if (pos === -1)
+            break;
+        count++;
+        pos += search.length;
+    }
+    return count;
+}
+export async function searchReplace(args, cwd, requireApproval) {
+    const abs = path.resolve(cwd, args.path);
+    let original;
+    try {
+        original = await fs.readFile(abs, 'utf-8');
+    }
+    catch {
+        return `ERROR: Cannot read ${args.path} — file does not exist.`;
+    }
+    const occurrences = countOccurrences(original, args.search);
+    if (occurrences === 0) {
+        return (`ERROR: Search string not found in ${args.path}.\n` +
+            `Tip: use read_files to get the exact current content, then retry with the precise text.`);
+    }
+    const patched = args.replace_all
+        ? original.split(args.search).join(args.replace)
+        : original.replace(args.search, args.replace);
+    const validation = validateCode(patched, abs);
+    if (!validation.valid) {
+        return [
+            `ERROR: Result has syntax errors in ${args.path} — not written.`,
+            ...validation.errors.map(e => `  • ${e}`),
+        ].join('\n');
+    }
+    if (requireApproval) {
+        tui.renderDiff(original, patched, args.path);
+        const approved = await tui.confirmDiff(args.path);
+        if (!approved)
+            return `Search-replace in ${args.path} cancelled by user.`;
+    }
+    await fs.writeFile(abs, patched, 'utf-8');
+    const replaced = args.replace_all ? occurrences : 1;
+    const skipped = args.replace_all ? 0 : occurrences - 1;
+    const note = skipped > 0 ? ` (${skipped} additional occurrence(s) left unchanged — pass replace_all:true to replace all)` : '';
+    return `Replaced ${replaced} occurrence(s) in ${args.path}${note}`;
+}
+// ─── fetch_url ────────────────────────────────────────────────────────────────
+function stripHtml(html) {
+    return html
+        .replace(/<script[\s\S]*?<\/script>/gi, '')
+        .replace(/<style[\s\S]*?<\/style>/gi, '')
+        .replace(/<[^>]+>/g, ' ')
+        .replace(/&nbsp;/g, ' ')
+        .replace(/&amp;/g, '&')
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&quot;/g, '"')
+        .replace(/&#39;/g, "'")
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+export async function fetchUrl(args) {
+    const maxChars = args.max_chars ?? 20_000;
+    try {
+        const response = await fetch(args.url, {
+            headers: { 'User-Agent': 'KONECK/1.0 (AI coding agent)' },
+            signal: AbortSignal.timeout(15_000),
+        });
+        if (!response.ok) {
+            return `ERROR: HTTP ${response.status} ${response.statusText} fetching ${args.url}`;
+        }
+        const contentType = response.headers.get('content-type') ?? '';
+        const raw = await response.text();
+        let text = contentType.includes('text/html') ? stripHtml(raw) : raw;
+        text = text.replace(/\s+/g, ' ').trim();
+        if (text.length > maxChars) {
+            return text.slice(0, maxChars) + `\n\n[truncated — ${text.length} chars total, showing first ${maxChars}]`;
+        }
+        return text || '(empty response)';
+    }
+    catch (err) {
+        return `ERROR: ${err instanceof Error ? err.message : String(err)}`;
+    }
+}
+// ─── web_search ───────────────────────────────────────────────────────────────
+async function braveSearch(query, n, key) {
+    const url = 'https://api.search.brave.com/res/v1/web/search?q=' +
+        encodeURIComponent(query) + '&count=' + String(n);
+    const res = await fetch(url, {
+        headers: { Accept: 'application/json', 'X-Subscription-Token': key },
+        signal: AbortSignal.timeout(10_000),
+    });
+    if (!res.ok)
+        return `ERROR: Brave Search returned HTTP ${res.status}`;
+    const data = await res.json();
+    const results = data.web?.results ?? [];
+    if (results.length === 0)
+        return 'No results found.';
+    return results
+        .map((r, i) => `${i + 1}. ${r.title}\n   ${r.url}\n   ${r.description ?? ''}`)
+        .join('\n\n');
+}
+async function serperSearch(query, n, key) {
+    const res = await fetch('https://google.serper.dev/search', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', 'X-API-KEY': key },
+        body: JSON.stringify({ q: query, num: n }),
+        signal: AbortSignal.timeout(10_000),
+    });
+    if (!res.ok)
+        return `ERROR: Serper returned HTTP ${res.status}`;
+    const data = await res.json();
+    const results = data.organic ?? [];
+    if (results.length === 0)
+        return 'No results found.';
+    return results
+        .map((r, i) => `${i + 1}. ${r.title}\n   ${r.link}\n   ${r.snippet ?? ''}`)
+        .join('\n\n');
+}
+export async function webSearch(args) {
+    const n = Math.min(args.num_results ?? 5, 10);
+    const braveKey = process.env['BRAVE_API_KEY'];
+    if (braveKey) {
+        try {
+            return await braveSearch(args.query, n, braveKey);
+        }
+        catch (err) {
+            return `ERROR: ${err instanceof Error ? err.message : String(err)}`;
+        }
+    }
+    const serperKey = process.env['SERPER_API_KEY'];
+    if (serperKey) {
+        try {
+            return await serperSearch(args.query, n, serperKey);
+        }
+        catch (err) {
+            return `ERROR: ${err instanceof Error ? err.message : String(err)}`;
+        }
+    }
+    return ('ERROR: No search API configured. ' +
+        'Set BRAVE_API_KEY (https://api.search.brave.com) or ' +
+        'SERPER_API_KEY (https://serper.dev) to enable web_search.');
+}
+// ─── remember ─────────────────────────────────────────────────────────────────
+export async function remember(args, cwd) {
+    await appendMemory(cwd, args.content, args.category ?? 'notes');
+    return `Remembered (${args.category ?? 'notes'}): ${args.content.slice(0, 100)}`;
+}
+// ─── Dispatcher ───────────────────────────────────────────────────────────────
+export async function dispatchTool(name, argsJson, cwd, requireApproval) {
+    let parsed;
+    try {
+        parsed = JSON.parse(argsJson);
+    }
+    catch {
+        return `ERROR: Malformed JSON arguments for tool "${name}": ${argsJson.slice(0, 200)}`;
+    }
+    switch (name) {
+        case 'read_files':
+            return readFiles(parsed, cwd);
+        case 'write_file':
+            return writeFile(parsed, cwd, requireApproval);
+        case 'apply_diff':
+            return applyDiff(parsed, cwd, requireApproval);
+        case 'execute_command':
+            return executeCommand(parsed, cwd, requireApproval);
+        case 'list_dir':
+            return listDir(parsed, cwd);
+        case 'glob_search':
+            return globSearch(parsed, cwd);
+        case 'grep_search':
+            return grepSearch(parsed, cwd);
+        case 'move_file':
+            return moveFile(parsed, cwd);
+        case 'delete_file':
+            return deleteFile(parsed, cwd, requireApproval);
+        case 'search_replace':
+            return searchReplace(parsed, cwd, requireApproval);
+        case 'fetch_url':
+            return fetchUrl(parsed);
+        case 'remember':
+            return remember(parsed, cwd);
+        case 'web_search':
+            return webSearch(parsed);
+        default:
+            if (name.startsWith('git_'))
+                return dispatchGitTool(name, argsJson, cwd);
+            return `ERROR: Unknown tool "${name}"`;
+    }
+}
+//# sourceMappingURL=tools.js.map