gitarsenal-cli 1.9.11 → 1.9.13

package/python/test_modalSandboxScript.py

@@ -15,7 +15,7 @@ import uuid
 import signal
 from pathlib import Path
 import modal
-
+import anthropic
 # Import authentication manager
 try:
     from auth_manager import AuthManager
@@ -31,6 +31,7 @@ parser.add_argument('--gpu', default='A10G', help='GPU type to use')
 parser.add_argument('--repo-url', help='Repository URL')
 parser.add_argument('--volume-name', help='Volume name')
 parser.add_argument('--use-api', action='store_true', help='Use API to fetch setup commands')
+parser.add_argument('--yes', action='store_true', help='Skip confirmation prompts')
 
 # Parse only known args to avoid conflicts with other arguments
 args, unknown = parser.parse_known_args()
@@ -515,21 +516,57 @@ class PersistentShell:
             REMOVE_COMMAND: <reason>
             """
             
-            # Call OpenAI API
-            import openai
-            client = openai.OpenAI(api_key=api_key)
-            
-            response = client.chat.completions.create(
-                model="gpt-4o-mini",
-                messages=[
-                    {"role": "system", "content": "You are a helpful assistant that suggests alternative commands that don't require user input."},
-                    {"role": "user", "content": prompt}
-                ],
-                max_tokens=150,
-                temperature=0.7
-            )
-            
-            response_text = response.choices[0].message.content.strip()
+            # Try OpenAI API first
+            try:
+                import openai
+                client = openai.OpenAI(api_key=api_key)
+                
+                response = client.chat.completions.create(
+                    model="gpt-4.1",
+                    messages=[
+                        {"role": "system", "content": "You are a helpful assistant that suggests alternative commands that don't require user input."},
+                        {"role": "user", "content": prompt}
+                    ],
+                    max_tokens=150,
+                    temperature=0.7
+                )
+                
+                response_text = response.choices[0].message.content.strip()
+                
+            except Exception as e:
+                print(f"⚠️ OpenAI API call failed: {e}")
+                
+                # Try Claude as fallback if available
+                if anthropic is not None:
+                    print("🔄 Trying Claude-4-Sonnet as fallback for alternative command suggestion...")
+                    try:
+                        # Get Anthropic API key
+                        anthropic_api_key = os.environ.get("ANTHROPIC_API_KEY")
+                        if not anthropic_api_key:
+                            print("⚠️ No ANTHROPIC_API_KEY found in environment")
+                            return None
+                        
+                        # Create Anthropic client
+                        client = anthropic.Anthropic(api_key=anthropic_api_key)
+                        
+                        print("🤖 Calling Claude-4-Sonnet for alternative command suggestion...")
+                        message = client.messages.create(
+                            model="claude-3-5-sonnet-20241022",
+                            max_tokens=150,
+                            messages=[
+                                {"role": "user", "content": prompt}
+                            ]
+                        )
+                        
+                        response_text = message.content[0].text.strip()
+                        print("✅ Claude alternative command suggestion completed")
+                        
+                    except Exception as claude_error:
+                        print(f"❌ Claude API call failed: {claude_error}")
+                        return None
+                else:
+                    print("⚠️ Claude fallback not available (anthropic library not installed)")
+                    return None
             
             # Check if the response suggests removing the command
             if response_text.startswith("REMOVE_COMMAND:"):
@@ -573,20 +610,10 @@ class PersistentShell:
             return output.strip()
         return self.working_dir
     
-    def get_virtual_env(self):
-        """Get the currently activated virtual environment path."""
-        return self.virtual_env_path
-    
     def is_in_venv(self):
         """Check if we're currently in a virtual environment."""
         return self.virtual_env_path is not None and self.virtual_env_path != ""
     
-    def get_venv_name(self):
-        """Get the name of the current virtual environment if active."""
-        if self.is_in_venv():
-            return os.path.basename(self.virtual_env_path)
-        return None
-    
     def exec(self, *args, **kwargs):
         """Compatibility method to make PersistentShell work with call_openai_for_debug."""
         # Convert exec call to execute method
