gitarsenal-cli 1.9.21 → 1.9.23

package/python/llm_debugging.py

@@ -0,0 +1,1061 @@
+import os
+import re
+import json
+import requests
+import openai
+import anthropic
+
+def call_openai_for_debug(command, error_output, api_key=None, current_dir=None, sandbox=None):
+    """Call OpenAI to debug a failed command and suggest a fix"""
+    print("\n🔍 DEBUG: Starting LLM 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 OpenAI debugging due to lack of error information.")
+        return None
+    
+    # Try to get API key from multiple sources
+    if not api_key:
+        print("🔍 DEBUG: No API key provided, searching for one...")
+        
+        # First try environment variable
+        api_key = os.environ.get("OPENAI_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["OPENAI_API_KEY"] = api_key
+                else:
+                    print("⚠️ Could not fetch OpenAI API key from server")
+            except Exception as e:
+                print(f"⚠️ Error fetching API key from server: {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/openai_key"), "w") as f:
+                    f.write(api_key)
+                print("✅ Saved OpenAI 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/openai_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 OpenAI 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["OPENAI_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}")
+        
+        # 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_openai_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["OPENAI_API_KEY"] = api_key
+                else:
+                    print(f"🔍 DEBUG: API key from credentials manager: Not found")
+            except ImportError as e:
+                print(f"🔍 DEBUG: Credentials manager not available: {e}")
+                # Fall back to direct input if credentials_manager is not available
+                pass
+        
+        # Finally, prompt the user if still no API key
+        if not api_key:
+            print("🔍 DEBUG: No API key found in any source, prompting user...")
+            print("\n" + "="*60)
+            print("🔑 OPENAI API KEY REQUIRED FOR DEBUGGING")
+            print("="*60)
+            print("To debug failed commands, an OpenAI API key is needed.")
+            print("📝 Please paste your OpenAI API key below:")
+            print("   (Your input will be hidden for security)")
+            print("-" * 60)
+            
+            try:
+                api_key = getpass.getpass("OpenAI API Key: ").strip()
+                if not api_key:
+                    print("❌ No API key provided. Skipping debugging.")
+                    return None
+                print("✅ API key received successfully!")
+                print(f"🔍 DEBUG: User-provided API key: {api_key}")
+                # Save the API key to environment for future use in this session
+                os.environ["OPENAI_API_KEY"] = api_key
+            except KeyboardInterrupt:
+                print("\n❌ API key input cancelled by user.")
+                return None
+            except Exception as e:
+                print(f"❌ Error getting API key: {e}")
+                return None
+    
+    # If we still don't have an API key, we can't proceed
+    if not api_key:
+        print("❌ No OpenAI API key available. Cannot perform LLM debugging.")
+        print("💡 To enable LLM debugging, set the OPENAI_API_KEY environment variable")
+        return None
+    
+    # print(f"✅ OpenAI API key available (length: {len(api_key)})")
+    
+    # Gather additional context to help with debugging
+    directory_context = ""
+    system_info = ""
+    command_history = ""
+    file_context = ""
+    
+    if sandbox:
+        try:
+            print("🔍 Getting system information for better debugging...")
+            
+            # Get OS information
+            os_info_cmd = """
+            echo "OS Information:"
+            cat /etc/os-release 2>/dev/null || echo "OS release info not available"
+            echo -e "\nKernel Information:"
+            uname -a
+            echo -e "\nPython Information:"
+            python --version
+            pip --version
+            echo -e "\nPackage Manager:"
+            which apt 2>/dev/null && echo "apt available" || echo "apt not available"
+            which yum 2>/dev/null && echo "yum available" || echo "yum not available"
+            which dnf 2>/dev/null && echo "dnf available" || echo "dnf not available"
+            which apk 2>/dev/null && echo "apk available" || echo "apk not available"
+            echo -e "\nEnvironment Variables:"
+            env | grep -E "^(PATH|PYTHON|VIRTUAL_ENV|HOME|USER|SHELL|LANG)" || echo "No relevant env vars found"
+            """
+            
+            os_result = sandbox.exec("bash", "-c", os_info_cmd)
+            os_output = ""
+            for line in os_result.stdout:
+                os_output += _to_str(line)
+            os_result.wait()
+            
+            system_info = f"""
+System Information:
+{os_output}
+"""
+            print("✅ System information gathered successfully")
+        except Exception as e:
+            print(f"⚠️ Error getting system information: {e}")
+            system_info = "System information not available\n"
+    
+    if current_dir and sandbox:
+        try:
+            # print("🔍 Getting directory context for better debugging...")
+            
+            # Get current directory contents
+            ls_result = sandbox.exec("bash", "-c", "ls -la")
+            ls_output = ""
+            for line in ls_result.stdout:
+                ls_output += _to_str(line)
+            ls_result.wait()
+            
+            # Get parent directory contents
+            parent_result = sandbox.exec("bash", "-c", "ls -la ../")
+            parent_ls = ""
+            for line in parent_result.stdout:
+                parent_ls += _to_str(line)
+            parent_result.wait()
+                
+            directory_context = f"""
+Current directory contents:
+{ls_output}
+
+Parent directory contents:
+{parent_ls}
+"""
+            print("✅ Directory context gathered successfully")
+            
+            # Check for relevant files that might provide additional context
+            # For example, if error mentions a specific file, try to get its content
+            relevant_files = []
+            error_files = re.findall(r'(?:No such file or directory|cannot open|not found): ([^\s:]+)', error_output)
+            if error_files:
+                for file_path in error_files:
+                    # Clean up the file path
+                    file_path = file_path.strip("'\"")
+                    if not os.path.isabs(file_path):
+                        file_path = os.path.join(current_dir, file_path)
+                
+                # Try to get the parent directory if the file doesn't exist
+                if '/' in file_path:
+                    parent_file_dir = os.path.dirname(file_path)
+                    relevant_files.append(parent_file_dir)
+            
+            # Look for package.json, requirements.txt, etc.
+            common_config_files = ["package.json", "requirements.txt", "pyproject.toml", "setup.py", 
+                                 "Pipfile", "Dockerfile", "docker-compose.yml", "Makefile"]
+            
+            for config_file in common_config_files:
+                check_cmd = f"test -f {current_dir}/{config_file}"
+                check_result = sandbox.exec("bash", "-c", check_cmd)
+                check_result.wait()
+                if check_result.returncode == 0:
+                    relevant_files.append(f"{current_dir}/{config_file}")
+            
+            # Get content of relevant files
+            if relevant_files:
+                file_context = "\nRelevant file contents:\n"
+                for file_path in relevant_files[:2]:  # Limit to 2 files to avoid too much context
+                    try:
+                        file_check_cmd = f"test -f {file_path}"
+                        file_check = sandbox.exec("bash", "-c", file_check_cmd)
+                        file_check.wait()
+                        
+                        if file_check.returncode == 0:
+                            # It's a file, get its content
+                            cat_cmd = f"cat {file_path}"
+                            cat_result = sandbox.exec("bash", "-c", cat_cmd)
+                            file_content = ""
+                            for line in cat_result.stdout:
+                                file_content += _to_str(line)
+                            cat_result.wait()
+                            
+                            # Truncate if too long
+                            if len(file_content) > 1000:
+                                file_content = file_content[:1000] + "\n... (truncated)"
+                            
+                            file_context += f"\n--- {file_path} ---\n{file_content}\n"
+                        else:
+                            # It's a directory, list its contents
+                            ls_cmd = f"ls -la {file_path}"
+                            ls_dir_result = sandbox.exec("bash", "-c", ls_cmd)
+                            dir_content = ""
+                            for line in ls_dir_result.stdout:
+                                dir_content += _to_str(line)
+                            ls_dir_result.wait()
+                            
+                            file_context += f"\n--- Directory: {file_path} ---\n{dir_content}\n"
+                    except Exception as e:
+                        print(f"⚠️ Error getting content of {file_path}: {e}")
+                
+                # print(f"✅ Additional file context gathered from {len(relevant_files)} relevant files")
+            
+        except Exception as e:
+            print(f"⚠️ Error getting directory context: {e}")
+            directory_context = f"\nCurrent directory: {current_dir}\n"
+    
+    # Prepare the API request
+    headers = {
+        "Content-Type": "application/json",
+        "Authorization": f"Bearer {api_key}"
+    }
+
+    stored_credentials = get_stored_credentials()
+    auth_context = generate_auth_context(stored_credentials)
+    
+    # Create a prompt for the LLM
+    print("\n" + "="*60)
+    print("DEBUG: ERROR_OUTPUT SENT TO LLM:")
+    print("="*60)
+    print(f"{error_output}")
+    print("="*60 + "\n")
+    
+    prompt = f"""
+I'm trying to run the following command in a Linux environment:
+
+```
+{command}
+```
+
+But it failed with this error:
+
+```
+{error_output}
+```
+{system_info}
+{directory_context}
+{file_context}
+
+AVAILABLE CREDENTIALS:
+{auth_context}
+
+Please analyze the error and provide ONLY a single terminal command that would fix the issue.
+Consider the current directory, system information, directory contents, and available credentials carefully before suggesting a solution.
+
+IMPORTANT GUIDELINES:
+1. For any commands that might ask for yes/no confirmation, use the appropriate non-interactive flag:
+   - For apt/apt-get: use -y or --yes
+   - For rm: use -f or --force
+
+2. If the error indicates a file is not found:
+   - FIRST try to search for the file using: find . -name "filename" -type f 2>/dev/null
+   - If found, navigate to that directory using: cd /path/to/directory
+   - If not found, then consider creating the file or installing missing packages
+
+3. For missing packages or dependencies:
+   - Use pip install for Python packages
+   - Use apt-get install -y for system packages
+   - Use npm install for Node.js packages
+
+4. For authentication issues:
+   - Analyze the error to determine what type of authentication is needed
+   - ALWAYS use the actual credential values from the AVAILABLE CREDENTIALS section above (NOT placeholders)
+   - Look for the specific API key or token needed in the auth_context and use its exact value
+   - Common patterns:
+     * wandb errors: use wandb login with the actual WANDB_API_KEY value from auth_context
+     * huggingface errors: use huggingface-cli login with the actual HF_TOKEN or HUGGINGFACE_TOKEN value from auth_context
+     * github errors: configure git credentials with the actual GITHUB_TOKEN value from auth_context
+     * kaggle errors: create ~/.kaggle/kaggle.json with the actual KAGGLE_USERNAME and KAGGLE_KEY values from auth_context
+     * API errors: export the appropriate API key as environment variable using the actual value from auth_context
+
+5. Environment variable exports:
+   - Use export commands for API keys that need to be in environment
+   - ALWAYS use the actual credential values from auth_context, never use placeholders like "YOUR_API_KEY"
+   - Example: export OPENAI_API_KEY="sk-..." (using the actual key from auth_context)
+
+6. CRITICAL: When using any API key, token, or credential:
+   - Find the exact value in the AVAILABLE CREDENTIALS section
+   - Use that exact value in your command
+   - Do not use generic placeholders or dummy values
+   - The auth_context contains real, usable credentials
+
+7. For Git SSH authentication failures:
+   - If the error contains "Host key verification failed" or "Could not read from remote repository"
+   - ALWAYS convert SSH URLs to HTTPS URLs for public repositories
+   - Replace git@github.com:username/repo.git with https://github.com/username/repo.git
+   - This works for public repositories without authentication
+   - Example: git clone https://github.com/xg-chu/ARTalk.git
+
+Do not provide any explanations, just the exact command to run.
+"""
+    
+    # Prepare the API request payload
+    # print("🔍 DEBUG: Preparing API request...")
+    
+    # Try to use GPT-4 first, but fall back to other models if needed
+    models_to_try = [
+        "gpt-4o-mini",        # First choice: GPT-4o (most widely available)
+    ]
+    
+    # Check if we have a preferred model in environment
+    preferred_model = os.environ.get("OPENAI_MODEL")
+    if preferred_model:
+        # Insert the preferred model at the beginning of the list
+        models_to_try.insert(0, preferred_model)
+        # print(f"✅ Using preferred model from environment: {preferred_model}")
+        
+    # Remove duplicates while preserving order
+    models_to_try = list(dict.fromkeys(models_to_try))
+    # print(f"🔍 DEBUG: Models to try: {models_to_try}")
+    
+    # Function to make the API call with a specific model
+    def try_api_call(model_name, retries=2, backoff_factor=1.5):
+        # print(f"🔍 DEBUG: Attempting API call with model: {model_name}")
+        # print(f"🔍 DEBUG: API key available: {'Yes' if api_key else 'No'}")
+        # if api_key:
+        #     print(f"🔍 DEBUG: API key length: {len(api_key)}")
+        #     print(f"🔍 DEBUG: API key starts with: {api_key[:10]}...")
+        
+        payload = {
+            "model": model_name,
+            "messages": [
+                {"role": "system", "content": "You are a debugging assistant. Provide only the terminal command to fix the issue. Analyze the issue first, understand why it's happening, then provide the command to fix it. 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."},
+                {"role": "user", "content": prompt}
+            ],
+            "temperature": 0.2,
+            "max_tokens": 300
+        }
+        
+        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 OpenAI with {model_name} model to debug the failed command...")
+                print(f"🔍 DEBUG: Making POST request to OpenAI API...")
+                response = requests.post(
+                    "https://api.openai.com/v1/chat/completions",
+                    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 = "OpenAI 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"⚠️ OpenAI 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"
+                # print(f"⚠️ {error_msg}")
+                # print(f"🔍 DEBUG: Timeout after 45 seconds")
+                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.openai.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:
+            # print(f"✅ Successfully got response from {model}")
+            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 OpenAI response...")
+        # print(f"🔍 DEBUG: Response structure: {list(result.keys())}")
+        print(f"🔍 DEBUG: Choices count: {len(result.get('choices', []))}")
+        
+        fix_command = result["choices"][0]["message"]["content"].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 OpenAI response: {e}")
+        print(f"🔍 DEBUG: Exception type: {type(e).__name__}")
+        print(f"🔍 DEBUG: Exception details: {str(e)}")
+        return None
+
+def call_openai_for_batch_debug(failed_commands, api_key=None, current_dir=None, sandbox=None):
+    """Call OpenAI to debug multiple failed commands and suggest fixes for all of them at once"""
+    print("\n🔍 DEBUG: Starting batch LLM 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("❌ No OpenAI API key provided 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:"""
+
+    # Make the API call
+    headers = {
+        "Authorization": f"Bearer {api_key}",
+        "Content-Type": "application/json"
+    }
+    
+    payload = {
+        "model": "gpt-4o-mini",  # Use a more capable model for batch analysis
+        "messages": [
+            {"role": "system", "content": "You are a debugging assistant. Analyze failed commands and provide specific fix commands. Return only the fix commands and reasons in the specified format."},
+            {"role": "user", "content": prompt}
+        ],
+        "temperature": 0.1,
+        "max_tokens": 1000
+    }
+    
+    try:
+        print(f"🤖 Calling OpenAI for batch debugging of {len(failed_commands)} commands...")
+        response = requests.post(
+            "https://api.openai.com/v1/chat/completions",
+            headers=headers,
+            json=payload,
+            timeout=60
+        )
+        
+        if response.status_code == 200:
+            result = response.json()
+            content = result['choices'][0]['message']['content']
+            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 "LLM 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"❌ OpenAI API error: {response.status_code} - {response.text}")
+            return []
+            
+    except Exception as e:
+        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