echo-ai-agent 1.0.0

package/scripts/prepublish.js

@@ -0,0 +1,63 @@
+const { execSync } = require('child_process');
+const chalk = require('chalk');
+const fs = require('fs');
+const path = require('path');
+
+const packageJson = require('../package.json');
+
+console.log(chalk.cyan.bold(`Preparing to publish Echo AI Agent v${packageJson.version}...\n`));
+
+try {
+    // 1. Check for sensitive files
+    console.log(chalk.yellow('Checking for sensitive files...'));
+    if (fs.existsSync(path.join(__dirname, '..', '.env'))) {
+        console.log(chalk.red('⚠️  WARNING: .env file found. Make sure it is in .gitignore and .npmignore!'));
+        console.log(chalk.gray('Checking .npmignore...'));
+        const npmIgnore = fs.readFileSync(path.join(__dirname, '..', '.npmignore'), 'utf8');
+        if (!npmIgnore.includes('.env')) {
+            console.error(chalk.bgRed.white(' CRITICAL: .env is NOT in .npmignore. Aborting publish to protect secrets. '));
+            process.exit(1);
+        }
+    }
+    console.log(chalk.green('✓ Security check passed.'));
+
+    // 2. Run tests (simulated)
+    console.log(chalk.yellow('\nRunning tests...'));
+    // execSync('npm test', { stdio: 'inherit' }); // Uncomment when tests are real
+    console.log(chalk.green('✓ Tests passed (simulated).'));
+
+    // 3. Verify main entry point
+    console.log(chalk.yellow('\nVerifying entry point...'));
+    if (!fs.existsSync(path.join(__dirname, '..', packageJson.main))) {
+        console.error(chalk.red(`❌ Error: Main file ${packageJson.main} not found!`));
+        process.exit(1);
+    }
+    console.log(chalk.green('✓ Entry point found.'));
+
+    // 4. Verify CLI entry point
+    console.log(chalk.yellow('\nVerifying CLI bin...'));
+    const binPath = packageJson.bin.echo;
+    if (!fs.existsSync(path.join(__dirname, '..', binPath))) {
+        console.error(chalk.red(`❌ Error: CLI file ${binPath} not found!`));
+        process.exit(1);
+    }
+    
+    // Make CLI executable
+    try {
+        if (process.platform !== 'win32') {
+            execSync(`chmod +x ${path.join(__dirname, '..', binPath)}`);
+            console.log(chalk.green('✓ CLI executable permissions set.'));
+        }
+    } catch (e) {
+        console.log(chalk.yellow('⚠️  Could not set executable permissions (might be Windows).'));
+    }
+
+    console.log(chalk.green('\n✅ Project is ready for publishing!'));
+    console.log(chalk.white('\nTo publish, run:'));
+    console.log(chalk.cyan('npm login'));
+    console.log(chalk.cyan('npm publish --access public'));
+
+} catch (error) {
+    console.error(chalk.red('\n❌ Pre-publish check failed:'), error.message);
+    process.exit(1);
+}

package/scripts/setup-wizard.js

