mani-calc 1.1.0

package/src/integration/windows-search.js

@@ -0,0 +1,126 @@
+const fs = require('fs');
+const path = require('path');
+const { exec } = require('child_process');
+const { promisify } = require('util');
+
+const execAsync = promisify(exec);
+
+class WindowsSearchIntegration {
+    constructor(maniCalc) {
+        this.maniCalc = maniCalc;
+        this.protocolName = 'calc';
+        this.appPath = process.execPath;
+        this.scriptPath = path.join(__dirname, '..', '..', 'bin', 'cli.js');
+    }
+
+    async register() {
+        try {
+            // Register protocol handler for Windows Search
+            await this.registerProtocolHandler();
+
+            // Create search connector
+            await this.createSearchConnector();
+
+            return true;
+        } catch (error) {
+            throw new Error(`Failed to register Windows Search integration: ${error.message}`);
+        }
+    }
+
+    async registerProtocolHandler() {
+        // Create registry entries for custom protocol
+        const regContent = `Windows Registry Editor Version 5.00
+
+[HKEY_CURRENT_USER\\Software\\Classes\\calc]
+@="URL:Mani-Calc Protocol"
+"URL Protocol"=""
+
+[HKEY_CURRENT_USER\\Software\\Classes\\calc\\shell]
+
+[HKEY_CURRENT_USER\\Software\\Classes\\calc\\shell\\open]
+
+[HKEY_CURRENT_USER\\Software\\Classes\\calc\\shell\\open\\command]
+@="\\"${process.execPath}\\" \\"${this.scriptPath}\\" \\"%1\\""
+`;
+
+        const regFile = path.join(process.env.TEMP, 'mani-calc-protocol.reg');
+        fs.writeFileSync(regFile, regContent);
+
+        try {
+            await execAsync(`reg import "${regFile}"`);
+            fs.unlinkSync(regFile);
+        } catch (error) {
+            console.warn('Could not register protocol handler automatically. Manual registration may be required.');
+        }
+    }
+
+    async createSearchConnector() {
+        const connectorPath = path.join(
+            process.env.APPDATA,
+            'Microsoft',
+            'Windows',
+            'Libraries',
+            'ManiCalc.searchConnector-ms'
+        );
+
+        const connectorXml = `<?xml version="1.0" encoding="UTF-8"?>
+<searchConnectorDescription xmlns="http://schemas.microsoft.com/windows/2009/searchConnector">
+    <description>Mani-Calc - Instant Calculator</description>
+    <isSearchOnlyItem>false</isSearchOnlyItem>
+    <includeInStartMenuScope>true</includeInStartMenuScope>
+    <iconReference>shell32.dll,23</iconReference>
+    <templateInfo>
+        <folderType>{5c4f28b5-f869-4e84-8e60-f11db97c5cc7}</folderType>
+    </templateInfo>
+    <simpleLocation>
+        <url>calc:</url>
+    </simpleLocation>
+</searchConnectorDescription>`;
+
+        try {
+            const dir = path.dirname(connectorPath);
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            fs.writeFileSync(connectorPath, connectorXml);
+        } catch (error) {
+            console.warn('Could not create search connector:', error.message);
+        }
+    }
+
+    async unregister() {
+        try {
+            // Remove protocol handler
+            await execAsync('reg delete "HKEY_CURRENT_USER\\Software\\Classes\\calc" /f').catch(() => { });
+
+            // Remove search connector
+            const connectorPath = path.join(
+                process.env.APPDATA,
+                'Microsoft',
+                'Windows',
+                'Libraries',
+                'ManiCalc.searchConnector-ms'
+            );
+
+            if (fs.existsSync(connectorPath)) {
+                fs.unlinkSync(connectorPath);
+            }
+
+            return true;
+        } catch (error) {
+            console.error('Failed to unregister:', error);
+            return false;
+        }
+    }
+
+    parseProtocolUrl(url) {
+        // Parse calc:query format
+        const match = url.match(/^calc:(.+)$/i);
+        if (match) {
+            return decodeURIComponent(match[1]);
+        }
+        return null;
+    }
+}
+
+module.exports = WindowsSearchIntegration;

package/src/ui/floating-search.js

@@ -0,0 +1,228 @@
+const { app, BrowserWindow, globalShortcut, ipcMain } = require('electron');
+const path = require('path');
+
+class FloatingSearchBox {
+    constructor(maniCalc) {
+        this.maniCalc = maniCalc;
+        this.window = null;
+        this.isVisible = false;
+        this.hotkey = 'Alt+Space'; // Default hotkey
+    }
+
+    async initialize() {
+        // Wait for Electron app to be ready
+        if (!app.isReady()) {
+            await app.whenReady();
+        }
+
+        this.createWindow();
+        this.registerHotkey();
+        this.setupIPC();
+    }
+
+    createWindow() {
+        this.window = new BrowserWindow({
+            width: 600,
+            height: 80,
+            frame: false,
+            transparent: true,
+            alwaysOnTop: true,
+            skipTaskbar: true,
+            resizable: false,
+            show: false,
+            webPreferences: {
+                nodeIntegration: true,
+                contextIsolation: false
+            }
+        });
+
+        // Center the window
+        const { screen } = require('electron');
+        const display = screen.getPrimaryDisplay();
+        const { width, height } = display.workAreaSize;
+        const x = Math.floor((width - 600) / 2);
+        const y = Math.floor(height * 0.3); // 30% from top
+
+        this.window.setPosition(x, y);
+
+        // Load the HTML
+        this.window.loadFile(path.join(__dirname, 'overlay.html'));
+
+        // Hide when losing focus
+        this.window.on('blur', () => {
+            if (this.isVisible) {
+                this.hide();
+            }
+        });
+    }
+
+    registerHotkey() {
+        globalShortcut.register(this.hotkey, () => {
+            this.toggle();
+        });
+
+        console.log(`✓ Hotkey registered: ${this.hotkey}`);
+    }
+
+    setupIPC() {
+        // Handle query from renderer
+        ipcMain.on('process-query', async (event, query) => {
+            try {
+                // Check for system commands first
+                const systemResult = await this.handleSystemCommand(query);
+                if (systemResult) {
+                    event.reply('query-result', systemResult);
+                    setTimeout(() => this.hide(), 1000);
+                    return;
+                }
+
+                // Process as calculation
+                const result = await this.maniCalc.processQuery(query);
+                event.reply('query-result', result);
+            } catch (error) {
+                event.reply('query-result', {
+                    error: error.message,
+                    type: 'error'
+                });
+            }
+        });
+
+        // Handle hide request
+        ipcMain.on('hide-window', () => {
+            this.hide();
+        });
+    }
+
+    async handleSystemCommand(query) {
+        const cmd = query.toLowerCase().trim();
+        const { exec } = require('child_process');
+        const { promisify } = require('util');
+        const execAsync = promisify(exec);
+
+        const commands = {
+            '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 () => {
+                    await execAsync('nircmd.exe changesysvolume 2000');
+                    return 'Volume increased';
+                },
+                description: 'Increase volume'
+            },
+            'volume down': {
+                action: async () => {
+                    await execAsync('nircmd.exe changesysvolume -2000');
+                    return 'Volume decreased';
+                },
+                description: 'Decrease volume'
+            },
+            'mute': {
+                action: async () => {
+                    await execAsync('nircmd.exe mutesysvolume 1');
+                    return 'Volume muted';
+                },
+                description: 'Mute volume'
+            },
+            'unmute': {
+                action: async () => {
+                    await execAsync('nircmd.exe mutesysvolume 0');
+                    return 'Volume unmuted';
+                },
+                description: 'Unmute volume'
+            }
+        };
+
+        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) {
+            globalShortcut.unregister(this.hotkey);
+            this.window.close();
+            this.window = null;
+        }
+    }
+}
+
+module.exports = FloatingSearchBox;

package/src/ui/overlay.html

@@ -0,0 +1,254 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Mani-Calc</title>
+  <style>
+    * {
+      margin: 0;
+      padding: 0;
+      box-sizing: border-box;
+    }
+
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif;
+      background: transparent;
+      -webkit-app-region: drag;
+      overflow: hidden;
+    }
+
+    .container {
+      width: 600px;
+      padding: 10px;
+    }
+
+    .search-box {
+      background: rgba(255, 255, 255, 0.95);
+      backdrop-filter: blur(20px);
+      border-radius: 12px;
+      box-shadow: 0 8px 32px rgba(0, 0, 0, 0.3);
+      overflow: hidden;
+      -webkit-app-region: no-drag;
+    }
+
+    .input-container {
+      display: flex;
+      align-items: center;
+      padding: 16px 20px;
+      border-bottom: 1px solid rgba(0, 0, 0, 0.1);
+    }
+
+    .icon {
+      font-size: 24px;
+      margin-right: 12px;
+      color: #00D9FF;
+    }
+
+    #search-input {
+      flex: 1;
+      border: none;
+      outline: none;
+      font-size: 18px;
+      background: transparent;
+      color: #333;
+    }
+
+    #search-input::placeholder {
+      color: #999;
+    }
+
+    .result-container {
+      padding: 12px 20px;
+      background: rgba(0, 217, 255, 0.05);
+      display: none;
+      animation: slideDown 0.2s ease;
+    }
+
+    .result-container.show {
+      display: block;
+    }
+
+    @keyframes slideDown {
+      from {
+        opacity: 0;
+        transform: translateY(-10px);
+      }
+      to {
+        opacity: 1;
+        transform: translateY(0);
+      }
+    }
+
+    .result-text {
+      font-size: 16px;
+      color: #00D9FF;
+      font-weight: 600;
+    }
+
+    .result-text.error {
+      color: #ff4444;
+    }
+
+    .result-text.success {
+      color: #00D9FF;
+    }
+
+    .result-text.system {
+      color: #ff9800;
+    }
+
+    .hint {
+      font-size: 12px;
+      color: #999;
+      margin-top: 4px;
+    }
+
+    .shortcuts {
+      padding: 8px 20px;
+      background: rgba(0, 0, 0, 0.02);
+      display: none;
+      font-size: 11px;
+      color: #666;
+    }
+
+    .shortcuts.show {
+      display: block;
+    }
+
+    .shortcut-item {
+      display: inline-block;
+      margin-right: 12px;
+    }
+
+    .key {
+      background: rgba(0, 0, 0, 0.1);
+      padding: 2px 6px;
+      border-radius: 3px;
+      font-family: monospace;
+    }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <div class="search-box">
+      <div class="input-container">
+        <div class="icon">⚡</div>
+        <input 
+          type="text" 
+          id="search-input" 
+          placeholder="Type calculation or command..."
+          autocomplete="off"
+          spellcheck="false"
+        >
+      </div>
+      
+      <div class="result-container" id="result-container">
+        <div class="result-text" id="result-text"></div>
+        <div class="hint" id="result-hint"></div>
+      </div>
+
+      <div class="shortcuts" id="shortcuts">
+        <span class="shortcut-item"><span class="key">Enter</span> Execute</span>
+        <span class="shortcut-item"><span class="key">Esc</span> Close</span>
+        <span class="shortcut-item"><span class="key">Alt+Space</span> Toggle</span>
+      </div>
+    </div>
+  </div>
+
+  <script>
+    const { ipcRenderer } = require('electron');
+    
+    const input = document.getElementById('search-input');
+    const resultContainer = document.getElementById('result-container');
+    const resultText = document.getElementById('result-text');
+    const resultHint = document.getElementById('result-hint');
+    const shortcuts = document.getElementById('shortcuts');
+
+    let debounceTimer;
+
+    // Focus input when window is shown
+    ipcRenderer.on('focus-input', () => {
+      input.focus();
+      input.select();
+      shortcuts.classList.add('show');
+    });
+
+    // Clear input when window is hidden
+    ipcRenderer.on('clear-input', () => {
+      input.value = '';
+      resultContainer.classList.remove('show');
+      shortcuts.classList.remove('show');
+    });
+
+    // Handle input
+    input.addEventListener('input', (e) => {
+      const query = e.target.value.trim();
+      
+      if (!query) {
+        resultContainer.classList.remove('show');
+        return;
+      }
+
+      // Debounce for live preview
+      clearTimeout(debounceTimer);
+      debounceTimer = setTimeout(() => {
+        processQuery(query, true);
+      }, 300);
+    });
+
+    // Handle Enter key
+    input.addEventListener('keydown', (e) => {
+      if (e.key === 'Enter') {
+        const query = input.value.trim();
+        if (query) {
+          processQuery(query, false);
+        }
+      } else if (e.key === 'Escape') {
+        ipcRenderer.send('hide-window');
+      }
+    });
+
+    // Process query
+    function processQuery(query, isPreview) {
+      if (!isPreview) {
+        ipcRenderer.send('process-query', query);
+      } else {
+        // Show preview for calculations
+        try {
+          // Simple preview for math expressions
+          if (/^[\d\s\+\-\*\/\(\)\.\^]+$/.test(query)) {
+            showResult('Calculating...', 'Press Enter to execute', 'success');
+          }
+        } catch (error) {
+          // Ignore preview errors
+        }
+      }
+    }
+
+    // Handle result from main process
+    ipcRenderer.on('query-result', (event, result) => {
+      if (result.error) {
+        showResult(`✗ ${result.error}`, '', 'error');
+      } else if (result.type === 'system_command') {
+        showResult(`✓ ${result.formatted}`, 'Copied to clipboard', 'system');
+      } else {
+        showResult(`✓ ${result.formatted}`, 'Copied to clipboard', 'success');
+      }
+    });
+
+    // Show result
+    function showResult(text, hint, type) {
+      resultText.textContent = text;
+      resultText.className = `result-text ${type}`;
+      resultHint.textContent = hint;
+      resultContainer.classList.add('show');
+    }
+
+    // Auto-focus on load
+    setTimeout(() => {
+      input.focus();
+    }, 100);
+  </script>
+</body>
+</html>