feat: Enhance Rust build scripts and add binary copying functionality

Author: Marvin Zhang

package.json

@@ -28,8 +28,10 @@
     "docs:dev": "pnpm --dir docs-site start",
     "docs:build": "pnpm --dir docs-site build",
     "docs:serve": "pnpm --dir docs-site serve",
-    "rust:build": "cargo build --release --manifest-path rust/Cargo.toml",
-    "rust:build:dev": "cargo build --manifest-path rust/Cargo.toml",
+    "rust:build": "cargo build --release --manifest-path rust/Cargo.toml && node scripts/copy-rust-binaries.mjs",
+    "rust:build:dev": "cargo build --manifest-path rust/Cargo.toml && node scripts/copy-rust-binaries.mjs",
+    "rust:build:all": "cargo build --release --manifest-path rust/Cargo.toml && node scripts/copy-rust-binaries.mjs --all",
+    "rust:copy": "node scripts/copy-rust-binaries.mjs",
     "rust:test": "cargo test --manifest-path rust/Cargo.toml",
     "rust:test:watch": "cargo watch -x 'test --manifest-path rust/Cargo.toml'",
     "rust:check": "cargo check --manifest-path rust/Cargo.toml",

packages/cli/bin/lean-spec-rust.js

@@ -20,6 +20,10 @@ const require = createRequire(import.meta.url);
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
+// Debug mode - enable with LEANSPEC_DEBUG=1
+const DEBUG = process.env.LEANSPEC_DEBUG === '1';
+const debug = (...args) => DEBUG && console.error('[lean-spec debug]', ...args);
+
 // Platform detection mapping
 const PLATFORM_MAP = {
   darwin: { x64: 'darwin-x64', arm64: 'darwin-arm64' },
@@ -31,6 +35,8 @@ function getBinaryPath() {
   const platform = process.platform;
   const arch = process.arch;
 
+  debug('Platform detection:', { platform, arch });
+  
   const platformKey = PLATFORM_MAP[platform]?.[arch];
   if (!platformKey) {
     console.error(`Unsupported platform: ${platform}-${arch}`);
@@ -41,21 +47,38 @@ function getBinaryPath() {
   const isWindows = platform === 'win32';
   const binaryName = isWindows ? 'lean-spec.exe' : 'lean-spec';
   const packageName = `lean-spec-${platformKey}`;
+  
+  debug('Binary info:', { platformKey, binaryName, packageName });
 
   // Try to resolve platform package
   try {
-    return require.resolve(`${packageName}/${binaryName}`);
+    const resolvedPath = require.resolve(`${packageName}/${binaryName}`);
+    debug('Found platform package binary:', resolvedPath);
+    return resolvedPath;
   } catch (e) {
-    // Platform package not found
+    debug('Platform package not found:', packageName, '-', e.message);
   }
 
   // Try local binaries directory (for development/testing)
   try {
     const localPath = join(__dirname, '..', 'binaries', platformKey, binaryName);
+    debug('Trying local binary:', localPath);
     accessSync(localPath);
+    debug('Found local binary:', localPath);
     return localPath;
   } catch (e) {
-    // Local binary not found
+    debug('Local binary not found:', e.message);
+  }
+
+  // Try rust/target/release directory (for local development)
+  try {
+    const rustTargetPath = join(__dirname, '..', '..', '..', 'rust', 'target', 'release', binaryName);
+    debug('Trying rust target binary:', rustTargetPath);
+    accessSync(rustTargetPath);
+    debug('Found rust target binary:', rustTargetPath);
+    return rustTargetPath;
+  } catch (e) {
+    debug('Rust target binary not found:', e.message);
   }
 
   console.error(`Binary not found for ${platform}-${arch}`);
@@ -71,16 +94,23 @@ function getBinaryPath() {
 
 // Execute binary
 const binaryPath = getBinaryPath();
-const child = spawn(binaryPath, process.argv.slice(2), {
+const args = process.argv.slice(2);
+
+debug('Spawning binary:', binaryPath);
+debug('Arguments:', args);
+
+const child = spawn(binaryPath, args, {
   stdio: 'inherit',
   windowsHide: true,
 });
 
 child.on('exit', (code) => {
+  debug('Binary exited with code:', code);
   process.exit(code ?? 1);
 });
 
 child.on('error', (err) => {
   console.error('Failed to start lean-spec:', err.message);
+  debug('Spawn error:', err);
   process.exit(1);
 });

scripts/copy-rust-binaries.mjs

@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+/**
+ * copy-rust-binaries.mjs
+ * 
+ * Copies Rust binaries from rust/target/release to packages/{cli,mcp}/binaries/{platform}/
+ * Automatically detects current platform and copies the appropriate binary.
+ * 
+ * Usage:
+ *   node scripts/copy-rust-binaries.mjs           # Copy current platform
+ *   node scripts/copy-rust-binaries.mjs --all     # Copy all platforms (requires cross-compilation)
+ */
+import { promises as fs } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const ROOT = path.resolve(__dirname, '..');
+
+// Platform mapping
+const PLATFORM_MAP = {
+  linux: { x64: 'linux-x64', arm64: 'linux-arm64' },
+  darwin: { x64: 'darwin-x64', arm64: 'darwin-arm64' },
+  win32: { x64: 'windows-x64', arm64: 'windows-arm64' }
+};
+
+// All platforms for --all flag
+const ALL_PLATFORMS = [
+  'darwin-x64',
+  'darwin-arm64',
+  'linux-x64',
+  'linux-arm64',
+  'windows-x64',
+];
+
+function getCurrentPlatform() {
+  const platform = process.platform;
+  const arch = process.arch;
+  const platformKey = PLATFORM_MAP[platform]?.[arch];
+  
+  if (!platformKey) {
+    throw new Error(`Unsupported platform: ${platform}-${arch}`);
+  }
+  
+  return platformKey;
+}
+
+async function copyBinary(binaryName, platformKey) {
+  const isWindows = platformKey.startsWith('windows-');
+  const sourceExt = isWindows ? '.exe' : '';
+  const sourcePath = path.join(ROOT, 'rust', 'target', 'release', `${binaryName}${sourceExt}`);
+  
+  // Determine destination based on binary name
+  const packagePath = binaryName === 'lean-spec' ? 'cli' : 'mcp';
+  const destDir = path.join(ROOT, 'packages', packagePath, 'binaries', platformKey);
+  const destPath = path.join(destDir, binaryName + sourceExt);
+  
+  // Check if source exists
+  try {
+    await fs.access(sourcePath);
+  } catch (e) {
+    console.warn(`⚠️  Source binary not found: ${sourcePath}`);
+    return false;
+  }
+  
+  // Ensure destination directory exists
+  await fs.mkdir(destDir, { recursive: true });
+  
+  // Copy binary
+  await fs.copyFile(sourcePath, destPath);
+  
+  // Make executable on Unix
+  if (!isWindows) {
+    await fs.chmod(destPath, 0o755);
+  }
+  
+  console.log(`✅ Copied ${binaryName} to ${packagePath}/binaries/${platformKey}/`);
+  return true;
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  const copyAll = args.includes('--all');
+  
+  console.log('🔧 Copying Rust binaries...\n');
+  
+  const binaries = ['lean-spec', 'leanspec-mcp'];
+  
+  if (copyAll) {
+    console.log('📦 Copying all platforms (requires cross-compiled binaries)\n');
+    
+    for (const platformKey of ALL_PLATFORMS) {
+      console.log(`\nPlatform: ${platformKey}`);
+      for (const binary of binaries) {
+        await copyBinary(binary, platformKey);
+      }
+    }
+  } else {
+    const currentPlatform = getCurrentPlatform();
+    console.log(`📦 Copying for current platform: ${currentPlatform}\n`);
+    
+    for (const binary of binaries) {
+      await copyBinary(binary, currentPlatform);
+    }
+  }
+  
+  console.log('\n✨ Done!');
+}
+
+main().catch(err => {
+  console.error('❌ Error:', err.message);
+  process.exit(1);
+});