@pheem49/mint 1.2.1

package/src/CLI/onboarding.js

@@ -0,0 +1,60 @@
+const fs = require('fs');
+const path = require('path');
+const { readConfig, writeConfig } = require('../System/config_manager');
+const { installDaemon } = require('../System/daemon_manager');
+
+/**
+ * Onboarding Wizard for Mint CLI
+ */
+async function runOnboarding(options = {}) {
+    // Dynamic import for ESM-only inquirer in CommonJS
+    const inquirer = (await import('inquirer')).default;
+    
+    console.log('\nWelcome to Mint Onboarding! Let\'s get you set up.\n');
+
+    const config = readConfig();
+
+    const questions = [
+        {
+            type: 'input',
+            name: 'apiKey',
+            message: 'Please enter your Google Gemini API Key:',
+            default: config.apiKey || undefined,
+            validate: (input) => input.length > 0 ? true : 'API Key is required.'
+        },
+        {
+            type: 'list',
+            name: 'geminiModel',
+            message: 'Select the Gemini model to use:',
+            choices: [
+                'gemini-2.5-flash',
+                'gemini-3.1-flash-lite-preview',
+                'gemini-3.1-flash-lite',
+                'gemini-2.0-pro-exp-02-05'
+            ],
+            default: config.geminiModel || 'gemini-2.5-flash'
+        }
+    ];
+
+    const answers = await inquirer.prompt(questions);
+
+    // Save configuration
+    const newConfig = { ...config, ...answers };
+    writeConfig(newConfig);
+    console.log('\n✅ Configuration saved successfully!');
+
+    // Install Daemon if requested
+    if (options.installDaemon) {
+        console.log('\n🚀 Installing Mint Background Agent (Daemon)...');
+        try {
+            const result = await installDaemon();
+            console.log(`✅ ${result}`);
+        } catch (err) {
+            console.error(`❌ Failed to install daemon: ${err.message}`);
+        }
+    }
+
+    console.log('\nAll set! You can now use "mint chat" to start talking to me.\n');
+}
+
+module.exports = { runOnboarding };

package/src/Command_Parser/parser.js

@@ -0,0 +1,34 @@
+function parseCommand(aiResponse) {
+    let action = { type: 'none', target: '' };
+    let responseText = '';
+
+    if (typeof aiResponse === 'string') {
+        // Attempt to parse string to JSON
+        try {
+            const parsed = JSON.parse(aiResponse);
+            action = parsed.action || action;
+            responseText = parsed.response || '';
+        } catch (e) {
+            // Fallback for markdown
+            const jsonMatch = aiResponse.match(/```json\n([\s\S]*?)\n```/) || aiResponse.match(/\{[\s\S]*\}/);
+            if (jsonMatch) {
+                try {
+                    const parsed = JSON.parse(jsonMatch[jsonMatch.length > 1 ? 1 : 0]);
+                    action = parsed.action || action;
+                    responseText = parsed.response || '';
+                } catch (err) {
+                    responseText = aiResponse;
+                }
+            } else {
+                responseText = aiResponse;
+            }
+        }
+    } else if (typeof aiResponse === 'object') {
+        action = aiResponse.action || action;
+        responseText = aiResponse.response || '';
+    }
+
+    return { response: responseText, action };
+}
+
+module.exports = { parseCommand };

package/src/Plugins/dev_tools.js