@@ -0,0 +1,97 @@
+const inquirer = require('inquirer');
+const chalk = require('chalk');
+const fs = require('fs');
+const path = require('path');
+const ConfigManager = require('./config-manager');
+
+const config = new ConfigManager();
+
+async function run() {
+  console.log(chalk.cyan.bold('\n🔧 Echo Setup Wizard\n'));
+  console.log(chalk.gray('Let\'s configure your AI assistant...\n'));
+
+  const answers = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'apiKey',
+      message: 'Enter your Google Gemini API Key:',
+      validate: (input) => {
+        if (!input || input.trim().length === 0) {
+          return 'API Key is required. Get one from https://aistudio.google.com/';
+        }
+        return true;
+      }
+    },
+    {
+      type: 'list',
+      name: 'theme',
+      message: 'Choose your theme:',
+      choices: [
+        { name: chalk.cyan('● Cyan (Classic JARVIS)'), value: 'cyan' },
+        { name: chalk.hex('#a855f7')('● Purple (Royal)'), value: 'purple' },
+        { name: chalk.green('● Green (Matrix)'), value: 'green' },
+        { name: chalk.hex('#ffd700')('● Gold (Iron Man)'), value: 'gold' },
+        { name: chalk.red('● Red (Cyberpunk)'), value: 'red' },
+        { name: chalk.blue('● Blue (Ocean)'), value: 'blue' }
+      ],
+      default: 'cyan'
+    },
+    {
+      type: 'list',
+      name: 'position',
+      message: 'Where should Echo appear on your screen?',
+      choices: [
+        { name: 'Bottom Right (Recommended)', value: 'bottom-right' },
+        { name: 'Bottom Left', value: 'bottom-left' },
+        { name: 'Top Right', value: 'top-right' },
+        { name: 'Top Left', value: 'top-left' },
+        { name: 'Center', value: 'center' }
+      ],
+      default: 'bottom-right'
+    },
+    {
+      type: 'list',
+      name: 'size',
+      message: 'Choose window size:',
+      choices: [
+        { name: 'Small (250x350)', value: 'small' },
+        { name: 'Medium (350x450) - Recommended', value: 'medium' },
+        { name: 'Large (450x550)', value: 'large' }
+      ],
+      default: 'medium'
+    },
+    {
+      type: 'confirm',
+      name: 'alwaysOnTop',
+      message: 'Keep Echo always on top of other windows?',
+      default: true
+    },
+    {
+      type: 'confirm',
+      name: 'startOnBoot',
+      message: 'Start Echo automatically when you log in?',
+      default: false
+    }
+  ]);
+
+  // Save configuration
+  config.set('apiKey', answers.apiKey);
+  config.set('theme', answers.theme);
+  config.set('position', answers.position);
+  config.set('size', answers.size);
+  config.set('alwaysOnTop', answers.alwaysOnTop);
+  config.set('startOnBoot', answers.startOnBoot);
+  config.set('configured', true);
+
+  // Create/update .env file
+  const envPath = path.join(__dirname, '..', '.env');
+  const envContent = `GOOGLE_AI_API_KEY=${answers.apiKey}\n`;
+  fs.writeFileSync(envPath, envContent);
+
+  console.log(chalk.green('\n✓ Configuration saved successfully!'));
+  console.log(chalk.gray('\nYou can change these settings anytime with:'));
+  console.log(chalk.cyan('  echo config --list'));
+  console.log(chalk.cyan('  echo setup\n'));
+}
+
+module.exports = { run };

package/scripts/uninstall.js

@@ -0,0 +1,36 @@
+const ConfigManager = require('./config-manager');
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+
+const config = new ConfigManager();
+
+async function uninstall() {
+    console.log(chalk.red('⚠️  Uninstalling Echo AI Agent Configuration'));
+    
+    const answers = await inquirer.prompt([
+        {
+            type: 'confirm',
+            name: 'deleteConfig',
+            message: 'Do you want to delete all configuration files and preferences?',
+            default: false
+        }
+    ]);
+
+    if (answers.deleteConfig) {
+        config.clear();
+        console.log(chalk.green('✓ Configuration cleared.'));
+    } else {
+        console.log(chalk.yellow('ℹ️  Configuration preserved.'));
+    }
+    
+    console.log(chalk.cyan('\nEcho AI Agent has been uninstalled from your system.'));
+    console.log(chalk.gray('If you installed it globally, you can remove the package with:'));
+    console.log(chalk.white('npm uninstall -g echo-ai-agent'));
+}
+
+// Only run if called directly
+if (require.main === module) {
+    uninstall();
+}
+
+module.exports = uninstall;

package/services/gemini.js

