dartmind 17.0.0

package/dist/tools/NativeTools.js

@@ -0,0 +1,1186 @@
+// packages/core/src/tools/NativeTools.ts
+// Native Claude Code-compatible tools for FlutterAI V15
+// Provides: Read, Write, Edit, Bash, Glob, Grep, Task, WebFetch, TodoWrite, AskUserQuestion
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { glob } from 'glob';
+import { createHash } from 'crypto';
+// Safety integration
+import { quickSafety } from '../safety/QuickSafety.js';
+// V15: Security constants
+import { BLOCKED_COMMAND_PATTERNS, HIGH_RISK_COMMAND_PATTERNS, MEDIUM_RISK_COMMAND_PATTERNS, HIGH_RISK_WRITE_PATHS, SECRET_PATTERNS, PLACEHOLDER_TOOLS, TOOL_ALTERNATIVES, MAX_CHECKPOINTS, BASH_DEFAULT_TIMEOUT_MS, } from '../constants/limits.js';
+const execAsync = promisify(exec);
+// =============================================================================
+// CHECKPOINT MANAGER (for undo/rewind support)
+// =============================================================================
+class CheckpointManager {
+    checkpoints = new Map();
+    maxCheckpointsPerFile = MAX_CHECKPOINTS;
+    async createCheckpoint(filePath) {
+        try {
+            const absolutePath = path.resolve(filePath);
+            const content = await fs.readFile(absolutePath, 'utf-8');
+            const hash = createHash('sha256').update(content).digest('hex');
+            const checkpoint = {
+                path: absolutePath,
+                content,
+                hash,
+                timestamp: new Date(),
+            };
+            const fileCheckpoints = this.checkpoints.get(absolutePath) || [];
+            fileCheckpoints.push(checkpoint);
+            // Keep only last N checkpoints
+            if (fileCheckpoints.length > this.maxCheckpointsPerFile) {
+                fileCheckpoints.shift();
+            }
+            this.checkpoints.set(absolutePath, fileCheckpoints);
+        }
+        catch {
+            // File doesn't exist yet, no checkpoint needed
+        }
+    }
+    async revert(filePath, steps = 1) {
+        const absolutePath = path.resolve(filePath);
+        const fileCheckpoints = this.checkpoints.get(absolutePath);
+        if (!fileCheckpoints || fileCheckpoints.length === 0) {
+            return false;
+        }
+        const targetIndex = Math.max(0, fileCheckpoints.length - steps - 1);
+        const checkpoint = fileCheckpoints[targetIndex];
+        await fs.writeFile(absolutePath, checkpoint.content);
+        // Remove checkpoints after this point
+        this.checkpoints.set(absolutePath, fileCheckpoints.slice(0, targetIndex + 1));
+        return true;
+    }
+    getCheckpoints(filePath) {
+        return this.checkpoints.get(path.resolve(filePath)) || [];
+    }
+}
+export const checkpointManager = new CheckpointManager();
+// =============================================================================
+// TOOL 1: READ
+// =============================================================================
+export const ReadTool = {
+    name: 'Read',
+    description: `Read the contents of a file from the filesystem.
+
+WHEN TO USE:
+- To understand existing code before making changes
+- To check configuration files (pubspec.yaml, analysis_options.yaml)
+- To read documentation or README files
+- To examine error logs or output files
+
+OUTPUT FORMAT:
+- Returns file content with line numbers (1-indexed)
+- Supports optional line range with start_line/end_line
+- Truncates files larger than 100KB with a note
+
+EXAMPLES:
+- Read entire file: { "file_path": "lib/main.dart" }
+- Read specific lines: { "file_path": "lib/main.dart", "start_line": 10, "end_line": 50 }`,
+    input_schema: {
+        type: 'object',
+        properties: {
+            file_path: {
+                type: 'string',
+                description: 'Absolute or relative path to the file to read',
+            },
+            start_line: {
+                type: 'number',
+                description: 'Optional: Start reading from this line (1-indexed)',
+            },
+            end_line: {
+                type: 'number',
+                description: 'Optional: Stop reading at this line (inclusive)',
+            },
+        },
+        required: ['file_path'],
+    },
+};
+export async function executeRead(params) {
+    try {
+        const absolutePath = path.resolve(params.file_path);
+        // Check if file exists
+        try {
+            await fs.access(absolutePath);
+        }
+        catch {
+            return {
+                success: false,
+                error: `File not found: ${absolutePath}`,
+            };
+        }
+        const content = await fs.readFile(absolutePath, 'utf-8');
+        const lines = content.split('\n');
+        const startIdx = Math.max(0, (params.start_line ?? 1) - 1);
+        const endIdx = Math.min(lines.length, params.end_line ?? lines.length);
+        const selectedLines = lines.slice(startIdx, endIdx);
+        const numberedContent = selectedLines
+            .map((line, idx) => {
+            const lineNum = (startIdx + idx + 1).toString().padStart(4);
+            return `${lineNum}\t${line}`;
+        })
+            .join('\n');
+        const totalLines = lines.length;
+        const isPartial = startIdx > 0 || endIdx < totalLines;
+        let output = numberedContent;
+        if (isPartial) {
+            output = `[Showing lines ${startIdx + 1}-${endIdx} of ${totalLines}]\n\n${numberedContent}`;
+        }
+        // Truncate very large outputs
+        const MAX_CHARS = 100000;
+        if (output.length > MAX_CHARS) {
+            output =
+                output.substring(0, MAX_CHARS) +
+                    '\n\n[TRUNCATED - File too large. Use start_line/end_line to read specific sections]';
+        }
+        return {
+            success: true,
+            output,
+            metadata: {
+                file_path: absolutePath,
+                total_lines: totalLines,
+                lines_shown: selectedLines.length,
+            },
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Failed to read file: ${error.message}`,
+        };
+    }
+}
+// =============================================================================
+// TOOL 2: WRITE
+// =============================================================================
+export const WriteTool = {
+    name: 'Write',
+    description: `Write content to a file. Creates the file if it doesn't exist, creates parent directories as needed.
+
+WHEN TO USE:
+- To create new files (widgets, services, models)
+- To completely replace file contents
+- For generated code, configs, documentation
+
+SAFETY FEATURES:
+- Creates automatic checkpoint before overwriting (for /rewind)
+- Creates parent directories automatically
+- Validates path is within project directory
+
+EXAMPLES:
+- Create new file: { "file_path": "lib/widgets/button.dart", "content": "..." }
+- Overwrite existing: { "file_path": "lib/main.dart", "content": "..." }`,
+    input_schema: {
+        type: 'object',
+        properties: {
+            file_path: {
+                type: 'string',
+                description: 'Path where the file should be written',
+            },
+            content: {
+                type: 'string',
+                description: 'Content to write to the file',
+            },
+        },
+        required: ['file_path', 'content'],
+    },
+};
+// V15: Write risk assessment
+function assessWriteRisk(filePath, content) {
+    const warnings = [];
+    let risk = 'low';
+    // Check for high-risk paths
+    for (const riskyPath of HIGH_RISK_WRITE_PATHS) {
+        if (filePath.includes(riskyPath)) {
+            risk = 'high';
+            warnings.push(`Writing to sensitive path: ${riskyPath}`);
+        }
+    }
+    // Check for secrets in content
+    for (const pattern of SECRET_PATTERNS) {
+        if (pattern.test(content)) {
+            risk = 'high';
+            warnings.push('Content appears to contain secrets/credentials');
+            break;
+        }
+    }
+    // Check for system paths
+    if (filePath.startsWith('/etc/') || filePath.startsWith('/usr/') || filePath.startsWith('/var/')) {
+        risk = 'critical';
+        warnings.push('Writing to system directory');
+    }
+    return { risk, warnings };
+}
+export async function executeWrite(params) {
+    try {
+        const absolutePath = path.resolve(params.file_path);
+        const dir = path.dirname(absolutePath);
+        // V15: Risk assessment
+        const { risk, warnings } = assessWriteRisk(absolutePath, params.content);
+        // Block critical risk writes
+        if (risk === 'critical') {
+            return {
+                success: false,
+                error: `🛑 Write blocked (critical risk): ${warnings.join(', ')}`,
+                metadata: { risk, warnings, blocked: true },
+            };
+        }
+        // Pre-flight safety check (fast, <60ms)
+        const safetyCheck = await quickSafety.quickCheck(params.content, absolutePath);
+        if (!safetyCheck.passed) {
+            return {
+                success: false,
+                error: `Safety check failed: ${safetyCheck.reason}`,
+                metadata: { gate: safetyCheck.gate, ms: safetyCheck.ms },
+            };
+        }
+        // Create checkpoint if file exists
+        await checkpointManager.createCheckpoint(absolutePath);
+        // Create directory if needed
+        await fs.mkdir(dir, { recursive: true });
+        // Check if file exists
+        let hadExisting = false;
+        try {
+            await fs.access(absolutePath);
+            hadExisting = true;
+        }
+        catch {
+            // File doesn't exist
+        }
+        // Write the file
+        await fs.writeFile(absolutePath, params.content, 'utf-8');
+        // Post-flight thorough check (background, non-blocking)
+        quickSafety.thoroughCheck(absolutePath);
+        const lines = params.content.split('\n').length;
+        const bytes = Buffer.byteLength(params.content, 'utf-8');
+        // V15: Include risk info in output
+        let output = hadExisting
+            ? `Updated ${absolutePath} (${lines} lines, ${bytes} bytes)`
+            : `Created ${absolutePath} (${lines} lines, ${bytes} bytes)`;
+        if (warnings.length > 0) {
+            output += `\n⚠️ Warnings: ${warnings.join(', ')}`;
+        }
+        return {
+            success: true,
+            output,
+            metadata: {
+                file_path: absolutePath,
+                lines_written: lines,
+                bytes_written: bytes,
+                had_existing: hadExisting,
+                action: hadExisting ? 'updated' : 'created',
+                safety_check_ms: safetyCheck.ms,
+                risk,
+                warnings,
+            },
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Failed to write file: ${error.message}`,
+        };
+    }
+}
+// =============================================================================
+// TOOL 3: EDIT
+// =============================================================================
+export const EditTool = {
+    name: 'Edit',
+    description: `Make surgical edits to a file using exact string replacement.
+
+WHEN TO USE:
+- To fix bugs in existing code
+- To rename variables/functions
+- To update specific values or imports
+- To add/remove small sections of code
+
+MATCHING RULES:
+- old_string must match EXACTLY (including whitespace, indentation, newlines)
+- If multiple matches found, the edit is rejected (add more context to make unique)
+- If no match found, the edit is rejected
+
+BEST PRACTICES:
+- Include enough surrounding context to ensure unique match
+- For multi-line edits, include the full block
+- Use Write for large rewrites instead
+- Verify changes with Read after editing
+
+EXAMPLES:
+- Fix a typo: { "file_path": "lib/main.dart", "old_string": "pritn(", "new_string": "print(" }
+- Update import: { "file_path": "lib/main.dart", "old_string": "import 'old.dart';", "new_string": "import 'new.dart';" }`,
+    input_schema: {
+        type: 'object',
+        properties: {
+            file_path: {
+                type: 'string',
+                description: 'Path to the file to edit',
+            },
+            old_string: {
+                type: 'string',
+                description: 'The exact string to find (must match exactly, including whitespace)',
+            },
+            new_string: {
+                type: 'string',
+                description: 'The string to replace it with',
+            },
+        },
+        required: ['file_path', 'old_string', 'new_string'],
+    },
+};
+export async function executeEdit(params) {
+    try {
+        const absolutePath = path.resolve(params.file_path);
+        // Check if file exists
+        try {
+            await fs.access(absolutePath);
+        }
+        catch {
+            return {
+                success: false,
+                error: `File not found: ${absolutePath}`,
+            };
+        }
+        const content = await fs.readFile(absolutePath, 'utf-8');
+        // Check if old_string exists
+        const occurrences = content.split(params.old_string).length - 1;
+        if (occurrences === 0) {
+            // Try to help debug by showing similar content
+            const lines = content.split('\n');
+            const searchTerms = params.old_string.split('\n')[0].trim().substring(0, 30);
+            const similarLines = lines
+                .map((line, idx) => ({ line, idx }))
+                .filter(({ line }) => line.includes(searchTerms.substring(0, 10)))
+                .slice(0, 3)
+                .map(({ line, idx }) => `  Line ${idx + 1}: ${line.substring(0, 80)}...`);
+            let hint = '';
+            if (similarLines.length > 0) {
+                hint = `\n\nSimilar content found:\n${similarLines.join('\n')}`;
+            }
+            return {
+                success: false,
+                error: `Could not find the specified string in ${absolutePath}. Make sure it matches exactly, including whitespace and newlines.${hint}`,
+            };
+        }
+        if (occurrences > 1) {
+            return {
+                success: false,
+                error: `Found ${occurrences} occurrences of the string in ${absolutePath}. Please provide more surrounding context to make the match unique.`,
+            };
+        }
+        // Create checkpoint before edit
+        await checkpointManager.createCheckpoint(absolutePath);
+        // Perform replacement
+        const newContent = content.replace(params.old_string, params.new_string);
+        await fs.writeFile(absolutePath, newContent, 'utf-8');
+        // Calculate diff stats
+        const oldLines = params.old_string.split('\n').length;
+        const newLines = params.new_string.split('\n').length;
+        const linesDiff = newLines - oldLines;
+        return {
+            success: true,
+            output: `Successfully edited ${absolutePath} (${linesDiff >= 0 ? '+' : ''}${linesDiff} lines)`,
+            metadata: {
+                file_path: absolutePath,
+                chars_removed: params.old_string.length,
+                chars_added: params.new_string.length,
+                lines_removed: oldLines,
+                lines_added: newLines,
+            },
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Failed to edit file: ${error.message}`,
+        };
+    }
+}
+// =============================================================================
+// TOOL 4: BASH
+// =============================================================================
+// V15: Enhanced command analysis using constants
+function analyzeBashCommand(command) {
+    const cmd = command.toLowerCase().trim();
+    // Check blocked patterns (NEVER execute)
+    for (const { pattern, reason } of BLOCKED_COMMAND_PATTERNS) {
+        if (pattern.test(cmd)) {
+            return { blocked: true, reason, risk: 'critical', destructive: true };
+        }
+    }
+    // Check high-risk patterns (require extra caution)
+    for (const { pattern, warning } of HIGH_RISK_COMMAND_PATTERNS) {
+        if (pattern.test(cmd)) {
+            return { blocked: false, risk: 'high', destructive: true, warning };
+        }
+    }
+    // Check medium-risk patterns
+    for (const pattern of MEDIUM_RISK_COMMAND_PATTERNS) {
+        if (pattern.test(cmd)) {
+            return { blocked: false, risk: 'medium', destructive: false };
+        }
+    }
+    // Default: low risk
+    return { blocked: false, risk: 'low', destructive: false };
+}
+const ALLOWED_COMMANDS = [
+    // File operations
+    'ls', 'cat', 'head', 'tail', 'wc', 'find', 'tree', 'mkdir', 'cp', 'mv', 'rm', 'touch',
+    // Git
+    'git',
+    // Flutter/Dart
+    'flutter', 'dart', 'pub',
+    // Build tools
+    'npm', 'yarn', 'pnpm', 'node', 'npx',
+    // Utilities
+    'grep', 'sed', 'awk', 'sort', 'uniq', 'diff', 'which', 'echo', 'pwd', 'env',
+    'curl', 'wget', // Without piping to shell
+    // Package managers
+    'brew', 'apt', 'yum', 'pip', 'cargo',
+];
+export const BashTool = {
+    name: 'Bash',
+    description: `Execute shell commands in the terminal.
+
+WHEN TO USE:
+- Running Flutter/Dart commands (flutter pub get, dart analyze)
+- Git operations (git status, git commit, git push)
+- File system operations (ls, mkdir, find)
+- Installing packages
+- Running tests and builds
+
+ALLOWED COMMANDS:
+- Flutter: flutter pub get, flutter analyze, flutter test, flutter build
+- Dart: dart analyze, dart fix, dart format, dart run
+- Git: All standard git commands
+- File ops: ls, cat, mkdir, cp, mv, rm, find, tree
+- Utilities: grep, sed, awk, curl, wget
+
+BLOCKED (security):
+- sudo, su (privilege escalation)
+- rm -rf / (destructive)
+- Piping to shell (curl | bash)
+- Network scanning tools
+
+TIMEOUT: 5 minutes default, configurable up to 10 minutes`,
+    input_schema: {
+        type: 'object',
+        properties: {
+            command: {
+                type: 'string',
+                description: 'The shell command to execute',
+            },
+            working_directory: {
+                type: 'string',
+                description: 'Optional: Directory to run the command in (default: current directory)',
+            },
+            timeout: {
+                type: 'number',
+                description: 'Optional: Timeout in milliseconds (default: 300000 = 5 min, max: 600000)',
+            },
+        },
+        required: ['command'],
+    },
+};
+export async function executeBash(params) {
+    // V15: Enhanced security check with command analysis
+    const analysis = analyzeBashCommand(params.command);
+    // Block critical/forbidden commands
+    if (analysis.blocked) {
+        return {
+            success: false,
+            error: `🛑 Command blocked: ${analysis.reason}\n\nThis command is not allowed for security reasons.`,
+            metadata: { blocked: true, reason: analysis.reason, risk: analysis.risk },
+        };
+    }
+    // Warn about high-risk commands (but allow them)
+    if (analysis.risk === 'high' && analysis.warning) {
+        console.warn(`⚠️  High-risk command: ${analysis.warning}`);
+    }
+    try {
+        const cwd = params.working_directory || process.cwd();
+        const timeout = Math.min(params.timeout || BASH_DEFAULT_TIMEOUT_MS, 600000); // Max 10 minutes
+        const startTime = Date.now();
+        const { stdout, stderr } = await execAsync(params.command, {
+            cwd,
+            timeout,
+            maxBuffer: 10 * 1024 * 1024, // 10MB buffer
+            env: {
+                ...process.env,
+                FORCE_COLOR: '1', // Enable colored output
+            },
+        });
+        const duration = Date.now() - startTime;
+        let output = '';
+        if (stdout)
+            output += stdout;
+        if (stderr) {
+            // Only add stderr if it's not just warnings
+            const isWarningOnly = stderr.includes('Warning') && !stderr.includes('Error');
+            if (!isWarningOnly || !stdout) {
+                output += (output ? '\n\n[STDERR]:\n' : '') + stderr;
+            }
+        }
+        // Truncate very large outputs
+        const MAX_CHARS = 50000;
+        if (output.length > MAX_CHARS) {
+            const truncated = output.substring(0, MAX_CHARS);
+            output = truncated + `\n\n[TRUNCATED - Output exceeded ${MAX_CHARS} characters]`;
+        }
+        return {
+            success: true,
+            output: output || '[Command completed with no output]',
+            metadata: {
+                command: params.command,
+                cwd,
+                duration_ms: duration,
+                stdout_bytes: stdout?.length || 0,
+                stderr_bytes: stderr?.length || 0,
+                risk: analysis.risk,
+                warning: analysis.warning,
+            },
+        };
+    }
+    catch (error) {
+        // Check if it's a timeout
+        if (error.killed) {
+            return {
+                success: false,
+                error: `Command timed out after ${params.timeout || BASH_DEFAULT_TIMEOUT_MS}ms`,
+            };
+        }
+        // Include stderr in error message if available
+        let errorMsg = error.message;
+        if (error.stderr) {
+            errorMsg += `\n\nSTDERR:\n${error.stderr}`;
+        }
+        if (error.stdout) {
+            errorMsg += `\n\nSTDOUT (before failure):\n${error.stdout}`;
+        }
+        return {
+            success: false,
+            error: `Command failed (exit code ${error.code || 'unknown'}):\n${errorMsg}`,
+        };
+    }
+}
+// =============================================================================
+// TOOL 5: GLOB
+// =============================================================================
+export const GlobTool = {
+    name: 'Glob',
+    description: `Find files matching a glob pattern. Use to discover project structure or locate files.
+
+PATTERN SYNTAX:
+- *        matches any characters except /
+- **       matches any characters including / (recursive)
+- ?        matches single character
+- [abc]    matches any of a, b, c
+- [a-z]    matches range
+- {a,b}    matches either a or b
+- !pattern negates the pattern
+
+COMMON PATTERNS:
+- "**/*.dart"           All Dart files recursively
+- "lib/**/*.dart"       Dart files in lib directory
+- "**/*_test.dart"      All test files
+- "**/{*.dart,*.yaml}"  Dart and YAML files
+- "**/widget_*.dart"    Files starting with widget_
+
+IGNORED BY DEFAULT:
+- node_modules, .git, build, .dart_tool`,
+    input_schema: {
+        type: 'object',
+        properties: {
+            pattern: {
+                type: 'string',
+                description: 'Glob pattern to match files',
+            },
+            cwd: {
+                type: 'string',
+                description: 'Optional: Directory to search from (default: current directory)',
+            },
+            ignore: {
+                type: 'array',
+                items: { type: 'string' },
+                description: 'Optional: Additional patterns to ignore',
+            },
+        },
+        required: ['pattern'],
+    },
+};
+export async function executeGlob(params) {
+    try {
+        const cwd = params.cwd || process.cwd();
+        const defaultIgnore = [
+            '**/node_modules/**',
+            '**/.git/**',
+            '**/build/**',
+            '**/.dart_tool/**',
+            '**/.idea/**',
+            '**/coverage/**',
+            '**/*.g.dart',
+            '**/*.freezed.dart',
+        ];
+        const ignore = [...defaultIgnore, ...(params.ignore || [])];
+        const files = await glob(params.pattern, {
+            cwd,
+            ignore,
+            nodir: true,
+            dot: false,
+        });
+        if (files.length === 0) {
+            return {
+                success: true,
+                output: `No files found matching pattern: ${params.pattern}`,
+                metadata: { pattern: params.pattern, count: 0 },
+            };
+        }
+        // Sort files by path
+        const sorted = files.sort();
+        // Group by directory for better readability
+        const byDir = {};
+        for (const file of sorted) {
+            const dir = path.dirname(file) || '.';
+            if (!byDir[dir])
+                byDir[dir] = [];
+            byDir[dir].push(path.basename(file));
+        }
+        let output = `Found ${files.length} file${files.length !== 1 ? 's' : ''}:\n\n`;
+        // If few enough files, list them directly
+        if (files.length <= 50) {
+            output += sorted.join('\n');
+        }
+        else {
+            // Otherwise, show directory summary
+            output += Object.entries(byDir)
+                .sort(([a], [b]) => a.localeCompare(b))
+                .map(([dir, dirFiles]) => `${dir}/ (${dirFiles.length} files)`)
+                .join('\n');
+            output += `\n\n[Showing directory summary. Use a more specific pattern to see individual files.]`;
+        }
+        return {
+            success: true,
+            output,
+            metadata: {
+                pattern: params.pattern,
+                count: files.length,
+                files: sorted.slice(0, 100), // Limit metadata
+            },
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Glob failed: ${error.message}`,
+        };
+    }
+}
+// =============================================================================
+// TOOL 6: GREP
+// =============================================================================
+export const GrepTool = {
+    name: 'Grep',
+    description: `Search file contents for a pattern. Find code usages, definitions, or specific text.
+
+SEARCH MODES:
+- Literal string search (default)
+- Regex search (when regex: true)
+- Case-insensitive (when ignore_case: true)
+
+OUTPUT FORMAT:
+- Shows matching lines with file paths and line numbers
+- Limited to first 100 matches by default
+- Use max_results to adjust limit
+
+EXAMPLES:
+- Find function: { "pattern": "void main(", "path": "lib/" }
+- Find class: { "pattern": "class.*Widget", "path": "lib/", "regex": true }
+- Find usage: { "pattern": "MyService", "path": ".", "include": "*.dart" }`,
+    input_schema: {
+        type: 'object',
+        properties: {
+            pattern: {
+                type: 'string',
+                description: 'Search pattern (string or regex)',
+            },
+            path: {
+                type: 'string',
+                description: 'File or directory to search in',
+            },
+            regex: {
+                type: 'boolean',
+                description: 'Treat pattern as regex (default: false)',
+            },
+            ignore_case: {
+                type: 'boolean',
+                description: 'Case-insensitive search (default: false)',
+            },
+            include: {
+                type: 'string',
+                description: 'Glob pattern for files to include (e.g., "*.dart")',
+            },
+            max_results: {
+                type: 'number',
+                description: 'Maximum results to return (default: 100)',
+            },
+        },
+        required: ['pattern', 'path'],
+    },
+};
+export async function executeGrep(params) {
+    try {
+        const maxResults = params.max_results || 100;
+        const searchPath = path.resolve(params.path);
+        // Build grep command
+        let grepCmd = 'grep -rn';
+        grepCmd += ' --color=never'; // Disable color codes in output
+        if (params.ignore_case)
+            grepCmd += ' -i';
+        if (!params.regex)
+            grepCmd += ' -F'; // Fixed string mode
+        if (params.include) {
+            grepCmd += ` --include="${params.include}"`;
+        }
+        // Add common excludes
+        grepCmd += ' --exclude-dir=node_modules';
+        grepCmd += ' --exclude-dir=.git';
+        grepCmd += ' --exclude-dir=build';
+        grepCmd += ' --exclude-dir=.dart_tool';
+        grepCmd += ' --exclude="*.g.dart"';
+        grepCmd += ' --exclude="*.freezed.dart"';
+        // Escape pattern for shell
+        const escapedPattern = params.pattern.replace(/'/g, "'\\''");
+        grepCmd += ` '${escapedPattern}' "${searchPath}"`;
+        grepCmd += ` | head -n ${maxResults + 1}`; // +1 to detect truncation
+        const { stdout } = await execAsync(grepCmd, {
+            maxBuffer: 10 * 1024 * 1024,
+        });
+        if (!stdout.trim()) {
+            return {
+                success: true,
+                output: `No matches found for: ${params.pattern}`,
+                metadata: { pattern: params.pattern, count: 0 },
+            };
+        }
+        const lines = stdout.trim().split('\n');
+        const truncated = lines.length > maxResults;
+        const displayLines = truncated ? lines.slice(0, maxResults) : lines;
+        let output = `Found ${truncated ? `${maxResults}+` : lines.length} match${lines.length !== 1 ? 'es' : ''}:\n\n`;
+        output += displayLines.join('\n');
+        if (truncated) {
+            output += `\n\n[Results truncated at ${maxResults}. Use max_results parameter to see more.]`;
+        }
+        return {
+            success: true,
+            output,
+            metadata: {
+                pattern: params.pattern,
+                count: displayLines.length,
+                truncated,
+            },
+        };
+    }
+    catch (error) {
+        // grep returns exit code 1 for no matches, which throws
+        if (error.code === 1 && !error.stderr) {
+            return {
+                success: true,
+                output: `No matches found for: ${params.pattern}`,
+                metadata: { pattern: params.pattern, count: 0 },
+            };
+        }
+        return {
+            success: false,
+            error: `Grep failed: ${error.message}`,
+        };
+    }
+}
+// =============================================================================
+// TOOL 7: WEB FETCH
+// =============================================================================
+export const WebFetchTool = {
+    name: 'WebFetch',
+    description: `Fetch content from a URL. Read documentation, API responses, or web content.
+
+SUPPORTED CONTENT:
+- HTML pages (returned as text, consider using for docs)
+- JSON APIs (parsed and formatted)
+- Plain text and Markdown
+- XML
+
+NOT SUPPORTED:
+- Binary files (images, PDFs, videos)
+- Files larger than 1MB
+
+EXAMPLES:
+- Fetch docs: { "url": "https://pub.dev/packages/dio" }
+- Fetch API: { "url": "https://api.example.com/data" }`,
+    input_schema: {
+        type: 'object',
+        properties: {
+            url: {
+                type: 'string',
+                description: 'URL to fetch',
+            },
+            headers: {
+                type: 'object',
+                description: 'Optional: Custom headers to include',
+            },
+            timeout: {
+                type: 'number',
+                description: 'Optional: Timeout in milliseconds (default: 30000)',
+            },
+        },
+        required: ['url'],
+    },
+};
+export async function executeWebFetch(params) {
+    try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), params.timeout || 30000);
+        const response = await fetch(params.url, {
+            headers: {
+                'User-Agent': 'FlutterAI/12.2',
+                ...params.headers,
+            },
+            signal: controller.signal,
+        });
+        clearTimeout(timeoutId);
+        if (!response.ok) {
+            return {
+                success: false,
+                error: `HTTP ${response.status}: ${response.statusText}`,
+            };
+        }
+        const contentType = response.headers.get('content-type') || '';
+        const contentLength = parseInt(response.headers.get('content-length') || '0', 10);
+        // Check size limit
+        if (contentLength > 1024 * 1024) {
+            return {
+                success: false,
+                error: `Content too large: ${(contentLength / 1024 / 1024).toFixed(1)}MB (max 1MB)`,
+            };
+        }
+        // Handle JSON
+        if (contentType.includes('application/json')) {
+            const json = await response.json();
+            return {
+                success: true,
+                output: JSON.stringify(json, null, 2),
+                metadata: { url: params.url, content_type: 'json' },
+            };
+        }
+        // Handle text content
+        if (contentType.includes('text/') ||
+            contentType.includes('application/xml') ||
+            contentType.includes('application/javascript')) {
+            let text = await response.text();
+            // Truncate large responses
+            const MAX_CHARS = 50000;
+            const truncated = text.length > MAX_CHARS;
+            if (truncated) {
+                text = text.substring(0, MAX_CHARS) + '\n\n[TRUNCATED]';
+            }
+            return {
+                success: true,
+                output: text,
+                metadata: { url: params.url, content_type: contentType, truncated },
+            };
+        }
+        return {
+            success: false,
+            error: `Unsupported content type: ${contentType}`,
+        };
+    }
+    catch (error) {
+        if (error.name === 'AbortError') {
+            return {
+                success: false,
+                error: `Request timed out after ${params.timeout || 30000}ms`,
+            };
+        }
+        return {
+            success: false,
+            error: `Fetch failed: ${error.message}`,
+        };
+    }
+}
+// =============================================================================
+// TOOL 8: TODO WRITE
+// =============================================================================
+export const TodoWriteTool = {
+    name: 'TodoWrite',
+    description: `Manage a todo list for tracking work items during the session.
+
+OPERATIONS:
+- add: Add a new todo item
+- complete: Mark an item as done
+- remove: Delete an item
+- list: Show all items
+- clear: Remove all items
+
+The todo list persists for the duration of the session and helps track progress on complex tasks.`,
+    input_schema: {
+        type: 'object',
+        properties: {
+            operation: {
+                type: 'string',
+                enum: ['add', 'complete', 'remove', 'list', 'clear'],
+                description: 'Operation to perform',
+            },
+            content: {
+                type: 'string',
+                description: 'Todo item content (for add operation)',
+            },
+            id: {
+                type: 'number',
+                description: 'Todo item ID (for complete/remove operations)',
+            },
+        },
+        required: ['operation'],
+    },
+};
+const todoList = [];
+let todoIdCounter = 1;
+export async function executeTodoWrite(params) {
+    switch (params.operation) {
+        case 'add':
+            if (!params.content) {
+                return { success: false, error: 'Content required for add operation' };
+            }
+            const newTodo = {
+                id: todoIdCounter++,
+                content: params.content,
+                completed: false,
+                created: new Date(),
+            };
+            todoList.push(newTodo);
+            return {
+                success: true,
+                output: `Added todo #${newTodo.id}: ${newTodo.content}`,
+                metadata: { id: newTodo.id },
+            };
+        case 'complete':
+            if (params.id === undefined) {
+                return { success: false, error: 'ID required for complete operation' };
+            }
+            const toComplete = todoList.find((t) => t.id === params.id);
+            if (!toComplete) {
+                return { success: false, error: `Todo #${params.id} not found` };
+            }
+            toComplete.completed = true;
+            return {
+                success: true,
+                output: `Completed todo #${params.id}: ${toComplete.content}`,
+            };
+        case 'remove':
+            if (params.id === undefined) {
+                return { success: false, error: 'ID required for remove operation' };
+            }
+            const idx = todoList.findIndex((t) => t.id === params.id);
+            if (idx === -1) {
+                return { success: false, error: `Todo #${params.id} not found` };
+            }
+            const removed = todoList.splice(idx, 1)[0];
+            return {
+                success: true,
+                output: `Removed todo #${params.id}: ${removed.content}`,
+            };
+        case 'list':
+            if (todoList.length === 0) {
+                return { success: true, output: 'No todo items.' };
+            }
+            const pending = todoList.filter((t) => !t.completed);
+            const completed = todoList.filter((t) => t.completed);
+            let output = '';
+            if (pending.length > 0) {
+                output += 'Pending:\n';
+                output += pending.map((t) => `  [ ] #${t.id}: ${t.content}`).join('\n');
+            }
+            if (completed.length > 0) {
+                if (output)
+                    output += '\n\n';
+                output += 'Completed:\n';
+                output += completed.map((t) => `  [x] #${t.id}: ${t.content}`).join('\n');
+            }
+            return {
+                success: true,
+                output,
+                metadata: { pending: pending.length, completed: completed.length },
+            };
+        case 'clear':
+            const count = todoList.length;
+            todoList.length = 0;
+            todoIdCounter = 1;
+            return {
+                success: true,
+                output: `Cleared ${count} todo item${count !== 1 ? 's' : ''}.`,
+            };
+        default:
+            return { success: false, error: `Unknown operation: ${params.operation}` };
+    }
+}
+// =============================================================================
+// TOOL 9: ASK USER QUESTION
+// =============================================================================
+export const AskUserQuestionTool = {
+    name: 'AskUserQuestion',
+    description: `Ask the user a question and wait for their response.
+
+WHEN TO USE:
+- Clarifying ambiguous requirements
+- Confirming before destructive operations
+- Getting user preferences or choices
+- Requesting missing information
+
+The question will be displayed to the user and execution will pause until they respond.`,
+    input_schema: {
+        type: 'object',
+        properties: {
+            question: {
+                type: 'string',
+                description: 'The question to ask the user',
+            },
+            options: {
+                type: 'array',
+                items: { type: 'string' },
+                description: 'Optional: Multiple choice options for the user to select from',
+            },
+            default: {
+                type: 'string',
+                description: 'Optional: Default answer if user just presses enter',
+            },
+        },
+        required: ['question'],
+    },
+};
+// Note: Actual implementation requires integration with TUI input system
+// This is a placeholder that will be wired up in ChatEngine
+export async function executeAskUserQuestion(params, userInputCallback) {
+    if (!userInputCallback) {
+        return {
+            success: false,
+            error: 'User input not available in this context',
+        };
+    }
+    try {
+        const response = await userInputCallback(params.question, params.options);
+        return {
+            success: true,
+            output: response || params.default || '',
+            metadata: { question: params.question },
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Failed to get user input: ${error.message}`,
+        };
+    }
+}
+// =============================================================================
+// TOOL 10: TASK (Subagent)
+// =============================================================================
+export const TaskTool = {
+    name: 'Task',
+    description: `Spawn a subagent to handle a complex subtask independently.
+
+WHEN TO USE:
+- Complex multi-step operations that benefit from focused context
+- Parallel work (multiple tasks can run simultaneously)
+- Tasks that might fail and need isolation
+- When main conversation context is getting full
+
+CAPABILITIES:
+- Subagent has access to all tools
+- Operates with fresh context focused on the specific task
+- Returns results when complete
+
+NOTE: This tool requires the agentic loop system to be active.`,
+    input_schema: {
+        type: 'object',
+        properties: {
+            description: {
+                type: 'string',
+                description: 'Short description of the task (shown in /tasks)',
+            },
+            instructions: {
+                type: 'string',
+                description: 'Detailed instructions for completing the task',
+            },
+            working_directory: {
+                type: 'string',
+                description: 'Optional: Directory context for the subagent',
+            },
+            timeout: {
+                type: 'number',
+                description: 'Optional: Timeout in milliseconds (default: 600000 = 10 min)',
+            },
+        },
+        required: ['description', 'instructions'],
+    },
+};
+// Note: Task execution requires integration with AgentOrchestrator
+// This is defined here for tool registration but executed in the agentic loop
+// =============================================================================
+// EXPORTS
+// =============================================================================
+export const ALL_NATIVE_TOOLS = [
+    ReadTool,
+    WriteTool,
+    EditTool,
+    BashTool,
+    GlobTool,
+    GrepTool,
+    WebFetchTool,
+    TodoWriteTool,
+    AskUserQuestionTool,
+    TaskTool,
+];
+export const TOOL_EXECUTORS = {
+    Read: executeRead,
+    Write: executeWrite,
+    Edit: executeEdit,
+    Bash: executeBash,
+    Glob: executeGlob,
+    Grep: executeGrep,
+    WebFetch: executeWebFetch,
+    TodoWrite: executeTodoWrite,
+    // AskUserQuestion and Task require special handling in ChatEngine
+};
+// Get tool by name
+export function getTool(name) {
+    return ALL_NATIVE_TOOLS.find((t) => t.name === name);
+}
+// V15: Check if a tool is a placeholder
+export function isPlaceholderTool(name) {
+    return PLACEHOLDER_TOOLS.has(name);
+}
+// V15: Get alternative for placeholder tool
+export function getToolAlternative(name) {
+    return TOOL_ALTERNATIVES[name];
+}
+// Execute a tool by name
+export async function executeTool(name, params) {
+    // V15: Handle placeholder tools with helpful errors
+    if (PLACEHOLDER_TOOLS.has(name)) {
+        const alternative = TOOL_ALTERNATIVES[name] || 'Use native tools (Read, Write, Edit, Bash)';
+        return {
+            success: false,
+            error: `🚫 Tool "${name}" is not yet implemented in V15.\n\n💡 Alternative: ${alternative}`,
+            metadata: { placeholder: true, alternative },
+        };
+    }
+    const executor = TOOL_EXECUTORS[name];
+    if (!executor) {
+        return {
+            success: false,
+            error: `Unknown tool: ${name}. Available tools: ${Object.keys(TOOL_EXECUTORS).join(', ')}`,
+        };
+    }
+    return executor(params);
+}
+//# sourceMappingURL=NativeTools.js.map