lsh-framework 0.5.4

package/dist/lib/floating-point-arithmetic.js

@@ -0,0 +1,256 @@
+/**
+ * Floating Point Arithmetic Implementation
+ * Provides ZSH-compatible floating point math support
+ */
+export class FloatingPointArithmetic {
+    mathFunctions = new Map();
+    precision = 6;
+    constructor() {
+        this.setupMathFunctions();
+    }
+    /**
+     * Evaluate arithmetic expression with floating point support
+     */
+    evaluate(expression) {
+        try {
+            // Clean and validate expression
+            const cleaned = this.cleanExpression(expression);
+            // Replace variables with their values
+            const withVariables = this.replaceVariables(cleaned);
+            // Replace function calls
+            const withFunctions = this.replaceFunctions(withVariables);
+            // Evaluate the expression
+            const result = this.evaluateExpression(withFunctions);
+            // Round to specified precision
+            return this.roundToPrecision(result);
+        }
+        catch (error) {
+            throw new Error(`Arithmetic error: ${error.message}`);
+        }
+    }
+    /**
+     * Set precision for floating point results
+     */
+    setPrecision(precision) {
+        this.precision = Math.max(0, Math.min(15, precision));
+    }
+    /**
+     * Get current precision
+     */
+    getPrecision() {
+        return this.precision;
+    }
+    /**
+     * Add a custom math function
+     */
+    addMathFunction(func) {
+        this.mathFunctions.set(func.name, func);
+    }
+    /**
+     * Get available math functions
+     */
+    getAvailableFunctions() {
+        return Array.from(this.mathFunctions.keys());
+    }
+    /**
+     * Setup built-in math functions
+     */
+    setupMathFunctions() {
+        // Basic trigonometric functions
+        this.addMathFunction({ name: 'sin', func: Math.sin, arity: 1 });
+        this.addMathFunction({ name: 'cos', func: Math.cos, arity: 1 });
+        this.addMathFunction({ name: 'tan', func: Math.tan, arity: 1 });
+        this.addMathFunction({ name: 'asin', func: Math.asin, arity: 1 });
+        this.addMathFunction({ name: 'acos', func: Math.acos, arity: 1 });
+        this.addMathFunction({ name: 'atan', func: Math.atan, arity: 1 });
+        this.addMathFunction({ name: 'atan2', func: (x, y) => Math.atan2(y ?? 0, x), arity: 2 });
+        // Hyperbolic functions
+        this.addMathFunction({ name: 'sinh', func: Math.sinh, arity: 1 });
+        this.addMathFunction({ name: 'cosh', func: Math.cosh, arity: 1 });
+        this.addMathFunction({ name: 'tanh', func: Math.tanh, arity: 1 });
+        this.addMathFunction({ name: 'asinh', func: Math.asinh, arity: 1 });
+        this.addMathFunction({ name: 'acosh', func: Math.acosh, arity: 1 });
+        this.addMathFunction({ name: 'atanh', func: Math.atanh, arity: 1 });
+        // Exponential and logarithmic functions
+        this.addMathFunction({ name: 'exp', func: Math.exp, arity: 1 });
+        this.addMathFunction({ name: 'log', func: Math.log, arity: 1 });
+        this.addMathFunction({ name: 'log10', func: Math.log10, arity: 1 });
+        this.addMathFunction({ name: 'log2', func: Math.log2, arity: 1 });
+        this.addMathFunction({ name: 'pow', func: (x, y) => Math.pow(x, y ?? 0), arity: 2 });
+        // Power and root functions
+        this.addMathFunction({ name: 'sqrt', func: Math.sqrt, arity: 1 });
+        this.addMathFunction({ name: 'cbrt', func: Math.cbrt, arity: 1 });
+        // Rounding functions
+        this.addMathFunction({ name: 'ceil', func: Math.ceil, arity: 1 });
+        this.addMathFunction({ name: 'floor', func: Math.floor, arity: 1 });
+        this.addMathFunction({ name: 'round', func: Math.round, arity: 1 });
+        this.addMathFunction({ name: 'trunc', func: Math.trunc, arity: 1 });
+        // Absolute value and sign
+        this.addMathFunction({ name: 'abs', func: Math.abs, arity: 1 });
+        this.addMathFunction({ name: 'sign', func: Math.sign, arity: 1 });
+        // Random functions
+        this.addMathFunction({ name: 'random', func: () => Math.random(), arity: 1 });
+        this.addMathFunction({ name: 'rand', func: () => Math.random(), arity: 1 });
+        // Constants
+        this.addMathFunction({ name: 'pi', func: () => Math.PI, arity: 1 });
+        this.addMathFunction({ name: 'e', func: () => Math.E, arity: 1 });
+        // Additional utility functions
+        this.addMathFunction({ name: 'min', func: (x, y) => Math.min(x, y ?? x), arity: 2 });
+        this.addMathFunction({ name: 'max', func: (x, y) => Math.max(x, y ?? x), arity: 2 });
+        this.addMathFunction({ name: 'clz32', func: Math.clz32, arity: 1 });
+        this.addMathFunction({ name: 'fround', func: Math.fround, arity: 1 });
+        this.addMathFunction({ name: 'imul', func: (x, y) => Math.imul(x, y ?? 0), arity: 2 });
+    }
+    /**
+     * Clean expression by removing whitespace and validating characters
+     */
+    cleanExpression(expression) {
+        // Remove whitespace
+        const cleaned = expression.replace(/\s/g, '');
+        // Validate characters (allow numbers, operators, parentheses, function names, and dots)
+        if (!/^[0-9+\-*/().,a-zA-Z_]+$/.test(cleaned)) {
+            throw new Error('Invalid characters in expression');
+        }
+        return cleaned;
+    }
+    /**
+     * Replace variables in expression (placeholder for future variable support)
+     */
+    replaceVariables(expression) {
+        // For now, just return the expression as-is
+        // In a full implementation, this would replace variables like $x with their values
+        return expression;
+    }
+    /**
+     * Replace function calls with their results
+     */
+    replaceFunctions(expression) {
+        let result = expression;
+        // Find function calls like sin(1.5) or pow(2,3)
+        const functionRegex = /([a-zA-Z_][a-zA-Z0-9_]*)\(([^)]*)\)/g;
+        let match;
+        while ((match = functionRegex.exec(expression)) !== null) {
+            const [fullMatch, funcName, argsStr] = match;
+            const func = this.mathFunctions.get(funcName);
+            if (!func) {
+                throw new Error(`Unknown function: ${funcName}`);
+            }
+            const args = this.parseFunctionArguments(argsStr);
+            if (args.length !== func.arity) {
+                throw new Error(`Function ${funcName} expects ${func.arity} arguments, got ${args.length}`);
+            }
+            const funcResult = func.func(args[0], args[1]);
+            result = result.replace(fullMatch, funcResult.toString());
+        }
+        return result;
+    }
+    /**
+     * Parse function arguments
+     */
+    parseFunctionArguments(argsStr) {
+        if (!argsStr.trim())
+            return [];
+        const args = [];
+        let current = '';
+        let parenCount = 0;
+        for (let i = 0; i < argsStr.length; i++) {
+            const char = argsStr[i];
+            if (char === '(') {
+                parenCount++;
+                current += char;
+            }
+            else if (char === ')') {
+                parenCount--;
+                current += char;
+            }
+            else if (char === ',' && parenCount === 0) {
+                args.push(parseFloat(current.trim()));
+                current = '';
+            }
+            else {
+                current += char;
+            }
+        }
+        if (current.trim()) {
+            args.push(parseFloat(current.trim()));
+        }
+        return args;
+    }
+    /**
+     * Evaluate the mathematical expression
+     */
+    evaluateExpression(expression) {
+        try {
+            // Use Function constructor for safe evaluation
+            // This is a simplified approach - a full implementation would use a proper parser
+            const func = new Function(`return ${expression}`);
+            const result = func();
+            if (typeof result !== 'number' || isNaN(result)) {
+                throw new Error('Invalid expression result');
+            }
+            return result;
+        }
+        catch (error) {
+            throw new Error(`Expression evaluation failed: ${error.message}`);
+        }
+    }
+    /**
+     * Round number to specified precision
+     */
+    roundToPrecision(num) {
+        const factor = Math.pow(10, this.precision);
+        return Math.round(num * factor) / factor;
+    }
+    /**
+     * Format number with specified precision
+     */
+    formatNumber(num, precision) {
+        const prec = precision !== undefined ? precision : this.precision;
+        return num.toFixed(prec);
+    }
+    /**
+     * Check if a string represents a valid floating point number
+     */
+    isValidFloat(str) {
+        const num = parseFloat(str);
+        return !isNaN(num) && isFinite(num);
+    }
+    /**
+     * Convert string to floating point number
+     */
+    parseFloat(str) {
+        const num = parseFloat(str);
+        if (isNaN(num)) {
+            throw new Error(`Invalid floating point number: ${str}`);
+        }
+        return num;
+    }
+    /**
+     * Get mathematical constants
+     */
+    getConstants() {
+        return {
+            pi: Math.PI,
+            e: Math.E,
+            ln2: Math.LN2,
+            ln10: Math.LN10,
+            log2e: Math.LOG2E,
+            log10e: Math.LOG10E,
+            sqrt1_2: Math.SQRT1_2,
+            sqrt2: Math.SQRT2,
+        };
+    }
+    /**
+     * Evaluate expression with error handling
+     */
+    safeEvaluate(expression) {
+        try {
+            const result = this.evaluate(expression);
+            return { success: true, result };
+        }
+        catch (error) {
+            return { success: false, error: error.message };
+        }
+    }
+}
+export default FloatingPointArithmetic;

package/dist/lib/history-system.js

@@ -0,0 +1,245 @@
+/**
+ * Command History System Implementation
+ * Provides ZSH-compatible history functionality
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+export class HistorySystem {
+    entries = [];
+    currentIndex = -1;
+    config;
+    isEnabled = true;
+    constructor(config) {
+        this.config = {
+            maxSize: 10000,
+            filePath: path.join(os.homedir(), '.lsh_history'),
+            shareHistory: false,
+            ignoreDups: true,
+            ignoreSpace: false,
+            expireDuplicatesFirst: true,
+            ...config,
+        };
+        this.loadHistory();
+    }
+    /**
+     * Add a command to history
+     */
+    addCommand(command, exitCode) {
+        if (!this.isEnabled)
+            return;
+        // Skip empty commands
+        if (!command.trim())
+            return;
+        // Skip commands starting with space if ignoreSpace is enabled
+        if (this.config.ignoreSpace && command.startsWith(' '))
+            return;
+        // Remove duplicates if configured
+        if (this.config.ignoreDups) {
+            this.removeDuplicateCommand(command);
+        }
+        const entry = {
+            lineNumber: this.entries.length + 1,
+            command: command.trim(),
+            timestamp: Date.now(),
+            exitCode,
+        };
+        this.entries.push(entry);
+        // Trim history if it exceeds max size
+        if (this.entries.length > this.config.maxSize) {
+            this.entries = this.entries.slice(-this.config.maxSize);
+            this.renumberEntries();
+        }
+        this.currentIndex = this.entries.length - 1;
+        this.saveHistory();
+    }
+    /**
+     * Get history entry by line number
+     */
+    getEntry(lineNumber) {
+        return this.entries.find(entry => entry.lineNumber === lineNumber);
+    }
+    /**
+     * Get history entry by command prefix
+     */
+    getEntryByPrefix(prefix) {
+        return this.entries
+            .slice()
+            .reverse()
+            .find(entry => entry.command.startsWith(prefix));
+    }
+    /**
+     * Get all history entries
+     */
+    getAllEntries() {
+        return [...this.entries];
+    }
+    /**
+     * Search history for commands matching pattern
+     */
+    searchHistory(pattern) {
+        const regex = new RegExp(pattern, 'i');
+        return this.entries.filter(entry => regex.test(entry.command));
+    }
+    /**
+     * Get previous command in history
+     */
+    getPreviousCommand() {
+        if (this.currentIndex > 0) {
+            this.currentIndex--;
+            return this.entries[this.currentIndex].command;
+        }
+        return null;
+    }
+    /**
+     * Get next command in history
+     */
+    getNextCommand() {
+        if (this.currentIndex < this.entries.length - 1) {
+            this.currentIndex++;
+            return this.entries[this.currentIndex].command;
+        }
+        return null;
+    }
+    /**
+     * Reset history navigation index
+     */
+    resetIndex() {
+        this.currentIndex = this.entries.length - 1;
+    }
+    /**
+     * Expand history references like !! !n !string
+     */
+    expandHistory(command) {
+        let result = command;
+        // Handle !! (last command)
+        result = result.replace(/!!/g, () => {
+            const lastEntry = this.entries[this.entries.length - 1];
+            return lastEntry ? lastEntry.command : '!!';
+        });
+        // Handle !n (command number n)
+        result = result.replace(/!(\d+)/g, (match, numStr) => {
+            const num = parseInt(numStr, 10);
+            const entry = this.getEntry(num);
+            return entry ? entry.command : match;
+        });
+        // Handle !string (last command starting with string)
+        result = result.replace(/!([a-zA-Z0-9_]+)/g, (match, prefix) => {
+            const entry = this.getEntryByPrefix(prefix);
+            return entry ? entry.command : match;
+        });
+        // Handle ^old^new (quick substitution)
+        result = result.replace(/\^([^^]+)\^([^^]*)/g, (match, old, replacement) => {
+            const lastEntry = this.entries[this.entries.length - 1];
+            if (lastEntry) {
+                return lastEntry.command.replace(new RegExp(old, 'g'), replacement);
+            }
+            return match;
+        });
+        return result;
+    }
+    /**
+     * Clear history
+     */
+    clearHistory() {
+        this.entries = [];
+        this.currentIndex = -1;
+        this.saveHistory();
+    }
+    /**
+     * Get history statistics
+     */
+    getStats() {
+        const unique = new Set(this.entries.map(e => e.command)).size;
+        const oldest = this.entries.length > 0 ? new Date(this.entries[0].timestamp) : null;
+        const newest = this.entries.length > 0 ? new Date(this.entries[this.entries.length - 1].timestamp) : null;
+        return {
+            total: this.entries.length,
+            unique,
+            oldest,
+            newest,
+        };
+    }
+    /**
+     * Enable/disable history
+     */
+    setEnabled(enabled) {
+        this.isEnabled = enabled;
+    }
+    /**
+     * Update configuration
+     */
+    updateConfig(newConfig) {
+        this.config = { ...this.config, ...newConfig };
+    }
+    /**
+     * Load history from file
+     */
+    loadHistory() {
+        try {
+            if (fs.existsSync(this.config.filePath)) {
+                const content = fs.readFileSync(this.config.filePath, 'utf8');
+                const lines = content.split('\n').filter(line => line.trim());
+                this.entries = lines.map((line, index) => {
+                    // Parse history line format: timestamp:command
+                    const colonIndex = line.indexOf(':');
+                    if (colonIndex > 0) {
+                        const timestamp = parseInt(line.substring(0, colonIndex), 10);
+                        const command = line.substring(colonIndex + 1);
+                        return {
+                            lineNumber: index + 1,
+                            command,
+                            timestamp: isNaN(timestamp) ? Date.now() : timestamp,
+                        };
+                    }
+                    else {
+                        return {
+                            lineNumber: index + 1,
+                            command: line,
+                            timestamp: Date.now(),
+                        };
+                    }
+                });
+            }
+        }
+        catch (_error) {
+            // If loading fails, start with empty history
+            this.entries = [];
+        }
+    }
+    /**
+     * Save history to file
+     */
+    saveHistory() {
+        try {
+            const content = this.entries
+                .map(entry => `${entry.timestamp}:${entry.command}`)
+                .join('\n');
+            // Ensure directory exists
+            const dir = path.dirname(this.config.filePath);
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            fs.writeFileSync(this.config.filePath, content, 'utf8');
+        }
+        catch (_error) {
+            // Silently fail if we can't save history
+        }
+    }
+    /**
+     * Remove duplicate command from history
+     */
+    removeDuplicateCommand(command) {
+        const trimmedCommand = command.trim();
+        this.entries = this.entries.filter(entry => entry.command !== trimmedCommand);
+    }
+    /**
+     * Renumber entries after trimming
+     */
+    renumberEntries() {
+        this.entries.forEach((entry, index) => {
+            entry.lineNumber = index + 1;
+        });
+    }
+}
+export default HistorySystem;