@indiccoder/mentis-cli 1.1.4 → 1.1.5

package/dist/tools/AskQuestionTool.js

@@ -0,0 +1,172 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AskQuestionTool = void 0;
+const inquirer_1 = __importDefault(require("inquirer"));
+const chalk_1 = __importDefault(require("chalk"));
+/**
+ * AskQuestionTool - Allows the AI to ask clarifying questions
+ * This enables interactive plan mode where AI can gather requirements
+ */
+class AskQuestionTool {
+    constructor() {
+        this.name = 'ask_question';
+        this.description = 'Ask the user a clarifying question. Use this in plan mode to gather requirements before implementation. Supports: text, confirm (yes/no), list (single choice), checkbox (multi-select).';
+        this.parameters = {
+            type: 'object',
+            properties: {
+                question: {
+                    type: 'string',
+                    description: 'The question to ask the user'
+                },
+                type: {
+                    type: 'string',
+                    enum: ['text', 'confirm', 'list', 'checkbox'],
+                    description: 'Type of question: text (free input), confirm (yes/no), list (single choice), checkbox (multi-select)'
+                },
+                options: {
+                    type: 'array',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            label: { type: 'string', description: 'Display text for the option' },
+                            description: { type: 'string', description: 'Additional context (optional)' }
+                        }
+                    },
+                    description: 'Options for list/checkbox questions. Required for list/checkbox types.'
+                },
+                default: {
+                    oneOf: [{ type: 'string' }, { type: 'boolean' }, { type: 'array' }],
+                    description: 'Default value (optional)'
+                }
+            },
+            required: ['question', 'type']
+        };
+    }
+    /**
+     * Execute the question and return the user's answer
+     */
+    async execute(args) {
+        const questionType = args.type || 'text';
+        // Show question header
+        console.log('');
+        console.log(chalk_1.default.cyan('🤔 Question from AI:'));
+        console.log(chalk_1.default.gray('─'.repeat(60)));
+        try {
+            let result;
+            switch (questionType) {
+                case 'text':
+                    result = await this.askText(args.question, args.default);
+                    break;
+                case 'confirm':
+                    result = await this.askConfirm(args.question, args.default);
+                    break;
+                case 'list':
+                    if (!args.options || args.options.length === 0) {
+                        return 'Error: list questions require options';
+                    }
+                    result = await this.askList(args.question, args.options, args.default);
+                    break;
+                case 'checkbox':
+                    if (!args.options || args.options.length === 0) {
+                        return 'Error: checkbox questions require options';
+                    }
+                    result = await this.askCheckbox(args.question, args.options, args.default);
+                    break;
+                default:
+                    return `Error: Unknown question type: ${questionType}`;
+            }
+            console.log(chalk_1.default.gray('─'.repeat(60)));
+            // Format result as string for return to LLM
+            return this.formatResult(result, questionType);
+        }
+        catch (error) {
+            return `Error asking question: ${error.message}`;
+        }
+    }
+    /**
+     * Ask a free-text question
+     */
+    async askText(question, defaultValue) {
+        const { answer } = await inquirer_1.default.prompt([
+            {
+                type: 'input',
+                name: 'answer',
+                message: question,
+                default: defaultValue
+            }
+        ]);
+        return answer;
+    }
+    /**
+     * Ask a yes/no confirmation
+     */
+    async askConfirm(question, defaultValue) {
+        const { answer } = await inquirer_1.default.prompt([
+            {
+                type: 'confirm',
+                name: 'answer',
+                message: question,
+                default: defaultValue ?? true
+            }
+        ]);
+        return answer;
+    }
+    /**
+     * Ask a single-choice list question
+     */
+    async askList(question, options, defaultValue) {
+        const { answer } = await inquirer_1.default.prompt([
+            {
+                type: 'list',
+                name: 'answer',
+                message: question,
+                choices: options.map((opt, i) => ({
+                    name: opt.label,
+                    value: opt.label,
+                    short: opt.label
+                })),
+                default: defaultValue
+            }
+        ]);
+        return answer;
+    }
+    /**
+     * Ask a multi-select checkbox question
+     */
+    async askCheckbox(question, options, defaultValue) {
+        const { answer } = await inquirer_1.default.prompt([
+            {
+                type: 'checkbox',
+                name: 'answer',
+                message: question,
+                choices: options.map((opt, i) => ({
+                    name: opt.label,
+                    value: opt.label,
+                    checked: defaultValue?.includes(opt.label),
+                    short: opt.label
+                }))
+            }
+        ]);
+        return answer;
+    }
+    /**
+     * Format the result for return to the LLM
+     */
+    formatResult(result, questionType) {
+        switch (questionType) {
+            case 'confirm':
+                return result === true ? 'Yes' : 'No';
+            case 'checkbox':
+                if (Array.isArray(result) && result.length > 0) {
+                    return `Selected: ${result.join(', ')}`;
+                }
+                return 'None selected';
+            default:
+                return String(result);
+        }
+    }
+}
+exports.AskQuestionTool = AskQuestionTool;

package/dist/tools/EditFileTool.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EditFileTool = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+/**
+ * EditFileTool - Performs string replacement in files (like Claude's Edit tool)
+ * Returns a unified diff preview instead of writing immediately
+ */
+class EditFileTool {
+    constructor() {
+        this.name = 'edit_file';
+        this.description = 'Make targeted edits to files using string replacement. Returns diff preview. Requires approval before writing.';
+        this.parameters = {
+            type: 'object',
+            properties: {
+                file_path: {
+                    type: 'string',
+                    description: 'The path to the file to edit'
+                },
+                old_string: {
+                    type: 'string',
+                    description: 'The exact string to replace. Must match exactly (including whitespace).'
+                },
+                new_string: {
+                    type: 'string',
+                    description: 'The new string to replace old_string with.'
+                },
+                auto_format: {
+                    type: 'boolean',
+                    description: 'Auto-format code after edit (default: false)'
+                }
+            },
+            required: ['file_path', 'old_string', 'new_string']
+        };
+    }
+    /**
+     * Execute the edit and return a diff preview
+     * Note: This does NOT write the file - it returns what WOULD change
+     * The caller (ReplManager) should handle approval before calling applyEdit()
+     */
+    async execute(args) {
+        const filePath = (0, path_1.resolve)(process.cwd(), args.file_path);
+        if (!(0, fs_1.existsSync)(filePath)) {
+            return `Error: File not found: ${args.file_path}`;
+        }
+        const originalContent = (0, fs_1.readFileSync)(filePath, 'utf-8');
+        if (!originalContent.includes(args.old_string)) {
+            return `Error: old_string not found in file. The string must match exactly (including whitespace and indentation).`;
+        }
+        // Count occurrences
+        const occurrences = (originalContent.match(new RegExp(this.escapeRegex(args.old_string), 'g')) || []).length;
+        if (occurrences > 1) {
+            return `Warning: old_string found ${occurrences} times. All occurrences will be replaced.\n\n${this.generateDiff(originalContent, args.old_string, args.new_string, args.file_path)}`;
+        }
+        // Generate and return diff
+        return this.generateDiff(originalContent, args.old_string, args.new_string, args.file_path);
+    }
+    /**
+     * Apply the edit after approval
+     * This should be called after user approves the diff
+     */
+    applyEdit(args) {
+        const filePath = (0, path_1.resolve)(process.cwd(), args.file_path);
+        if (!(0, fs_1.existsSync)(filePath)) {
+            return { success: false, message: `File not found: ${args.file_path}` };
+        }
+        const originalContent = (0, fs_1.readFileSync)(filePath, 'utf-8');
+        if (!originalContent.includes(args.old_string)) {
+            return { success: false, message: 'old_string not found in file' };
+        }
+        const newContent = originalContent.replace(args.old_string, args.new_string);
+        (0, fs_1.writeFileSync)(filePath, newContent, 'utf-8');
+        return {
+            success: true,
+            message: `Successfully edited ${args.file_path}`
+        };
+    }
+    /**
+     * Generate a unified diff preview
+     */
+    generateDiff(content, oldString, newString, filePath) {
+        const lines = content.split('\n');
+        const oldLines = oldString.split('\n');
+        const newLines = newString.split('\n');
+        // Find the line number where old_string starts
+        let startLine = -1;
+        for (let i = 0; i <= lines.length - oldLines.length; i++) {
+            let match = true;
+            for (let j = 0; j < oldLines.length; j++) {
+                if (lines[i + j] !== oldLines[j]) {
+                    match = false;
+                    break;
+                }
+            }
+            if (match) {
+                startLine = i;
+                break;
+            }
+        }
+        if (startLine === -1) {
+            return 'Error: Could not locate old_string in file';
+        }
+        // Build unified diff
+        let diff = `\n${'─'.repeat(60)}\n`;
+        diff += `📝 Edit Preview: ${filePath}\n`;
+        diff += `${'─'.repeat(60)}\n`;
+        diff += `Line ${startLine + 1}:\n\n`;
+        // Show context (2 lines before)
+        const contextStart = Math.max(0, startLine - 2);
+        if (contextStart < startLine) {
+            for (let i = contextStart; i < startLine; i++) {
+                diff += `  ${lines[i]}\n`;
+            }
+        }
+        // Show removed lines (red)
+        for (const line of oldLines) {
+            diff += `\x1b[31m- ${line}\x1b[0m\n`;
+        }
+        // Show added lines (green)
+        for (const line of newLines) {
+            diff += `\x1b[32m+ ${line}\x1b[0m\n`;
+        }
+        // Show context (2 lines after)
+        const contextEnd = Math.min(lines.length, startLine + oldLines.length + 2);
+        if (startLine + oldLines.length < contextEnd) {
+            for (let i = startLine + oldLines.length; i < contextEnd; i++) {
+                diff += `  ${lines[i]}\n`;
+            }
+        }
+        diff += `${'─'.repeat(60)}\n`;
+        return diff;
+    }
+    /**
+     * Escape special regex characters
+     */
+    escapeRegex(str) {
+        return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    }
+}
+exports.EditFileTool = EditFileTool;

package/dist/tools/FileTools.js

@@ -3,9 +3,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ListDirTool = exports.ReadFileTool = exports.WriteFileTool = void 0;
+exports.ListDirTool = exports.ReadFileTool = exports.WriteFileTool = exports.PlanModeTool = exports.AskQuestionTool = exports.EditFileTool = void 0;
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const path_1 = __importDefault(require("path"));
+var EditFileTool_1 = require("./EditFileTool");
+Object.defineProperty(exports, "EditFileTool", { enumerable: true, get: function () { return EditFileTool_1.EditFileTool; } });
+var AskQuestionTool_1 = require("./AskQuestionTool");
+Object.defineProperty(exports, "AskQuestionTool", { enumerable: true, get: function () { return AskQuestionTool_1.AskQuestionTool; } });
+var PlanModeTool_1 = require("./PlanModeTool");
+Object.defineProperty(exports, "PlanModeTool", { enumerable: true, get: function () { return PlanModeTool_1.PlanModeTool; } });
 class WriteFileTool {
     constructor() {
         this.name = 'write_file';

package/dist/tools/PlanModeTool.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlanModeTool = void 0;
+const inquirer_1 = __importDefault(require("inquirer"));
+const chalk_1 = __importDefault(require("chalk"));
+const PlanModeUI_1 = require("../ui/PlanModeUI");
+/**
+ * PlanModeTool - Allows AI to suggest switching to plan mode
+ * Use this when the task is complex, requires architecture design, or needs requirements gathering
+ */
+class PlanModeTool {
+    constructor() {
+        this.name = 'enter_plan_mode';
+        this.description = 'Suggest switching to plan mode for complex tasks. Call this when you need to gather requirements, design architecture, or break down a complex implementation before coding.';
+        this.parameters = {
+            type: 'object',
+            properties: {
+                reason: {
+                    type: 'string',
+                    description: 'Explain why plan mode is recommended for this task'
+                }
+            },
+            required: ['reason']
+        };
+    }
+    /**
+     * Execute - Ask user if they want to switch to plan mode
+     */
+    async execute(args) {
+        console.log('');
+        console.log(chalk_1.default.cyan('🎯 AI suggests entering PLAN MODE'));
+        console.log(chalk_1.default.gray('─'.repeat(60)));
+        console.log(chalk_1.default.dim(`Reason: ${args.reason}`));
+        console.log(chalk_1.default.gray('─'.repeat(60)));
+        const { confirm } = await inquirer_1.default.prompt([
+            {
+                type: 'confirm',
+                name: 'confirm',
+                message: 'Switch to plan mode?',
+                default: true
+            }
+        ]);
+        if (confirm) {
+            PlanModeUI_1.PlanModeUI.showPlanHeader();
+            return 'User approved. Switching to plan mode for requirements gathering and planning.';
+        }
+        return 'User declined. Continuing in current mode.';
+    }
+}
+exports.PlanModeTool = PlanModeTool;

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;