mani-calc 1.1.0

package/src/core/history-manager.js

@@ -0,0 +1,141 @@
+const fs = require('fs');
+const path = require('path');
+
+class HistoryManager {
+    constructor() {
+        this.historyFile = path.join(process.env.APPDATA || process.env.HOME, 'mani-calc', 'history.json');
+        this.maxEntries = 100;
+        this.ensureHistoryFile();
+    }
+
+    ensureHistoryFile() {
+        const dir = path.dirname(this.historyFile);
+
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+
+        if (!fs.existsSync(this.historyFile)) {
+            fs.writeFileSync(this.historyFile, JSON.stringify([], null, 2));
+        }
+    }
+
+    addEntry(entry) {
+        try {
+            const history = this.loadHistory();
+
+            const newEntry = {
+                ...entry,
+                timestamp: new Date().toISOString(),
+                id: Date.now()
+            };
+
+            history.unshift(newEntry);
+
+            // Keep only the most recent entries
+            if (history.length > this.maxEntries) {
+                history.splice(this.maxEntries);
+            }
+
+            this.saveHistory(history);
+
+            return newEntry;
+        } catch (error) {
+            console.error('Failed to add history entry:', error);
+        }
+    }
+
+    getHistory(limit = 10) {
+        try {
+            const history = this.loadHistory();
+            return {
+                type: 'history',
+                entries: history.slice(0, limit),
+                total: history.length,
+                formatted: this.formatHistory(history.slice(0, limit))
+            };
+        } catch (error) {
+            console.error('Failed to get history:', error);
+            return {
+                type: 'history',
+                entries: [],
+                total: 0,
+                formatted: 'No history available'
+            };
+        }
+    }
+
+    formatHistory(entries) {
+        if (entries.length === 0) {
+            return 'No calculation history yet';
+        }
+
+        let formatted = 'Recent Calculations:\n\n';
+
+        entries.forEach((entry, index) => {
+            const date = new Date(entry.timestamp);
+            const timeStr = date.toLocaleTimeString('en-US', {
+                hour: '2-digit',
+                minute: '2-digit'
+            });
+
+            formatted += `${index + 1}. ${entry.formatted} (${timeStr})\n`;
+        });
+
+        return formatted;
+    }
+
+    clearHistory() {
+        try {
+            this.saveHistory([]);
+            return true;
+        } catch (error) {
+            console.error('Failed to clear history:', error);
+            return false;
+        }
+    }
+
+    loadHistory() {
+        try {
+            const data = fs.readFileSync(this.historyFile, 'utf8');
+            return JSON.parse(data);
+        } catch (error) {
+            return [];
+        }
+    }
+
+    saveHistory(history) {
+        try {
+            fs.writeFileSync(this.historyFile, JSON.stringify(history, null, 2));
+        } catch (error) {
+            console.error('Failed to save history:', error);
+        }
+    }
+
+    searchHistory(query) {
+        try {
+            const history = this.loadHistory();
+            const results = history.filter(entry =>
+                entry.query.toLowerCase().includes(query.toLowerCase()) ||
+                entry.formatted.toLowerCase().includes(query.toLowerCase())
+            );
+
+            return {
+                type: 'search',
+                query,
+                results,
+                formatted: this.formatHistory(results)
+            };
+        } catch (error) {
+            console.error('Failed to search history:', error);
+            return {
+                type: 'search',
+                query,
+                results: [],
+                formatted: 'Search failed'
+            };
+        }
+    }
+}
+
+module.exports = HistoryManager;

package/src/core/math-engine.js

@@ -0,0 +1,95 @@
+const math = require('mathjs');
+
+class MathEngine {
+    constructor() {
+        // Configure mathjs for better precision and functionality
+        this.parser = math.parser();
+
+        // Add custom functions
+        this.addCustomFunctions();
+    }
+
+    addCustomFunctions() {
+        // Add percentage calculation
+        this.parser.set('percent', (value, total) => {
+            return (value / 100) * total;
+        });
+
+        // Add common shortcuts
+        this.parser.set('half', (value) => value / 2);
+        this.parser.set('double', (value) => value * 2);
+        this.parser.set('triple', (value) => value * 3);
+    }
+
+    evaluate(expression) {
+        try {
+            // Clean the expression
+            const cleanExpression = this.cleanExpression(expression);
+
+            // Evaluate using mathjs
+            const result = this.parser.evaluate(cleanExpression);
+
+            // Format the result
+            return this.formatResult(result);
+        } catch (error) {
+            throw new Error(`Invalid expression: ${error.message}`);
+        }
+    }
+
+    cleanExpression(expr) {
+        // Remove common prefixes
+        expr = expr.replace(/^(calc:|calculate:|=)\s*/i, '');
+
+        // Replace common words with operators
+        expr = expr.replace(/\s+plus\s+/gi, ' + ');
+        expr = expr.replace(/\s+minus\s+/gi, ' - ');
+        expr = expr.replace(/\s+times\s+/gi, ' * ');
+        expr = expr.replace(/\s+divided by\s+/gi, ' / ');
+        expr = expr.replace(/\s+multiplied by\s+/gi, ' * ');
+
+        // Handle implicit multiplication (e.g., "2(3+4)" -> "2*(3+4)")
+        expr = expr.replace(/(\d)\(/g, '$1*(');
+
+        return expr.trim();
+    }
+
+    formatResult(result) {
+        // Handle complex numbers
+        if (typeof result === 'object' && result.im !== undefined) {
+            return result.toString();
+        }
+
+        // Handle arrays/matrices
+        if (Array.isArray(result)) {
+            return JSON.stringify(result);
+        }
+
+        // Handle regular numbers
+        if (typeof result === 'number') {
+            // Round to reasonable precision
+            if (Math.abs(result) < 1e-10) return 0;
+            if (Math.abs(result - Math.round(result)) < 1e-10) {
+                return Math.round(result);
+            }
+            return Math.round(result * 1e10) / 1e10;
+        }
+
+        return result;
+    }
+
+    // Store variables for session
+    setVariable(name, value) {
+        this.parser.set(name, value);
+    }
+
+    getVariable(name) {
+        return this.parser.get(name);
+    }
+
+    clearVariables() {
+        this.parser.clear();
+        this.addCustomFunctions();
+    }
+}
+
+module.exports = MathEngine;

package/src/core/nlp-parser.js

@@ -0,0 +1,146 @@
+class NLPParser {
+    constructor() {
+        this.patterns = this.initializePatterns();
+    }
+
+    initializePatterns() {
+        return {
+            // Percentage patterns
+            percentage: [
+                /what is (\d+\.?\d*)\s*(?:percent|%)\s*of\s*(\d+\.?\d*)/i,
+                /(\d+\.?\d*)\s*(?:percent|%)\s*of\s*(\d+\.?\d*)/i,
+                /calculate (\d+\.?\d*)\s*(?:percent|%)\s*of\s*(\d+\.?\d*)/i
+            ],
+
+            // Fraction patterns
+            fraction: [
+                /(half|quarter|third)\s*of\s*(\d+\.?\d*)/i,
+                /(\d+\.?\d*)\s*(?:divided|split)\s*(?:by|into)\s*(\d+)/i
+            ],
+
+            // Square root patterns
+            squareRoot: [
+                /(?:square root|sqrt)\s*(?:of\s*)?(\d+\.?\d*)/i,
+                /√(\d+\.?\d*)/
+            ],
+
+            // Power patterns
+            power: [
+                /(\d+\.?\d*)\s*(?:to the power of|raised to|power)\s*(\d+\.?\d*)/i,
+                /(\d+\.?\d*)\s*(?:squared|²)/i,
+                /(\d+\.?\d*)\s*(?:cubed|³)/i
+            ],
+
+            // Conversion patterns (handled separately)
+            conversion: [
+                /(\d+\.?\d*)\s*([a-z]+)\s*(?:to|in|as)\s*([a-z]+)/i
+            ]
+        };
+    }
+
+    parse(query) {
+        const cleanQuery = query.trim();
+
+        // Check for percentage
+        for (const pattern of this.patterns.percentage) {
+            const match = cleanQuery.match(pattern);
+            if (match) {
+                const percentage = parseFloat(match[1]);
+                const total = parseFloat(match[2]);
+                return {
+                    type: 'natural_language',
+                    expression: `(${percentage} / 100) * ${total}`,
+                    original: cleanQuery
+                };
+            }
+        }
+
+        // Check for fractions
+        for (const pattern of this.patterns.fraction) {
+            const match = cleanQuery.match(pattern);
+            if (match) {
+                const fractionMap = {
+                    'half': 2,
+                    'quarter': 4,
+                    'third': 3
+                };
+
+                if (match[1].toLowerCase() in fractionMap) {
+                    const divisor = fractionMap[match[1].toLowerCase()];
+                    const value = parseFloat(match[2]);
+                    return {
+                        type: 'natural_language',
+                        expression: `${value} / ${divisor}`,
+                        original: cleanQuery
+                    };
+                }
+            }
+        }
+
+        // Check for square root
+        for (const pattern of this.patterns.squareRoot) {
+            const match = cleanQuery.match(pattern);
+            if (match) {
+                const value = parseFloat(match[1]);
+                return {
+                    type: 'natural_language',
+                    expression: `sqrt(${value})`,
+                    original: cleanQuery
+                };
+            }
+        }
+
+        // Check for power
+        for (const pattern of this.patterns.power) {
+            const match = cleanQuery.match(pattern);
+            if (match) {
+                if (cleanQuery.includes('squared') || cleanQuery.includes('²')) {
+                    const value = parseFloat(match[1]);
+                    return {
+                        type: 'natural_language',
+                        expression: `${value}^2`,
+                        original: cleanQuery
+                    };
+                }
+                if (cleanQuery.includes('cubed') || cleanQuery.includes('³')) {
+                    const value = parseFloat(match[1]);
+                    return {
+                        type: 'natural_language',
+                        expression: `${value}^3`,
+                        original: cleanQuery
+                    };
+                }
+                const base = parseFloat(match[1]);
+                const exponent = parseFloat(match[2]);
+                return {
+                    type: 'natural_language',
+                    expression: `${base}^${exponent}`,
+                    original: cleanQuery
+                };
+            }
+        }
+
+        // Check for conversion
+        for (const pattern of this.patterns.conversion) {
+            const match = cleanQuery.match(pattern);
+            if (match) {
+                return {
+                    type: 'conversion',
+                    value: parseFloat(match[1]),
+                    fromUnit: match[2].toLowerCase(),
+                    toUnit: match[3].toLowerCase(),
+                    original: cleanQuery
+                };
+            }
+        }
+
+        // No pattern matched, return as direct expression
+        return {
+            type: 'direct',
+            expression: cleanQuery,
+            original: cleanQuery
+        };
+    }
+}
+
+module.exports = NLPParser;

package/src/core/unit-converter.js

@@ -0,0 +1,208 @@
+class UnitConverter {
+    constructor() {
+        this.conversions = this.initializeConversions();
+    }
+
+    initializeConversions() {
+        return {
+            // Length conversions (base: meters)
+            length: {
+                m: 1,
+                meter: 1,
+                meters: 1,
+                km: 1000,
+                kilometer: 1000,
+                kilometers: 1000,
+                cm: 0.01,
+                centimeter: 0.01,
+                centimeters: 0.01,
+                mm: 0.001,
+                millimeter: 0.001,
+                millimeters: 0.001,
+                mile: 1609.34,
+                miles: 1609.34,
+                yard: 0.9144,
+                yards: 0.9144,
+                foot: 0.3048,
+                feet: 0.3048,
+                ft: 0.3048,
+                inch: 0.0254,
+                inches: 0.0254,
+                in: 0.0254
+            },
+
+            // Weight conversions (base: kilograms)
+            weight: {
+                kg: 1,
+                kilogram: 1,
+                kilograms: 1,
+                g: 0.001,
+                gram: 0.001,
+                grams: 0.001,
+                mg: 0.000001,
+                milligram: 0.000001,
+                milligrams: 0.000001,
+                lb: 0.453592,
+                lbs: 0.453592,
+                pound: 0.453592,
+                pounds: 0.453592,
+                oz: 0.0283495,
+                ounce: 0.0283495,
+                ounces: 0.0283495,
+                ton: 1000,
+                tons: 1000,
+                tonne: 1000,
+                tonnes: 1000
+            },
+
+            // Temperature conversions (special handling)
+            temperature: {
+                celsius: 'C',
+                c: 'C',
+                fahrenheit: 'F',
+                f: 'F',
+                kelvin: 'K',
+                k: 'K'
+            },
+
+            // Volume conversions (base: liters)
+            volume: {
+                l: 1,
+                liter: 1,
+                liters: 1,
+                ml: 0.001,
+                milliliter: 0.001,
+                milliliters: 0.001,
+                gallon: 3.78541,
+                gallons: 3.78541,
+                gal: 3.78541,
+                quart: 0.946353,
+                quarts: 0.946353,
+                qt: 0.946353,
+                pint: 0.473176,
+                pints: 0.473176,
+                pt: 0.473176,
+                cup: 0.236588,
+                cups: 0.236588,
+                floz: 0.0295735,
+                'fluid ounce': 0.0295735,
+                'fluid ounces': 0.0295735
+            },
+
+            // Time conversions (base: seconds)
+            time: {
+                s: 1,
+                sec: 1,
+                second: 1,
+                seconds: 1,
+                min: 60,
+                minute: 60,
+                minutes: 60,
+                h: 3600,
+                hr: 3600,
+                hour: 3600,
+                hours: 3600,
+                day: 86400,
+                days: 86400,
+                week: 604800,
+                weeks: 604800,
+                month: 2592000,
+                months: 2592000,
+                year: 31536000,
+                years: 31536000
+            },
+
+            // Speed conversions (base: m/s)
+            speed: {
+                'm/s': 1,
+                'km/h': 0.277778,
+                'mph': 0.44704,
+                'ft/s': 0.3048,
+                knot: 0.514444,
+                knots: 0.514444
+            }
+        };
+    }
+
+    convert(value, fromUnit, toUnit) {
+        fromUnit = fromUnit.toLowerCase();
+        toUnit = toUnit.toLowerCase();
+
+        // Find which category the units belong to
+        const category = this.findCategory(fromUnit, toUnit);
+
+        if (!category) {
+            throw new Error(`Cannot convert from ${fromUnit} to ${toUnit}`);
+        }
+
+        // Special handling for temperature
+        if (category === 'temperature') {
+            return this.convertTemperature(value, fromUnit, toUnit);
+        }
+
+        // Standard conversion
+        const conversions = this.conversions[category];
+
+        if (!conversions[fromUnit] || !conversions[toUnit]) {
+            throw new Error(`Unknown unit in conversion: ${fromUnit} or ${toUnit}`);
+        }
+
+        // Convert to base unit, then to target unit
+        const baseValue = value * conversions[fromUnit];
+        const result = baseValue / conversions[toUnit];
+
+        return this.formatResult(result);
+    }
+
+    findCategory(fromUnit, toUnit) {
+        for (const [category, units] of Object.entries(this.conversions)) {
+            if (units[fromUnit] !== undefined && units[toUnit] !== undefined) {
+                return category;
+            }
+        }
+        return null;
+    }
+
+    convertTemperature(value, fromUnit, toUnit) {
+        const temps = this.conversions.temperature;
+        const from = temps[fromUnit];
+        const to = temps[toUnit];
+
+        if (!from || !to) {
+            throw new Error(`Unknown temperature unit: ${fromUnit} or ${toUnit}`);
+        }
+
+        let celsius;
+
+        // Convert to Celsius first
+        if (from === 'C') {
+            celsius = value;
+        } else if (from === 'F') {
+            celsius = (value - 32) * 5 / 9;
+        } else if (from === 'K') {
+            celsius = value - 273.15;
+        }
+
+        // Convert from Celsius to target
+        let result;
+        if (to === 'C') {
+            result = celsius;
+        } else if (to === 'F') {
+            result = (celsius * 9 / 5) + 32;
+        } else if (to === 'K') {
+            result = celsius + 273.15;
+        }
+
+        return this.formatResult(result);
+    }
+
+    formatResult(result) {
+        // Round to reasonable precision
+        if (Math.abs(result - Math.round(result)) < 1e-10) {
+            return Math.round(result);
+        }
+        return Math.round(result * 100) / 100;
+    }
+}
+
+module.exports = UnitConverter;

package/src/index.js

@@ -0,0 +1,121 @@
+const MathEngine = require('./core/math-engine');
+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 WindowsSearchIntegration = require('./integration/windows-search');
+const chalk = require('chalk');
+
+class ManiCalc {
+  constructor() {
+    this.mathEngine = new MathEngine();
+    this.nlpParser = new NLPParser();
+    this.unitConverter = new UnitConverter();
+    this.historyManager = new HistoryManager();
+    this.clipboardManager = new ClipboardManager();
+    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: 10 km to miles'));
+      console.log(chalk.gray('   - calc: history\n'));
+      
+      return true;
+    } catch (error) {
+      console.error(chalk.red('✗ Failed to initialize:'), error.message);
+      return false;
+    }
+  }
+
+  async processQuery(query) {
+    try {
+      // Check for special commands
+      if (query.toLowerCase().trim() === 'history') {
+        return this.historyManager.getHistory();
+      }
+
+      if (query.toLowerCase().trim() === 'clear history') {
+        this.historyManager.clearHistory();
+        return { result: 'History cleared', type: 'info' };
+      }
+
+      // Try natural language parsing first
+      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) {
+      return {
+        query,
+        error: error.message,
+        type: 'error',
+        formatted: `Error: ${error.message}`
+      };
+    }
+  }
+
+  async shutdown() {
+    console.log(chalk.cyan('👋 Mani-Calc shutting down...'));
+    await this.windowsSearch.unregister();
+  }
+}
+
+module.exports = ManiCalc;