forgecode 0.100.1 → 0.100.3

package/README.md

@@ -341,9 +341,9 @@ Define custom commands as shortcuts for repetitive prompts:
 ```yaml
 # forge.yaml
 commands:
-  - name: "refactor"
-    description: "Refactor selected code"
-    prompt: "Please refactor this code to improve readability and performance"
+  - name: 'refactor'
+    description: 'Refactor selected code'
+    prompt: 'Please refactor this code to improve readability and performance'
 ```
 
 </details>
@@ -355,7 +355,7 @@ Specify the default AI model to use for all agents in the workflow.
 
 ```yaml
 # forge.yaml
-model: "claude-3.7-sonnet"
+model: 'claude-3.7-sonnet'
 ```
 
 </details>

package/forge.js

@@ -20,24 +20,25 @@ if (!existsSync(forgeBinaryPath)) {
   process.exit(1);
 }
 
-// Execute the binary with the same arguments
-const forgeProcess = spawn(
-  process.platform === 'win32' ? `"${forgeBinaryPath}"` : forgeBinaryPath, 
-  process.argv.slice(2), 
-  { 
-    stdio: 'inherit',
-    shell: process.platform === 'win32' // Use shell on Windows
-  });
-
-// Pass through SIGINT signals to the child process
+// Configure spawn options based on platform
+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', () => {
-  // Instead of handling here, forward to the child
-  forgeProcess.kill('SIGINT');
-  // Don't exit - let the child process determine what happens
+  // for windows, let the child process handle it
+  if (process.platform !== 'win32') {
+    forgeProcess.kill('SIGINT');
+  }
 });
 
 // Handle process exit
-forgeProcess.on('exit', (code) => {
-  // Only exit with code when the child actually exits
-  process.exit(code || 0);
-});
+forgeProcess.on('exit', code => {
+  if (code !== null) {
+    process.exit(code);
+  }
+});

package/install.js

@@ -10,23 +10,26 @@ const os = require('os');
 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();
