@pheem49/mint 1.2.1

package/mint-cli-logic.js

@@ -0,0 +1,71 @@
+// Mint CLI Action Logic
+const { openApp } = require('./src/Automation_Layer/open_app');
+const { openWebsite, openSearch } = require('./src/Automation_Layer/open_website');
+const { createFolder, openFile, deleteFile } = require('./src/Automation_Layer/file_operations');
+const { indexFile } = require('./src/AI_Brain/knowledge_base');
+const SystemAutomation = require('./src/System/system_automation');
+const pluginManager = require('./src/Plugins/plugin_manager');
+
+async function executeAction(action) {
+    if (!action || action.type === 'none') return null;
+
+    try {
+        switch (action.type) {
+            case 'open_url':
+                openWebsite(action.target);
+                return `Opened URL: ${action.target}`;
+            case 'search':
+                openSearch(action.target);
+                return `Searching for: ${action.target}`;
+            case 'open_app':
+                openApp(action.target);
+                return `Opening app: ${action.target}`;
+            case 'create_folder':
+                createFolder(action.target);
+                return `Created folder: ${action.target}`;
+            case 'open_file':
+                await openFile(action.target);
+                return `Opening: ${action.target}`;
+            case 'delete_file':
+                await deleteFile(action.target);
+                return `Deleted: ${action.target}`;
+            case 'learn_file':
+                return await indexFile(action.target);
+            case 'plugin':
+                return await pluginManager.executePlugin(action.pluginName, action.target);
+            case 'system_automation':
+                return await handleSystemAutomation(action.target);
+            default:
+                return `Action ${action.type} is not yet fully supported in CLI.`;
+        }
+    } catch (err) {
+        return `Error executing action: ${err.message}`;
+    }
+}
+
+async function handleSystemAutomation(target) {
+    const [cmd, value] = target.split(':');
+    switch (cmd) {
+        case 'volume':
+            return await SystemAutomation.setVolume(parseInt(value));
+        case 'mute':
+            return await SystemAutomation.mute();
+        case 'brightness':
+            return await SystemAutomation.setBrightness(parseInt(value));
+        case 'sleep':
+            return await SystemAutomation.sleep();
+        case 'restart':
+            return await SystemAutomation.restart();
+        case 'shutdown':
+            return await SystemAutomation.shutdown();
+        case 'minimize_all':
+            return await SystemAutomation.minimizeAll();
+        default:
+            if (SystemAutomation[target]) {
+                return await SystemAutomation[target]();
+            }
+            throw new Error(`Unknown system command: ${target}`);
+    }
+}
+
+module.exports = { executeAction };

package/mint-cli.js

@@ -0,0 +1,239 @@
+#!/usr/bin/env node
+require('dotenv').config();
+const { Command } = require('commander');
+const { handleChat, resetChat } = require('./src/AI_Brain/Gemini_API');
+const { runOnboarding } = require('./src/CLI/onboarding');
+const { startAgent } = require('./src/AI_Brain/headless_agent');
+const { displayFeatures } = require('./src/CLI/list_features');
+const { readConfig, writeConfig } = require('./src/System/config_manager');
+const readline = require('readline');
+const { createChatUI } = require('./src/CLI/chat_ui');
+
+// ANSI Colors
+const colors = {
+    reset: "\x1b[0m",
+    bright: "\x1b[1m",
+    mint: "\x1b[38;5;121m",
+    pink: "\x1b[38;5;213m",
+    gray: "\x1b[90m",
+    cyan: "\x1b[36m",
+    yellow: "\x1b[33m"
+};
+
+const program = new Command();
+
+program
+  .name('mint-ai')
+  .description('Mint - Your Personal AI Assistant CLI')
+  .version('1.0.0');
+
+// Chat Command (Interactive Mode)
+program
+  .command('chat', { isDefault: true })
+  .description('Start interactive chat session with Mint')
+  .argument('[message]', 'Initial message to send to Mint')
+  .action(async (message) => {
+    await startInteractiveChat(message);
+  });
+
+// Onboard Command
+program
+  .command('onboard')
+  .description('Setup Mint for the first time')
+  .option('--install-daemon', 'Automatically install systemd background agent')
+  .action(async (options) => {
+    await runOnboarding(options);
+  });
+
+// Agent Command (Headless Daemon Mode)
+program
+  .command('agent')
+  .description('Run Mint as a background agent (headless)')
+  .argument('[initialTask]', 'Optional first task to perform immediately on startup')
+  .action(async (initialTask) => {
+    if (initialTask) {
+        const taskManager = require('./src/System/task_manager');
+        taskManager.addTask(initialTask);
+        console.log(`\n${colors.mint}${colors.bright}[Mint-Agent] Starting with initial task:${colors.reset} "${initialTask}"`);
+    }
+    await startAgent();
+  });
+
+// List Command
+program
+  .command('list')
+  .description('Show list of Mint features and commands')
+  .action(() => {
+    displayFeatures();
+  });
+
+// Task Command (Autonomous Background Task)
+program
+  .command('task')
+  .description('Delegate a complex task to the background agent')
+  .argument('<description>', 'Description of the task for Mint to perform autonomously')
+  .action(async (description) => {
+    const taskManager = require('./src/System/task_manager');
+    const task = taskManager.addTask(description);
+    console.log(`\n${colors.mint}${colors.bright}Task Received!${colors.reset}`);
+    console.log(`${colors.gray}Task ID: ${task.id}${colors.reset}`);
+    console.log(`"${description}"`);
+    console.log(`\n${colors.cyan}Mint Agent is starting to work on this in the background.${colors.reset}`);
+    console.log(`${colors.gray}You will receive a notification when it's done.${colors.reset}\n`);
+  });
+
+program.parse(process.argv);
+
+/**
+ * The Interactive Chat Loop — Gemini-style TUI
+ */
+async function startInteractiveChat(initialMessage = null) {
+    const { screen, appendMessage, setThinking, updateStatusModel, copyLastResponse } = createChatUI({
+        onSubmit: async (text) => {
+            if (text.startsWith('/')) {
+                // Slash commands via fake rl-compatible object
+                const fakeRl = { close: () => {} };
+                appendMessage('user', text);
+                await handleSlashCommandUI(text, appendMessage, updateStatusModel, copyLastResponse);
+                return;
+            }
+            appendMessage('user', text);
+
+            // Start thinking timer
+            let seconds = 0;
+            setThinking(true, seconds);
+            const timer = setInterval(() => {
+                seconds++;
+                setThinking(true, seconds);
+            }, 1000);
+
+            try {
+                const response = await handleChat(text);
+                clearInterval(timer);
+                setThinking(false);
+                appendMessage('assistant', response.response);
+
+                // Execute Actions
+                const { executeAction } = require('./mint-cli-logic');
+                if (response.action && response.action.type !== 'none') {
+                    const result = await executeAction(response.action);
+                    if (result) appendMessage('system', `Action: ${result}`);
+                }
+            } catch (err) {
+                clearInterval(timer);
+                setThinking(false);
+                appendMessage('error', err.message);
+            }
+        },
+        onExit: () => {
+            screen.destroy();
+            console.log(`\n${colors.pink}Goodbye! See you again soon!${colors.reset}\n`);
+            process.exit(0);
+        }
+    });
+
+    // Handle initial message if passed via CLI arg
+    if (initialMessage) {
+        appendMessage('user', initialMessage);
+        let seconds = 0;
+        setThinking(true, seconds);
+        const timer = setInterval(() => { seconds++; setThinking(true, seconds); }, 1000);
+        try {
+            const response = await handleChat(initialMessage);
+            clearInterval(timer);
+            setThinking(false);
+            appendMessage('assistant', response.response);
+        } catch (err) {
+            clearInterval(timer);
+            setThinking(false);
+            appendMessage('error', err.message);
+        }
+    }
+}
+
+/**
+ * Handles slash commands within the TUI context
+ */
+async function handleSlashCommandUI(input, appendMessage, updateStatusModel, copyLastResponse) {
+    const parts = input.split(' ');
+    const command = parts[0].toLowerCase();
+    const args = parts.slice(1);
+
+    switch (command) {
+        case '/help':
+        case '/?':
+            appendMessage('system', [
+                'Mint Slash Commands:',
+                '  /models [name]  — List or switch Gemini models',
+                '  /config         — Show current configuration',
+                '  /copy           — Copy last response to clipboard',
+                '  /clear          — Clear conversation history',
+                '  /reset          — Reset conversation history',
+                '  /exit           — Exit Mint'
+            ].join('\n'));
+            break;
+
+        case '/models':
+            const config = readConfig();
+            if (args.length === 0) {
+                appendMessage('system', [
+                    `Current Model: ${config.geminiModel}`,
+                    'Available Presets:',
+                    '  - gemini-2.5-flash (Default)',
+                    '  - gemini-3.1-flash-lite-preview',
+                    '  - gemini-3.1-flash-lite',
+                    '  - ollama (local provider)',
+                    'Usage: /models <name> to switch'
+                ].join('\n'));
+            } else {
+                const { writeConfig } = require('./src/System/config_manager');
+                const newModel = args[0];
+                if (newModel === 'ollama') {
+                    config.aiProvider = 'ollama';
+                } else {
+                    config.aiProvider = 'gemini';
+                    config.geminiModel = newModel;
+                }
+                writeConfig(config);
+                appendMessage('system', `✅ Switched to: ${newModel}`);
+                if (updateStatusModel) updateStatusModel(newModel);
+            }
+            break;
+
+        case '/config':
+            const currentCfg = readConfig();
+            appendMessage('system', [
+                'Current Configuration:',
+                `  Provider  : ${currentCfg.aiProvider}`,
+                `  Model     : ${currentCfg.geminiModel}`,
+                `  Ollama    : ${currentCfg.ollamaModel}`,
+                `  Voice     : ${currentCfg.enableVoiceReply ? 'ON' : 'OFF'}`,
+                `  Language  : ${currentCfg.language}`,
+                `  API Key   : ${currentCfg.apiKey ? 'SET (****)' : 'NOT SET'}`
+            ].join('\n'));
+            break;
+
+        case '/copy':
+            if (copyLastResponse && copyLastResponse()) {
+                appendMessage('system', '✓ Last response copied to clipboard.');
+            } else {
+                appendMessage('system', '✖ Nothing to copy, or xclip/xsel not installed.');
+            }
+            break;
+
+        case '/clear':
+        case '/reset':
+            resetChat();
+            appendMessage('system', 'Conversation history cleared.');
+            break;
+
+        case '/exit':
+        case '/quit':
+            process.exit(0);
+            break;
+
+        default:
+            appendMessage('system', `Unknown command: ${command}. Type /help for options.`);
+    }
+}
+

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@pheem49/mint",
+  "version": "1.2.1",
+  "description": "A powerful Electron-based AI desktop assistant powered by Google Gemini, featuring screen vision, web automation, and proactive suggestions.",
+  "main": "main.js",
+  "scripts": {
+    "start": "electron .",
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build:linux": "electron-builder --linux",
+    "cli": "node mint-cli.js"
+  },
+  "bin": {
+    "mint": "mint-cli.js"
+  },
+  "keywords": [],
+  "author": {
+    "name": "Pheem49",
+    "email": "killerpheem13@gmail.com"
+  },
+  "license": "AGPL-3.0-only",
+  "type": "commonjs",
+  "dependencies": {
+    "@google/genai": "^1.44.0",
+    "@inkjs/ui": "^2.0.0",
+    "axios": "^1.13.6",
+    "blessed": "^0.1.81",
+    "cheerio": "^1.2.0",
+    "commander": "^14.0.3",
+    "dotenv": "^17.3.1",
+    "google-tts-api": "^2.0.2",
+    "ink": "^7.0.1",
+    "ink-text-input": "^6.0.0",
+    "inquirer": "^13.4.1",
+    "mammoth": "^1.12.0",
+    "pdf-parse": "^2.4.5",
+    "puppeteer": "^24.38.0",
+    "react": "^19.2.5",
+    "xlsx": "^0.18.5"
+  },
+  "devDependencies": {
+    "electron": "^40.7.0",
+    "electron-builder": "^26.8.1"
+  },
+  "build": {
+    "appId": "com.yourname.mint",
+    "productName": "Mint",
+    "files": [
+      "**/*",
+      "!node_modules/.cache/**"
+    ],
+    "linux": {
+      "icon": "assets/icon.png",
+      "target": [
+        "AppImage",
+        "deb"
+      ],
+      "category": "Utility"
+    }
+  }
+}

package/preload-picker.js

@@ -0,0 +1,11 @@
+const { contextBridge, ipcRenderer } = require('electron');
+
+contextBridge.exposeInMainWorld('electronPicker', {
+    onScreenshot: (callback) => ipcRenderer.on('screenshot-data', (_, data) => callback(data)),
+    sendSelection: (base64Image) => ipcRenderer.send('vision-selection', base64Image),
+    startContinuousTranslation: (rect) => ipcRenderer.send('vision-translate-start', rect),
+    stopContinuousTranslation: () => ipcRenderer.send('vision-translate-stop'),
+    onTranslationResult: (callback) => ipcRenderer.on('vision-translate-result', (_, text) => callback(text)),
+    closePicker: () => ipcRenderer.send('vision-cancel'),
+    setOverlayInteractable: (isInteractable) => ipcRenderer.send('vision-overlay-interactable', isInteractable)
+});

package/preload-settings.js

@@ -0,0 +1,11 @@
+const { contextBridge, ipcRenderer } = require('electron');
+
+contextBridge.exposeInMainWorld('settingsApi', {
+    getSettings: () => ipcRenderer.invoke('get-settings'),
+    saveSettings: (config) => ipcRenderer.invoke('save-settings', config),
+    closeSettings: () => ipcRenderer.send('close-settings'),
+    quitApp: () => ipcRenderer.send('quit-app'),
+    openExternal: (url) => ipcRenderer.invoke('open-external', url),
+    openCustomWorkflows: () => ipcRenderer.invoke('open-custom-workflows'),
+    reloadCustomWorkflows: () => ipcRenderer.invoke('reload-custom-workflows'),
+});

package/preload.js

@@ -0,0 +1,37 @@
+const { contextBridge, ipcRenderer } = require('electron');
+
+contextBridge.exposeInMainWorld('api', {
+    sendMessage: (message, base64Image, base64Audio) => ipcRenderer.invoke('chat-message', message, base64Image, base64Audio),
+    closeWindow: () => ipcRenderer.send('close-window'),
+    minimizeWindow: () => ipcRenderer.send('minimize-window'),
+    quitApp: () => ipcRenderer.send('quit-app'),
+    maximizeWindow: () => ipcRenderer.send('maximize-window'),
+    resetChat: () => ipcRenderer.invoke('reset-chat'),
+    getChatHistory: () => ipcRenderer.invoke('get-chat-history'),
+    openSettings: () => ipcRenderer.invoke('open-settings'),
+    // Clipboard
+    readClipboard: () => ipcRenderer.invoke('clipboard-read'),
+    writeClipboard: (text) => ipcRenderer.invoke('clipboard-write', text),
+    // System Info
+    getSystemInfo: () => ipcRenderer.invoke('get-system-info'),
+    getWeather: (city) => ipcRenderer.invoke('get-weather', city),
+    // Settings
+    getSettings: () => ipcRenderer.invoke('get-settings'),
+    // Listen for settings changes from other window
+    onSettingsChanged: (callback) => ipcRenderer.on('settings-changed', (event, data) => callback(data)),
+    // Vision
+    startVision: () => ipcRenderer.invoke('start-screen-capture'),
+    onVisionReady: (callback) => ipcRenderer.on('vision-ready', (event, data) => callback(data)),
+    captureSilentScreen: () => ipcRenderer.invoke('capture-silent-screen'),
+    // Proactive Assistant
+    onProactiveSuggestion: (callback) => ipcRenderer.on('proactive-suggestion', (event, data) => callback(data)),
+    onProactiveNotification: (callback) => ipcRenderer.on('proactive-notification', (event, data) => callback(data)),
+    toggleProactive: (isOn) => ipcRenderer.send('toggle-proactive', isOn),
+    recordBehavior: (context) => ipcRenderer.send('record-behavior', context),
+    executeProactiveAction: (action) => ipcRenderer.invoke('execute-proactive-action', action),
+    onSpotlightToChat: (callback) => ipcRenderer.on('spotlight-to-chat', (_event, query) => callback(query)),
+    notifyAiResponse: () => ipcRenderer.send('ai-notify'),
+    clearAiNotifications: () => ipcRenderer.send('ai-notify-clear'),
+    getTtsUrls: (text) => ipcRenderer.invoke('get-tts-urls', text),
+    setAiState: (state) => ipcRenderer.send('set-ai-state', state)
+});

package/privacy.txt

@@ -0,0 +1 @@
+DuckDuckGo is considered more private than Google because it does not store your search history, track your personal data, or build advertising profiles based on your activity. While Google uses user search data to create personalized profiles for targeted advertising, DuckDuckGo provides anonymous search results. Additionally, DuckDuckGo's browser and extensions offer features like third-party tracker blocking and automatic HTTPS upgrades to further enhance user anonymity and security.