@indiccoder/mentis-cli 1.1.3 → 1.1.5

package/dist/tools/WebSearchTool.js

@@ -4,12 +4,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WebSearchTool = void 0;
-const duck_duck_scrape_1 = require("duck-duck-scrape");
 const chalk_1 = __importDefault(require("chalk"));
+const child_process_1 = require("child_process");
+const os_1 = __importDefault(require("os"));
 class WebSearchTool {
     constructor() {
         this.name = 'search_web';
-        this.description = 'Search the internet for documentation, libraries, or solutions to errors. Returns snippets of top results.';
+        this.description = 'Search internet for documentation, libraries, or solutions to errors. Returns snippets of top results.';
         this.parameters = {
             type: 'object',
             properties: {
@@ -21,40 +22,202 @@ class WebSearchTool {
             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) {
-        try {
-            // Priority 1: Google Search
+        // 1. Try API Key (Most Reliable)
+        if (process.env.TAVILY_API_KEY) {
             try {
-                // Dynamic import to avoid build issues if types are missing
-                const { search: googleSearch } = require('google-sr');
-                console.log(chalk_1.default.dim(`  Searching Google for: "${args.query}"...`));
-                const googleResults = 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}`;
+                return await this.searchTavily(args.query, process.env.TAVILY_API_KEY);
+            }
+            catch (e) {
+                console.error(chalk_1.default.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 (googleError) {
-                console.log(chalk_1.default.dim(`  Google search failed (${googleError.message}), failing over to DuckDuckGo...`));
+            catch (e) {
+                // Ignore npm error
             }
-            // Priority 2: DuckDuckGo Fallback
-            console.log(chalk_1.default.dim(`  Searching DuckDuckGo for: "${args.query}"...`));
-            const ddgResults = await (0, duck_duck_scrape_1.search)(args.query, {
-                safeSearch: 0
-            });
-            if (!ddgResults.results || ddgResults.results.length === 0) {
-                return 'No results found.';
+        }
+        // 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');
             }
-            // 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 (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_1.default.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) => `[${r.title}](${r.url})\n${r.description || 'No description found.'}`).join('\n\n');
         }
         catch (error) {
-            return `Error searching web: ${error.message}`;
+            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"`;
+        }
+    }
+    formatResults(results, source) {
+        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}`;
+    }
+    async searchTavily(query, apiKey) {
+        console.log(chalk_1.default.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();
+            const results = data.results.map((r) => `[${r.title}](${r.url})\n${r.content}`).join('\n\n');
+            return `Tavily Results:\n\n${results}`;
+        }
+        catch (e) {
+            throw new Error(`Tavily Error: ${e.message}`);
         }
     }
+    async checkNpmVersion(pkg) {
+        return new Promise((resolve) => {
+            (0, child_process_1.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('');
+                }
+            });
+        });
+    }
+    async searchGoogleCurl(query) {
+        console.log(chalk_1.default.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_1.default.platform() === 'win32' ? 'curl.exe' : 'curl';
+        return new Promise((resolve, reject) => {
+            (0, child_process_1.exec)(`${curlCmd} -s -L -A "${userAgent}" "${url}"`, { maxBuffer: 1024 * 1024 * 2 }, (error, stdout) => {
+                if (error) {
+                    reject(error);
+                    return;
+                }
+                const html = stdout;
+                const results = [];
+                // 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);
+            });
+        });
+    }
+    async curl(url) {
+        const curl = os_1.default.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((resolve, reject) => {
+            (0, child_process_1.exec)(`${curl} -s -L -A "${userAgent}" "${url}"`, { maxBuffer: 1024 * 1024 * 2 }, (error, stdout, stderr) => {
+                if (error) {
+                    reject(error);
+                    return;
+                }
+                resolve(stdout);
+            });
+        });
+    }
+    async searchDuckDuckGoHtml(query) {
+        console.log(chalk_1.default.dim(`  Searching DuckDuckGo (HTML) for: "${query}"...`));
+        const url = `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`;
+        const html = await this.curl(url);
+        const results = [];
+        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;
+    }
+    async searchDuckDuckGoLite(query) {
+        console.log(chalk_1.default.dim(`  Searching DuckDuckGo (Lite) for: "${query}"...`));
+        const url = `https://lite.duckduckgo.com/lite/?q=${encodeURIComponent(query)}`;
+        const html = await this.curl(url);
+        const results = [];
+        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;
+    }
+    decodeHtml(str) {
+        return str
+            .replace(/&amp;/g, '&')
+            .replace(/&lt;/g, '<')
+            .replace(/&gt;/g, '>')
+            .replace(/&quot;/g, '"')
+            .replace(/&#39;/g, "'");
+    }
 }
 exports.WebSearchTool = WebSearchTool;

package/dist/ui/DiffViewer.js

@@ -0,0 +1,110 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiffViewer = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const diff_1 = require("diff");
+/**
+ * Visual diff viewer component
+ * Shows file changes with color coding like git diff
+ */
+class DiffViewer {
+    /**
+     * Display a unified diff between old and new content
+     */
+    static showDiff(filePath, oldContent, newContent, contextLines = 3) {
+        const diff = (0, diff_1.diffLines)(oldContent, newContent);
+        console.log('');
+        console.log(chalk_1.default.gray('─'.repeat(60)));
+        console.log(chalk_1.default.cyan(`📝 Diff: ${filePath}`));
+        console.log(chalk_1.default.gray('─'.repeat(60)));
+        console.log('');
+        let unchangedCount = 0;
+        const unchangedBuffer = [];
+        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_1.default.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_1.default.green('+ ' + line));
+                    additions++;
+                    hasChanges = true;
+                }
+                else if (part.removed) {
+                    flushUnchanged();
+                    console.log(chalk_1.default.red('- ' + line));
+                    deletions++;
+                    hasChanges = true;
+                }
+                else {
+                    unchangedBuffer.push(line);
+                    unchangedCount++;
+                }
+            }
+        }
+        flushUnchanged();
+        console.log('');
+        console.log(chalk_1.default.gray('─'.repeat(60)));
+        if (hasChanges) {
+            console.log(chalk_1.default.green(`+ ${additions} additions`) + chalk_1.default.dim(' | ') + chalk_1.default.red(`- ${deletions} deletions`));
+        }
+        else {
+            console.log(chalk_1.default.dim('No changes'));
+        }
+        console.log(chalk_1.default.gray('─'.repeat(60)));
+        console.log('');
+    }
+    /**
+     * Display a simple edit preview (for EditFileTool)
+     */
+    static showEditPreview(filePath, oldString, newString, lineNumber) {
+        console.log('');
+        console.log(chalk_1.default.gray('─'.repeat(60)));
+        console.log(chalk_1.default.cyan(`📝 Edit Preview: ${filePath}`));
+        console.log(chalk_1.default.gray('─'.repeat(60)));
+        console.log(chalk_1.default.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_1.default.red('- ' + line));
+        }
+        // Show added lines in green
+        for (const line of newLines) {
+            console.log(chalk_1.default.green('+ ' + line));
+        }
+        console.log('');
+        console.log(chalk_1.default.gray('─'.repeat(60)));
+        console.log('');
+    }
+    /**
+     * Display approval prompt
+     */
+    static showApprovalPrompt(filePath, operation) {
+        const icon = operation === 'write' ? '📄' : '✏️';
+        console.log(chalk_1.default.yellow(`${icon} Approve ${operation} to ${filePath}?`));
+        console.log(chalk_1.default.dim('  [y] Yes  [n] No  [e] Edit'));
+    }
+}
+exports.DiffViewer = DiffViewer;

