mani-calc 1.2.1 → 2.1.0

package/src/index.js

@@ -3,6 +3,11 @@ const NLPParser = require('./core/nlp-parser');
 const UnitConverter = require('./core/unit-converter');
 const HistoryManager = require('./core/history-manager');
 const ClipboardManager = require('./core/clipboard-manager');
+const CurrencyConverter = require('./core/currency-converter');
+const DateTimeCalculator = require('./core/date-time-calculator');
+const ProgrammerCalculator = require('./core/programmer-calc');
+const SettingsManager = require('./core/settings-manager');
+const UtilitiesModule = require('./core/utilities');
 const WindowsSearchIntegration = require('./integration/windows-search');
 const chalk = require('chalk');
 
@@ -13,22 +18,30 @@ class ManiCalc {
     this.unitConverter = new UnitConverter();
     this.historyManager = new HistoryManager();
     this.clipboardManager = new ClipboardManager();
+    this.currencyConverter = new CurrencyConverter();
+    this.dateTimeCalculator = new DateTimeCalculator();
+    this.programmerCalculator = new ProgrammerCalculator();
+    this.settingsManager = new SettingsManager();
+    this.utilities = new UtilitiesModule();
     this.windowsSearch = new WindowsSearchIntegration(this);
   }
 
   async initialize() {
     console.log(chalk.cyan('🚀 Mani-Calc initializing...'));
-    
+
     try {
       await this.windowsSearch.register();
       console.log(chalk.green('✓ Windows Search integration registered'));
       console.log(chalk.yellow('\n📝 You can now use mani-calc directly from Windows Search!'));
       console.log(chalk.gray('   Examples:'));
       console.log(chalk.gray('   - calc: 2 + 3 * 5'));
-      console.log(chalk.gray('   - calc: what is 25 percent of 200'));
+      console.log(chalk.gray('   - calc: 100 USD to INR'));
+      console.log(chalk.gray('   - calc: time in tokyo'));
+      console.log(chalk.gray('   - calc: today + 30 days'));
+      console.log(chalk.gray('   - calc: 255 to hex'));
       console.log(chalk.gray('   - calc: 10 km to miles'));
       console.log(chalk.gray('   - calc: history\n'));
-      
+
       return true;
     } catch (error) {
       console.error(chalk.red('✗ Failed to initialize:'), error.message);
@@ -38,68 +51,175 @@ class ManiCalc {
 
   async processQuery(query) {
     try {
+      const lowerQuery = query.toLowerCase().trim();
+
       // Check for special commands
-      if (query.toLowerCase().trim() === 'history') {
+      if (lowerQuery === 'history') {
         return this.historyManager.getHistory();
       }
 
-      if (query.toLowerCase().trim() === 'clear history') {
+      if (lowerQuery === 'clear history') {
         this.historyManager.clearHistory();
-        return { result: 'History cleared', type: 'info' };
+        return { result: 'History cleared', type: 'info', formatted: 'History cleared' };
+      }
+
+      // Check for settings commands
+      if (lowerQuery === 'settings' || lowerQuery === 'config') {
+        const settings = this.settingsManager.getAll();
+        return {
+          result: settings,
+          type: 'settings',
+          formatted: `Theme: ${settings.theme}, Hotkey: ${settings.hotkey}, Auto-start: ${settings.autoStart}`
+        };
+      }
+
+      // Check for theme commands
+      if (lowerQuery.startsWith('theme ') || lowerQuery === 'themes') {
+        if (lowerQuery === 'themes') {
+          const themes = this.settingsManager.getThemes();
+          return {
+            result: themes.map(t => t.name).join(', '),
+            type: 'info',
+            formatted: `Available themes: ${themes.map(t => t.id).join(', ')}`
+          };
+        }
+        const themeId = lowerQuery.replace('theme ', '').trim();
+        const theme = this.settingsManager.setTheme(themeId);
+        if (theme) {
+          return {
+            result: theme.name,
+            type: 'theme',
+            themeId: theme.id,
+            formatted: `Theme changed to: ${theme.name}`
+          };
+        }
+      }
+
+      // Check for auto-start command
+      if (lowerQuery === 'autostart on' || lowerQuery === 'auto start on') {
+        const result = await this.settingsManager.setAutoStart(true);
+        return { result: result.message, type: 'info', formatted: result.message };
+      }
+      if (lowerQuery === 'autostart off' || lowerQuery === 'auto start off') {
+        const result = await this.settingsManager.setAutoStart(false);
+        return { result: result.message, type: 'info', formatted: result.message };
+      }
+
+      // Try currency conversion: "100 USD to INR", "100 dollars to rupees"
+      const currencyResult = await this.tryCurrencyConversion(query);
+      if (currencyResult) {
+        this.historyManager.addEntry(currencyResult);
+        await this.clipboardManager.copy(currencyResult.result.toString());
+        return currencyResult;
+      }
+
+      // Try date/time calculation
+      const dateTimeResult = this.dateTimeCalculator.parse(query);
+      if (dateTimeResult && !dateTimeResult.error) {
+        const response = {
+          query,
+          result: dateTimeResult.result,
+          type: dateTimeResult.type,
+          formatted: dateTimeResult.formatted
+        };
+        this.historyManager.addEntry(response);
+        await this.clipboardManager.copy(dateTimeResult.result.toString());
+        return response;
+      }
+
+      // Try programmer calculation
+      const programmerResult = this.programmerCalculator.parse(query);
+      if (programmerResult && !programmerResult.error) {
+        const response = {
+          query,
+          result: programmerResult.result,
+          type: 'programmer',
+          formatted: programmerResult.formatted,
+          conversions: programmerResult.conversions
+        };
+        this.historyManager.addEntry(response);
+        await this.clipboardManager.copy(programmerResult.result.toString());
+        return response;
       }
 
-      // Try natural language parsing first
+      // Try utilities (password, random, color, text, emoji, search)
+      const utilityResult = this.utilities.parse(query);
+      if (utilityResult) {
+        // Handle web search - open browser
+        if (utilityResult.type === 'search' && utilityResult.url) {
+          const { exec } = require('child_process');
+          exec(`start "" "${utilityResult.url}"`);
+          return {
+            query,
+            result: utilityResult.result,
+            type: 'search',
+            formatted: utilityResult.formatted
+          };
+        }
+
+        const response = {
+          query,
+          result: utilityResult.result,
+          type: utilityResult.type,
+          formatted: utilityResult.formatted
+        };
+        this.historyManager.addEntry(response);
+        await this.clipboardManager.copy(utilityResult.result.toString());
+        return response;
+      }
+
+      // Try natural language parsing
       const nlpResult = this.nlpParser.parse(query);
-      
+
       if (nlpResult.type === 'conversion') {
         const result = this.unitConverter.convert(
           nlpResult.value,
           nlpResult.fromUnit,
           nlpResult.toUnit
         );
-        
+
         const response = {
           query,
           result,
           type: 'conversion',
           formatted: `${nlpResult.value} ${nlpResult.fromUnit} = ${result} ${nlpResult.toUnit}`
         };
-        
+
         this.historyManager.addEntry(response);
         await this.clipboardManager.copy(result.toString());
-        
+
         return response;
       }
 
       if (nlpResult.type === 'natural_language') {
         const mathResult = this.mathEngine.evaluate(nlpResult.expression);
-        
+
         const response = {
           query,
           result: mathResult,
           type: 'natural_language',
           formatted: `${query} = ${mathResult}`
         };
-        
+
         this.historyManager.addEntry(response);
         await this.clipboardManager.copy(mathResult.toString());
-        
+
         return response;
       }
 
       // Direct math evaluation
       const mathResult = this.mathEngine.evaluate(query);
-      
+
       const response = {
         query,
         result: mathResult,
         type: 'math',
         formatted: `${query} = ${mathResult}`
       };
-      
+
       this.historyManager.addEntry(response);
       await this.clipboardManager.copy(mathResult.toString());
-      
+
       return response;
 
     } catch (error) {
@@ -112,6 +232,43 @@ class ManiCalc {
     }
   }
 
+  /**
+   * Try to parse as currency conversion
+   */
+  async tryCurrencyConversion(query) {
+    // Pattern: "100 USD to INR", "100 dollars to rupees", "$100 to euros"
+    const patterns = [
+      /^(\d+(?:\.\d+)?)\s*([a-zA-Z$€£¥₹]+)\s+(?:to|in|=)\s+([a-zA-Z$€£¥₹]+)$/i,
+      /^convert\s+(\d+(?:\.\d+)?)\s*([a-zA-Z$€£¥₹]+)\s+to\s+([a-zA-Z$€£¥₹]+)$/i
+    ];
+
+    for (const pattern of patterns) {
+      const match = query.match(pattern);
+      if (match) {
+        try {
+          const amount = parseFloat(match[1]);
+          const fromCurrency = match[2];
+          const toCurrency = match[3];
+
+          const conversion = await this.currencyConverter.convert(amount, fromCurrency, toCurrency);
+
+          return {
+            query,
+            result: conversion.result,
+            type: 'currency',
+            formatted: this.currencyConverter.formatResult(conversion),
+            rate: conversion.rate
+          };
+        } catch (error) {
+          // Not a valid currency conversion
+          return null;
+        }
+      }
+    }
+
+    return null;
+  }
+
   async shutdown() {
     console.log(chalk.cyan('👋 Mani-Calc shutting down...'));
     await this.windowsSearch.unregister();

package/src/ui/floating-search.js

@@ -74,7 +74,13 @@ class FloatingSearchBox {
                 if (systemResult) {
                     console.log('System command executed:', systemResult);
                     event.reply('query-result', systemResult);
-                    setTimeout(() => this.hide(), 1000);
+                    // Don't auto-hide for info commands like 'help' - let user read the content
+                    // Only auto-hide for action commands that perform an action (sleep, lock, etc.)
+                    const actionCommands = ['sleep', 'shutdown', 'restart', 'lock', 'logout', 'quit', 'exit'];
+                    const cmd = query.toLowerCase().trim();
+                    if (actionCommands.includes(cmd)) {
+                        setTimeout(() => this.hide(), 1500);
+                    }
                     return;
                 }
 
@@ -96,9 +102,344 @@ class FloatingSearchBox {
         ipcMain.on('hide-window', () => {
             this.hide();
         });
+
+        // Handle resize request
+        ipcMain.on('resize-window', (event, height) => {
+            if (this.window) {
+                this.window.setSize(600, height);
+            }
+        });
     }
 
-    // ... (rest of methods) ...
+    async handleSystemCommand(query) {
+        const cmd = query.toLowerCase().trim();
+        const { exec } = require('child_process');
+        const { promisify } = require('util');
+        const execAsync = promisify(exec);
+
+        const commands = {
+            'help': {
+                action: async () => {
+                    return `📊 MATH: 2+3, sqrt(16), 15% of 200
+💱 CURRENCY: 100 USD to INR, 50 euros to dollars
+📅 DATE/TIME: time in tokyo, today + 30 days
+💻 PROGRAMMER: 255 to hex, 0xFF to decimal
+📏 UNITS: 10 km to miles, 100 kg to pounds
+🔐 PASSWORD: password, password 16
+🎲 RANDOM: random, dice, coin, uuid
+🎨 COLOR: #FF5733 to rgb, rgb(255,0,0) to hex
+📝 TEXT: upper hello, lower HELLO, count text
+😀 EMOJI: emoji happy, emoji heart
+🔒 HASH: md5 hello, sha256 hello
+🔤 BASE64: base64 encode/decode text
+🔍 SEARCH: google AI, youtube music, wiki topic
+⚙️ SYSTEM: sleep, lock, mute, screenshot, battery
+🎨 THEMES: theme dark, theme neon, themes
+⚡ SETTINGS: autostart on/off, settings, history`;
+                },
+                description: 'Show available commands'
+            },
+            'quit': {
+                action: async () => {
+                    setTimeout(() => app.quit(), 500);
+                    return 'Quitting Mani-Calc...';
+                },
+                description: 'Quit application'
+            },
+            'exit': {
+                action: async () => {
+                    setTimeout(() => app.quit(), 500);
+                    return 'Quitting Mani-Calc...';
+                },
+                description: 'Quit application'
+            },
+            'theme': {
+                action: async () => {
+                    this.window.webContents.send('toggle-theme');
+                    return 'Toggled theme';
+                },
+                description: 'Toggle Light/Dark mode'
+            },
+            'sleep': {
+                action: async () => {
+                    await execAsync('rundll32.exe powrprof.dll,SetSuspendState 0,1,0');
+                    return 'System going to sleep...';
+                },
+                description: 'Put computer to sleep'
+            },
+            'shutdown': {
+                action: async () => {
+                    await execAsync('shutdown /s /t 0');
+                    return 'Shutting down...';
+                },
+                description: 'Shutdown computer'
+            },
+            'restart': {
+                action: async () => {
+                    await execAsync('shutdown /r /t 0');
+                    return 'Restarting...';
+                },
+                description: 'Restart computer'
+            },
+            'lock': {
+                action: async () => {
+                    await execAsync('rundll32.exe user32.dll,LockWorkStation');
+                    return 'Locking computer...';
+                },
+                description: 'Lock computer'
+            },
+            'logout': {
+                action: async () => {
+                    await execAsync('shutdown /l');
+                    return 'Logging out...';
+                },
+                description: 'Log out current user'
+            },
+            'empty recycle bin': {
+                action: async () => {
+                    await execAsync('rd /s /q %systemdrive%\\$Recycle.bin');
+                    return 'Recycle bin emptied';
+                },
+                description: 'Empty recycle bin'
+            },
+            'volume up': {
+                action: async () => {
+                    // Use PowerShell to simulate volume up key press
+                    await execAsync('powershell -Command "(New-Object -ComObject WScript.Shell).SendKeys([char]175)"');
+                    return 'Volume increased';
+                },
+                description: 'Increase volume'
+            },
+            'volume down': {
+                action: async () => {
+                    // Use PowerShell to simulate volume down key press
+                    await execAsync('powershell -Command "(New-Object -ComObject WScript.Shell).SendKeys([char]174)"');
+                    return 'Volume decreased';
+                },
+                description: 'Decrease volume'
+            },
+            'mute': {
+                action: async () => {
+                    // Use PowerShell to simulate mute key press
+                    await execAsync('powershell -Command "(New-Object -ComObject WScript.Shell).SendKeys([char]173)"');
+                    return 'Volume muted/unmuted';
+                },
+                description: 'Toggle mute'
+            },
+            'unmute': {
+                action: async () => {
+                    // Same as mute - it's a toggle
+                    await execAsync('powershell -Command "(New-Object -ComObject WScript.Shell).SendKeys([char]173)"');
+                    return 'Volume muted/unmuted';
+                },
+                description: 'Toggle mute'
+            },
+            // Screenshot
+            'screenshot': {
+                action: async () => {
+                    await execAsync('snippingtool');
+                    return 'Opening Snipping Tool...';
+                },
+                description: 'Take a screenshot'
+            },
+            'snip': {
+                action: async () => {
+                    await execAsync('snippingtool');
+                    return 'Opening Snipping Tool...';
+                },
+                description: 'Take a screenshot'
+            },
+            // Brightness controls
+            'brightness up': {
+                action: async () => {
+                    await execAsync('powershell -Command "(Get-WmiObject -Namespace root/WMI -Class WmiMonitorBrightnessMethods).WmiSetBrightness(1, [Math]::Min(100, (Get-WmiObject -Namespace root/WMI -Class WmiMonitorBrightness).CurrentBrightness + 10))"');
+                    return 'Brightness increased';
+                },
+                description: 'Increase screen brightness'
+            },
+            'brightness down': {
+                action: async () => {
+                    await execAsync('powershell -Command "(Get-WmiObject -Namespace root/WMI -Class WmiMonitorBrightnessMethods).WmiSetBrightness(1, [Math]::Max(0, (Get-WmiObject -Namespace root/WMI -Class WmiMonitorBrightness).CurrentBrightness - 10))"');
+                    return 'Brightness decreased';
+                },
+                description: 'Decrease screen brightness'
+            },
+            // WiFi toggle
+            'wifi on': {
+                action: async () => {
+                    await execAsync('netsh interface set interface "Wi-Fi" enable');
+                    return 'WiFi enabled';
+                },
+                description: 'Enable WiFi'
+            },
+            'wifi off': {
+                action: async () => {
+                    await execAsync('netsh interface set interface "Wi-Fi" disable');
+                    return 'WiFi disabled';
+                },
+                description: 'Disable WiFi'
+            },
+            // Bluetooth toggle
+            'bluetooth on': {
+                action: async () => {
+                    await execAsync('powershell -Command "Start-Service bthserv"');
+                    return 'Bluetooth service started';
+                },
+                description: 'Enable Bluetooth'
+            },
+            'bluetooth off': {
+                action: async () => {
+                    await execAsync('powershell -Command "Stop-Service bthserv"');
+                    return 'Bluetooth service stopped';
+                },
+                description: 'Disable Bluetooth'
+            },
+            // Quick app launchers
+            'notepad': {
+                action: async () => {
+                    await execAsync('notepad');
+                    return 'Opening Notepad...';
+                },
+                description: 'Open Notepad'
+            },
+            'calculator': {
+                action: async () => {
+                    await execAsync('calc');
+                    return 'Opening Calculator...';
+                },
+                description: 'Open Windows Calculator'
+            },
+            'calc app': {
+                action: async () => {
+                    await execAsync('calc');
+                    return 'Opening Calculator...';
+                },
+                description: 'Open Windows Calculator'
+            },
+            'explorer': {
+                action: async () => {
+                    await execAsync('explorer');
+                    return 'Opening File Explorer...';
+                },
+                description: 'Open File Explorer'
+            },
+            'files': {
+                action: async () => {
+                    await execAsync('explorer');
+                    return 'Opening File Explorer...';
+                },
+                description: 'Open File Explorer'
+            },
+            'task manager': {
+                action: async () => {
+                    await execAsync('taskmgr');
+                    return 'Opening Task Manager...';
+                },
+                description: 'Open Task Manager'
+            },
+            'taskmgr': {
+                action: async () => {
+                    await execAsync('taskmgr');
+                    return 'Opening Task Manager...';
+                },
+                description: 'Open Task Manager'
+            },
+            'control panel': {
+                action: async () => {
+                    await execAsync('control');
+                    return 'Opening Control Panel...';
+                },
+                description: 'Open Control Panel'
+            },
+            'settings app': {
+                action: async () => {
+                    await execAsync('start ms-settings:');
+                    return 'Opening Windows Settings...';
+                },
+                description: 'Open Windows Settings'
+            },
+            'cmd': {
+                action: async () => {
+                    await execAsync('start cmd');
+                    return 'Opening Command Prompt...';
+                },
+                description: 'Open Command Prompt'
+            },
+            'powershell': {
+                action: async () => {
+                    await execAsync('start powershell');
+                    return 'Opening PowerShell...';
+                },
+                description: 'Open PowerShell'
+            },
+            'browser': {
+                action: async () => {
+                    await execAsync('start chrome || start msedge || start firefox');
+                    return 'Opening Browser...';
+                },
+                description: 'Open default browser'
+            },
+            // System info
+            'ip': {
+                action: async () => {
+                    const { stdout } = await execAsync('powershell -Command "(Get-NetIPAddress -AddressFamily IPv4 | Where-Object {$_.InterfaceAlias -notlike \'*Loopback*\'} | Select-Object -First 1).IPAddress"');
+                    return `Your IP: ${stdout.trim()}`;
+                },
+                description: 'Show IP address'
+            },
+            'battery': {
+                action: async () => {
+                    const { stdout } = await execAsync('powershell -Command "(Get-WmiObject Win32_Battery).EstimatedChargeRemaining"');
+                    const percent = stdout.trim();
+                    return `🔋 Battery: ${percent}%`;
+                },
+                description: 'Show battery level'
+            }
+        };
+
+        if (commands[cmd]) {
+            try {
+                const message = await commands[cmd].action();
+                return {
+                    result: message,
+                    type: 'system_command',
+                    formatted: message
+                };
+            } catch (error) {
+                return {
+                    error: `Failed to execute: ${error.message}`,
+                    type: 'error'
+                };
+            }
+        }
+
+        return null;
+    }
+
+    show() {
+        if (this.window) {
+            this.window.show();
+            this.window.focus();
+            this.isVisible = true;
+            this.window.webContents.send('focus-input');
+        }
+    }
+
+    hide() {
+        if (this.window) {
+            this.window.hide();
+            this.isVisible = false;
+            this.window.webContents.send('clear-input');
+        }
+    }
+
+    toggle() {
+        if (this.isVisible) {
+            this.hide();
+        } else {
+            this.show();
+        }
+    }
 
     destroy() {
         if (this.window) {