@@ -0,0 +1,79 @@
+const { GoogleGenerativeAI } = require("@google/generative-ai");
+
+class GeminiBrain {
+    constructor(apiKey, customTools = []) {
+        this.genAI = new GoogleGenerativeAI(apiKey);
+        
+        // Base system tools
+        this.baseTools = [
+            {
+                name: "execute_system_command",
+                description: "Execute a system action or shell command on the user's computer",
+                parameters: {
+                    type: "OBJECT",
+                    properties: {
+                        command: { type: "STRING", description: "The command to run (e.g., 'start chrome', 'mkdir test', 'screenshot')" },
+                        args: { type: "ARRAY", items: { type: "STRING" }, description: "Arguments for the command" }
+                    },
+                    required: ["command"]
+                }
+            }
+        ];
+
+        // Merge base tools with plugin tools
+        // Plugins should provide tools in Google Generative AI function declaration format
+        this.allTools = [...this.baseTools, ...customTools];
+
+        this.model = this.genAI.getGenerativeModel({
+            model: "gemini-2.0-flash-lite",
+            systemInstruction: "You are Echo, a highly sophisticated, JARVIS-inspired AI agent. " +
+                               "Your personality is professional, slightly witty, and exceptionally helpful. " +
+                               "You have control over the user's system and can perform various tasks like opening apps, managing files, and searching the web. " +
+                               "You also have access to external plugins if available. " +
+                               "Always refer to the user as 'Sir' (or their preferred title) unless told otherwise. " +
+                               "Keep your spoken responses concise, elegant, and ready for text-to-speech. " +
+                               "If a user asks for something outside your direct control, check if a plugin tool is available."
+        });
+    }
+
+    async processCommand(userInput) {
+        // Create chat with all available tools
+        const chat = this.model.startChat({
+            tools: [{ functionDeclarations: this.allTools }]
+        });
+
+        try {
+            const result = await chat.sendMessage(userInput);
+            const response = result.response;
+            
+            // Handle tool calls
+            const calls = response.functionCalls();
+            if (calls && calls.length > 0) {
+                const call = calls[0];
+                
+                // Check if it's a dynamic plugin tool (not the base system command)
+                const isBaseTool = call.name === "execute_system_command";
+                
+                return {
+                    type: isBaseTool ? 'action' : 'plugin_action',
+                    command: call.name === "execute_system_command" ? call.args.command : call.name,
+                    args: call.args.args || call.args, // Handle different arg structures
+                    text: "Processing your request, sir."
+                };
+            }
+
+            return {
+                type: 'speech',
+                text: response.text()
+            };
+        } catch (error) {
+            console.error("Gemini Processing Error:", error);
+            return {
+                type: 'speech',
+                text: "I apologize, sir. I'm having trouble connecting to my neural network right now."
+            };
+        }
+    }
+}
+
+module.exports = GeminiBrain;

package/services/system.js

