forgecode 1.8.0 → 1.10.0

package/forge.js

@@ -1,44 +1,204 @@
 #!/usr/bin/env node
 
 const { join } = require('path');
-const { spawn } = require('child_process');
+const { spawn, spawnSync } = require('child_process');
 const { existsSync } = require('fs');
+const os = require('os');
+const { platform, arch } = process;
 
-// Get the correct binary extension based on platform
-const getBinaryExtension = () => {
-  return process.platform === 'win32' ? '.exe' : '';
-};
+// Function to check if running on Android
+function isAndroid() {
+  try {
+    // Check for Android-specific system properties
+    const result = spawnSync('getprop', ['ro.build.version.release'], { encoding: 'utf8' });
+    if (result.status === 0 && result.stdout) {
+      return true;
+    }
+  } catch (e) {
+    // getprop command not available, probably not Android
+  }
+
+  // Check for Termux environment
+  if (process.env.PREFIX && process.env.PREFIX.includes('com.termux')) {
+    return true;
+  }
+  
+  // Check for Android-specific environment variables
+  if (process.env.ANDROID_ROOT || process.env.ANDROID_DATA) {
+    return true;
+  }
+
+  // Check for Android-specific system properties
+  if (existsSync('/system/build.prop')) {
+    return true;
+  }
+
+  return false;
+}
+
+// Function to get the glibc version on Linux
+function getGlibcVersion() {
+  try {
+    // Using ldd to get version info (common on most Linux distros)
+    const lddOutput =
+      spawnSync('ldd', ['--version'], { encoding: 'utf8' }).stderr.toString() ||
+      spawnSync('ldd', ['--version'], { encoding: 'utf8' }).stdout.toString();
+
+    // Check if this is musl libc
+    if (lddOutput.toLowerCase().includes('musl')) {
+      return { type: 'musl', version: null };
+    }
+
+    // Extract glibc version using regex
+    const versionMatch = /\b(\d+\.\d+)\b/.exec(lddOutput);
+    if (versionMatch && versionMatch[1]) {
+      return { type: 'gnu', version: versionMatch[1] };
+    }
+
+    // Alternative method using GNU-specific getconf
+    try {
+      const getconfOutput = spawnSync('getconf', ['GNU_LIBC_VERSION'], {
+        encoding: 'utf8',
+      }).stdout.toString();
+      const getconfMatch = /\b(\d+\.\d+)\b/.exec(getconfOutput);
+      if (getconfMatch && getconfMatch[1]) {
+        return { type: 'gnu', version: getconfMatch[1] };
+      }
+    } catch (e) {
+      // Ignore error if getconf is not available
+    }
+
+    // If we got here, we couldn't get the specific version
+    return { type: 'gnu', version: null };
+  } catch (error) {
+    return { type: 'unknown', version: null };
+  }
+}
+
+// Check if the glibc version is sufficient for our binary
+function isGlibcVersionSufficient(version) {
+  if (!version) return false;
+
+  // Our binary requires 2.32 or higher
+  const requiredVersion = 2.32;
+  const currentVersion = parseFloat(version);
+
+  return currentVersion >= requiredVersion;
+}
 
-// Get the path to the forge binary in the same directory as this script
-const forgeBinaryPath = join(__dirname, 'forge' + getBinaryExtension());
+// Enhanced libc detection for Linux
+function detectLibcType() {
+  if (platform !== 'linux') {
+    return null; // Not relevant for non-Linux platforms
+  }
+
+  const libcInfo = getGlibcVersion();
 
-// Check if the binary exists
-if (!existsSync(forgeBinaryPath)) {
-  console.error(`❌ Forge binary not found at: ${forgeBinaryPath}`);
-  console.error('Please try reinstalling the package with: npm install -g forgecode');
-  console.error(`System information: ${process.platform} (${process.arch})`);
-  process.exit(1);
+  // If it's musl, or if it's an older glibc version, prefer musl
+  if (
+    libcInfo.type === 'musl' ||
+    (libcInfo.type === 'gnu' && !isGlibcVersionSufficient(libcInfo.version))
+  ) {
+    return 'musl';
+  }
+
+  return 'gnu';
 }
 
-// Configure spawn options based on platform
-const spawnOptions = {
-  stdio: 'inherit',
+// Map of supported platforms and architectures to binary names
+const PLATFORMS = {
+  darwin: {
+    x64: 'forge-x86_64-apple-darwin',
+    arm64: 'forge-aarch64-apple-darwin',
+  },
+  linux: {
+    x64: {
+      gnu: 'forge-x86_64-unknown-linux-gnu',
+      musl: 'forge-x86_64-unknown-linux-musl',
+    },
+    arm64: {
+      gnu: 'forge-aarch64-unknown-linux-gnu',
+      musl: 'forge-aarch64-unknown-linux-musl',
+    },
+  },
+  win32: {
+    x64: 'forge-x86_64-pc-windows-msvc.exe',
+    arm64: 'forge-aarch64-pc-windows-msvc.exe',
+  },
+  android: {
+    arm64: 'forge-aarch64-linux-android',
+  }
 };
 
-// Spawn the forge process
-const forgeProcess = spawn(forgeBinaryPath, process.argv.slice(2), spawnOptions);
+// Helper function to construct binary path
+function buildBinaryPath(platformDir, archDir, binaryName) {
+  return join(__dirname, 'bin', platformDir, archDir, binaryName);
+}
+
+// Determine the path to the correct binary
+function getBinaryPath() {
+  // Check for override
+  if (process.env.FORGE_BINARY_PATH) {
+    return process.env.FORGE_BINARY_PATH;
+  }
+
+  // Detect actual platform (override for Android)
+  const isAndroidEnv = platform === 'linux' && isAndroid();
+  const actualPlatform = isAndroidEnv ? 'android' : platform;
+
+  // Handle Android
+  if (actualPlatform === 'android') {
+    const binaryName = PLATFORMS.android?.[arch];
+    return binaryName ? buildBinaryPath('android', arch, binaryName) : null;
+  }
 
-// Handle SIGINT (Ctrl+C) based on platform
-process.on('SIGINT', () => {
-  // for windows, let the child process handle it
-  if (process.platform !== 'win32') {
-    forgeProcess.kill('SIGINT');
+  // Handle Linux with libc detection
+  if (platform === 'linux') {
+    const forceMusl = process.env.FORCE_MUSL === '1';
+    const libcType = forceMusl ? 'musl' : (detectLibcType() || 'gnu');
+    const binaryName = PLATFORMS.linux?.[arch]?.[libcType];
+    return binaryName ? buildBinaryPath(platform, arch, binaryName) : null;
   }
-});
 
-// Handle process exit
-forgeProcess.on('exit', code => {
-  if (code !== null) {
-    process.exit(code);
+  // Handle macOS and Windows
+  const binaryName = PLATFORMS[actualPlatform]?.[arch];
+  return binaryName ? buildBinaryPath(actualPlatform, arch, binaryName) : null;
+}
+
+// Export for testing
+module.exports = { getBinaryPath };
+
+/* istanbul ignore next */
+// Only run if not being required as a module (i.e., being executed directly)
+if (require.main === module) {
+  const forgeBinaryPath = getBinaryPath();
+
+  // Check if the binary exists
+  if (!forgeBinaryPath || !existsSync(forgeBinaryPath)) {
+    console.error(`❌ Forge binary not found for platform: ${platform} (${arch})`);
+    console.error('Please check if your system is supported.');
+    process.exit(1);
   }
-});
+
+  // Configure spawn options
+  const spawnOptions = {
+    stdio: 'inherit',
+  };
+
+  // Spawn the forge process
+  const forgeProcess = spawn(forgeBinaryPath, process.argv.slice(2), spawnOptions);
+
+  // Handle SIGINT (Ctrl+C) based on platform
+  process.on('SIGINT', () => {
+    if (process.platform !== 'win32') {
+      forgeProcess.kill('SIGINT');
+    }
+  });
+
+  // Handle process exit
+  forgeProcess.on('exit', code => {
+    if (code !== null) {
+      process.exit(code);
+    }
+  });
+}

package/install.js

@@ -1,378 +1,33 @@
 #!/usr/bin/env node
 
 const { platform, arch } = process;
-const { join } = require('path');
-const { chmodSync, copyFileSync, existsSync } = require('fs');
-const { spawnSync } = require('child_process');
-const os = require('os');
 
-// Function to check if running on Android
-function isAndroid() {
-  try {
-    // Check for Android-specific system properties
-    const result = spawnSync('getprop', ['ro.build.version.release'], { encoding: 'utf8' });
-    if (result.status === 0 && result.stdout) {
-      return true;
-    }
-  } catch (e) {
-    // getprop command not available, probably not Android
-  }
-
-  // Check for Termux environment
-  if (process.env.PREFIX && process.env.PREFIX.includes('com.termux')) {
-    return true;
-  }
-
-  return false;
-}
-
-// Function to get the glibc version on Linux
-function getGlibcVersion() {
-  try {
-    // Using ldd to get version info (common on most Linux distros)
-    const lddOutput =
-      spawnSync('ldd', ['--version'], { encoding: 'utf8' }).stderr.toString() ||
-      spawnSync('ldd', ['--version'], { encoding: 'utf8' }).stdout.toString();
-
-    // Check if this is musl libc
-    if (lddOutput.toLowerCase().includes('musl')) {
-      return { type: 'musl', version: null };
-    }
-
-    // Extract glibc version using regex
-    const versionMatch = /\b(\d+\.\d+)\b/.exec(lddOutput);
-    if (versionMatch && versionMatch[1]) {
-      return { type: 'gnu', version: versionMatch[1] };
-    }
-
-    // Alternative method using GNU-specific getconf
-    try {
-      const getconfOutput = spawnSync('getconf', ['GNU_LIBC_VERSION'], {
-        encoding: 'utf8',
-      }).stdout.toString();
-      const getconfMatch = /\b(\d+\.\d+)\b/.exec(getconfOutput);
-      if (getconfMatch && getconfMatch[1]) {
-        return { type: 'gnu', version: getconfMatch[1] };
-      }
-    } catch (e) {
-      // Ignore error if getconf is not available
-    }
-
-    // If we got here, we couldn't get the specific version
-    return { type: 'gnu', version: null };
-  } catch (error) {
-    console.warn('Warning: Could not detect libc version details.');
-    return { type: 'unknown', version: null };
-  }
-}
-
-// Check if the glibc version is sufficient for our binary
-function isGlibcVersionSufficient(version) {
-  if (!version) return false;
-
-  // Our binary requires 2.32 or higher based on the error message
-  const requiredVersion = 2.32;
-  const currentVersion = parseFloat(version);
-
-  return currentVersion >= requiredVersion;
-}
-
-// Enhanced libc detection for Linux
-function detectLibcType() {
-  if (platform !== 'linux') {
-    return null; // Not relevant for non-Linux platforms
-  }
-
-  const libcInfo = getGlibcVersion();
-  console.log(
-    `🔍 Detected libc: ${libcInfo.type}${libcInfo.version ? ` version ${libcInfo.version}` : ''}`
-  );
-
-  // If it's musl, or if it's an older glibc version, prefer musl
-  if (
-    libcInfo.type === 'musl' ||
-    (libcInfo.type === 'gnu' && !isGlibcVersionSufficient(libcInfo.version))
-  ) {
-    return 'musl';
-  }
-
-  return 'gnu';
-}
-
-// Test if a binary will run on this system
-function testBinary(binaryPath) {
-  try {
-    const result = spawnSync(binaryPath, ['--version'], {
-      encoding: 'utf8',
-      timeout: 5000, // 5 second timeout
-    });
-
-    // Check if execution was successful (return code 0)
-    if (result.status === 0) {
-      return true;
-    }
-
-    // Check specific errors that indicate glibc version problems
-    if (result.stderr && result.stderr.includes('GLIBC_')) {
-      console.warn(`⚠️  Binary compatibility issue: ${result.stderr.split('\n')[0]}`);
-      return false;
-    }
-
-    return false;
-  } catch (error) {
-    console.warn(`⚠️  Binary test failed: ${error.message}`);
-    return false;
-  }
-}
-
-// Detect if running on Android (Termux or similar)
-function isAndroid() {
-  try {
-    // Check for Android-specific environment variables
-    if (process.env.ANDROID_ROOT || process.env.ANDROID_DATA) {
-      return true;
-    }
-
-    // Check if running in Termux
-    if (process.env.PREFIX && process.env.PREFIX.includes('com.termux')) {
-      return true;
-    }
-
-    // Check for Android-specific system properties
-    const { existsSync } = require('fs');
-    if (existsSync('/system/build.prop')) {
-      return true;
-    }
-
-    return false;
-  } catch (error) {
-    return false;
-  }
-}
+// Note: This script only performs a basic compatibility check.
+// All platform/architecture detection happens at runtime in forge.js
+// to avoid permission issues during npm install.
 
-// Map of supported platforms and architectures to binary names
-const PLATFORMS = {
-  darwin: {
-    x64: 'forge-x86_64-apple-darwin',
-    arm64: 'forge-aarch64-apple-darwin',
-  },
-  linux: {
-    x64: {
-      gnu: 'forge-x86_64-unknown-linux-gnu',
-      musl: 'forge-x86_64-unknown-linux-musl',
-    },
-    arm64: {
-      gnu: 'forge-aarch64-unknown-linux-gnu',
-      musl: 'forge-aarch64-unknown-linux-musl',
-      android: 'forge-aarch64-linux-android',
-    },
-  },
-  win32: {
-    x64: 'forge-x86_64-pc-windows-msvc.exe',
-    arm64: 'forge-aarch64-pc-windows-msvc.exe',
-  },
-  android: {
-    arm64: 'forge-aarch64-linux-android',
-  }
+const SUPPORTED_PLATFORMS = {
+  darwin: ['x64', 'arm64'],
+  linux: ['x64', 'arm64'],
+  win32: ['x64', 'arm64'],
+  android: ['arm64']
 };
 
-// Platform-specific binary extension
-function getBinaryExtension() {
-  return platform === 'win32' ? '.exe' : '';
-}
-
-// Print available platform information for debugging
-function printPlatformInfo() {
-  console.log('System Information:');
-  console.log(` - Platform: ${platform}`);
-  console.log(` - Architecture: ${arch}`);
-  console.log(` - Node.js: ${process.version}`);
-  console.log(` - OS: ${os.type()} ${os.release()}`);
-
-  if (platform === 'linux') {
-    if (isAndroid()) {
-      console.log(` - Environment: Android`);
-    }
-
-    const libcInfo = getGlibcVersion();
-    console.log(
-      ` - Libc: ${libcInfo.type}${libcInfo.version ? ` version ${libcInfo.version}` : ''}`
-    );
-
-    try {
-      const distroInfo = spawnSync('cat', ['/etc/os-release'], {
-        encoding: 'utf8',
-      }).stdout.toString();
-      const distroName = /PRETTY_NAME="([^"]+)"/.exec(distroInfo);
-      if (distroName && distroName[1]) {
-        console.log(` - Distribution: ${distroName[1]}`);
-      }
-    } catch (e) {
-      // Ignore if we can't get distribution info
-    }
-  }
-}
-
-// Install binary based on platform and architecture
 function install() {
-  printPlatformInfo();
-
-  // Detect actual platform (override for Android)
-  let actualPlatform = platform;
-  if (platform === 'linux' && isAndroid()) {
-    actualPlatform = 'android';
-    console.log('🤖 Android environment detected, using Android binaries');
-  }
-
-  // Check if platform is supported
-  if (!PLATFORMS[actualPlatform]) {
-    console.error(`❌ Unsupported platform: ${actualPlatform}`);
-    console.error('Supported platforms: macOS, Linux, Windows, Android');
-    process.exit(1);
-  }
-
-  // Check if architecture is supported
-  if (!PLATFORMS[actualPlatform][arch]) {
-    console.error(`❌ Unsupported architecture: ${arch} for platform ${actualPlatform}`);
-    console.error(
-      `Supported architectures for ${actualPlatform}: ${Object.keys(PLATFORMS[actualPlatform]).join(', ')}`
-    );
-    process.exit(1);
-  }
-
-  let binaryName;
-  let binaryPath;
-  const targetPath = join(__dirname, 'forge' + getBinaryExtension());
-
-  // Handle platform-specific binary selection
-  if (actualPlatform === 'android') {
-    // Android: simple case, just one binary per arch
-    binaryName = PLATFORMS[actualPlatform][arch];
-    binaryPath = join(__dirname, 'bin', actualPlatform, arch, binaryName);
-  } else if (platform === 'linux') {
-    // Linux: handle libc type detection
-    // Check if running on Android first
-    if (isAndroid() && arch === 'arm64' && PLATFORMS[platform][arch]['android']) {
-      console.log('🤖 Android platform detected');
-      binaryName = PLATFORMS[platform][arch]['android'];
-      // Android binaries are stored in darwin/arm64 directory as per update-package.sh
-      binaryPath = join(__dirname, 'bin', 'darwin', 'arm64', binaryName);
-    } else {
-      let libcType = detectLibcType();
-
-      // Always try musl first if available (it's more portable)
-      const muslBinaryName = PLATFORMS[platform][arch]['musl'];
-      const muslBinaryPath = join(__dirname, 'bin', platform, arch, muslBinaryName);
-
-      // Check if musl binary exists
-      if (existsSync(muslBinaryPath)) {
-        console.log('📦 Found musl binary, which should work on most Linux systems');
-        binaryName = muslBinaryName;
-        binaryPath = muslBinaryPath;
-      }
-      // Fall back to detected libc type
-      else {
-        // Check if the detected libc type is supported in our binaries
-        if (!PLATFORMS[platform][arch][libcType]) {
-          // If not supported, try the alternative
-          libcType = libcType === 'gnu' ? 'musl' : 'gnu';
-          console.warn(`⚠️  Detected libc type is not supported, trying ${libcType} instead`);
-        }
-
-        binaryName = PLATFORMS[platform][arch][libcType];
-        binaryPath = join(__dirname, 'bin', platform, arch, binaryName);
-      }
-
-      // If binary doesn't exist, try the alternative
-      if (!existsSync(binaryPath)) {
-        const alternativeLibc = libcType === 'gnu' ? 'musl' : 'gnu';
-        const alternativeBinaryName = PLATFORMS[platform][arch][alternativeLibc];
-        const alternativeBinaryPath = join(__dirname, 'bin', platform, arch, alternativeBinaryName);
-
-        if (existsSync(alternativeBinaryPath)) {
-          console.warn(`⚠️  Binary for ${libcType} not found, trying ${alternativeLibc} instead`);
-          binaryName = alternativeBinaryName;
-          binaryPath = alternativeBinaryPath;
-        }
-      }
-    }
+  console.log(`📦 Installing forge for ${platform}/${arch}...`);
+
+  // Basic platform check
+  if (!SUPPORTED_PLATFORMS[platform]) {
+    console.warn(`⚠️  Warning: Platform '${platform}' might not be supported.`);
+    console.warn('Supported platforms: darwin, linux, win32');
+  } else if (!SUPPORTED_PLATFORMS[platform].includes(arch)) {
+    console.warn(`⚠️  Warning: Architecture '${arch}' on '${platform}' might not be supported.`);
+    console.warn(`Supported architectures for ${platform}: ${SUPPORTED_PLATFORMS[platform].join(', ')}`);
   } else {
-    // macOS, Windows: simple case
-    binaryName = PLATFORMS[actualPlatform][arch];
-    binaryPath = join(__dirname, 'bin', actualPlatform, arch, binaryName);
+    console.log(`✅ System compatible: ${platform}/${arch}`);
   }
-
-  // Check if binary exists
-  if (!existsSync(binaryPath)) {
-    console.error(`❌ Binary not found: ${binaryPath}`);
-    console.error(
-      'If this is a new architecture or platform, please check the repository for updates.'
-    );
-    process.exit(1);
-  }
-
-  try {
-    // Copy binary to target location
-    copyFileSync(binaryPath, targetPath);
-    // Make binary executable (not needed on Windows)
-    if (platform !== 'win32') {
-      chmodSync(targetPath, '755');
-    }
-
-    // For Linux, test if the binary will actually run
-    if (platform === 'linux') {
-      console.log('🧪 Testing binary compatibility...');
-      if (!testBinary(targetPath)) {
-        // If current binary fails and we haven't tried musl yet, try the musl version
-        if (binaryName.includes('-gnu')) {
-          const muslBinaryName = binaryName.replace('-gnu', '-musl');
-          const muslBinaryPath = join(__dirname, 'bin', platform, arch, muslBinaryName);
-
-          if (existsSync(muslBinaryPath)) {
-            console.log('🔄 GNU binary not compatible, trying musl binary instead');
-            copyFileSync(muslBinaryPath, targetPath);
-            chmodSync(targetPath, '755');
-
-            if (!testBinary(targetPath)) {
-              console.error('❌ Both GNU and musl binaries failed to run on this system.');
-              reportCompatibilityError();
-              process.exit(1);
-            }
-          } else {
-            console.error('❌ GNU binary not compatible, and musl binary not available.');
-            reportCompatibilityError();
-            process.exit(1);
-          }
-        } else {
-          console.error('❌ Binary compatibility test failed.');
-          reportCompatibilityError();
-          process.exit(1);
-        }
-      }
-    }
-
-    console.log(`✅ Successfully installed forge for ${platform}/${arch}`);
-  } catch (error) {
-    console.error(`❌ Error installing binary: ${error.message}`);
-    reportCompatibilityError();
-    process.exit(1);
-  }
-}
-
-function reportCompatibilityError() {
-  console.error('\n🔧 Possible solutions:');
-  console.error('1. Try using the musl binary, which has fewer system dependencies:');
-  console.error('   - Set FORCE_MUSL=1 before installing');
-  console.error("2. Update your system's glibc to a newer version");
-  console.error('3. Contact support with the following information:');
-  printPlatformInfo();
-}
-
-// Check for environment variable to force musl
-if (process.env.FORCE_MUSL === '1' && platform === 'linux') {
-  console.log('🔧 FORCE_MUSL=1 environment variable detected, forcing musl binary');
-  process.env.FORCE_LIBC = 'musl';
+  
+  console.log("✨ Forge installed successfully. Run 'forge' to start.");
 }
 
-// Run installation
 install();

package/package.json

@@ -1,12 +1,19 @@
 {
   "name": "forgecode",
-  "version": "1.8.0",
+  "version": "1.10.0",
   "description": "Code Forge CLI - an AI-powered coding assistant",
   "bin": {
     "forge": "forge.js"
   },
   "scripts": {
-    "postinstall": "node install.js"
+    "postinstall": "node install.js",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage"
+  },
+  "devDependencies": {
+    "@jest/globals": "^29.7.0",
+    "jest": "^29.7.0"
   },
   "repository": {
     "type": "git",