@pheem49/mint 1.2.4 → 1.4.0

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,81 @@
+/**
+ * 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');
+
+const WORKSPACE_FILE = path.join(os.homedir(), '.config', 'mint', 'workspaces.json');
+
+function ensureDir() {
+    const dir = path.dirname(WORKSPACE_FILE);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+}
+
+function loadWorkspaces() {
+    ensureDir();
+    if (!fs.existsSync(WORKSPACE_FILE)) return {};
+    try {
+        return JSON.parse(fs.readFileSync(WORKSPACE_FILE, 'utf8'));
+    } catch (e) {
+        return {};
+    }
+}
+
+function saveWorkspaces(data) {
+    ensureDir();
+    fs.writeFileSync(WORKSPACE_FILE, JSON.stringify(data, null, 2));
+}
+
+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 (absoluteCurrent.startsWith(ws.path)) {
+            return ws;
+        }
+    }
+    return null;
+}
+
+function listWorkspaces() {
+    return loadWorkspaces();
+}
+
+module.exports = {
+    addWorkspace,
+    removeWorkspace,
+    getWorkspaceByPath,
+    listWorkspaces
+};

package/src/Plugins/mcp_manager.js

@@ -0,0 +1,95 @@
+const { spawn } = require('child_process');
+const { readConfig } = require('../System/config_manager');
+
+/**
+ * McpManager handles the lifecycle of multiple MCP servers.
+ * Since MCP SDK is ESM and this project is CommonJS, we use dynamic imports.
+ */
+class McpManager {
+    constructor() {
+        this.clients = new Map(); // serverName -> { client, transport }
+        this.tools = [];
+    }
+
+    async init() {
+        const config = readConfig();
+        const mcpServers = config.mcpServers || {};
+
+        console.log(`[MCP] Initializing ${Object.keys(mcpServers).length} servers...`);
+
+        // Load SDK via dynamic import
+        const { Client } = await import('@modelcontextprotocol/sdk/client/index.js');
+        const { StdioClientTransport } = await import('@modelcontextprotocol/sdk/client/stdio.js');
+
+        for (const [name, serverConfig] of Object.entries(mcpServers)) {
+            try {
+                console.log(`[MCP] Connecting to server: ${name}`);
+                
+                const transport = new StdioClientTransport({
+                    command: serverConfig.command,
+                    args: serverConfig.args,
+                    env: { ...process.env, ...serverConfig.env }
+                });
+
+                const client = new Client(
+                    { name: 'mint-ai-assistant', version: '1.2.4' },
+                    { capabilities: {} }
+                );
+
+                await client.connect(transport);
+                
+                // Discover tools
+                const toolsResponse = await client.listTools();
+                const serverTools = (toolsResponse.tools || []).map(t => ({
+                    ...t,
+                    serverName: name
+                }));
+
+                this.clients.set(name, { client, transport, tools: serverTools });
+                this.tools.push(...serverTools);
+
+                console.log(`[MCP] Server ${name} connected. Found ${serverTools.length} tools.`);
+            } catch (err) {
+                console.error(`[MCP] Failed to connect to server ${name}:`, err.message);
+            }
+        }
+    }
+
+    getAllTools() {
+        return this.tools;
+    }
+
+    async callTool(serverName, toolName, args) {
+        const server = this.clients.get(serverName);
+        if (!server) throw new Error(`MCP Server "${serverName}" not found or not connected.`);
+
+        try {
+            console.log(`[MCP] Calling tool ${toolName} on server ${serverName}...`);
+            const result = await server.client.callTool({
+                name: toolName,
+                arguments: args
+            });
+            return result;
+        } catch (err) {
+            console.error(`[MCP] Error calling tool ${toolName}:`, err);
+            throw err;
+        }
+    }
+
+    async shutdown() {
+        console.log('[MCP] Shutting down all servers...');
+        for (const [name, server] of this.clients.entries()) {
+            try {
+                await server.client.close();
+                console.log(`[MCP] Server ${name} closed.`);
+            } catch (err) {
+                console.error(`[MCP] Error closing server ${name}:`, err.message);
+            }
+        }
+        this.clients.clear();
+        this.tools = [];
+    }
+}
+
+const instance = new McpManager();
+module.exports = instance;