@@ -976,23 +1003,59 @@ class CommandListManager:
             RUN: <reason>
             """
             
-            # Call OpenAI API
-            import openai
-            client = openai.OpenAI(api_key=api_key)
-            
-            print("🔍 Analyzing if original command should be skipped...")
-            
-            response = client.chat.completions.create(
-                model="gpt-3.5-turbo",
-                messages=[
-                    {"role": "system", "content": "You are a helpful assistant that analyzes command execution."},
-                    {"role": "user", "content": prompt}
-                ],
-                max_tokens=100,
-                temperature=0.3
-            )
-            
-            response_text = response.choices[0].message.content.strip()
+            # Try OpenAI API first
+            try:
+                import openai
+                client = openai.OpenAI(api_key=api_key)
+                
+                print("🔍 Analyzing if original command should be skipped...")
+                
+                response = client.chat.completions.create(
+                    model="gpt-3.5-turbo",
+                    messages=[
+                        {"role": "system", "content": "You are a helpful assistant that analyzes command execution."},
+                        {"role": "user", "content": prompt}
+                    ],
+                    max_tokens=100,
+                    temperature=0.3
+                )
+                
+                response_text = response.choices[0].message.content.strip()
+                
+            except Exception as e:
+                print(f"⚠️ OpenAI API call failed: {e}")
+                
+                # Try Claude as fallback if available
+                if anthropic is not None:
+                    print("🔄 Trying Claude-4-Sonnet as fallback for command skip analysis...")
+                    try:
+                        # Get Anthropic API key
+                        anthropic_api_key = os.environ.get("ANTHROPIC_API_KEY")
+                        if not anthropic_api_key:
+                            print("⚠️ No ANTHROPIC_API_KEY found in environment")
+                            return False, "No API key available"
+                        
+                        # Create Anthropic client
+                        client = anthropic.Anthropic(api_key=anthropic_api_key)
+                        
+                        print("🤖 Calling Claude-4-Sonnet for command skip analysis...")
+                        message = client.messages.create(
+                            model="claude-3-5-sonnet-20241022",
+                            max_tokens=100,
+                            messages=[
+                                {"role": "user", "content": prompt}
+                            ]
+                        )
+                        
+                        response_text = message.content[0].text.strip()
+                        print("✅ Claude command skip analysis completed")
+                        
+                    except Exception as claude_error:
+                        print(f"❌ Claude API call failed: {claude_error}")
+                        return False, f"Error: {claude_error}"
+                else:
+                    print("⚠️ Claude fallback not available (anthropic library not installed)")
+                    return False, "No API key available"
             
             # Parse the response
             if response_text.startswith("SKIP:"):
@@ -1120,24 +1183,60 @@ class CommandListManager:
             Only include commands that need changes (SKIP, MODIFY, ADD_AFTER), not KEEP actions.
             """
             
-            # Call OpenAI API
-            import openai
-            import json
-            client = openai.OpenAI(api_key=api_key)
-            
-            print("🔍 Analyzing command list for optimizations...")
-            
-            response = client.chat.completions.create(
-                model="gpt-4o-mini",  # Use a more capable model for this complex task
-                messages=[
-                    {"role": "system", "content": "You are a helpful assistant that analyzes and optimizes command lists."},
-                    {"role": "user", "content": prompt}
-                ],
-                max_tokens=1000,
-                temperature=0.2
-            )
-            
-            response_text = response.choices[0].message.content.strip()
+            # Try OpenAI API first
+            try:
+                import openai
+                import json
+                client = openai.OpenAI(api_key=api_key)
+                
+                print("🔍 Analyzing command list for optimizations...")
+                
+                response = client.chat.completions.create(
+                    model="gpt-4.1",  # Use a more capable model for this complex task
+                    messages=[
+                        {"role": "system", "content": "You are a helpful assistant that analyzes and optimizes command lists."},
+                        {"role": "user", "content": prompt}
+                    ],
+                    max_tokens=1000,
+                    temperature=0.2
+                )
+                
+                response_text = response.choices[0].message.content.strip()
+                
+            except Exception as e:
+                print(f"⚠️ OpenAI API call failed: {e}")
+                
+                # Try Claude as fallback if available
+                if anthropic is not None:
+                    print("🔄 Trying Claude-4-Sonnet as fallback for command list analysis...")
+                    try:
+                        # Get Anthropic API key
+                        anthropic_api_key = os.environ.get("ANTHROPIC_API_KEY")
+                        if not anthropic_api_key:
+                            print("⚠️ No ANTHROPIC_API_KEY found in environment")
+                            return False
+                        
+                        # Create Anthropic client
+                        client = anthropic.Anthropic(api_key=anthropic_api_key)
+                        
+                        print("🤖 Calling Claude-4-Sonnet for command list analysis...")
+                        message = client.messages.create(
+                            model="claude-3-5-sonnet-20241022",
+                            max_tokens=1000,
+                            messages=[
+                                {"role": "user", "content": prompt}
+                            ]
+                        )
+                        
+                        response_text = message.content[0].text.strip()
+                        print("✅ Claude command list analysis completed")
+                        
+                    except Exception as claude_error:
+                        print(f"❌ Claude API call failed: {claude_error}")
+                        return False
+                else:
+                    print("⚠️ Claude fallback not available (anthropic library not installed)")
+                    return False
             
             # Extract JSON from the response
             try:
