@indiccoder/mentis-cli 1.1.4 → 1.1.5

package/src/tools/WebSearchTool.ts

@@ -1,63 +1,235 @@
-import { Tool } from './Tool';
-import { search } from 'duck-duck-scrape';
-import chalk from 'chalk';
-
-export class WebSearchTool implements Tool {
-    name = 'search_web';
-    description = 'Search the internet for documentation, libraries, or solutions to errors. Returns snippets of top results.';
-    parameters = {
-        type: 'object',
-        properties: {
-            query: {
-                type: 'string',
-                description: 'The search query.'
-            }
-        },
-        required: ['query']
-    };
-
-    async execute(args: { query: string }): Promise<string> {
-        try {
-            // Priority 1: Google Search
-            try {
-                // Dynamic import to avoid build issues if types are missing
-                const { search: googleSearch } = require('google-sr');
-                console.log(chalk.dim(`  Searching Google for: "${args.query}"...`));
-
-                const googleResults: any[] = await googleSearch({
-                    query: args.query,
-                    limit: 5,
-                });
-
-                if (googleResults && googleResults.length > 0) {
-                    const formatted = googleResults.map(r =>
-                        `[${r.title}](${r.link})\n${r.description || 'No description.'}`
-                    ).join('\n\n');
-                    return `Top Google Results:\n\n${formatted}`;
-                }
-            } catch (googleError: any) {
-                console.log(chalk.dim(`  Google search failed (${googleError.message}), failing over to DuckDuckGo...`));
-            }
-
-            // Priority 2: DuckDuckGo Fallback
-            console.log(chalk.dim(`  Searching DuckDuckGo for: "${args.query}"...`));
-            const ddgResults = await search(args.query, {
-                safeSearch: 0
-            });
-
-            if (!ddgResults.results || ddgResults.results.length === 0) {
-                return 'No results found.';
-            }
-
-            // Return top 5 results
-            const topResults = ddgResults.results.slice(0, 5).map(r =>
-                `[${r.title}](${r.url})\n${r.description || 'No description found.'}`
-            ).join('\n\n');
-
-            return `Top Search Results (via DDG):\n\n${topResults}`;
-
-        } catch (error: any) {
-            return `Error searching web: ${error.message}`;
-        }
-    }
-}
+import { Tool } from './Tool';
+import chalk from 'chalk';
+import { exec } from 'child_process';
+import os from 'os';
+
+export class WebSearchTool implements Tool {
+    name = 'search_web';
+    description = 'Search internet for documentation, libraries, or solutions to errors. Returns snippets of top results.';
+    parameters = {
+        type: 'object',
+        properties: {
+            query: {
+                type: 'string',
+                description: 'The search query.'
+            }
+        },
+        required: ['query']
+    };
+
+    /**
+     * Execute search using a hybrid strategy:
+     * 1. Tavily API (if configured) - Most Reliable
+     * 2. NPM/Expo Registry (if applicable) - Bypasses search engines
+     * 3. Google Curl - Mimics browser request
+     * 4. DuckDuckGo Lite - Low bandwidth fallback
+     * 5. DuckDuckScrape Library - Last resort
+     */
+    async execute(args: { query: string }): Promise<string> {
+        // 1. Try API Key (Most Reliable)
+        if (process.env.TAVILY_API_KEY) {
+            try {
+                return await this.searchTavily(args.query, process.env.TAVILY_API_KEY);
+            } catch (e) {
+                console.error(chalk.red('Tavily search failed, falling back to scraper.'));
+            }
+        }
+
+        // 2. Specific Fallback: NPM/Expo Queries (Bypass Search Engines)
+        // If user asks for versions, use npm directly
+        if (args.query.toLowerCase().includes('expo') || args.query.toLowerCase().includes('react native')) {
+            try {
+                const npmInfo = await this.checkNpmVersion('expo');
+                if (npmInfo) {
+                    return `NPM Registry Info:\n${npmInfo}\n\n(Web search was blocked, but I checked NPM directly.)`;
+                }
+            } catch (e) {
+                // Ignore npm error
+            }
+        }
+
+        // Rate limit protection
+        await new Promise(resolve => setTimeout(resolve, 2000));
+
+        try {
+            // Strategy 1: Google Curl (Specific Browser Header)
+            try {
+                const googleResults = await this.searchGoogleCurl(args.query);
+                if (googleResults.length > 0) return this.formatResults(googleResults, 'Google');
+            } catch (e) {
+                // Ignore
+            }
+
+            // Strategy 2: DDG Lite
+            try {
+                const liteResults = await this.searchDuckDuckGoLite(args.query);
+                if (liteResults.length > 0) return this.formatResults(liteResults, 'DDG Lite');
+            } catch (e) {
+                // Ignore
+            }
+
+            // Strategy 3: Library Fallback
+            console.log(chalk.dim(`  Direct scraping failed, falling back to library...`));
+            const { search } = require('duck-duck-scrape');
+            const ddgResults = await search(args.query, { safeSearch: 0 });
+
+            if (!ddgResults.results?.length) throw new Error('No results from library');
+
+            return `Top Search Results (Library):\n\n` +
+                ddgResults.results.slice(0, 5).map((r: any) =>
+                    `[${r.title}](${r.url})\n${r.description || 'No description found.'}`
+                ).join('\n\n');
+
+        } catch (error: any) {
+            return `Web Search Failed (CAPTCHA Blocked).
+
+Search engines are blocking automated requests from your network.
+
+To enable web search, get a free Tavily API key:
+  1. Go to https://tavily.com
+  2. Sign up for free
+  3. Add to your .env: TAVILY_API_KEY=your_key_here
+
+Alternatively, use Exa via MCP:
+  1. Get key at https://exa.ai
+  2. Add EXA_API_KEY to .env
+  3. Run: /mcp connect "Exa Search"`;
+        }
+    }
+
+    private formatResults(results: any[], source: string): string {
+        const formatted = results.slice(0, 5).map(r =>
+            `[${r.title}](${r.url})\n${r.snippet || 'No description.'}`
+        ).join('\n\n');
+        return `Top Search Results (${source}):\n\n${formatted}`;
+    }
+
+    private async searchTavily(query: string, apiKey: string): Promise<string> {
+        console.log(chalk.dim(`  Searching Tavily for: "${query}"...`));
+        try {
+            const response = await fetch("https://api.tavily.com/search", {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ api_key: apiKey, query, search_depth: "basic", include_answer: true })
+            });
+            const data = await response.json() as any;
+            const results = data.results.map((r: any) => `[${r.title}](${r.url})\n${r.content}`).join('\n\n');
+            return `Tavily Results:\n\n${results}`;
+        } catch (e: any) {
+            throw new Error(`Tavily Error: ${e.message}`);
+        }
+    }
+
+    private async checkNpmVersion(pkg: string): Promise<string> {
+        return new Promise((resolve) => {
+            exec(`npm view ${pkg} name version dist-tags --json`, { maxBuffer: 1024 * 1024 }, (error, stdout) => {
+                if (error || !stdout) resolve('');
+                try {
+                    const info = JSON.parse(stdout);
+                    resolve(`Package: ${info.name}\nLatest Version: ${info.version}\nTags: ${JSON.stringify(info['dist-tags'])}`);
+                } catch { resolve('') }
+            });
+        });
+    }
+
+    private async searchGoogleCurl(query: string): Promise<Array<{ title: string, url: string, snippet: string }>> {
+        console.log(chalk.dim(`  Searching Google (Curl) for: "${query}"...`));
+        const url = `https://www.google.com/search?q=${encodeURIComponent(query)}&hl=en`;
+        const userAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36";
+
+        // Use curl.exe explicitly on Windows
+        const curlCmd = os.platform() === 'win32' ? 'curl.exe' : 'curl';
+
+        return new Promise((resolve, reject) => {
+            exec(`${curlCmd} -s -L -A "${userAgent}" "${url}"`, { maxBuffer: 1024 * 1024 * 2 }, (error, stdout) => {
+                if (error) {
+                    reject(error);
+                    return;
+                }
+
+                const html = stdout;
+                const results: Array<{ title: string, url: string, snippet: string }> = [];
+
+                // Matches standard google result anchors: <a href="/url?q=..." ...><h3 ...>Title</h3>...
+                const linkRegex = /<a href="\/url\?q=([^&]+)&amp;[^"]+">[^<]*<h3[^>]*><div[^>]*>([^<]+)<\/div><\/h3>/g;
+
+                let match;
+                while ((match = linkRegex.exec(html)) !== null) {
+                    results.push({
+                        url: decodeURIComponent(match[1]),
+                        title: this.decodeHtml(match[2]),
+                        snippet: ''
+                    });
+                }
+
+                resolve(results);
+            });
+        });
+    }
+
+    private async curl(url: string): Promise<string> {
+        const curl = os.platform() === 'win32' ? 'curl.exe' : 'curl';
+        const userAgent = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36';
+
+        return new Promise<string>((resolve, reject) => {
+            exec(`${curl} -s -L -A "${userAgent}" "${url}"`, { maxBuffer: 1024 * 1024 * 2 }, (error, stdout, stderr) => {
+                if (error) {
+                    reject(error);
+                    return;
+                }
+                resolve(stdout);
+            });
+        });
+    }
+
+    private async searchDuckDuckGoHtml(query: string): Promise<Array<{ title: string, url: string, snippet: string }>> {
+        console.log(chalk.dim(`  Searching DuckDuckGo (HTML) for: "${query}"...`));
+        const url = `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`;
+        const html = await this.curl(url);
+
+        const results: Array<{ title: string, url: string, snippet: string }> = [];
+        const chunks = html.split('class="result__body"');
+
+        for (let i = 1; i < chunks.length; i++) {
+            const chunk = chunks[i];
+            const titleMatch = chunk.match(/class="result__a" href="([^"]+)">(.*?)<\/a>/);
+            const snippetMatch = chunk.match(/class="result__snippet"[^>]*>(.*?)<\/a>/);
+
+            if (titleMatch) {
+                results.push({
+                    url: titleMatch[1],
+                    title: this.decodeHtml(titleMatch[2].replace(/<[^>]+>/g, '').trim()),
+                    snippet: snippetMatch ? this.decodeHtml(snippetMatch[1].replace(/<[^>]+>/g, '').trim()) : ''
+                });
+            }
+        }
+        return results;
+    }
+
+    private async searchDuckDuckGoLite(query: string): Promise<Array<{ title: string, url: string, snippet: string }>> {
+        console.log(chalk.dim(`  Searching DuckDuckGo (Lite) for: "${query}"...`));
+        const url = `https://lite.duckduckgo.com/lite/?q=${encodeURIComponent(query)}`;
+        const html = await this.curl(url);
+
+        const results: Array<{ title: string, url: string, snippet: string }> = [];
+        const regex = /<a[^>]+class="result-link"[^>]+href="(.*?)"[^>]*>(.*?)<\/a>/g;
+        let match;
+        while ((match = regex.exec(html)) !== null) {
+            results.push({
+                url: match[1],
+                title: this.decodeHtml(match[2].replace(/<[^>]+>/g, '').trim()),
+                snippet: 'Click to view.'
+            });
+        }
+        return results;
+    }
+
+    private decodeHtml(str: string): string {
+        return str
+            .replace(/&amp;/g, '&')
+            .replace(/&lt;/g, '<')
+            .replace(/&gt;/g, '>')
+            .replace(/&quot;/g, '"')
+            .replace(/&#39;/g, "'");
+    }
+}

