gitarsenal-cli 1.9.69 → 1.9.71

package/.venv_status.json

@@ -1 +1 @@
-{"created":"2025-08-15T05:02:30.288Z","packages":["modal","gitingest","requests","anthropic"],"uv_version":"uv 0.8.4 (Homebrew 2025-07-30)"}
+{"created":"2025-08-15T05:31:11.835Z","packages":["modal","gitingest","requests","anthropic"],"uv_version":"uv 0.8.4 (Homebrew 2025-07-30)"}

package/bin/gitarsenal.js

@@ -16,6 +16,89 @@ const fs = require('fs');
 const https = require('https');
 const http = require('http');
 
+// Function to activate virtual environment
+function activateVirtualEnvironment() {
+  const isWindows = process.platform === 'win32';
+  const venvPath = path.join(__dirname, '..', '.venv');
+  const statusFile = path.join(__dirname, '..', '.venv_status.json');
+  
+  // Check if virtual environment exists
+  if (!fs.existsSync(venvPath)) {
+    console.log(chalk.red('❌ Virtual environment not found. Please reinstall the package:'));
+    console.log(chalk.yellow('   npm uninstall -g gitarsenal-cli'));
+    console.log(chalk.yellow('   npm install -g gitarsenal-cli'));
+    console.log(chalk.yellow(''));
+    console.log(chalk.yellow('💡 Or run the postinstall script manually:'));
+    console.log(chalk.yellow('   cd /root/.nvm/versions/node/v22.18.0/lib/node_modules/gitarsenal-cli'));
+    console.log(chalk.yellow('   node scripts/postinstall.js'));
+    return false;
+  }
+  
+  // Check if status file exists (indicates successful installation)
+  if (fs.existsSync(statusFile)) {
+    try {
+      const status = JSON.parse(fs.readFileSync(statusFile, 'utf8'));
+    } catch (error) {
+      console.log(chalk.gray('✅ Virtual environment found'));
+    }
+  }
+  
+  // Verify virtual environment structure - uv creates different structure
+  let pythonPath, pipPath;
+  
+  // Check for uv-style virtual environment first
+  const uvPythonPath = path.join(venvPath, 'bin', 'python');
+  const uvPipPath = path.join(venvPath, 'bin', 'pip');
+  
+  // Check for traditional venv structure
+  const traditionalPythonPath = isWindows ? 
+    path.join(venvPath, 'Scripts', 'python.exe') : 
+    path.join(venvPath, 'bin', 'python');
+  const traditionalPipPath = isWindows ? 
+    path.join(venvPath, 'Scripts', 'pip.exe') : 
+    path.join(venvPath, 'bin', 'pip');
+  
+  // Determine which structure exists
+  // console.log(chalk.gray(`🔍 Checking virtual environment structure:`));
+  // console.log(chalk.gray(`  Python: ${uvPythonPath} (exists: ${fs.existsSync(uvPythonPath)})`));
+  // console.log(chalk.gray(`  Pip: ${uvPipPath} (exists: ${fs.existsSync(uvPipPath)})`));
+  
+  // For uv virtual environments, we only need Python to exist
+  // uv doesn't create a pip executable, it uses 'uv pip' instead
+  if (fs.existsSync(uvPythonPath)) {
+    pythonPath = uvPythonPath;
+    pipPath = 'uv pip'; // Use uv pip instead of pip executable
+    // console.log(chalk.gray('✅ Found uv-style virtual environment'));
+  } else if (fs.existsSync(traditionalPythonPath) && fs.existsSync(traditionalPipPath)) {
+    pythonPath = traditionalPythonPath;
+    pipPath = traditionalPipPath;
+    console.log(chalk.gray('✅ Found traditional virtual environment'));
+  } else {
+    console.log(chalk.red('❌ Virtual environment structure not recognized'));
+    console.log(chalk.gray('Expected Python at:'));
+    console.log(chalk.gray(`  ${uvPythonPath}`));
+    console.log(chalk.gray(`  ${traditionalPythonPath}`));
+    console.log(chalk.yellow('💡 Please reinstall the package'));
+    return false;
+  }
+  
+  // Update PATH to prioritize virtual environment
+  const pathSeparator = isWindows ? ';' : ':';
+  const venvBinPath = path.dirname(pythonPath); // Use the same directory as the Python executable
+  
+  process.env.PATH = `${venvBinPath}${pathSeparator}${process.env.PATH}`;
+  process.env.VIRTUAL_ENV = venvPath;
+  process.env.PYTHONPATH = venvPath;
+  
+  // Set Python executable path for child processes
+  process.env.PYTHON_EXECUTABLE = pythonPath;
+  process.env.PIP_EXECUTABLE = pipPath;
+  
+  console.log(chalk.green('✅ Virtual environment activated successfully'));
+  
+  return true;
+}
+
 
 // Lightweight preview of GPU/Torch/CUDA recommendations prior to GPU selection
 async function previewRecommendations(repoUrl, optsOrShowSummary = true) {

package/kill_claude/claude_code_agent.py

@@ -372,7 +372,7 @@ The following {len(TOOL_SCHEMAS)} tools are loaded and available:
                 
                 # Execute tool calls
                 if tool_calls:
-                    print(f"🤖 Claude requested {len(tool_calls)} tool call(s)")
+                    print(f"🤖 Agent requested {len(tool_calls)} tool call(s)")
                     tool_results = []
                     
                     for i, tool_call in enumerate(tool_calls, 1):

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitarsenal-cli",
-  "version": "1.9.69",
+  "version": "1.9.71",
   "description": "CLI tool for creating Modal sandboxes with GitHub repositories",
   "main": "index.js",
   "bin": {

package/python/test_modalSandboxScript.py

@@ -541,28 +541,89 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
                 print("🎉 AGENT OUTPUT (LIVE)")
                 print("="*60)
                 
-                # Use Popen for real-time output streaming
+                # Use Popen for real-time output streaming with optimizations
+                import sys
+                import select
+                import fcntl
+                import os as os_module
+                
                 process = subprocess.Popen(
-                    ["python", "/python/kill_claude/claude_code_agent.py", claude_prompt],
+                    ["python", "-u", "/python/kill_claude/claude_code_agent.py", claude_prompt],  # -u for unbuffered output
                     cwd="/root",
                     stdout=subprocess.PIPE,
-                    stderr=subprocess.STDOUT,  # Merge stderr into stdout
+                    stderr=subprocess.PIPE,  # Keep separate for better handling
                     text=True,
-                    bufsize=1,  # Line buffered
-                    universal_newlines=True
+                    bufsize=0,  # Unbuffered for fastest output
+                    universal_newlines=True,
+                    env=dict(os.environ, PYTHONUNBUFFERED='1')  # Force unbuffered Python output
                 )
                 
-                # Stream output in real-time
+                # Make stdout and stderr non-blocking for faster reading
+                def make_non_blocking(fd):
+                    flags = fcntl.fcntl(fd, fcntl.F_GETFL)
+                    fcntl.fcntl(fd, fcntl.F_SETFL, flags | os_module.O_NONBLOCK)
+                
+                make_non_blocking(process.stdout)
+                make_non_blocking(process.stderr)
+                
+                # Stream output in real-time with robust error handling
                 try:
-                    while True:
-                        output = process.stdout.readline()
-                        if output == '' and process.poll() is not None:
-                            break
-                        if output:
-                            print(output.rstrip())
+                    stdout_buffer = ""
+                    stderr_buffer = ""
+                    
+                    while process.poll() is None:
+                        try:
+                            # Use select for efficient I/O multiplexing with error handling
+                            ready, _, _ = select.select([process.stdout, process.stderr], [], [], 0.1)  # 100ms timeout
+                            
+                            for stream in ready:
+                                try:
+                                    if stream == process.stdout:
+                                        chunk = stream.read(1024)  # Read in chunks for efficiency
+                                        if chunk is not None and chunk:
+                                            stdout_buffer += chunk
+                                            # Process complete lines immediately
+                                            while '\n' in stdout_buffer:
+                                                line, stdout_buffer = stdout_buffer.split('\n', 1)
+                                                print(line, flush=True)  # Force immediate flush
+                                    elif stream == process.stderr:
+                                        chunk = stream.read(1024)
+                                        if chunk is not None and chunk:
+                                            stderr_buffer += chunk
+                                            # Process complete lines immediately  
+                                            while '\n' in stderr_buffer:
+                                                line, stderr_buffer = stderr_buffer.split('\n', 1)
+                                                print(f"STDERR: {line}", flush=True)
+                                except (BlockingIOError, OSError, ValueError):
+                                    # Handle various I/O errors gracefully
+                                    continue
+                        except (select.error, OSError):
+                            # If select fails, fall back to simple polling
+                            time.sleep(0.1)
+                            continue
+                    
+                    # Process any remaining output after process ends
+                    try:
+                        # Read any remaining data from streams
+                        remaining_stdout = process.stdout.read()
+                        remaining_stderr = process.stderr.read()
+                        
+                        if remaining_stdout:
+                            stdout_buffer += remaining_stdout
+                        if remaining_stderr:
+                            stderr_buffer += remaining_stderr
+                        
+                        # Output remaining buffered content
+                        if stdout_buffer.strip():
+                            print(stdout_buffer.strip(), flush=True)
+                        if stderr_buffer.strip():
+                            print(f"STDERR: {stderr_buffer.strip()}", flush=True)
+                    except (OSError, ValueError):
+                        # Handle cases where streams are already closed
+                        pass
                     
-                    # Wait for process to complete and get return code
-                    return_code = process.wait(timeout=600)  # 10 minute timeout
+                    # Get final return code
+                    return_code = process.returncode
                     
                     print("\n" + "="*60)
                     if return_code == 0:
@@ -576,9 +637,48 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
                     process.kill()
                     process.wait()
                 except Exception as stream_error:
-                    print(f"\n⚠️ Error streaming output: {stream_error}")
-                    process.kill()
-                    process.wait()
+                    # print(f"\n⚠️ Error with advanced streaming: {stream_error}")
+                    # print("🔄 Falling back to simple streaming...")
+                    pass
+                    
+                    # Fallback to simple readline approach
+                    try:
+                        # Restart the process with simpler streaming
+                        if process.poll() is None:
+                            process.kill()
+                            process.wait()
+                        
+                        fallback_process = subprocess.Popen(
+                            ["python", "-u", "/python/kill_claude/claude_code_agent.py", claude_prompt],
+                            cwd="/root",
+                            stdout=subprocess.PIPE,
+                            stderr=subprocess.STDOUT,
+                            text=True,
+                            bufsize=1,
+                            universal_newlines=True
+                        )
+                        
+                        # Simple line-by-line reading
+                        while True:
+                            line = fallback_process.stdout.readline()
+                            if line == '' and fallback_process.poll() is not None:
+                                break
+                            if line:
+                                print(line.rstrip(), flush=True)
+                        
+                        return_code = fallback_process.returncode
+                        
+                        print("\n" + "="*60)
+                        if return_code == 0:
+                            print("✅ Agent completed successfully!")
+                        else:
+                            print(f"⚠️ Agent exited with code: {return_code}")
+                        print("="*60)
+                        
+                    except Exception as fallback_error:
+                        print(f"\n❌ Fallback streaming also failed: {fallback_error}")
+                        print("⚠️ Agent may have completed, but output streaming failed")
+                        return_code = 1
                 
             except Exception as e:
                 print(f"❌ Error during repository setup: {e}")