package/src/Plugins/plugin_manager.js

@@ -16,8 +16,8 @@ class PluginManager {
 
             const files = fs.readdirSync(this.pluginsDir);
             for (const file of files) {
-                // Ignore self and non-JS files
-                if (file === 'plugin_manager.js' || !file.endsWith('.js')) continue;
+                // Ignore self and core system managers
+                if (file === 'plugin_manager.js' || file === 'mcp_manager.js' || !file.endsWith('.js')) continue;
 
                 const pluginPath = path.join(this.pluginsDir, file);
                 

package/src/Plugins/spotify.js

@@ -1,45 +1,173 @@
-const { exec } = require('child_process');
+/**
+ * Mint Spotify Plugin — Complete Edition
+ * ----------------------------------------
+ * Controls Spotify playback via playerctl (no OAuth required).
+ * Supports: play, pause, next, previous, stop, shuffle, volume,
+ *           now_playing, search (opens Spotify search URL).
+ *
+ * Requirements: playerctl installed (sudo apt install playerctl)
+ * Spotify must be running (Desktop app or Snap).
+ */
+
+const { exec, execSync } = require('child_process');
+const { promisify } = require('util');
+const execAsync = promisify(exec);
+
+// ── Helpers ────────────────────────────────────────────────────────────────
+
+async function runPlayerctl(args) {
+    try {
+        const { stdout } = await execAsync(`playerctl -p spotify ${args}`);
+        return { ok: true, output: stdout.trim() };
+    } catch (err) {
+        const msg = (err.stderr || err.message || '').toLowerCase();
+        if (msg.includes('no players found') || msg.includes('could not find player')) {
+            return { ok: false, error: 'spotify_not_running' };
+        }
+        if (err.code === 127) {
+            return { ok: false, error: 'playerctl_missing' };
+        }
+        return { ok: false, error: err.message };
+    }
+}
+
+function formatError(errorCode) {
+    if (errorCode === 'spotify_not_running') {
+        return '🎵 Spotify ยังไม่ได้เปิดอยู่นะคะ กรุณาเปิด Spotify ก่อนนะคะ';
+    }
+    if (errorCode === 'playerctl_missing') {
+        return '⚠️ ไม่พบ playerctl กรุณาติดตั้งด้วยคำสั่ง: sudo apt install playerctl';
+    }
+    return `❌ เกิดข้อผิดพลาด: ${errorCode}`;
+}
+
+// ── Action Handlers ────────────────────────────────────────────────────────
+
+const ACTION_MAP = {
+    'play':     () => runPlayerctl('play'),
+    'pause':    () => runPlayerctl('pause'),
+    'stop':     () => runPlayerctl('stop'),
+    'next':     () => runPlayerctl('next'),
+    'previous': () => runPlayerctl('previous'),
+    'prev':     () => runPlayerctl('previous'),
+};
+
+const ACTION_MESSAGES = {
+    'play':     '▶️ เล่น Spotify แล้วค่ะ 🎵',
+    'pause':    '⏸️ หยุดเพลงชั่วคราวแล้วค่ะ',
+    'stop':     '⏹️ หยุด Spotify แล้วค่ะ',
+    'next':     '⏭️ ข้ามไปเพลงถัดไปแล้วค่ะ 🎵',
+    'previous': '⏮️ กลับไปเพลงก่อนหน้าแล้วค่ะ',
+    'prev':     '⏮️ กลับไปเพลงก่อนหน้าแล้วค่ะ',
+};
+
+async function getNowPlaying() {
+    const [title, artist, album, status] = await Promise.all([
+        runPlayerctl('metadata title'),
+        runPlayerctl('metadata artist'),
+        runPlayerctl('metadata album'),
+        runPlayerctl('status'),
+    ]);
+
+    if (!title.ok) return formatError(title.error);
+
+    const statusIcon = (status.output || '').toLowerCase() === 'playing' ? '▶️' : '⏸️';
+    const titleText  = title.output  || 'ไม่ทราบชื่อเพลง';
+    const artistText = artist.output || 'ไม่ทราบศิลปิน';
+    const albumText  = album.output  || '';
+
+    let reply = `${statusIcon} กำลังเล่น: **${titleText}**\n`;
+    reply += `🎤 ศิลปิน: ${artistText}`;
+    if (albumText) reply += `\n💿 อัลบั้ม: ${albumText}`;
+    return reply;
+}
+
+async function setVolume(levelStr) {
+    const level = parseInt(levelStr, 10);
+    if (isNaN(level) || level < 0 || level > 100) {
+        return '⚠️ กรุณาระบุระดับเสียง 0-100 ค่ะ เช่น "volume 70"';
+    }
+    // playerctl volume uses 0.0–1.0
+    const result = await runPlayerctl(`volume ${(level / 100).toFixed(2)}`);
+    if (!result.ok) return formatError(result.error);
+    return `🔊 ปรับเสียงเป็น ${level}% แล้วค่ะ`;
+}
+
+async function setShuffle(state) {
+    // state: 'on' | 'off' | 'toggle'
+    const shuffleState = state === 'on' ? 'On' : state === 'off' ? 'Off' : 'Toggle';
+    const result = await runPlayerctl(`shuffle ${shuffleState}`);
+    if (!result.ok) return formatError(result.error);
+    if (state === 'toggle') return '🔀 สลับโหมด Shuffle แล้วค่ะ';
+    return `🔀 Shuffle ${state === 'on' ? 'เปิด' : 'ปิด'}แล้วค่ะ`;
+}
+
+function searchSpotify(query) {
+    if (!query || !query.trim()) {
+        return '⚠️ กรุณาระบุคำที่ต้องการค้นหาด้วยนะคะ เช่น "search BTS"';
+    }
+    const encoded = encodeURIComponent(query.trim());
+    const url = `https://open.spotify.com/search/${encoded}`;
+    try {
+        const { exec: execSync2 } = require('child_process');
+        execSync2(`xdg-open "${url}"`, { detached: true, stdio: 'ignore' });
+        return `🔍 เปิดค้นหา "${query}" ใน Spotify แล้วค่ะ 🎵`;
+    } catch (_) {
+        return `🔍 ค้นหา "${query}" ที่: ${url}`;
+    }
+}
+
+// ── Main Plugin Export ─────────────────────────────────────────────────────
 
 module.exports = {
     name: 'spotify',
-    description: 'Controls Spotify playback (play, pause, next, previous). Only works if Spotify is running. Valid targets are: "play", "pause", "next", "previous".',
-    
+    description: [
+        'Controls Spotify playback and gets now-playing info.',
+        'Valid targets:',
+        '  "play" | "pause" | "stop" | "next" | "previous" — playback control',
+        '  "now_playing" or "status" — get current song info',
+        '  "volume <0-100>" — set volume level (e.g. "volume 70")',
+        '  "shuffle on" | "shuffle off" | "shuffle toggle" — toggle shuffle',
+        '  "search <query>" — search Spotify (e.g. "search BTS Dynamite")',
+    ].join(' '),
+
     async execute(target) {
-        return new Promise((resolve) => {
-            const commandMap = {
-                'play': 'playerctl -p spotify play',
-                'pause': 'playerctl -p spotify pause',
-                'next': 'playerctl -p spotify next',
-                'previous': 'playerctl -p spotify previous'
-            };
-
-            const cmd = commandMap[target.toLowerCase()];
-
-            if (!cmd) {
-                return resolve(`Invalid spotify command: ${target}`);
-            }
-
-            exec(cmd, (error) => {
-                if (error) {
-                    // Check if playerctl is missing or Spotify isn't running
-                    if (error.message.includes('No players found')) {
-                        return resolve('Spotify is not currently running or playing anything.');
-                    }
-                    if (error.code === 127) {
-                        return resolve('Error: "playerctl" is not installed on this system. Please install it (e.g., sudo apt install playerctl).');
-                    }
-                    return resolve(`Failed to execute Spotify command: ${error.message}`);
-                }
-
-                const actionText = {
-                    'play': 'Playing Spotify.',
-                    'pause': 'Paused Spotify.',
-                    'next': 'Skipped to the next song.',
-                    'previous': 'Went back to the previous song.'
-                };
-
-                resolve(actionText[target.toLowerCase()]);
-            });
-        });
-    }
+        const raw = (target || '').trim().toLowerCase();
+
+        // ── Basic playback commands ───────────────────────────────────────
+        if (ACTION_MAP[raw]) {
+            const result = await ACTION_MAP[raw]();
+            if (!result.ok) return formatError(result.error);
+            return ACTION_MESSAGES[raw];
+        }
+
+        // ── Now Playing ───────────────────────────────────────────────────
+        if (raw === 'now_playing' || raw === 'status' || raw === 'what\'s playing' || raw === 'current') {
+            return await getNowPlaying();
+        }
+
+        // ── Volume ────────────────────────────────────────────────────────
+        if (raw.startsWith('volume')) {
+            const levelStr = raw.replace('volume', '').trim();
+            return await setVolume(levelStr);
+        }
+
+        // ── Shuffle ───────────────────────────────────────────────────────
+        if (raw.startsWith('shuffle')) {
+            const state = raw.replace('shuffle', '').trim() || 'toggle';
+            return await setShuffle(state);
+        }
+
+        // ── Search ────────────────────────────────────────────────────────
+        if (raw.startsWith('search')) {
+            const query = target.replace(/^search\s*/i, '').trim();
+            return searchSpotify(query);
+        }
+
+        // ── Fallback: try as playerctl arg directly ───────────────────────
+        return `⚠️ ไม่รู้จักคำสั่ง Spotify: "${target}"\nคำสั่งที่รองรับ: play, pause, stop, next, previous, now_playing, volume <0-100>, shuffle on/off, search <query>`;
+    },
+
+    // Expose helpers for testing
+    _helpers: { runPlayerctl, getNowPlaying, setVolume, setShuffle, searchSpotify }
 };

package/src/Plugins/system_monitor.js

@@ -0,0 +1,72 @@
+/**
+ * Mint System Monitor Plugin
+ * --------------------------
+ * Provides real-time system statistics for the host machine.
+ * Uses standard Linux commands (uptime, free, df) for lightweight monitoring.
+ */
+
+const { exec } = require('child_process');
+const { promisify } = require('util');
+const execAsync = promisify(exec);
+const os = require('os');
+
+async function getStats() {
+    try {
+        const [uptime, free, df] = await Promise.all([
+            execAsync('uptime -p'),
+            execAsync('free -h'),
+            execAsync('df -h / --output=pcent,avail')
+        ]);
+
+        // Parse Memory
+        const memLines = free.stdout.split('\n');
+        const memLine = memLines.find(l => l.startsWith('Mem:')) || '';
+        const memParts = memLine.split(/\s+/).filter(Boolean);
+        const memUsed = memParts[2] || 'Unknown';
+        const memTotal = memParts[1] || 'Unknown';
+
+        // Parse Disk
+        const diskLines = df.stdout.trim().split('\n');
+        const diskLine = diskLines[1] || '';
+        const [diskPercent, diskAvail] = diskLine.trim().split(/\s+/);
+
+        const cpuLoad = os.loadavg()[0].toFixed(2);
+        const cpuCores = os.cpus().length;
+
+        let report = `📊 **System Health Report**\n`;
+        report += `⏱️ **Uptime:** ${uptime.stdout.trim()}\n`;
+        report += `💻 **CPU Load:** ${cpuLoad} (on ${cpuCores} cores)\n`;
+        report += `🧠 **Memory:** ${memUsed} / ${memTotal} used\n`;
+        report += `💽 **Disk (/):** ${diskAvail} available (${diskPercent} full)`;
+
+        return report;
+    } catch (err) {
+        return `❌ Error fetching system stats: ${err.message}`;
+    }
+}
+
+module.exports = {
+    name: 'system_monitor',
+    description: 'Provides system statistics like CPU load, memory usage, disk space, and uptime. Target can be "stats", "cpu", "memory", or "disk".',
+
+    async execute(target) {
+        const cmd = (target || 'stats').toLowerCase().trim();
+        
+        switch (cmd) {
+            case 'stats':
+            case 'health':
+                return await getStats();
+            case 'cpu':
+                return `💻 **CPU Load (1m):** ${os.loadavg()[0].toFixed(2)}\nCores: ${os.cpus().length}\nModel: ${os.cpus()[0].model}`;
+            case 'memory':
+            case 'ram':
+                const { stdout: mem } = await execAsync('free -h');
+                return `🧠 **Memory Status:**\n\`\`\`\n${mem}\`\`\``;
+            case 'disk':
+                const { stdout: disk } = await execAsync('df -h /');
+                return `💽 **Disk Status:**\n\`\`\`\n${disk}\`\`\``;
+            default:
+                return await getStats();
+        }
+    }
+};

package/src/System/config_manager.js

@@ -10,14 +10,27 @@ try {
     app = null;
 }
 
-const MINT_DIR = path.join(os.homedir(), '.mint');
-if (!fs.existsSync(MINT_DIR)) {
-    fs.mkdirSync(MINT_DIR, { recursive: true });
+const CONFIG_DIR = path.join(os.homedir(), '.config', 'mint');
+const LEGACY_DIR = path.join(os.homedir(), '.mint');
+
+if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+}
+
+// Migration: If old .mint exists but new .config/mint is empty, move files
+if (fs.existsSync(LEGACY_DIR) && fs.readdirSync(CONFIG_DIR).length === 0) {
+    try {
+        const files = fs.readdirSync(LEGACY_DIR);
+        for (const file of files) {
+            fs.copyFileSync(path.join(LEGACY_DIR, file), path.join(CONFIG_DIR, file));
+        }
+        console.log('[Config] Migrated settings from ~/.mint to ~/.config/mint');
+    } catch (e) {
+        console.error('[Config] Migration failed:', e);
+    }
 }
 
-const CONFIG_PATH = app && app.getPath
-    ? path.join(app.getPath('userData'), 'mint-config.json')
-    : path.join(MINT_DIR, 'mint-config.json');
+const CONFIG_PATH = path.join(CONFIG_DIR, 'mint-config.json');
 
 const DEFAULT_CONFIG = {
     theme: 'dark',
@@ -43,9 +56,22 @@ const DEFAULT_CONFIG = {
     pluginSpotifyEnabled: true,
     pluginCalendarEnabled: false,
     pluginDiscordEnabled: false,
-    showDesktopWidget: true
+    showDesktopWidget: true,
+    mcpServers: {},
+    anthropicApiKey: '',
+    openaiApiKey: '',
+    hfApiKey: '',
+    anthropicModel: 'claude-3-5-sonnet-latest',
+    openaiModel: 'gpt-4o',
+    hfModel: 'meta-llama/Meta-Llama-3-8B-Instruct',
+    localApiBaseUrl: 'http://localhost:1234/v1',
+    localModelName: 'local-model',
+    ollamaHost: 'http://localhost:11434',
+    enableAgentCollaboration: true
 };
 
+
+
 function readConfig() {
     try {
         if (!fs.existsSync(CONFIG_PATH)) {
@@ -70,4 +96,31 @@ function writeConfig(config) {
     }
 }
 
-module.exports = { readConfig, writeConfig, CONFIG_PATH };
+function getAvailableProviders(config) {
+    const providers = [];
+    const cfg = config || readConfig();
+    
+    const isPlaceholder = (val) => !val || val.startsWith('your_') || val.includes('key_here') || val.trim() === '';
+
+    // Check which providers have API keys or URLs configured
+    const anthropicKey = cfg.anthropicApiKey || process.env.ANTHROPIC_API_KEY;
+    if (!isPlaceholder(anthropicKey)) providers.push('anthropic');
+
+    const openaiKey = cfg.openaiApiKey || process.env.OPENAI_API_KEY;
+    if (!isPlaceholder(openaiKey)) providers.push('openai');
+
+    const geminiKey = cfg.apiKey || process.env.GEMINI_API_KEY;
+    if (!isPlaceholder(geminiKey)) providers.push('gemini');
+
+    const hfKey = cfg.hfApiKey || process.env.HF_API_KEY;
+    if (!isPlaceholder(hfKey)) providers.push('huggingface');
+
+    if (cfg.localApiBaseUrl && cfg.localApiBaseUrl.trim() !== '') providers.push('local_openai');
+    
+    // Always push ollama at the end since it's local
+    providers.push('ollama');
+
+    return providers;
+}
+
+module.exports = { readConfig, writeConfig, getAvailableProviders, CONFIG_PATH };