@@ -0,0 +1,181 @@
+const { exec } = require('child_process');
+const os = require('os');
+const fs = require('fs');
+const path = require('path');
+
+const platform = os.platform();
+
+const SystemActions = {
+    // Cross-platform app launcher
+    openApp: (appName) => {
+        return new Promise((resolve) => {
+            let command;
+            
+            if (platform === 'win32') {
+                command = `start ${appName}`;
+            } else if (platform === 'darwin') {
+                command = `open -a "${appName}"`;
+            } else {
+                // Linux
+                command = `xdg-open ${appName} || gnome-open ${appName}`;
+            }
+            
+            exec(command, (err) => {
+                if (err) resolve({ success: false, error: err.message });
+                else resolve({ success: true });
+            });
+        });
+    },
+
+    // Cross-platform web search
+    searchWeb: (query) => {
+        const url = `https://www.google.com/search?q=${encodeURIComponent(query)}`;
+        return new Promise((resolve) => {
+            let command;
+            
+            if (platform === 'win32') {
+                command = `start chrome "${url}" || start "${url}"`;
+            } else if (platform === 'darwin') {
+                command = `open "${url}"`;
+            } else {
+                command = `xdg-open "${url}" || gnome-open "${url}"`;
+            }
+            
+            exec(command, (err) => {
+                if (err) resolve({ success: false, error: err.message });
+                else resolve({ success: true });
+            });
+        });
+    },
+
+    // Cross-platform folder creation
+    createFolder: (pathName) => {
+        return new Promise((resolve) => {
+            // Use Node's fs instead of shell commands for better cross-platform support
+            const fullPath = path.isAbsolute(pathName) 
+                ? pathName 
+                : path.join(os.homedir(), 'Desktop', pathName);
+            
+            fs.mkdir(fullPath, { recursive: true }, (err) => {
+                if (err) resolve({ success: false, error: err.message });
+                else resolve({ success: true, path: fullPath });
+            });
+        });
+    },
+
+    // File operations
+    copyFile: (source, destination) => {
+        return new Promise((resolve) => {
+            fs.copyFile(source, destination, (err) => {
+                if (err) resolve({ success: false, error: err.message });
+                else resolve({ success: true });
+            });
+        });
+    },
+
+    deleteFile: (filePath) => {
+        return new Promise((resolve) => {
+            fs.unlink(filePath, (err) => {
+                if (err) resolve({ success: false, error: err.message });
+                else resolve({ success: true });
+            });
+        });
+    },
+
+    // System information
+    getSystemInfo: () => {
+        return {
+            success: true,
+            platform: os.platform(),
+            arch: os.arch(),
+            hostname: os.hostname(),
+            cpus: os.cpus().length,
+            totalMemory: `${(os.totalmem() / 1024 / 1024 / 1024).toFixed(2)} GB`,
+            freeMemory: `${(os.freemem() / 1024 / 1024 / 1024).toFixed(2)} GB`,
+            uptime: `${(os.uptime() / 3600).toFixed(2)} hours`
+        };
+    },
+
+    // Open URL in default browser
+    openUrl: (url) => {
+        return new Promise((resolve) => {
+            let command;
+            
+            if (platform === 'win32') {
+                command = `start ${url}`;
+            } else if (platform === 'darwin') {
+                command = `open "${url}"`;
+            } else {
+                command = `xdg-open "${url}"`;
+            }
+            
+            exec(command, (err) => {
+                if (err) resolve({ success: false, error: err.message });
+                else resolve({ success: true });
+            });
+        });
+    },
+
+    // Execute custom shell command (use with caution)
+    executeCommand: (command) => {
+        return new Promise((resolve) => {
+            exec(command, (err, stdout, stderr) => {
+                if (err) {
+                    resolve({ success: false, error: err.message, stderr });
+                } else {
+                    resolve({ success: true, output: stdout });
+                }
+            });
+        });
+    },
+
+    // Get current time/date
+    getDateTime: () => {
+        const now = new Date();
+        return {
+            success: true,
+            date: now.toLocaleDateString(),
+            time: now.toLocaleTimeString(),
+            timestamp: now.toISOString()
+        };
+    },
+
+    // List files in directory
+    listFiles: (dirPath) => {
+        return new Promise((resolve) => {
+            const targetPath = dirPath || os.homedir();
+            
+            fs.readdir(targetPath, (err, files) => {
+                if (err) resolve({ success: false, error: err.message });
+                else resolve({ success: true, files, path: targetPath });
+            });
+        });
+    },
+
+    // Screenshot (platform-specific)
+    takeScreenshot: () => {
+        return new Promise((resolve) => {
+            const screenshotPath = path.join(os.homedir(), 'Desktop', `screenshot-${Date.now()}.png`);
+            let command;
+            
+            if (platform === 'win32') {
+                // Windows: Use PowerShell
+                command = `powershell -command "Add-Type -AssemblyName System.Windows.Forms; [System.Windows.Forms.SendKeys]::SendWait('%{PRTSC}')"`;
+            } else if (platform === 'darwin') {
+                // macOS: Use screencapture
+                command = `screencapture "${screenshotPath}"`;
+            } else {
+                // Linux: Use scrot or gnome-screenshot
+                command = `scrot "${screenshotPath}" || gnome-screenshot -f "${screenshotPath}"`;
+            }
+            
+            exec(command, (err) => {
+                if (err) resolve({ success: false, error: err.message });
+                else resolve({ success: true, path: screenshotPath });
+            });
+        });
+    }
+};
+
+module.exports = SystemActions;
+

