echo-ai-agent 1.0.0

package/main/main.js

@@ -0,0 +1,206 @@
+const { app, BrowserWindow, ipcMain, screen, globalShortcut, Menu } = require('electron');
+const path = require('path');
+const GeminiBrain = require('../services/gemini');
+const SystemActions = require('../services/system');
+const ConfigManager = require('../scripts/config-manager');
+const PluginManager = require('../scripts/plugin-manager');
+require('dotenv').config();
+
+let mainWindow;
+let brain;
+const config = new ConfigManager();
+const pluginManager = new PluginManager();
+
+async function initializeBrain() {
+    // ... existing initialization code
+    const apiKey = config.get('apiKey') || process.env.GOOGLE_AI_API_KEY;
+    
+    if (apiKey) {
+        // Load plugins first
+        await pluginManager.loadPlugins();
+        
+        // Convert plugin commands to Gemini tool format
+        const pluginTools = pluginManager.listPlugins().filter(p => p.enabled).flatMap(p => {
+            const plugin = pluginManager.plugins.get(p.name);
+            return Object.keys(plugin.commands).map(cmdName => ({
+                name: cmdName, // Command name matches function name
+                description: plugin.commandDescriptions?.[cmdName] || `Execute ${cmdName} command`,
+                parameters: {
+                    type: "OBJECT",
+                    properties: {
+                        args: { type: "STRING", description: "Arguments for the command" }
+                    }
+                }
+            }));
+        });
+
+        brain = new GeminiBrain(apiKey, pluginTools);
+    }
+}
+
+function createWindow() {
+    const { width, height } = screen.getPrimaryDisplay().workAreaSize;
+    
+    // Get user preferences
+    const windowSize = config.getWindowSize(config.get('size') || 'medium');
+    const position = config.getWindowPosition(
+        config.get('position') || 'bottom-right',
+        { width, height },
+        windowSize
+    );
+    const alwaysOnTop = config.get('alwaysOnTop') !== false;
+    const startOnBoot = config.get('startOnBoot') === true;
+
+    // Apply start on boot setting
+    app.setLoginItemSettings({
+        openAtLogin: startOnBoot,
+        path: app.getPath('exe') // Correct specialized path for packaged app
+    });
+
+    mainWindow = new BrowserWindow({
+        width: windowSize.width,
+        height: windowSize.height,
+        x: position.x,
+        y: position.y,
+        frame: false,
+        transparent: true,
+        alwaysOnTop: alwaysOnTop,
+        webPreferences: {
+            preload: path.join(__dirname, 'preload.js'),
+            nodeIntegration: false,
+            contextIsolation: true,
+        },
+        skipTaskbar: true,
+        resizable: true,
+        hasShadow: false
+    });
+
+    mainWindow.loadFile(path.join(__dirname, '../ui/index.html'));
+
+    // Create Context Menu (Right-Click)
+    const contextMenu = Menu.buildFromTemplate([
+        { label: 'Echo AI Agent', enabled: false },
+        { type: 'separator' },
+        { 
+            label: 'Hide (Ctrl+Shift+E)', 
+            click: () => mainWindow.hide() 
+        },
+        { type: 'separator' },
+        { 
+            label: 'Quit Echo', 
+            click: () => app.quit() 
+        }
+    ]);
+
+    // Attach context menu to window
+    mainWindow.webContents.on('context-menu', (e, params) => {
+        contextMenu.popup(mainWindow, params.x, params.y);
+    });
+
+    // Register global hotkey
+    const hotkey = config.get('hotkey') || 'CommandOrControl+Shift+E';
+    globalShortcut.register(hotkey, () => {
+        if (mainWindow) {
+            if (mainWindow.isVisible()) {
+                mainWindow.hide();
+            } else {
+                mainWindow.show();
+                mainWindow.focus();
+            }
+        }
+    });
+
+    // Send theme configuration to renderer
+    mainWindow.webContents.on('did-finish-load', () => {
+        const theme = config.get('theme') || 'cyan';
+        const themeColors = config.getThemeColors(theme);
+        mainWindow.webContents.send('apply-theme', themeColors);
+    });
+}
+
+// Global error handlers
+process.on('uncaughtException', (error) => {
+    console.error('Critical Error:', error);
+    // Optionally show a dialog to the user
+});
+
+process.on('unhandledRejection', (reason, promise) => {
+    console.error('Unhandled Rejection at:', promise, 'reason:', reason);
+});
+
+// Initialize system
+app.whenReady().then(async () => {
+    await initializeBrain();
+    createWindow();
+});
+
+app.on('will-quit', () => {
+    // Unregister all shortcuts
+    globalShortcut.unregisterAll();
+});
+
+// Handle voice/text commands from the UI
+ipcMain.handle('process-input', async (event, text) => {
+    if (!brain) return { success: false, text: "API Key missing. Please run 'echo setup' first." };
+    
+    try {
+        const response = await brain.processCommand(text);
+        
+        if (response.type === 'action') {
+            // Execute the system action
+            let result;
+            const cmd = response.command.toLowerCase();
+            const argsStr = Array.isArray(response.args) ? response.args.join(' ') : response.args;
+
+            // Enhanced command routing
+            if (cmd.includes('chrome') || cmd.includes('search') || cmd.includes('web')) {
+                result = await SystemActions.searchWeb(argsStr || text);
+            } else if (cmd.includes('mkdir') || cmd.includes('folder')) {
+                result = await SystemActions.createFolder(argsStr || "New Folder");
+            } else if (cmd.includes('screenshot')) {
+                result = await SystemActions.takeScreenshot();
+            } else if (cmd.includes('system') || cmd.includes('info')) {
+                result = SystemActions.getSystemInfo();
+            } else if (cmd.includes('time') || cmd.includes('date')) {
+                result = SystemActions.getDateTime();
+            } else if (cmd.includes('list') || cmd.includes('files')) {
+                result = await SystemActions.listFiles(argsStr);
+            } else if (cmd.includes('copy')) {
+                const [source, dest] = argsStr.split(' to ');
+                result = await SystemActions.copyFile(source, dest);
+            } else if (cmd.includes('delete')) {
+                result = await SystemActions.deleteFile(argsStr);
+            } else if (cmd.includes('url') || cmd.includes('open')) {
+                result = await SystemActions.openUrl(argsStr);
+            } else {
+                result = await SystemActions.openApp(cmd);
+            }
+            
+            return { success: true, text: response.text || "Action completed, sir.", action: response.command };
+        
+        } else if (response.type === 'plugin_action') {
+            // Execute plugin command
+            const result = await pluginManager.executeCommand(response.command, response.args);
+            
+            if (result.success) {
+                return { success: true, text: result.result.message || "Plugin executed successfully.", action: response.command };
+            } else {
+                return { success: false, text: `Plugin error: ${result.error}` };
+            }
+        }
+        
+        return { success: true, text: response.text };
+    } catch (error) {
+        console.error("Gemini Error:", error);
+        return { success: false, text: "I encountered an error processing that, sir." };
+    }
+});
+
+// Get configuration
+ipcMain.handle('get-config', async () => {
+    return {
+        theme: config.get('theme') || 'cyan',
+        themeColors: config.getThemeColors(config.get('theme') || 'cyan')
+    };
+});
+

