codemeld 2.1.0

package/dist/tui/tools.js

@@ -0,0 +1,1370 @@
+/**
+ * Full-powered tool suite for the TUI chat agent.
+ * Mirrors Claude Code's capabilities: file I/O, glob, grep, edit,
+ * bash, git, npm, tree, and more.
+ */
+import { readFile, writeFile, readdir, stat, mkdir, unlink, rename, copyFile } from 'fs/promises';
+import { join, extname, dirname } from 'path';
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+import { generateDesignGuide, getFallbackGuide } from './design-guide.js';
+const execFileAsync = promisify(execFile);
+const SHELL_OPTS = { shell: true };
+const IS_WIN = process.platform === 'win32';
+const TODO_FILE = '.todos.json';
+async function loadTodos(projectDir) {
+    const filePath = join(projectDir, TODO_FILE);
+    try {
+        const raw = await readFile(filePath, 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return { nextId: 1, items: [] };
+    }
+}
+async function saveTodos(projectDir, store) {
+    const filePath = join(projectDir, TODO_FILE);
+    await writeFile(filePath, JSON.stringify(store, null, 2), 'utf-8');
+}
+const STATUS_ICONS = {
+    pending: '○',
+    in_progress: '◐',
+    done: '●',
+    blocked: '✗',
+};
+const PRIORITY_LABELS = {
+    high: '🔴 HIGH',
+    medium: '🟡 MED',
+    low: '🔵 LOW',
+};
+function formatTodoItem(item, indent = '') {
+    const icon = STATUS_ICONS[item.status] || '?';
+    const pri = PRIORITY_LABELS[item.priority] || item.priority;
+    const statusLabel = item.status === 'done' ? '✓ done' : item.status === 'blocked' ? '✗ blocked' : item.status;
+    let line = `${indent}${icon} #${item.id}  [${pri}]  ${item.title}  (${statusLabel})`;
+    if (item.description) {
+        line += `\n${indent}   ${item.description}`;
+    }
+    return line;
+}
+function formatTodoList(store, filter) {
+    let items = store.items;
+    if (filter && filter !== 'all') {
+        items = items.filter(i => i.status === filter);
+    }
+    if (items.length === 0) {
+        return filter && filter !== 'all'
+            ? `No ${filter} todos.`
+            : 'No todos yet. Use todo_add to create tasks.';
+    }
+    // Group by status
+    const groups = {};
+    for (const item of items) {
+        if (!groups[item.status])
+            groups[item.status] = [];
+        groups[item.status].push(item);
+    }
+    const lines = [];
+    const order = ['in_progress', 'pending', 'blocked', 'done'];
+    // Summary
+    const total = store.items.length;
+    const done = store.items.filter(i => i.status === 'done').length;
+    const progress = total > 0 ? Math.round((done / total) * 100) : 0;
+    const bar = '█'.repeat(Math.floor(progress / 5)) + '░'.repeat(20 - Math.floor(progress / 5));
+    lines.push(`Progress: [${bar}] ${done}/${total} (${progress}%)\n`);
+    for (const status of order) {
+        const group = groups[status];
+        if (!group || group.length === 0)
+            continue;
+        lines.push(`── ${status.toUpperCase().replace('_', ' ')} (${group.length}) ──`);
+        // Separate top-level and subtasks
+        const topLevel = group.filter(i => !i.parentId);
+        const subtasks = group.filter(i => i.parentId);
+        for (const item of topLevel) {
+            lines.push(formatTodoItem(item));
+            // Show subtasks under parent
+            const children = subtasks.filter(s => s.parentId === item.id);
+            for (const child of children) {
+                lines.push(formatTodoItem(child, '    '));
+            }
+        }
+        // Orphaned subtasks (parent not in this group)
+        const shownChildIds = new Set(topLevel.flatMap(p => subtasks.filter(s => s.parentId === p.id).map(s => s.id)));
+        for (const sub of subtasks) {
+            if (!shownChildIds.has(sub.id)) {
+                lines.push(formatTodoItem(sub, '    '));
+            }
+        }
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+// ─── Tool Definitions (sent to AI API) ──────────────────────────────
+export const chatToolDefinitions = [
+    // ── File Reading ──────────────────────────────────────────────
+    {
+        type: 'function',
+        function: {
+            name: 'read_file',
+            description: 'Read a file with line numbers. Returns max 200 lines per call. For larger files, use offset and limit to page through in chunks. Always shows total line count so you know if there is more to read.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: {
+                        type: 'string',
+                        description: 'Relative file path (e.g., "src/App.tsx", "package.json")',
+                    },
+                    offset: {
+                        type: 'number',
+                        description: 'Start reading from this line number (1-based). Default: 1.',
+                    },
+                    limit: {
+                        type: 'number',
+                        description: 'Number of lines to read, max 200. Default: 200.',
+                    },
+                },
+                required: ['path'],
+            },
+        },
+    },
+    // ── File Writing ──────────────────────────────────────────────
+    {
+        type: 'function',
+        function: {
+            name: 'write_file',
+            description: 'Create or overwrite a file with the given content. Creates parent directories automatically.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: {
+                        type: 'string',
+                        description: 'Relative file path to write',
+                    },
+                    content: {
+                        type: 'string',
+                        description: 'The complete file content',
+                    },
+                },
+                required: ['path', 'content'],
+            },
+        },
+    },
+    // ── File Editing (targeted replacement) ───────────────────────
+    {
+        type: 'function',
+        function: {
+            name: 'edit_file',
+            description: 'Make a targeted edit by finding and replacing a specific string in a file. The old_string must appear exactly once in the file (include enough context to make it unique). Use replace_all=true to replace ALL occurrences.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: {
+                        type: 'string',
+                        description: 'Relative file path',
+                    },
+                    old_string: {
+                        type: 'string',
+                        description: 'The exact text to find (must be unique unless replace_all=true)',
+                    },
+                    new_string: {
+                        type: 'string',
+                        description: 'The replacement text',
+                    },
+                    replace_all: {
+                        type: 'boolean',
+                        description: 'Replace ALL occurrences instead of requiring uniqueness (default: false)',
+                    },
+                },
+                required: ['path', 'old_string', 'new_string'],
+            },
+        },
+    },
+    // ── Multi-Edit (multiple replacements in one call) ────────────
+    {
+        type: 'function',
+        function: {
+            name: 'multi_edit',
+            description: 'Apply multiple find-and-replace edits to a file in a single operation. Each edit is applied sequentially. More efficient than multiple edit_file calls.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: {
+                        type: 'string',
+                        description: 'Relative file path',
+                    },
+                    edits: {
+                        type: 'array',
+                        items: {
+                            type: 'object',
+                            properties: {
+                                old_string: { type: 'string', description: 'Text to find' },
+                                new_string: { type: 'string', description: 'Replacement text' },
+                            },
+                            required: ['old_string', 'new_string'],
+                        },
+                        description: 'Array of {old_string, new_string} edit operations',
+                    },
+                },
+                required: ['path', 'edits'],
+            },
+        },
+    },
+    // ── Insert at Line ────────────────────────────────────────────
+    {
+        type: 'function',
+        function: {
+            name: 'insert_at_line',
+            description: 'Insert text at a specific line number in a file. The existing content at that line shifts down.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: {
+                        type: 'string',
+                        description: 'Relative file path',
+                    },
+                    line: {
+                        type: 'number',
+                        description: 'Line number to insert at (1-based). Use 1 for beginning, or a large number for end.',
+                    },
+                    content: {
+                        type: 'string',
+                        description: 'The text to insert',
+                    },
+                },
+                required: ['path', 'line', 'content'],
+            },
+        },
+    },
+    // ── File Operations (delete, move, copy) ──────────────────────
+    {
+        type: 'function',
+        function: {
+            name: 'delete_file',
+            description: 'Delete a file from the project.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: {
+                        type: 'string',
+                        description: 'Relative file path to delete',
+                    },
+                },
+                required: ['path'],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'move_file',
+            description: 'Move or rename a file. Creates destination directories automatically.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    from: {
+                        type: 'string',
+                        description: 'Current relative file path',
+                    },
+                    to: {
+                        type: 'string',
+                        description: 'New relative file path',
+                    },
+                },
+                required: ['from', 'to'],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'copy_file',
+            description: 'Copy a file to a new location.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    from: {
+                        type: 'string',
+                        description: 'Source relative file path',
+                    },
+                    to: {
+                        type: 'string',
+                        description: 'Destination relative file path',
+                    },
+                },
+                required: ['from', 'to'],
+            },
+        },
+    },
+    // ── Directory Listing ─────────────────────────────────────────
+    {
+        type: 'function',
+        function: {
+            name: 'list_files',
+            description: 'List files and directories at a path with sizes. Excludes node_modules and hidden files.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: {
+                        type: 'string',
+                        description: 'Relative directory path (use "." for project root)',
+                    },
+                    recursive: {
+                        type: 'boolean',
+                        description: 'List files recursively (default: false). Shows a tree-like structure.',
+                    },
+                },
+                required: ['path'],
+            },
+        },
+    },
+    // ── Glob (find files by pattern) ──────────────────────────────
+    {
+        type: 'function',
+        function: {
+            name: 'glob',
+            description: 'Find files matching a glob pattern. Returns matching file paths. Examples: "**/*.tsx", "src/**/*.css", "*.json".',
+            parameters: {
+                type: 'object',
+                properties: {
+                    pattern: {
+                        type: 'string',
+                        description: 'Glob pattern (e.g., "**/*.tsx", "src/components/*.tsx", "**/*.test.ts")',
+                    },
+                    path: {
+                        type: 'string',
+                        description: 'Base directory for the search (default: project root ".")',
+                    },
+                },
+                required: ['pattern'],
+            },
+        },
+    },
+    // ── Grep (search file contents) ───────────────────────────────
+    {
+        type: 'function',
+        function: {
+            name: 'grep',
+            description: 'Search for a regex pattern across files. Returns matching lines with file paths and line numbers. Powerful for finding definitions, usages, imports, etc.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    pattern: {
+                        type: 'string',
+                        description: 'Regex pattern to search for (e.g., "useState", "function\\s+handle", "import.*from")',
+                    },
+                    path: {
+                        type: 'string',
+                        description: 'Directory or file to search in (default: ".")',
+                    },
+                    file_type: {
+                        type: 'string',
+                        description: 'File extension filter without dot (e.g., "tsx", "css", "json", "ts")',
+                    },
+                    context: {
+                        type: 'number',
+                        description: 'Number of context lines to show before/after each match (default: 0)',
+                    },
+                    case_insensitive: {
+                        type: 'boolean',
+                        description: 'Case-insensitive search (default: false)',
+                    },
+                    max_results: {
+                        type: 'number',
+                        description: 'Maximum number of matching lines to return (default: 50)',
+                    },
+                },
+                required: ['pattern'],
+            },
+        },
+    },
+    // ── Bash / Shell Command ──────────────────────────────────────
+    {
+        type: 'function',
+        function: {
+            name: 'bash',
+            description: 'Execute a shell command in the project directory. Use for: npm/npx commands, git operations, curl, system tools, piped commands, etc. Returns stdout and stderr.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    command: {
+                        type: 'string',
+                        description: 'Shell command to run (e.g., "npm install lodash", "git diff HEAD~1", "ls -la src/")',
+                    },
+                    timeout: {
+                        type: 'number',
+                        description: 'Timeout in milliseconds (default: 120000 = 2 minutes)',
+                    },
+                },
+                required: ['command'],
+            },
+        },
+    },
+    // ── Build & Typecheck (convenience shortcuts) ─────────────────
+    {
+        type: 'function',
+        function: {
+            name: 'run_build',
+            description: 'Run "npx vite build" to compile the project. Shortcut for bash with build command.',
+            parameters: { type: 'object', properties: {} },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'run_typecheck',
+            description: 'Run "npx tsc --noEmit" to check TypeScript types. Shortcut for bash with typecheck command.',
+            parameters: { type: 'object', properties: {} },
+        },
+    },
+    // ── Git Operations ────────────────────────────────────────────
+    {
+        type: 'function',
+        function: {
+            name: 'git_status',
+            description: 'Show git status: modified, staged, and untracked files.',
+            parameters: { type: 'object', properties: {} },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'git_diff',
+            description: 'Show git diff of changes. Can diff specific files or all changes.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: {
+                        type: 'string',
+                        description: 'Specific file to diff (optional, defaults to all changes)',
+                    },
+                    staged: {
+                        type: 'boolean',
+                        description: 'Show staged changes only (--cached)',
+                    },
+                    ref: {
+                        type: 'string',
+                        description: 'Compare against a specific ref (e.g., "HEAD~1", "main", commit hash)',
+                    },
+                },
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'git_log',
+            description: 'Show recent git commit history.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    count: {
+                        type: 'number',
+                        description: 'Number of commits to show (default: 10)',
+                    },
+                    oneline: {
+                        type: 'boolean',
+                        description: 'One-line format (default: true)',
+                    },
+                },
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'git_commit',
+            description: 'Stage files and create a git commit.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    message: {
+                        type: 'string',
+                        description: 'Commit message',
+                    },
+                    files: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        description: 'Files to stage (default: all modified files). Use ["."] for all.',
+                    },
+                },
+                required: ['message'],
+            },
+        },
+    },
+    // ── NPM Operations ───────────────────────────────────────────
+    {
+        type: 'function',
+        function: {
+            name: 'npm_install',
+            description: 'Install npm packages. Can install specific packages or run npm install for all dependencies.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    packages: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        description: 'Package names to install (e.g., ["lodash", "@types/lodash"]). Omit to run plain "npm install".',
+                    },
+                    dev: {
+                        type: 'boolean',
+                        description: 'Install as devDependency (--save-dev)',
+                    },
+                },
+            },
+        },
+    },
+    // ── File Info ──────────────────────────────────────────────────
+    {
+        type: 'function',
+        function: {
+            name: 'file_info',
+            description: 'Get detailed information about a file: size, line count, last modified, type.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: {
+                        type: 'string',
+                        description: 'Relative file path',
+                    },
+                },
+                required: ['path'],
+            },
+        },
+    },
+    // ── Project Overview ──────────────────────────────────────────
+    {
+        type: 'function',
+        function: {
+            name: 'project_overview',
+            description: 'Get a high-level overview of the project: directory tree, key config files (package.json, tsconfig.json), dependencies, and scripts. Great first tool to call when exploring a new project.',
+            parameters: { type: 'object', properties: {} },
+        },
+    },
+    // ── Todo Management ──────────────────────────────────────────
+    {
+        type: 'function',
+        function: {
+            name: 'todo_list',
+            description: 'List all todo items. Shows ID, status, priority, and description for each task. Use this to see current progress and what needs to be done.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    filter: {
+                        type: 'string',
+                        enum: ['all', 'pending', 'in_progress', 'done', 'blocked'],
+                        description: 'Filter by status (default: "all")',
+                    },
+                },
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'todo_add',
+            description: 'Add a new todo item. Use this to track tasks, plan work, and break down complex requests into steps.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    title: {
+                        type: 'string',
+                        description: 'Short title for the task',
+                    },
+                    description: {
+                        type: 'string',
+                        description: 'Detailed description of what needs to be done',
+                    },
+                    priority: {
+                        type: 'string',
+                        enum: ['high', 'medium', 'low'],
+                        description: 'Priority level (default: "medium")',
+                    },
+                    parent_id: {
+                        type: 'number',
+                        description: 'ID of a parent task to create a subtask under (optional)',
+                    },
+                },
+                required: ['title'],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'todo_update',
+            description: 'Update an existing todo item. Change its status, priority, title, or description. Mark tasks as done when completed.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    id: {
+                        type: 'number',
+                        description: 'ID of the todo item to update',
+                    },
+                    status: {
+                        type: 'string',
+                        enum: ['pending', 'in_progress', 'done', 'blocked'],
+                        description: 'New status',
+                    },
+                    title: {
+                        type: 'string',
+                        description: 'Updated title',
+                    },
+                    description: {
+                        type: 'string',
+                        description: 'Updated description',
+                    },
+                    priority: {
+                        type: 'string',
+                        enum: ['high', 'medium', 'low'],
+                        description: 'Updated priority',
+                    },
+                },
+                required: ['id'],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'todo_remove',
+            description: 'Remove a todo item by ID.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    id: {
+                        type: 'number',
+                        description: 'ID of the todo item to remove',
+                    },
+                },
+                required: ['id'],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'todo_batch',
+            description: 'Perform multiple todo operations at once. Efficient for setting up a task plan or marking multiple items done.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    operations: {
+                        type: 'array',
+                        items: {
+                            type: 'object',
+                            properties: {
+                                action: {
+                                    type: 'string',
+                                    enum: ['add', 'update', 'remove'],
+                                    description: 'The operation to perform',
+                                },
+                                title: { type: 'string', description: 'Title (for add)' },
+                                description: { type: 'string', description: 'Description (for add)' },
+                                priority: { type: 'string', enum: ['high', 'medium', 'low'] },
+                                id: { type: 'number', description: 'ID (for update/remove)' },
+                                status: { type: 'string', enum: ['pending', 'in_progress', 'done', 'blocked'] },
+                            },
+                            required: ['action'],
+                        },
+                        description: 'Array of todo operations',
+                    },
+                },
+                required: ['operations'],
+            },
+        },
+    },
+    // ── Design Guide Generation ──────────────────────────────────
+    {
+        type: 'function',
+        function: {
+            name: 'generate_design_guide',
+            description: 'Generate a unique, project-specific design system with typography (Google Fonts), color palette, layout patterns, animations, hero section style, and sample copy. The guide is generated by an AI design director and ensures every project has a distinctive aesthetic. Call this BEFORE creating or modifying UI components.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    project_type: {
+                        type: 'string',
+                        description: 'Type of project (e.g., "Travel booking app", "SaaS dashboard", "Portfolio site", "E-commerce store")',
+                    },
+                    user_request: {
+                        type: 'string',
+                        description: 'Additional design preferences from the user (e.g., "dark mode, minimalist", "colorful and playful")',
+                    },
+                },
+                required: ['project_type'],
+            },
+        },
+    },
+];
+/**
+ * Run a shell command and return stdout+stderr.
+ */
+async function runShell(command, cwd, timeout = 120_000) {
+    try {
+        const { stdout, stderr } = await execFileAsync(IS_WIN ? 'cmd' : 'sh', IS_WIN ? ['/c', command] : ['-c', command], { cwd, timeout, maxBuffer: 10 * 1024 * 1024 });
+        const output = (stdout + (stderr ? `\nstderr:\n${stderr}` : '')).trim() || '(no output)';
+        return { output, success: true };
+    }
+    catch (err) {
+        const e = err;
+        const output = `Exit code ${e.code || '?'}:\n${e.stdout || ''}\n${e.stderr || ''}`.trim();
+        return { output, success: false };
+    }
+}
+/**
+ * Recursively list a directory tree.
+ */
+async function listTree(dir, base, prefix = '', depth = 0, maxDepth = 4) {
+    if (depth > maxDepth)
+        return [`${prefix}... (max depth reached)`];
+    const lines = [];
+    try {
+        const entries = await readdir(dir, { withFileTypes: true });
+        const filtered = entries.filter(e => e.name !== '.git' && e.name !== 'node_modules' && e.name !== 'dist');
+        for (let i = 0; i < filtered.length; i++) {
+            const entry = filtered[i];
+            const isLast = i === filtered.length - 1;
+            const connector = isLast ? '└── ' : '├── ';
+            const childPrefix = isLast ? '    ' : '│   ';
+            if (entry.isDirectory()) {
+                lines.push(`${prefix}${connector}${entry.name}/`);
+                const children = await listTree(join(dir, entry.name), base, prefix + childPrefix, depth + 1, maxDepth);
+                lines.push(...children);
+            }
+            else {
+                try {
+                    const s = await stat(join(dir, entry.name));
+                    const size = s.size < 1024 ? `${s.size}B` : s.size < 1048576 ? `${(s.size / 1024).toFixed(1)}K` : `${(s.size / 1048576).toFixed(1)}M`;
+                    lines.push(`${prefix}${connector}${entry.name} (${size})`);
+                }
+                catch {
+                    lines.push(`${prefix}${connector}${entry.name}`);
+                }
+            }
+        }
+    }
+    catch {
+        lines.push(`${prefix}(error reading directory)`);
+    }
+    return lines;
+}
+export function createChatToolExecutor(ctx) {
+    const { projectDir, onToolStart, onToolEnd } = ctx;
+    return async function executeTool(name, args) {
+        onToolStart?.(name, args);
+        let result;
+        let success = true;
+        try {
+            switch (name) {
+                // ── read_file ─────────────────────────────────────────
+                case 'read_file': {
+                    const MAX_READ_LINES = 200;
+                    const filePath = join(projectDir, args.path);
+                    try {
+                        const content = await readFile(filePath, 'utf-8');
+                        const allLines = content.split('\n');
+                        const offset = (args.offset || 1) - 1;
+                        const limit = Math.min(args.limit || MAX_READ_LINES, MAX_READ_LINES);
+                        const slice = allLines.slice(offset, offset + limit);
+                        const numbered = slice.map((l, i) => `${String(offset + i + 1).padStart(4)}  ${l}`).join('\n');
+                        const endLine = offset + slice.length;
+                        const remaining = allLines.length - endLine;
+                        let info = `\n\n(${allLines.length} total lines`;
+                        if (remaining > 0) {
+                            info += `, showing ${offset + 1}-${endLine}. ${remaining} more lines — use offset: ${endLine + 1} to continue`;
+                        }
+                        info += ')';
+                        result = numbered + info;
+                    }
+                    catch {
+                        result = `Error: File not found: ${args.path}`;
+                        success = false;
+                    }
+                    break;
+                }
+                // ── write_file ────────────────────────────────────────
+                case 'write_file': {
+                    const filePath = join(projectDir, args.path);
+                    try {
+                        await mkdir(dirname(filePath), { recursive: true });
+                        await writeFile(filePath, args.content, 'utf-8');
+                        const lineCount = args.content.split('\n').length;
+                        result = `Wrote ${args.path} (${lineCount} lines)`;
+                    }
+                    catch (err) {
+                        result = `Error writing: ${err instanceof Error ? err.message : String(err)}`;
+                        success = false;
+                    }
+                    break;
+                }
+                // ── edit_file ─────────────────────────────────────────
+                case 'edit_file': {
+                    const filePath = join(projectDir, args.path);
+                    try {
+                        const content = await readFile(filePath, 'utf-8');
+                        const oldStr = args.old_string;
+                        const newStr = args.new_string;
+                        const replaceAll = args.replace_all;
+                        const count = content.split(oldStr).length - 1;
+                        if (count === 0) {
+                            result = `Error: String not found in ${args.path}. Check for exact whitespace/indentation match.`;
+                            success = false;
+                        }
+                        else if (count > 1 && !replaceAll) {
+                            result = `Error: Found ${count} occurrences in ${args.path} — must be unique. Add more context or use replace_all=true.`;
+                            success = false;
+                        }
+                        else {
+                            const updated = replaceAll ? content.split(oldStr).join(newStr) : content.replace(oldStr, newStr);
+                            await writeFile(filePath, updated, 'utf-8');
+                            result = replaceAll
+                                ? `Replaced ${count} occurrence(s) in ${args.path}`
+                                : `Edited ${args.path} (${oldStr.split('\n').length} → ${newStr.split('\n').length} lines)`;
+                        }
+                    }
+                    catch {
+                        result = `Error: File not found: ${args.path}`;
+                        success = false;
+                    }
+                    break;
+                }
+                // ── multi_edit ────────────────────────────────────────
+                case 'multi_edit': {
+                    const filePath = join(projectDir, args.path);
+                    try {
+                        let content = await readFile(filePath, 'utf-8');
+                        const edits = args.edits;
+                        let applied = 0;
+                        const errors = [];
+                        for (let i = 0; i < edits.length; i++) {
+                            const { old_string, new_string } = edits[i];
+                            if (!content.includes(old_string)) {
+                                errors.push(`Edit ${i + 1}: old_string not found`);
+                            }
+                            else {
+                                content = content.replace(old_string, new_string);
+                                applied++;
+                            }
+                        }
+                        await writeFile(filePath, content, 'utf-8');
+                        result = `Applied ${applied}/${edits.length} edits to ${args.path}`;
+                        if (errors.length > 0) {
+                            result += `\nWarnings:\n${errors.join('\n')}`;
+                            success = applied > 0;
+                        }
+                    }
+                    catch {
+                        result = `Error: File not found: ${args.path}`;
+                        success = false;
+                    }
+                    break;
+                }
+                // ── insert_at_line ────────────────────────────────────
+                case 'insert_at_line': {
+                    const filePath = join(projectDir, args.path);
+                    try {
+                        const content = await readFile(filePath, 'utf-8');
+                        const lines = content.split('\n');
+                        const lineNum = Math.max(1, Math.min(args.line || 1, lines.length + 1));
+                        const insertContent = args.content;
+                        lines.splice(lineNum - 1, 0, insertContent);
+                        await writeFile(filePath, lines.join('\n'), 'utf-8');
+                        result = `Inserted ${insertContent.split('\n').length} line(s) at line ${lineNum} in ${args.path}`;
+                    }
+                    catch {
+                        result = `Error: File not found: ${args.path}`;
+                        success = false;
+                    }
+                    break;
+                }
+                // ── delete_file ───────────────────────────────────────
+                case 'delete_file': {
+                    const filePath = join(projectDir, args.path);
+                    try {
+                        await unlink(filePath);
+                        result = `Deleted ${args.path}`;
+                    }
+                    catch {
+                        result = `Error: Could not delete ${args.path}`;
+                        success = false;
+                    }
+                    break;
+                }
+                // ── move_file ─────────────────────────────────────────
+                case 'move_file': {
+                    const fromPath = join(projectDir, args.from);
+                    const toPath = join(projectDir, args.to);
+                    try {
+                        await mkdir(dirname(toPath), { recursive: true });
+                        await rename(fromPath, toPath);
+                        result = `Moved ${args.from} → ${args.to}`;
+                    }
+                    catch (err) {
+                        result = `Error moving file: ${err instanceof Error ? err.message : String(err)}`;
+                        success = false;
+                    }
+                    break;
+                }
+                // ── copy_file ─────────────────────────────────────────
+                case 'copy_file': {
+                    const fromPath = join(projectDir, args.from);
+                    const toPath = join(projectDir, args.to);
+                    try {
+                        await mkdir(dirname(toPath), { recursive: true });
+                        await copyFile(fromPath, toPath);
+                        result = `Copied ${args.from} → ${args.to}`;
+                    }
+                    catch (err) {
+                        result = `Error copying: ${err instanceof Error ? err.message : String(err)}`;
+                        success = false;
+                    }
+                    break;
+                }
+                // ── list_files ────────────────────────────────────────
+                case 'list_files': {
+                    const dirPath = join(projectDir, args.path || '.');
+                    const recursive = args.recursive;
+                    if (recursive) {
+                        const tree = await listTree(dirPath, projectDir);
+                        result = tree.length > 0 ? tree.join('\n') : '(empty)';
+                    }
+                    else {
+                        try {
+                            const entries = await readdir(dirPath, { withFileTypes: true });
+                            const lines = [];
+                            for (const entry of entries) {
+                                if (entry.name === '.git' || entry.name === 'node_modules')
+                                    continue;
+                                if (entry.isDirectory()) {
+                                    lines.push(`  [dir]  ${entry.name}/`);
+                                }
+                                else {
+                                    try {
+                                        const s = await stat(join(dirPath, entry.name));
+                                        const size = s.size < 1024 ? `${s.size}B` : `${(s.size / 1024).toFixed(1)}K`;
+                                        lines.push(`  ${size.padStart(7)}  ${entry.name}`);
+                                    }
+                                    catch {
+                                        lines.push(`         ${entry.name}`);
+                                    }
+                                }
+                            }
+                            result = lines.length > 0 ? lines.join('\n') : '(empty directory)';
+                        }
+                        catch {
+                            result = `Error: Directory not found: ${args.path}`;
+                            success = false;
+                        }
+                    }
+                    break;
+                }
+                // ── glob ──────────────────────────────────────────────
+                case 'glob': {
+                    const pattern = args.pattern;
+                    const basePath = join(projectDir, args.path || '.');
+                    try {
+                        const { glob: globFn } = await import('glob');
+                        const matches = await globFn(pattern, {
+                            cwd: basePath,
+                            nodir: true,
+                            ignore: ['node_modules/**', '.git/**', 'dist/**'],
+                        });
+                        result = matches.length > 0
+                            ? `${matches.length} file(s) found:\n${matches.slice(0, 100).join('\n')}${matches.length > 100 ? '\n... (truncated)' : ''}`
+                            : 'No files matched.';
+                    }
+                    catch (err) {
+                        result = `Glob error: ${err instanceof Error ? err.message : String(err)}`;
+                        success = false;
+                    }
+                    break;
+                }
+                // ── grep ──────────────────────────────────────────────
+                case 'grep': {
+                    const pattern = args.pattern;
+                    const searchPath = join(projectDir, args.path || '.');
+                    const fileType = args.file_type;
+                    const contextLines = args.context || 0;
+                    const caseInsensitive = args.case_insensitive;
+                    const maxResults = args.max_results || 50;
+                    const grepCmd = IS_WIN ? 'findstr' : 'grep';
+                    if (IS_WIN) {
+                        // Use findstr on Windows
+                        const findstrArgs = [
+                            caseInsensitive ? '/I' : '',
+                            '/S', '/N',
+                            `/R`, `"${pattern}"`,
+                            fileType ? `*.${fileType}` : '*.*',
+                        ].filter(Boolean).join(' ');
+                        const { output, success: ok } = await runShell(`findstr ${findstrArgs}`, searchPath, 15_000);
+                        if (!ok && output.includes('Exit code')) {
+                            result = 'No matches found.';
+                        }
+                        else {
+                            const lines = output.split('\n').slice(0, maxResults);
+                            result = lines.join('\n') + (lines.length >= maxResults ? `\n... (showing first ${maxResults})` : '');
+                        }
+                    }
+                    else {
+                        // Use grep on Unix
+                        const grepArgs = ['-rn'];
+                        if (caseInsensitive)
+                            grepArgs.push('-i');
+                        if (contextLines > 0)
+                            grepArgs.push(`-C${contextLines}`);
+                        if (fileType)
+                            grepArgs.push(`--include=*.${fileType}`);
+                        grepArgs.push('--exclude-dir=node_modules', '--exclude-dir=.git', '--exclude-dir=dist');
+                        grepArgs.push('-e', pattern, searchPath);
+                        try {
+                            const { stdout } = await execFileAsync('grep', grepArgs, {
+                                timeout: 15_000,
+                                maxBuffer: 2 * 1024 * 1024,
+                            });
+                            const lines = stdout.split('\n')
+                                .filter(Boolean)
+                                .map(l => l.replace(projectDir + '/', ''))
+                                .slice(0, maxResults);
+                            result = lines.length > 0
+                                ? lines.join('\n') + (lines.length >= maxResults ? `\n... (showing first ${maxResults})` : '')
+                                : 'No matches found.';
+                        }
+                        catch (err) {
+                            const e = err;
+                            result = e.code === 1 ? 'No matches found.' : `Grep error: ${err instanceof Error ? err.message : String(err)}`;
+                            success = e.code === 1;
+                        }
+                    }
+                    break;
+                }
+                // ── bash ──────────────────────────────────────────────
+                case 'bash': {
+                    const command = args.command;
+                    const timeout = args.timeout || 120_000;
+                    // Block truly dangerous operations
+                    const blocked = ['rm -rf /', 'format c:', 'del /f /s /q c:', 'mkfs', ':(){'];
+                    if (blocked.some(b => command.includes(b))) {
+                        result = 'Error: Dangerous command blocked.';
+                        success = false;
+                        break;
+                    }
+                    const r = await runShell(command, projectDir, timeout);
+                    result = r.output;
+                    success = r.success;
+                    break;
+                }
+                // ── run_build ─────────────────────────────────────────
+                case 'run_build': {
+                    const r = await runShell('npx vite build', projectDir, 60_000);
+                    result = (r.success ? 'BUILD SUCCESS\n' : 'BUILD FAILED\n') + r.output;
+                    success = r.success;
+                    break;
+                }
+                // ── run_typecheck ─────────────────────────────────────
+                case 'run_typecheck': {
+                    const r = await runShell('npx tsc --noEmit', projectDir, 60_000);
+                    result = (r.success ? 'TYPECHECK PASSED\n' : 'TYPECHECK ERRORS\n') + r.output;
+                    success = r.success;
+                    break;
+                }
+                // ── git_status ────────────────────────────────────────
+                case 'git_status': {
+                    const r = await runShell('git status', projectDir);
+                    result = r.output;
+                    success = r.success;
+                    break;
+                }
+                // ── git_diff ──────────────────────────────────────────
+                case 'git_diff': {
+                    let cmd = 'git diff';
+                    if (args.staged)
+                        cmd += ' --cached';
+                    if (args.ref)
+                        cmd += ` ${args.ref}`;
+                    if (args.path)
+                        cmd += ` -- ${args.path}`;
+                    const r = await runShell(cmd, projectDir);
+                    result = r.output || '(no changes)';
+                    success = r.success;
+                    break;
+                }
+                // ── git_log ───────────────────────────────────────────
+                case 'git_log': {
+                    const count = args.count || 10;
+                    const oneline = args.oneline !== false;
+                    const fmt = oneline ? '--oneline' : '--format=medium';
+                    const r = await runShell(`git log ${fmt} -${count}`, projectDir);
+                    result = r.output;
+                    success = r.success;
+                    break;
+                }
+                // ── git_commit ────────────────────────────────────────
+                case 'git_commit': {
+                    const message = args.message;
+                    const files = args.files || ['.'];
+                    // Stage files
+                    const stageCmd = files.map(f => `git add "${f}"`).join(' && ');
+                    const stageR = await runShell(stageCmd, projectDir);
+                    if (!stageR.success) {
+                        result = `Staging failed: ${stageR.output}`;
+                        success = false;
+                        break;
+                    }
+                    // Commit
+                    const commitR = await runShell(`git commit -m "${message.replace(/"/g, '\\"')}"`, projectDir);
+                    result = commitR.output;
+                    success = commitR.success;
+                    break;
+                }
+                // ── npm_install ───────────────────────────────────────
+                case 'npm_install': {
+                    const packages = args.packages;
+                    const isDev = args.dev;
+                    let cmd = 'npm install';
+                    if (packages && packages.length > 0) {
+                        cmd += ` ${packages.join(' ')}`;
+                        if (isDev)
+                            cmd += ' --save-dev';
+                    }
+                    const r = await runShell(cmd, projectDir, 120_000);
+                    result = r.output;
+                    success = r.success;
+                    break;
+                }
+                // ── file_info ─────────────────────────────────────────
+                case 'file_info': {
+                    const filePath = join(projectDir, args.path);
+                    try {
+                        const s = await stat(filePath);
+                        const content = await readFile(filePath, 'utf-8');
+                        const lines = content.split('\n').length;
+                        const ext = extname(filePath);
+                        const size = s.size < 1024 ? `${s.size} bytes` : s.size < 1048576 ? `${(s.size / 1024).toFixed(1)} KB` : `${(s.size / 1048576).toFixed(1)} MB`;
+                        result = [
+                            `File: ${args.path}`,
+                            `Size: ${size}`,
+                            `Lines: ${lines}`,
+                            `Type: ${ext || 'unknown'}`,
+                            `Modified: ${s.mtime.toISOString()}`,
+                            `Created: ${s.birthtime.toISOString()}`,
+                        ].join('\n');
+                    }
+                    catch {
+                        result = `Error: File not found: ${args.path}`;
+                        success = false;
+                    }
+                    break;
+                }
+                // ── project_overview ──────────────────────────────────
+                case 'project_overview': {
+                    const sections = [];
+                    // Directory tree
+                    sections.push('=== Project Structure ===');
+                    const tree = await listTree(projectDir, projectDir);
+                    sections.push(tree.slice(0, 50).join('\n'));
+                    if (tree.length > 50)
+                        sections.push(`... (${tree.length - 50} more entries)`);
+                    // package.json summary
+                    try {
+                        const pkgRaw = await readFile(join(projectDir, 'package.json'), 'utf-8');
+                        const pkg = JSON.parse(pkgRaw);
+                        sections.push('\n=== package.json ===');
+                        if (pkg.name)
+                            sections.push(`Name: ${pkg.name}`);
+                        if (pkg.version)
+                            sections.push(`Version: ${pkg.version}`);
+                        if (pkg.scripts) {
+                            sections.push(`Scripts: ${Object.keys(pkg.scripts).join(', ')}`);
+                        }
+                        if (pkg.dependencies) {
+                            sections.push(`Dependencies: ${Object.keys(pkg.dependencies).join(', ')}`);
+                        }
+                        if (pkg.devDependencies) {
+                            sections.push(`DevDependencies: ${Object.keys(pkg.devDependencies).join(', ')}`);
+                        }
+                    }
+                    catch { /* no package.json */ }
+                    // tsconfig summary
+                    try {
+                        const tscRaw = await readFile(join(projectDir, 'tsconfig.json'), 'utf-8');
+                        const tsc = JSON.parse(tscRaw);
+                        sections.push('\n=== tsconfig.json ===');
+                        if (tsc.compilerOptions?.target)
+                            sections.push(`Target: ${tsc.compilerOptions.target}`);
+                        if (tsc.compilerOptions?.module)
+                            sections.push(`Module: ${tsc.compilerOptions.module}`);
+                        if (tsc.compilerOptions?.jsx)
+                            sections.push(`JSX: ${tsc.compilerOptions.jsx}`);
+                        if (tsc.compilerOptions?.strict !== undefined)
+                            sections.push(`Strict: ${tsc.compilerOptions.strict}`);
+                    }
+                    catch { /* no tsconfig */ }
+                    result = sections.join('\n');
+                    break;
+                }
+                // ── generate_design_guide ─────────────────────────────
+                case 'generate_design_guide': {
+                    const projectType = args.project_type;
+                    const userRequest = args.user_request;
+                    try {
+                        const { guide, design } = await generateDesignGuide(projectType, userRequest);
+                        // Save to project for reference
+                        await writeFile(join(projectDir, '.design-guide.md'), guide, 'utf-8');
+                        result = `Design guide generated and saved to .design-guide.md\n\n${guide}`;
+                    }
+                    catch (err) {
+                        const fallback = getFallbackGuide(projectType);
+                        await writeFile(join(projectDir, '.design-guide.md'), fallback, 'utf-8');
+                        result = `Design API failed (using fallback). Saved to .design-guide.md\n\n${fallback}`;
+                        success = false;
+                    }
+                    break;
+                }
+                // ── todo_list ──────────────────────────────────────────
+                case 'todo_list': {
+                    const store = await loadTodos(projectDir);
+                    const filter = args.filter || 'all';
+                    result = formatTodoList(store, filter);
+                    break;
+                }
+                // ── todo_add ───────────────────────────────────────────
+                case 'todo_add': {
+                    const store = await loadTodos(projectDir);
+                    const newItem = {
+                        id: store.nextId++,
+                        title: args.title,
+                        description: args.description,
+                        status: 'pending',
+                        priority: args.priority || 'medium',
+                        parentId: args.parent_id,
+                        createdAt: new Date().toISOString(),
+                        updatedAt: new Date().toISOString(),
+                    };
+                    store.items.push(newItem);
+                    await saveTodos(projectDir, store);
+                    const parentInfo = newItem.parentId ? ` (subtask of #${newItem.parentId})` : '';
+                    result = `Added todo #${newItem.id}: "${newItem.title}" [${newItem.priority}]${parentInfo}`;
+                    break;
+                }
+                // ── todo_update ────────────────────────────────────────
+                case 'todo_update': {
+                    const store = await loadTodos(projectDir);
+                    const id = args.id;
+                    const item = store.items.find(i => i.id === id);
+                    if (!item) {
+                        result = `Error: Todo #${id} not found.`;
+                        success = false;
+                        break;
+                    }
+                    const changes = [];
+                    if (args.status) {
+                        item.status = args.status;
+                        changes.push(`status → ${item.status}`);
+                    }
+                    if (args.title) {
+                        item.title = args.title;
+                        changes.push(`title updated`);
+                    }
+                    if (args.description !== undefined) {
+                        item.description = args.description;
+                        changes.push(`description updated`);
+                    }
+                    if (args.priority) {
+                        item.priority = args.priority;
+                        changes.push(`priority → ${item.priority}`);
+                    }
+                    item.updatedAt = new Date().toISOString();
+                    await saveTodos(projectDir, store);
+                    result = `Updated todo #${id}: ${changes.join(', ')}`;
+                    break;
+                }
+                // ── todo_remove ────────────────────────────────────────
+                case 'todo_remove': {
+                    const store = await loadTodos(projectDir);
+                    const id = args.id;
+                    const idx = store.items.findIndex(i => i.id === id);
+                    if (idx === -1) {
+                        result = `Error: Todo #${id} not found.`;
+                        success = false;
+                        break;
+                    }
+                    const removed = store.items.splice(idx, 1)[0];
+                    // Also remove subtasks
+                    const subtaskIds = store.items.filter(i => i.parentId === id).map(i => i.id);
+                    store.items = store.items.filter(i => i.parentId !== id);
+                    await saveTodos(projectDir, store);
+                    result = `Removed todo #${id}: "${removed.title}"`;
+                    if (subtaskIds.length > 0) {
+                        result += ` (and ${subtaskIds.length} subtask(s))`;
+                    }
+                    break;
+                }
+                // ── todo_batch ─────────────────────────────────────────
+                case 'todo_batch': {
+                    const store = await loadTodos(projectDir);
+                    const operations = args.operations;
+                    const results = [];
+                    for (const op of operations) {
+                        switch (op.action) {
+                            case 'add': {
+                                const newItem = {
+                                    id: store.nextId++,
+                                    title: op.title || 'Untitled',
+                                    description: op.description,
+                                    status: 'pending',
+                                    priority: op.priority || 'medium',
+                                    createdAt: new Date().toISOString(),
+                                    updatedAt: new Date().toISOString(),
+                                };
+                                store.items.push(newItem);
+                                results.push(`+ Added #${newItem.id}: "${newItem.title}"`);
+                                break;
+                            }
+                            case 'update': {
+                                const item = store.items.find(i => i.id === op.id);
+                                if (item) {
+                                    if (op.status)
+                                        item.status = op.status;
+                                    if (op.title)
+                                        item.title = op.title;
+                                    if (op.priority)
+                                        item.priority = op.priority;
+                                    item.updatedAt = new Date().toISOString();
+                                    results.push(`~ Updated #${item.id}: ${op.status || op.title || 'modified'}`);
+                                }
+                                else {
+                                    results.push(`! #${op.id} not found`);
+                                }
+                                break;
+                            }
+                            case 'remove': {
+                                const idx = store.items.findIndex(i => i.id === op.id);
+                                if (idx >= 0) {
+                                    const removed = store.items.splice(idx, 1)[0];
+                                    results.push(`- Removed #${removed.id}: "${removed.title}"`);
+                                }
+                                else {
+                                    results.push(`! #${op.id} not found`);
+                                }
+                                break;
+                            }
+                        }
+                    }
+                    await saveTodos(projectDir, store);
+                    result = `Batch: ${operations.length} operation(s)\n${results.join('\n')}`;
+                    break;
+                }
+                default:
+                    result = `Unknown tool: ${name}`;
+                    success = false;
+            }
+        }
+        catch (err) {
+            result = `Tool error: ${err instanceof Error ? err.message : String(err)}`;
+            success = false;
+        }
+        onToolEnd?.(name, result, success);
+        return result;
+    };
+}
+//# sourceMappingURL=tools.js.map