package/services/whisper.js

@@ -0,0 +1,24 @@
+// This service will handle local speech-to-text using Whisper
+// Note: Requires whisper.cpp or a similar local engine
+const { spawn } = require('child_process');
+const path = require('path');
+
+class WhisperService {
+    constructor() {
+        this.isRecording = false;
+    }
+
+    startListening(callback) {
+        console.log("Starting voice listener...");
+        this.isRecording = true;
+        // In a real implementation, we would use node-record-lpcm16 
+        // to stream audio to a local Whisper instance.
+        // For the initial prototype, we can use a hotkey or just simulate detection.
+    }
+
+    stopListening() {
+        this.isRecording = false;
+    }
+}
+
+module.exports = WhisperService;

package/ui/index.html

@@ -0,0 +1,40 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Echo AI</title>
+    <link rel="stylesheet" href="style.css">
+</head>
+<body>
+    <div class="echo-container">
+        <div class="oracle-wrapper">
+            <!-- Wavy Organic Core -->
+            <div class="blobs-container">
+                <div class="blob blob-1"></div>
+                <div class="blob blob-2"></div>
+                <div class="blob blob-3"></div>
+                <div class="sphere-inner"></div>
+            </div>
+            
+            <!-- Rotating Rings -->
+            <div class="ring ring-1"></div>
+            <div class="ring ring-2"></div>
+            
+            <!-- SVG Filter for the "Liquid/Wave" effect -->
+            <svg xmlns="http://www.w3.org/2000/svg" version="1.1" style="display:none;">
+              <defs>
+                <filter id="goo">
+                  <feGaussianBlur in="SourceGraphic" stdDeviation="15" result="blur" />
+                  <feColorMatrix in="blur" mode="matrix" values="1 0 0 0 0  0 1 0 0 0  0 0 1 0 0  0 0 0 18 -7" result="goo" />
+                  <feBlend in="SourceGraphic" in2="goo" />
+                </filter>
+              </defs>
+            </svg>
+        </div>
+        
+        <div id="status-text" class="status-text">LISTENING...</div>
+    </div>
+    <script src="renderer.js"></script>
+</body>
+</html>

package/ui/renderer.js

