mathcalc-cli 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Mcas-996
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,150 @@
+# Calculator CLI
+
+A lightweight Rust command-line calculator capable of evaluating real/complex expressions, solving equations (with exact symbolic output up to quintics), and processing small systems of linear equations.
+
+## Quick Start
+
+1. Clone the project: `git clone https://github.com/allen/calculator-cli && cd calculator-cli`.
+2. Build a Release binary: `cargo build --release`.
+3. Run an expression straight from your shell: `./target/release/calculator "x^2-5x+6=0"`.
+
+## NPM Installation
+
+### For x64 Systems (Windows, macOS Intel, Linux x64)
+The easiest way to install calculator-cli is via npm:
+
+```bash
+npm install -g calculator-cli
+```
+
+Once installed, you can run:
+
+```bash
+calculator "2 + 2"
+calculator "x^2-5x+6=0"
+```
+
+### For ARM Systems (Apple Silicon, ARM64 Linux)
+The npm package includes precompiled binaries only for x64 systems. For ARM systems:
+
+```bash
+# 1. Install Rust if you haven't already:
+curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
+source ~/.cargo/env
+
+# 2. Install calculator-cli from source:
+cargo install calculator
+```
+
+### Platform Support
+| Platform | Architecture | Installation Method |
+|----------|-------------|--------------------|
+| Windows | x64 | npm install |
+| macOS | x64 (Intel) | npm install |
+| macOS | ARM (Apple Silicon) | cargo install |
+| Linux | x64 | npm install |
+| Linux | ARM64 | cargo install |
+
+## Features
+
+### Expression Engine
+- Addition, subtraction, multiplication, division, exponentiation.
+- Percentages (`50% * 200`), parentheses, unary minus.
+- Constants `pi`, `e`, imaginary unit `i`, and decimal or fractional inputs (fractions auto-simplify in output).
+- Square root `sqrt()`, absolute value `abs()`, trigonometric functions in radians `sin()/cos()` and degree variants `sind()/cosd()`.
+- Full complex-number arithmetic, e.g. `sqrt(-4)`, `(3+2i)*(1-i)`, `cosd(60+i)`.
+
+### Equation Solving
+- Linear equations: `2x+5=0`
+- Quadratic equations: `x^2-5x+6=0` (real or complex roots)
+- Cubic equations: `x^3-6x^2+11x-6=0`
+- Quartic equations: `x^4-2=0` (symbolic roots via `sqrt`/`cbrt`, numeric Durand–Kerner fallback)
+- Quintic equations: `x^5+2x^4+...=0` → numeric approximation via Durand-Kerner method
+- Systems of linear equations (up to 3 variables): `x+y=5, x-y=1`
+
+### Output Formatting
+- Results favor exact fractions when possible (e.g. `1/3` stays rational) and fall back to decimals only when necessary.
+- Complex numbers print as `a + bi`, with simplified `i`/`-i`.
+- Multiple output formats: ASCII, Unicode, and LaTeX.
+
+## Usage
+
+```bash
+# Basic usage (expression as CLI argument)
+./target/release/calculator "3 + 5 * (2 - 8)^2"
+
+# Complex numbers
+./target/release/calculator "(3+2i) * (1 - i)"
+./target/release/calculator "sqrt(-9)"        # -> 3i
+
+# Trigonometry
+./target/release/calculator "sin(pi / 6)"     # radians
+./target/release/calculator "sind(30)"        # degrees
+
+# Equation solving
+./target/release/calculator "x^2-5x+6=0"
+./target/release/calculator "x+y=5, x-y=1"
+
+# Output formatting
+./target/release/calculator --unicode "sqrt(16)"
+./target/release/calculator --latex "pi"
+./target/release/calculator --ascii "3 + 4"
+```
+
+Passing `--help` or `--version` prints CLI info. Without an argument, the program enters interactive mode.
+
+## Building
+
+The project uses Rust and Cargo.
+
+```bash
+# Build in release mode
+cargo build --release
+
+# Run tests
+cargo test
+
+# Run with clippy for additional checks
+cargo clippy
+```
+
+- Rust 1.75.0 or later is required
+- Cargo handles all dependencies automatically
+- The binary will be available at `target/release/calculator`
+
+## Interactive Mode
+
+Run the calculator without arguments to enter interactive mode:
+
+```bash
+./target/release/calculator
+```
+
+Type expressions and press Enter to evaluate. Type `exit` or `quit` to exit, or press Ctrl+D.
+
+## Project Structure
+
+- `src/core/` - Core data types (ComplexNumber, Fraction, Expression)
+- `src/parser/` - Expression parser and tokenizer
+- `src/solver/` - Equation solvers (linear, quadratic, cubic, quartic, quintic)
+- `src/output/` - Output formatters (ASCII, Unicode, LaTeX)
+- `src/main.rs` - CLI entry point
+
+## Troubleshooting
+
+- **Cargo not found**: Install Rust from https://rustup.rs/
+- **Build fails**: Ensure you have Rust 1.75.0 or later
+- **Locale-dependent parsing issues**: force the C locale before running (`LC_ALL=C ./calculator`)
+
+## License
+
+MIT License - See LICENSE file for details
+
+## Migration from C++ Version
+
+This calculator was originally implemented in C++20 with SymEngine. The Rust version provides:
+- Faster build times (seconds instead of minutes)
+- No external dependencies (no 374MB SymEngine vendored code)
+- Memory safety without garbage collection
+- Smaller binary size
+- Better cross-platform support

package/index.js

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+
+// Entry point for the calculator-cli npm package
+// This is a minimal wrapper that delegates to the compiled binary
+
+const path = require("path");
+const { spawnSync } = require("child_process");
+const os = require("os");
+
+// Determine the appropriate binary based on platform
+const platform = os.platform();
+const isWindows = platform === "win32";
+
+// Binary file names
+const binaryName = isWindows
+    ? "calculator_windows-x86-64.exe"
+    : "calculator_linux-x64";
+const binaryPath = path.join(__dirname, "bin", binaryName);
+
+function runCalculator(args) {
+    if (!require("fs").existsSync(binaryPath)) {
+        console.error(`Error: Calculator binary not found for ${platform}`);
+        process.exit(1);
+    }
+
+    try {
+        const result = spawnSync(binaryPath, args, { stdio: "inherit" });
+        process.exit(result.status);
+    } catch (error) {
+        console.error(`Error: ${error.message}`);
+        process.exit(1);
+    }
+}
+
+// If called from npm scripts, pass all arguments to the binary
+if (require.main === module) {
+    runCalculator(process.argv.slice(2));
+}
+
+module.exports = { runCalculator };

package/package.json

@@ -0,0 +1,41 @@
+{
+    "name": "mathcalc-cli",
+    "version": "0.1.0",
+    "description": "A command-line calculator with symbolic math support",
+    "main": "index.js",
+    "bin": {
+        "calculator": "bin/calculator_linux-x64"
+    },
+    "scripts": {
+        "preinstall": "node scripts/install.js",
+        "postinstall": "node scripts/postinstall.js",
+        "test": "node scripts/test.js"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/anomalyco/calculator-cli.git"
+    },
+    "keywords": [
+        "calculator",
+        "math",
+        "cli",
+        "command-line",
+        "equations"
+    ],
+    "author": "Allen <anomalyco@github.com>",
+    "license": "MIT",
+    "os": [
+        "linux",
+        "win32"
+    ],
+    "cpu": [
+        "x64"
+    ],
+    "files": [
+        "bin/",
+        "scripts/"
+    ],
+    "engines": {
+        "node": ">=12.0.0"
+    }
+}

package/scripts/build-binaries.js

@@ -0,0 +1,482 @@
+#!/usr/bin/env node
+
+/*
+ * Local build script for generating platform-specific binaries for npm distribution
+ * This script is designed for local compilation across multiple platforms
+ *
+ * To build for all platforms locally, you'll need:
+ * - Rust toolchains: x86_64-pc-windows-gnu, x86_64-apple-darwin, x86_64-unknown-linux-gnu
+ * - Cross-compilation tools for Windows (mingw-w64) on Linux/macOS
+ */
+
+const path = require("path");
+const { execSync } = require("child_process");
+const fs = require("fs");
+
+// Target platforms and their output files
+const platforms = [
+    {
+        target: "x86_64-unknown-linux-gnu",
+        outputFile: "calculator-linux-x64",
+        canBuildOn: ["linux"],
+    },
+    {
+        target: "x86_64-pc-windows-gnu",
+        outputFile: "calculator-win32-x64.exe",
+        canBuildOn: ["linux", "macos", "windows"],
+        requires: {
+            linux: "x86_64-w64-mingw32-gcc",
+            macos: "x86_64-w64-mingw32-gcc",
+        },
+    },
+    {
+        target: "x86_64-apple-darwin",
+        outputFile: "calculator-darwin-x64",
+        canBuildOn: ["macos"],
+    },
+];
+
+console.log("🔨 Building calculator-cli binaries for npm distribution...\n");
+
+// Check if Cargo.toml exists
+const projectRoot = path.join(__dirname, "..");
+if (!fs.existsSync(path.join(projectRoot, "Cargo.toml"))) {
+    console.error("❌ Cargo.toml not found in project root");
+    console.log("Make sure this script is run from the correct directory");
+    process.exit(1);
+}
+
+// Detect current platform and WSL environment
+const detectCurrentPlatform = () => {
+    const platform = process.platform;
+    if (platform === "linux") return "linux";
+    if (platform === "darwin") return "macos";
+    if (platform === "win32") return "windows";
+    return "unknown";
+};
+
+// Check if running in WSL
+const isWSL = () => {
+    try {
+        return (
+            fs
+                .readFileSync("/proc/version", "utf8")
+                .toLowerCase()
+                .includes("microsoft") ||
+            process.env.WSL_DISTRO_NAME !== undefined
+        );
+    } catch (e) {
+        return false;
+    }
+};
+
+const currentPlatform = detectCurrentPlatform();
+const inWSL = currentPlatform === "linux" && isWSL();
+console.log(
+    `📍 Detected current platform: ${currentPlatform}${inWSL ? " (in WSL)" : ""}\n`,
+);
+
+// Helper function to check if a command is available
+const commandExists = (command) => {
+    try {
+        execSync(`which ${command}`, { stdio: "ignore" });
+        return true;
+    } catch (e) {
+        return false;
+    }
+};
+
+// Helper function to check if a target is installed
+const isTargetInstalled = (target) => {
+    try {
+        const list = execSync("rustup target list --installed", {
+            encoding: "utf8",
+        });
+        return list.includes(target);
+    } catch (e) {
+        return false;
+    }
+};
+
+try {
+    // Get version from Cargo.toml
+    const cargoContent = fs.readFileSync(
+        path.join(projectRoot, "Cargo.toml"),
+        "utf8",
+    );
+    const versionMatch = cargoContent.match(/^version\s*=\s*"([^"]+)"/m);
+    const version = versionMatch ? versionMatch[1] : "2.0.0";
+    console.log(`Found version: ${version}\n`);
+
+    // Create bin directory if it doesn't exist
+    const binDir = path.join(projectRoot, "bin");
+    if (!fs.existsSync(binDir)) {
+        fs.mkdirSync(binDir, { recursive: true });
+        console.log(`Created bin directory: ${binDir}\n`);
+    }
+
+    // Filter platforms that can be built on current platform
+    const buildablePlatforms = platforms.filter((platform) =>
+        platform.canBuildOn.includes(currentPlatform),
+    );
+
+    if (buildablePlatforms.length === 0) {
+        console.log(`⚠️  No platforms can be built on ${currentPlatform}`);
+        console.log("This script supports:");
+
+        platforms.forEach((platform) => {
+            console.log(
+                `- ${platform.target}: ${platform.canBuildOn.join(", ")}`,
+            );
+        });
+
+        console.log("\n💡 Consider using a different platform or a CI service");
+        process.exit(1);
+    }
+
+    let successfulBuilds = 0;
+
+    // Build for each buildable target platform
+    for (const platform of buildablePlatforms) {
+        console.log(`📦 Building for ${platform.target}...`);
+
+        // Check if the target is installed
+        if (!isTargetInstalled(platform.target)) {
+            console.log(`❌ Rust target '${platform.target}' not installed`);
+            console.log(`💡 Installing target now...`);
+
+            try {
+                execSync(`rustup target add ${platform.target}`, {
+                    stdio: "inherit",
+                    maxBuffer: 10 * 1024 * 1024,
+                });
+                console.log(
+                    `✅ Target '${platform.target}' installed successfully\n`,
+                );
+            } catch (error) {
+                console.log(`❌ Failed to install target: ${error.message}`);
+                console.log(
+                    `💡 Please install manually: rustup target add ${platform.target}\n`,
+                );
+                continue;
+            }
+        }
+
+        // Check for required tools
+        if (platform.requires && platform.requires[currentPlatform]) {
+            const requiredTool = platform.requires[currentPlatform];
+            if (!commandExists(requiredTool)) {
+                console.log(`❌ Required tool '${requiredTool}' not found`);
+
+                // Provide installation instructions
+                if (
+                    currentPlatform === "linux" &&
+                    platform.target.includes("windows")
+                ) {
+                    console.log("💡 To install on Linux/Ubuntu:");
+                    console.log("   sudo apt-get update");
+                    console.log("   sudo apt-get install mingw-w64");
+                    console.log("   # For Debian:");
+                    console.log("   sudo apt-get install gcc-mingw-w64-x86-64");
+                } else if (
+                    currentPlatform === "macos" &&
+                    platform.target.includes("windows")
+                ) {
+                    console.log("💡 To install on macOS:");
+                    console.log("   brew install mingw-w64");
+                }
+
+                console.log("");
+                continue;
+            }
+        }
+
+        try {
+            // Set environment variables for cross-compilation if needed
+            const env = { ...process.env };
+
+            // Configure environment for cross-compilation
+            const env = { ...process.env };
+            if (
+                platform.target === "x86_64-pc-windows-gnu" &&
+                currentPlatform !== "windows"
+            ) {
+                // Set the linker for Windows cross-compilation
+                env.CARGO_TARGET_X86_64_PC_WINDOWS_GNU_LINKER =
+                    "x86_64-w64-mingw32-gcc";
+                env.CC_x86_64_pc_windows_gnu = "x86_64-w64-mingw32-gcc";
+                env.CXX_x86_64_pc_windows_gnu = "x86_64-w64-mingw32-g++";
+
+                // WSL-specific settings
+                if (inWSL) {
+                    console.log(
+                        "   🐧 Applying WSL-specific settings for Windows target",
+                    );
+                    // Additional linker flags for WSL
+                    env.CARGO_TARGET_X86_64_PC_WINDOWS_GNU_RUSTFLAGS =
+                        "-C link-arg=-Wl,--subsystem,console -C link-arg=-static";
+
+                    // Try alternative linking strategy for WSL
+                    if (process.env.USE_MSVC_TOOLCHAIN) {
+                        console.log(
+                            "   Using MSVC toolchain for Windows target",
+                        );
+                        env.RUSTUP_TOOLCHAIN = "stable-x86_64-pc-windows-msvc";
+                    }
+                }
+            }
+
+            // Build the binary
+            const buildCmd = `cargo build --release --target ${platform.target}`;
+            console.log(`   Running: ${buildCmd}`);
+
+            // Use inherit stdio and increased buffer to avoid ENOBUFS errors
+            execSync(buildCmd, {
+                stdio: "inherit",
+                env,
+                cwd: projectRoot,
+                maxBuffer: 10 * 1024 * 1024, // 10MB buffer
+            });
+
+            // Copy the binary to the bin directory
+            const sourcePath = path.join(
+                projectRoot,
+                "target",
+                platform.target,
+                "release",
+                "calculator",
+            );
+
+            // For Windows, the binary has .exe extension
+            const windowsSourcePath = path.join(
+                projectRoot,
+                "target",
+                platform.target,
+                "release",
+                "calculator.exe",
+            );
+
+            const finalSourcePath = platform.target.includes("windows")
+                ? windowsSourcePath
+                : sourcePath;
+            const destPath = path.join(binDir, platform.outputFile);
+
+            // Verify source exists
+            if (!fs.existsSync(finalSourcePath)) {
+                throw new Error(
+                    `Binary not found at expected path: ${finalSourcePath}`,
+                );
+            }
+
+            // Copy binary
+            fs.copyFileSync(finalSourcePath, destPath);
+
+            // On Unix-like systems, make sure the binary is executable
+            if (!platform.target.includes("windows")) {
+                try {
+                    fs.chmodSync(destPath, "755");
+                } catch (error) {
+                    console.warn(
+                        `Warning: Could not set executable permissions: ${error.message}`,
+                    );
+                }
+            }
+
+            console.log(`✅ Built and copied to: ${destPath}\n`);
+            successfulBuilds++;
+        } catch (error) {
+            console.error(
+                `❌ Failed to build for ${platform.target}: ${error.message}`,
+            );
+
+            // Provide specific help for common errors
+            if (
+                error.message.includes("E0425") ||
+                error.message.includes("E0431") ||
+                error.message.includes("linker") ||
+                error.message.includes("undefined reference")
+            ) {
+                console.log("");
+                console.log(
+                    "💡 This appears to be a linker error (E0425/E0431). Solutions:",
+                );
+
+                if (platform.target.includes("windows")) {
+                    console.log("1. For WSL MinGW issues, try these steps:");
+                    if (inWSL) {
+                        console.log("   🐧 WSL-specific solutions:");
+                        console.log("   a) Install complete MinGW toolchain:");
+                        console.log(
+                            "      sudo apt-get update && sudo apt-get install mingw-w64 gcc-mingw-w64-x86-64",
+                        );
+                        console.log("");
+                        console.log("   b) Set environment variables for WSL:");
+                        console.log(
+                            "      export CARGO_TARGET_X86_64_PC_WINDOWS_GNU_LINKER=x86_64-w64-mingw32-gcc",
+                        );
+                        console.log(
+                            "      export CC_x86_64_pc_windows_gnu=x86_64-w64-mingw32-gcc",
+                        );
+                        console.log(
+                            "      export CXX_x86_64_pc_windows_gnu=x86_64-w64-mingw32-g++",
+                        );
+                        console.log("");
+                        console.log(
+                            "   c) Alternative: Use Windows native Rust:",
+                        );
+                        console.log(
+                            "      rustup toolchain install stable-x86_64-pc-windows-msvc",
+                        );
+                        console.log(
+                            "      rustup default stable-x86_64-pc-windows-msvc",
+                        );
+                        console.log(
+                            "      rustup target add x86_64-pc-windows-msvc",
+                        );
+                        console.log("");
+                        console.log(
+                            "   d) For persistent configuration, add to ~/.bashrc:",
+                        );
+                        console.log("      [target.x86_64-pc-windows-gnu]");
+                        console.log("      linker = 'x86_64-w64-mingw32-gcc'");
+                        console.log("      ");
+                        console.log("      [target.x86_64-pc-windows-msvc]");
+                        console.log("      linker = 'lld-link'");
+                    } else {
+                        console.log(
+                            "   sudo apt-get update && sudo apt-get install mingw-w64",
+                        );
+                    }
+
+                    console.log("");
+                    console.log(
+                        "2. Try reinstalling and reconfiguring Rust targets:",
+                    );
+                    console.log(
+                        "   rustup target remove --toolchain stable x86_64-pc-windows-gnu",
+                    );
+                    console.log(
+                        "   rustup target add --toolchain stable x86_64-pc-windows-gnu",
+                    );
+                    console.log("   # Or try MSVC target:");
+                    console.log("   rustup target add x86_64-pc-windows-msvc");
+
+                    if (inWSL) {
+                        console.log("");
+                        console.log("🐧 WSL Specific Tips:");
+                        console.log(
+                            "   - WSL MinGW builds can be tricky. Consider using:",
+                        );
+                        console.log(
+                            "   * Windows Subsystem for Linux with Windows Rust installed in Windows",
+                        );
+                        console.log(
+                            "   * The MSVC target which might be more stable in WSL",
+                        );
+                        console.log(
+                            "   * Running the build directly in Windows instead of WSL",
+                        );
+                    }
+
+                    console.log("");
+                    console.log("3. Alternative approaches:");
+                    console.log("   - Build in native Windows environment");
+                    console.log(
+                        "   - Use GitHub Actions or another CI service",
+                    );
+                    console.log(
+                        "   - Focus on platforms that build successfully",
+                    );
+                }
+            } else if (error.message.includes("could not find")) {
+                console.log("");
+                console.log(`💡 Rust target not found. To install:`);
+                console.log(`   rustup target add ${platform.target}`);
+                console.log("");
+                console.log("To see all installed targets:");
+                console.log("   rustup target list --installed");
+            }
+
+            console.log("");
+        }
+    }
+
+    // Build summary
+    console.log("📋 Build Summary:");
+    platforms.forEach((platform) => {
+        const destPath = path.join(binDir, platform.outputFile);
+        if (fs.existsSync(destPath)) {
+            console.log(`✅ ${platform.outputFile}`);
+        } else {
+            const canBuild = platform.canBuildOn.includes(currentPlatform)
+                ? "buildable"
+                : "requires different platform";
+            console.log(`❌ ${platform.outputFile} (${canBuild})`);
+        }
+    });
+
+    console.log(
+        `\nSuccessfully built ${successfulBuilds} out of ${buildablePlatforms.length} platforms`,
+    );
+
+    if (successfulBuilds === 0) {
+        console.log("\n❌ No binaries were built successfully");
+        console.log("\n💡 Troubleshooting:");
+        console.log("1. Install missing Rust targets:");
+        buildablePlatforms.forEach((platform) => {
+            console.log(`   rustup target add ${platform.target}`);
+        });
+        console.log("\n2. Install cross-compilation tools:");
+        if (currentPlatform === "linux") {
+            console.log(
+                "   sudo apt-get update && sudo apt-get install mingw-w64",
+            );
+        } else if (currentPlatform === "macos") {
+            console.log("   brew install mingw-w64");
+        }
+        console.log("\n3. See LOCAL_BUILD_GUIDE.md for detailed instructions");
+        console.log("\n4. Consider building only for your current platform");
+    } else {
+        console.log("\n✅ Build completed successfully!");
+    }
+
+    console.log("\n📦 Next steps:");
+    if (successfulBuilds > 0) {
+        console.log("1. Test the package: node test-package.js");
+        console.log("2. Create package: npm run prepare-package");
+        console.log("3. Test locally: npm run local-test");
+        console.log("4. Publish to npm: npm publish");
+        console.log(
+            "\n💡 Remember to update the version number in Cargo.toml before publishing!",
+        );
+
+        if (inWSL) {
+            console.log("\n🐧 WSL-Specific Tips:");
+            console.log("- Windows binaries are accessible from Windows at:");
+            console.log(
+                `  \\\\wsl$\\$(hostname)\\${path
+                    .resolve(projectRoot)
+                    .replace(/^\/mnt\//, "")
+                    .replace(/\//g, "\\")}\\bin`,
+            );
+            console.log(
+                "- Test Windows binaries directly in Windows Command Prompt or PowerShell",
+            );
+        }
+    } else {
+        console.log("1. Fix the build issues shown above");
+        console.log("2. Try building for fewer platforms");
+        console.log("3. Consider building only for your current platform");
+
+        if (inWSL) {
+            console.log("\n🐧 WSL-Specific Tips:");
+            console.log("- Ensure you have the latest mingw-w64 packages");
+            console.log(
+                "- Try running the build script from /mnt/c/ to avoid WSL path limitations",
+            );
+        }
+    }
+} catch (error) {
+    console.error(`❌ Build process failed: ${error.message}`);
+    process.exit(1);
+}

package/scripts/fix-wsl-build.sh

@@ -0,0 +1,148 @@
+#!/bin/bash
+
+# WSL Windows Build Fix Script
+# This script helps resolve E4025 and E4031 linker errors when building Windows binaries in WSL
+
+echo "🐧 WSL Windows Build Fix Script"
+echo "================================"
+echo ""
+
+# Check if we're in WSL
+if ! grep -qi microsoft /proc/version; then
+    echo "⚠️  This script is optimized for WSL but can run on other Linux systems"
+fi
+
+# Install complete MinGW toolchain
+echo "🔧 Installing complete MinGW toolchain..."
+sudo apt-get update
+sudo apt-get install -y \
+    mingw-w64 \
+    gcc-mingw-w64-x86-64 \
+    gcc-mingw-w64-i686 \
+    binutils-mingw-w64-x86-64 \
+    binutils-mingw-w64-i686 \
+    mingw-w64-tools \
+    mingw-w64-x86-64-dev \
+    g++-mingw-w64-x86-64
+
+# Create Cargo config directory if it doesn't exist
+echo ""
+echo "📝 Configuring Cargo for cross-compilation..."
+mkdir -p ~/.cargo
+
+# Create or update Cargo config.toml
+cat > ~/.cargo/config.toml << 'EOF'
+[target.x86_64-pc-windows-gnu]
+linker = "x86_64-w64-mingw32-gcc"
+ar = "x86_64-w64-mingw32-ar"
+
+[target.x86_64-pc-windows-gnu.env]
+CC_x86_64_pc_windows_gnu = "x86_64-w64-mingw32-gcc"
+CXX_x86_64_pc_windows_gnu = "x86_64-w64-mingw32-g++"
+AR_x86_64_pc_windows_gnu = "x86_64-w64-mingw32-ar"
+
+[target.i686-pc-windows-gnu]
+linker = "i686-w64-mingw32-gcc"
+ar = "i686-w64-mingw32-ar"
+
+[target.i686-pc-windows-gnu.env]
+CC_i686_pc_windows_gnu = "i686-w64-mingw32-gcc"
+CXX_i686_pc_windows_gnu = "i686-w64-mingw32-g++"
+AR_i686_pc_windows_gnu = "i686-w64-mingw32-ar"
+EOF
+
+# Set environment variables for current session
+echo ""
+echo "🔧 Setting environment variables..."
+export CARGO_TARGET_X86_64_PC_WINDOWS_GNU_LINKER=x86_64-w64-mingw32-gcc
+export CC_x86_64_pc_windows_gnu=x86_64-w64-mingw32-gcc
+export CXX_x86_64_pc_windows_gnu=x86_64-w64-mingw32-g++
+export AR_x86_64_pc_windows_gnu=x86_64-w64-mingw32-ar
+
+# Add to ~/.bashrc for persistence
+echo ""
+echo "💾 Adding environment variables to ~/.bashrc..."
+cat >> ~/.bashrc << 'EOF'
+
+# Rust cross-compilation for Windows in WSL
+export CARGO_TARGET_X86_64_PC_WINDOWS_GNU_LINKER=x86_64-w64-mingw32-gcc
+export CC_x86_64_pc_windows_gnu=x86_64-w64-mingw32-gcc
+export CXX_x86_64_pc_windows_gnu=x86_64-w64-mingw32-g++
+export AR_x86_64_pc_windows_gnu=x86_64-w64-mingw32-ar
+EOF
+
+# Add to ~/.zshrc if zsh is used
+if [ -f ~/.zshrc ]; then
+    echo ""
+    echo "💾 Adding environment variables to ~/.zshrc..."
+    cat >> ~/.zshrc << 'EOF'
+
+# Rust cross-compilation for Windows in WSL
+export CARGO_TARGET_X86_64_PC_WINDOWS_GNU_LINKER=x86_64-w64-mingw32-gcc
+export CC_x86_64_pc_windows_gnu=x86_64-w64-mingw32-gcc
+export CXX_x86_64_pc_windows_gnu=x86_64-w64-mingw32-g++
+export AR_x86_64_pc_windows_gnu=x86_64-w64-mingw32-ar
+EOF
+fi
+
+# Verify installation
+echo ""
+echo "🔍 Verifying installation..."
+if command -v x86_64-w64-mingw32-gcc &> /dev/null; then
+    echo "✅ MinGW GCC found"
+    echo "   Version: $(x86_64-w64-mingw32-gcc --version | head -1)"
+else
+    echo "❌ MinGW GCC not found"
+fi
+
+if command -v x86_64-w64-mingw32-ar &> /dev/null; then
+    echo "✅ MinGW AR found"
+else
+    echo "❌ MinGW AR not found"
+fi
+
+# Install or update Rust targets
+echo ""
+echo "🔧 Installing Rust targets..."
+rustup target add x86_64-pc-windows-gnu
+rustup target add i686-pc-windows-gnu
+
+# Test compilation with a simple C program
+echo ""
+echo "🧪 Testing MinGW with a simple program..."
+cat > test_minGW.c << 'EOF'
+#include <stdio.h>
+
+int main() {
+    printf("Hello from Windows binary built in WSL!\n");
+    return 0;
+}
+EOF
+
+# Compile with MinGW
+if x86_64-w64-mingw32-gcc -o test_minGW.exe test_minGW.c 2>/dev/null; then
+    echo "✅ MinGW test compilation successful"
+    echo "   Output: $(./test_minGW.exe 2>/dev/null || echo 'Binary created, needs Windows to run')"
+    rm -f test_minGW.exe test_minGW.c
+else
+    echo "❌ MinGW test compilation failed"
+    echo "   You may need to restart your terminal or source your shell configuration"
+fi
+
+# Clean up
+rm -f test_minGW.c
+
+echo ""
+echo "🎉 WSL Windows build fix completed!"
+echo ""
+echo "📋 Next steps:"
+echo "1. Restart your terminal or run: source ~/.bashrc"
+echo "2. Try building Windows binary: npm run build-windows"
+echo "3. If you still have issues, try: npm run build-windows-static"
+echo ""
+echo "🔧 Additional options if problems persist:"
+echo "- Use MSVC toolchain: rustup toolchain install stable-x86_64-pc-windows-msvc"
+echo "- Build in native Windows environment"
+echo "- Use GitHub Actions for automated builds"
+echo ""
+echo "💡 For more help, see: WSL_BUILD_GUIDE.md"

package/scripts/install.js

@@ -0,0 +1,265 @@
+#!/usr/bin/env node
+
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+// Platform detection
+const platform = os.platform();
+console.log(`Detected platform: ${platform}`);
+console.log(`Detected architecture: ${os.arch()}`);
+
+// Map platforms to binary files
+const binaries = {
+  'win32': 'calculator_windows-x86-64.exe',
+  'linux': 'calculator_linux-x64'
+};
+
+// Check if platform is supported
+if (!binaries[platform]) {
+  console.error(`
+❌ Platform ${platform} is not supported by calculator-cli v0.1.0
+
+Supported platforms:
+- Windows (x64)
+- Linux (x64)
+
+For other platforms, please build from source:
+git clone https://github.com/anomalyco/calculator-cli.git
+cd calculator-cli
+cargo build --release
+  `);
+  process.exit(1);
+}
+
+// Binary path
+const binaryName = binaries[platform];
+const binaryPath = path.join(__dirname, '..', 'bin', binaryName);
+
+// Verify binary exists
+if (!fs.existsSync(binaryPath)) {
+  console.error(`❌ Binary not found: ${binaryPath}`);
+  console.error('Please ensure the binary files are present in the bin directory.');
+  console.error('For Windows users: Place calculator_windows-x86-64.exe in bin/');
+  console.error('For Linux users: Place calculator_linux-x64 in bin/');
+  process.exit(1);
+}
+
+// Create symlink or wrapper for node_modules/.bin
+const targetDir = path.join(__dirname, '..', 'node_modules', '.bin');
+const targetPath = path.join(targetDir, 'calculator');
+
+try {
+  // Ensure .bin directory exists
+  if (!fs.existsSync(targetDir)) {
+    fs.mkdirSync(targetDir, { recursive: true });
+  }
+
+  if (platform === 'win32') {
+    // Create a batch file wrapper for Windows
+    const batchContent = `@echo off
+"${binaryPath}" %*`;
+    fs.writeFileSync(`${targetPath}.cmd`, batchContent);
+    console.log('✅ Created Windows batch file');
+  } else {
+    // Create symbolic link for Unix-like systems
+    if (fs.existsSync(targetPath)) {
+      fs.unlinkSync(targetPath);
+    }
+    fs.symlinkSync(binaryPath, targetPath);
+    // Ensure executable permissions
+    fs.chmodSync(targetPath, '755');
+    console.log('✅ Created symbolic link with executable permissions');
+  }
+} catch (error) {
+  console.error(`❌ Failed to create command link: ${error.message}`);
+  process.exit(1);
+}
+
+console.log('✅ Installation complete!');
+console.log(`You can now run 'calculator' in your terminal.`);
+```
+
+<file_path>
+calculator-cli/scripts/postinstall.js
+</file_path>
+
+<edit_description>
+Create postinstall validation script
+</edit_description>
+
+```javascript
+#!/usr/bin/env node
+
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+console.log('✅ Validating calculator-cli installation...');
+
+// Check for proper binary based on platform
+const platform = os.platform();
+const expectedBinary = platform === 'win32'
+  ? 'calculator_windows-x86-64.exe'
+  : 'calculator_linux-x64';
+
+const binaryPath = path.join(__dirname, '..', 'bin', expectedBinary);
+
+if (fs.existsSync(binaryPath)) {
+  console.log(`✅ Binary found: ${expectedBinary}`);
+} else {
+  console.error(`❌ Binary not found: ${expectedBinary}`);
+  console.error('Please ensure the binary files are present in the bin directory.');
+  process.exit(1);
+}
+
+// Verify command is accessible
+const targetPath = path.join(__dirname, '..', 'node_modules', '.bin');
+const commandPath = platform === 'win32'
+  ? path.join(targetPath, 'calculator.cmd')
+  : path.join(targetPath, 'calculator');
+
+if (fs.existsSync(commandPath)) {
+  console.log('✅ Command link created successfully');
+} else {
+  console.error('❌ Command link not found');
+  process.exit(1);
+}
+
+console.log('✅ Installation validated successfully!');
+```
+
+<file_path>
+calculator-cli/scripts/test.js
+</file_path>
+
+<edit_description>
+Create test script to validate the binary
+</edit_description>
+
+```javascript
+#!/usr/bin/env node
+
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+const { execSync } = require('child_process');
+
+console.log('🧪 Testing calculator-cli binary...');
+
+// Platform detection
+const platform = os.platform();
+const binaryName = platform === 'win32'
+  ? 'calculator_windows-x86-64.exe'
+  : 'calculator_linux-x64';
+
+const binaryPath = path.join(__dirname, '..', 'bin', binaryName);
+
+// Check if binary exists
+if (!fs.existsSync(binaryPath)) {
+  console.error(`❌ Binary not found: ${binaryName}`);
+  process.exit(1);
+}
+
+// Test basic calculation
+try {
+  console.log('🧮 Testing basic calculation: 2 + 2');
+  const result = execSync(`"${binaryPath}" "2 + 2"`, { encoding: 'utf8' }).trim();
+
+  if (result && result.includes('4')) {
+    console.log(`✅ Basic calculation test passed: ${result}`);
+  } else {
+    console.log(`❌ Unexpected result: ${result}`);
+    process.exit(1);
+  }
+} catch (error) {
+  console.error(`❌ Failed to run binary: ${error.message}`);
+  process.exit(1);
+}
+
+// Test equation solving
+try {
+  console.log('🧮 Testing equation solving: x^2-4=0');
+  const equationResult = execSync(`"${binaryPath}" "x^2-4=0"`, { encoding: 'utf8' }).trim();
+
+  console.log(`✅ Equation solving result: ${equationResult}`);
+} catch (error) {
+  console.error(`❌ Failed to solve equation: ${error.message}`);
+  process.exit(1);
+}
+
+console.log('🎉 All tests passed! Calculator CLI is working correctly.');
+```
+
+<file_path>
+calculator-cli/index.js
+</file_path>
+
+<edit_description>
+Create simple entry point
+</edit_description>
+
+```javascript
+#!/usr/bin/env node
+
+// Entry point for the calculator-cli npm package
+// This file is minimal because the actual binary handles all functionality
+
+console.log('calculator-cli v0.1.0');
+console.log('Run "calculator <expression>" to use the calculator');
+```
+
+<file_path>
+calculator-cli/README.md
+</file_path>
+
+<edit_description>
+Create simple README for v0.1 release
+</edit_description>
+
+```markdown
+# Calculator CLI v0.1.0
+
+A lightweight command-line calculator with symbolic math support, available for Windows and Linux x64 platforms.
+
+## Quick Start
+
+1. Install: `npm install -g calculator-cli`
+2. Run: `calculator "2 + 2"` or `calculator "x^2-4=0"`
+3. For interactive mode: `calculator` (no arguments)
+
+## Features
+
+- Basic arithmetic operations
+- Equation solving
+- Complex number support
+- Fraction and symbolic output when possible
+
+## Supported Platforms
+
+- Windows (x64)
+- Linux (x64)
+
+## Usage Examples
+
+```bash
+# Basic calculations
+calculator "2 + 2"
+calculator "3 * (4 + 5)"
+
+# Equation solving
+calculator "x^2-4=0"
+calculator "x+y=5, x-y=1"
+
+# Complex numbers
+calculator "sqrt(-4)"
+calculator "(3+2i) * (1-i)"
+```
+
+## Installation Notes
+
+This package includes precompiled binaries for Windows and Linux x64. No Rust toolchain is required.
+
+## License
+
+MIT License

package/scripts/postinstall.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+
+const path = require("path");
+const fs = require("fs");
+const os = require("os");
+
+console.log("🔍 Validating calculator-cli installation...");
+
+// Platform detection
+const platform = os.platform();
+const expectedBinary =
+    platform === "win32"
+        ? "calculator_windows-x86-64.exe"
+        : "calculator_linux-x64";
+
+const binaryPath = path.join(__dirname, "..", "bin", expectedBinary);
+
+if (!fs.existsSync(binaryPath)) {
+    console.error(`❌ Required binary not found: ${expectedBinary}`);
+    process.exit(1);
+}
+
+if (!os.arch().includes("64")) {
+    console.warn("⚠️ Warning: 64-bit architecture recommended");
+}
+
+console.log("✅ Calculator CLI v0.1.0 is ready!");

package/scripts/setup-wsl.js

@@ -0,0 +1,112 @@
+#!/usr/bin/env node
+
+/*
+ * WSL Setup Script for calculator-cli
+ * This script installs all necessary tools and dependencies for building in WSL
+ */
+
+const { execSync } = require("child_process");
+const path = require("path");
+
+console.log("🐧 Setting up calculator-cli build environment in WSL...\n");
+
+// Function to run a command and display its output
+function runCommand(command, description) {
+    console.log(`🔧 ${description}...`);
+    try {
+        execSync(command, { stdio: "inherit" });
+        console.log("✅ Success\n");
+        return true;
+    } catch (error) {
+        console.log(`❌ Failed: ${error.message}\n`);
+        return false;
+    }
+}
+
+// Update package lists
+runCommand("sudo apt-get update", "Updating package lists");
+
+// Install build tools
+runCommand("sudo apt-get install -y build-essential", "Installing build tools");
+
+// Install mingw-w64 for Windows cross-compilation
+runCommand("sudo apt-get install -y mingw-w64", "Installing mingw-w64");
+
+// Try installing additional mingw packages if needed
+runCommand(
+    "sudo apt-get install -y gcc-mingw-w64-x86-64",
+    "Installing additional mingw packages",
+);
+
+// Install Rust targets
+console.log("🔧 Installing Rust target platforms...");
+try {
+    // Windows target
+    runCommand("rustup target add x86_64-pc-windows-gnu", {
+        stdio: "inherit",
+        maxBuffer: 1024 * 1024,
+    });
+    console.log("✅ Added x86_64-pc-windows-gnu target");
+
+    // Linux target (usually already installed)
+    try {
+        execSync("rustup target add x86_64-unknown-linux-gnu", {
+            stdio: "inherit",
+            maxBuffer: 1024 * 1024,
+        });
+        console.log("✅ Added x86_64-unknown-linux-gnu target");
+    } catch (e) {
+        console.log("ℹ️  Linux target may already be installed");
+    }
+    console.log("✅ Rust targets installed\n");
+} catch (error) {
+    console.log(`❌ Failed to install Rust targets: ${error.message}\n`);
+}
+
+// Set up environment variables for cross-compilation
+console.log("💡 Setting up environment variables...");
+console.log(`
+Add these lines to your ~/.bashrc or ~/.zshrc:
+export CARGO_TARGET_X86_64_PC_WINDOWS_GNU_LINKER=x86_64-w64-mingw32-gcc
+export CC_x86_64_pc_windows_gnu=x86_64-w64-mingw32-gcc
+export CXX_x86_64_pc_windows_gnu=x86_64-w64-mingw32-g++
+
+Then run: source ~/.bashrc or source ~/.zshrc
+`);
+
+// Verify installation
+console.log("🔍 Verifying installation...");
+try {
+    // Check mingw installation
+    execSync("x86_64-w64-mingw32-gcc --version", {
+        stdio: "inherit",
+        maxBuffer: 1024 * 1024,
+    });
+    console.log("✅ MinGW-w64 is properly installed");
+} catch (error) {
+    console.log(
+        "⚠️  MinGW-w64 verification failed, but installation may have succeeded",
+    );
+}
+
+try {
+    // Check Rust targets
+    const targets = execSync("rustup target list --installed", {
+        encoding: "utf8",
+        maxBuffer: 1024 * 1024,
+    });
+    if (targets.includes("x86_64-pc-windows-gnu")) {
+        console.log("✅ Windows target is installed");
+    } else {
+        console.log("⚠️  Windows target may not be properly installed");
+    }
+} catch (error) {
+    console.log("⚠️  Could not verify Rust targets");
+}
+
+console.log("\n🎉 WSL setup completed!");
+console.log("\n📦 Next steps:");
+console.log("1. Set up environment variables (see instructions above)");
+console.log("2. Run: npm run build-binaries");
+console.log("3. Test the built binaries");
+console.log("\n💡 For more information, see WSL_BUILD_GUIDE.md");