package/main/preload.js

@@ -0,0 +1,10 @@
+const { contextBridge, ipcRenderer } = require('electron');
+
+contextBridge.exposeInMainWorld('electronAPI', {
+    executeCommand: (command, args) => ipcRenderer.invoke('system-command', { command, args }),
+    processInput: (text) => ipcRenderer.invoke('process-input', text),
+    onSpeechUpdate: (callback) => ipcRenderer.on('speech-update', callback),
+    getConfig: () => ipcRenderer.invoke('get-config'),
+    onApplyTheme: (callback) => ipcRenderer.on('apply-theme', (event, theme) => callback(theme))
+});
+

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "echo-ai-agent",
+  "version": "1.0.0",
+  "description": "A premium JARVIS-inspired AI assistant for your desktop - voice-controlled, intelligent, and beautiful",
+  "main": "main/main.js",
+  "bin": {
+    "echo": "./cli.js"
+  },
+  "preferGlobal": true,
+  "scripts": {
+    "start": "electron .",
+    "dev": "electron . --inspect",
+    "postinstall": "node scripts/postinstall.js",
+    "uninstall": "node scripts/uninstall.js",
+    "prepublishOnly": "node scripts/prepublish.js",
+    "test": "echo \"Tests coming soon\" && exit 0"
+  },
+  "dependencies": {
+    "@google/generative-ai": "^0.21.0",
+    "chalk": "^4.1.2",
+    "commander": "^11.1.0",
+    "conf": "^10.2.0",
+    "dotenv": "^16.4.5",
+    "electron": "^32.0.0",
+    "inquirer": "^8.2.5",
+    "node-record-lpcm16": "^1.0.1",
+    "ora": "^5.4.1"
+  },
+  "devDependencies": {},
+  "keywords": [
+    "ai",
+    "assistant",
+    "jarvis",
+    "voice-control",
+    "desktop-assistant",
+    "electron",
+    "gemini",
+    "productivity",
+    "automation",
+    "ai-agent",
+    "voice-assistant",
+    "system-control"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/MuhammadUsmanGM/Echo"
+  },
+  "bugs": {
+    "url": "https://github.com/MuhammadUsmanGM/Echo/issues"
+  },
+  "homepage": "https://github.com/MuhammadUsmanGM/Echo#readme",
+  "author": "Muhammad Usman",
+  "license": "MIT",
+  "engines": {
+    "node": ">=14.0.0"
+  }
+}

package/plugins/example-plugin.js

@@ -0,0 +1,100 @@
+/**
+ * Example Plugin for Echo AI Agent
+ * 
+ * This is a sample plugin that demonstrates how to extend Echo with custom commands.
+ * Copy this file to create your own plugins!
+ */
+
+module.exports = {
+    // Plugin metadata
+    name: 'example-plugin',
+    version: '1.0.0',
+    description: 'An example plugin showing how to create custom commands',
+    author: 'Echo Team',
+
+    // Optional: Initialize plugin (runs once when loaded)
+    init: async function() {
+        console.log('Example plugin initialized!');
+    },
+
+    // Command definitions
+    commands: {
+        /**
+         * Example command: greet
+         * Usage: "Echo, greet John"
+         */
+        greet: async function(args) {
+            const name = args || 'there';
+            return {
+                success: true,
+                message: `Hello, ${name}! This is a custom command from the example plugin.`
+            };
+        },
+
+        /**
+         * Example command: calculate
+         * Usage: "Echo, calculate 5 + 3"
+         */
+        calculate: async function(args) {
+            try {
+                // Simple calculator (be careful with eval in production!)
+                const result = eval(args);
+                return {
+                    success: true,
+                    message: `The result is ${result}`
+                };
+            } catch (error) {
+                return {
+                    success: false,
+                    message: 'Invalid calculation'
+                };
+            }
+        },
+
+        /**
+         * Example command: joke
+         * Usage: "Echo, tell me a joke"
+         */
+        joke: async function(args) {
+            const jokes = [
+                "Why don't scientists trust atoms? Because they make up everything!",
+                "Why did the scarecrow win an award? He was outstanding in his field!",
+                "Why don't eggs tell jokes? They'd crack each other up!",
+                "What do you call a bear with no teeth? A gummy bear!",
+                "Why did the bicycle fall over? It was two tired!"
+            ];
+            
+            const randomJoke = jokes[Math.floor(Math.random() * jokes.length)];
+            
+            return {
+                success: true,
+                message: randomJoke
+            };
+        },
+
+        /**
+         * Example command: weather (mock)
+         * Usage: "Echo, what's the weather"
+         */
+        weather: async function(args) {
+            // In a real plugin, you'd call a weather API here
+            return {
+                success: true,
+                message: 'The weather is sunny with a chance of code! 🌞 (This is a mock response)'
+            };
+        }
+    },
+
+    // Optional: Command descriptions for help
+    commandDescriptions: {
+        greet: 'Greet someone by name',
+        calculate: 'Perform a simple calculation',
+        joke: 'Tell a random joke',
+        weather: 'Get weather information (mock)'
+    },
+
+    // Optional: Cleanup when plugin is disabled
+    cleanup: async function() {
+        console.log('Example plugin cleaned up!');
+    }
+};

package/scripts/config-manager.js

@@ -0,0 +1,86 @@
+const Conf = require('conf');
+const path = require('path');
+
+class ConfigManager {
+  constructor() {
+    this.config = new Conf({
+      projectName: 'echo-ai-agent',
+      defaults: {
+        configured: false,
+        theme: 'cyan',
+        position: 'bottom-right',
+        size: 'medium',
+        apiKey: null,
+        voice: 'auto',
+        hotkey: 'CommandOrControl+Shift+E',
+        alwaysOnTop: true,
+        startOnBoot: false,
+        plugins: []
+      }
+    });
+  }
+
+  get(key) {
+    return this.config.get(key);
+  }
+
+  set(key, value) {
+    this.config.set(key, value);
+  }
+
+  has(key) {
+    return this.config.has(key);
+  }
+
+  delete(key) {
+    this.config.delete(key);
+  }
+
+  clear() {
+    this.config.clear();
+  }
+
+  get store() {
+    return this.config.store;
+  }
+
+  getThemeColors(themeName) {
+    const themes = {
+      cyan: { core: '#00f2ff', glow: 'rgba(0, 242, 255, 0.5)' },
+      purple: { core: '#a855f7', glow: 'rgba(168, 85, 247, 0.5)' },
+      green: { core: '#00ff88', glow: 'rgba(0, 255, 136, 0.5)' },
+      gold: { core: '#ffd700', glow: 'rgba(255, 215, 0, 0.5)' },
+      red: { core: '#ff0055', glow: 'rgba(255, 0, 85, 0.5)' },
+      blue: { core: '#0088ff', glow: 'rgba(0, 136, 255, 0.5)' }
+    };
+    return themes[themeName] || themes.cyan;
+  }
+
+  getWindowPosition(position, screenSize, windowSize) {
+    const positions = {
+      'top-left': { x: 20, y: 20 },
+      'top-right': { x: screenSize.width - windowSize.width - 20, y: 20 },
+      'bottom-left': { x: 20, y: screenSize.height - windowSize.height - 20 },
+      'bottom-right': { 
+        x: screenSize.width - windowSize.width - 20, 
+        y: screenSize.height - windowSize.height - 20 
+      },
+      'center': { 
+        x: (screenSize.width - windowSize.width) / 2, 
+        y: (screenSize.height - windowSize.height) / 2 
+      }
+    };
+    return positions[position] || positions['bottom-right'];
+  }
+
+  getWindowSize(size) {
+    const sizes = {
+      small: { width: 250, height: 350 },
+      medium: { width: 350, height: 450 },
+      large: { width: 450, height: 550 }
+    };
+    return sizes[size] || sizes.medium;
+  }
+}
+
+module.exports = ConfigManager;

package/scripts/plugin-manager.js