package/src/ui/DiffViewer.ts

@@ -0,0 +1,117 @@
+import chalk from 'chalk';
+import { diffLines } from 'diff';
+
+/**
+ * Visual diff viewer component
+ * Shows file changes with color coding like git diff
+ */
+export class DiffViewer {
+    /**
+     * Display a unified diff between old and new content
+     */
+    static showDiff(filePath: string, oldContent: string, newContent: string, contextLines: number = 3): void {
+        const diff = diffLines(oldContent, newContent);
+
+        console.log('');
+        console.log(chalk.gray('─'.repeat(60)));
+        console.log(chalk.cyan(`📝 Diff: ${filePath}`));
+        console.log(chalk.gray('─'.repeat(60)));
+        console.log('');
+
+        let unchangedCount = 0;
+        const unchangedBuffer: string[] = [];
+
+        const flushUnchanged = () => {
+            if (unchangedBuffer.length > 0) {
+                // Show context lines
+                const contextStart = Math.max(0, unchangedBuffer.length - contextLines);
+                for (let i = contextStart; i < unchangedBuffer.length; i++) {
+                    console.log(chalk.dim('  ' + unchangedBuffer[i].replace(/\n/g, '')));
+                }
+                unchangedBuffer.length = 0;
+                unchangedCount = 0;
+            }
+        };
+
+        let hasChanges = false;
+        let additions = 0;
+        let deletions = 0;
+
+        for (const part of diff) {
+            const lines = part.value.split('\n');
+            // Remove empty last line if exists
+            if (lines[lines.length - 1] === '') {
+                lines.pop();
+            }
+
+            for (const line of lines) {
+                if (part.added) {
+                    flushUnchanged();
+                    console.log(chalk.green('+ ' + line));
+                    additions++;
+                    hasChanges = true;
+                } else if (part.removed) {
+                    flushUnchanged();
+                    console.log(chalk.red('- ' + line));
+                    deletions++;
+                    hasChanges = true;
+                } else {
+                    unchangedBuffer.push(line);
+                    unchangedCount++;
+                }
+            }
+        }
+
+        flushUnchanged();
+
+        console.log('');
+        console.log(chalk.gray('─'.repeat(60)));
+
+        if (hasChanges) {
+            console.log(chalk.green(`+ ${additions} additions`) + chalk.dim(' | ') + chalk.red(`- ${deletions} deletions`));
+        } else {
+            console.log(chalk.dim('No changes'));
+        }
+
+        console.log(chalk.gray('─'.repeat(60)));
+        console.log('');
+    }
+
+    /**
+     * Display a simple edit preview (for EditFileTool)
+     */
+    static showEditPreview(filePath: string, oldString: string, newString: string, lineNumber: number): void {
+        console.log('');
+        console.log(chalk.gray('─'.repeat(60)));
+        console.log(chalk.cyan(`📝 Edit Preview: ${filePath}`));
+        console.log(chalk.gray('─'.repeat(60)));
+        console.log(chalk.dim(`Line ${lineNumber}:`));
+        console.log('');
+
+        const oldLines = oldString.split('\n');
+        const newLines = newString.split('\n');
+
+        // Show removed lines in red
+        for (const line of oldLines) {
+            console.log(chalk.red('- ' + line));
+        }
+
+        // Show added lines in green
+        for (const line of newLines) {
+            console.log(chalk.green('+ ' + line));
+        }
+
+        console.log('');
+        console.log(chalk.gray('─'.repeat(60)));
+        console.log('');
+    }
+
+    /**
+     * Display approval prompt
+     */
+    static showApprovalPrompt(filePath: string, operation: 'write' | 'edit'): void {
+        const icon = operation === 'write' ? '📄' : '✏️';
+        console.log(chalk.yellow(`${icon} Approve ${operation} to ${filePath}?`));
+        console.log(chalk.dim('  [y] Yes  [n] No  [e] Edit'));
+    }
+}