-    
+    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 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] };
@@ -34,7 +37,7 @@ function getGlibcVersion() {
     } 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) {
@@ -46,11 +49,11 @@ function getGlibcVersion() {
 // 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;
 }
 
@@ -61,36 +64,40 @@ function detectLibcType() {
   }
 
   const libcInfo = getGlibcVersion();
-  console.log(`🔍 Detected libc: ${libcInfo.type}${libcInfo.version ? ` version ${libcInfo.version}` : ''}`);
-  
+  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))) {
+  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'], { 
+    const result = spawnSync(binaryPath, ['--version'], {
       encoding: 'utf8',
-      timeout: 5000 // 5 second timeout
+      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}`);
@@ -100,24 +107,24 @@ function testBinary(binaryPath) {
 
 // Map of supported platforms and architectures to binary names
 const PLATFORMS = {
-  'darwin': {
-    'x64': 'forge-x86_64-apple-darwin',
-    'arm64': 'forge-aarch64-apple-darwin'
+  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'
+  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',
     },
-    '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'
-  }
+  win32: {
+    x64: 'forge-x86_64-pc-windows-msvc.exe',
+    arm64: 'forge-aarch64-pc-windows-msvc.exe',
+  },
 };
 
 // Platform-specific binary extension
@@ -132,13 +139,17 @@ function printPlatformInfo() {
   console.log(` - Architecture: ${arch}`);
   console.log(` - Node.js: ${process.version}`);
   console.log(` - OS: ${os.type()} ${os.release()}`);
-  
+
   if (platform === 'linux') {
     const libcInfo = getGlibcVersion();
-    console.log(` - Libc: ${libcInfo.type}${libcInfo.version ? ` version ${libcInfo.version}` : ''}`);
-    
+    console.log(
+      ` - Libc: ${libcInfo.type}${libcInfo.version ? ` version ${libcInfo.version}` : ''}`
+    );
+
     try {
-      const distroInfo = spawnSync('cat', ['/etc/os-release'], { encoding: 'utf8' }).stdout.toString();
+      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]}`);
@@ -152,7 +163,7 @@ function printPlatformInfo() {
 // Install binary based on platform and architecture
 function install() {
   printPlatformInfo();
-  
+
   // Check if platform is supported
   if (!PLATFORMS[platform]) {
     console.error(`❌ Unsupported platform: ${platform}`);
@@ -163,7 +174,9 @@ function install() {
   // Check if architecture is supported
   if (!PLATFORMS[platform][arch]) {
     console.error(`❌ Unsupported architecture: ${arch} for platform ${platform}`);
-    console.error(`Supported architectures for ${platform}: ${Object.keys(PLATFORMS[platform]).join(', ')}`);
+    console.error(
+      `Supported architectures for ${platform}: ${Object.keys(PLATFORMS[platform]).join(', ')}`
+    );
     process.exit(1);
   }
 
@@ -174,36 +187,36 @@ function install() {
   // Handle Linux specially for libc type
   if (platform === 'linux') {
     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';
+        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;
@@ -218,7 +231,9 @@ function install() {
   // 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.');
+    console.error(
+      'If this is a new architecture or platform, please check the repository for updates.'
+    );
     process.exit(1);
   }
 
@@ -229,7 +244,7 @@ function install() {
     if (platform !== 'win32') {
       chmodSync(targetPath, '755');
     }
-    
+
     // For Linux, test if the binary will actually run
     if (platform === 'linux') {
       console.log('🧪 Testing binary compatibility...');
@@ -238,12 +253,12 @@ function install() {
         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();
@@ -261,7 +276,7 @@ function install() {
         }
       }
     }
-    
+
     console.log(`✅ Successfully installed forge for ${platform}/${arch}`);
   } catch (error) {
     console.error(`❌ Error installing binary: ${error.message}`);
@@ -274,7 +289,7 @@ 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("2. Update your system's glibc to a newer version");
   console.error('3. Contact support with the following information:');
   printPlatformInfo();
 }
@@ -286,4 +301,4 @@ if (process.env.FORCE_MUSL === '1' && platform === 'linux') {
 }
 
 // Run installation
-install();
+install();

package/package.json

@@ -1,38 +1,38 @@
 {
-    "name": "forgecode",
-    "version": "0.100.1",
-    "description": "Code Forge CLI - an AI-powered coding assistant",
-    "bin": {
-        "forge": "forge.js"
-    },
-    "scripts": {
-        "postinstall": "node install.js"
-    },
-    "repository": {
-        "type": "git",
-        "url": "git+https://github.com/antinomyhq/forge.git"
-    },
-    "keywords": [
-        "code-forge",
-        "ai",
-        "assistant",
-        "cli"
-    ],
-    "author": "Antinomy Inc.",
-    "license": "MIT",
-    "bugs": {
-        "url": "https://github.com/antinomyhq/forge/issues"
-    },
-    "homepage": "https://antinomy.ai/",
-    "files": [
-        "bin/**/*",
-        "install.js",
-        "forge.js"
-    ],
-    "engines": {
-        "node": ">=18.0.0"
-    },
-    "publishConfig": {
-        "access": "public"
-    }
+  "name": "forgecode",
+  "version": "0.100.3",
+  "description": "Code Forge CLI - an AI-powered coding assistant",
+  "bin": {
+    "forge": "forge.js"
+  },
+  "scripts": {
+    "postinstall": "node install.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/antinomyhq/forge.git"
+  },
+  "keywords": [
+    "code-forge",
+    "ai",
+    "assistant",
+    "cli"
+  ],
+  "author": "Antinomy Inc.",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/antinomyhq/forge/issues"
+  },
+  "homepage": "https://antinomy.ai/",
+  "files": [
+    "bin/**/*",
+    "install.js",
+    "forge.js"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
 }