@pheem49/mint 1.4.0 → 1.4.2

package/src/CLI/workspace_manager.js

@@ -9,26 +9,35 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 
-const WORKSPACE_FILE = path.join(os.homedir(), '.config', 'mint', 'workspaces.json');
+function getWorkspaceFile() {
+    return process.env.MINT_WORKSPACE_FILE || path.join(os.homedir(), '.config', 'mint', 'workspaces.json');
+}
 
 function ensureDir() {
-    const dir = path.dirname(WORKSPACE_FILE);
+    const dir = path.dirname(getWorkspaceFile());
     if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
 }
 
 function loadWorkspaces() {
+    const workspaceFile = getWorkspaceFile();
     ensureDir();
-    if (!fs.existsSync(WORKSPACE_FILE)) return {};
+    if (!fs.existsSync(workspaceFile)) return {};
     try {
-        return JSON.parse(fs.readFileSync(WORKSPACE_FILE, 'utf8'));
+        return JSON.parse(fs.readFileSync(workspaceFile, 'utf8'));
     } catch (e) {
         return {};
     }
 }
 
 function saveWorkspaces(data) {
+    const workspaceFile = getWorkspaceFile();
     ensureDir();
-    fs.writeFileSync(WORKSPACE_FILE, JSON.stringify(data, null, 2));
+    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 = '') {
@@ -62,7 +71,7 @@ function getWorkspaceByPath(currentPath) {
     // Find workspace where current path is inside or equal to workspace path
     for (const name in workspaces) {
         const ws = workspaces[name];
-        if (absoluteCurrent.startsWith(ws.path)) {
+        if (isPathInsideWorkspace(absoluteCurrent, ws.path)) {
             return ws;
         }
     }

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') {

package/src/System/config_manager.js

@@ -67,7 +67,7 @@ const DEFAULT_CONFIG = {
     localApiBaseUrl: 'http://localhost:1234/v1',
     localModelName: 'local-model',
     ollamaHost: 'http://localhost:11434',
-    enableAgentCollaboration: true
+    enableAgentCollaboration: false
 };
 
 

package/src/System/custom_workflows.js

@@ -3,6 +3,10 @@ const path = require('path');
 const { app, shell } = require('electron');
 const { exec } = require('child_process');
 
+function escapeRegExp(text) {
+    return String(text).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
 class CustomWorkflows {
     constructor() {
         this.configPath = path.join(app.getPath('userData'), 'workflows.json');
@@ -86,7 +90,7 @@ class CustomWorkflows {
                     if (wf.trigger && wf.trigger.type === 'process_running' && wf.trigger.processName) {
                         const targetName = wf.trigger.processName.toLowerCase();
                         // simplistic exact-word match to avoid partial matches
-                        const regex = new RegExp(`^${targetName}$`, 'm');
+                        const regex = new RegExp(`^${escapeRegExp(targetName)}$`, 'm');
                         const isRunning = regex.test(runningProcesses);
                         
                         if (isRunning) {
@@ -124,4 +128,7 @@ class CustomWorkflows {
     }
 }
 
-module.exports = new CustomWorkflows();
+const instance = new CustomWorkflows();
+instance._helpers = { escapeRegExp };
+
+module.exports = instance;

package/tests/chat_router.test.js

@@ -0,0 +1,42 @@
+/**
+ * Tests: chat_router routing helpers
+ */
+
+jest.mock('@google/genai', () => ({
+    GoogleGenAI: jest.fn()
+}));
+
+jest.mock('../src/CLI/code_agent', () => ({
+    executeCodeTask: jest.fn(),
+    _helpers: {
+        selectSupportedCodeProvider: jest.fn(() => 'gemini')
+    }
+}));
+
+jest.mock('../src/System/config_manager', () => ({
+    readConfig: jest.fn(() => ({})),
+    getAvailableProviders: jest.fn(() => ['gemini'])
+}));
+
+describe('chat_router helpers', () => {
+    test('recognizes direct folder open request as chat task', () => {
+        const { _helpers } = require('../src/CLI/chat_router');
+        expect(_helpers.isDirectFilesystemActionRequest('เปิดโฟลเดอร์ xidaidai ให้หน่อย')).toBe(true);
+    });
+
+    test('does not classify direct folder open request as code intent', () => {
+        const { _helpers } = require('../src/CLI/chat_router');
+        const route = _helpers.detectCodeIntentHeuristic('open folder xidaidai', process.cwd());
+        expect(route).toBe(false);
+    });
+
+    test('treats small file-related request as normal chat', () => {
+        const { _helpers } = require('../src/CLI/chat_router');
+        expect(_helpers.isLargeCodeTaskRequest('ดูไฟล์ package.json ให้หน่อย', process.cwd())).toBe(false);
+    });
+
+    test('treats substantial project fix request as code task', () => {
+        const { _helpers } = require('../src/CLI/chat_router');
+        expect(_helpers.isLargeCodeTaskRequest('fix the failing tests in this project and verify the result', process.cwd())).toBe(true);
+    });
+});

package/tests/code_agent.test.js

@@ -0,0 +1,69 @@
+/**
+ * Tests: code_agent helpers
+ */
+
+jest.mock('@google/genai', () => ({
+    GoogleGenAI: jest.fn()
+}));
+
+jest.mock('axios', () => ({}));
+
+jest.mock('../src/System/config_manager', () => ({
+    readConfig: jest.fn(() => ({})),
+    getAvailableProviders: jest.fn(() => ['ollama', 'gemini'])
+}));
+
+jest.mock('../src/CLI/code_session_memory', () => ({
+    readWorkspaceSession: jest.fn(() => ({
+        summary: '',
+        lastTask: '',
+        lastVerification: '',
+        updatedAt: null
+    })),
+    writeWorkspaceSession: jest.fn()
+}));
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+describe('code_agent helpers', () => {
+    test('extractJson recovers JSON embedded in surrounding text', () => {
+        const { _helpers } = require('../src/CLI/code_agent');
+        const parsed = _helpers.extractJson('note\n{"action":"finish","input":{"summary":"ok"}}\nthanks');
+        expect(parsed.action).toBe('finish');
+        expect(parsed.input.summary).toBe('ok');
+    });
+
+    test('selectSupportedCodeProvider falls back away from unsupported code providers', () => {
+        const { _helpers } = require('../src/CLI/code_agent');
+        const selected = _helpers.selectSupportedCodeProvider(
+            { aiProvider: 'ollama' },
+            ['ollama', 'openai', 'gemini']
+        );
+        expect(selected).toBe('openai');
+    });
+
+    test('selectSupportedCodeProvider keeps configured supported provider when available', () => {
+        const { _helpers } = require('../src/CLI/code_agent');
+        const selected = _helpers.selectSupportedCodeProvider(
+            { aiProvider: 'anthropic' },
+            ['anthropic', 'gemini']
+        );
+        expect(selected).toBe('anthropic');
+    });
+
+    test('findPaths can locate directories by partial name', async () => {
+        const { _helpers } = require('../src/CLI/code_agent');
+        const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mint-code-agent-'));
+        const targetDir = path.join(tempDir, 'projects', 'xidaidai');
+        fs.mkdirSync(targetDir, { recursive: true });
+
+        try {
+            const result = await _helpers.findPaths(tempDir, 'xidaidai', 'dir');
+            expect(result).toContain('[dir] projects/xidaidai');
+        } finally {
+            fs.rmSync(tempDir, { recursive: true, force: true });
+        }
+    });
+});

package/tests/docker.test.js

@@ -0,0 +1,46 @@
+/**
+ * Tests: docker.js plugin
+ */
+
+jest.mock('child_process', () => ({
+    execFile: jest.fn()
+}));
+
+let docker;
+let execFile;
+
+beforeEach(() => {
+    jest.resetModules();
+    ({ execFile } = require('child_process'));
+    execFile.mockReset();
+    docker = require('../src/Plugins/docker');
+});
+
+describe('Docker Plugin', () => {
+    test('lists running containers', async () => {
+        execFile.mockImplementation((command, args, callback) => {
+            callback(null, 'web (Up 2 hours)\n', '');
+        });
+
+        const result = await docker.execute('list');
+        expect(execFile).toHaveBeenCalledWith('docker', ['ps', '--format', '{{.Names}} ({{.Status}})'], expect.any(Function));
+        expect(result).toContain('Running Containers');
+        expect(result).toContain('web (Up 2 hours)');
+    });
+
+    test('starts a named container without shell interpolation', async () => {
+        execFile.mockImplementation((command, args, callback) => {
+            callback(null, '', '');
+        });
+
+        const result = await docker.execute('start my-app');
+        expect(execFile).toHaveBeenCalledWith('docker', ['start', 'my-app'], expect.any(Function));
+        expect(result).toContain('Successfully executed "docker start"');
+    });
+
+    test('returns helpful message when command is invalid', async () => {
+        const result = await docker.execute('remove my-app');
+        expect(result).toContain('Invalid docker command');
+        expect(execFile).not.toHaveBeenCalled();
+    });
+});

package/tests/file_operations.test.js

@@ -0,0 +1,57 @@
+/**
+ * Tests: file_operations helpers
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+describe('file_operations findPath', () => {
+    let tempDir;
+    let originalCwd;
+
+    beforeEach(() => {
+        jest.resetModules();
+        tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mint-file-ops-'));
+        originalCwd = process.cwd();
+        process.chdir(tempDir);
+    });
+
+    afterEach(() => {
+        process.chdir(originalCwd);
+        fs.rmSync(tempDir, { recursive: true, force: true });
+    });
+
+    test('finds directory matches by name', () => {
+        const targetDir = path.join(tempDir, 'nested', 'xidaidai');
+        fs.mkdirSync(targetDir, { recursive: true });
+
+        const { findPath } = require('../src/Automation_Layer/file_operations');
+        const result = findPath('xidaidai', { type: 'dir', maxResults: 10, roots: [tempDir] });
+
+        expect(result.success).toBe(true);
+        expect(result.matches.some(match => match.path === targetDir && match.type === 'dir')).toBe(true);
+    });
+
+    test('returns not found message when no path matches', () => {
+        const { findPath } = require('../src/Automation_Layer/file_operations');
+        const result = findPath('does-not-exist', { type: 'dir', maxResults: 10, roots: [tempDir] });
+
+        expect(result.success).toBe(false);
+        expect(result.message).toContain('ไม่พบ');
+    });
+
+    test('prefers exact directory name matches over nested partial matches', () => {
+        const exactDir = path.join(tempDir, 'xidaidai');
+        const nestedPartial = path.join(tempDir, 'xidaidai collection', 'xidaidai gif');
+        fs.mkdirSync(exactDir, { recursive: true });
+        fs.mkdirSync(nestedPartial, { recursive: true });
+
+        const { findPath } = require('../src/Automation_Layer/file_operations');
+        const result = findPath('xidaidai', { type: 'dir', maxResults: 10, roots: [tempDir] });
+
+        expect(result.success).toBe(true);
+        expect(result.matches.length).toBe(1);
+        expect(result.matches[0].path).toBe(exactDir);
+    });
+});

package/tests/provider_routing.test.js

@@ -0,0 +1,67 @@
+/**
+ * Tests: Gemini_API provider routing helpers
+ */
+
+jest.mock('@google/genai', () => ({
+    GoogleGenAI: jest.fn(() => ({
+        chats: {
+            create: jest.fn(() => ({
+                sendMessage: jest.fn(),
+                sendMessageStream: jest.fn(),
+                getHistory: jest.fn(async () => [])
+            }))
+        },
+        models: {
+            generateContent: jest.fn()
+        }
+    }))
+}));
+
+jest.mock('../src/System/chat_history_manager', () => ({
+    readChatHistory: jest.fn(() => []),
+    writeChatHistory: jest.fn(),
+    clearChatHistory: jest.fn()
+}));
+
+jest.mock('../src/System/config_manager', () => ({
+    readConfig: jest.fn(() => ({})),
+    getAvailableProviders: jest.fn(() => ['ollama', 'gemini'])
+}));
+
+jest.mock('../src/Plugins/plugin_manager', () => ({
+    loadPlugins: jest.fn(),
+    getPromptDescriptions: jest.fn(() => '')
+}));
+
+jest.mock('../src/Plugins/mcp_manager', () => ({
+    getAllTools: jest.fn(() => [])
+}));
+
+jest.mock('../src/AI_Brain/memory_store', () => ({
+    getUserContext: jest.fn(() => ''),
+    getCachedResponse: jest.fn(),
+    recordInteraction: jest.fn(),
+    cacheResponse: jest.fn()
+}));
+
+jest.mock('../src/AI_Brain/agent_orchestrator', () => ({
+    getCurrentAgent: jest.fn(() => ({ name: 'Mint Default', instruction: 'default' }))
+}));
+
+jest.mock('../src/CLI/workspace_manager', () => ({
+    getWorkspaceByPath: jest.fn(() => null)
+}));
+
+describe('Gemini_API provider routing helpers', () => {
+    test('prioritizes configured provider, then falls back to available providers', () => {
+        const geminiApi = require('../src/AI_Brain/Gemini_API');
+        const order = geminiApi._helpers.getProviderAttemptOrder({
+            aiProvider: 'openai',
+            openaiApiKey: 'key',
+            localApiBaseUrl: 'http://localhost:1234/v1'
+        });
+
+        expect(order[0]).toBe('openai');
+        expect(order).toContain('ollama');
+    });
+});

package/tests/workspace_manager.test.js

@@ -9,13 +9,17 @@ const os = require('os');
 
 describe('Workspace Manager', () => {
     let tempDir;
+    let workspaceFile;
 
     beforeEach(() => {
         // Create a temp workspace directory
         tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mint-ws-test-'));
+        workspaceFile = path.join(tempDir, 'workspaces.json');
+        process.env.MINT_WORKSPACE_FILE = workspaceFile;
     });
 
     afterEach(() => {
+        delete process.env.MINT_WORKSPACE_FILE;
         fs.rmSync(tempDir, { recursive: true, force: true });
     });
 
@@ -32,6 +36,17 @@ describe('Workspace Manager', () => {
         expect(ws.name).toBe('test-ws');
     });
 
+    test('does not match sibling paths with same prefix', () => {
+        const workspaceRoot = path.join(tempDir, 'project');
+        const siblingPath = path.join(tempDir, 'project-two');
+        fs.mkdirSync(workspaceRoot, { recursive: true });
+        fs.mkdirSync(siblingPath, { recursive: true });
+
+        wsManager.addWorkspace('test-ws', workspaceRoot);
+        const ws = wsManager.getWorkspaceByPath(siblingPath);
+        expect(ws).toBeNull();
+    });
+
     test('removes workspaces', () => {
         wsManager.addWorkspace('test-ws', tempDir);
         wsManager.removeWorkspace('test-ws');