@@ -0,0 +1,160 @@
+const fs = require('fs');
+const path = require('path');
+const ConfigManager = require('./config-manager');
+
+class PluginManager {
+    constructor() {
+        this.config = new ConfigManager();
+        this.plugins = new Map();
+        this.pluginDir = path.join(__dirname, '..', 'plugins');
+        
+        // Create plugins directory if it doesn't exist
+        if (!fs.existsSync(this.pluginDir)) {
+            fs.mkdirSync(this.pluginDir, { recursive: true });
+        }
+    }
+
+    /**
+     * Load all plugins from the plugins directory
+     */
+    async loadPlugins() {
+        const enabledPlugins = this.config.get('plugins') || [];
+        
+        try {
+            const files = fs.readdirSync(this.pluginDir);
+            
+            for (const file of files) {
+                if (file.endsWith('.js')) {
+                    const pluginPath = path.join(this.pluginDir, file);
+                    await this.loadPlugin(pluginPath);
+                }
+            }
+            
+            console.log(`Loaded ${this.plugins.size} plugin(s)`);
+        } catch (error) {
+            console.error('Error loading plugins:', error);
+        }
+    }
+
+    /**
+     * Load a single plugin
+     */
+    async loadPlugin(pluginPath) {
+        try {
+            const plugin = require(pluginPath);
+            
+            // Validate plugin structure
+            if (!plugin.name || !plugin.commands) {
+                throw new Error('Invalid plugin structure. Must have name and commands.');
+            }
+            
+            // Check if plugin is enabled
+            const enabledPlugins = this.config.get('plugins') || [];
+            if (!enabledPlugins.includes(plugin.name)) {
+                console.log(`Plugin ${plugin.name} is disabled. Skipping...`);
+                return;
+            }
+            
+            this.plugins.set(plugin.name, plugin);
+            console.log(`Loaded plugin: ${plugin.name} v${plugin.version || '1.0.0'}`);
+            
+            // Run plugin initialization if it exists
+            if (plugin.init && typeof plugin.init === 'function') {
+                await plugin.init();
+            }
+        } catch (error) {
+            console.error(`Error loading plugin ${pluginPath}:`, error);
+        }
+    }
+
+    /**
+     * Execute a command from a plugin
+     */
+    async executeCommand(commandName, args) {
+        for (const [pluginName, plugin] of this.plugins) {
+            if (plugin.commands[commandName]) {
+                try {
+                    const result = await plugin.commands[commandName](args);
+                    return { success: true, plugin: pluginName, result };
+                } catch (error) {
+                    return { 
+                        success: false, 
+                        plugin: pluginName, 
+                        error: error.message 
+                    };
+                }
+            }
+        }
+        
+        return { success: false, error: 'Command not found in any plugin' };
+    }
+
+    /**
+     * Get all available commands from all plugins
+     */
+    getAvailableCommands() {
+        const commands = [];
+        
+        for (const [pluginName, plugin] of this.plugins) {
+            for (const commandName of Object.keys(plugin.commands)) {
+                commands.push({
+                    plugin: pluginName,
+                    command: commandName,
+                    description: plugin.commandDescriptions?.[commandName] || 'No description'
+                });
+            }
+        }
+        
+        return commands;
+    }
+
+    /**
+     * Enable a plugin
+     */
+    enablePlugin(pluginName) {
+        const enabledPlugins = this.config.get('plugins') || [];
+        if (!enabledPlugins.includes(pluginName)) {
+            enabledPlugins.push(pluginName);
+            this.config.set('plugins', enabledPlugins);
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * Disable a plugin
+     */
+    disablePlugin(pluginName) {
+        const enabledPlugins = this.config.get('plugins') || [];
+        const index = enabledPlugins.indexOf(pluginName);
+        if (index > -1) {
+            enabledPlugins.splice(index, 1);
+            this.config.set('plugins', enabledPlugins);
+            this.plugins.delete(pluginName);
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * List all installed plugins
+     */
+    listPlugins() {
+        const plugins = [];
+        const enabledPlugins = this.config.get('plugins') || [];
+        
+        for (const [name, plugin] of this.plugins) {
+            plugins.push({
+                name,
+                version: plugin.version || '1.0.0',
+                description: plugin.description || 'No description',
+                enabled: enabledPlugins.includes(name),
+                commands: Object.keys(plugin.commands).length
+            });
+        }
+        
+        return plugins;
+    }
+}
+
+module.exports = PluginManager;

package/scripts/postinstall.js

@@ -0,0 +1,30 @@
+const chalk = require('chalk');
+
+function postInstall() {
+    console.log('\n');
+    console.log(chalk.cyan('╔═══════════════════════════════════════════════════════════════╗'));
+    console.log(chalk.cyan('║                                                               ║'));
+    console.log(chalk.cyan('║') + chalk.bold.white('                    ECHO AI AGENT                          ') + chalk.cyan('║'));
+    console.log(chalk.cyan('║') + chalk.gray('              Premium Desktop Assistant v1.0.0             ') + chalk.cyan('║'));
+    console.log(chalk.cyan('║                                                               ║'));
+    console.log(chalk.cyan('╚═══════════════════════════════════════════════════════════════╝'));
+    console.log('\n');
+    
+    console.log(chalk.green.bold('  ✓ Installation Successful!'));
+    console.log(chalk.gray('  Welcome to the future of desktop automation.'));
+    
+    console.log('\n' + chalk.yellow.bold('  👉 NEXT STEP: SETUP'));
+    console.log(chalk.white('  To configure your API key, theme, and startup preferences, run:'));
+    console.log('\n      ' + chalk.bgCyan.black.bold(' echo setup ') + '\n');
+    
+    console.log(chalk.white('  Then launch Echo with:'));
+    console.log('      ' + chalk.cyan('echo start') + '\n');
+    
+    console.log(chalk.gray('  Need help? Run ') + chalk.white('echo --help') + '\n');
+}
+
+if (require.main === module) {
+    postInstall();
+}
+
+module.exports = postInstall;