gitarsenal-cli 1.9.16 → 1.9.17

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,7 +31,6 @@ 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()
@@ -516,57 +515,21 @@ class PersistentShell:
             REMOVE_COMMAND: <reason>
             """
             
-            # 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
+            # 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()
             
             # Check if the response suggests removing the command
             if response_text.startswith("REMOVE_COMMAND:"):
@@ -610,10 +573,20 @@ 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
@@ -1003,59 +976,23 @@ class CommandListManager:
             RUN: <reason>
             """
             
-            # 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"
+            # 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()
             
             # Parse the response
             if response_text.startswith("SKIP:"):
@@ -1183,60 +1120,24 @@ class CommandListManager:
             Only include commands that need changes (SKIP, MODIFY, ADD_AFTER), not KEEP actions.
             """
             
-            # 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
+            # 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()
             
             # Extract JSON from the response
             try:
@@ -1345,6 +1246,7 @@ 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
@@ -1764,9 +1666,13 @@ 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-4.1",        # First choice: GPT-4o (most widely available)
+        "gpt-4o-mini",        # First choice: GPT-4o (most widely available)
     ]
     
     # Check if we have a preferred model in environment
@@ -1774,12 +1680,19 @@ 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,
@@ -1882,192 +1795,15 @@ 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 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
+        print(f"❌ All model attempts failed. Last error: {last_error}")
+        return None
     
     # Process the response
     try:
@@ -2223,7 +1959,7 @@ Provide fixes for all {len(failed_commands)} failed commands:"""
     }
     
     payload = {
-        "model": "gpt-4.1",  # Use a more capable model for batch analysis
+        "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}
@@ -2274,70 +2010,49 @@ Provide fixes for all {len(failed_commands)} failed commands:"""
             return fixes
         else:
             print(f"❌ OpenAI API error: {response.status_code} - {response.text}")
-            
-            # 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 []
+            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 + "!@#$%^&*"
@@ -2352,6 +2067,11 @@ 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:
@@ -3028,6 +2748,7 @@ 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")
                 
@@ -3111,13 +2832,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 = "{}"
+            gitingest_data = generate_basic_repo_analysis_from_url(repo_url)
         
         # Prepare the request payload with GitIngest data
         payload = {
@@ -3351,6 +3072,171 @@ 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 = []
@@ -3860,6 +3746,152 @@ 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):
     """
@@ -3909,57 +3941,21 @@ Return only the JSON array, no other text.
             print("⚠️ No OpenAI API key available for command preprocessing")
             return setup_commands
         
-        # 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)
+        # 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()
         
         # Debug: Print the raw response
         print(f"🔍 LLM Response: {result[:200]}...")
@@ -4202,6 +4198,7 @@ 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)')
@@ -4238,6 +4235,11 @@ 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()
@@ -4296,6 +4298,7 @@ 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
@@ -4309,7 +4312,16 @@ 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: