@pheem49/mint 1.4.0 → 1.4.1

package/README.md

@@ -1,200 +1,244 @@
 # Mint
 
 <p align="center">
-  <img src="assets/icon.png" alt="Luna Mint Icon" width="160">
+  <img src="assets/icon.png" alt="Mint Icon" width="160">
 </p>
 
 <p align="center">
-  <strong>An advanced AI Assistant built for the modern workflow — now on Desktop & Terminal.</strong>
+  <strong>Desktop assistant + CLI coding agent built with Electron, Node.js, and modern LLM providers.</strong>
 </p>
 
 <p align="center">
   <img src="https://img.shields.io/badge/License-AGPL--3.0-blue?style=for-the-badge" alt="License">
   <img src="https://img.shields.io/badge/Node.js-LTS-green?style=for-the-badge&logo=node.js" alt="Node.js">
-  <img src="https://img.shields.io/badge/Electron-Latest-47848F?style=for-the-badge&logo=electron" alt="Electron">
-  <img src="https://img.shields.io/badge/Powered%20By-Gemini-orange?style=for-the-badge&logo=google-gemini" alt="Gemini">
+  <img src="https://img.shields.io/badge/Electron-40.x-47848F?style=for-the-badge&logo=electron" alt="Electron">
+  <img src="https://img.shields.io/badge/CLI-Agentic-orange?style=for-the-badge" alt="CLI Agentic">
 </p>
 
----
+Mint is an AI assistant that runs in two main surfaces:
 
-**Mint** is a powerful AI Assistant built with **Electron**, **Node.js**, and **Google Gemini** (with extended support for Hugging Face, Anthropic, OpenAI, and Local Models). It bridges the gap between your Desktop and Terminal, featuring real-time screen vision, web automation, local knowledge search, and a professional CLI for developers who love the command line.
+- A desktop Electron app for chat, screen-aware help, and system actions
+- A terminal-first CLI with a workspace-aware coding agent
 
-## Highlights
+The project is built around practical local workflows: inspect code, edit files, run safe commands with approval, use project context, and fall back across multiple AI providers when needed.
 
-- **Dual-Mode AI**: Switch between a beautiful **Desktop GUI** and a professional **CLI**.
-- **Code Agent Mode**: Use `mint code "<task>"` to inspect, edit, and verify a project directly from the current terminal workspace.
-- **Chat-First Workflow**: Regular Mint chat can now auto-route coding requests into workspace Code Mode, so the main chat acts as the control surface.
-- **Advanced Multi-Agent Hub**: 
-  - **Smart Routing**: Intelligently routes coding/general tasks to the most capable configured provider (e.g., Claude, OpenAI, Gemini).
-  - **Agent Collaboration**: Enable Multi-Agent Review so that a primary AI writes the code while a secondary AI automatically reviews it in the same loop.
-  - **Resilient Fallback**: Automatically fallbacks to alternative AI providers (Gemini, Anthropic, OpenAI, Hugging Face, LM Studio, Ollama) if your active provider fails.
-- **Visible Mode State**: The CLI status bar now shows whether Mint is currently in `Chat` or `Code` mode.
-- **Interactive Slash Commands**: Manage models and settings in the terminal with `/model`, `/config`, `/clear`, etc.
-- **Smart TUI Experience**: Professional message framing, character-wrapped Thai text support, and mouse scroll wheel navigation.
-- **System Information Action**: Retrieve OS, Kernel, and Architecture details via natural language.
-- **Dynamic UI Aesthetics**: Animated **Aura Glow** for the AI widget and **Glassmorphism** design.
-- **Minimize-to-Tray**: Keep Mint running in the background via the System Tray.
-- **Vision-Ready (Desktop)**: Capture, analyze, and translate any part of your screen in real-time.
-- **Automation First**: Control your system and browser via natural language from both App and Terminal.
-- **Background Agent**: Install Mint as a `systemd` user service for proactive monitoring.
+## What Mint Can Do
 
----
+- Chat in Desktop or CLI mode
+- Route coding requests into Code Mode automatically from the CLI chat UI
+- Inspect a workspace before editing
+- Search code, read file ranges, and patch files
+- Run non-destructive shell commands with user approval
+- Keep lightweight per-workspace session memory
+- Perform a second-pass reviewer step in Code Mode
+- Execute structured actions such as opening apps, URLs, folders, and system tasks
+- Support multiple providers: Gemini, Anthropic, OpenAI, local OpenAI-compatible endpoints, Ollama, and Hugging Face
+
+## Current Agent Capabilities
+
+Mint CLI is an agentic coding workflow, not just a chat wrapper.
+
+In Code Mode it can:
+
+- Decide on the next step from the current observation
+- Use tools in a loop: `list_files`, `read_file`, `search_code`, `run_shell`, `apply_patch`, `write_file`
+- Observe tool output and continue iterating
+- Stop with a summary and verification result
+- Ask for approval before shell commands and file changes
+
+That makes Mint a practical CLI coding agent, while still keeping the user in control of risky actions.
 
 ## Screenshots
 
 <p align="center">
-  <img src="assets/Agent_Mint.png" alt="Agent Mint UI" width="48%">
-  <img src="assets/Settings.png" alt="Settings Window" width="48%">
+  <img src="assets/Agent_Mint.png" alt="Mint Desktop UI" width="48%">
+  <img src="assets/Settings.png" alt="Mint Settings" width="48%">
 </p>
+
 <p align="center">
-  <em>Desktop Interface and personalized Settings window</em>
+  <img src="assets/CLI_Screen.png" alt="Mint CLI" width="100%">
 </p>
 
----
+## Installation
 
-## CLI Usage (Power Users)
+### Global install
 
-Mint CLI is built for speed and efficiency. Use the **`mint`** command from anywhere.
+```bash
+npm install -g @pheem49/mint@latest
+```
 
-<p align="center">
-  <img src="assets/CLI_Screen.png" alt="Mint CLI Preview" width="100%">
-</p>
+### Local development
 
-### Professional Commands
-- **`mint`** : Start interactive chat mode (Default).
-- **`mint code "task"`** : Run Mint as a workspace-aware coding agent in the current project folder.
-- **`mint agent`** : Run Mint as a headless background agent (Monitoring mode).
-- **`mint agent "task"`** : Start agent and execute an autonomous task immediately.
-- **`mint task "task"`** : Delegate a multi-step task to an already running background agent.
-- **`mint onboard`** : Setup API Key, Model, and initialize global configuration in `~/.mint/`.
-- **`mint list`** : See full list of automation actions and plugins.
+```bash
+git clone https://github.com/Pheem49/Mint.git
+cd Mint
+npm install
+```
 
----
+## Quick Start
 
-### Autonomous Agent (Task Delegate)
-Mint isn't just a chatbot—it's an autonomous worker. Assign complex tasks that require multiple steps of reasoning.
+### Run the desktop app
 
-### Code Agent Mode
-Mint now includes a dedicated coding workflow as the first step toward a Claude-Code-like experience in the terminal.
+```bash
+npm start
+```
 
-**What it can do now:**
-- Inspect the current workspace before editing
-- Search code across the repo
-- Read targeted file ranges
-- Run non-destructive shell commands in the project with interactive approval
-- Apply patch-based file edits with approval before changes are written
-- Reuse lightweight session memory and git/test context per project
+### Run the CLI
 
-**Usage Example:**
 ```bash
-mint code "fix the failing CLI command and verify it"
+mint
 ```
 
-**Chat-first Example:**
+### First-time setup
+
 ```bash
-mint
-> สำรวจโปรเจคนี้ให้หน่อย
+mint onboard
 ```
 
-Mint will classify the request, switch the status bar to `Code`, and return to `Chat` mode after the coding flow finishes.
+## CLI Commands
 
-**Supported Autonomous Tools:**
-- **Web Automation**: Full Puppeteer-based browsing, info extraction, and research.
-- **File System**: Create, Write, Delete, and Manage folders using `~/` path expansion.
-- **Knowledge Search**: Query local files and documentation (RAG).
-- **Safety Mode (Bash)**: Mint proposes commands via notifications; you choose whether to run them.
+- `mint` or `mint chat`
+Start the interactive chat UI.
 
-**Usage Examples:**
-```bash
-# Research and write a report
-mint agent 'Search for the latest iPhone reviews and write a SUMMARY.md to my desktop.'
+- `mint code "<task>"`
+Run the workspace-aware coding agent in the current directory.
+
+- `mint task "<task>"`
+Queue a background task for the headless agent.
 
-# Background Task
-mint task 'Process these 5 files and move them to ~/Documents/Archive'
+- `mint agent`
+Run the background headless agent.
+
+- `mint list`
+Show major features and commands.
+
+- `mint onboard`
+Configure API keys and local settings.
+
+## CLI Examples
+
+### Interactive chat
+
+```bash
+mint
 ```
 
----
+Then ask naturally:
+
+```text
+สำรวจโปรเจคนี้ให้หน่อย
+แก้บัคใน CLI ตัวนี้และรันเทสต์
+open github
+```
 
-### Slash Commands (Interactive Chat)
-While in terminal chat, type **`/`** to access advanced tools with the new visual autocomplete system.
-> [!TIP]
-> Use **Up/Down arrow keys** to navigate the suggestion list and press **Enter** to select!
+### One-shot coding task
 
-- `/help` : View all commands and descriptions.
-- `/models` : List and switch between Gemini, Ollama, Hugging Face, Anthropic, OpenAI, and Local models.
-- `/config` : Check your active API keys and preferences.
-- `/clear` / `/reset` : Clean terminal or reset AI context.
+```bash
+mint code "fix the failing tests and verify the result"
+```
 
----
+### Background task
 
-### Proactive Monitoring
-When running in `agent` mode, Mint monitors your system in the background:
-- **Battery Alerts**: Notifies you when power is low or charging status changes.
-- **Network Status**: Alerts you when connection status changes.
-- **Resource Usage**: Proactive tips if system load is too high (System Metrics).
+```bash
+mint task "inspect the repo and summarize the top 3 risks"
+```
 
+## Code Mode Workflow
 
----
+Mint Code Mode is designed around an inspect -> act -> verify loop.
 
-## Desktop GUI Features
+What it does well right now:
 
-- **Floating Widget**: A persistent AI character on your desktop.
-- **Animated Aura**: The widget breathes and glows when Mint is thinking or proactive.
-- **Minimize to Tray**: Click the dash icon (-) to hide the window to your system tray. Mint stays active!
-- **Widget Toggle**: Enable or disable the desktop widget anytime from **Settings > General**.
-- **Screen Overlay Glow**: Visual feedback when Mint is capturing your screen for analysis.
+- Understand the current workspace path
+- Read git status and diff summary
+- Suggest verification commands from `package.json`
+- Apply focused patches instead of blind rewrites
+- Keep a workspace session summary for future tasks
 
----
+What it deliberately does not do:
 
-## Security & Privacy
+- Run destructive commands like `rm -rf` or `git reset --hard`
+- Edit files outside the current workspace
+- Execute shell edits without approval
 
-- **Push Protection**: Automated `.gitignore` patterns for `mint-config.json` and `.env` files.
-- **History Scrubbing**: Integrated tools to ensure API keys are never leaked to Git history.
-- **Local First**: Built-in **Ollama** and **LM Studio (OpenAI Compatible)** support for 100% private, offline AI processing.
+## Desktop Features
 
----
+- Chat window with custom UI
+- Settings window for provider and behavior configuration
+- System tray support
+- Proactive suggestion loop
+- Silent screen capture for analysis
+- Screen translation support
+- Floating widget / overlay UI elements
 
-## Getting Started
+## AI Providers
 
-### Prerequisites
-- [Node.js](https://nodejs.org/) (LTS)
-- [npm](https://www.npmjs.com/)
-- A **Google Gemini API Key** (Get one at [Google AI Studio](https://aistudio.google.com/))
+Mint supports multiple providers and local backends.
 
-### Installation
-1. **Install via NPM (Recommended)**
-   ```bash
-   npm install -g @pheem49/mint@latest
-   ```
+- `gemini`
+- `anthropic`
+- `openai`
+- `local_openai`
+- `ollama`
+- `huggingface`
 
-2. **Manual Installation (For Developers)**
-   ```bash
-   git clone https://github.com/Pheem49/Mint.git
-   cd Mint
-   npm install
-   sudo npm link
-   ```
+For CLI Code Mode, Mint currently behaves best with:
 
----
+- `gemini`
+- `anthropic`
+- `openai`
+- `local_openai`
 
 ## Project Structure
 
 ```text
 Mint/
 ├── src/
-│   ├── AI_Brain/        # Gemini/Ollama integration & logic
-│   ├── Automation/      # Puppeteer and browser scripts
-│   ├── CLI/             # CLI Onboarding and Feature list
-│   ├── Plugins/         # Spotify, Docker, Obsidian, Git, etc.
-│   ├── System/          # Config, Daemon, and Event Monitoring
-│   └── UI/              # Electron renderer (Glassmorphism & Aura)
-├── mint-cli.js          # CLI Main Entry
-├── main.js              # Electron Main process
-└── package.json         # Binaries and dependencies
+│   ├── AI_Brain/          # Provider integration, prompts, memory, orchestration
+│   ├── Automation_Layer/  # App/file/browser actions
+│   ├── CLI/               # Chat router, code agent, TUI support, onboarding
+│   ├── Plugins/           # Docker, Spotify, calendar, system monitor, MCP
+│   ├── System/            # Config, notifications, daemon, automation, task queue
+│   └── UI/                # Electron renderer files
+├── tests/                 # Jest tests
+├── mint-cli.js            # Main CLI entry
+├── mint-cli-logic.js      # CLI action executor
+├── main.js                # Electron main process
+└── package.json
+```
+
+## Development
+
+### Run tests
+
+```bash
+npm test -- --runInBand
+```
+
+### Watch tests
+
+```bash
+npm run test:watch
+```
+
+### Build Linux packages
+
+```bash
+npm run build:linux
 ```
 
----
+See [BUILD_AND_RELEASE.md](/home/pheem49/vscode/Project/Mint/BUILD_AND_RELEASE.md) for Linux packaging and release notes workflow.
+
+## Security Notes
+
+- API keys are stored in local config, not in source files
+- Code Mode asks for approval before shell commands and file edits
+- Workspace path resolution blocks writes outside the active workspace
+- Several shell-based execution paths have been hardened to use argument-based process execution
+
+This is still an actively evolving project. Review permissions and local configuration before using Mint against sensitive files or production systems.
 
 ## License
 
-Distributed under the **GNU Affero General Public License v3.0**. See `LICENSE` for details.
+Mint is licensed under the GNU Affero General Public License v3.0.
+See [LICENSE](/home/pheem49/vscode/Project/Mint/LICENSE).

package/main.js

@@ -6,7 +6,7 @@ const { handleChat, resetChat, getChatTranscript, translateImageContent, refresh
 const { openApp } = require('./src/Automation_Layer/open_app');
 const { openWebsite, openSearch } = require('./src/Automation_Layer/open_website');
 const { performWebAutomation } = require('./src/Automation_Layer/browser_automation');
-const { createFolder, openFile, deleteFile } = require('./src/Automation_Layer/file_operations');
+const { createFolder, openFile, deleteFile, findPath } = require('./src/Automation_Layer/file_operations');
 const { getSystemInfo, getWeather } = require('./src/System/system_info');
 const { readConfig, writeConfig } = require('./src/System/config_manager');
 const { parseCommand } = require('./src/Command_Parser/parser');
@@ -868,6 +868,26 @@ async function executeAction(action) {
         case 'delete_file':
             await deleteFile(action.target);
             break;
+        case 'find_path': {
+            const result = findPath(action.target, {
+                type: action.pathType,
+                maxResults: 10
+            });
+            if (!result.success) {
+                return result.message;
+            }
+
+            if (action.openAfter === true) {
+                if (result.matches.length === 1) {
+                    const match = result.matches[0];
+                    const openResult = await openFile(match.path);
+                    return openResult || `Successfully found and opened ${match.type === 'dir' ? 'folder' : 'file'}: ${match.path} ✅`;
+                }
+                return `Found multiple matches for "${action.target}". Please be more specific:\n${result.matches.map(m => `- [${m.type}] ${m.path}`).join('\n')}`;
+            }
+
+            return `Found matches for "${action.target}":\n${result.matches.map(m => `- [${m.type}] ${m.path}`).join('\n')}`;
+        }
         case 'clipboard_write':
             clipboard.writeText(action.target);
             break;

package/mint-cli-logic.js

@@ -1,7 +1,7 @@
 // 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 { createFolder, openFile, deleteFile, findPath } = 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');
@@ -32,6 +32,26 @@ async function executeAction(action) {
             case 'delete_file':
                 await deleteFile(action.target);
                 return `Deleted: ${action.target}`;
+            case 'find_path': {
+                const result = findPath(action.target, {
+                    type: action.pathType,
+                    maxResults: 10
+                });
+                if (!result.success) {
+                    return result.message;
+                }
+
+                if (action.openAfter === true) {
+                    if (result.matches.length === 1) {
+                        const match = result.matches[0];
+                        await openFile(match.path);
+                        return `Found and opened ${match.type === 'dir' ? 'folder' : 'file'}: ${match.path}`;
+                    }
+                    return `Found multiple matches for "${action.target}". Please be more specific:\n${result.matches.map(m => `- [${m.type}] ${m.path}`).join('\n')}`;
+                }
+
+                return `Found matches for "${action.target}":\n${result.matches.map(m => `- [${m.type}] ${m.path}`).join('\n')}`;
+            }
             case 'learn_file':
                 return await indexFile(action.target);
             case 'mcp_tool':

package/mint-cli.js

@@ -1,7 +1,15 @@
 #!/usr/bin/env node
 require('dotenv').config({ quiet: true });
+// Suppress experimental SQLite warning
+const originalEmit = process.emit;
+process.emit = function (name, data, ...args) {
+    if (name === 'warning' && typeof data === 'object' && data.name === 'ExperimentalWarning' && data.message.includes('SQLite')) {
+        return false;
+    }
+    return originalEmit.apply(process, [name, data, ...args]);
+};
 const { Command } = require('commander');
-const { handleChat, handleGeminiChatStream, resetChat, refreshApiKeyFromConfig } = require('./src/AI_Brain/Gemini_API');
+const { handleChat, handleGeminiChatStream, resetChat, refreshApiKeyFromConfig, getChatTranscript } = require('./src/AI_Brain/Gemini_API');
 const agentOrchestrator = require('./src/AI_Brain/agent_orchestrator');
 const workspaceManager = require('./src/CLI/workspace_manager');
 const systemMonitor = require('./src/Plugins/system_monitor');
@@ -145,7 +153,7 @@ async function startInteractiveChat(initialMessage = null) {
                         if (success) {
                             const agent = agentOrchestrator.getCurrentAgent();
                             appendMessage('system', `Switched to Agent: ${agent.icon} ${agent.name}`);
-                            updateStatusModel(null, agent.name); // Pass name to status bar
+                            updateStatusModel(agent.name); // Pass name to status bar
                             resetChat(); // Reset to apply new system prompt
                         } else {
                             appendMessage('error', `Agent "${args[1]}" not found. Try /agent list`);
@@ -217,16 +225,32 @@ async function startInteractiveChat(initialMessage = null) {
             }
             appendMessage('user', text);
 
-            const routeDecision = await detectCodeIntent(text, process.cwd());
+            const transcript = await getChatTranscript();
+            const routeDecision = await detectCodeIntent(text, process.cwd(), transcript);
             if (routeDecision.route === 'code') {
-                appendMessage('system', `Router: entering Code Mode. ${routeDecision.reason}`);
-                await runChatRoutedTask(text, {
-                    appendMessage,
-                    setThinking,
-                    requestApproval,
-                    setMode
+                const approved = await requestApproval({
+                    type: 'code_mode',
+                    label: 'Mint wants to switch this request into Code Mode.',
+                    preview: [
+                        `Request: ${text}`,
+                        `Reason: ${routeDecision.reason}`,
+                        '',
+                        'Code Mode is better for larger coding tasks that may inspect the workspace, run checks, or edit files.'
+                    ].join('\n')
                 });
-                return;
+                if (!approved) {
+                    appendMessage('system', `Router stayed in Chat Mode. ${routeDecision.reason}`);
+                } else {
+                    appendMessage('system', `Router: entering Code Mode. ${routeDecision.reason}`);
+                    await runChatRoutedTask(text, {
+                        appendMessage,
+                        setThinking,
+                        requestApproval,
+                        setMode,
+                        history: transcript
+                    });
+                    return;
+                }
             }
 
             setMode('Chat');
@@ -243,7 +267,7 @@ async function startInteractiveChat(initialMessage = null) {
                 const config = require('./src/System/config_manager').readConfig();
                 const provider = config.aiProvider || 'gemini';
                 const currentAgent = agentOrchestrator.getCurrentAgent();
-                updateStatusModel(null, currentAgent.name);
+                updateStatusModel(currentAgent.name);
                 if (provider === 'gemini') {
                     // ── Streaming path (Gemini only) ──────────────────────────────────
                     // Gemini returns JSON so we buffer all chunks and progressively
@@ -346,16 +370,52 @@ async function startInteractiveChat(initialMessage = null) {
     // Handle initial message if passed via CLI arg
     if (initialMessage) {
         appendMessage('user', initialMessage);
-        const routeDecision = await detectCodeIntent(initialMessage, process.cwd());
-        if (routeDecision.route === 'code') {
-            appendMessage('system', `Router: entering Code Mode. ${routeDecision.reason}`);
-            await runChatRoutedTask(initialMessage, {
-                appendMessage,
-                setThinking,
-                requestApproval,
-                setMode
-            });
-        } else {
+            const transcript = await getChatTranscript();
+            const routeDecision = await detectCodeIntent(initialMessage, process.cwd(), transcript);
+            if (routeDecision.route === 'code') {
+                const approved = await requestApproval({
+                    type: 'code_mode',
+                    label: 'Mint wants to switch this request into Code Mode.',
+                    preview: [
+                        `Request: ${initialMessage}`,
+                        `Reason: ${routeDecision.reason}`,
+                        '',
+                        'Code Mode is better for larger coding tasks that may inspect the workspace, run checks, or edit files.'
+                    ].join('\n')
+                });
+                if (approved) {
+                    appendMessage('system', `Router: entering Code Mode. ${routeDecision.reason}`);
+                    await runChatRoutedTask(initialMessage, {
+                        appendMessage,
+                        setThinking,
+                        requestApproval,
+                        setMode,
+                        history: transcript
+                    });
+                } else {
+                    appendMessage('system', `Router stayed in Chat Mode. ${routeDecision.reason}`);
+                    setMode('Chat');
+                    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, response.timestamp);
+                        lastResponseText = response.response;
+                        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);
+                    }
+                }
+            } else {
             setMode('Chat');
             let seconds = 0;
             setThinking(true, seconds);
@@ -365,6 +425,12 @@ async function startInteractiveChat(initialMessage = null) {
                 clearInterval(timer);
                 setThinking(false);
                 appendMessage('assistant', response.response, response.timestamp);
+                lastResponseText = response.response;
+                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);
@@ -455,7 +521,8 @@ async function handleSlashCommandUI(input, appendMessage, updateStatusModel, cop
                 appendMessage,
                 setThinking,
                 requestApproval,
-                setMode
+                setMode,
+                history: await getChatTranscript()
             });
             break;
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pheem49/mint",
-  "version": "1.4.0",
+  "version": "1.4.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": {