package/src/ui/InputBox.ts

@@ -62,19 +62,34 @@ export class InputBox {
 
             rl.prompt();
 
+            const cleanup = () => {
+                rl.close();
+                rl.removeAllListeners();
+                // Explicitly ensure raw mode is off to prevent terminal freeze
+                if (process.stdin.isTTY) {
+                    process.stdin.setRawMode(false);
+                }
+            };
+
             rl.on('line', (line) => {
                 // Display bottom horizontal line after input
                 console.log(this.createLine());
-                rl.close();
+                cleanup();
                 resolve(line);
             });
 
             // Handle Ctrl+C
             rl.on('SIGINT', () => {
                 console.log(this.createLine());
-                rl.close();
+                cleanup();
                 resolve('/exit');
             });
+
+            // Handle stream errors or unexpected close
+            rl.on('close', () => {
+                // Should already be cleaned up, but safe to ensure
+                if (process.stdin.isTTY) process.stdin.setRawMode(false);
+            });
         });
     }
 

package/src/ui/MultiFileSelector.ts

@@ -0,0 +1,135 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import { statSync } from 'fs';
+import { join } from 'path';
+
+export interface FileSelection {
+    path: string;
+    selected: boolean;
+    size?: string;
+    type?: string;
+}
+
+/**
+ * Multi-file selector for read approval
+ * Shows interactive checklist when AI wants to read multiple files
+ */
+export class MultiFileSelector {
+    /**
+     * Show file selection UI for read operations
+     * Returns the list of approved files
+     */
+    static async selectFiles(filePaths: string[], message: string = 'Select files to read:'): Promise<string[]> {
+        if (filePaths.length === 0) {
+            return [];
+        }
+
+        if (filePaths.length === 1) {
+            // Single file - just show what's being read
+            console.log(chalk.dim(`📖 Reading: ${filePaths[0]}`));
+            return filePaths;
+        }
+
+        // Build file choices with metadata
+        const choices = filePaths.map(path => {
+            let metadata = '';
+            try {
+                const stats = statSync(path);
+                const size = this.formatFileSize(stats.size);
+                metadata = chalk.dim(` (${size})`);
+            } catch {
+                // File might not exist or be inaccessible
+            }
+
+            return {
+                name: path + metadata,
+                value: path,
+                checked: true, // Default to checked
+                short: path
+            };
+        });
+
+        console.log('');
+        console.log(chalk.cyan(`📖 AI wants to read ${filePaths.length} files:`));
+        console.log('');
+
+        const { selectedFiles } = await inquirer.prompt([
+            {
+                type: 'checkbox',
+                name: 'selectedFiles',
+                message: message,
+                choices: choices,
+                pageSize: 15,
+                validate: (answer: string[]) => {
+                    if (answer.length === 0) {
+                        return 'You must select at least one file, or press Ctrl+C to cancel.';
+                    }
+                    return true;
+                }
+            }
+        ]);
+
+        // Show what was selected
+        if (selectedFiles.length < filePaths.length) {
+            console.log(chalk.dim(`  Reading ${selectedFiles.length} of ${filePaths.length} files`));
+        }
+
+        return selectedFiles;
+    }
+
+    /**
+     * Show a simple confirmation for single file reads (optional)
+     */
+    static async confirmRead(filePath: string, preview?: string): Promise<boolean> {
+        let message = chalk.cyan(`📖 Read file: ${filePath}?`);
+
+        if (preview) {
+            const lines = preview.split('\n');
+            const previewLines = lines.slice(0, 5);
+            console.log('');
+            console.log(chalk.gray('─'.repeat(60)));
+            console.log(message);
+            console.log(chalk.gray('─'.repeat(60)));
+            console.log(chalk.dim('Preview:'));
+            for (const line of previewLines) {
+                console.log(chalk.dim('  ' + line));
+            }
+            if (lines.length > 5) {
+                console.log(chalk.dim('  ...'));
+            }
+            console.log(chalk.gray('─'.repeat(60)));
+        } else {
+            console.log(message);
+        }
+
+        const { confirmed } = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'confirmed',
+                message: 'Continue?',
+                default: true
+            }
+        ]);
+
+        return confirmed;
+    }
+
+    /**
+     * Format file size in human-readable format
+     */
+    private static formatFileSize(bytes: number): string {
+        if (bytes === 0) return '0 B';
+        const k = 1024;
+        const sizes = ['B', 'KB', 'MB', 'GB'];
+        const i = Math.floor(Math.log(bytes) / Math.log(k));
+        return parseFloat((bytes / Math.pow(k, i)).toFixed(1)) + ' ' + sizes[i];
+    }
+
+    /**
+     * Show progress when reading multiple files
+     */
+    static showReadProgress(current: number, total: number, filePath: string): void {
+        const progress = chalk.dim(`[${current}/${total}]`);
+        console.log(chalk.dim(`  ${progress} Reading: ${filePath}`));
+    }
+}