@sparkleideas/cuda-wasm 1.1.2

package/package.json

@@ -0,0 +1,185 @@
+{
+  "name": "@sparkleideas/cuda-wasm",
+  "version": "1.1.2",
+  "description": "High-performance CUDA to WebAssembly/WebGPU transpiler with Rust safety - Run GPU kernels in browsers and Node.js",
+  "main": "dist/index.js",
+  "module": "dist/index.esm.js",
+  "types": "dist/index.d.ts",
+  "browser": "dist/index.browser.js",
+  "bin": {
+    "@sparkleideas/cuda-wasm": "./cli/index.js"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.esm.js",
+      "require": "./dist/index.js",
+      "browser": "./dist/index.browser.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./wasm": {
+      "import": "./dist/cuda_rust_wasm_bg.wasm",
+      "require": "./dist/cuda_rust_wasm_bg.wasm"
+    }
+  },
+  "scripts": {
+    "build": "npm run clean && npm run build:rust && npm run build:wasm && npm run build:node && npm run build:types",
+    "build:all": "npm run build",
+    "build:rust": "cargo build --release --features optimized-build",
+    "build:rust:native": "cargo build --release --features native-gpu,optimized-build,parallel-compilation",
+    "build:rust:wasm": "cargo build --profile wasm --target wasm32-unknown-unknown --features wasm-simd",
+    "build:wasm": "./scripts/build-wasm.sh",
+    "build:wasm:dev": "BUILD_MODE=dev ./scripts/build-wasm.sh",
+    "build:wasm:size": "OPTIMIZE_SIZE=true BUILD_MODE=release ./scripts/build-wasm.sh",
+    "build:wasm:speed": "OPTIMIZE_SIZE=false BUILD_MODE=release ./scripts/build-wasm.sh",
+    "build:wasm:simd": "ENABLE_SIMD=true ./scripts/build-wasm.sh",
+    "build:node": "node-gyp rebuild",
+    "build:types": "tsc --declaration --emitDeclarationOnly --outDir dist",
+    "clean": "rm -rf dist build pkg target/wasm32-unknown-unknown .cargo-cache",
+    "clean:full": "cargo clean && npm run clean",
+    "clean:cache": "ENABLE_CACHE=false ./scripts/build-wasm.sh clean",
+    "test": "npm run test:rust && npm run test:node && npm run test:integration",
+    "test:rust": "cargo test --features native-gpu,optimized-build",
+    "test:wasm": "cargo test --target wasm32-unknown-unknown --features wasm-simd",
+    "test:node": "jest --passWithNoTests",
+    "test:integration": "node scripts/test-integration.js",
+    "test:package": "npm pack && npm install -g ./cuda-wasm-core-*.tgz && npm run test:smoke",
+    "test:smoke": "cuda-wasm --help && node -e 'require(\"cuda-rust-wasm\")'",
+    "test:bench": "cargo bench --features native-gpu",
+    "test:coverage": "cargo tarpaulin --out html --output-dir coverage --features native-gpu",
+    "test:memory": "valgrind --tool=memcheck cargo test --features native-gpu",
+    "lint": "cargo clippy --features native-gpu -- -W clippy::all && eslint cli/ --ext .js --fix",
+    "lint:rust": "cargo clippy --features native-gpu -- -D warnings",
+    "lint:js": "eslint cli/ --ext .js --fix",
+    "format": "cargo fmt && prettier --write 'cli/**/*.js' 'scripts/**/*.js'",
+    "format:check": "cargo fmt -- --check && prettier --check 'cli/**/*.js' 'scripts/**/*.js'",
+    "audit": "cargo audit && npm audit",
+    "prebuild": "echo 'Skipping build checks'",
+    "prepublishOnly": "echo 'Publishing dist files'",
+    "postinstall": "node scripts/postinstall.js",
+    "demo": "cd demo && npm start",
+    "docs": "cargo doc --open --features native-gpu,optimized-build",
+    "docs:build": "cargo doc --no-deps --features native-gpu,optimized-build",
+    "size-analysis": "npm run build:wasm && twiggy top dist/cuda_rust_wasm_bg.wasm -n 20",
+    "benchmark": "cargo bench --features native-gpu && node cli/benchmark.js",
+    "benchmark:wasm": "npm run build:wasm && node scripts/benchmark-wasm.js",
+    "profile": "cargo build --profile bench --features native-gpu && perf record target/release/cuda2rust",
+    "dev": "npm run build:wasm:dev && npm run test:node",
+    "dev:watch": "cargo watch -x 'build --profile wasm-dev --target wasm32-unknown-unknown'",
+    "ci": "npm run format:check && npm run lint && npm run test && npm run build && npm run audit",
+    "ci:quick": "npm run lint:rust && cargo test --features native-gpu",
+    "version": "npm run build && git add dist/",
+    "postversion": "git push && git push --tags",
+    "release": "npm run ci && npm version patch && npm publish",
+    "release:minor": "npm run ci && npm version minor && npm publish",
+    "release:major": "npm run ci && npm version major && npm publish"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ruvnet/ruv-FANN.git",
+    "directory": "cuda-wasm"
+  },
+  "keywords": [
+    "cuda",
+    "webassembly",
+    "wasm",
+    "webgpu",
+    "gpu",
+    "parallel-computing",
+    "transpiler",
+    "rust",
+    "scientific-computing",
+    "machine-learning",
+    "high-performance-computing",
+    "browser-gpu",
+    "compute-shaders",
+    "nvidia",
+    "opencl",
+    "vulkan",
+    "performance",
+    "compiler",
+    "kernel",
+    "simd"
+  ],
+  "author": {
+    "name": "CUDA-WASM Team",
+    "url": "https://github.com/ruvnet/ruv-FANN"
+  },
+  "contributors": [
+    {
+      "name": "VibeCast Team",
+      "url": "https://github.com/vibecast"
+    }
+  ],
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/ruvnet/ruv-FANN/issues"
+  },
+  "homepage": "https://github.com/ruvnet/ruv-FANN/tree/main/cuda-wasm#readme",
+  "funding": {
+    "type": "github",
+    "url": "https://github.com/sponsors/ruvnet"
+  },
+  "dependencies": {
+    "commander": "^11.1.0",
+    "chalk": "^4.1.2",
+    "semver": "^7.5.4"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "@types/jest": "^29.5.8",
+    "jest": "^29.7.0",
+    "node-gyp": "^10.0.1",
+    "typescript": "^5.3.2",
+    "eslint": "^8.55.0",
+    "prettier": "^3.1.0",
+    "@typescript-eslint/eslint-plugin": "^6.13.0",
+    "@typescript-eslint/parser": "^6.13.0"
+  },
+  "engines": {
+    "node": ">=16.0.0",
+    "npm": ">=8.0.0"
+  },
+  "os": [
+    "linux",
+    "darwin",
+    "win32"
+  ],
+  "cpu": [
+    "x64",
+    "arm64"
+  ],
+  "files": [
+    "dist/",
+    "cli/",
+    "bindings/",
+    "scripts/postinstall.js",
+    "scripts/test-integration.js",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md",
+    "pkg/cuda_rust_wasm_bg.wasm"
+  ],
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public",
+    "tag": "latest"
+  },
+  "browserslist": [
+    "> 1%",
+    "last 2 versions",
+    "not dead",
+    "Chrome >= 80",
+    "Firefox >= 78",
+    "Safari >= 14",
+    "Edge >= 80"
+  ],
+  "ava": {
+    "extensions": [
+      "js",
+      "ts"
+    ],
+    "require": [
+      "ts-node/register"
+    ]
+  }
+}

package/scripts/postinstall.js

@@ -0,0 +1,95 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+console.log('🚀 CUDA-Rust-WASM Post-install Setup');
+
+// Check if we're in development (npm link) or production
+const isDev = process.env.npm_lifecycle_event === 'install' && 
+              process.cwd().includes('cuda-rust-wasm');
+
+if (isDev) {
+  console.log('📋 Development mode detected, skipping post-install');
+  process.exit(0);
+}
+
+// Check for WebAssembly support
+try {
+  new WebAssembly.Module(new Uint8Array([0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00]));
+  console.log('✅ WebAssembly support detected');
+} catch (e) {
+  console.warn('⚠️  WebAssembly not supported in this environment');
+  console.warn('   Some features may not be available');
+}
+
+// Check for native dependencies
+const optionalDeps = [
+  { name: 'node-gyp', install: 'npm install -g node-gyp' },
+  { name: 'wasm-pack', install: 'cargo install wasm-pack' },
+  { name: 'wasm-opt', install: 'npm install -g wasm-opt' }
+];
+
+console.log('📋 Checking optional dependencies...');
+optionalDeps.forEach(dep => {
+  try {
+    execSync(`which ${dep.name}`, { stdio: 'ignore' });
+    console.log(`  ✅ ${dep.name} found`);
+  } catch (e) {
+    console.log(`  ⚠️  ${dep.name} not found`);
+    console.log(`     Install with: ${dep.install}`);
+  }
+});
+
+// Create example directory if it doesn't exist
+const exampleDir = path.join(process.cwd(), 'cuda-examples');
+if (!fs.existsSync(exampleDir)) {
+  console.log('📁 Creating example directory...');
+  fs.mkdirSync(exampleDir, { recursive: true });
+  
+  // Create a simple example
+  const exampleContent = `// Example: Vector Addition
+const { transpileCuda } = require('cuda-rust-wasm');
+
+const cudaCode = \`
+__global__ void vectorAdd(float* a, float* b, float* c, int n) {
+    int tid = blockIdx.x * blockDim.x + threadIdx.x;
+    if (tid < n) {
+        c[tid] = a[tid] + b[tid];
+    }
+}
+\`;
+
+async function main() {
+  try {
+    const result = await transpileCuda(cudaCode, { 
+      target: 'wasm',
+      optimize: true 
+    });
+    
+    console.log('✅ Transpilation successful!');
+    console.log('Generated code length:', result.code.length);
+    
+    if (result.wasmBinary) {
+      console.log('WASM binary size:', result.wasmBinary.length, 'bytes');
+    }
+  } catch (error) {
+    console.error('❌ Transpilation failed:', error.message);
+  }
+}
+
+main();
+`;
+  
+  fs.writeFileSync(
+    path.join(exampleDir, 'vector_add.js'),
+    exampleContent
+  );
+  
+  console.log('✅ Example created at cuda-examples/vector_add.js');
+}
+
+console.log('\n🎉 CUDA-Rust-WASM setup complete!');
+console.log('📚 Documentation: https://github.com/vibecast/cuda-rust-wasm');
+console.log('🚀 Get started with: npx cuda-rust-wasm --help\n');

package/scripts/test-integration.js

@@ -0,0 +1,393 @@
+#!/usr/bin/env node
+
+/**
+ * Integration test suite for @cuda-wasm/core
+ * Tests the complete pipeline from CUDA code to execution
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+
+// Test colors
+const colors = {
+  reset: '\x1b[0m',
+  green: '\x1b[32m',
+  red: '\x1b[31m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  cyan: '\x1b[36m'
+};
+
+function log(message, color = 'reset') {
+  console.log(colors[color] + message + colors.reset);
+}
+
+class IntegrationTester {
+  constructor() {
+    this.tests = [];
+    this.passed = 0;
+    this.failed = 0;
+  }
+
+  addTest(name, testFn) {
+    this.tests.push({ name, testFn });
+  }
+
+  async runTests() {
+    log('\n🧪 Running CUDA-WASM Integration Tests\n', 'cyan');
+
+    for (const test of this.tests) {
+      try {
+        log(`Running: ${test.name}`, 'blue');
+        await test.testFn();
+        log(`✅ PASSED: ${test.name}`, 'green');
+        this.passed++;
+      } catch (error) {
+        log(`❌ FAILED: ${test.name}`, 'red');
+        log(`   Error: ${error.message}`, 'red');
+        this.failed++;
+      }
+    }
+
+    log(`\n📊 Test Results:`, 'cyan');
+    log(`   ✅ Passed: ${this.passed}`, 'green');
+    log(`   ❌ Failed: ${this.failed}`, this.failed > 0 ? 'red' : 'green');
+    log(`   📈 Success Rate: ${((this.passed / this.tests.length) * 100).toFixed(1)}%`, 
+        this.failed === 0 ? 'green' : 'yellow');
+
+    return this.failed === 0;
+  }
+
+  async runCommand(command, args = []) {
+    return new Promise((resolve, reject) => {
+      const proc = spawn(command, args, { 
+        stdio: ['pipe', 'pipe', 'pipe'],
+        shell: process.platform === 'win32'
+      });
+      
+      let stdout = '';
+      let stderr = '';
+      
+      proc.stdout.on('data', (data) => {
+        stdout += data.toString();
+      });
+      
+      proc.stderr.on('data', (data) => {
+        stderr += data.toString();
+      });
+      
+      proc.on('close', (code) => {
+        if (code === 0) {
+          resolve({ stdout, stderr });
+        } else {
+          reject(new Error(`Command failed with code ${code}: ${stderr}`));
+        }
+      });
+    });
+  }
+}
+
+// Sample CUDA kernels for testing
+const testKernels = {
+  vectorAdd: `
+__global__ void vectorAdd(float* a, float* b, float* c, int n) {
+    int tid = blockIdx.x * blockDim.x + threadIdx.x;
+    if (tid < n) {
+        c[tid] = a[tid] + b[tid];
+    }
+}
+`,
+
+  matrixMultiply: `
+__global__ void matrixMul(float* A, float* B, float* C, int N) {
+    int row = blockIdx.y * blockDim.y + threadIdx.y;
+    int col = blockIdx.x * blockDim.x + threadIdx.x;
+    
+    if (row < N && col < N) {
+        float sum = 0.0f;
+        for (int k = 0; k < N; k++) {
+            sum += A[row * N + k] * B[k * N + col];
+        }
+        C[row * N + col] = sum;
+    }
+}
+`,
+
+  reduction: `
+__global__ void reduce(float* input, float* output, int n) {
+    __shared__ float sdata[256];
+    
+    int tid = threadIdx.x;
+    int i = blockIdx.x * blockDim.x + threadIdx.x;
+    
+    sdata[tid] = (i < n) ? input[i] : 0;
+    __syncthreads();
+    
+    for (int s = blockDim.x / 2; s > 0; s >>= 1) {
+        if (tid < s) {
+            sdata[tid] += sdata[tid + s];
+        }
+        __syncthreads();
+    }
+    
+    if (tid == 0) output[blockIdx.x] = sdata[0];
+}
+`
+};
+
+async function main() {
+  const tester = new IntegrationTester();
+
+  // Test 1: Package installation
+  tester.addTest('Package can be imported', async () => {
+    try {
+      const cudaWasm = require('../dist/index.js');
+      if (!cudaWasm.transpileCuda) {
+        throw new Error('Main function not exported');
+      }
+      if (!cudaWasm.getVersion) {
+        throw new Error('Version function not exported');
+      }
+    } catch (error) {
+      throw new Error(`Failed to import package: ${error.message}`);
+    }
+  });
+
+  // Test 2: CLI availability
+  tester.addTest('CLI tool is accessible', async () => {
+    try {
+      const result = await tester.runCommand('node', ['cli/index.js', '--help']);
+      if (!result.stdout.includes('cuda-wasm')) {
+        throw new Error('CLI help does not contain expected content');
+      }
+    } catch (error) {
+      throw new Error(`CLI not accessible: ${error.message}`);
+    }
+  });
+
+  // Test 3: Version command
+  tester.addTest('Version command works', async () => {
+    try {
+      const cudaWasm = require('../dist/index.js');
+      const version = cudaWasm.getVersion();
+      
+      if (!version.version || !version.features) {
+        throw new Error('Version info incomplete');
+      }
+    } catch (error) {
+      throw new Error(`Version command failed: ${error.message}`);
+    }
+  });
+
+  // Test 4: Basic transpilation
+  tester.addTest('Basic CUDA transpilation', async () => {
+    try {
+      const cudaWasm = require('../dist/index.js');
+      const result = await cudaWasm.transpileCuda(testKernels.vectorAdd, {
+        target: 'wasm',
+        optimize: false
+      });
+      
+      if (!result.code || result.code.length === 0) {
+        throw new Error('No transpiled code generated');
+      }
+    } catch (error) {
+      throw new Error(`Transpilation failed: ${error.message}`);
+    }
+  });
+
+  // Test 5: Kernel analysis
+  tester.addTest('Kernel analysis functionality', async () => {
+    try {
+      const cudaWasm = require('../dist/index.js');
+      const analysis = await cudaWasm.analyzeKernel(testKernels.vectorAdd);
+      
+      if (typeof analysis.threadUtilization !== 'number') {
+        throw new Error('Analysis missing thread utilization');
+      }
+      
+      if (!Array.isArray(analysis.suggestions)) {
+        throw new Error('Analysis missing suggestions array');
+      }
+    } catch (error) {
+      throw new Error(`Kernel analysis failed: ${error.message}`);
+    }
+  });
+
+  // Test 6: Code validation
+  tester.addTest('CUDA code validation', async () => {
+    try {
+      const cudaWasm = require('../dist/index.js');
+      
+      const validResult = cudaWasm.validateCudaCode(testKernels.vectorAdd);
+      if (!validResult.isValid && validResult.errors.length > 0) {
+        throw new Error('Valid CUDA code marked as invalid');
+      }
+      
+      const invalidResult = cudaWasm.validateCudaCode('invalid code');
+      if (invalidResult.warnings.length === 0) {
+        throw new Error('Invalid code should generate warnings');
+      }
+    } catch (error) {
+      throw new Error(`Code validation failed: ${error.message}`);
+    }
+  });
+
+  // Test 7: Kernel parsing
+  tester.addTest('CUDA kernel parsing', async () => {
+    try {
+      const cudaWasm = require('../dist/index.js');
+      const kernels = cudaWasm.parseCudaKernels(testKernels.vectorAdd);
+      
+      if (!Array.isArray(kernels) || kernels.length === 0) {
+        throw new Error('No kernels parsed from valid CUDA code');
+      }
+      
+      if (kernels[0].name !== 'vectorAdd') {
+        throw new Error('Incorrect kernel name parsed');
+      }
+    } catch (error) {
+      throw new Error(`Kernel parsing failed: ${error.message}`);
+    }
+  });
+
+  // Test 8: Benchmark functionality
+  tester.addTest('Benchmark functionality', async () => {
+    try {
+      const cudaWasm = require('../dist/index.js');
+      const benchmark = await cudaWasm.benchmark(testKernels.vectorAdd, {
+        iterations: 5,
+        warmupIterations: 2
+      });
+      
+      if (typeof benchmark.avgTime !== 'number' || benchmark.avgTime <= 0) {
+        throw new Error('Invalid benchmark timing');
+      }
+      
+      if (typeof benchmark.throughput !== 'number') {
+        throw new Error('Missing throughput measurement');
+      }
+    } catch (error) {
+      throw new Error(`Benchmark failed: ${error.message}`);
+    }
+  });
+
+  // Test 9: WebGPU availability check
+  tester.addTest('WebGPU availability check', async () => {
+    try {
+      const cudaWasm = require('../dist/index.js');
+      const available = cudaWasm.isWebGPUAvailable();
+      
+      // In Node.js environment, this should return false
+      if (available !== false) {
+        log('   Note: WebGPU availability check behavior may vary by environment', 'yellow');
+      }
+    } catch (error) {
+      throw new Error(`WebGPU availability check failed: ${error.message}`);
+    }
+  });
+
+  // Test 10: Complex kernel transpilation
+  tester.addTest('Complex kernel transpilation', async () => {
+    try {
+      const cudaWasm = require('../dist/index.js');
+      const result = await cudaWasm.transpileCuda(testKernels.reduction, {
+        target: 'wasm',
+        optimize: true,
+        profile: true
+      });
+      
+      if (!result.code) {
+        throw new Error('No code generated for complex kernel');
+      }
+      
+      if (!result.profile) {
+        throw new Error('Profiling data not generated');
+      }
+      
+      if (typeof result.profile.totalTime !== 'number') {
+        throw new Error('Invalid profiling data');
+      }
+    } catch (error) {
+      throw new Error(`Complex kernel transpilation failed: ${error.message}`);
+    }
+  });
+
+  // Test 11: File operations test
+  tester.addTest('CLI file operations', async () => {
+    try {
+      // Create a temporary CUDA file
+      const tempFile = path.join(__dirname, 'temp_kernel.cu');
+      fs.writeFileSync(tempFile, testKernels.vectorAdd);
+      
+      try {
+        // Test CLI transpilation with file input
+        const result = await tester.runCommand('node', [
+          'cli/index.js', 
+          'transpile', 
+          tempFile, 
+          '--output', 
+          'temp_output.wasm'
+        ]);
+        
+        if (!result.stdout.includes('Transpilation complete') && 
+            !result.stdout.includes('Success')) {
+          throw new Error('CLI transpilation did not complete successfully');
+        }
+      } finally {
+        // Cleanup
+        if (fs.existsSync(tempFile)) {
+          fs.unlinkSync(tempFile);
+        }
+        const outputFile = path.join(__dirname, 'temp_output.wasm');
+        if (fs.existsSync(outputFile)) {
+          fs.unlinkSync(outputFile);
+        }
+      }
+    } catch (error) {
+      throw new Error(`CLI file operations failed: ${error.message}`);
+    }
+  });
+
+  // Test 12: TypeScript definitions
+  tester.addTest('TypeScript definitions available', async () => {
+    try {
+      const typesFile = path.join(__dirname, '../dist/index.d.ts');
+      
+      if (!fs.existsSync(typesFile)) {
+        throw new Error('TypeScript definitions file not found');
+      }
+      
+      const typesContent = fs.readFileSync(typesFile, 'utf8');
+      
+      if (!typesContent.includes('TranspileOptions') || 
+          !typesContent.includes('transpileCuda')) {
+        throw new Error('TypeScript definitions incomplete');
+      }
+    } catch (error) {
+      throw new Error(`TypeScript definitions test failed: ${error.message}`);
+    }
+  });
+
+  // Run all tests
+  const success = await tester.runTests();
+  
+  if (success) {
+    log('\n🎉 All integration tests passed!', 'green');
+    process.exit(0);
+  } else {
+    log('\n💥 Some integration tests failed!', 'red');
+    process.exit(1);
+  }
+}
+
+// Run tests if this file is executed directly
+if (require.main === module) {
+  main().catch((error) => {
+    log(`\n💥 Integration test runner failed: ${error.message}`, 'red');
+    process.exit(1);
+  });
+}
+
+module.exports = { IntegrationTester, testKernels };