@pheem49/mint 1.5.0 → 1.5.1

package/src/CLI/code_agent.js

@@ -7,8 +7,11 @@ 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, onProgress = () => {}) {
     if (!query) throw new Error('Search query required.');
@@ -169,6 +172,109 @@ function extractJson(text) {
     }
 }
 
+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'];
@@ -371,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
     });
@@ -478,7 +585,7 @@ class UnifiedAgentClient {
         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', {
@@ -504,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`, {
@@ -525,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,
@@ -542,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;
     }
 }
@@ -616,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`
@@ -636,6 +749,8 @@ async function buildInitialObservation(task, workspaceRoot, history = []) {
         session.summary || '(none)',
         `Previous task: ${session.lastTask || '(none)'}`,
         `Previous verification: ${session.lastVerification || '(none)'}`,
+        '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');
 }
@@ -644,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;
@@ -656,7 +772,24 @@ async function executeCodeTask(task, options = {}) {
     const provider = providerOrder[0];
     const client = new UnifiedAgentClient(provider, config, providerOrder);
 
-    let observation = await buildInitialObservation(task, workspaceRoot, history);
+    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 = '';
@@ -669,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({
@@ -682,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,
@@ -785,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 || input.path || input.query // Handle all possible input fields
+                    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:
@@ -797,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') {
@@ -858,6 +1046,7 @@ async function executeCodeTask(task, options = {}) {
     }
 
     if (finalSummary) {
+        memoryStore.recordInteraction(task, finalSummary);
         const answeredProvider = client.lastSuccessfulProvider || client.provider || provider;
         return {
             summary: finalSummary,

package/src/CLI/image_input.js

@@ -0,0 +1,90 @@
+const fs = require('fs');
+const path = require('path');
+const { execFileSync } = require('child_process');
+
+const IMAGE_MIME_TYPES = {
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.webp': 'image/webp',
+    '.gif': 'image/gif'
+};
+
+function resolveImagePath(imagePath, cwd = process.cwd()) {
+    if (!imagePath || typeof imagePath !== 'string') {
+        throw new Error('Image path is required.');
+    }
+
+    return path.resolve(cwd, imagePath);
+}
+
+function getImageMimeType(imagePath) {
+    const ext = path.extname(imagePath).toLowerCase();
+    const mimeType = IMAGE_MIME_TYPES[ext];
+    if (!mimeType) {
+        throw new Error(`Unsupported image type "${ext || '(none)'}". Supported: ${Object.keys(IMAGE_MIME_TYPES).join(', ')}`);
+    }
+    return mimeType;
+}
+
+function loadImageAsDataUri(imagePath, cwd = process.cwd()) {
+    const resolved = resolveImagePath(imagePath, cwd);
+    if (!fs.existsSync(resolved)) {
+        throw new Error(`Image file not found: ${imagePath}`);
+    }
+
+    const stat = fs.statSync(resolved);
+    if (!stat.isFile()) {
+        throw new Error(`Image path is not a file: ${imagePath}`);
+    }
+
+    const mimeType = getImageMimeType(resolved);
+    const data = fs.readFileSync(resolved).toString('base64');
+    return {
+        path: resolved,
+        mimeType,
+        dataUri: `data:${mimeType};base64,${data}`
+    };
+}
+
+function tryReadClipboardCommand(command, args) {
+    try {
+        return execFileSync(command, args, {
+            encoding: 'buffer',
+            maxBuffer: 1024 * 1024 * 20,
+            stdio: ['ignore', 'pipe', 'ignore']
+        });
+    } catch (_) {
+        return null;
+    }
+}
+
+function loadClipboardImageAsDataUri() {
+    const attempts = [
+        { command: 'wl-paste', args: ['--type', 'image/png', '--no-newline'] },
+        { command: 'xclip', args: ['-selection', 'clipboard', '-t', 'image/png', '-o'] }
+    ];
+
+    for (const attempt of attempts) {
+        const data = tryReadClipboardCommand(attempt.command, attempt.args);
+        if (data && data.length > 0) {
+            return {
+                path: 'clipboard',
+                mimeType: 'image/png',
+                dataUri: `data:image/png;base64,${data.toString('base64')}`
+            };
+        }
+    }
+
+    throw new Error('No clipboard image found. On Linux, install wl-clipboard or xclip, then copy an image and try Ctrl+V again.');
+}
+
+module.exports = {
+    loadImageAsDataUri,
+    loadClipboardImageAsDataUri,
+    _helpers: {
+        getImageMimeType,
+        resolveImagePath,
+        tryReadClipboardCommand
+    }
+};

package/src/CLI/onboarding.js

@@ -4,6 +4,35 @@ const { readConfig, writeConfig } = require('../System/config_manager');
 const { installDaemon } = require('../System/daemon_manager');
 const { runGmailAuth } = require('./gmail_auth');
 
+const CUSTOM_MODEL_VALUE = '__custom_model__';
+const ANTHROPIC_MODEL_CHOICES = [
+    'claude-3-5-sonnet-latest',
+    'claude-3-opus-latest',
+    'claude-3-5-haiku-latest'
+];
+const OPENAI_MODEL_CHOICES = [
+    'gpt-4o',
+    'gpt-4o-mini',
+    'o1-preview',
+    'o1-mini'
+];
+
+function buildModelChoices(models, currentModel) {
+    const choices = models.map(model => ({ name: model, value: model }));
+    if (currentModel && !models.includes(currentModel)) {
+        choices.push({ name: `${currentModel} (current)`, value: currentModel });
+    }
+    choices.push({ name: 'Custom...', value: CUSTOM_MODEL_VALUE });
+    return choices;
+}
+
+function resolveCustomModelSelection(answers, modelKey, customKey, fallbackModel) {
+    if (answers[modelKey] !== CUSTOM_MODEL_VALUE) return;
+    const customModel = typeof answers[customKey] === 'string' ? answers[customKey].trim() : '';
+    answers[modelKey] = customModel || fallbackModel;
+    delete answers[customKey];
+}
+
 /**
  * Onboarding Wizard for Mint CLI
  */
@@ -56,10 +85,10 @@ async function runOnboarding(options = {}) {
                 { name: 'Gmail API', value: 'gmail', checked: config.pluginGmailEnabled },
                 { name: 'Notion API', value: 'notion', checked: config.pluginNotionEnabled },
                 new inquirer.Separator(),
-                { name: 'Anthropic (Claude)', value: 'anthropic', checked: config.aiProvider === 'anthropic' || !!config.anthropicApiKey },
-                { name: 'OpenAI (GPT-4o)', value: 'openai', checked: config.aiProvider === 'openai' || !!config.openaiApiKey },
-                { name: 'Hugging Face', value: 'hf', checked: config.aiProvider === 'huggingface' || !!config.hfApiKey },
-                { name: 'Local AI (LM Studio/Ollama)', value: 'local', checked: config.aiProvider === 'local_openai' || (!!config.localApiBaseUrl && config.localApiBaseUrl.length > 0) },
+                { name: 'Anthropic (Claude)', value: 'anthropic', checked: !!config.anthropicApiKey },
+                { name: 'OpenAI (GPT-4o)', value: 'openai', checked: !!config.openaiApiKey },
+                { name: 'Hugging Face', value: 'hf', checked: !!config.hfApiKey },
+                { name: 'Local AI (LM Studio/Ollama)', value: 'local', checked: !!(config.localApiBaseUrl && config.localApiBaseUrl.length > 0) },
                 new inquirer.Separator(),
                 { name: 'Google Search API', value: 'google_search', checked: !!config.googleSearchApiKey },
                 { name: 'Brave Search API', value: 'brave_search', checked: !!config.braveSearchApiKey },
@@ -257,7 +286,23 @@ async function runOnboarding(options = {}) {
                 type: 'input',
                 name: 'anthropicApiKey',
                 message: 'Enter Anthropic API Key:',
-                default: config.anthropicApiKey
+                default: config.anthropicApiKey,
+                validate: (input) => input.trim().length > 0 ? true : 'Anthropic API Key is required when Anthropic is selected.'
+            });
+            dynamicQuestions.push({
+                type: 'list',
+                name: 'anthropicModel',
+                message: 'Select Anthropic model:',
+                choices: buildModelChoices(ANTHROPIC_MODEL_CHOICES, config.anthropicModel),
+                default: config.anthropicModel || 'claude-3-5-sonnet-latest'
+            });
+            dynamicQuestions.push({
+                type: 'input',
+                name: 'anthropicModelCustom',
+                message: 'Enter custom Anthropic model:',
+                default: config.anthropicModel || 'claude-3-5-sonnet-latest',
+                when: (answers) => answers.anthropicModel === CUSTOM_MODEL_VALUE,
+                validate: (input) => input.trim().length > 0 ? true : 'Model name is required.'
             });
         }
 
@@ -266,7 +311,23 @@ async function runOnboarding(options = {}) {
                 type: 'input',
                 name: 'openaiApiKey',
                 message: 'Enter OpenAI API Key:',
-                default: config.openaiApiKey
+                default: config.openaiApiKey,
+                validate: (input) => input.trim().length > 0 ? true : 'OpenAI API Key is required when OpenAI is selected.'
+            });
+            dynamicQuestions.push({
+                type: 'list',
+                name: 'openaiModel',
+                message: 'Select OpenAI model:',
+                choices: buildModelChoices(OPENAI_MODEL_CHOICES, config.openaiModel),
+                default: config.openaiModel || 'gpt-4o'
+            });
+            dynamicQuestions.push({
+                type: 'input',
+                name: 'openaiModelCustom',
+                message: 'Enter custom OpenAI model:',
+                default: config.openaiModel || 'gpt-4o',
+                when: (answers) => answers.openaiModel === CUSTOM_MODEL_VALUE,
+                validate: (input) => input.trim().length > 0 ? true : 'Model name is required.'
             });
         }
 
@@ -297,19 +358,15 @@ async function runOnboarding(options = {}) {
 
     if (dynamicQuestions.length > 0) {
         const extraAnswers = await inquirer.prompt(dynamicQuestions);
+        resolveCustomModelSelection(extraAnswers, 'anthropicModel', 'anthropicModelCustom', config.anthropicModel || 'claude-3-5-sonnet-latest');
+        resolveCustomModelSelection(extraAnswers, 'openaiModel', 'openaiModelCustom', config.openaiModel || 'gpt-4o');
         config = { ...config, ...extraAnswers };
         
     }
 
-    // Ensure aiProvider reflects the selected primary AI. If no optional AI
-    // provider is selected, keep Gemini as the safe default from basic setup.
-    if (!selections.includes('skip')) {
-        if (selections.includes('anthropic')) config.aiProvider = 'anthropic';
-        else if (selections.includes('openai')) config.aiProvider = 'openai';
-        else if (selections.includes('hf')) config.aiProvider = 'huggingface';
-        else if (selections.includes('local')) config.aiProvider = 'local_openai';
-        else config.aiProvider = 'gemini';
-    }
+    // Onboarding treats Gemini as the primary AI. Other providers are optional
+    // configured backends that become available only when credentials are set.
+    config.aiProvider = 'gemini';
 
     // Save configuration
     writeConfig(config);

package/src/CLI/updater.js

@@ -74,7 +74,8 @@ function shouldRunAutoUpdate(config = {}, now = Date.now()) {
 
 async function getLatestVersion(packageName = pkg.name) {
     const { stdout } = await execFilePromise(NPM_COMMAND, ['view', packageName, 'version', '--json'], {
-        maxBuffer: 1024 * 1024
+        maxBuffer: 1024 * 1024,
+        timeout: 30000
     });
     return normalizeNpmVersionOutput(stdout);
 }
@@ -86,7 +87,8 @@ async function installLatest(packageName = pkg.name, options = {}) {
     }
 
     return await execFilePromise(NPM_COMMAND, args, {
-        maxBuffer: 1024 * 1024 * 8
+        maxBuffer: 1024 * 1024 * 8,
+        timeout: 5 * 60 * 1000
     });
 }
 
@@ -182,14 +184,14 @@ async function runStartupAutoUpdate(config, writeConfig, options = {}) {
         };
     }
 
+    const result = await runUpdate({ checkOnly: false });
     if (typeof writeConfig === 'function') {
         writeConfig({
             ...config,
             lastUpdateCheckAt: new Date(now).toISOString()
         });
     }
-
-    return await runUpdate({ checkOnly: false });
+    return result;
 }
 
 module.exports = {