@@ -0,0 +1,41 @@
+const { exec } = require('child_process');
+
+function execPromise(command, cwd) {
+    return new Promise((resolve) => {
+        exec(command, { cwd }, (error, stdout, stderr) => {
+            if (error) {
+                resolve(`Error: ${stderr || error.message}`);
+                return;
+            }
+            resolve(stdout.trim());
+        });
+    });
+}
+
+module.exports = {
+    name: 'dev_tools',
+    description: 'Get git status, recent commits, or branch information for a project. Instruction MUST be "git status", "git log", or "git branch".',
+    
+    async execute(instruction) {
+        let cwd = process.cwd();
+        let cmd = (instruction || '').toLowerCase();
+        
+        let gitCmd = '';
+        if (cmd.includes('status')) {
+            gitCmd = 'git status -s';
+        } else if (cmd.includes('log') || cmd.includes('commit')) {
+            gitCmd = 'git log -n 5 --oneline';
+        } else if (cmd.includes('branch')) {
+            gitCmd = 'git branch';
+        } else {
+            return "ไม่เข้าใจคำสั่ง git ค่ะ ระบุเป็น status, log, หรือ branch นะคะ (ตัวอย่าง: git status)";
+        }
+
+        const output = await execPromise(gitCmd, cwd);
+        if (!output || output.startsWith('Error:')) {
+            return `ไม่สามารถดึงข้อมูล Git ได้ค่ะ: ${output}`;
+        }
+
+        return `ผลลัพธ์จาก Git:\n${output}`;
+    }
+};

package/src/Plugins/discord.js

@@ -0,0 +1,20 @@
+module.exports = {
+    name: 'discord',
+    description: 'Interacts with Discord. Valid targets are "mute", "unmute", "deafen", "undeafen". (Note: This is currently a placeholder plugin)',
+    
+    async execute(target) {
+        return new Promise((resolve) => {
+            console.log(`[Discord Plugin] Received command: ${target}`);
+            
+            // In a real implementation, you might use Discord RPC or xdotool
+            // For now, it just simulates success.
+            const validTargets = ['mute', 'unmute', 'deafen', 'undeafen'];
+            
+            if (!validTargets.includes(target.toLowerCase())) {
+                return resolve(`Invalid discord command: ${target}`);
+            }
+
+            resolve(`Simulated Discord command: ${target}`);
+        });
+    }
+};

package/src/Plugins/docker.js

@@ -0,0 +1,45 @@
+const { exec } = require('child_process');
+
+module.exports = {
+    name: 'docker',
+    description: 'Interacts with local Docker engine. Valid targets include: "start <container>", "stop <container>", "restart <container>", "list".',
+    
+    async execute(target) {
+        return new Promise((resolve) => {
+            console.log(`[Docker Plugin] Executing command: ${target}`);
+            
+            const [action, ...args] = target.toLowerCase().split(' ');
+            const containerName = args.join(' ');
+
+            let cmd = '';
+            
+            if (action === 'list') {
+                cmd = 'docker ps --format "{{.Names}} ({{.Status}})"';
+            } else if (['start', 'stop', 'restart'].includes(action) && containerName) {
+                cmd = `docker ${action} ${containerName}`;
+            } else {
+                return resolve(`Invalid docker command or missing container name: ${target}`);
+            }
+
+            exec(cmd, (error, stdout, stderr) => {
+                if (error) {
+                    if (error.code === 127 || stderr.includes('not found')) {
+                        return resolve('Error: Docker is not installed or not in PATH.');
+                    }
+                    if (stderr.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}`);
+                }
+
+                if (action === 'list') {
+                    const containers = stdout.trim();
+                    if (!containers) return resolve("No running Docker containers found.");
+                    return resolve(`Running Containers:\n${containers}`);
+                }
+
+                resolve(`Successfully executed "docker ${action}" on container "${containerName}".`);
+            });
+        });
+    }
+};

package/src/Plugins/google_calendar.js

@@ -0,0 +1,26 @@
+const { shell } = require('electron');
+
+module.exports = {
+    name: 'google_calendar',
+    description: 'Quickly open Google Calendar to add a new event or view the calendar. Instruction should be the event title (e.g., "Meeting with team"). If no title, just put "open".',
+    
+    async execute(instruction) {
+        const inst = (instruction || '').trim();
+        
+        if (!inst || inst.toLowerCase() === 'open') {
+            shell.openExternal('https://calendar.google.com/');
+            return 'กำลังเปิดหน้าต่างปฏิทินให้ค่ะ 📅';
+        }
+        
+        // Encode the event title for the URL
+        const title = encodeURIComponent(inst);
+        const url = `https://calendar.google.com/calendar/r/eventedit?text=${title}`;
+        
+        try {
+            shell.openExternal(url);
+            return `กำลังเปิดหน้าต่างสร้างกิจกรรม "${inst}" ใน Google Calendar ให้ลูกพี่ค่ะ 📅✨`;
+        } catch (e) {
+            return `เกิดข้อผิดพลาดในการเปิด Calendar ค่ะ: ${e.message}`;
+        }
+    }
+};

package/src/Plugins/obsidian.js

@@ -0,0 +1,54 @@
+const fs = require('fs');
+const path = require('path');
+
+function getNotesDir() {
+    let base = process.env.HOME || process.env.USERPROFILE || process.cwd();
+    // Default to Documents/Mint_Notes
+    const dir = path.join(base, 'Documents', 'Mint_Notes');
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    return dir;
+}
+
+module.exports = {
+    name: 'obsidian',
+    description: 'Manage local Markdown notes (like Obsidian/Notion). Instruction MUST be one of: "list", "read: [filename]", "write: [filename] | [content]".',
+    
+    async execute(instruction) {
+        const dir = getNotesDir();
+        
+        if (instruction.startsWith('list')) {
+            const files = fs.readdirSync(dir).filter(f => f.endsWith('.md'));
+            if (files.length === 0) return "ยังไม่มีโน้ตอยู่ในระบบค่ะ 📝";
+            return `รายการโน้ตทั้งหมด:\n${files.join('\n')}`;
+        }
+        
+        if (instruction.startsWith('read:')) {
+            let filename = instruction.replace('read:', '').trim();
+            if (!filename.endsWith('.md')) filename += '.md';
+            const filepath = path.join(dir, filename);
+            if (fs.existsSync(filepath)) {
+                return `เนื้อหาของโน้ต ${filename}:\n\n${fs.readFileSync(filepath, 'utf8')}`;
+            }
+            return `ไม่พบโน้ตชื่อ ${filename} ค่ะ ❌`;
+        }
+        
+        if (instruction.startsWith('write:')) {
+            const parts = instruction.replace('write:', '').split('|');
+            if (parts.length < 2) return "รูปแบบคำสั่งไม่ถูกต้องค่ะ ต้องเป็น write: filename | content";
+            let filename = parts[0].trim();
+            const content = parts.slice(1).join('|').trim();
+            
+            if (!filename.endsWith('.md')) filename += '.md';
+            const filepath = path.join(dir, filename);
+            
+            // Log timestamp
+            const timestamp = new Date().toLocaleString('th-TH');
+            const entry = `\n---บันทึกเมื่อ ${timestamp}---\n${content}\n`;
+            
+            fs.appendFileSync(filepath, entry);
+            return `บันทึกข้อความลงในโน้ต ${filename} เรียบร้อยแล้วค่ะ ✅`;
+        }
+        
+        return "คำสั่งโน้ตไม่ถูกต้องค่ะ ลองใช้ 'list', 'read: ชื่อไฟล์', หรือ 'write: ชื่อไฟล์ | เนื้อหา' นะคะ";
+    }
+};

package/src/Plugins/plugin_manager.js

@@ -0,0 +1,81 @@
+const fs = require('fs');
+const path = require('path');
+
+class PluginManager {
+    constructor() {
+        this.plugins = new Map();
+        this.pluginsDir = path.join(__dirname);
+    }
+
+    // Load or reload plugins
+    loadPlugins() {
+        this.plugins.clear();
+        
+        try {
+            if (!fs.existsSync(this.pluginsDir)) return;
+
+            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;
+
+                const pluginPath = path.join(this.pluginsDir, file);
+                
+                // Clear require cache for hot-reloading
+                delete require.cache[require.resolve(pluginPath)];
+                
+                try {
+                    const plugin = require(pluginPath);
+                    if (this.validatePlugin(plugin)) {
+                        this.plugins.set(plugin.name, plugin);
+                        console.log(`[PluginManager] Loaded: ${plugin.name}`);
+                    } else {
+                        console.warn(`[PluginManager] Invalid plugin format: ${file}`);
+                    }
+                } catch (err) {
+                    console.error(`[PluginManager] Error loading plugin ${file}:`, err);
+                }
+            }
+        } catch (err) {
+            console.error('[PluginManager] Error accessing plugin directory:', err);
+        }
+    }
+
+    validatePlugin(plugin) {
+        return plugin 
+            && typeof plugin.name === 'string' 
+            && typeof plugin.description === 'string' 
+            && typeof plugin.execute === 'function';
+    }
+
+    // Returns formatted descriptions for the Gemini prompt
+    getPromptDescriptions() {
+        if (this.plugins.size === 0) return '';
+        
+        let descriptions = '\nPlugin Actions Available:\n';
+        for (const [name, plugin] of this.plugins.entries()) {
+            descriptions += `- Plugin: "${name}" | Description: ${plugin.description}\n`;
+        }
+        return descriptions;
+    }
+
+    // Execute a plugin's action
+    async executePlugin(name, instruction) {
+        const plugin = this.plugins.get(name);
+        if (!plugin) {
+            return `Plugin "${name}" not found.`;
+        }
+
+        try {
+            console.log(`[PluginManager] Executing ${name} with instruction: "${instruction}"`);
+            return await plugin.execute(instruction);
+        } catch (err) {
+            console.error(`[PluginManager] Error executing plugin ${name}:`, err);
+            return `Error executing plugin ${name}: ${err.message}`;
+        }
+    }
+}
+
+// Export a singleton instance
+const pluginManager = new PluginManager();
+module.exports = pluginManager;

package/src/Plugins/spotify.js

@@ -0,0 +1,45 @@
+const { exec } = require('child_process');
+
+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".',
+    
+    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()]);
+            });
+        });
+    }
+};

package/src/Plugins/system_metrics.js

@@ -0,0 +1,31 @@
+const os = require('os');
+const { getSystemInfo } = require('../System/system_info');
+
+/**
+ * System Metrics Plugin — Provides real-time hardware stats to Gemini
+ */
+module.exports = {
+    name: 'system_metrics',
+    description: 'Get real-time system metrics like CPU usage, RAM, and uptime. Instruction can be "all", "ram", "cpu", or "uptime".',
+    
+    async execute(instruction) {
+        const info = getSystemInfo();
+        const uptimeMin = Math.floor(os.uptime() / 60);
+        const uptimeHours = (uptimeMin / 60).toFixed(1);
+        
+        const inst = (instruction || 'all').toLowerCase();
+
+        if (inst.includes('ram')) {
+            return `ความจำเครื่อง (RAM): ใช้ไป ${info.ram.used} จากทั้งหมด ${info.ram.total} (${info.ram.percent})`;
+        } 
+        if (inst.includes('cpu')) {
+            return `หน่วยประมวลผล (CPU): ${info.cpu.model} มีทั้งหมด ${info.cpu.cores} คอร์`;
+        }
+        if (inst.includes('uptime')) {
+            return `เปิดเครื่องมาแล้ว: ${uptimeMin} นาที (${uptimeHours} ชั่วโมง)`;
+        }
+
+        // Default: Return basic summary in Thai for Mint's personality
+        return `สรุปสถานะระบบ: RAM ใช้ไป ${info.ram.percent}, CPU ${info.cpu.cores} Cores, เปิดเครื่องมาแล้ว ${uptimeMin} นาทีค่ะ ✨`;
+    }
+};

package/src/System/chat_history_manager.js

@@ -0,0 +1,57 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+let app;
+try {
+    const electron = require('electron');
+    app = electron.app;
+} catch (e) {
+    app = null;
+}
+
+const MINT_DIR = path.join(os.homedir(), '.mint');
+if (!fs.existsSync(MINT_DIR)) {
+    fs.mkdirSync(MINT_DIR, { recursive: true });
+}
+
+const CHAT_HISTORY_PATH = app && app.getPath 
+    ? path.join(app.getPath('userData'), 'mint-chat-history.json')
+    : path.join(MINT_DIR, 'mint-chat-history.json');
+
+function readChatHistory() {
+    try {
+        if (!fs.existsSync(CHAT_HISTORY_PATH)) {
+            return [];
+        }
+
+        const raw = fs.readFileSync(CHAT_HISTORY_PATH, 'utf-8');
+        const parsed = JSON.parse(raw);
+        return Array.isArray(parsed) ? parsed : [];
+    } catch (err) {
+        console.error('readChatHistory error:', err);
+        return [];
+    }
+}
+
+function writeChatHistory(history) {
+    try {
+        const safeHistory = Array.isArray(history) ? history : [];
+        fs.writeFileSync(CHAT_HISTORY_PATH, JSON.stringify(safeHistory, null, 2), 'utf-8');
+        return { success: true };
+    } catch (err) {
+        console.error('writeChatHistory error:', err);
+        return { success: false, message: err.message };
+    }
+}
+
+function clearChatHistory() {
+    return writeChatHistory([]);
+}
+
+module.exports = {
+    CHAT_HISTORY_PATH,
+    readChatHistory,
+    writeChatHistory,
+    clearChatHistory
+};

package/src/System/config_manager.js

@@ -0,0 +1,73 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+let app;
+try {
+    const electron = require('electron');
+    app = electron.app;
+} catch (e) {
+    app = null;
+}
+
+const MINT_DIR = path.join(os.homedir(), '.mint');
+if (!fs.existsSync(MINT_DIR)) {
+    fs.mkdirSync(MINT_DIR, { recursive: true });
+}
+
+const CONFIG_PATH = app && app.getPath
+    ? path.join(app.getPath('userData'), 'mint-config.json')
+    : path.join(MINT_DIR, 'mint-config.json');
+
+const DEFAULT_CONFIG = {
+    theme: 'dark',
+    accentColor: '#8b5cf6',
+    systemTextColor: '#f8fafc',
+    customBgStart: '#0f172a',
+    customBgEnd: '#1e1b4b',
+    customPanelBg: '#1e293b',
+    apiKey: '',
+    geminiModel: 'gemini-2.5-flash',
+    language: 'th-TH',
+    automationBrowser: 'chromium',
+    proactiveInterval: 60,   // seconds between screen captures
+    proactiveCooldown: 120,   // seconds minimum between actual suggestions
+    aiProvider: 'gemini',
+    ollamaModel: 'llama3:latest',
+    enableVoiceReply: true,
+    enableCustomWorkflows: true,
+    ttsProvider: 'google',
+    ttsVolume: 1.0,
+    ttsSpeed: 1.0,
+    ttsPitch: 1.0,
+    pluginSpotifyEnabled: true,
+    pluginCalendarEnabled: false,
+    pluginDiscordEnabled: false,
+    showDesktopWidget: true
+};
+
+function readConfig() {
+    try {
+        if (!fs.existsSync(CONFIG_PATH)) {
+            writeConfig(DEFAULT_CONFIG);
+            return DEFAULT_CONFIG;
+        }
+        const raw = fs.readFileSync(CONFIG_PATH, 'utf-8');
+        return { ...DEFAULT_CONFIG, ...JSON.parse(raw) };
+    } catch (err) {
+        console.error('readConfig error:', err);
+        return DEFAULT_CONFIG;
+    }
+}
+
+function writeConfig(config) {
+    try {
+        fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), 'utf-8');
+        return { success: true };
+    } catch (err) {
+        console.error('writeConfig error:', err);
+        return { success: false, message: err.message };
+    }
+}
+
+module.exports = { readConfig, writeConfig, CONFIG_PATH };