@pheem49/mint 1.3.0 → 1.4.1

package/src/CLI/code_agent.js

@@ -3,13 +3,16 @@ const path = require('path');
 const { execFile } = require('child_process');
 const { promisify } = require('util');
 const { GoogleGenAI } = require('@google/genai');
-const { readConfig } = require('../System/config_manager');
+const axios = require('axios');
+const { readConfig, getAvailableProviders } = require('../System/config_manager');
 const { readWorkspaceSession, writeWorkspaceSession } = require('./code_session_memory');
 
 const execFileAsync = promisify(execFile);
 const DEFAULT_GEMINI_MODEL = 'gemini-2.5-flash';
 const MAX_TOOL_OUTPUT = 12000;
 const MAX_AGENT_STEPS = 16;
+const MAX_JSON_REPAIR_ATTEMPTS = 2;
+const SUPPORTED_CODE_PROVIDERS = ['gemini', 'anthropic', 'openai', 'local_openai'];
 
 const CODE_AGENT_PROMPT = `You are Mint Code Mode, a careful coding agent for a local workspace.
 
@@ -30,10 +33,11 @@ Rules:
 Response format:
 {
   "thought": "short reasoning",
-  "action": "list_files" | "read_file" | "search_code" | "run_shell" | "apply_patch" | "write_file" | "finish",
+  "action": "list_files" | "read_file" | "search_code" | "find_path" | "run_shell" | "apply_patch" | "write_file" | "finish",
   "input": {
     "path": "relative/path",
     "query": "search text",
+    "type": "file" | "dir" | "any",
     "command": "shell command",
     "startLine": 1,
     "endLine": 120,
@@ -57,6 +61,7 @@ Tool notes:
 - "list_files": inspect the workspace or a subdirectory.
 - "read_file": read a file, optionally with startLine/endLine.
 - "search_code": search by text or regex-like pattern.
+- "find_path": find files or directories by path/name when the user is looking for a folder, filename, or location.
 - "run_shell": run a non-destructive command in the workspace.
 - "apply_patch": update an existing file using one or more exact replacement hunks.
 - "write_file": create a new file or fully rewrite a file when replacement is not practical.
@@ -80,6 +85,22 @@ 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;
+    }
+
+    const priority = ['anthropic', 'openai', 'gemini', 'local_openai'];
+    for (const provider of priority) {
+        if (availableProviders.includes(provider)) {
+            return provider;
+        }
+    }
+
+    return 'gemini';
+}
+
 function resolveWorkspacePath(workspaceRoot, targetPath = '.') {
     const resolved = path.resolve(workspaceRoot, targetPath);
     const relative = path.relative(workspaceRoot, resolved);
@@ -159,6 +180,40 @@ async function searchCode(workspaceRoot, query) {
     }
 }
 
+async function findPaths(workspaceRoot, query, type = 'any') {
+    if (!query || !query.trim()) {
+        throw new Error('Path search query is required.');
+    }
+
+    const normalizedType = ['file', 'dir', 'any'].includes(type) ? type : 'any';
+    const loweredQuery = query.trim().toLowerCase();
+    const results = [];
+
+    function visit(currentPath) {
+        const entries = fs.readdirSync(currentPath, { withFileTypes: true });
+        for (const entry of entries) {
+            const absoluteEntryPath = path.join(currentPath, entry.name);
+            const relativeEntryPath = path.relative(workspaceRoot, absoluteEntryPath) || '.';
+            const entryType = entry.isDirectory() ? 'dir' : 'file';
+            const matchesType = normalizedType === 'any' || normalizedType === entryType;
+            const matchesQuery = entry.name.toLowerCase().includes(loweredQuery) || relativeEntryPath.toLowerCase().includes(loweredQuery);
+
+            if (matchesType && matchesQuery) {
+                results.push(`${entryType === 'dir' ? '[dir]' : '[file]'} ${relativeEntryPath}`);
+                if (results.length >= 200) return;
+            }
+
+            if (entry.isDirectory() && results.length < 200) {
+                visit(absoluteEntryPath);
+                if (results.length >= 200) return;
+            }
+        }
+    }
+
+    visit(workspaceRoot);
+    return results.length > 0 ? results.join('\n') : '(no matching paths)';
+}
+
 function assertSafeShell(command) {
     const blockedPatterns = [
         /\brm\s+-rf\b/,
@@ -244,16 +299,124 @@ function writeFile(workspaceRoot, targetPath, content) {
     return `Wrote ${targetPath}`;
 }
 
-function getAiClientAndModel() {
-    const config = readConfig();
-    const apiKey = (config.apiKey || process.env.GEMINI_API_KEY || '').trim();
-    if (!apiKey) {
-        throw new Error("Missing Gemini API key. Run 'mint onboard' first.");
+class UnifiedAgentClient {
+    constructor(provider, config) {
+        this.provider = SUPPORTED_CODE_PROVIDERS.includes(provider) ? provider : 'gemini';
+        this.config = config;
+        this.history = [];
+        this.systemInstruction = CODE_AGENT_PROMPT;
+    }
+
+    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();
+        }
+
+        this.history.push({ role: 'assistant', content: responseText });
+        return responseText;
+    }
+
+    async _callAnthropic() {
+        const apiKey = this.config.anthropicApiKey || process.env.ANTHROPIC_API_KEY;
+        const messages = this.history.map(m => ({
+            role: m.role,
+            content: m.content
+        }));
+
+        const response = await axios.post('https://api.anthropic.com/v1/messages', {
+            model: this.config.anthropicModel || 'claude-3-5-sonnet-latest',
+            max_tokens: 8192,
+            system: this.systemInstruction,
+            messages: messages
+        }, {
+            headers: {
+                'x-api-key': apiKey,
+                'anthropic-version': '2023-06-01',
+                'content-type': 'application/json'
+            }
+        });
+        return response.data.content[0].text;
+    }
+
+    async _callOpenAI() {
+        const isLocal = this.provider === 'local_openai';
+        const apiKey = isLocal ? 'not-needed' : (this.config.openaiApiKey || process.env.OPENAI_API_KEY);
+        const baseUrl = isLocal ? (this.config.localApiBaseUrl || 'http://localhost:1234/v1') : 'https://api.openai.com/v1';
+        const model = isLocal ? (this.config.localModelName || 'local-model') : (this.config.openaiModel || 'gpt-4o');
+
+        const messages = [
+            { role: 'system', content: this.systemInstruction },
+            ...this.history
+        ];
+
+        const response = await axios.post(`${baseUrl.replace(/\/$/, '')}/chat/completions`, {
+            model: model,
+            messages: messages,
+            response_format: isLocal ? undefined : { type: "json_object" }
+        }, {
+            headers: {
+                'Authorization': `Bearer ${apiKey}`,
+                'Content-Type': 'application/json'
+            }
+        });
+        return response.data.choices[0].message.content;
+    }
+
+    async _callGemini() {
+        const apiKey = this.config.apiKey || process.env.GEMINI_API_KEY;
+        const model = this.config.geminiModel || DEFAULT_GEMINI_MODEL;
+        const ai = new GoogleGenAI({ apiKey });
+        
+        // Convert history for Gemini
+        const geminiHistory = this.history.slice(0, -1).map(m => ({
+            role: m.role === 'assistant' ? 'model' : 'user',
+            parts: [{ text: m.content }]
+        }));
+        
+        const lastMessage = this.history[this.history.length - 1].content;
+
+        const chat = ai.chats.create({
+            model,
+            config: {
+                systemInstruction: this.systemInstruction,
+                responseMimeType: 'application/json'
+            },
+            history: geminiHistory
+        });
+
+        const response = await chat.sendMessage({ message: [{ text: lastMessage }] });
+        return typeof response.text === 'function' ? response.text() : response.text;
+    }
+}
+
+async function getAgentDecision(client, observation, options = {}) {
+    const onProgress = typeof options.onProgress === 'function' ? options.onProgress : () => {};
+    const step = options.step || 0;
+
+    let rawText = await client.sendMessage(observation);
+    for (let attempt = 0; attempt <= MAX_JSON_REPAIR_ATTEMPTS; attempt++) {
+        try {
+            return extractJson(rawText);
+        } catch (error) {
+            if (attempt === MAX_JSON_REPAIR_ATTEMPTS) {
+                throw new Error(`Agent returned invalid JSON after ${MAX_JSON_REPAIR_ATTEMPTS + 1} attempts: ${error.message}`);
+            }
+
+            onProgress(`Step ${step}: invalid JSON response, requesting repair (${attempt + 1}/${MAX_JSON_REPAIR_ATTEMPTS})`);
+            rawText = await client.sendMessage([
+                'Your previous response was not valid JSON for Code Mode.',
+                'Reply again with valid JSON only, following the required schema exactly.',
+                `Previous response:\n${truncate(rawText, 4000)}`
+            ].join('\n'));
+        }
     }
-    return {
-        ai: new GoogleGenAI({ apiKey }),
-        model: (config.geminiModel || DEFAULT_GEMINI_MODEL).trim() || DEFAULT_GEMINI_MODEL
-    };
 }
 
 function detectPackageManager(workspaceRoot) {
@@ -298,12 +461,17 @@ async function getGitContext(workspaceRoot) {
     return { isRepo: true, branch, status, diffSummary };
 }
 
-async function buildInitialObservation(task, workspaceRoot) {
+async function buildInitialObservation(task, workspaceRoot, history = []) {
     const session = readWorkspaceSession(workspaceRoot);
     const gitContext = await getGitContext(workspaceRoot);
     const testCommands = detectTestCommands(workspaceRoot);
 
+    const contextStr = history.length > 0 
+        ? `Recent Context:\n${history.slice(-10).map(m => `${m.sender}: ${m.text}`).join('\n')}\n`
+        : '';
+
     return [
+        contextStr,
         `Task: ${task}`,
         `Workspace: ${workspaceRoot}`,
         `Git branch: ${gitContext.branch}`,
@@ -323,45 +491,41 @@ async function buildInitialObservation(task, workspaceRoot) {
 
 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 requestApproval = typeof options.requestApproval === 'function'
         ? options.requestApproval
         : async () => true;
-    const { ai, model } = getAiClientAndModel();
-
-    const chat = ai.chats.create({
-        model,
-        config: {
-            systemInstruction: CODE_AGENT_PROMPT,
-            responseMimeType: 'application/json'
-        },
-        history: []
-    });
+    const config = readConfig();
+    const provider = options.provider || selectSupportedCodeProvider(config);
+    const client = new UnifiedAgentClient(provider, config);
 
-    let observation = await buildInitialObservation(task, workspaceRoot);
+    let observation = await buildInitialObservation(task, workspaceRoot, history);
+
+    let finalSummary = '';
+    let finalVerification = '';
+    let finalSessionSummary = '';
+    let executedSteps = 0;
 
     for (let step = 1; step <= MAX_AGENT_STEPS; step++) {
+        executedSteps = step;
         onProgress(`Step ${step}: thinking`);
-        const response = await chat.sendMessage({ message: [{ text: observation }] });
-        const text = typeof response.text === 'function' ? response.text() : response.text;
-        const decision = extractJson(text);
+        const decision = await getAgentDecision(client, observation, { onProgress, step });
         const action = decision.action;
         const input = decision.input || {};
 
         onProgress(`Step ${step}: ${action}${input.path ? ` ${input.path}` : input.command ? ` ${input.command}` : ''}`);
 
         if (action === 'finish') {
-            const sessionSummary = input.sessionSummary || input.summary || task;
+            finalSessionSummary = input.sessionSummary || input.summary || task;
+            finalSummary = input.summary || 'Task complete.';
+            finalVerification = input.verification || 'Not specified.';
             writeWorkspaceSession(workspaceRoot, {
-                summary: sessionSummary,
+                summary: finalSessionSummary,
                 lastTask: task,
-                lastVerification: input.verification || 'Not specified.'
+                lastVerification: finalVerification
             });
-            return {
-                summary: input.summary || 'Task complete.',
-                verification: input.verification || 'Not specified.',
-                steps: step
-            };
+            break;
         }
 
         let toolResult = '';
@@ -375,6 +539,9 @@ async function executeCodeTask(task, options = {}) {
             case 'search_code':
                 toolResult = await searchCode(workspaceRoot, input.query);
                 break;
+            case 'find_path':
+                toolResult = await findPaths(workspaceRoot, input.query, input.type);
+                break;
             case 'run_shell': {
                 const approved = await requestApproval({
                     type: 'shell',
@@ -427,6 +594,45 @@ async function executeCodeTask(task, options = {}) {
         ].join('\n');
     }
 
+    // Check for Agent Collaboration (Review)
+    if (config.enableAgentCollaboration !== false) {
+        const availableProviders = getAvailableProviders(config);
+        // Exclude providers that often need special local setup or are slow/unreliable for tiny reviews
+        const altProviders = availableProviders.filter(p => p !== provider && p !== 'ollama' && p !== 'huggingface' && p !== 'local_openai');
+        
+        // Fallback to provider itself if no other good ones exist, or pick the best available
+        const reviewerProvider = altProviders.length > 0 
+            ? altProviders[0] 
+            : (availableProviders.includes('gemini') ? 'gemini' : availableProviders[0]);
+
+        if (reviewerProvider && finalSummary) {
+            onProgress(`Invoking Reviewer Agent (${reviewerProvider})...`);
+            
+            const reviewerClient = new UnifiedAgentClient(reviewerProvider, config);
+            reviewerClient.systemInstruction = CODE_AGENT_PROMPT + "\n\nYou are the Reviewer Agent. Review the primary agent's changes, test output, and verification. If you spot a critical bug, point it out. Otherwise, confirm it looks good. Return JSON with action: 'finish' and your review in the 'summary' field.";
+            
+            const reviewPrompt = `The primary agent (${provider}) just completed the task: "${task}".\nSummary: ${finalSummary}\nVerification: ${finalVerification}\nGit Status: ${(await getGitContext(workspaceRoot)).status}\n\nPlease review this. Return JSON with action: 'finish'.`;
+            
+            try {
+                const reviewResponse = await reviewerClient.sendMessage(reviewPrompt);
+                const reviewDecision = extractJson(reviewResponse);
+                const reviewInput = reviewDecision.input || {};
+                
+                finalSummary += `\n\n[Review by ${reviewerProvider}]\n${reviewInput.summary || reviewDecision.thought || 'Looks good.'}`;
+            } catch (e) {
+                onProgress(`Reviewer Agent failed: ${e.message}`);
+            }
+        }
+    }
+
+    if (finalSummary) {
+        return {
+            summary: finalSummary,
+            verification: finalVerification,
+            steps: executedSteps
+        };
+    }
+
     writeWorkspaceSession(workspaceRoot, {
         summary: `Task stopped before completion: ${task}`,
         lastTask: task,
@@ -436,8 +642,15 @@ async function executeCodeTask(task, options = {}) {
     return {
         summary: 'Stopped after reaching the maximum number of agent steps.',
         verification: 'Agent limit reached before explicit completion.',
-        steps: MAX_AGENT_STEPS
+        steps: executedSteps || MAX_AGENT_STEPS
     };
 }
 
-module.exports = { executeCodeTask };
+module.exports = {
+    executeCodeTask,
+    _helpers: {
+        extractJson,
+        selectSupportedCodeProvider,
+        findPaths
+    }
+};

package/src/CLI/onboarding.js

@@ -18,28 +18,75 @@ async function runOnboarding(options = {}) {
         {
             type: 'input',
             name: 'apiKey',
-            message: 'Please enter your Google Gemini API Key:',
+            message: 'Enter your Google Gemini API Key (Required for basic features):',
             default: config.apiKey || undefined,
-            validate: (input) => input.length > 0 ? true : 'API Key is required.'
+            validate: (input) => input.trim().length > 0 ? true : 'API Key is required.'
         },
         {
             type: 'list',
-            name: 'geminiModel',
-            message: 'Select the Gemini model to use:',
+            name: 'geminiModelChoice',
+            message: 'Select the primary Gemini model to use:',
             choices: [
                 'gemini-2.5-flash',
+                'gemini-2.0-pro-exp-02-05',
                 'gemini-3.1-flash-lite-preview',
                 'gemini-3.1-flash-lite',
-                'gemini-2.0-pro-exp-02-05'
+                'Custom model name'
             ],
             default: config.geminiModel || 'gemini-2.5-flash'
+        },
+        {
+            type: 'input',
+            name: 'customGeminiModel',
+            message: 'Enter your custom Gemini model name:',
+            when: (answers) => answers.geminiModelChoice === 'Custom model name',
+            validate: (input) => input.trim().length > 0 ? true : 'Please enter a valid model name.'
+        },
+        {
+            type: 'input',
+            name: 'anthropicApiKey',
+            message: 'Enter your Anthropic API Key (Optional, press Enter to skip):',
+            default: config.anthropicApiKey || ''
+        },
+        {
+            type: 'input',
+            name: 'openaiApiKey',
+            message: 'Enter your OpenAI API Key (Optional, press Enter to skip):',
+            default: config.openaiApiKey || ''
+        },
+        {
+            type: 'input',
+            name: 'hfApiKey',
+            message: 'Enter your Hugging Face API Key (Optional, press Enter to skip):',
+            default: config.hfApiKey || ''
+        },
+        {
+            type: 'input',
+            name: 'localApiBaseUrl',
+            message: 'Enter your Local AI (LM Studio/OpenAI Compatible) Base URL (Optional, press Enter to skip):',
+            default: config.localApiBaseUrl || ''
+        },
+        {
+            type: 'input',
+            name: 'localModelName',
+            message: 'Enter your Local Model Name (Optional, press Enter to skip):',
+            default: config.localModelName || ''
         }
     ];
 
     const answers = await inquirer.prompt(questions);
+    
+    // Resolve custom gemini model if selected
+    const geminiModel = answers.geminiModelChoice === 'Custom model name' 
+        ? answers.customGeminiModel 
+        : answers.geminiModelChoice;
+
+    // Remove temporary choice fields before saving
+    delete answers.geminiModelChoice;
+    delete answers.customGeminiModel;
 
     // Save configuration
-    const newConfig = { ...config, ...answers };
+    const newConfig = { ...config, ...answers, geminiModel };
     writeConfig(newConfig);
     console.log('\n✅ Configuration saved successfully!');
 

package/src/CLI/workspace_manager.js

@@ -0,0 +1,90 @@
+/**
+ * Mint Workspace Manager
+ * -----------------------
+ * Manages project-specific contexts and persistent workspaces.
+ * Stores data in ~/.config/mint/workspaces.json
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+function getWorkspaceFile() {
+    return process.env.MINT_WORKSPACE_FILE || path.join(os.homedir(), '.config', 'mint', 'workspaces.json');
+}
+
+function ensureDir() {
+    const dir = path.dirname(getWorkspaceFile());
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+}
+
+function loadWorkspaces() {
+    const workspaceFile = getWorkspaceFile();
+    ensureDir();
+    if (!fs.existsSync(workspaceFile)) return {};
+    try {
+        return JSON.parse(fs.readFileSync(workspaceFile, 'utf8'));
+    } catch (e) {
+        return {};
+    }
+}
+
+function saveWorkspaces(data) {
+    const workspaceFile = getWorkspaceFile();
+    ensureDir();
+    fs.writeFileSync(workspaceFile, JSON.stringify(data, null, 2));
+}
+
+function isPathInsideWorkspace(currentPath, workspacePath) {
+    const relative = path.relative(workspacePath, currentPath);
+    return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
+}
+
+function addWorkspace(name, rootPath, instructions = '') {
+    const workspaces = loadWorkspaces();
+    const absolutePath = path.resolve(rootPath);
+    workspaces[name] = {
+        name,
+        path: absolutePath,
+        instructions,
+        addedAt: new Date().toISOString(),
+        lastAccessed: new Date().toISOString()
+    };
+    saveWorkspaces(workspaces);
+    return workspaces[name];
+}
+
+function removeWorkspace(name) {
+    const workspaces = loadWorkspaces();
+    if (workspaces[name]) {
+        delete workspaces[name];
+        saveWorkspaces(workspaces);
+        return true;
+    }
+    return false;
+}
+
+function getWorkspaceByPath(currentPath) {
+    const workspaces = loadWorkspaces();
+    const absoluteCurrent = path.resolve(currentPath);
+    
+    // Find workspace where current path is inside or equal to workspace path
+    for (const name in workspaces) {
+        const ws = workspaces[name];
+        if (isPathInsideWorkspace(absoluteCurrent, ws.path)) {
+            return ws;
+        }
+    }
+    return null;
+}
+
+function listWorkspaces() {
+    return loadWorkspaces();
+}
+
+module.exports = {
+    addWorkspace,
+    removeWorkspace,
+    getWorkspaceByPath,
+    listWorkspaces
+};

package/src/Plugins/docker.js

@@ -1,4 +1,4 @@
-const { exec } = require('child_process');
+const { execFile } = require('child_process');
 
 module.exports = {
     name: 'docker',
@@ -8,28 +8,30 @@ module.exports = {
         return new Promise((resolve) => {
             console.log(`[Docker Plugin] Executing command: ${target}`);
             
-            const [action, ...args] = target.toLowerCase().split(' ');
+            const rawTarget = (target || '').trim();
+            const [rawAction, ...args] = rawTarget.split(/\s+/);
+            const action = (rawAction || '').toLowerCase();
             const containerName = args.join(' ');
-
-            let cmd = '';
+            let commandArgs = [];
             
             if (action === 'list') {
-                cmd = 'docker ps --format "{{.Names}} ({{.Status}})"';
+                commandArgs = ['ps', '--format', '{{.Names}} ({{.Status}})'];
             } else if (['start', 'stop', 'restart'].includes(action) && containerName) {
-                cmd = `docker ${action} ${containerName}`;
+                commandArgs = [action, containerName];
             } else {
                 return resolve(`Invalid docker command or missing container name: ${target}`);
             }
 
-            exec(cmd, (error, stdout, stderr) => {
+            execFile('docker', commandArgs, (error, stdout, stderr) => {
                 if (error) {
-                    if (error.code === 127 || stderr.includes('not found')) {
+                    const stderrText = stderr || '';
+                    if (error.code === 127 || stderrText.includes('not found') || error.code === 'ENOENT') {
                         return resolve('Error: Docker is not installed or not in PATH.');
                     }
-                    if (stderr.includes('permission denied')) {
+                    if (stderrText.toLowerCase().includes('permission denied')) {
                         return resolve('Error: Permission denied. You might need to add your user to the "docker" group.');
                     }
-                    return resolve(`Docker Error: ${stderr || error.message}`);
+                    return resolve(`Docker Error: ${stderrText || error.message}`);
                 }
 
                 if (action === 'list') {