gitarsenal-cli 1.9.71 → 1.9.73

package/python/test_modalSandboxScript.py

@@ -6,150 +6,34 @@ import json
 import re
 import datetime
 import getpass
-import requests
 import secrets
 import string
 import argparse
-import threading
-import uuid
-import signal
 from pathlib import Path
 import modal
-import io
-import contextlib
-import unicodedata
-import shutil
 from auth_manager import AuthManager
 
-# Global flag to indicate when an outer boxed capture is active
-_BOX_CAPTURE_ACTIVE = False
+# Removed unused boxed output functions since they're no longer used with the Agent-based approach
 
 
-def _print_boxed_block(content: str):
-    # Use NBSP for padding to prevent renderers from trimming trailing spaces
-    NBSP = "\u00A0"
-    lines = content.splitlines() if content else ["(no output)"]
+# Removed _execute_with_box function as it's no longer used with the Agent-based approach
 
-    def _strip_ansi(s: str) -> str:
-        return re.sub(r"\x1B\[[0-9;]*[A-Za-z]", "", s)
+# Early argument parsing for proxy settings only
+early_parser = argparse.ArgumentParser(add_help=False)
+early_parser.add_argument('--proxy-url', help='URL of the proxy server')
+early_parser.add_argument('--proxy-api-key', help='API key for the proxy server')
 
-    def _display_width(s: str) -> int:
-        s = s.replace("\t", "    ")
-        width = 0
-        for ch in s:
-            if unicodedata.combining(ch):
-                continue
-            ea = unicodedata.east_asian_width(ch)
-            width += 2 if ea in ("W", "F") else 1
-        return width
-
-    # Compute desired inner width: full terminal width when available
-    visible_widths = [_display_width(_strip_ansi(line)) for line in lines]
-    term_width = shutil.get_terminal_size(fallback=(120, 24)).columns
-    # Borders add 4 chars: left '│ ', right ' │'
-    desired_inner = max(20, term_width - 4)
-
-    # If content has lines longer than max_inner, hard-truncate with ellipsis preserving ANSI
-    def _truncate_line(line: str, target: int) -> str:
-        plain = _strip_ansi(line)
-        if _display_width(plain) <= target:
-            return line
-        out = []
-        acc = 0
-        i = 0
-        while i < len(line) and acc < max(0, target - 1):
-            ch = line[i]
-            out.append(ch)
-            # Skip ANSI sequences intact
-            if ch == "\x1b":
-                # consume until letter
-                j = i + 1
-                while j < len(line) and not (line[j].isalpha() and line[j-1] == 'm'):
-                    j += 1
-                # include the terminator if present
-                if j < len(line):
-                    out.append(line[i+1:j+1])
-                    i = j + 1
-                else:
-                    i += 1
-                continue
-            # width accounting
-            if not unicodedata.combining(ch):
-                ea = unicodedata.east_asian_width(ch)
-                acc += 2 if ea in ("W", "F") else 1
-            i += 1
-        return ''.join(out) + '…'
-
-    adjusted_lines = [_truncate_line(line, desired_inner) for line in lines]
-    inner_width = desired_inner
-
-    top = "┌" + "─" * (inner_width + 2) + "┐"
-    bottom = "└" + "─" * (inner_width + 2) + "┘"
-    print(top)
-    for line in adjusted_lines:
-        vis = _strip_ansi(line)
-        pad_len = inner_width - _display_width(vis)
-        pad = NBSP * max(pad_len, 0)
-        print("│ " + line + pad + " │")
-    print(bottom)
-
-
-@contextlib.contextmanager
-def _boxed_capture():
-    global _BOX_CAPTURE_ACTIVE
-    buf = io.StringIO()
-    prev = _BOX_CAPTURE_ACTIVE
-    _BOX_CAPTURE_ACTIVE = True
-    try:
-        with contextlib.redirect_stdout(buf):
-            yield
-    finally:
-        _BOX_CAPTURE_ACTIVE = prev
-        content = buf.getvalue().rstrip("\n")
-        _print_boxed_block(content)
-
-
-def _execute_with_box(shell, cmd_text: str, timeout: int, title_line: str = None, box: bool = True):
-    start_time = time.time()
-    if box and not _BOX_CAPTURE_ACTIVE:
-        buf = io.StringIO()
-        with contextlib.redirect_stdout(buf):
-            if title_line:
-                print(title_line)
-            success, stdout, stderr = shell.execute(cmd_text, timeout=timeout)
-        execution_time = time.time() - start_time
-        content = buf.getvalue().rstrip("\n")
-        _print_boxed_block(content)
-        return success, stdout, stderr, execution_time
-    else:
-        if title_line:
-            print(title_line)
-        success, stdout, stderr = shell.execute(cmd_text, timeout=timeout)
-        execution_time = time.time() - start_time
-        return success, stdout, stderr, execution_time
-
-# Parse command-line arguments
-parser = argparse.ArgumentParser()
-parser.add_argument('--proxy-url', help='URL of the proxy server')
-parser.add_argument('--proxy-api-key', help='API key for the proxy server')
-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='Automatically confirm prompts (non-interactive)')
-
-# Parse only known args to avoid conflicts with other arguments
-args, unknown = parser.parse_known_args()
+# Parse only proxy args early to avoid conflicts 
+early_args, _ = early_parser.parse_known_args()
 
 # Set proxy URL and API key in environment variables if provided
-if args.proxy_url:
-    os.environ["MODAL_PROXY_URL"] = args.proxy_url
+if early_args.proxy_url:
+    os.environ["MODAL_PROXY_URL"] = early_args.proxy_url
     
-if args.proxy_api_key:
-    os.environ["MODAL_PROXY_API_KEY"] = args.proxy_api_key
+if early_args.proxy_api_key:
+    os.environ["MODAL_PROXY_API_KEY"] = early_args.proxy_api_key
 
 # Import the fetch_modal_tokens module
-# print("🔄 Fetching tokens from proxy server...")
 from fetch_modal_tokens import get_tokens
 token_id, token_secret, openai_api_key, anthropic_api_key, openrouter_api_key, groq_api_key = get_tokens()
 
@@ -157,8 +41,6 @@ token_id, token_secret, openai_api_key, anthropic_api_key, openrouter_api_key, g
 if token_id is None or token_secret is None:
     raise ValueError("Could not get valid tokens")
 
-# print(f"✅ Tokens fetched successfully")
-
 # Explicitly set the environment variables again to be sure
 os.environ["MODAL_TOKEN_ID"] = token_id
 os.environ["MODAL_TOKEN_SECRET"] = token_secret
@@ -198,9 +80,9 @@ def get_stored_credentials():
         return {}
 
 
-# Now modify the create_modal_ssh_container function to use the PersistentShell
+# Create Modal SSH container with GPU support and intelligent repository setup using Agent
 def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_commands=None, 
-                               volume_name=None, timeout_minutes=60, ssh_password=None, interactive=False, gpu_count=1):
+                               volume_name=None, timeout_minutes=60, ssh_password=None, interactive=False, gpu_count=1, use_cuda_base=False):
     """Create a Modal SSH container with GPU support and intelligent repository setup.
     
     When repo_url is provided, uses Agent for intelligent repository setup.
@@ -355,47 +237,54 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
     current_dir = os.path.dirname(os.path.abspath(__file__))
     # Get the gitarsenal-cli root directory for kill_claude files
     gitarsenal_root = os.path.dirname(current_dir)
-    # print(f"🔍 Current directory for mounting: {current_dir}")
     
-    # Use a more stable CUDA base image and avoid problematic packages
+    # Choose base image to avoid CUDA segfault issues
+    print("⚠️ Using CUDA base image - this may cause segfaults on some systems")
+    # base_image = modal.Image.from_registry("nvidia/cuda:12.4.0-runtime-ubuntu22.04", add_python="3.11")
+    base_image = modal.Image.debian_slim()
+    pip_cmd = "uv_pip_install"
+    
+    # Build the SSH image with the chosen base
     ssh_image = (
-        # modal.Image.from_registry("nvidia/cuda:12.4.0-devel-ubuntu22.04", add_python="3.11")
-        modal.Image.debian_slim()
+        base_image
         .apt_install(
             "openssh-server", "sudo", "curl", "wget", "vim", "htop", "git", 
             "python3", "python3-pip", "build-essential", "tmux", "screen", "nano",
             "gpg", "ca-certificates", "software-properties-common"
         )
-        .uv_pip_install("uv", "modal", "gitingest", "requests", "openai", "anthropic", "exa-py")  # Remove problematic CUDA packages
-        .run_commands(
-            # Create SSH directory
-            "mkdir -p /var/run/sshd",
-            "mkdir -p /root/.ssh",
-            "chmod 700 /root/.ssh",
-            
-            # Configure SSH server
-            "sed -i 's/#PermitRootLogin prohibit-password/PermitRootLogin yes/' /etc/ssh/sshd_config",
-            "sed -i 's/#PasswordAuthentication yes/PasswordAuthentication yes/' /etc/ssh/sshd_config",
-            "sed -i 's/#PubkeyAuthentication yes/PubkeyAuthentication yes/' /etc/ssh/sshd_config",
-            
-            # SSH keep-alive settings
-            "echo 'ClientAliveInterval 60' >> /etc/ssh/sshd_config",
-            "echo 'ClientAliveCountMax 3' >> /etc/ssh/sshd_config",
-            
-            # Generate SSH host keys
-            "ssh-keygen -A",
-            
-            # Set up a nice bash prompt
-            "echo 'export PS1=\"\\[\\e[1;32m\\]modal:\\[\\e[1;34m\\]\\w\\[\\e[0m\\]$ \"' >> /root/.bashrc",
-            
-            # Create base directories (subdirectories will be created automatically when mounting)
-            "mkdir -p /python",
-        )
-        # Mount entire directories instead of individual files
-        .add_local_dir(current_dir, "/python", ignore=lambda p: not p.name.endswith('.py'))  # Mount all Python files from current directory
-        .add_local_dir(os.path.join(gitarsenal_root, "kill_claude"), "/python/kill_claude")  # Mount entire kill_claude directory with all subdirectories
-
     )
+    
+    # Add Python packages using the appropriate method
+    if pip_cmd == "uv_pip_install":
+        ssh_image = ssh_image.uv_pip_install("uv", "modal", "gitingest", "requests", "openai", "anthropic", "exa-py")
+    else:
+        ssh_image = ssh_image.pip_install("modal", "gitingest", "requests", "openai", "anthropic", "exa-py")
+    
+    # Add the rest of the configuration
+    ssh_image = ssh_image.run_commands(
+        # Create SSH directory
+        "mkdir -p /var/run/sshd",
+        "mkdir -p /root/.ssh",
+        "chmod 700 /root/.ssh",
+        
+        # Configure SSH server
+        "sed -i 's/#PermitRootLogin prohibit-password/PermitRootLogin yes/' /etc/ssh/sshd_config",
+        "sed -i 's/#PasswordAuthentication yes/PasswordAuthentication yes/' /etc/ssh/sshd_config",
+        "sed -i 's/#PubkeyAuthentication yes/PubkeyAuthentication yes/' /etc/ssh/sshd_config",
+        
+        # SSH keep-alive settings
+        "echo 'ClientAliveInterval 60' >> /etc/ssh/sshd_config",
+        "echo 'ClientAliveCountMax 3' >> /etc/ssh/sshd_config",
+        
+        # Generate SSH host keys
+        "ssh-keygen -A",
+        
+        # Set up a nice bash prompt
+        "echo 'export PS1=\"\\[\\e[1;32m\\]modal:\\[\\e[1;34m\\]\\w\\[\\e[0m\\]$ \"' >> /root/.bashrc",
+        
+        # Create base directories (subdirectories will be created automatically when mounting)
+        "mkdir -p /python",
+    ).add_local_dir(current_dir, "/python", ignore=lambda p: not p.name.endswith('.py')).add_local_dir(os.path.join(gitarsenal_root, "kill_claude"), "/python/kill_claude")
     print("✅ SSH image built successfully")
         
     # Configure volumes if available
@@ -428,28 +317,11 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
         import sys
         
         # Add the mounted python directory to the Python path
-        sys.path.insert(0, "/python")
+        # sys.path.insert(0, "/python")
         
-        # Import the required classes from the mounted modules
-        try:
-            from command_manager import CommandListManager
-            from shell import PersistentShell
-            from llm_debugging import get_stored_credentials, generate_auth_context, call_llm_for_debug, call_llm_for_batch_debug, call_anthropic_for_debug, call_openai_for_debug, call_openai_for_batch_debug, call_anthropic_for_batch_debug, call_openrouter_for_debug, call_openrouter_for_batch_debug, get_current_debug_model
-            
-            print("✅ Successfully imported CommandListManager, PersistentShell, and all llm_debugging functions from mounted modules")
-        except ImportError as e:
-            print(f"❌ Failed to import modules from mounted directory: {e}")
-            print("🔍 Available files in /python:")
-            try:
-                import os
-                if os.path.exists("/python"):
-                    for file in os.listdir("/python"):
-                        print(f"  - {file}")
-                else:
-                    print("  /python directory does not exist")
-            except Exception as list_error:
-                print(f"  Error listing files: {list_error}")
-            raise
+        # Import only the modules we actually need (none currently for Agent-based approach)
+        # Note: CommandListManager and llm_debugging functions are not used in the Agent-based approach
+        print("✅ Container setup complete - using Agent-based repository setup")
         
         # Set root password
         subprocess.run(["bash", "-c", f"echo 'root:{ssh_password}' | chpasswd"], check=True)
@@ -457,7 +329,6 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
         # Set OpenAI API key if provided
         if openai_api_key:
             os.environ['OPENAI_API_KEY'] = openai_api_key
-            # print(f"✅ Set OpenAI API key in container environment (length: {len(openai_api_key)})")
         else:
             print("⚠️ No OpenAI API key provided to container")
         
@@ -637,8 +508,6 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
                     process.kill()
                     process.wait()
                 except Exception as stream_error:
-                    # print(f"\n⚠️ Error with advanced streaming: {stream_error}")
-                    # print("🔄 Falling back to simple streaming...")
                     pass
                     
                     # Fallback to simple readline approach
@@ -724,11 +593,9 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
             with app.run():
                 # Get the API key from environment
                 api_key = os.environ.get("OPENAI_API_KEY")
-                # print(f"🔐 API key: {api_key}")
                 
                 # Get stored credentials from local file
                 stored_credentials = get_stored_credentials()
-                # print(f"🔐 Stored credentials: {stored_credentials}")
                 if stored_credentials:
                     print(f"🔐 Found {len(stored_credentials)} stored credentials to send to container")
                 else:
@@ -748,393 +615,6 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
         print(f"❌ Error running container: {e}")
         return None
 
-def fetch_setup_commands_from_api(repo_url):
-    """Fetch setup commands from the GitIngest API using real repository analysis."""
-    import tempfile
-    import subprocess
-    import os
-    import shutil
-    import json
-    import time
-    import requests
-    
-    # Define API endpoints to try in order - using only online endpoints
-    api_endpoints = [
-        "https://www.gitarsenal.dev/api/analyze-with-gitingest"  # Working endpoint with www prefix
-    ]
-    
-    print(f"🔍 Fetching setup commands from API for repository: {repo_url}")
-    
-    # Check if gitingest command line tool is available - try multiple possible command names
-    has_gitingest_cli = False
-    gitingest_cmd_name = None
-    
-    # Try the standard command name first
-    try:
-        print(f"🔍 Checking for GitIngest CLI tool...")
-        result = subprocess.run(["gitingest", "--help"], check=True, capture_output=True, text=True)
-        has_gitingest_cli = True
-        gitingest_cmd_name = "gitingest"
-        print(f"✅ GitIngest CLI tool found")
-    except (subprocess.SubprocessError, FileNotFoundError) as e:
-        print(f"  - GitIngest command not found: {str(e)}")
-    
-    # Create a temporary directory for output
-    temp_dir = tempfile.mkdtemp(prefix="repo_analysis_")
-    output_file = os.path.join(temp_dir, "digest.json")
-    
-    # Create a directory to save GitIngest results
-    save_dir = os.path.join(os.path.expanduser("~"), "gitarsenal_results")
-    os.makedirs(save_dir, exist_ok=True)
-    timestamp = time.strftime("%Y%m%d_%H%M%S")
-    repo_name = repo_url.split("/")[-1].replace(".git", "")
-    save_file = os.path.join(save_dir, f"gitingest_{repo_name}_{timestamp}.txt")
-    
-    try:
-        if has_gitingest_cli:
-            # Use gitingest CLI tool to analyze the repository directly from URL
-            print(f"🔎 Running GitIngest analysis on {repo_url}...")
-            
-            # Based on the help output, the correct format is:
-            # gitingest [OPTIONS] [SOURCE]
-            # With options:
-            # -o, --output TEXT           Output file path
-            # --format TEXT               Output format (json)
-            
-            # Run gitingest command with proper parameters
-            gitingest_run_cmd = [
-                gitingest_cmd_name,
-                repo_url,
-                "-o", output_file,  # Use -o for output file
-            ]
-            
-            print(f"🔄 Executing: {' '.join(gitingest_run_cmd)}")
-            
-            result = subprocess.run(gitingest_run_cmd, capture_output=True, text=True)
-            
-            if result.returncode != 0:
-                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")
-                
-                # Read the output file - note that the default format might not be JSON
-                try:
-                    # First try to parse as JSON
-                    try:
-                        with open(output_file, 'r', encoding='utf-8') as f:
-                            content = f.read()
-                            
-                            # Save the GitIngest output to the results directory
-                            with open(save_file, 'w', encoding='utf-8') as save_f:
-                                save_f.write(content)
-                            print(f"📁 GitIngest output saved to: {save_file}")
-                            
-                            try:
-                                gitingest_data = json.loads(content)
-                                print(f"✅ GitIngest data loaded as JSON from {output_file}")
-                            except json.JSONDecodeError:
-                                # If not JSON, convert the text output to a basic structure
-                                print(f"⚠️ GitIngest output is not in JSON format, converting text to structure")
-                                
-                                # Process the text to extract useful information
-                                import re
-                                
-                                # Try to identify language
-                                language_match = re.search(r"(?i)language[s]?:?\s*(\w+)", content)
-                                detected_language = language_match.group(1) if language_match else "Unknown"
-                                
-                                # Try to identify technologies with stronger evidence requirements
-                                tech_patterns = {
-                                    "python": r"(?i)(python|\.py\b|pip\b|requirements\.txt|setup\.py)",
-                                    "javascript": r"(?i)(javascript|\.js\b|node|npm|yarn|package\.json)",
-                                    "typescript": r"(?i)(typescript|\.ts\b|tsc\b|tsconfig\.json)",
-                                    "go": r"(?i)(\bgo\b|golang|\.go\b|go\.mod|go\.sum)",
-                                    "rust": r"(?i)(rust|\.rs\b|cargo|Cargo\.toml)",
-                                    "java": r"(?i)(java\b|\.java\b|maven|gradle|pom\.xml)",
-                                    "c++": r"(?i)(c\+\+|\.cpp\b|\.hpp\b|cmake\b|CMakeLists\.txt)",
-                                    "pytorch": r"(?i)(pytorch|torch\b|nn\.Module)",
-                                    "tensorflow": r"(?i)(tensorflow|tf\.|keras\b)",
-                                }
-                                
-                                # Count occurrences to filter out false positives
-                                tech_counts = {}
-                                for tech, pattern in tech_patterns.items():
-                                    matches = re.findall(pattern, content)
-                                    if matches:
-                                        tech_counts[tech] = len(matches)
-                                
-                                # Filter technologies based on threshold
-                                thresholds = {
-                                    "javascript": 3,  # Higher threshold for JavaScript
-                                    "go": 3,          # Higher threshold for Go
-                                    "default": 2      # Default threshold
-                                }
-                                
-                                detected_technologies = []
-                                for tech, count in tech_counts.items():
-                                    threshold = thresholds.get(tech, thresholds["default"])
-                                    if count >= threshold:
-                                        detected_technologies.append(tech)
-                                        print(f"📊 Detected {tech} with confidence score {count}")
-                                
-                                # Create a structured representation
-                                gitingest_data = {
-                                    "system_info": {
-                                        "detected_language": detected_language,
-                                        "detected_technologies": detected_technologies,
-                                    },
-                                    "repository_analysis": {
-                                        "summary": content[:5000],  # First 5000 chars as summary
-                                        "content_preview": content[:10000]  # First 10000 chars as preview
-                                    },
-                                    "success": True
-                                }
-                                
-                                # Save the processed data
-                                processed_file = os.path.join(save_dir, f"gitingest_processed_{repo_name}_{timestamp}.json")
-                                with open(processed_file, 'w', encoding='utf-8') as proc_f:
-                                    json.dump(gitingest_data, proc_f, indent=2)
-                                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)
-        
-        # Prepare the request payload with GitIngest data
-        payload = {
-            "repoUrl": repo_url,
-            "gitingestData": gitingest_data,
-            "userRequest": "Setup and run the repository"
-        }
-        
-        print(f"📤 API Request payload prepared (GitIngest data size: {len(json.dumps(gitingest_data))} bytes)")
-        
-        # Try each endpoint in sequence until one succeeds
-        response = None
-        for api_url in api_endpoints:
-            # Use the retry mechanism for more reliable requests
-            response = make_api_request_with_retry(
-                url=api_url,
-                payload=payload,
-                max_retries=2,
-                timeout=180  # 3 minute timeout
-            )
-            
-            # If we got a response and it's successful, break out of the loop
-            if response and response.status_code == 200:
-                print(f"✅ Successful response from {api_url}")
-                break
-                
-            if response:
-                print(f"⚠️ Endpoint {api_url} returned status code {response.status_code}, trying next endpoint...")
-            else:
-                print(f"⚠️ Failed to connect to {api_url}, trying next endpoint...")
-        
-        # If we've tried all endpoints and still don't have a response, use fallback
-        if response is None:
-            print("❌ All API endpoints failed")
-            return generate_fallback_commands(gitingest_data)
-            
-        # Continue with the response we got from the successful endpoint
-        if not response:
-            print("❌ No valid response received from any endpoint")
-            return generate_fallback_commands(gitingest_data)
-            
-        try:
-            print(f"📥 API Response status code: {response.status_code}")
-            
-            if response.status_code == 200:
-                try:
-                    data = response.json()
-                    print(f"📄 API Response data received")
-                    print(f"📄 Response size: {len(response.text)} bytes")
-                    print(f"📄 Response URL: {response.url}")
-                    
-                    # Extract setup commands from the response
-                    if "setupInstructions" in data and "commands" in data["setupInstructions"]:
-                        commands = data["setupInstructions"]["commands"]
-                        print(f"✅ Successfully fetched {len(commands)} setup commands from API")
-                        
-                        # Print the original commands for reference
-                        print("📋 Original commands from API:")
-                        for i, cmd in enumerate(commands, 1):
-                            print(f"  {i}. {cmd}")
-                        
-                        # Fix the commands by removing placeholders and comments
-                        fixed_commands = fix_setup_commands(commands)
-                        
-                        # If we have a temp_dir with the cloned repo, try to find the entry point
-                        # and replace any placeholder entry points
-                        for i, cmd in enumerate(fixed_commands):
-                            if "python main.py" in cmd or "python3 main.py" in cmd:
-                                try:
-                                    entry_point = find_entry_point(temp_dir)
-                                    if entry_point and entry_point != "main.py":
-                                        fixed_commands[i] = cmd.replace("main.py", entry_point)
-                                        print(f"🔄 Replaced main.py with detected entry point: {entry_point}")
-                                except Exception as e:
-                                    print(f"⚠️ Error finding entry point: {e}")
-                        
-                        # Print the fixed commands
-                        print("\n📋 Fixed commands:")
-                        for i, cmd in enumerate(fixed_commands, 1):
-                            print(f"  {i}. {cmd}")
-                        
-                        return fixed_commands
-                    else:
-                        print("⚠️ API response did not contain setupInstructions.commands field")
-                        print("📋 Available fields in response:")
-                        for key in data.keys():
-                            print(f"  - {key}")
-                        # Return fallback commands
-                        return generate_fallback_commands(gitingest_data)
-                except json.JSONDecodeError as e:
-                    print(f"❌ Failed to parse API response as JSON: {e}")
-                    print(f"Raw response: {response.text[:500]}...")
-                    # Return fallback commands
-                    return generate_fallback_commands(gitingest_data)
-            elif response.status_code == 504:
-                print(f"❌ API request timed out (504 Gateway Timeout)")
-                print("⚠️ The server took too long to respond. Using fallback commands instead.")
-                # Return fallback commands
-                return generate_fallback_commands(gitingest_data)
-            else:
-                print(f"❌ API request failed with status code: {response.status_code}")
-                print(f"❌ Response URL: {response.url}")
-                print(f"❌ Response headers: {dict(response.headers)}")
-                print(f"❌ Error response: {response.text[:500]}...")
-                # Return fallback commands
-                return generate_fallback_commands(gitingest_data)
-        except Exception as e:
-            print(f"❌ Error processing API response: {str(e)}")
-            print("⚠️ Using fallback commands instead")
-            # Return fallback commands
-            return generate_fallback_commands(gitingest_data)
-    except Exception as e:
-        print(f"❌ Error fetching setup commands from API: {e}")
-        import traceback
-        traceback.print_exc()
-        # Return fallback commands
-        return generate_fallback_commands(None)
-    finally:
-        # Clean up the temporary directory
-        print(f"🧹 Cleaning up temporary directory...")
-        shutil.rmtree(temp_dir, ignore_errors=True)
-
-def generate_fallback_commands(gitingest_data):
-    return True
-
-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):
-    return True
-
-def fix_setup_commands(commands):
-    """Fix setup commands by removing placeholders and comments."""
-    fixed_commands = []
-    
-    for cmd in commands:
-        # Remove placeholders like "(or the appropriate entry point...)"
-        cmd = re.sub(r'\([^)]*\)', '', cmd).strip()
-        
-        # Skip empty commands or pure comments
-        if not cmd or cmd.startswith('#'):
-            continue
-            
-        # Remove trailing comments
-        cmd = re.sub(r'#.*$', '', cmd).strip()
-        
-        if cmd:
-            fixed_commands.append(cmd)
-    
-    return fixed_commands
-
-def find_entry_point(repo_dir):
-    """Find the entry point script for a repository."""
-    # Common entry point files to check
-    common_entry_points = [
-        "main.py", "app.py", "run.py", "train.py", "start.py", 
-        "server.py", "cli.py", "demo.py", "example.py"
-    ]
-    
-    # Check if any of the common entry points exist
-    for entry_point in common_entry_points:
-        if os.path.exists(os.path.join(repo_dir, entry_point)):
-            return entry_point
-    
-    # Look for Python files in the root directory
-    python_files = [f for f in os.listdir(repo_dir) if f.endswith('.py')]
-    if python_files:
-        # Prioritize files with main function or if_name_main pattern
-        for py_file in python_files:
-            file_path = os.path.join(repo_dir, py_file)
-            try:
-                with open(file_path, 'r') as f:
-                    content = f.read()
-                    if "def main" in content or "if __name__ == '__main__'" in content or 'if __name__ == "__main__"' in content:
-                        return py_file
-            except:
-                pass
-        
-        # If no main function found, return the first Python file
-        return python_files[0]
-    
-    return None
 
 def cleanup_security_tokens():
     """Delete all security tokens and API keys after SSH container is started"""
@@ -1146,27 +626,22 @@ def cleanup_security_tokens():
         for var in modal_env_vars:
             if var in os.environ:
                 del os.environ[var]
-                # print(f"✅ Removed {var} from environment")
         
         # Remove OpenAI API key from environment
         if "OPENAI_API_KEY" in os.environ:
             del os.environ["OPENAI_API_KEY"]
-            # print("✅ Removed OpenAI API key from environment")
         
         # Delete ~/.modal.toml file
         home_dir = os.path.expanduser("~")
         modal_toml = os.path.join(home_dir, ".modal.toml")
         if os.path.exists(modal_toml):
             os.remove(modal_toml)
-            # print(f"✅ Deleted Modal token file at {modal_toml}")
         
         # Delete ~/.gitarsenal/openai_key file
         openai_key_file = os.path.join(home_dir, ".gitarsenal", "openai_key")
         if os.path.exists(openai_key_file):
             os.remove(openai_key_file)
-            # print(f"✅ Deleted OpenAI API key file at {openai_key_file}")
         
-        # print("✅ Security cleanup completed successfully")
     except Exception as e:
         print(f"❌ Error during security cleanup: {e}")
 
@@ -1175,6 +650,7 @@ def cleanup_modal_token():
     """Legacy function - now calls the comprehensive cleanup"""
     cleanup_security_tokens()
 
+
 def show_usage_examples():
     """Display usage examples for the script."""
     print("Usage Examples\n")
@@ -1254,497 +730,6 @@ def show_usage_examples():
     print("  # Manual setup (advanced users):")
     print("  gitarsenal --gpu A10G --setup-commands \"pip install torch\" \"python train.py\"")
 
-def make_api_request_with_retry(url, payload, max_retries=2, timeout=180):
-    """Make an API request with retry mechanism."""
-    import requests
-    import time
-    
-    for attempt in range(max_retries + 1):
-        try:
-            if attempt > 0:
-                print(f"🔄 Retry attempt {attempt}/{max_retries}...")
-                
-            # print(f"🌐 Making POST request to: {url}")
-            # print(f"⏳ Waiting up to {timeout//60} minutes for response...")
-            
-            # Set allow_redirects=True to follow redirects automatically
-            response = requests.post(
-                url, 
-                json=payload, 
-                timeout=timeout,
-                allow_redirects=True,
-                headers={
-                    'Content-Type': 'application/json',
-                    'User-Agent': 'GitArsenal-CLI/1.0'
-                }
-            )
-            
-            # Print redirect info if any
-            if response.history:
-                print(f"✅ Request was redirected {len(response.history)} times")
-                for resp in response.history:
-                    print(f"  - Redirect: {resp.status_code} from {resp.url}")
-                print(f"✅ Final URL: {response.url}")
-            
-            return response
-        except requests.exceptions.RequestException as e:
-            if attempt < max_retries:
-                retry_delay = 2 ** attempt  # Exponential backoff
-                print(f"⚠️ Request failed: {str(e)}")
-                print(f"⏳ Waiting {retry_delay} seconds before retrying...")
-                time.sleep(retry_delay)
-            else:
-                print(f"❌ All retry attempts failed: {str(e)}")
-                return None
-    
-    return None
-
-def get_setup_commands_from_gitingest(repo_url):
-    """
-    Get repository setup commands using the gitingest approach.
-    
-    This function is inspired by gitingest_setup_client.py and provides a more
-    robust way to get setup commands for a repository.
-    
-    Args:
-        repo_url: URL of the repository to set up
-        
-    Returns:
-        List of setup commands or None if failed
-    """
-    import requests
-    import json
-    import os
-    import sys
-    import tempfile
-    import subprocess
-    
-    print(f"🔍 Getting setup commands for repository: {repo_url}")
-    
-    # Define API endpoints to try in order
-    api_endpoints = [
-        "https://www.gitarsenal.dev/api/gitingest-setup-commands",
-        "https://gitarsenal.dev/api/gitingest-setup-commands",
-    ]
-    
-    # Generate basic gitingest data
-    def generate_basic_gitingest_data():
-        # Extract repo name from URL
-        repo_name = repo_url.split('/')[-1].replace('.git', '')
-        
-        return {
-            "system_info": {
-                "platform": "Unknown",
-                "python_version": "Unknown",
-                "detected_language": "Unknown",
-                "detected_technologies": [],
-                "file_count": 0,
-                "repo_stars": 0,
-                "repo_forks": 0,
-                "primary_package_manager": "Unknown",
-                "complexity_level": "Unknown"
-            },
-            "repository_analysis": {
-                "summary": f"Repository: {repo_name}",
-                "tree": "",
-                "content_preview": ""
-            },
-            "success": True
-        }
-    
-    # Try to generate gitingest data using CLI if available
-    def generate_gitingest_data_from_cli():
-        try:
-            # Check if gitingest CLI is available
-            subprocess.run(["gitingest", "--help"], check=True, capture_output=True, text=True)
-            
-            # Create a temporary file for the output
-            with tempfile.NamedTemporaryFile(suffix='.json', delete=False) as tmp:
-                output_file = tmp.name
-            
-            # Run gitingest command
-            print(f"Running gitingest analysis on {repo_url}...")
-            gitingest_cmd = ["gitingest", repo_url, "-o", output_file]
-            result = subprocess.run(gitingest_cmd, capture_output=True, text=True)
-            
-            if result.returncode != 0:
-                print(f"GitIngest CLI failed: {result.stderr}")
-                return None
-            
-            # Read the output file
-            try:
-                with open(output_file, 'r', encoding='utf-8') as f:
-                    content = f.read()
-                    try:
-                        data = json.loads(content)
-                        return data
-                    except json.JSONDecodeError:
-                        # If not JSON, convert the text output to a basic structure
-                        return {
-                            "system_info": {
-                                "platform": "Unknown",
-                                "python_version": "Unknown",
-                                "detected_language": "Unknown",
-                                "detected_technologies": []
-                            },
-                            "repository_analysis": {
-                                "summary": content[:5000],  # First 5000 chars as summary
-                                "tree": "",
-                                "content_preview": content[:10000]  # First 10000 chars as preview
-                            },
-                            "success": True
-                        }
-            except Exception as e:
-                print(f"Error reading gitingest output: {e}")
-                return None
-            finally:
-                # Clean up the temporary file
-                if os.path.exists(output_file):
-                    os.unlink(output_file)
-        
-        except (subprocess.SubprocessError, FileNotFoundError):
-            print("GitIngest CLI not found")
-            return None
-    
-    # First try to get data from CLI
-    gitingest_data = generate_gitingest_data_from_cli()
-    
-    # If CLI failed, use basic data
-    if not gitingest_data:
-        print("Using basic gitingest data")
-        gitingest_data = generate_basic_gitingest_data()
-    
-    # Try each API endpoint
-    for api_url in api_endpoints:
-        try:
-            # print(f"Trying API endpoint: {api_url}")
-            
-            # Load stored credentials
-            stored_credentials = get_stored_credentials()
-            
-            payload = {
-                "repoUrl": repo_url,
-                "gitingestData": gitingest_data,
-                "storedCredentials": stored_credentials,  # Add back stored credentials
-                "preview": False
-            }
-            
-            # Use the retry mechanism for more reliable requests
-            response = make_api_request_with_retry(
-                url=api_url,
-                payload=payload,
-                max_retries=2,
-                timeout=180,  # 3 minute timeout
-            )
-            
-            if not response:
-                print(f"Failed to connect to {api_url}")
-                continue
-                
-            if response.status_code != 200:
-                print(f"API request failed with status code: {response.status_code}")
-                continue
-            
-            try:
-                result = response.json()
-                
-                # Check if we have commands in the response
-                commands = None
-                
-                # Check for different response formats
-                if "commands" in result:
-                    commands = result["commands"]
-                elif "setupInstructions" in result and "commands" in result["setupInstructions"]:
-                    commands = result["setupInstructions"]["commands"]
-                
-                if commands:
-                    print(f"✅ Successfully fetched {len(commands)} setup commands from API at {api_url}")
-                    
-                    # Enhanced response handling for API key detection
-                    if "requiredApiKeys" in result:
-                        api_keys = result.get("requiredApiKeys", [])
-                        if api_keys:
-                            print(f"\n🔑 Required API Keys ({len(api_keys)}):")
-                            # Load stored GitArsenal credentials
-                            stored_credentials = {}
-                            try:
-                                credentials_file = Path.home() / ".gitarsenal" / "credentials.json"
-                                if credentials_file.exists():
-                                    with open(credentials_file, 'r') as f:
-                                        stored_credentials = json.load(f)
-                                    print(f"📋 Found {len(stored_credentials)} stored GitArsenal credentials")
-                                else:
-                                    print("📋 No stored GitArsenal credentials found")
-                            except Exception as e:
-                                print(f"⚠️ Error loading stored credentials: {e}")
-                            
-                            # Identify missing required API keys
-                            missing_required_keys = []
-                            available_keys = []
-                            
-                            for i, api_key in enumerate(api_keys, 1):
-                                key_name = api_key.get('name', 'Unknown')
-                                is_required = api_key.get("required", False)
-                                has_stored_key = key_name in stored_credentials
-                                
-                                if is_required:
-                                    if has_stored_key:
-                                        status = "✅ Required (Available)"
-                                        available_keys.append(key_name)
-                                    else:
-                                        status = "🔴 Required (Missing)"
-                                        missing_required_keys.append(api_key)
-                                else:
-                                    status = "🟡 Optional"
-                                
-                                print(f"  {i}. {key_name} - {status}")
-                                print(f"     Service: {api_key.get('service', 'Unknown')}")
-                                print(f"     Description: {api_key.get('description', 'No description')}")
-                                if api_key.get('example'):
-                                    print(f"     Example: {api_key.get('example')}")
-                                if api_key.get('documentation_url'):
-                                    print(f"     Docs: {api_key.get('documentation_url')}")
-                                print()
-                            
-                            # Prompt for missing required API keys
-                            if missing_required_keys:
-                                print("🔧 Setting up missing required API keys...")
-                                print("Press Enter to continue or Ctrl+C to skip...")
-                                
-                                for api_key in missing_required_keys:
-                                    key_name = api_key.get('name', 'Unknown')
-                                    service = api_key.get('service', 'Unknown')
-                                    description = api_key.get('description', 'No description')
-                                    example = api_key.get('example', '')
-                                    docs_url = api_key.get('documentation_url', '')
-                                    
-                                    print(f"\n📝 Setting up {key_name} for {service}:")
-                                    print(f"   Description: {description}")
-                                    if example:
-                                        print(f"   Example: {example}")
-                                    if docs_url:
-                                        print(f"   Documentation: {docs_url}")
-                                    
-                                    # Prompt user for the API key
-                                    try:
-                                        import getpass
-                                        print(f"\nPlease enter your {key_name} for {service}:")
-                                        new_key = getpass.getpass(f"{key_name} ({service}) API Key (hidden): ").strip()
-                                        
-                                        if new_key:
-                                            # Save to credentials file
-                                            credentials_file = Path.home() / ".gitarsenal" / "credentials.json"
-                                            credentials_file.parent.mkdir(parents=True, exist_ok=True)
-                                            
-                                            # Load existing credentials
-                                            if credentials_file.exists():
-                                                with open(credentials_file, 'r') as f:
-                                                    all_credentials = json.load(f)
-                                            else:
-                                                all_credentials = {}
-                                            
-                                            # Add new key
-                                            all_credentials[key_name] = new_key
-                                            
-                                            # Save back to file
-                                            with open(credentials_file, 'w') as f:
-                                                json.dump(all_credentials, f, indent=2)
-                                            
-                                            print(f"✅ {key_name} saved successfully!")
-                                            available_keys.append(key_name)
-                                        else:
-                                            print(f"⚠️ Skipping {key_name} (no input provided)")
-                                    except KeyboardInterrupt:
-                                        print(f"\n⚠️ Skipping {key_name} (cancelled by user)")
-                                    except Exception as e:
-                                        print(f"❌ Error saving {key_name}: {e}")
-                                
-                                # Show summary
-                                if available_keys:
-                                    print(f"✅ Available API keys: {', '.join(available_keys)}")
-                                if missing_required_keys:
-                                    print(f"⚠️ Missing required keys: {', '.join([k.get('name') for k in missing_required_keys])}")
-                            else:
-                                print("ℹ️ All required API keys are already available.")
-                    
-                    # Display setup complexity if available
-                    if "setupComplexity" in result:
-                        complexity = result.get("setupComplexity", "medium")
-                        estimated_time = result.get("estimatedSetupTime", "Unknown")
-                        print(f"📊 Setup Complexity: {complexity.upper()}")
-                        print(f"⏱️  Estimated Time: {estimated_time}")
-                    
-                    # Print the commands
-                    print("\n📋 Setup Commands:")
-                    for i, cmd in enumerate(commands, 1):
-                        print(f"  {i}. {cmd}")
-                    
-                    # Fix the commands
-                    fixed_commands = fix_setup_commands(commands)
-                    
-                    # Print the fixed commands
-                    print("\n📋 Fixed commands:")
-                    for i, cmd in enumerate(fixed_commands, 1):
-                        print(f"  {i}. {cmd}")
-                    
-                    return fixed_commands
-                else:
-                    print("No commands found in API response")
-            except json.JSONDecodeError:
-                print(f"Failed to parse API response as JSON")
-        except Exception as e:
-            print(f"Error with API endpoint {api_url}: {e}")
-    
-    print("❌ All API endpoints failed")
-    return generate_fallback_commands(gitingest_data)
-
-
-
-
-
-def preprocess_commands_with_llm(setup_commands, stored_credentials, api_key=None):
-    """
-    Use LLM to preprocess setup commands and inject available credentials.
-    
-    Args:
-        setup_commands: List of setup commands
-        stored_credentials: Dictionary of stored credentials
-        api_key: OpenAI API key for LLM calls
-        
-    Returns:
-        List of processed commands with credentials injected
-    """
-    if not setup_commands or not stored_credentials:
-        return setup_commands
-    
-    try:
-        # Create context for the LLM
-        credentials_info = "\n".join([f"- {key}: {value[:8]}..." for key, value in stored_credentials.items()])
-        
-        prompt = f"""
-You are a command preprocessing assistant. Your task is to modify setup commands to use available credentials and make them non-interactive.
-
-AVAILABLE CREDENTIALS:
-{credentials_info}
-
-ORIGINAL COMMANDS:
-{chr(10).join([f"{i+1}. {cmd}" for i, cmd in enumerate(setup_commands)])}
-
-INSTRUCTIONS:
-1. Replace any authentication commands with token-based versions using available credentials
-2. Make all commands non-interactive (add --yes, --no-input, -y flags where needed)
-3. Use environment variables or direct token injection where appropriate
-4. Skip commands that cannot be made non-interactive due to missing credentials
-5. Add any necessary environment variable exports
-
-Return the modified commands as a JSON array of strings. If a command should be skipped, prefix it with "# SKIPPED: ".
-
-Example transformations:
-- "huggingface-cli login" → "huggingface-cli login --token $HUGGINGFACE_TOKEN"
-- "npm install" → "npm install --yes"
-
-Return only the JSON array, no other text.
-"""
-        
-        if not api_key:
-            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-4.1",
-            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]}...")
-        
-        # Parse the JSON response
-        import json
-        try:
-            processed_commands = json.loads(result)
-            if isinstance(processed_commands, list):
-                print(f"🔧 LLM preprocessed {len(processed_commands)} commands")
-                for i, cmd in enumerate(processed_commands):
-                    if cmd != setup_commands[i]:
-                        print(f"  {i+1}. {setup_commands[i]} → {cmd}")
-                return processed_commands
-            else:
-                print("⚠️ LLM returned invalid format, using fallback preprocessing")
-                return fallback_preprocess_commands(setup_commands, stored_credentials)
-        except json.JSONDecodeError as e:
-            print(f"⚠️ Failed to parse LLM response: {e}")
-            print("🔄 Using fallback preprocessing...")
-            return fallback_preprocess_commands(setup_commands, stored_credentials)
-            
-    except Exception as e:
-        print(f"⚠️ LLM preprocessing failed: {e}")
-        print("🔄 Using fallback preprocessing...")
-        return fallback_preprocess_commands(setup_commands, stored_credentials)
-
-def fallback_preprocess_commands(setup_commands, stored_credentials):
-    """
-    Fallback preprocessing function that manually handles common credential injection patterns.
-    
-    Args:
-        setup_commands: List of setup commands
-        stored_credentials: Dictionary of stored credentials
-        
-    Returns:
-        List of processed commands with credentials injected
-    """
-    if not setup_commands or not stored_credentials:
-        return setup_commands
-    
-    processed_commands = []
-    
-    for i, command in enumerate(setup_commands):
-        processed_command = command
-        
-        # Handle Hugging Face login
-        if 'huggingface-cli login' in command and '--token' not in command:
-            if 'HUGGINGFACE_TOKEN' in stored_credentials:
-                processed_command = f"huggingface-cli login --token $HUGGINGFACE_TOKEN"
-                print(f"🔧 Fallback: Injected HF token into command {i+1}")
-            else:
-                processed_command = f"# SKIPPED: {command} (no HF token available)"
-                print(f"🔧 Fallback: Skipped command {i+1} (no HF token)")
-        
-        # Handle OpenAI API key
-        elif 'openai' in command.lower() and 'api_key' not in command.lower():
-            if 'OPENAI_API_KEY' in stored_credentials:
-                processed_command = f"export OPENAI_API_KEY=$OPENAI_API_KEY && {command}"
-                print(f"🔧 Fallback: Added OpenAI API key export to command {i+1}")
-        
-        # Handle npm install
-        elif 'npm install' in command and '--yes' not in command and '--no-interactive' not in command:
-            processed_command = command.replace('npm install', 'npm install --yes')
-            print(f"🔧 Fallback: Made npm install non-interactive in command {i+1}")
-        
-        # Handle git clone
-        elif command.strip().startswith('git clone') and '--depth 1' not in command:
-            processed_command = command.replace('git clone', 'git clone --depth 1')
-            print(f"🔧 Fallback: Made git clone non-interactive in command {i+1}")
-        
-        # Handle apt-get install
-        elif 'apt-get install' in command and '-y' not in command:
-            processed_command = command.replace('apt-get install', 'apt-get install -y')
-            print(f"🔧 Fallback: Made apt-get install non-interactive in command {i+1}")
-        
-        processed_commands.append(processed_command)
-    
-    print(f"🔧 Fallback preprocessing completed: {len(processed_commands)} commands")
-    return processed_commands
 
 def _check_authentication(auth_manager):
     """Check if user is authenticated, prompt for login if not"""
@@ -1756,6 +741,7 @@ def _check_authentication(auth_manager):
     print("\n🔐 Authentication required")
     return auth_manager.interactive_auth_flow()
 
+
 def _handle_auth_commands(auth_manager, args):
     """Handle authentication-related commands"""
     if args.login:
@@ -1914,9 +900,6 @@ if __name__ == "__main__":
     parser.add_argument('--volume-name', type=str, help='Name of the Modal volume for persistent storage')
     parser.add_argument('--timeout', type=int, default=60, help='Container timeout in minutes (default: 60)')
     parser.add_argument('--ssh-password', type=str, help='SSH password (random if not provided)')
-    parser.add_argument('--use-api', action='store_true', help='[DEPRECATED] Fetch setup commands from original API (use --repo-url for Agent instead)')
-    parser.add_argument('--use-gitingest', action='store_true', default=True, help='[DEPRECATED] Use gitingest approach (Agent is now used when --repo-url is provided)')
-    parser.add_argument('--no-gitingest', action='store_true', help='[DEPRECATED] Disable gitingest approach (no longer needed with Agent)')
     parser.add_argument('--show-examples', action='store_true', help='Show usage examples')
     parser.add_argument('--list-gpus', action='store_true', help='List available GPU types with their specifications')
     parser.add_argument('--interactive', action='store_true', help='Run in interactive mode with prompts')
@@ -1927,6 +910,7 @@ if __name__ == "__main__":
     parser.add_argument('--gpu', default='A10G', help='GPU type to use')
     parser.add_argument('--gpu-count', type=int, default=1, help='Number of GPUs to use (default: 1)')
     parser.add_argument('--repo-url', help='Repository URL')
+    parser.add_argument('--use-cuda-base', action='store_true', help='Use CUDA base image (may cause segfaults, use only if needed for CUDA libraries)')
     
     # Authentication-related arguments
     parser.add_argument('--auth', action='store_true', help='Manage authentication (login, register, logout)')
@@ -2050,8 +1034,6 @@ if __name__ == "__main__":
     print(f"Volume: {args.volume_name or 'None'}")
     if args.repo_url:
         print("Repository Setup: Agent (intelligent)")
-    elif args.use_api:
-        print("Setup Commands: Auto-detect from repository")
     elif args.setup_commands:
         print(f"Setup Commands: {len(args.setup_commands)} custom commands")
     else:
@@ -2068,7 +1050,6 @@ if __name__ == "__main__":
             print("\n🛑 Operation cancelled by user.")
             sys.exit(0)
     else:
-        # print("🔍 Debug: yes parameter = true")
         print("")
     
     # Interactive mode or missing required arguments
@@ -2117,25 +1098,13 @@ if __name__ == "__main__":
                 print("\n🛑 Setup cancelled.")
                 sys.exit(1)
         
-        # Ask about setup commands
-        use_gitingest = args.use_gitingest and not args.no_gitingest
-        if not args.use_api and not args.setup_commands and not args.setup_commands_json:
-            try:
-                auto_detect = input("? Automatically detect setup commands for this repository? (Y/n): ").strip().lower()
-                if auto_detect in ('n', 'no'):
-                    use_gitingest = False
-            except KeyboardInterrupt:
-                print("\n🛑 Setup cancelled.")
-                sys.exit(1)
-        
         # Update args with interactive values
         args.repo_url = repo_url
         args.volume_name = volume_name
         args.gpu_count = gpu_count
-        args.use_gitingest = use_gitingest
     
     try:    
-        # Setup commands are no longer used when repo_url is provided ( Agent handles setup)
+        # Setup commands are no longer used when repo_url is provided (Agent handles setup)
         setup_commands = args.setup_commands or []
         
         # Repository setup approach
@@ -2145,7 +1114,6 @@ if __name__ == "__main__":
         else:
             print("⚠️ No repository URL provided - setup commands may be needed manually")
             
-        
         # Parse setup commands from JSON if provided
         if args.setup_commands_json:
             try:
@@ -2161,7 +1129,6 @@ if __name__ == "__main__":
                 print(f"⚠️ Error parsing JSON setup commands: {e}")
                 print(f"Received JSON string: {args.setup_commands_json}")
         
-                
         # Load commands from file if specified
         if args.commands_file and os.path.exists(args.commands_file):
             try:
@@ -2197,7 +1164,7 @@ if __name__ == "__main__":
             try:
                 with open(args.setup_script, 'r') as f:
                     script_content = f.read().strip()
-                    # Convert script to individual commandsr
+                    # Convert script to individual commands
                     script_commands = [line.strip() for line in script_content.split('\n') 
                                     if line.strip() and not line.strip().startswith('#')]
                     setup_commands.extend(script_commands)
@@ -2233,7 +1200,8 @@ if __name__ == "__main__":
             timeout_minutes=args.timeout,
             ssh_password=ssh_password,
             interactive=args.interactive,
-            gpu_count=getattr(args, 'gpu_count', 1)
+            gpu_count=getattr(args, 'gpu_count', 1),
+            use_cuda_base=getattr(args, 'use_cuda_base', False)
         )
     except KeyboardInterrupt:
         cleanup_modal_token()