package/dist/ui/InputBox.js

@@ -51,18 +51,32 @@ class InputBox {
                 completer: this.completer.bind(this)
             });
             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/dist/ui/MultiFileSelector.js

@@ -0,0 +1,123 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MultiFileSelector = void 0;
+const inquirer_1 = __importDefault(require("inquirer"));
+const chalk_1 = __importDefault(require("chalk"));
+const fs_1 = require("fs");
+/**
+ * Multi-file selector for read approval
+ * Shows interactive checklist when AI wants to read multiple files
+ */
+class MultiFileSelector {
+    /**
+     * Show file selection UI for read operations
+     * Returns the list of approved files
+     */
+    static async selectFiles(filePaths, message = 'Select files to read:') {
+        if (filePaths.length === 0) {
+            return [];
+        }
+        if (filePaths.length === 1) {
+            // Single file - just show what's being read
+            console.log(chalk_1.default.dim(`📖 Reading: ${filePaths[0]}`));
+            return filePaths;
+        }
+        // Build file choices with metadata
+        const choices = filePaths.map(path => {
+            let metadata = '';
+            try {
+                const stats = (0, fs_1.statSync)(path);
+                const size = this.formatFileSize(stats.size);
+                metadata = chalk_1.default.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_1.default.cyan(`📖 AI wants to read ${filePaths.length} files:`));
+        console.log('');
+        const { selectedFiles } = await inquirer_1.default.prompt([
+            {
+                type: 'checkbox',
+                name: 'selectedFiles',
+                message: message,
+                choices: choices,
+                pageSize: 15,
+                validate: (answer) => {
+                    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_1.default.dim(`  Reading ${selectedFiles.length} of ${filePaths.length} files`));
+        }
+        return selectedFiles;
+    }
+    /**
+     * Show a simple confirmation for single file reads (optional)
+     */
+    static async confirmRead(filePath, preview) {
+        let message = chalk_1.default.cyan(`📖 Read file: ${filePath}?`);
+        if (preview) {
+            const lines = preview.split('\n');
+            const previewLines = lines.slice(0, 5);
+            console.log('');
+            console.log(chalk_1.default.gray('─'.repeat(60)));
+            console.log(message);
+            console.log(chalk_1.default.gray('─'.repeat(60)));
+            console.log(chalk_1.default.dim('Preview:'));
+            for (const line of previewLines) {
+                console.log(chalk_1.default.dim('  ' + line));
+            }
+            if (lines.length > 5) {
+                console.log(chalk_1.default.dim('  ...'));
+            }
+            console.log(chalk_1.default.gray('─'.repeat(60)));
+        }
+        else {
+            console.log(message);
+        }
+        const { confirmed } = await inquirer_1.default.prompt([
+            {
+                type: 'confirm',
+                name: 'confirmed',
+                message: 'Continue?',
+                default: true
+            }
+        ]);
+        return confirmed;
+    }
+    /**
+     * Format file size in human-readable format
+     */
+    static formatFileSize(bytes) {
+        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, total, filePath) {
+        const progress = chalk_1.default.dim(`[${current}/${total}]`);
+        console.log(chalk_1.default.dim(`  ${progress} Reading: ${filePath}`));
+    }
+}
+exports.MultiFileSelector = MultiFileSelector;

package/dist/ui/PlanModeUI.js

@@ -0,0 +1,105 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlanModeUI = void 0;
+const inquirer_1 = __importDefault(require("inquirer"));
+const chalk_1 = __importDefault(require("chalk"));
+/**
+ * Plan Mode UI - Shows Q&A history and handles plan → build transition
+ */
+class PlanModeUI {
+    /**
+     * Record a Q&A entry
+     */
+    static recordQA(question, answer) {
+        this.qaHistory.push({
+            question,
+            answer,
+            timestamp: new Date()
+        });
+    }
+    /**
+     * Show the current Q&A history
+     */
+    static showQAHistory() {
+        if (this.qaHistory.length === 0) {
+            console.log(chalk_1.default.dim('  No questions asked yet.'));
+            return;
+        }
+        console.log('');
+        console.log(chalk_1.default.cyan('📋 Requirements gathered:'));
+        console.log(chalk_1.default.gray('─'.repeat(60)));
+        for (let i = 0; i < this.qaHistory.length; i++) {
+            const entry = this.qaHistory[i];
+            console.log(chalk_1.default.bold(`${i + 1}. ${entry.question}`));
+            console.log(chalk_1.default.dim(`   Answer: ${entry.answer}`));
+            console.log('');
+        }
+        console.log(chalk_1.default.gray('─'.repeat(60)));
+    }
+    /**
+     * Ask if ready to switch to build mode
+     */
+    static async askReadyToBuild() {
+        console.log('');
+        const { ready } = await inquirer_1.default.prompt([
+            {
+                type: 'confirm',
+                name: 'ready',
+                message: chalk_1.default.cyan('🚀 Ready to switch to BUILD mode and implement?'),
+                default: true
+            }
+        ]);
+        return ready;
+    }
+    /**
+     * Show plan mode header/summary
+     */
+    static showPlanHeader() {
+        console.log('');
+        console.log(chalk_1.default.cyan.bold('🎯 PLAN MODE'));
+        console.log(chalk_1.default.dim('   Gathering requirements and planning the solution...'));
+        console.log(chalk_1.default.dim('   Type your requirements, answer questions, then switch to /build to implement.'));
+        console.log('');
+    }
+    /**
+     * Show suggestion to switch to build mode
+     */
+    static suggestBuildMode() {
+        console.log('');
+        console.log(chalk_1.default.yellow('💡 Tip: Type ') + chalk_1.default.bold('/build') + chalk_1.default.yellow(' to start implementing when ready.'));
+    }
+    /**
+     * Clear Q&A history (e.g., when starting a new session)
+     */
+    static clearHistory() {
+        this.qaHistory = [];
+    }
+    /**
+     * Get Q&A history
+     */
+    static getHistory() {
+        return [...this.qaHistory];
+    }
+    /**
+     * Show a summary of the plan
+     */
+    static showPlanSummary() {
+        if (this.qaHistory.length === 0) {
+            return;
+        }
+        console.log('');
+        console.log(chalk_1.default.cyan('📝 Plan Summary:'));
+        console.log(chalk_1.default.gray('─'.repeat(60)));
+        console.log(chalk_1.default.dim(`Questions answered: ${this.qaHistory.length}`));
+        // Show key answers as bullet points
+        for (const entry of this.qaHistory) {
+            console.log(chalk_1.default.dim(`  • ${entry.question}: ${entry.answer}`));
+        }
+        console.log(chalk_1.default.gray('─'.repeat(60)));
+    }
+}
+exports.PlanModeUI = PlanModeUI;
+PlanModeUI.qaHistory = [];