@@ -1246,7 +1345,6 @@ class CommandListManager:
             print(f"⚠️ Error analyzing command list: {e}")
             return False
 
-
 # Import the fetch_modal_tokens module
 # print("🔄 Fetching tokens from proxy server...")
 from fetch_modal_tokens import get_tokens
@@ -1666,13 +1764,9 @@ IMPORTANT GUIDELINES:
 
 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)
+        "gpt-4.1",        # First choice: GPT-4o (most widely available)
     ]
     
     # Check if we have a preferred model in environment
@@ -1680,19 +1774,12 @@ Do not provide any explanations, just the exact command to run.
     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,
@@ -1795,15 +1882,192 @@ Do not provide any explanations, just the exact command to run.
     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
+        print(f"❌ All OpenAI model attempts failed. Last error: {last_error}")
+        
+        # Try Claude as fallback if available
+        if anthropic is not None:
+            print("🔄 Trying Claude-4-Sonnet as fallback...")
+            try:
+                # Get Anthropic API key
+                anthropic_api_key = os.environ.get("ANTHROPIC_API_KEY")
+                if not anthropic_api_key:
+                    print("⚠️ No ANTHROPIC_API_KEY found in environment")
+                    return None
+                
+                # Create Anthropic client
+                client = anthropic.Anthropic(api_key=anthropic_api_key)
+                
+                # Prepare the same prompt for Claude
+                claude_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.
+"""
+                
+                print("🤖 Calling Claude-4-Sonnet to debug the failed command...")
+                message = client.messages.create(
+                    model="claude-3-5-sonnet-20241022",
+                    max_tokens=300,
+                    messages=[
+                        {"role": "user", "content": claude_prompt}
+                    ]
+                )
+                
+                fix_command = message.content[0].text.strip()
+                print(f"🔍 DEBUG: Raw Claude response content: {fix_command}")
+                
+                # Process the response similar to OpenAI
+                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 Claude:")
+                    print("-" * 60)
+                    print(original_response)
+                    print("-" * 60)
+                    print("⚠️ Using best guess for command")
+                
+                print(f"🔧 Claude suggested fix: {fix_command}")
+                print(f"🔍 DEBUG: Returning Claude fix command: {fix_command}")
+                return fix_command
+                
+            except Exception as e:
+                print(f"❌ Claude API call failed: {e}")
+                return None
+        else:
+            print("⚠️ Claude fallback not available (anthropic library not installed)")
+            return None
     
     # Process the response
     try:
@@ -1959,7 +2223,7 @@ Provide fixes for all {len(failed_commands)} failed commands:"""
     }
     
     payload = {
-        "model": "gpt-4o-mini",  # Use a more capable model for batch analysis
+        "model": "gpt-4.1",  # 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}
@@ -2010,49 +2274,70 @@ Provide fixes for all {len(failed_commands)} failed commands:"""
             return fixes
         else:
             print(f"❌ OpenAI API error: {response.status_code} - {response.text}")
-            return []
+            
+            # Try Claude as fallback if available
+            if anthropic is not None:
+                print("🔄 Trying Claude-4-Sonnet as fallback for batch debugging...")
+                try:
+                    # Get Anthropic API key
+                    anthropic_api_key = os.environ.get("ANTHROPIC_API_KEY")
+                    if not anthropic_api_key:
+                        print("⚠️ No ANTHROPIC_API_KEY found in environment")
+                        return []
+                    
+                    # Create Anthropic client
+                    client = anthropic.Anthropic(api_key=anthropic_api_key)
+                    
+                    print("🤖 Calling Claude-4-Sonnet for batch debugging...")
+                    message = client.messages.create(
+                        model="claude-3-5-sonnet-20241022",
+                        max_tokens=1000,
+                        messages=[
+                            {"role": "user", "content": prompt}
+                        ]
+                    )
+                    
+                    content = message.content[0].text
+                    print(f"✅ Claude 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 "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 Claude batch analysis")
+                    return fixes
+                    
+                except Exception as e:
+                    print(f"❌ Claude API call failed: {e}")
+                    return []
+            else:
+                print("⚠️ Claude fallback not available (anthropic library not installed)")
+                return []
             
     except Exception as e:
         print(f"❌ Error during batch debugging: {e}")
         return []
 
-def prompt_for_hf_token():
-    """Prompt user for Hugging Face token when needed"""
-    # Try to use credentials manager first
-    try:
-        from credentials_manager import CredentialsManager
-        credentials_manager = CredentialsManager()
-        token = credentials_manager.get_huggingface_token()
-        if token:
-            return token
-    except ImportError:
-        # Fall back to direct input if credentials_manager is not available
-        pass
-    
-    # Traditional direct input method as fallback
-    print("\n" + "="*60)
-    print("🔑 HUGGING FACE TOKEN REQUIRED")
-    print("="*60)
-    print("The training script requires a valid Hugging Face token.")
-    print("You can get your token from: https://huggingface.co/settings/tokens")
-    print("📝 Please paste your Hugging Face token below:")
-    print("   (Your input will be hidden for security)")
-    print("-" * 60)
-    
-    try:
-        token = getpass.getpass("HF Token: ").strip()
-        if not token:
-            print("❌ No token provided.")
-            return None
-        print("✅ Token received successfully!")
-        return token
-    except KeyboardInterrupt:
-        print("\n❌ Token input cancelled by user.")
-        return None
-    except Exception as e:
-        print(f"❌ Error getting token: {e}")
-        return None
-
 def generate_random_password(length=16):
     """Generate a random password for SSH access"""
     alphabet = string.ascii_letters + string.digits + "!@#$%^&*"
@@ -2067,11 +2352,6 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
     
     # Use interactive mode if specified
     if interactive:
-        # If GPU type is not specified, prompt for it
-        if not gpu_type:
-            gpu_type = prompt_for_gpu()
-        else:
-            print(f"✅ Using provided GPU type: {gpu_type}")
             
         # If repo URL is not specified, prompt for it
         if not repo_url:
@@ -2748,7 +3028,6 @@ def fetch_setup_commands_from_api(repo_url):
                 print(f"⚠️ GitIngest CLI failed with exit code {result.returncode}")
                 print(f"⚠️ Error output: {result.stderr}")
                 print("Falling back to basic analysis")
-                gitingest_data = generate_basic_repo_analysis_from_url(repo_url)
             else:
                 print(f"✅ GitIngest analysis completed successfully")
                 
@@ -2832,13 +3111,13 @@ def fetch_setup_commands_from_api(repo_url):
                                 print(f"📁 Processed GitIngest data saved to: {processed_file}")
                     except FileNotFoundError:
                         print(f"⚠️ Output file not found at {output_file}")
-                        gitingest_data = generate_basic_repo_analysis_from_url(repo_url)
+                       
                 except Exception as e:
                     print(f"⚠️ Error reading GitIngest output: {e}")
-                    gitingest_data = generate_basic_repo_analysis_from_url(repo_url)
+     
         else:
             # Fall back to basic analysis if gitingest CLI is not available
-            gitingest_data = generate_basic_repo_analysis_from_url(repo_url)
+            gitingest_data = "{}"
         
         # Prepare the request payload with GitIngest data
         payload = {
@@ -3072,171 +3351,6 @@ def generate_fallback_commands(gitingest_data):
     
     return fixed_commands
 
-def generate_basic_repo_analysis_from_url(repo_url):
-    """Generate basic repository analysis data from a repository URL."""
-    import tempfile
-    import subprocess
-    import os
-    import shutil
-    
-    # Create a temporary directory for cloning
-    temp_dir = tempfile.mkdtemp(prefix="repo_basic_analysis_")
-    
-    try:
-        print(f"📥 Cloning repository to {temp_dir} for basic analysis...")
-        clone_result = subprocess.run(
-            ["git", "clone", "--depth", "1", repo_url, temp_dir],
-            capture_output=True,
-            text=True
-        )
-        
-        if clone_result.returncode != 0:
-            print(f"❌ Failed to clone repository: {clone_result.stderr}")
-            return {
-                "system_info": {
-                    "platform": "linux",
-                    "python_version": "3.10",
-                    "detected_language": "Unknown",
-                    "detected_technologies": [],
-                    "file_count": 0,
-                    "repo_stars": 0,
-                    "repo_forks": 0,
-                    "primary_package_manager": "Unknown",
-                    "complexity_level": "low"
-                },
-                "repository_analysis": {
-                    "summary": f"Repository analysis for {repo_url}",
-                    "tree": "Failed to clone repository",
-                    "content_preview": "No content available"
-                },
-                "success": False
-            }
-        
-        print(f"✅ Repository cloned successfully for basic analysis")
-        
-        # Use the existing generate_basic_repo_analysis function
-        return generate_basic_repo_analysis(temp_dir)
-    finally:
-        # Clean up the temporary directory
-        print(f"🧹 Cleaning up temporary directory for basic analysis...")
-        shutil.rmtree(temp_dir, ignore_errors=True)
-
-def generate_basic_repo_analysis(repo_dir):
-    """Generate basic repository analysis when GitIngest is not available."""
-    import os
-    import subprocess
-    
-    # Detect language and technologies based on file extensions
-    file_extensions = {}
-    file_count = 0
-    
-    for root, _, files in os.walk(repo_dir):
-        for file in files:
-            file_count += 1
-            ext = os.path.splitext(file)[1].lower()
-            if ext:
-                file_extensions[ext] = file_extensions.get(ext, 0) + 1
-    
-    # Determine primary language
-    language_map = {
-        '.py': 'Python',
-        '.js': 'JavaScript',
-        '.ts': 'TypeScript',
-        '.jsx': 'JavaScript',
-        '.tsx': 'TypeScript',
-        '.java': 'Java',
-        '.cpp': 'C++',
-        '.c': 'C',
-        '.go': 'Go',
-        '.rs': 'Rust',
-        '.rb': 'Ruby',
-        '.php': 'PHP',
-        '.swift': 'Swift',
-        '.kt': 'Kotlin',
-        '.cs': 'C#'
-    }
-    
-    # Count files by language
-    language_counts = {}
-    for ext, count in file_extensions.items():
-        if ext in language_map:
-            lang = language_map[ext]
-            language_counts[lang] = language_counts.get(lang, 0) + count
-    
-    # Determine primary language
-    primary_language = max(language_counts.items(), key=lambda x: x[1])[0] if language_counts else "Unknown"
-    
-    # Detect package managers
-    package_managers = []
-    package_files = {
-        'requirements.txt': 'pip',
-        'setup.py': 'pip',
-        'pyproject.toml': 'pip',
-        'package.json': 'npm',
-        'yarn.lock': 'yarn',
-        'pnpm-lock.yaml': 'pnpm',
-        'Cargo.toml': 'cargo',
-        'go.mod': 'go',
-        'Gemfile': 'bundler',
-        'pom.xml': 'maven',
-        'build.gradle': 'gradle',
-        'composer.json': 'composer'
-    }
-    
-    for file, manager in package_files.items():
-        if os.path.exists(os.path.join(repo_dir, file)):
-            package_managers.append(manager)
-    
-    primary_package_manager = package_managers[0] if package_managers else "Unknown"
-    
-    # Get README content
-    readme_content = ""
-    for readme_name in ['README.md', 'README', 'README.txt', 'readme.md']:
-        readme_path = os.path.join(repo_dir, readme_name)
-        if os.path.exists(readme_path):
-            with open(readme_path, 'r', encoding='utf-8', errors='ignore') as f:
-                readme_content = f.read()
-            break
-    
-    # Try to get repository info
-    repo_info = {}
-    try:
-        # Get remote origin URL
-        cmd = ["git", "config", "--get", "remote.origin.url"]
-        result = subprocess.run(cmd, cwd=repo_dir, capture_output=True, text=True)
-        if result.returncode == 0:
-            repo_info["url"] = result.stdout.strip()
-        
-        # Get commit count as a proxy for activity
-        cmd = ["git", "rev-list", "--count", "HEAD"]
-        result = subprocess.run(cmd, cwd=repo_dir, capture_output=True, text=True)
-        if result.returncode == 0:
-            repo_info["commit_count"] = int(result.stdout.strip())
-    except Exception:
-        pass
-    
-    # Build the analysis data
-    return {
-        "system_info": {
-            "platform": "linux",  # Assuming Linux for container environment
-            "python_version": "3.10",  # Common Python version
-            "detected_language": primary_language,
-            "detected_technologies": list(language_counts.keys()),
-            "file_count": file_count,
-            "repo_stars": repo_info.get("stars", 0),
-            "repo_forks": repo_info.get("forks", 0),
-            "primary_package_manager": primary_package_manager,
-            "complexity_level": "medium"  # Default assumption
-        },
-        "repository_analysis": {
-            "summary": f"Repository analysis for {repo_dir}",
-            "readme_content": readme_content[:5000] if readme_content else "No README found",
-            "package_managers": package_managers,
-            "file_extensions": list(file_extensions.keys())
-        },
-        "success": True
-    }
-
 def fix_setup_commands(commands):
     """Fix setup commands by removing placeholders and comments."""
     fixed_commands = []
@@ -3746,152 +3860,6 @@ def get_setup_commands_from_gitingest(repo_url):
     print("❌ All API endpoints failed")
     return generate_fallback_commands(gitingest_data)
 
-def prompt_for_gpu():
-    """
-    Prompt the user to select a GPU type from available options using arrow keys.
-    Returns the selected GPU type.
-    """
-    import sys
-    import tty
-    import termios
-    
-    print("\n🔧 GPU Selection Required")
-    print("No GPU type was specified with --gpu flag.")
-    print("Please select a GPU type for your container:")
-    
-    # Define available GPU types and their specifications
-    gpu_specs = {
-        'T4': {'gpu': 'T4', 'memory': '16GB'},
-        'L4': {'gpu': 'L4', 'memory': '24GB'},
-        'A10G': {'gpu': 'A10G', 'memory': '24GB'},
-        'A100-40': {'gpu': 'A100-40GB', 'memory': '40GB'},
-        'A100-80': {'gpu': 'A100-80GB', 'memory': '80GB'},
-        'L40S': {'gpu': 'L40S', 'memory': '48GB'},
-        'H100': {'gpu': 'H100', 'memory': '80GB'},
-        'H200': {'gpu': 'H200', 'memory': '141GB'},
-        'B200': {'gpu': 'B200', 'memory': '141GB'}
-    }
-    
-    # Create a list of options
-    options = list(gpu_specs.keys())
-    selected_index = 2  # Default to A10G (index 2)
-    
-    def get_key():
-        """Get a single keypress from the user."""
-        fd = sys.stdin.fileno()
-        old_settings = termios.tcgetattr(fd)
-        try:
-            tty.setraw(sys.stdin.fileno())
-            ch = sys.stdin.read(1)
-            if ch == '\x1b':  # Escape sequence
-                ch2 = sys.stdin.read(1)
-                if ch2 == '[':
-                    ch3 = sys.stdin.read(1)
-                    if ch3 == 'A':
-                        return 'UP'
-                    elif ch3 == 'B':
-                        return 'DOWN'
-            elif ch == '\r' or ch == '\n':
-                return 'ENTER'
-            elif ch == '\x03':  # Ctrl+C
-                return 'CTRL_C'
-            return ch
-        finally:
-            termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
-    
-    def display_menu():
-        """Display the GPU selection menu with current selection highlighted."""
-        print("\n📊 Available GPU Options:")
-        print("┌──────────────┬─────────┐")
-        print("│   GPU Type   │  VRAM   │")
-        print("├──────────────┼─────────┤")
-        
-        for i, gpu_type in enumerate(options):
-            specs = gpu_specs[gpu_type]
-            # Calculate proper spacing for alignment
-            number_part = f"{i+1}."
-            if i == selected_index:
-                prefix = "> "
-                suffix = " ←"
-            else:
-                prefix = "  "
-                suffix = ""
-            
-            # Ensure consistent width for GPU type column
-            gpu_display = f"{prefix}{number_part} {gpu_type}"
-            gpu_padded = f"{gpu_display:<12}"  # Fixed width for GPU column
-            
-            print(f"│ {gpu_padded} │ {specs['memory']:<7} │{suffix}")
-        
-        print("└──────────────┴─────────┘")
-        print("Use ↑/↓ arrows to select, Enter to confirm, Ctrl+C to cancel")
-    
-    # Clear screen and show initial menu
-    print("\033[2J\033[H", end="")  # Clear screen and move cursor to top
-    display_menu()
-    
-    while True:
-        try:
-            key = get_key()
-            
-            if key == 'UP':
-                selected_index = (selected_index - 1) % len(options)
-                print("\033[2J\033[H", end="")  # Clear screen
-                display_menu()
-            elif key == 'DOWN':
-                selected_index = (selected_index + 1) % len(options)
-                print("\033[2J\033[H", end="")  # Clear screen
-                display_menu()
-            elif key == 'ENTER':
-                selected_gpu = options[selected_index]
-                print(f"\n✅ Selected GPU: {selected_gpu}")
-                return selected_gpu
-            elif key == 'CTRL_C':
-                print("\n🛑 Selection cancelled.")
-                sys.exit(1)
-                
-        except KeyboardInterrupt:
-            print("\n🛑 Selection cancelled.")
-            sys.exit(1)
-        except Exception as e:
-            print(f"\n❌ Error with interactive menu: {e}")
-            print("🔄 Falling back to simple text input...")
-            # Fall back to simple input method
-            try:
-                print("\n📊 Available GPU Options:")
-                for i, gpu_type in enumerate(options, 1):
-                    specs = gpu_specs[gpu_type]
-                    print(f"  {i}. {gpu_type} ({specs['memory']})")
-                print(f"  Default: A10G")
-                
-                choice = input("\n🔍 Select GPU type (number or name, default is A10G): ").strip()
-                if not choice:
-                    print("✅ Using default GPU: A10G")
-                    return "A10G"
-                if choice.isdigit():
-                    index = int(choice) - 1
-                    if 0 <= index < len(options):
-                        selected = options[index]
-                        print(f"✅ Selected GPU: {selected}")
-                        return selected
-                    else:
-                        print(f"⚠️ Invalid number. Using default: A10G")
-                        return "A10G"
-                elif choice in options:
-                    print(f"✅ Selected GPU: {choice}")
-                    return choice
-                else:
-                    print(f"⚠️ Invalid choice '{choice}'. Using default: A10G")
-                    return "A10G"
-            except KeyboardInterrupt:
-                print("\n🛑 Selection cancelled.")
-                sys.exit(1)
-            except Exception as fallback_error:
-                print(f"❌ Error in fallback input: {fallback_error}")
-                print("✅ Using default GPU: A10G")
-                return "A10G"
-
-
 
 def preprocess_commands_with_llm(setup_commands, stored_credentials, api_key=None):
     """
@@ -3941,21 +3909,57 @@ Return only the JSON array, no other text.
             print("⚠️ No OpenAI API key available for command preprocessing")
             return setup_commands
         
-        # Call OpenAI API
-        import openai
-        client = openai.OpenAI(api_key=api_key)
-        
-        response = client.chat.completions.create(
-            model="gpt-3.5-turbo",
-            messages=[
-                {"role": "system", "content": "You are a command preprocessing assistant that modifies setup commands to use available credentials and make them non-interactive."},
-                {"role": "user", "content": prompt}
-            ],
-            temperature=0.1,
-            max_tokens=2000
-        )
-        
-        result = response.choices[0].message.content.strip()
+        # Try OpenAI API first
+        try:
+            import openai
+            client = openai.OpenAI(api_key=api_key)
+            
+            response = client.chat.completions.create(
+                model="gpt-3.5-turbo",
+                messages=[
+                    {"role": "system", "content": "You are a command preprocessing assistant that modifies setup commands to use available credentials and make them non-interactive."},
+                    {"role": "user", "content": prompt}
+                ],
+                temperature=0.1,
+                max_tokens=2000
+            )
+            
+            result = response.choices[0].message.content.strip()
+            
+        except Exception as e:
+            print(f"⚠️ OpenAI API call failed: {e}")
+            
+            # Try Claude as fallback if available
+            if anthropic is not None:
+                print("🔄 Trying Claude-4-Sonnet as fallback for command preprocessing...")
+                try:
+                    # Get Anthropic API key
+                    anthropic_api_key = os.environ.get("ANTHROPIC_API_KEY")
+                    if not anthropic_api_key:
+                        print("⚠️ No ANTHROPIC_API_KEY found in environment")
+                        return fallback_preprocess_commands(setup_commands, stored_credentials)
+                    
+                    # Create Anthropic client
+                    client = anthropic.Anthropic(api_key=anthropic_api_key)
+                    
+                    print("🤖 Calling Claude-4-Sonnet for command preprocessing...")
+                    message = client.messages.create(
+                        model="claude-3-5-sonnet-20241022",
+                        max_tokens=2000,
+                        messages=[
+                            {"role": "user", "content": prompt}
+                        ]
+                    )
+                    
+                    result = message.content[0].text.strip()
+                    print("✅ Claude preprocessing completed")
+                    
+                except Exception as claude_error:
+                    print(f"❌ Claude API call failed: {claude_error}")
+                    return fallback_preprocess_commands(setup_commands, stored_credentials)
+            else:
+                print("⚠️ Claude fallback not available (anthropic library not installed)")
+                return fallback_preprocess_commands(setup_commands, stored_credentials)
         
         # Debug: Print the raw response
         print(f"🔍 LLM Response: {result[:200]}...")
@@ -4198,7 +4202,6 @@ if __name__ == "__main__":
     parser = argparse.ArgumentParser()
     parser.add_argument('--gpu', type=str, help='GPU type (e.g., A10G, T4, A100-80GB). If not provided, will prompt for GPU selection.')
     parser.add_argument('--repo-url', type=str, help='Repository URL to clone')
-    parser.add_argument('--repo-name', type=str, help='Repository name override')
     parser.add_argument('--setup-commands', type=str, nargs='+', help='Setup commands to run (deprecated)')
     parser.add_argument('--setup-commands-json', type=str, help='Setup commands as JSON array')
     parser.add_argument('--commands-file', type=str, help='Path to file containing setup commands (one per line)')
@@ -4235,11 +4238,6 @@ if __name__ == "__main__":
         _handle_auth_commands(auth_manager, args)
         sys.exit(0)
     
-    # If --list-gpus is specified, just show GPU options and exit
-    if args.list_gpus:
-        prompt_for_gpu()
-        sys.exit(0)
-    
     # If no arguments or only --show-examples is provided, show usage examples
     if len(sys.argv) == 1 or args.show_examples:
         show_usage_examples()
@@ -4298,7 +4296,6 @@ if __name__ == "__main__":
     else:
         print("\n📋 No GPU type specified with --gpu flag.")
         print("🔄 Prompting for GPU selection...")
-        gpu_type = prompt_for_gpu()
         args.gpu = gpu_type
     
     # Display configuration after GPU selection
@@ -4312,16 +4309,7 @@ if __name__ == "__main__":
         print(f"Setup Commands: {len(args.setup_commands)} custom commands")
     else:
         print("Setup Commands: Auto-detect from repository")
-    
-    # Confirm settings
-    try:
-        proceed = input("Proceed with these settings? (Y/n): ").strip().lower()
-        if proceed in ('n', 'no'):
-            print("🛑 Operation cancelled by user.")
-            sys.exit(0)
-    except KeyboardInterrupt:
-        print("\n🛑 Operation cancelled by user.")
-        sys.exit(0)
+
     
     # Interactive mode or missing required arguments
     if args.interactive or not args.repo_url or not args.volume_name: