gitarsenal-cli 1.9.18 → 1.9.20

package/test_modalSandboxScript.py

@@ -899,8 +899,8 @@ class CommandListManager:
         
         print(f"🔍 Analyzing {len(failed_commands)} failed commands with LLM...")
         
-        # Use batch debugging for efficiency
-        fixes = call_openai_for_batch_debug(failed_commands, api_key, current_dir, sandbox)
+        # Use unified batch debugging for efficiency
+        fixes = call_llm_for_batch_debug(failed_commands, api_key, current_dir, sandbox)
         
         # Add the fixes to the command list
         added_fixes = []
@@ -1250,7 +1250,7 @@ class CommandListManager:
 # Import the fetch_modal_tokens module
 # print("🔄 Fetching tokens from proxy server...")
 from fetch_modal_tokens import get_tokens
-token_id, token_secret, openai_api_key = get_tokens()
+token_id, token_secret, openai_api_key, _ = get_tokens()
 
 # Check if we got valid tokens
 if token_id is None or token_secret is None:
@@ -1349,7 +1349,7 @@ def call_openai_for_debug(command, error_output, api_key=None, current_dir=None,
             try:
                 print("🔍 DEBUG: Trying to fetch API key from server...")
                 from fetch_modal_tokens import get_tokens
-                _, _, api_key = get_tokens()
+                _, _, api_key, _ = get_tokens()
                 if api_key:
                     # Set in environment for this session
                     os.environ["OPENAI_API_KEY"] = api_key
@@ -2016,6 +2016,674 @@ Provide fixes for all {len(failed_commands)} failed commands:"""
         print(f"❌ Error during batch debugging: {e}")
         return []
 
+def call_anthropic_for_debug(command, error_output, api_key=None, current_dir=None, sandbox=None):
+    """Call Anthropic Claude to debug a failed command and suggest a fix"""
+    print("\n🔍 DEBUG: Starting Anthropic Claude debugging...")
+    print(f"🔍 DEBUG: Command: {command}")
+    print(f"🔍 DEBUG: Error output length: {len(error_output) if error_output else 0}")
+    print(f"🔍 DEBUG: Current directory: {current_dir}")
+    print(f"🔍 DEBUG: Sandbox available: {sandbox is not None}")
+    
+    # Define _to_str function locally to avoid NameError
+    def _to_str(maybe_bytes):
+        try:
+            return (maybe_bytes.decode('utf-8') if isinstance(maybe_bytes, (bytes, bytearray)) else maybe_bytes)
+        except UnicodeDecodeError:
+            # Handle non-UTF-8 bytes by replacing invalid characters
+            if isinstance(maybe_bytes, (bytes, bytearray)):
+                return maybe_bytes.decode('utf-8', errors='replace')
+            else:
+                return str(maybe_bytes)
+        except Exception:
+            # Last resort fallback
+            return str(maybe_bytes)
+            
+    # Skip debugging for certain commands that commonly return non-zero exit codes
+    # but aren't actually errors (like test commands)
+    if command.strip().startswith("test "):
+        print("🔍 Skipping debugging for test command - non-zero exit code is expected behavior")
+        return None
+        
+    # Validate error_output - if it's empty, we can't debug effectively
+    if not error_output or not error_output.strip():
+        print("⚠️ Error output is empty. Cannot effectively debug the command.")
+        print("⚠️ Skipping Anthropic debugging due to lack of error information.")
+        return None
+    
+    # Try to get API key from multiple sources
+    if not api_key:
+        print("🔍 DEBUG: No Anthropic API key provided, searching for one...")
+        
+        # First try environment variable
+        api_key = os.environ.get("ANTHROPIC_API_KEY")
+        print(f"🔍 DEBUG: API key from environment: {'Found' if api_key else 'Not found'}")
+        if api_key:
+            print(f"🔍 DEBUG: Environment API key value: {api_key}")
+        
+        # If not in environment, try to fetch from server using fetch_modal_tokens
+        if not api_key:
+            try:
+                print("🔍 DEBUG: Trying to fetch API key from server...")
+                from fetch_modal_tokens import get_tokens
+                _, _, _, api_key = get_tokens()
+                if api_key:
+                    # Set in environment for this session
+                    os.environ["ANTHROPIC_API_KEY"] = api_key
+                else:
+                    print("⚠️ Could not fetch Anthropic API key from server")
+            except Exception as e:
+                print(f"⚠️ Error fetching API key from server: {e}")
+        
+        # Then try credentials manager
+        if not api_key:
+            print("🔍 DEBUG: Trying credentials manager...")
+            try:
+                from credentials_manager import CredentialsManager
+                credentials_manager = CredentialsManager()
+                api_key = credentials_manager.get_anthropic_api_key()
+                if api_key:
+                    print(f"🔍 DEBUG: API key from credentials manager: Found")
+                    print(f"🔍 DEBUG: Credentials manager API key value: {api_key}")
+                    # Set in environment for this session
+                    os.environ["ANTHROPIC_API_KEY"] = api_key
+                else:
+                    print("⚠️ Could not fetch Anthropic API key from credentials manager")
+            except Exception as e:
+                print(f"⚠️ Error fetching API key from credentials manager: {e}")
+        
+        # Store the API key in a persistent file if found
+        if api_key:
+            try:
+                os.makedirs(os.path.expanduser("~/.gitarsenal"), exist_ok=True)
+                with open(os.path.expanduser("~/.gitarsenal/anthropic_key"), "w") as f:
+                    f.write(api_key)
+                print("✅ Saved Anthropic API key for future use")
+            except Exception as e:
+                print(f"⚠️ Could not save API key: {e}")
+        
+        # Try to load from saved file if not in environment
+        if not api_key:
+            try:
+                key_file = os.path.expanduser("~/.gitarsenal/anthropic_key")
+                print(f"🔍 DEBUG: Checking for saved API key at: {key_file}")
+                if os.path.exists(key_file):
+                    with open(key_file, "r") as f:
+                        api_key = f.read().strip()
+                    if api_key:
+                        print("✅ Loaded Anthropic API key from saved file")
+                        print(f"🔍 DEBUG: API key from file: {api_key}")
+                        print(f"🔍 DEBUG: API key length: {len(api_key)}")
+                        # Also set in environment for this session
+                        os.environ["ANTHROPIC_API_KEY"] = api_key
+                    else:
+                        print("🔍 DEBUG: Saved file exists but is empty")
+                else:
+                    print("🔍 DEBUG: No saved API key file found")
+            except Exception as e:
+                print(f"⚠️ Could not load saved API key: {e}")
+    
+    if not api_key:
+        print("❌ No Anthropic API key available for debugging")
+        return None
+    
+    # Prepare the prompt for debugging
+    error_str = _to_str(error_output)
+    prompt = f"""You are a debugging assistant. Provide only the terminal command to fix the issue. 
+
+Context:
+- Current directory: {current_dir}
+- Sandbox available: {sandbox is not None}
+- Failed command: {command}
+- Error output: {error_str}
+
+Analyze the issue first, understand why it's happening, then provide the command to fix it. 
+
+Guidelines:
+- For file not found errors, first search for the file using 'find . -name filename -type f' and navigate to the directory if found
+- For missing packages, use appropriate package managers (pip, apt-get, npm)
+- For Git SSH authentication failures, always convert SSH URLs to HTTPS URLs (git@github.com:user/repo.git -> https://github.com/user/repo.git)
+- For authentication, suggest login commands with placeholders
+- For permission errors, suggest commands with sudo if appropriate
+- For network issues, suggest retry commands or alternative URLs
+
+Return only the command to fix the issue, nothing else."""
+
+    # Set up headers for Anthropic API
+    headers = {
+        "x-api-key": api_key,
+        "anthropic-version": "2023-06-01",
+        "content-type": "application/json"
+    }
+    
+    # Models to try in order of preference
+    models_to_try = ["claude-4-sonnet"]
+    
+    def try_api_call(model_name, retries=2, backoff_factor=1.5):
+        payload = {
+            "model": model_name,
+            "max_tokens": 300,
+            "messages": [
+                {"role": "user", "content": prompt}
+            ]
+        }
+        
+        print(f"🔍 DEBUG: Payload prepared, prompt length: {len(prompt)}")
+        
+        # Add specific handling for common errors
+        last_error = None
+        for attempt in range(retries + 1):
+            try:
+                if attempt > 0:
+                    # Exponential backoff
+                    wait_time = backoff_factor * (2 ** (attempt - 1))
+                    print(f"⏱️ Retrying in {wait_time:.1f} seconds... (attempt {attempt+1}/{retries+1})")
+                    time.sleep(wait_time)
+                
+                print(f"🤖 Calling Anthropic Claude with {model_name} model to debug the failed command...")
+                print(f"🔍 DEBUG: Making POST request to Anthropic API...")
+                response = requests.post(
+                    "https://api.anthropic.com/v1/messages",
+                    headers=headers,
+                    json=payload,
+                    timeout=45  # Increased timeout for reliability
+                )
+                
+                print(f"🔍 DEBUG: Response received, status code: {response.status_code}")
+                
+                # Handle specific status codes
+                if response.status_code == 200:
+                    print(f"🔍 DEBUG: Success! Response length: {len(response.text)}")
+                    return response.json(), None
+                elif response.status_code == 401:
+                    error_msg = "Authentication error: Invalid API key"
+                    print(f"❌ {error_msg}")
+                    print(f"🔍 DEBUG: Response text: {response.text}")
+                    # Don't retry auth errors
+                    return None, error_msg
+                elif response.status_code == 429:
+                    error_msg = "Rate limit exceeded or quota reached"
+                    print(f"⚠️ {error_msg}")
+                    print(f"🔍 DEBUG: Response text: {response.text}")
+                    # Always retry rate limit errors with increasing backoff
+                    last_error = error_msg
+                    continue
+                elif response.status_code == 500:
+                    error_msg = "Anthropic server error"
+                    print(f"⚠️ {error_msg}")
+                    print(f"🔍 DEBUG: Response text: {response.text}")
+                    # Retry server errors
+                    last_error = error_msg
+                    continue
+                else:
+                    error_msg = f"Status code: {response.status_code}, Response: {response.text}"
+                    print(f"⚠️ Anthropic API error: {error_msg}")
+                    print(f"🔍 DEBUG: Full response text: {response.text}")
+                    last_error = error_msg
+                    # Only retry if we have attempts left
+                    if attempt < retries:
+                        continue
+                    return None, error_msg
+            except requests.exceptions.Timeout:
+                error_msg = "Request timed out"
+                last_error = error_msg
+                # Always retry timeouts
+                continue
+            except requests.exceptions.ConnectionError:
+                error_msg = "Connection error"
+                print(f"⚠️ {error_msg}")
+                print(f"🔍 DEBUG: Connection failed to api.anthropic.com")
+                last_error = error_msg
+                # Always retry connection errors
+                continue
+            except Exception as e:
+                error_msg = str(e)
+                print(f"⚠️ Unexpected error: {error_msg}")
+                print(f"🔍 DEBUG: Exception type: {type(e).__name__}")
+                print(f"🔍 DEBUG: Exception details: {str(e)}")
+                last_error = error_msg
+                # Only retry if we have attempts left
+                if attempt < retries:
+                    continue
+                return None, error_msg
+        
+        # If we get here, all retries failed
+        return None, last_error
+    
+    # Try each model in sequence until one works
+    result = None
+    last_error = None
+    
+    for model in models_to_try:
+        result, error = try_api_call(model)
+        if result:
+            break
+        else:
+            print(f"⚠️ Failed to get response from {model}: {error}")
+            last_error = error
+    
+    if not result:
+        print(f"❌ All model attempts failed. Last error: {last_error}")
+        return None
+    
+    # Process the response
+    try:
+        print(f"🔍 DEBUG: Processing Anthropic response...")
+        print(f"🔍 DEBUG: Choices count: {len(result.get('content', []))}")
+        
+        fix_command = result["content"][0]["text"].strip()
+        print(f"🔍 DEBUG: Raw response content: {fix_command}")
+        
+        # Save the original response for debugging
+        original_response = fix_command
+        
+        # Extract just the command if it's wrapped in backticks or explanation
+        if "```" in fix_command:
+            # Extract content between backticks
+            import re
+            code_blocks = re.findall(r'```(?:bash|sh)?\s*(.*?)\s*```', fix_command, re.DOTALL)
+            if code_blocks:
+                fix_command = code_blocks[0].strip()
+                print(f"✅ Extracted command from code block: {fix_command}")
+        
+        # If the response still has explanatory text, try to extract just the command
+        if len(fix_command.split('\n')) > 1:
+            # First try to find lines that look like commands (start with common command prefixes)
+            command_prefixes = ['sudo', 'apt', 'pip', 'npm', 'yarn', 'git', 'cd', 'mv', 'cp', 'rm', 'mkdir', 'touch', 
+                              'chmod', 'chown', 'echo', 'cat', 'python', 'python3', 'node', 'export',
+                              'curl', 'wget', 'docker', 'make', 'gcc', 'g++', 'javac', 'java',
+                              'conda', 'uv', 'poetry', 'nvm', 'rbenv', 'pyenv', 'rustup']
+            
+            # Check for lines that start with common command prefixes
+            command_lines = [line.strip() for line in fix_command.split('\n') 
+                           if any(line.strip().startswith(prefix) for prefix in command_prefixes)]
+            
+            if command_lines:
+                # Use the first command line found
+                fix_command = command_lines[0]
+                print(f"✅ Identified command by prefix: {fix_command}")
+            else:
+                # Try to find lines that look like commands (contain common shell patterns)
+                shell_patterns = [' | ', ' > ', ' >> ', ' && ', ' || ', ' ; ', '$(',  '`', ' -y ', ' --yes ']
+                command_lines = [line.strip() for line in fix_command.split('\n') 
+                              if any(pattern in line for pattern in shell_patterns)]
+                
+                if command_lines:
+                    # Use the first command line found
+                    fix_command = command_lines[0]
+                    print(f"✅ Identified command by shell pattern: {fix_command}")
+                else:
+                    # Fall back to the shortest non-empty line as it's likely the command
+                    lines = [line.strip() for line in fix_command.split('\n') if line.strip()]
+                    if lines:
+                        # Exclude very short lines that are likely not commands
+                        valid_lines = [line for line in lines if len(line) > 5]
+                        if valid_lines:
+                            fix_command = min(valid_lines, key=len)
+                        else:
+                            fix_command = min(lines, key=len)
+                        print(f"✅ Selected shortest line as command: {fix_command}")
+        
+        # Clean up the command - remove any trailing periods or quotes
+        fix_command = fix_command.rstrip('.;"\'')
+        
+        # Remove common prefixes that LLMs sometimes add
+        prefixes_to_remove = [
+            "Run: ", "Execute: ", "Try: ", "Command: ", "Fix: ", "Solution: ",
+            "You should run: ", "You can run: ", "You need to run: "
+        ]
+        for prefix in prefixes_to_remove:
+            if fix_command.startswith(prefix):
+                fix_command = fix_command[len(prefix):].strip()
+                print(f"✅ Removed prefix: {prefix}")
+                break
+        
+        # If the command is still multi-line or very long, it might not be a valid command
+        if len(fix_command.split('\n')) > 1 or len(fix_command) > 500:
+            print("⚠️ Extracted command appears invalid (multi-line or too long)")
+            print("🔍 Original response from LLM:")
+            print("-" * 60)
+            print(original_response)
+            print("-" * 60)
+            print("⚠️ Using best guess for command")
+        
+        print(f"🔧 Suggested fix: {fix_command}")
+        print(f"🔍 DEBUG: Returning fix command: {fix_command}")
+        return fix_command
+    except Exception as e:
+        print(f"❌ Error processing Anthropic response: {e}")
+        print(f"🔍 DEBUG: Exception type: {type(e).__name__}")
+        print(f"🔍 DEBUG: Exception details: {str(e)}")
+        return None
+
+def switch_to_anthropic_models():
+    """Switch the debugging system to use Anthropic Claude models instead of OpenAI"""
+    print("\n🔄 Switching to Anthropic Claude models for debugging...")
+    
+    # Set environment variable to indicate Anthropic preference
+    os.environ["GITARSENAL_DEBUG_MODEL"] = "anthropic"
+    
+    # Try to get Anthropic API key
+    try:
+        from credentials_manager import CredentialsManager
+        credentials_manager = CredentialsManager()
+        api_key = credentials_manager.get_anthropic_api_key()
+        if api_key:
+            os.environ["ANTHROPIC_API_KEY"] = api_key
+            print("✅ Anthropic API key configured")
+            print("✅ Debugging will now use Anthropic Claude models")
+            return True
+        else:
+            print("⚠️ No Anthropic API key found")
+            print("💡 You can set your Anthropic API key using:")
+            print("   export ANTHROPIC_API_KEY='your-key'")
+            print("   Or run the credentials manager to set it up")
+            return False
+    except Exception as e:
+        print(f"❌ Error configuring Anthropic: {e}")
+        return False
+
+def switch_to_openai_models():
+    """Switch the debugging system to use OpenAI models (default)"""
+    print("\n🔄 Switching to OpenAI models for debugging...")
+    
+    # Set environment variable to indicate OpenAI preference
+    os.environ["GITARSENAL_DEBUG_MODEL"] = "openai"
+    
+    # Try to get OpenAI API key
+    try:
+        from credentials_manager import CredentialsManager
+        credentials_manager = CredentialsManager()
+        api_key = credentials_manager.get_openai_api_key()
+        if api_key:
+            os.environ["OPENAI_API_KEY"] = api_key
+            print("✅ OpenAI API key configured")
+            print("✅ Debugging will now use OpenAI models")
+            return True
+        else:
+            print("⚠️ No OpenAI API key found")
+            print("💡 You can set your OpenAI API key using:")
+            print("   export OPENAI_API_KEY='your-key'")
+            print("   Or run the credentials manager to set it up")
+            return False
+    except Exception as e:
+        print(f"❌ Error configuring OpenAI: {e}")
+        return False
+
+def get_current_debug_model():
+    """Get the currently configured debugging model preference"""
+    return os.environ.get("GITARSENAL_DEBUG_MODEL", "openai")
+
+def call_llm_for_debug(command, error_output, api_key=None, current_dir=None, sandbox=None):
+    """Unified function to call LLM for debugging - routes to OpenAI or Anthropic based on configuration"""
+    current_model = get_current_debug_model()
+    
+    print(f"🔍 DEBUG: Using {current_model.upper()} for debugging...")
+    
+    if current_model == "anthropic":
+        # Try to get Anthropic API key if not provided
+        if not api_key:
+            # First try environment variable
+            api_key = os.environ.get("ANTHROPIC_API_KEY")
+            
+            # If not in environment, try to fetch from server using fetch_modal_tokens
+            if not api_key:
+                try:
+                    from fetch_modal_tokens import get_tokens
+                    _, _, _, api_key = get_tokens()
+                except Exception as e:
+                    print(f"⚠️ Error fetching Anthropic API key from server: {e}")
+            
+            # Then try credentials manager
+            if not api_key:
+                try:
+                    from credentials_manager import CredentialsManager
+                    credentials_manager = CredentialsManager()
+                    api_key = credentials_manager.get_anthropic_api_key()
+                except Exception as e:
+                    print(f"⚠️ Error getting Anthropic API key from credentials manager: {e}")
+        
+        return call_anthropic_for_debug(command, error_output, api_key, current_dir, sandbox)
+    else:
+        # Default to OpenAI
+        # Try to get OpenAI API key if not provided
+        if not api_key:
+            # First try environment variable
+            api_key = os.environ.get("OPENAI_API_KEY")
+            
+            # If not in environment, try to fetch from server using fetch_modal_tokens
+            if not api_key:
+                try:
+                    from fetch_modal_tokens import get_tokens
+                    _, _, api_key, _ = get_tokens()
+                except Exception as e:
+                    print(f"⚠️ Error fetching OpenAI API key from server: {e}")
+            
+            # Then try credentials manager
+            if not api_key:
+                try:
+                    from credentials_manager import CredentialsManager
+                    credentials_manager = CredentialsManager()
+                    api_key = credentials_manager.get_openai_api_key()
+                except Exception as e:
+                    print(f"⚠️ Error getting OpenAI API key from credentials manager: {e}")
+        
+        return call_openai_for_debug(command, error_output, api_key, current_dir, sandbox)
+
+def call_llm_for_batch_debug(failed_commands, api_key=None, current_dir=None, sandbox=None):
+    """Unified function to call LLM for batch debugging - routes to OpenAI or Anthropic based on configuration"""
+    current_model = get_current_debug_model()
+    
+    print(f"🔍 DEBUG: Using {current_model.upper()} for batch debugging...")
+    
+    if current_model == "anthropic":
+        # Try to get Anthropic API key if not provided
+        if not api_key:
+            # First try environment variable
+            api_key = os.environ.get("ANTHROPIC_API_KEY")
+            
+            # If not in environment, try to fetch from server using fetch_modal_tokens
+            if not api_key:
+                try:
+                    from fetch_modal_tokens import get_tokens
+                    _, _, _, api_key = get_tokens()
+                except Exception as e:
+                    print(f"⚠️ Error fetching Anthropic API key from server: {e}")
+            
+            # Then try credentials manager
+            if not api_key:
+                try:
+                    from credentials_manager import CredentialsManager
+                    credentials_manager = CredentialsManager()
+                    api_key = credentials_manager.get_anthropic_api_key()
+                except Exception as e:
+                    print(f"⚠️ Error getting Anthropic API key from credentials manager: {e}")
+        
+        return call_anthropic_for_batch_debug(failed_commands, api_key, current_dir, sandbox)
+    else:
+        # Default to OpenAI
+        # Try to get OpenAI API key if not provided
+        if not api_key:
+            # First try environment variable
+            api_key = os.environ.get("OPENAI_API_KEY")
+            
+            # If not in environment, try to fetch from server using fetch_modal_tokens
+            if not api_key:
+                try:
+                    from fetch_modal_tokens import get_tokens
+                    _, _, api_key, _ = get_tokens()
+                except Exception as e:
+                    print(f"⚠️ Error fetching OpenAI API key from server: {e}")
+            
+            # Then try credentials manager
+            if not api_key:
+                try:
+                    from credentials_manager import CredentialsManager
+                    credentials_manager = CredentialsManager()
+                    api_key = credentials_manager.get_openai_api_key()
+                except Exception as e:
+                    print(f"⚠️ Error getting OpenAI API key from credentials manager: {e}")
+        
+        return call_openai_for_batch_debug(failed_commands, api_key, current_dir, sandbox)
+
+def call_anthropic_for_batch_debug(failed_commands, api_key=None, current_dir=None, sandbox=None):
+    """Call Anthropic Claude to debug multiple failed commands and suggest fixes for all of them at once"""
+    print("\n🔍 DEBUG: Starting batch Anthropic Claude debugging...")
+    print(f"🔍 DEBUG: Analyzing {len(failed_commands)} failed commands")
+    
+    if not failed_commands:
+        print("⚠️ No failed commands to analyze")
+        return []
+    
+    if not api_key:
+        print("🔍 DEBUG: No Anthropic API key provided, searching for one...")
+        
+        # First try environment variable
+        api_key = os.environ.get("ANTHROPIC_API_KEY")
+        print(f"🔍 DEBUG: API key from environment: {'Found' if api_key else 'Not found'}")
+        if api_key:
+            print(f"🔍 DEBUG: Environment API key value: {api_key}")
+        
+        # If not in environment, try to fetch from server using fetch_modal_tokens
+        if not api_key:
+            try:
+                print("🔍 DEBUG: Trying to fetch API key from server...")
+                from fetch_modal_tokens import get_tokens
+                _, _, _, api_key = get_tokens()
+                if api_key:
+                    # Set in environment for this session
+                    os.environ["ANTHROPIC_API_KEY"] = api_key
+                else:
+                    print("⚠️ Could not fetch Anthropic API key from server")
+            except Exception as e:
+                print(f"⚠️ Error fetching API key from server: {e}")
+        
+        # Then try credentials manager
+        if not api_key:
+            print("🔍 DEBUG: Trying credentials manager...")
+            try:
+                from credentials_manager import CredentialsManager
+                credentials_manager = CredentialsManager()
+                api_key = credentials_manager.get_anthropic_api_key()
+                if api_key:
+                    print(f"🔍 DEBUG: API key from credentials manager: Found")
+                    print(f"🔍 DEBUG: Credentials manager API key value: {api_key}")
+                    # Set in environment for this session
+                    os.environ["ANTHROPIC_API_KEY"] = api_key
+                else:
+                    print("⚠️ Could not fetch Anthropic API key from credentials manager")
+            except Exception as e:
+                print(f"⚠️ Error fetching API key from credentials manager: {e}")
+        
+        if not api_key:
+            print("❌ No Anthropic API key available for batch debugging")
+            return []
+    
+    # Prepare context for batch analysis
+    context_parts = []
+    context_parts.append(f"Current directory: {current_dir}")
+    context_parts.append(f"Sandbox available: {sandbox is not None}")
+    
+    # Add failed commands with their errors
+    for i, failed_cmd in enumerate(failed_commands, 1):
+        cmd_type = failed_cmd.get('type', 'main')
+        original_cmd = failed_cmd.get('original_command', '')
+        cmd_text = failed_cmd['command']
+        stderr = failed_cmd.get('stderr', '')
+        stdout = failed_cmd.get('stdout', '')
+        
+        context_parts.append(f"\n--- Failed Command {i} ({cmd_type}) ---")
+        context_parts.append(f"Command: {cmd_text}")
+        if original_cmd and original_cmd != cmd_text:
+            context_parts.append(f"Original Command: {original_cmd}")
+        if stderr:
+            context_parts.append(f"Error Output: {stderr}")
+        if stdout:
+            context_parts.append(f"Standard Output: {stdout}")
+    
+    # Create the prompt for batch analysis
+    prompt = f"""You are a debugging assistant analyzing multiple failed commands. 
+
+Context:
+{chr(10).join(context_parts)}
+
+Please analyze each failed command and provide a fix command for each one. For each failed command, respond with:
+
+FIX_COMMAND_{i}: <the fix command>
+REASON_{i}: <brief explanation of why the original command failed and how the fix addresses it>
+
+Guidelines:
+- For file not found errors, first search for the file using 'find . -name filename -type f'
+- For missing packages, use appropriate package managers (pip, apt-get, npm)
+- For Git SSH authentication failures, convert SSH URLs to HTTPS URLs
+- For permission errors, suggest commands with sudo if appropriate
+- For network issues, suggest retry commands or alternative URLs
+- Keep each fix command simple and focused on the specific error
+
+Provide fixes for all {len(failed_commands)} failed commands:"""
+
+    # Set up headers for Anthropic API
+    headers = {
+        "x-api-key": api_key,
+        "anthropic-version": "2023-06-01",
+        "content-type": "application/json"
+    }
+    
+    payload = {
+        "model": "claude-3-5-sonnet-20241022",  # Use a more capable model for batch analysis
+        "max_tokens": 1000,
+        "messages": [
+            {"role": "user", "content": prompt}
+        ]
+    }
+    
+    try:
+        print(f"🤖 Calling Anthropic Claude for batch debugging of {len(failed_commands)} commands...")
+        response = requests.post(
+            "https://api.anthropic.com/v1/messages",
+            headers=headers,
+            json=payload,
+            timeout=60
+        )
+        
+        if response.status_code == 200:
+            result = response.json()
+            content = result['content'][0]['text']
+            print(f"✅ Batch analysis completed")
+            
+            # Parse the response to extract fix commands
+            fixes = []
+            for i in range(1, len(failed_commands) + 1):
+                fix_pattern = f"FIX_COMMAND_{i}: (.+)"
+                reason_pattern = f"REASON_{i}: (.+)"
+                
+                fix_match = re.search(fix_pattern, content, re.MULTILINE)
+                reason_match = re.search(reason_pattern, content, re.MULTILINE)
+                
+                if fix_match:
+                    fix_command = fix_match.group(1).strip()
+                    reason = reason_match.group(1).strip() if reason_match else "Anthropic Claude suggested fix"
+                    
+                    # Clean up the fix command
+                    if fix_command.startswith('`') and fix_command.endswith('`'):
+                        fix_command = fix_command[1:-1]
+                    
+                    fixes.append({
+                        'original_command': failed_commands[i-1]['command'],
+                        'fix_command': fix_command,
+                        'reason': reason,
+                        'command_index': i-1
+                    })
+            
+            print(f"🔧 Generated {len(fixes)} fix commands from batch analysis")
+            return fixes
+        else:
+            print(f"❌ Anthropic API error: {response.status_code} - {response.text}")
+            return []
+            
+    except Exception as e:
+        print(f"❌ Error during batch debugging: {e}")
+        return []
+
 def generate_random_password(length=16):
     """Generate a random password for SSH access"""
     alphabet = string.ascii_letters + string.digits + "!@#$%^&*"
@@ -2418,13 +3086,12 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
                         if not success:
                             print(f"⚠️ Command failed, attempting LLM debugging...")
                             
-                            # Call OpenAI for debugging
+                            # Call LLM for debugging
                             try:
                                 current_dir = shell.get_cwd()
-                                api_key = os.environ.get("OPENAI_API_KEY")
                                 
-                                # Use existing call_openai_for_debug function
-                                fix_command = call_openai_for_debug(cmd_text, stderr, api_key=api_key, current_dir=current_dir, sandbox=shell)
+                                # Use unified LLM debugging function
+                                fix_command = call_llm_for_debug(cmd_text, stderr, current_dir=current_dir, sandbox=shell)
                                 
                                 if fix_command:
                                     print(f"🔧 OpenAI suggested fix command: {fix_command}")