mathcalc-cli 0.2.0 → 0.2.1

package/README.md

@@ -8,22 +8,36 @@ A lightweight Rust command-line calculator capable of evaluating real/complex ex
 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:
+### npm全局安装（推荐）
+```bash
+npm install -g mathcalc-cli
+mathcalc "2 + 2"
+mathcalc "x^2-5x+6=0"
+```
 
+### npx方式（无需全局安装）
 ```bash
-npm install -g calculator-cli
+npx mathcalc-cli "2 + 2"
+npx mathcalc-cli "x^2-5x+6=0"
 ```
 
-Once installed, you can run:
+### 本地项目使用
+```bash
+npm install mathcalc-cli
+npx mathcalc-cli "2 + 2"
+```
 
+### 从GitHub Release下载
 ```bash
-calculator "2 + 2"
-calculator "x^2-5x+6=0"
+https://github.com/Mcas-996/calculator-cli/releases
 ```
 
+下载对应平台的二进制文件
+```
+
+
 ### For ARM Systems (Apple Silicon, ARM64 Linux)
 The npm package includes precompiled binaries only for x64 systems. For ARM systems:
 

package/index.js

@@ -1,40 +1,89 @@
 #!/usr/bin/env node
 
-// Entry point for the calculator-cli npm package
-// This is a minimal wrapper that delegates to the compiled binary
-
+const os = require("os");
 const path = require("path");
+const fs = require("fs");
 const { spawnSync } = require("child_process");
-const os = require("os");
 
-// Determine the appropriate binary based on platform
+// Determine platform and appropriate binary
 const platform = os.platform();
 const isWindows = platform === "win32";
+const arch = os.arch();
 
-// Binary file names
-const binaryName = isWindows
-    ? "calculator_windows-x86-64.exe"
-    : "calculator_linux-x64";
-const binaryPath = path.join(__dirname, "bin", binaryName);
+if (!arch.includes("64")) {
+    console.error("❌ Calculator CLI only supports 64-bit architectures");
+    process.exit(1);
+}
 
-function runCalculator(args) {
-    if (!require("fs").existsSync(binaryPath)) {
-        console.error(`Error: Calculator binary not found for ${platform}`);
-        process.exit(1);
-    }
+let binaryPath, calculatorName;
 
+if (isWindows) {
+    calculatorName = "calculator_windows-x86-64.exe";
+    binaryPath = path.join(__dirname, "bin", calculatorName);
+} else if (platform === "linux") {
+    calculatorName = "calculator-linux-x64";
+    binaryPath = path.join(__dirname, "bin", calculatorName);
+} else {
+    console.error("❌ Platform not supported:", platform);
+    console.log(
+        "For macOS (Apple Silicon) or other platforms, please install from source:",
+    );
+    console.log("  cargo install calculator");
+    process.exit(1);
+}
+
+// Check if binary exists
+if (!fs.existsSync(binaryPath)) {
+    console.error(`❌ Calculator binary not found: ${calculatorName}`);
+    console.log(
+        "Please ensure the binary files are present in the bin directory.",
+    );
+    console.log("\nFor Windows:");
+    console.log("  Place calculator_windows-x86-64.exe in bin/");
+    console.log("\nFor Linux:");
+    console.log("  Place calculator-linux-x64 in bin/");
+    console.log("\nDownload releases from:");
+    console.log("  https://github.com/Mcas-996/calculator-cli/releases");
+    process.exit(1);
+}
+
+// Make sure binary is executable (Unix-like systems)
+if (!isWindows) {
     try {
-        const result = spawnSync(binaryPath, args, { stdio: "inherit" });
-        process.exit(result.status);
-    } catch (error) {
-        console.error(`Error: ${error.message}`);
-        process.exit(1);
+        fs.chmodSync(binaryPath, "755");
+    } catch (err) {
+        console.warn(
+            `⚠️ Warning: Could not set executable permissions: ${err.message}`,
+        );
     }
 }
 
-// If called from npm scripts, pass all arguments to the binary
-if (require.main === module) {
-    runCalculator(process.argv.slice(2));
+// Handle command line arguments
+const args = process.argv.slice(2);
+
+if (args.length === 0) {
+    // Display help when no arguments provided
+    console.log("Calculator CLI v0.2.0 - Command Line Calculator");
+    console.log("");
+    console.log("Usage:");
+    console.log('  mathcalc "expression"    Calculate an expression');
+    console.log('  mathcalc "equation"     Solve an equation');
+    console.log("  mathcalc                Interactive mode");
+    console.log("");
+    console.log("Examples:");
+    console.log('  mathcalc "2 + 2"        # => 4');
+    console.log('  mathcalc "x^2-4=0"      # => x = 2, -2');
+    console.log('  mathcalc "(3+2i)*(1-i)" # => 5 + i');
+    console.log("");
+    console.log("For more help:");
+    console.log("  mathcalc --help");
+    process.exit(0);
 }
 
-module.exports = { runCalculator };
+try {
+    const result = spawnSync(binaryPath, args, { stdio: "inherit" });
+    process.exit(result.status || 0);
+} catch (error) {
+    console.error(`Error: ${error.message}`);
+    process.exit(1);
+}

package/package.json

@@ -1,10 +1,10 @@
 {
     "name": "mathcalc-cli",
-    "version": "0.2.0",
+    "version": "0.2.1",
     "description": "A command-line calculator with symbolic math support",
     "main": "index.js",
     "bin": {
-        "calculator": "bin/calculator_linux-x64"
+        "mathcalc": "index.js"
     },
     "scripts": {
         "preinstall": "node scripts/install.js",
@@ -22,11 +22,11 @@
         "command-line",
         "equations"
     ],
-    "author": "Allen <anomalyco@github.com>",
+    "author": "allen",
     "license": "MIT",
     "os": [
-        "linux",
-        "win32"
+        "win32",
+        "linux"
     ],
     "cpu": [
         "x64"

package/scripts/install.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
-const path = require('path');
-const fs = require('fs');
-const os = require('os');
+const path = require("path");
+const fs = require("fs");
+const os = require("os");
 
 // Platform detection
 const platform = os.platform();
@@ -11,255 +11,89 @@ console.log(`Detected architecture: ${os.arch()}`);
 
 // Map platforms to binary files
 const binaries = {
-  'win32': 'calculator_windows-x86-64.exe',
-  'linux': 'calculator_linux-x64'
+    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
+    console.error(`
+❌ Platform ${platform} is not supported by mathcalc-cli v0.2.0
 
 Supported platforms:
 - Windows (x64)
 - Linux (x64)
 
 For other platforms, please build from source:
-git clone https://github.com/anomalyco/calculator-cli.git
+git clone https://github.com/Mcas-996/calculator-cli.git
 cd calculator-cli
 cargo build --release
   `);
-  process.exit(1);
+    process.exit(1);
 }
 
 // Binary path
 const binaryName = binaries[platform];
-const binaryPath = path.join(__dirname, '..', 'bin', binaryName);
+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);
+    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');
+const targetDir = path.join(__dirname, "..", "node_modules", ".bin");
+const targetPath = path.join(targetDir, "mathcalc");
 
 try {
-  // Ensure .bin directory exists
-  if (!fs.existsSync(targetDir)) {
-    fs.mkdirSync(targetDir, { recursive: true });
-  }
+    // 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
+    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.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");
     }
-    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.error(`❌ Failed to create command link: ${error.message}`);
+    console.error("Creating alternative wrapper script...");
+
+    try {
+        // Create a wrapper script instead
+        const wrapperContent = `#!/usr/bin/env node
+const { spawnSync } = require('child_process');
+const result = spawnSync('${binaryPath}', process.argv.slice(2), { stdio: 'inherit' });
+process.exit(result.status || 0);
+`;
+        fs.writeFileSync(targetPath, wrapperContent);
+        fs.chmodSync(targetPath, "755");
+        console.log("✅ Created wrapper script");
+    } catch (wrapperError) {
+        console.error(`❌ Failed to create wrapper: ${wrapperError.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
+console.log("✅ Installation complete!");
+console.log(`You can now run 'mathcalc' in your terminal.`);

package/scripts/postinstall.js

@@ -4,14 +4,14 @@ const path = require("path");
 const fs = require("fs");
 const os = require("os");
 
-console.log("🔍 Validating calculator-cli installation...");
+console.log("🔍 Validating mathcalc-cli installation...");
 
 // Platform detection
 const platform = os.platform();
 const expectedBinary =
     platform === "win32"
         ? "calculator_windows-x86-64.exe"
-        : "calculator_linux-x64";
+        : "calculator-linux-x64";
 
 const binaryPath = path.join(__dirname, "..", "bin", expectedBinary);
 
@@ -24,4 +24,4 @@ if (!os.arch().includes("64")) {
     console.warn("⚠️ Warning: 64-bit architecture recommended");
 }
 
-console.log("✅ Calculator CLI v0.1.0 is ready!");
+console.log("✅ MathCalc CLI v0.2.0 is ready!");

package/scripts/test.js

@@ -0,0 +1,107 @@
+#!/usr/bin/env node
+
+const { spawnSync } = require("child_process");
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+
+console.log("🧪 Testing calculator-cli package functionality...\n");
+
+// 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);
+
+// Test 1: Check if binary exists
+console.log("1. Checking binary existence...");
+if (!fs.existsSync(binaryPath)) {
+    console.error(`❌ Binary not found: ${binaryName}`);
+    process.exit(1);
+}
+console.log(`✅ Found binary: ${binaryName}`);
+
+// Test 2: Test basic calculation
+console.log("\n2. Testing basic calculation: 2 + 2");
+try {
+    const result = spawnSync(binaryPath, ["2 + 2"], { encoding: "utf8" });
+
+    if (result.status === 0) {
+        console.log(`✅ Calculation result: ${result.stdout.trim()}`);
+    } else {
+        console.error(`❌ Calculation failed with status ${result.status}`);
+        console.error(`Error output: ${result.stderr}`);
+        process.exit(1);
+    }
+} catch (error) {
+    console.error(`❌ Failed to run binary: ${error.message}`);
+    process.exit(1);
+}
+
+// Test 3: Test equation solving
+console.log("\n3. Testing equation solving: x^2-4=0");
+try {
+    const equationResult = spawnSync(binaryPath, ["x^2-4=0"], {
+        encoding: "utf8",
+    });
+
+    if (equationResult.status === 0) {
+        console.log(`✅ Equation result: ${equationResult.stdout.trim()}`);
+    } else {
+        console.error(
+            `❌ Equation solving failed with status ${equationResult.status}`,
+        );
+        console.error(`Error output: ${equationResult.stderr}`);
+        process.exit(1);
+    }
+} catch (error) {
+    console.error(`❌ Failed to solve equation: ${error.message}`);
+    process.exit(1);
+}
+
+// Test 4: Test complex numbers
+console.log("\n4. Testing complex numbers: sqrt(-4)");
+try {
+    const complexResult = spawnSync(binaryPath, ["sqrt(-4)"], {
+        encoding: "utf8",
+    });
+
+    if (complexResult.status === 0) {
+        console.log(`✅ Complex number result: ${complexResult.stdout.trim()}`);
+    } else {
+        console.error(
+            `❌ Complex number calculation failed with status ${complexResult.status}`,
+        );
+        console.error(`Error output: ${complexResult.stderr}`);
+        process.exit(1);
+    }
+} catch (error) {
+    console.error(`❌ Failed to calculate complex number: ${error.message}`);
+    process.exit(1);
+}
+
+// Test 5: Test index.js entry point
+console.log("\n5. Testing index.js entry point...");
+try {
+    const indexResult = spawnSync(
+        "node",
+        [path.join(__dirname, "..", "index.js"), "--help"],
+        { encoding: "utf8" },
+    );
+
+    if (indexResult.status === 0) {
+        console.log("✅ index.js help command works");
+    } else {
+        console.log(
+            `ℹ️  index.js returned status ${indexResult.status} (this may be expected)`,
+        );
+    }
+} catch (error) {
+    console.error(`❌ Failed to run index.js: ${error.message}`);
+    process.exit(1);
+}
+
+console.log("\n🎉 All tests passed! Calculator CLI is ready for distribution.");

package/scripts/build-binaries.js

@@ -1,482 +0,0 @@
-#!/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

@@ -1,148 +0,0 @@
-#!/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"