@pheem49/mint 1.4.2 → 1.5.1

package/src/CLI/code_agent.js

@@ -6,11 +6,46 @@ const { GoogleGenAI } = require('@google/genai');
 const axios = require('axios');
 const cheerio = require('cheerio');
 const { readConfig, getAvailableProviders } = require('../System/config_manager');
+const safetyManager = require('../System/safety_manager');
+const memoryStore = require('../AI_Brain/memory_store');
 const { readWorkspaceSession, writeWorkspaceSession } = require('./code_session_memory');
-const { executeAction } = require('../../mint-cli-logic');
+const { executeAction } = require('../System/action_executor');
+const toolRegistry = require('../System/tool_registry');
+const sandboxRunner = require('../System/sandbox_runner');
 
-async function webSearch(query) {
+async function webSearch(query, onProgress = () => {}) {
     if (!query) throw new Error('Search query required.');
+    const config = readConfig();
+
+    // 1. Try Google Search API if configured
+    if (config.googleSearchApiKey && config.googleSearchCx) {
+        try {
+            const GoogleSearch = require('../Channels/google_search_bridge');
+            const google = new GoogleSearch({ apiKey: config.googleSearchApiKey, cx: config.googleSearchCx });
+            const results = await google.search(query);
+            if (results.length > 0) {
+                return results.map(r => `Title: ${r.title}\nSnippet: ${r.snippet}\nURL: ${r.link}`).join('\n\n');
+            }
+        } catch (e) { 
+            onProgress({ phase: 'error', action: 'web_search', message: e.message });
+        }
+    }
+
+    // 2. Try Brave Search API if configured
+    if (config.braveSearchApiKey) {
+        try {
+            const BraveSearch = require('../Channels/brave_search_bridge');
+            const brave = new BraveSearch({ apiKey: config.braveSearchApiKey });
+            const results = await brave.search(query);
+            if (results.length > 0) {
+                return results.map(r => `Title: ${r.title}\nSnippet: ${r.snippet}\nURL: ${r.link}`).join('\n\n');
+            }
+        } catch (e) { 
+            onProgress({ phase: 'error', action: 'web_search', message: e.message });
+        }
+    }
+
+    // 3. Fallback to DuckDuckGo Scraping
     try {
         const response = await axios.get(`https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`, {
             headers: {
@@ -28,8 +63,14 @@ async function webSearch(query) {
                 results.push(`Title: ${title}\nSnippet: ${snippet}\nURL: ${link}`);
             }
         });
+
+        if (results.length === 0) {
+             onProgress({ phase: 'error', action: 'web_search', message: 'DuckDuckGo scraping returned no results. It might be blocking us.' });
+        }
+
         return results.length > 0 ? results.join('\n\n') : 'No results found.';
     } catch (e) {
+        onProgress({ phase: 'error', action: 'web_search', message: `DuckDuckGo fallback failed: ${e.message}` });
         return `Search failed: ${e.message}`;
     }
 }
@@ -48,6 +89,10 @@ You work in an inspect -> plan -> act -> verify loop.
 PERSONALITY & TONE:
 - Gender: Female.
 - Persona: Friendly, energetic, polite, and slightly playful.
+- Language routing is mandatory and based on the user's latest message:
+  - If the latest user message contains Thai characters, respond in Thai.
+  - If the latest user message is English, ASCII-only, or a short English greeting such as "hi", "hello", "ok", or "thanks", respond in English.
+  - Do not use Thai just because your persona mentions Mint/มิ้นท์, previous history was Thai, or app settings use th-TH.
 - Politeness: 
   - **WHEN RESPONDING IN THAI:** ALWAYS use female polite particles such as "ค่ะ", "นะคะ", "นะค๊า", "จ้า". Refer to yourself as "มิ้นท์" or "หนู".
   - **WHEN RESPONDING IN ENGLISH:** Use a cheerful, polite, and bubbly tone.
@@ -127,20 +172,143 @@ function extractJson(text) {
     }
 }
 
-function selectSupportedCodeProvider(config, availableProviders = getAvailableProviders(config || {})) {
-    const requestedProvider = (config && config.aiProvider) || 'gemini';
-    if (SUPPORTED_CODE_PROVIDERS.includes(requestedProvider) && availableProviders.includes(requestedProvider)) {
-        return requestedProvider;
+function normalizeExecutorAction(action, input = {}) {
+    return {
+        type: action,
+        target: input.target || input.path || input.query || '',
+        path: input.path,
+        pathType: input.type,
+        openAfter: input.openAfter,
+        pluginName: input.pluginName,
+        server: input.server,
+        args: input.args,
+        x: input.x,
+        y: input.y,
+        button: input.button
+    };
+}
+
+function formatActionPreview(action, input = {}) {
+    if (input.command) return input.command;
+    if (input.path) return input.path;
+    if (input.target) return input.target;
+    if (input.query) return input.query;
+    return action;
+}
+
+function evaluateActionResult(action, toolResult = '') {
+    if (!toolRegistry.isImportantAction(action)) {
+        return null;
+    }
+
+    const text = String(toolResult || '');
+    if (/^Error:|blocked|denied|failed|exception|not found/i.test(text)) {
+        return {
+            status: 'failed',
+            message: `Evaluator: ${action} may have failed. Review the observation before continuing.`
+        };
+    }
+
+    if (action === 'run_shell' && /(ERR!|Error:|FAIL|failed|not found|permission denied)/i.test(text)) {
+        return {
+            status: 'warning',
+            message: 'Evaluator: shell output contains error-like text; verify before claiming success.'
+        };
+    }
+
+    return {
+        status: 'passed',
+        message: `Evaluator: ${action} completed without obvious errors.`
+    };
+}
+
+function splitDataUri(dataUri = '') {
+    const match = String(dataUri).match(/^data:([^;]+);base64,([\s\S]+)$/);
+    if (!match) return null;
+    return {
+        mimeType: match[1],
+        data: match[2]
+    };
+}
+
+function contentToText(content) {
+    if (content && typeof content === 'object' && !Array.isArray(content)) {
+        return String(content.text || '');
+    }
+    return String(content || '');
+}
+
+function contentToGeminiParts(content) {
+    const text = contentToText(content);
+    const parts = text ? [{ text }] : [];
+    if (content && typeof content === 'object' && content.imageDataUri) {
+        const image = splitDataUri(content.imageDataUri);
+        if (image) {
+            parts.push({ inlineData: { mimeType: image.mimeType, data: image.data } });
+        }
+    }
+    return parts.length > 0 ? parts : [{ text: '' }];
+}
+
+function contentToOpenAIContent(content) {
+    const text = contentToText(content) || 'Analyze this input.';
+    if (content && typeof content === 'object' && content.imageDataUri) {
+        return [
+            { type: 'text', text },
+            { type: 'image_url', image_url: { url: content.imageDataUri } }
+        ];
     }
+    return text;
+}
 
+function contentToAnthropicContent(content) {
+    const text = contentToText(content) || 'Analyze this input.';
+    if (content && typeof content === 'object' && content.imageDataUri) {
+        const image = splitDataUri(content.imageDataUri);
+        if (image) {
+            return [
+                { type: 'image', source: { type: 'base64', media_type: image.mimeType, data: image.data } },
+                { type: 'text', text }
+            ];
+        }
+    }
+    return text;
+}
+
+function getSupportedCodeProviderOrder(config, availableProviders = getAvailableProviders(config || {}), requestedOverride = null) {
+    const requestedProvider = requestedOverride || (config && config.aiProvider) || 'gemini';
     const priority = ['anthropic', 'openai', 'gemini', 'local_openai'];
+    const ordered = [];
+
+    if (SUPPORTED_CODE_PROVIDERS.includes(requestedProvider) && availableProviders.includes(requestedProvider)) {
+        ordered.push(requestedProvider);
+    }
+
     for (const provider of priority) {
-        if (availableProviders.includes(provider)) {
-            return provider;
+        if (availableProviders.includes(provider) && !ordered.includes(provider)) {
+            ordered.push(provider);
         }
     }
 
-    return 'gemini';
+    return ordered.length > 0 ? ordered : ['gemini'];
+}
+
+function selectSupportedCodeProvider(config, availableProviders = getAvailableProviders(config || {})) {
+    return getSupportedCodeProviderOrder(config, availableProviders)[0];
+}
+
+function getCodeProviderModel(provider, config = {}) {
+    switch (provider) {
+        case 'anthropic':
+            return config.anthropicModel || 'claude-3-5-sonnet-latest';
+        case 'openai':
+            return config.openaiModel || 'gpt-4o';
+        case 'local_openai':
+            return config.localModelName || 'local-model';
+        case 'gemini':
+        default:
+            return config.geminiModel || DEFAULT_GEMINI_MODEL;
+    }
 }
 
 function resolveWorkspacePath(workspaceRoot, targetPath = '.') {
@@ -301,21 +469,7 @@ async function findPaths(workspaceRoot, query, type = 'any') {
 }
 
 function assertSafeShell(command) {
-    const blockedPatterns = [
-        /\brm\s+-rf\b/,
-        /\bgit\s+reset\s+--hard\b/,
-        /\bgit\s+checkout\s+--\b/,
-        /\bmkfs\b/,
-        /\bshutdown\b/,
-        /\breboot\b/,
-        />\s*\/dev\//,
-        /\bcurl\b.*\|\s*(sh|bash)\b/,
-        /\bwget\b.*\|\s*(sh|bash)\b/
-    ];
-
-    if (blockedPatterns.some(pattern => pattern.test(command))) {
-        throw new Error(`Blocked unsafe command: ${command}`);
-    }
+    return safetyManager.assertShellCommandAllowed(command);
 }
 
 async function runShell(workspaceRoot, command) {
@@ -323,7 +477,8 @@ async function runShell(workspaceRoot, command) {
         throw new Error('Shell command is required.');
     }
     assertSafeShell(command);
-    const { stdout, stderr } = await execFileAsync('bash', ['-lc', command], {
+    const { stdout, stderr } = await sandboxRunner.runShell(command, {
+        source: 'code_agent',
         cwd: workspaceRoot,
         maxBuffer: 1024 * 1024 * 4
     });
@@ -386,34 +541,51 @@ function writeFile(workspaceRoot, targetPath, content) {
 }
 
 class UnifiedAgentClient {
-    constructor(provider, config) {
+    constructor(provider, config, providerOrder = [provider]) {
         this.provider = SUPPORTED_CODE_PROVIDERS.includes(provider) ? provider : 'gemini';
+        this.providerOrder = providerOrder.length > 0 ? providerOrder : [this.provider];
         this.config = config;
         this.history = [];
         this.systemInstruction = CODE_AGENT_PROMPT;
+        this.lastSuccessfulProvider = null;
     }
 
     async sendMessage(observation) {
         this.history.push({ role: 'user', content: observation });
 
-        let responseText = '';
-        if (this.provider === 'anthropic') {
-            responseText = await this._callAnthropic();
-        } else if (this.provider === 'openai' || this.provider === 'local_openai') {
-            responseText = await this._callOpenAI();
-        } else {
-            responseText = await this._callGemini();
+        const failures = [];
+        for (const provider of this.providerOrder) {
+            this.provider = SUPPORTED_CODE_PROVIDERS.includes(provider) ? provider : 'gemini';
+            try {
+                let responseText = '';
+                if (this.provider === 'anthropic') {
+                    responseText = await this._callAnthropic();
+                } else if (this.provider === 'openai' || this.provider === 'local_openai') {
+                    responseText = await this._callOpenAI();
+                } else {
+                    responseText = await this._callGemini();
+                }
+
+                this.history.push({ role: 'assistant', content: responseText });
+                this.lastSuccessfulProvider = this.provider;
+                return responseText;
+            } catch (error) {
+                const message = error.message || error.code || 'unknown error';
+                failures.push(`${this.provider}: ${message}`);
+                if (process.env.MINT_DEBUG === '1') {
+                    console.error(`[Code Agent Fallback] Provider '${this.provider}' failed: ${message}`);
+                }
+            }
         }
 
-        this.history.push({ role: 'assistant', content: responseText });
-        return responseText;
+        throw new Error(`All code agent providers failed. ${failures.join(' | ')}`);
     }
 
     async _callAnthropic() {
         const apiKey = this.config.anthropicApiKey || process.env.ANTHROPIC_API_KEY;
         const messages = this.history.map(m => ({
             role: m.role,
-            content: m.content
+            content: contentToAnthropicContent(m.content)
         }));
 
         const response = await axios.post('https://api.anthropic.com/v1/messages', {
@@ -439,7 +611,10 @@ class UnifiedAgentClient {
 
         const messages = [
             { role: 'system', content: this.systemInstruction },
-            ...this.history
+            ...this.history.map(m => ({
+                role: m.role,
+                content: contentToOpenAIContent(m.content)
+            }))
         ];
 
         const response = await axios.post(`${baseUrl.replace(/\/$/, '')}/chat/completions`, {
@@ -460,13 +635,15 @@ class UnifiedAgentClient {
         const model = this.config.geminiModel || DEFAULT_GEMINI_MODEL;
         const ai = new GoogleGenAI({ apiKey });
         
+        const recentHistory = this.history.slice(-16);
+        const priorHistory = recentHistory.slice(0, -1);
+        const lastEntry = recentHistory[recentHistory.length - 1] || { content: '' };
+
         // Convert history for Gemini, ensuring parts are correctly structured
-        const geminiHistory = this.history.slice(-16).map(m => ({
+        const geminiHistory = priorHistory.map(m => ({
             role: m.role === 'assistant' ? 'model' : 'user',
-            parts: [{ text: String(m.content || '') }]
+            parts: contentToGeminiParts(m.content)
         }));
-        
-        const lastMessage = String(this.history[this.history.length - 1].content || '');
 
         const chat = ai.chats.create({
             model,
@@ -477,7 +654,7 @@ class UnifiedAgentClient {
             history: geminiHistory
         });
 
-        const response = await chat.sendMessage({ message: [{ text: lastMessage }] });
+        const response = await chat.sendMessage({ message: contentToGeminiParts(lastEntry.content) });
         return typeof response.text === 'function' ? response.text() : response.text;
     }
 }
@@ -551,6 +728,7 @@ async function buildInitialObservation(task, workspaceRoot, history = []) {
     const session = readWorkspaceSession(workspaceRoot);
     const gitContext = await getGitContext(workspaceRoot);
     const testCommands = detectTestCommands(workspaceRoot);
+    const userContext = memoryStore.getUserContext(task);
 
     const contextStr = history.length > 0 
         ? `Recent Context:\n${history.slice(-10).map(m => `${m.sender}: ${m.text}`).join('\n')}\n`
@@ -571,7 +749,9 @@ async function buildInitialObservation(task, workspaceRoot, history = []) {
         session.summary || '(none)',
         `Previous task: ${session.lastTask || '(none)'}`,
         `Previous verification: ${session.lastVerification || '(none)'}`,
-        'Start by inspecting the workspace before making edits unless the task is trivial.'
+        'Long-term user context:',
+        userContext || '(none)',
+        'If the task is conversational or trivial, finish directly without inspecting the workspace. For code/workspace tasks, inspect before making edits.'
     ].join('\n');
 }
 
@@ -579,6 +759,7 @@ async function executeCodeTask(task, options = {}) {
     const workspaceRoot = path.resolve(options.cwd || process.cwd());
     const history = options.history || [];
     const onProgress = typeof options.onProgress === 'function' ? options.onProgress : () => {};
+    const onFinalSummary = typeof options.onFinalSummary === 'function' ? options.onFinalSummary : null;
     const requestApproval = typeof options.requestApproval === 'function'
         ? options.requestApproval
         : async () => true;
@@ -586,10 +767,29 @@ async function executeCodeTask(task, options = {}) {
         ? options.askUser
         : async (q) => `User didn't answer: ${q}`;
     const config = readConfig();
-    const provider = options.provider || selectSupportedCodeProvider(config);
-    const client = new UnifiedAgentClient(provider, config);
-
-    let observation = await buildInitialObservation(task, workspaceRoot, history);
+    const availableProviders = getAvailableProviders(config);
+    const providerOrder = getSupportedCodeProviderOrder(config, availableProviders, options.provider);
+    const provider = providerOrder[0];
+    const client = new UnifiedAgentClient(provider, config, providerOrder);
+
+    const initialObservationText = await buildInitialObservation(task, workspaceRoot, history);
+    const relevantMemoryCount = memoryStore.searchInteractions(task, 5).length;
+    onProgress({
+        phase: 'memory',
+        action: 'memory_context',
+        message: `Loaded memory: profile + recent history, ${relevantMemoryCount} direct match${relevantMemoryCount === 1 ? '' : 'es'}`
+    });
+    let observation = options.imageDataUri
+        ? {
+            text: [
+                initialObservationText,
+                '',
+                `[Attached image: ${options.imagePath || 'command-line image'}]`,
+                'Use the attached image as visual context when planning and answering.'
+            ].join('\n'),
+            imageDataUri: options.imageDataUri
+        }
+        : initialObservationText;
 
     let finalSummary = '';
     let finalVerification = '';
@@ -602,6 +802,17 @@ async function executeCodeTask(task, options = {}) {
         const decision = await getAgentDecision(client, observation, { onProgress, step });
         const action = decision.action;
         const input = decision.input || {};
+        try {
+            toolRegistry.validateToolInput(action, input);
+        } catch (e) {
+            observation = [
+                `Previous thought: ${decision.thought || '(none)'}`,
+                `Action: ${action || '(none)'}`,
+                'Observation:',
+                `Error: ${e.message}`
+            ].join('\n');
+            continue;
+        }
 
         // Immediately show the agent's thought/reasoning
         onProgress({
@@ -615,6 +826,16 @@ async function executeCodeTask(task, options = {}) {
             finalSessionSummary = input.sessionSummary || input.summary || task;
             finalSummary = input.summary || 'Task complete.';
             finalVerification = input.verification || 'Not specified.';
+            if (onFinalSummary) {
+                await onFinalSummary({
+                    summary: finalSummary,
+                    verification: finalVerification,
+                    providerInfo: {
+                        provider: client.lastSuccessfulProvider || client.provider || provider,
+                        model: getCodeProviderModel(client.lastSuccessfulProvider || client.provider || provider, config)
+                    }
+                });
+            }
             writeWorkspaceSession(workspaceRoot, {
                 summary: finalSessionSummary,
                 lastTask: task,
@@ -627,7 +848,7 @@ async function executeCodeTask(task, options = {}) {
         try {
             switch (action) {
                 case 'web_search':
-                    toolResult = await webSearch(input.query);
+                    toolResult = await webSearch(input.query, onProgress);
                     break;
                 case 'list_files':
                     toolResult = await listFiles(workspaceRoot, input.path || '.');
@@ -640,6 +861,13 @@ async function executeCodeTask(task, options = {}) {
                     break;
                 case 'find_path':
                     toolResult = await findPaths(workspaceRoot, input.query, input.type);
+                    if (input.openAfter === true) {
+                        const result = JSON.parse(toolResult);
+                        if (result.success && result.matches.length === 1) {
+                            await executeAction({ type: 'open_folder', target: result.matches[0].path });
+                            toolResult = `Found and opened: ${result.matches[0].path}`;
+                        }
+                    }
                     break;
                 case 'run_shell': {
                     const approved = await requestApproval({
@@ -651,6 +879,12 @@ async function executeCodeTask(task, options = {}) {
                         toolResult = `User denied shell command: ${input.command}`;
                         break;
                     }
+                    safetyManager.appendActionLog({
+                        source: 'code_agent',
+                        action: 'run_shell',
+                        command: input.command,
+                        approved
+                    });
                     toolResult = await runShell(workspaceRoot, input.command);
                     break;
                 }
@@ -665,6 +899,12 @@ async function executeCodeTask(task, options = {}) {
                         toolResult = `User denied patch for ${patchInput.path}`;
                         break;
                     }
+                    safetyManager.appendActionLog({
+                        source: 'code_agent',
+                        action: 'apply_patch',
+                        path: patchInput.path,
+                        approved
+                    });
                     toolResult = applyPatch(workspaceRoot, patchInput);
                     break;
                 }
@@ -678,6 +918,12 @@ async function executeCodeTask(task, options = {}) {
                         toolResult = `User denied full file write for ${input.path}`;
                         break;
                     }
+                    safetyManager.appendActionLog({
+                        source: 'code_agent',
+                        action: 'write_file',
+                        path: input.path,
+                        approved
+                    });
                     toolResult = writeFile(workspaceRoot, input.path, input.content);
                     break;
                 }
@@ -693,10 +939,28 @@ async function executeCodeTask(task, options = {}) {
                 case 'create_folder':
                 case 'system_info':
                 case 'system_automation': {
-                    // Delegate to existing automation logic
-                    toolResult = await executeAction({
-                        type: action,
-                        target: input.target
+                    const executorAction = normalizeExecutorAction(action, input);
+                    const safety = safetyManager.classifyAction(executorAction);
+                    let allowDangerous = false;
+                    let allowApproval = false;
+                    if (safety.tier === safetyManager.TIERS.APPROVAL || safety.tier === safetyManager.TIERS.DANGEROUS) {
+                        const approved = await requestApproval({
+                            type: action,
+                            label: formatActionPreview(action, input),
+                            preview: `${action}: ${formatActionPreview(action, input)}\nSafety: ${safety.tier} (${safety.reason})`
+                        });
+                        if (!approved) {
+                            toolResult = `User denied ${action}: ${formatActionPreview(action, input)}`;
+                            break;
+                        }
+                        allowApproval = safety.tier === safetyManager.TIERS.APPROVAL;
+                        allowDangerous = safety.tier === safetyManager.TIERS.DANGEROUS;
+                    }
+
+                    toolResult = await executeAction(executorAction, {
+                        source: 'code_agent',
+                        allowApproval,
+                        allowDangerous
                     });
                     break;
                 }                default:
@@ -705,6 +969,22 @@ async function executeCodeTask(task, options = {}) {
             toolResult = `Error: ${e.message}`;
         }
 
+        const evaluation = evaluateActionResult(action, toolResult);
+        if (evaluation) {
+            onProgress({
+                step,
+                phase: 'evaluating',
+                action: 'evaluator',
+                message: `${evaluation.status}: ${evaluation.message}`
+            });
+            toolResult = [
+                toolResult,
+                '',
+                'Evaluation:',
+                `${evaluation.status}: ${evaluation.message}`
+            ].join('\n');
+        }
+
         // Log the finished step with result
         let resultSummary = '';
         if (action === 'search_code') {
@@ -718,8 +998,7 @@ async function executeCodeTask(task, options = {}) {
             step,
             phase: 'finished',
             action,
-            target: (input.path || input.command || input.query || '') + resultSummary,
-            thought: decision.thought
+            target: (input.path || input.command || input.query || '') + resultSummary
         });
 
         // Format tool result to be more readable and structured for the agent
@@ -767,10 +1046,16 @@ async function executeCodeTask(task, options = {}) {
     }
 
     if (finalSummary) {
+        memoryStore.recordInteraction(task, finalSummary);
+        const answeredProvider = client.lastSuccessfulProvider || client.provider || provider;
         return {
             summary: finalSummary,
             verification: finalVerification,
-            steps: executedSteps
+            steps: executedSteps,
+            providerInfo: {
+                provider: answeredProvider,
+                model: getCodeProviderModel(answeredProvider, config)
+            }
         };
     }
 
@@ -780,10 +1065,15 @@ async function executeCodeTask(task, options = {}) {
         lastVerification: 'Agent limit reached before explicit completion.'
     });
 
+    const answeredProvider = client.lastSuccessfulProvider || client.provider || provider;
     return {
         summary: 'Stopped after reaching the maximum number of agent steps.',
         verification: 'Agent limit reached before explicit completion.',
-        steps: executedSteps || MAX_AGENT_STEPS
+        steps: executedSteps || MAX_AGENT_STEPS,
+        providerInfo: {
+            provider: answeredProvider,
+            model: getCodeProviderModel(answeredProvider, config)
+        }
     };
 }
 
@@ -792,6 +1082,7 @@ module.exports = {
     _helpers: {
         extractJson,
         selectSupportedCodeProvider,
+        getSupportedCodeProviderOrder,
         findPaths,
         listFiles,
         searchCode,