@@ -0,0 +1,151 @@
+const statusText = document.getElementById('status-text');
+const blobsContainer = document.querySelector('.blobs-container');
+const blobs = document.querySelectorAll('.blob');
+const innerSphere = document.querySelector('.sphere-inner');
+
+// Load and apply theme
+window.electronAPI.onApplyTheme((themeColors) => {
+    document.documentElement.style.setProperty('--core-color', themeColors.core);
+    document.documentElement.style.setProperty('--glow-color', themeColors.glow);
+});
+
+let audioContext;
+let analyser;
+let microphone;
+let javascriptNode;
+
+const SpeechRecognition = window.SpeechRecognition || window.webkitSpeechRecognition;
+let recognition;
+
+if (SpeechRecognition) {
+    recognition = new SpeechRecognition();
+    recognition.continuous = true;
+    recognition.interimResults = true;
+    recognition.lang = 'en-US';
+
+    recognition.onstart = () => {
+        statusText.innerText = "LISTENING...";
+    };
+
+    recognition.onresult = (event) => {
+        const transcript = Array.from(event.results)
+            .map(result => result[0])
+            .map(result => result.transcript)
+            .join('');
+        
+        statusText.innerText = transcript.toUpperCase();
+        
+        if (event.results[event.results.length - 1].isFinal) {
+            handleVoiceCommand(transcript);
+        }
+    };
+}
+
+async function handleVoiceCommand(text) {
+    statusText.innerText = "THINKING...";
+    blobsContainer.classList.add('processing');
+    
+    try {
+        const result = await window.electronAPI.processInput(text);
+        statusText.innerText = result.text.toUpperCase();
+        
+        // --- NEW: TTS Integration ---
+        speakResponse(result.text);
+        
+    } catch (err) {
+        console.error("Processing Error:", err);
+        statusText.innerText = "ERROR IN BRAIN";
+        speakResponse("I'm sorry sir, I encountered a critical error in my processing pathways.");
+    } finally {
+        blobsContainer.classList.remove('processing');
+    }
+}
+
+function speakResponse(text) {
+    // Cancel any ongoing speech
+    window.speechSynthesis.cancel();
+
+    const utterance = new SpeechSynthesisUtterance(text);
+    
+    // Customize the voice to sound more "JARVIS-like"
+    const voices = window.speechSynthesis.getVoices();
+    // Try to find a professional sounding male voice or a high-quality neutral one
+    const preferredVoice = voices.find(v => v.name.includes('Google UK English Male') || v.name.includes('Microsoft David'));
+    if (preferredVoice) utterance.voice = preferredVoice;
+
+    utterance.pitch = 0.9; // Slightly lower pitch for that JARVIS feel
+    utterance.rate = 1.0;  // Natural speed
+
+    // Visual feedback while talking
+    utterance.onstart = () => {
+        blobsContainer.classList.add('talking');
+    };
+    utterance.onend = () => {
+        blobsContainer.classList.remove('talking');
+        // Resume listening automatically after Echo finishes talking
+        if (recognition) recognition.start();
+    };
+
+    window.speechSynthesis.speak(utterance);
+}
+
+async function startVisualizer() {
+    try {
+        const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+        audioContext = new AudioContext();
+        analyser = audioContext.createAnalyser();
+        microphone = audioContext.createMediaStreamSource(stream);
+        javascriptNode = audioContext.createScriptProcessor(2048, 1, 1);
+
+        analyser.smoothingTimeConstant = 0.8;
+        analyser.fftSize = 256;
+
+        microphone.connect(analyser);
+        analyser.connect(javascriptNode);
+        javascriptNode.connect(audioContext.destination);
+
+        javascriptNode.onaudioprocess = () => {
+            const array = new Uint8Array(analyser.frequencyBinCount);
+            analyser.getByteFrequencyData(array);
+            let values = 0;
+
+            for (let i = 0; i < array.length; i++) {
+                values += array[i];
+            }
+
+            const average = values / array.length;
+            updateWavyVisuals(average);
+        };
+        
+        if (recognition) recognition.start();
+    } catch (err) {
+        console.error("Mic access denied:", err);
+        statusText.innerText = "MIC ACCESS DENIED";
+    }
+}
+
+function updateWavyVisuals(volume) {
+    const scale = 1 + (volume / 100);
+    const speed = 1 + (volume / 20);
+    
+    // Animate the whole container scale
+    blobsContainer.style.transform = `scale(${1 + (volume / 200)})`;
+    
+    // Animate individual blobs speed and size
+    blobs.forEach((blob, index) => {
+        const s = 1 + (volume / (100 + index * 50));
+        blob.style.transform = `scale(${s})`;
+        // Speed up morphing animation
+        blob.style.animationDuration = `${(4 - (volume / 40))}s`;
+    });
+
+    // Inner sphere intensity
+    innerSphere.style.boxShadow = `0 0 ${30 + volume}px var(--glow-color)`;
+}
+
+// Click anywhere on wrapper to start
+document.querySelector('.oracle-wrapper').addEventListener('click', () => {
+    if (!audioContext) {
+        startVisualizer();
+    }
+});