minovative-mind-cli 1.0.0

package/dist/services/agent-tools.js

@@ -0,0 +1,764 @@
+import { exec } from 'node:child_process';
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { promisify } from 'node:util';
+import { SchemaType } from '@google/generative-ai';
+import { resolveAndValidatePath } from '../utils/pathSecurity.js';
+import { changeLogger } from './changeLogger.js';
+import { findBestMatch, applyMatch } from '../utils/fuzzyMatch.js';
+import { validateSyntax } from '../utils/syntaxValidator.js';
+import { sanitizeForCDATA } from '../utils/contextPrompts.js';
+import { findDependencies, formatDependencyResult } from '../utils/dependencyTracer.js';
+import { atomicWriteFile } from '../utils/atomicWrite.js';
+import { EXCLUDED_EXTENSIONS } from '../utils/excludedExtensions.js';
+import { extractSymbols } from '../utils/symbolExtractor.js';
+const execAsync = promisify(exec);
+// ─── Tool Declarations for Gemini Function Calling ───────────────────
+/**
+ * FunctionDeclaration-compatible schema objects that describe
+ * every tool the agent can invoke. Passed to the model at init.
+ */
+export const toolDeclarations = [
+    {
+        name: 'read_file',
+        description: 'Read the contents of a file at the given path relative to the workspace root. Returns the file text. Use startLine and endLine to read specific chunks of massive files to avoid context limits.',
+        parameters: {
+            type: SchemaType.OBJECT,
+            properties: {
+                filePath: {
+                    type: SchemaType.STRING,
+                    description: 'Relative path to the file from the workspace root.',
+                },
+                startLine: {
+                    type: SchemaType.NUMBER,
+                    description: 'Optional. 1-indexed starting line number to read from.',
+                },
+                endLine: {
+                    type: SchemaType.NUMBER,
+                    description: 'Optional. 1-indexed ending line number to read up to (inclusive).',
+                },
+                targetElements: {
+                    type: SchemaType.ARRAY,
+                    items: { type: SchemaType.STRING },
+                    description: 'Optional. An array of specific function names, class names, or variables to extract. The tool will intelligently locate and return only the blocks defining these elements.',
+                },
+            },
+            required: ['filePath'],
+        },
+    },
+    {
+        name: 'write_file',
+        description: 'Create a new file or completely overwrite an existing file with the provided content. Use modify_file for targeted edits instead.',
+        parameters: {
+            type: SchemaType.OBJECT,
+            properties: {
+                filePath: {
+                    type: SchemaType.STRING,
+                    description: 'Relative path to the file from the workspace root.',
+                },
+                content: {
+                    type: SchemaType.STRING,
+                    description: 'The full content to write to the file.',
+                },
+            },
+            required: ['filePath', 'content'],
+        },
+    },
+    {
+        name: 'delete_file',
+        description: 'Deletes a file from the filesystem. Use this instead of running an rm command.',
+        parameters: {
+            type: SchemaType.OBJECT,
+            properties: {
+                filePath: {
+                    type: SchemaType.STRING,
+                    description: 'Relative path to the file to delete.',
+                },
+            },
+            required: ['filePath'],
+        },
+    },
+    {
+        name: 'rename_file',
+        description: 'Moves or renames a file. Use this instead of running an mv command.',
+        parameters: {
+            type: SchemaType.OBJECT,
+            properties: {
+                sourcePath: {
+                    type: SchemaType.STRING,
+                    description: 'Relative path to the file to move/rename.',
+                },
+                targetPath: {
+                    type: SchemaType.STRING,
+                    description: 'New relative path for the file.',
+                },
+            },
+            required: ['sourcePath', 'targetPath'],
+        },
+    },
+    {
+        name: 'modify_file',
+        description: 'Perform one or multiple targeted search-and-replace edits in a single file. The search strings must match exactly (including whitespace). This is preferred over write_file for editing existing files because it preserves the rest of the file. Use this to batch multiple changes into a single operation.',
+        parameters: {
+            type: SchemaType.OBJECT,
+            properties: {
+                filePath: {
+                    type: SchemaType.STRING,
+                    description: 'Relative path to the file from the workspace root.',
+                },
+                edits: {
+                    type: SchemaType.ARRAY,
+                    description: 'An array of edit objects to apply to the file.',
+                    items: {
+                        type: SchemaType.OBJECT,
+                        properties: {
+                            searchContent: {
+                                type: SchemaType.STRING,
+                                description: 'The exact text to find in the file.',
+                            },
+                            replaceContent: {
+                                type: SchemaType.STRING,
+                                description: 'The replacement text.',
+                            },
+                        },
+                        required: ['searchContent', 'replaceContent'],
+                    },
+                },
+            },
+            required: ['filePath', 'edits'],
+        },
+    },
+    {
+        name: 'list_directory',
+        description: 'List files and subdirectories in a directory relative to the workspace root. Returns a recursive tree structure.',
+        parameters: {
+            type: SchemaType.OBJECT,
+            properties: {
+                dirPath: {
+                    type: SchemaType.STRING,
+                    description: 'Relative path to the directory from the workspace root. Use "." for the root.',
+                },
+                maxDepth: {
+                    type: SchemaType.NUMBER,
+                    description: 'Maximum depth to recurse. Defaults to 3. Use 1 for a shallow listing.',
+                },
+            },
+            required: ['dirPath'],
+        },
+    },
+    {
+        name: 'run_command',
+        description: 'Execute a shell command in the workspace root directory and return stdout/stderr. The user will be prompted for approval before execution unless they have chosen to auto-approve.',
+        parameters: {
+            type: SchemaType.OBJECT,
+            properties: {
+                command: {
+                    type: SchemaType.STRING,
+                    description: 'The shell command to execute.',
+                },
+            },
+            required: ['command'],
+        },
+    },
+    {
+        name: 'grep_search',
+        description: 'Search for a text pattern across files in the workspace. Returns matching file paths with line numbers and content snippets. Uses Extended Regular Expressions (grep -E). IMPORTANT: grep searches line-by-line. Do NOT search for long lists of Tailwind classes or multi-line strings, as they will fail if line-wrapped. Search for short, unique substrings.',
+        parameters: {
+            type: SchemaType.OBJECT,
+            properties: {
+                pattern: {
+                    type: SchemaType.STRING,
+                    description: 'The text or extended regex pattern to search for.',
+                },
+                fileGlob: {
+                    type: SchemaType.STRING,
+                    description: 'Optional glob to restrict file types, e.g. "*.ts" or "*.py". Defaults to all files.',
+                },
+            },
+            required: ['pattern'],
+        },
+    },
+    {
+        name: 'find_dependencies',
+        description: 'Find all files that import or are imported by the given file. Returns both forward dependencies (what the file imports) and reverse dependencies (files that import it). Use this to understand the blast radius of modifying, deleting, or renaming a file.',
+        parameters: {
+            type: SchemaType.OBJECT,
+            properties: {
+                filePath: {
+                    type: SchemaType.STRING,
+                    description: 'Relative path to the file to trace dependencies for.',
+                },
+                direction: {
+                    type: SchemaType.STRING,
+                    description: 'Direction to trace: "both" (default), "forward" (what this file imports), or "reverse" (what imports this file).',
+                },
+                maxDepth: {
+                    type: SchemaType.NUMBER,
+                    description: 'Maximum depth to traverse the dependency tree. Defaults to 3.',
+                },
+            },
+            required: ['filePath'],
+        },
+    },
+    {
+        name: 'find_recent_changes',
+        description: 'Find files that have been modified recently within the workspace. Useful for understanding what the user was just working on if they ask vague questions like "why is it failing?". Automatically ignores .git, node_modules, etc.',
+        parameters: {
+            type: SchemaType.OBJECT,
+            properties: {
+                dirPath: {
+                    type: SchemaType.STRING,
+                    description: 'Relative path to directory to search from. Defaults to workspace root ".".',
+                },
+                minutes: {
+                    type: SchemaType.NUMBER,
+                    description: 'Look for files modified within this many minutes. Defaults to 60.',
+                },
+                maxDepth: {
+                    type: SchemaType.NUMBER,
+                    description: 'Maximum depth to traverse. Defaults to 5.',
+                },
+            },
+        },
+    },
+    {
+        name: 'create_and_run_test',
+        description: 'Write a snippet of code (e.g. a unit test or debug script) to a temporary file, execute it using the specified runtime, and return the exact standard output and standard error logs. Use this to actively test and debug code during execution and verification loops.',
+        parameters: {
+            type: SchemaType.OBJECT,
+            properties: {
+                language: {
+                    type: SchemaType.STRING,
+                    description: 'The runtime to use: "node", "ts-node", "python", "bash", "go", or "rust".',
+                },
+                code: {
+                    type: SchemaType.STRING,
+                    description: 'The exact test code or script to execute.',
+                },
+            },
+            required: ['language', 'code'],
+        },
+    },
+];
+let currentApprovalMode = 'ask';
+export function getApprovalMode() {
+    return currentApprovalMode;
+}
+export function setApprovalMode(mode) {
+    currentApprovalMode = mode;
+}
+/**
+ * If set to 'skip-once', reverts to 'ask' after a single command is run.
+ */
+export function consumeSkipOnce() {
+    if (currentApprovalMode === 'skip-once') {
+        currentApprovalMode = 'ask';
+    }
+}
+// ─── Ignored Paths ───────────────────────────────────────────────────
+const DEFAULT_IGNORED_DIRS = new Set([
+    'node_modules',
+    '.git',
+    'dist',
+    '.next',
+    '.nuxt',
+    '__pycache__',
+    '.venv',
+    'venv',
+    '.cache',
+    'coverage',
+    '.turbo',
+]);
+const DEFAULT_IGNORED_FILES = new Set(['package-lock.json', 'yarn.lock', 'pnpm-lock.yaml', '.DS_Store']);
+/**
+ * Parses .gitignore to supplement the default ignore lists.
+ */
+async function getIgnoredPaths(workspaceRoot) {
+    const ignoredDirs = new Set(DEFAULT_IGNORED_DIRS);
+    const ignoredFiles = new Set(DEFAULT_IGNORED_FILES);
+    try {
+        const gitignoreContent = await fs.readFile(path.join(workspaceRoot, '.gitignore'), 'utf-8');
+        const lines = gitignoreContent
+            .split('\n')
+            .map((l) => l.trim())
+            .filter((l) => l && !l.startsWith('#'));
+        for (const line of lines) {
+            const cleanLine = line.replace(/^\//, '').replace(/\/$/, '');
+            if (!cleanLine.includes('*')) {
+                ignoredDirs.add(cleanLine);
+                ignoredFiles.add(cleanLine);
+            }
+        }
+    }
+    catch {
+        // Ignore missing .gitignore
+    }
+    return { ignoredDirs, ignoredFiles };
+}
+// ─── Tool Implementations ────────────────────────────────────────────
+export async function readFile(workspaceRoot, filePath, startLine, endLine, targetElements) {
+    try {
+        const absPath = resolveAndValidatePath(workspaceRoot, filePath);
+        let content = await fs.readFile(absPath, 'utf-8');
+        if (targetElements && targetElements.length > 0) {
+            content = extractSymbols(content, filePath, targetElements);
+        }
+        else if (startLine !== undefined || endLine !== undefined) {
+            const lines = content.split('\n');
+            const start = startLine !== undefined ? Math.max(1, startLine) : 1;
+            const end = endLine !== undefined ? Math.min(lines.length, endLine) : lines.length;
+            if (start > end) {
+                return { output: '', error: `Invalid line range: startLine (${startLine}) > endLine (${endLine})` };
+            }
+            content = lines.slice(start - 1, end).join('\n');
+        }
+        const attrLines = startLine || endLine ? ` lines="${startLine || 1}-${endLine || 'end'}"` : '';
+        const attrTargets = targetElements && targetElements.length > 0 ? ` elements="${targetElements.join(',')}"` : '';
+        const wrappedContent = `<workspace_file path="${filePath}"${attrLines}${attrTargets}>\n<content_data><![CDATA[\n${sanitizeForCDATA(content)}\n]]></content_data>\n</workspace_file>`;
+        return { output: wrappedContent };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { output: '', error: `Failed to read file "${filePath}": ${message}` };
+    }
+}
+export async function writeFile(workspaceRoot, filePath, content) {
+    try {
+        const absPath = resolveAndValidatePath(workspaceRoot, filePath);
+        let existingContent = null;
+        try {
+            existingContent = await fs.readFile(absPath, 'utf-8');
+        }
+        catch {
+            // File doesn't exist
+        }
+        const validation = validateSyntax(content, filePath);
+        if (!validation.valid) {
+            return {
+                output: '',
+                error: `Syntax validation failed for "${filePath}":\\n- ${validation.errors.join('\\n- ')}\\n\\nPlease fix the syntax and try again.`,
+            };
+        }
+        await fs.mkdir(path.dirname(absPath), { recursive: true });
+        changeLogger.logChange(filePath, existingContent, existingContent !== null ? 'modify' : 'create');
+        await atomicWriteFile(absPath, content, 'utf-8');
+        return { output: `Successfully wrote to "${filePath}".` };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+            output: '',
+            error: `Failed to write file "${filePath}": ${message}`,
+        };
+    }
+}
+export async function deleteFile(workspaceRoot, filePath) {
+    try {
+        const absPath = resolveAndValidatePath(workspaceRoot, filePath);
+        let existingContent = null;
+        try {
+            existingContent = await fs.readFile(absPath, 'utf-8');
+        }
+        catch {
+            return { output: '', error: `Failed to delete "${filePath}": File does not exist.` };
+        }
+        changeLogger.logChange(filePath, existingContent, 'delete');
+        await fs.rm(absPath, { force: true });
+        return { output: `Successfully deleted "${filePath}".` };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { output: '', error: `Failed to delete file "${filePath}": ${message}` };
+    }
+}
+export async function renameFile(workspaceRoot, sourcePath, targetPath) {
+    try {
+        const absSource = resolveAndValidatePath(workspaceRoot, sourcePath);
+        const absTarget = resolveAndValidatePath(workspaceRoot, targetPath);
+        let existingContent = null;
+        try {
+            existingContent = await fs.readFile(absSource, 'utf-8');
+        }
+        catch {
+            return { output: '', error: `Failed to move/rename "${sourcePath}": File does not exist.` };
+        }
+        // Log the source deletion
+        changeLogger.logChange(sourcePath, existingContent, 'delete');
+        // Log the target creation
+        changeLogger.logChange(targetPath, null, 'create');
+        await fs.mkdir(path.dirname(absTarget), { recursive: true });
+        await fs.rename(absSource, absTarget);
+        return { output: `Successfully moved/renamed "${sourcePath}" to "${targetPath}".` };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { output: '', error: `Failed to move/rename file: ${message}` };
+    }
+}
+export async function modifyFile(workspaceRoot, filePath, edits) {
+    const MAX_MODIFY_RETRIES = 2;
+    const absPath = resolveAndValidatePath(workspaceRoot, filePath);
+    for (let attempt = 1; attempt <= MAX_MODIFY_RETRIES; attempt++) {
+        try {
+            const existing = await fs.readFile(absPath, 'utf-8');
+            let modified = existing;
+            const strategies = [];
+            for (let i = 0; i < edits.length; i++) {
+                const edit = edits[i];
+                const match = findBestMatch(modified, edit.searchContent);
+                if (!match) {
+                    if (attempt < MAX_MODIFY_RETRIES) {
+                        // Break out of inner loop, triggering a retry in outer loop
+                        modified = existing; // reset
+                        break;
+                    }
+                    // Provide a preview of the file to help the AI self-correct
+                    const preview = modified.split('\\n').slice(0, 20).join('\\n');
+                    return {
+                        output: '',
+                        error: `Edit #${i + 1} failed: Search content not found in "${filePath}".\\nFile start preview:\\n${preview}\\n...`,
+                    };
+                }
+                modified = applyMatch(modified, match, edit.replaceContent);
+                strategies.push(`Edit #${i + 1}: ${match.strategy}`);
+            }
+            // If we broke out early for a retry, the modified string will equal the existing string
+            // (or we haven't completed all edits), so we continue to the next attempt.
+            if (attempt < MAX_MODIFY_RETRIES && modified === existing && edits.length > 0) {
+                await new Promise((resolve) => setTimeout(resolve, 100));
+                continue;
+            }
+            const validation = validateSyntax(modified, filePath);
+            if (!validation.valid) {
+                return {
+                    output: '',
+                    error: `Syntax validation failed for "${filePath}" after modification:\\n- ${validation.errors.join('\\n- ')}\\n\\nPlease review your replacement content.`,
+                };
+            }
+            changeLogger.logChange(filePath, existing, 'modify');
+            await atomicWriteFile(absPath, modified, 'utf-8');
+            return { output: `Successfully applied ${edits.length} edit(s) to "${filePath}".\\nStrategies used:\\n${strategies.join('\\n')}` };
+        }
+        catch (err) {
+            if (attempt === MAX_MODIFY_RETRIES) {
+                const message = err instanceof Error ? err.message : String(err);
+                return {
+                    output: '',
+                    error: `Failed to modify file "${filePath}": ${message}`,
+                };
+            }
+            await new Promise((resolve) => setTimeout(resolve, 100));
+        }
+    }
+    return { output: '', error: 'Modify failed.' };
+}
+export async function listDirectory(workspaceRoot, dirPath, maxDepth = 3) {
+    try {
+        const absPath = resolveAndValidatePath(workspaceRoot, dirPath);
+        const lines = [];
+        const { ignoredDirs, ignoredFiles } = await getIgnoredPaths(workspaceRoot);
+        async function walk(currentPath, prefix, depth) {
+            if (depth > maxDepth)
+                return;
+            const entries = await fs.readdir(currentPath, { withFileTypes: true });
+            // Sort directories first, then files, both alphabetically
+            const sorted = entries
+                .filter((entry) => !entry.name.startsWith('.'))
+                .sort((a, b) => {
+                if (a.isDirectory() && !b.isDirectory())
+                    return -1;
+                if (!a.isDirectory() && b.isDirectory())
+                    return 1;
+                return a.name.localeCompare(b.name);
+            });
+            for (let i = 0; i < sorted.length; i++) {
+                const entry = sorted[i];
+                const isLast = i === sorted.length - 1;
+                const connector = isLast ? '└── ' : '├── ';
+                const childPrefix = isLast ? '    ' : '│   ';
+                if (entry.isDirectory()) {
+                    if (ignoredDirs.has(entry.name)) {
+                        lines.push(`${prefix}${connector}${entry.name}/ (ignored)`);
+                        continue;
+                    }
+                    lines.push(`${prefix}${connector}${entry.name}/`);
+                    await walk(path.join(currentPath, entry.name), `${prefix}${childPrefix}`, depth + 1);
+                }
+                else {
+                    if (ignoredFiles.has(entry.name))
+                        continue;
+                    if (EXCLUDED_EXTENSIONS.some((ext) => entry.name.endsWith(ext.replace('*', ''))))
+                        continue;
+                    lines.push(`${prefix}${connector}${entry.name}`);
+                }
+            }
+        }
+        await walk(absPath, '', 0);
+        return { output: lines.join('\n') || '(empty directory)' };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+            output: '',
+            error: `Failed to list directory "${dirPath}": ${message}`,
+        };
+    }
+}
+export async function runCommand(workspaceRoot, command) {
+    try {
+        const { stdout, stderr } = await execAsync(command, {
+            cwd: workspaceRoot,
+            timeout: 60_000, // 60 second timeout
+            maxBuffer: 1024 * 1024 * 2, // 2 MB buffer
+        });
+        let output = [stdout, stderr].filter(Boolean).join('\n');
+        // Truncate command output to prevent memory blowout from massive build logs
+        const MAX_CMD_OUTPUT = 50_000;
+        if (output.length > MAX_CMD_OUTPUT) {
+            output = output.substring(0, MAX_CMD_OUTPUT) + '\n... (output truncated — exceeded 50KB limit)';
+        }
+        return { output: output || '(command produced no output)' };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        // Also truncate error output
+        const MAX_ERR_OUTPUT = 30_000;
+        const truncatedMsg = message.length > MAX_ERR_OUTPUT
+            ? message.substring(0, MAX_ERR_OUTPUT) + '\n... (error output truncated)'
+            : message;
+        return { output: '', error: `Command failed: ${truncatedMsg}` };
+    }
+}
+export async function grepSearch(workspaceRoot, pattern, fileGlob) {
+    try {
+        const { ignoredDirs } = await getIgnoredPaths(workspaceRoot);
+        const excludeDirArgs = Array.from(ignoredDirs)
+            .map((dir) => `--exclude-dir="${dir}"`)
+            .concat('--exclude-dir=".*"') // Exclude all hidden directories
+            .join(' ');
+        const excludeFileArgs = EXCLUDED_EXTENSIONS.map((ext) => `--exclude="${ext}"`)
+            .concat('--exclude=".*"') // Exclude all hidden files
+            .join(' ');
+        // Build a grep command that works cross-platform via node
+        // We use grep -rnIEi for recursive, line numbers, skip binary, extended regex, case-insensitive
+        const globArg = fileGlob ? ` --include="${fileGlob}"` : '';
+        const cmd = `grep -rnIEi --color=never ${excludeDirArgs} ${excludeFileArgs}${globArg} "${pattern.replace(/"/g, '\\"')}" .`;
+        const { stdout } = await execAsync(cmd, {
+            cwd: workspaceRoot,
+            timeout: 15_000,
+            maxBuffer: 1024 * 1024 * 2,
+        });
+        // Limit output to 50 results
+        const lines = stdout.trim().split('\n');
+        const limited = lines.slice(0, 50);
+        const resultText = limited.join('\n') + (lines.length > 50 ? `\n\n... (${lines.length - 50} more results truncated)` : '');
+        if (!resultText)
+            return { output: `No matches found for "${pattern}".` };
+        const wrappedResult = `<workspace_file path="grep_search_results">\n<content_data><![CDATA[\n${sanitizeForCDATA(resultText)}\n]]></content_data>\n</workspace_file>`;
+        return { output: wrappedResult };
+    }
+    catch (err) {
+        // grep returns exit code 1 when no matches are found.
+        // Node's execException returns the code as a number.
+        if (err instanceof Error && 'code' in err && err.code === 1) {
+            return { output: `No matches found for "${pattern}".` };
+        }
+        const message = err instanceof Error ? err.message : String(err);
+        // Also handle stringified exit codes just in case
+        if (message.includes('Command failed') &&
+            (message.includes('exit code 1') || message.includes('exited with code 1'))) {
+            return { output: `No matches found for "${pattern}".` };
+        }
+        return { output: '', error: `Grep failed: ${message}` };
+    }
+}
+export async function traceDependencies(workspaceRoot, filePath, direction, maxDepth) {
+    try {
+        const dir = (direction === 'forward' || direction === 'reverse') ? direction : 'both';
+        const depth = maxDepth && maxDepth > 0 ? Math.min(maxDepth, 5) : 3;
+        const result = await findDependencies(workspaceRoot, filePath, dir, depth);
+        const formatted = formatDependencyResult(result);
+        const wrappedResult = `<workspace_file path="dependency_trace_results">\n<content_data><![CDATA[\n${sanitizeForCDATA(formatted)}\n]]></content_data>\n</workspace_file>`;
+        return { output: wrappedResult };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { output: '', error: `Dependency tracing failed for "${filePath}": ${message}` };
+    }
+}
+export async function findRecentChanges(workspaceRoot, dirPath = '.', minutes = 60, maxDepth = 5) {
+    try {
+        const absPath = resolveAndValidatePath(workspaceRoot, dirPath);
+        const { ignoredDirs, ignoredFiles } = await getIgnoredPaths(workspaceRoot);
+        const thresholdMs = Date.now() - (minutes * 60 * 1000);
+        const recentFiles = [];
+        async function walk(currentPath, depth) {
+            if (depth > maxDepth)
+                return;
+            let entries;
+            try {
+                entries = await fs.readdir(currentPath, { withFileTypes: true });
+            }
+            catch {
+                return; // Skip unreadable directories
+            }
+            for (const entry of entries) {
+                if (entry.name.startsWith('.'))
+                    continue;
+                if (entry.isDirectory()) {
+                    if (ignoredDirs.has(entry.name))
+                        continue;
+                    await walk(path.join(currentPath, entry.name), depth + 1);
+                }
+                else {
+                    if (ignoredFiles.has(entry.name))
+                        continue;
+                    if (EXCLUDED_EXTENSIONS.some((ext) => entry.name.endsWith(ext.replace('*', ''))))
+                        continue;
+                    try {
+                        const filePath = path.join(currentPath, entry.name);
+                        const stats = await fs.stat(filePath);
+                        if (stats.mtimeMs >= thresholdMs) {
+                            const relPath = path.relative(workspaceRoot, filePath);
+                            recentFiles.push({ path: relPath, mtime: stats.mtimeMs });
+                        }
+                    }
+                    catch {
+                        // Ignore stat errors
+                    }
+                }
+            }
+        }
+        await walk(absPath, 0);
+        if (recentFiles.length === 0) {
+            return { output: `No files were modified in the last ${minutes} minutes.` };
+        }
+        // Sort by most recently modified first
+        recentFiles.sort((a, b) => b.mtime - a.mtime);
+        // Format output
+        const lines = recentFiles.map(f => {
+            const minsAgo = Math.max(0, Math.round((Date.now() - f.mtime) / 60000));
+            return `- ${f.path} (${minsAgo} minutes ago)`;
+        });
+        const resultText = `Files modified in the last ${minutes} minutes:\n${lines.join('\n')}`;
+        const wrappedResult = `<workspace_file path="recent_changes">\n<content_data><![CDATA[\n${sanitizeForCDATA(resultText)}\n]]></content_data>\n</workspace_file>`;
+        return { output: wrappedResult };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+            output: '',
+            error: `Failed to find recent changes: ${message}`,
+        };
+    }
+}
+// ─── Tool Dispatcher ─────────────────────────────────────────────────
+export async function createAndRunTest(workspaceRoot, language, code) {
+    const extMap = {
+        node: '.js',
+        'ts-node': '.ts',
+        python: '.py',
+        bash: '.sh',
+        go: '.go',
+        rust: '.rs',
+    };
+    const ext = extMap[language.toLowerCase()] || '.txt';
+    const tmpFileName = `.minovative-scratch${ext}`;
+    const absPath = path.join(workspaceRoot, tmpFileName);
+    try {
+        await fs.writeFile(absPath, code, 'utf-8');
+        let cmd = '';
+        switch (language.toLowerCase()) {
+            case 'node':
+                cmd = `node ${tmpFileName}`;
+                break;
+            case 'ts-node':
+                cmd = `npx ts-node ${tmpFileName}`;
+                break;
+            case 'python':
+                cmd = `python3 ${tmpFileName}`;
+                break;
+            case 'bash':
+                cmd = `bash ${tmpFileName}`;
+                break;
+            case 'go':
+                cmd = `go run ${tmpFileName}`;
+                break;
+            case 'rust':
+                cmd = `rustc ${tmpFileName} && ./${tmpFileName.replace('.rs', '')}`;
+                break;
+            default:
+                return { output: '', error: `Unsupported language runtime: ${language}` };
+        }
+        try {
+            const { stdout, stderr } = await execAsync(cmd, { cwd: workspaceRoot, timeout: 15_000 });
+            const out = stdout.trim();
+            const errOut = stderr.trim();
+            let finalOutput = '';
+            if (out)
+                finalOutput += `[STDOUT]\n${out}\n`;
+            if (errOut)
+                finalOutput += `[STDERR]\n${errOut}\n`;
+            if (!finalOutput)
+                finalOutput = 'Script executed successfully with no output.';
+            return { output: `<test_results>\n${sanitizeForCDATA(finalOutput)}\n</test_results>` };
+        }
+        catch (err) {
+            const out = (err.stdout || '').trim();
+            const errOut = (err.stderr || '').trim();
+            let finalOutput = `Script failed with exit code ${err.code || 1}.\n`;
+            if (out)
+                finalOutput += `[STDOUT]\n${out}\n`;
+            if (errOut)
+                finalOutput += `[STDERR]\n${errOut}\n`;
+            return { output: `<test_results>\n${sanitizeForCDATA(finalOutput)}\n</test_results>` };
+        }
+    }
+    catch (err) {
+        return { output: '', error: `Failed to create or run test script: ${err instanceof Error ? err.message : String(err)}` };
+    }
+    finally {
+        try {
+            await fs.rm(absPath, { force: true });
+            if (language.toLowerCase() === 'rust') {
+                const binPath = absPath.replace('.rs', '');
+                await fs.rm(binPath, { force: true });
+            }
+        }
+        catch {
+            // Ignore cleanup errors
+        }
+    }
+}
+/**
+ * Dispatches a function call from the model to the appropriate local tool.
+ * Returns the tool result as a string to feed back to the model.
+ */
+export async function executeTool(workspaceRoot, toolName, args) {
+    switch (toolName) {
+        case 'read_file':
+            return readFile(workspaceRoot, args.filePath, args.startLine, args.endLine, args.targetElements);
+        case 'write_file':
+            return writeFile(workspaceRoot, args.filePath, args.content);
+        case 'delete_file':
+            return deleteFile(workspaceRoot, args.filePath);
+        case 'rename_file':
+            return renameFile(workspaceRoot, args.sourcePath, args.targetPath);
+        case 'modify_file':
+            return modifyFile(workspaceRoot, args.filePath, args.edits);
+        case 'list_directory':
+            return listDirectory(workspaceRoot, args.dirPath, args.maxDepth ?? 3);
+        case 'run_command':
+            return runCommand(workspaceRoot, args.command);
+        case 'create_and_run_test':
+            return createAndRunTest(workspaceRoot, args.language, args.code);
+        case 'grep_search':
+            return grepSearch(workspaceRoot, args.pattern, args.fileGlob);
+        case 'find_dependencies':
+            return traceDependencies(workspaceRoot, args.filePath, args.direction, args.maxDepth);
+        case 'find_recent_changes':
+            return findRecentChanges(workspaceRoot, args.dirPath, args.minutes, args.maxDepth);
+        default:
+            return { output: '', error: `Unknown tool: "${toolName}"` };
+    }
+}