gitarsenal-cli 1.3.7 → 1.3.9

package/python/test_modalSandboxScript.py

@@ -119,12 +119,12 @@ except Exception as e:
 # print(f"🔍 Token ID exists: {'Yes' if os.environ.get('MODAL_TOKEN_ID') else 'No'}")
 # print(f"🔍 Token secret exists: {'Yes' if os.environ.get('MODAL_TOKEN_SECRET') else 'No'}")
 # print(f"🔍 Token exists: {'Yes' if os.environ.get('MODAL_TOKEN') else 'No'}")
-# if os.environ.get('MODAL_TOKEN_ID'):
-#     print(f"🔍 Token ID length: {len(os.environ.get('MODAL_TOKEN_ID'))}")
-# if os.environ.get('MODAL_TOKEN_SECRET'):
-#     print(f"🔍 Token secret length: {len(os.environ.get('MODAL_TOKEN_SECRET'))}")
-# if os.environ.get('MODAL_TOKEN'):
-#     print(f"🔍 Token length: {len(os.environ.get('MODAL_TOKEN'))}")
+if os.environ.get('MODAL_TOKEN_ID'):
+    print(f"🔍 Token ID length: {len(os.environ.get('MODAL_TOKEN_ID'))}")
+if os.environ.get('MODAL_TOKEN_SECRET'):
+    print(f"🔍 Token secret length: {len(os.environ.get('MODAL_TOKEN_SECRET'))}")
+if os.environ.get('MODAL_TOKEN'):
+    print(f"🔍 Token length: {len(os.environ.get('MODAL_TOKEN'))}")
 # print(f"✅ Token setup completed")
 
 # Import modal after token setup
@@ -2025,7 +2025,7 @@ cd "{current_dir}"
     print("⏳ Sandbox will remain running until you terminate it with:")
     print(f"modal sandbox terminate {sandbox_id}")
 
-    # Try to open a new terminal window and connect to the containera
+    # Try to open a new terminal window and connect to the container
     if container_id:
         print("🖥️ Attempting to open new terminal window...")
         # Use osascript to open a new terminal with the modal shell command
@@ -2558,6 +2558,15 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
         print(f"❌ Error running container: {e}")
         return None
 
+def is_local_server_running(url, timeout=2):
+    """Check if a local server is running by attempting a connection."""
+    import requests
+    try:
+        response = requests.get(url, timeout=timeout)
+        return True
+    except requests.exceptions.RequestException:
+        return False
+
 def fetch_setup_commands_from_api(repo_url):
     """Fetch setup commands from the GitIngest API using real repository analysis."""
     import tempfile
@@ -2565,8 +2574,13 @@ def fetch_setup_commands_from_api(repo_url):
     import os
     import shutil
     import json
+    import time
+    import requests
     
-    api_url = "https://git-arsenal.vercel.app/api/analyze-with-gitingest"
+    # 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}")
     
@@ -2588,6 +2602,13 @@ def fetch_setup_commands_from_api(repo_url):
     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
@@ -2618,44 +2639,87 @@ def fetch_setup_commands_from_api(repo_url):
             else:
                 print(f"✅ GitIngest analysis completed successfully")
                 
-                # Read the output file - GitIngest outputs structured text, not JSON
+                # Read the output file - note that the default format might not be JSON
                 try:
-                    with open(output_file, 'r', encoding='utf-8') as f:
-                        content = f.read()
-                    
-                    # Process the text output into a structured format
-                    print(f"📄 Processing GitIngest text output")
-                    
-                    # Extract key information from the text output
-                    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
-                    tech_matches = re.findall(r"(?i)(python|javascript|typescript|react|node|vue|angular|django|flask|express|pytorch|tensorflow|rust|go|ruby|rails|php|laravel|c\+\+|java|kotlin|swift)", content)
-                    detected_technologies = list(set(tech_matches)) if tech_matches else []
-                    
-                    # Create a structured representation
-                    gitingest_data = {
-                        "system_info": {
-                            "detected_language": detected_language,
-                            "detected_technologies": detected_technologies,
-                        },
-                        "repository_analysis": {
-                            "summary": content[:1000],  # First 1000 chars as summary
-                            "content_preview": content[:5000]  # First 5000 chars as preview
-                        },
-                        "raw_text": content[:10000],  # Include a portion of the raw text
-                        "success": True
-                    }
-                    
-                    print(f"📄 Processed GitIngest output: Detected language: {detected_language}, Technologies: {', '.join(detected_technologies) if detected_technologies else 'None'}")
-                    
-                except FileNotFoundError:
-                    print(f"⚠️ Output file not found at {output_file}")
-                    gitingest_data = generate_basic_repo_analysis_from_url(repo_url)
+                    # 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)
@@ -2672,17 +2736,46 @@ def fetch_setup_commands_from_api(repo_url):
         
         print(f"📤 API Request payload prepared (GitIngest data size: {len(json.dumps(gitingest_data))} bytes)")
         
-        # Make the API request with a shorter timeout to avoid long waits
-        print(f"🌐 Making POST request to: {api_url}")
-        try:
-            response = requests.post(api_url, json=payload, timeout=30)  # Reduced timeout to 30 seconds
+        # 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"]:
@@ -2720,68 +2813,40 @@ def fetch_setup_commands_from_api(repo_url):
                         print("📋 Available fields in response:")
                         for key in data.keys():
                             print(f"  - {key}")
-                        
-                        # Generate fallback commands based on the gitingest data
-                        print("\n" + "="*80)
-                        print("📋 GENERATING FALLBACK SETUP COMMANDS")
-                        print("="*80)
-                        fallback_commands = generate_fallback_commands(gitingest_data)
-                        return fallback_commands
-                except Exception as e:
-                    print(f"⚠️ Error parsing API response: {e}")
+                        # 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(f"⚠️ The server took too long to respond. Using fallback commands instead.")
-                
-                # Generate fallback commands based on the gitingest data
-                print("\n" + "="*80)
-                print("📋 GENERATING FALLBACK SETUP COMMANDS")
-                print("="*80)
-                fallback_commands = generate_fallback_commands(gitingest_data)
-                return fallback_commands
+                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: {response.text[:500]}")
-                
-                # Generate fallback commands based on the gitingest data
-                print("\n" + "="*80)
-                print("📋 GENERATING FALLBACK SETUP COMMANDS")
-                print("="*80)
-                fallback_commands = generate_fallback_commands(gitingest_data)
-                return fallback_commands
-        except requests.exceptions.Timeout:
-            print(f"❌ API request timed out after 30 seconds")
-            print(f"⚠️ The server took too long to respond. Using fallback commands instead.")
-            
-            # Generate fallback commands based on the gitingest data
-            print("\n" + "="*80)
-            print("📋 GENERATING FALLBACK SETUP COMMANDS")
-            print("="*80)
-            fallback_commands = generate_fallback_commands(gitingest_data)
-            return fallback_commands
+                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 making API request: {e}")
-            
-            # Generate fallback commands based on the gitingest data
-            print("\n" + "="*80)
-            print("📋 GENERATING FALLBACK SETUP COMMANDS")
-            print("="*80)
-            fallback_commands = generate_fallback_commands(gitingest_data)
-            return fallback_commands
+            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 temporary directory
+        # Clean up the temporary directory
         print(f"🧹 Cleaning up temporary directory...")
-        try:
-            shutil.rmtree(temp_dir)
-        except Exception as e:
-            print(f"⚠️ Error cleaning up temporary directory: {e}")
-    
-    # If all else fails, return basic setup commands
-    return [
-        "apt-get update -y",
-        "apt-get install -y git curl wget",
-        "pip install --upgrade pip setuptools wheel"
-    ]
+        shutil.rmtree(temp_dir, ignore_errors=True)
 
 def generate_fallback_commands(gitingest_data):
     """Generate fallback setup commands based on repository analysis"""
@@ -3060,8 +3125,11 @@ def generate_basic_repo_analysis(repo_dir):
     }
 
 def get_setup_commands_from_local_api(repo_url, gitingest_data):
-    """Try to get setup commands from the local API."""
-    api_url = "http://localhost:3000/api/analyze-with-gitingest"
+    """Try to get setup commands from the API."""
+    # Use only online endpoints
+    api_endpoints = [
+        "https://www.gitarsenal.dev/api/analyze-with-gitingest"  # Working endpoint with www prefix
+    ]
     
     # Prepare the request payload
     payload = {
@@ -3070,34 +3138,49 @@ def get_setup_commands_from_local_api(repo_url, gitingest_data):
         "userRequest": "Setup and run the repository"
     }
     
-    try:
-        # Make the API request
-        print(f"🌐 Making POST request to local API: {api_url}")
-        response = requests.post(api_url, json=payload, timeout=60)
+    # Try each API endpoint
+    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 response.status_code == 200:
-            data = response.json()
-            if "setupInstructions" in data and "commands" in data["setupInstructions"]:
-                commands = data["setupInstructions"]["commands"]
-                print(f"✅ Successfully fetched {len(commands)} setup commands from local API")
-                
-                # Print the original commands
-                print("📋 Original commands from local API:")
-                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
-    except Exception as e:
-        print(f"❌ Error connecting to local API: {e}")
+        if response and response.status_code == 200:
+            try:
+                data = response.json()
+                print(f"📄 Response size: {len(response.text)} bytes")
+                print(f"📄 Response URL: {response.url}")
+                if "setupInstructions" in data and "commands" in data["setupInstructions"]:
+                    commands = data["setupInstructions"]["commands"]
+                    print(f"✅ Successfully fetched {len(commands)} setup commands from API at {api_url}")
+                    
+                    # Print the original commands
+                    print("📋 Original commands from API:")
+                    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("⚠️ API response did not contain setupInstructions.commands field")
+            except json.JSONDecodeError:
+                print(f"❌ Failed to parse API response as JSON")
+        elif response:
+            print(f"❌ API request failed with status code: {response.status_code}")
+        else:
+            print(f"❌ Failed to connect to {api_url}")
     
+    print("❌ All API endpoints failed")
     return None
 
 # Define a function to create and return a properly configured ssh container function
@@ -3388,9 +3471,248 @@ def show_usage_examples():
     print("│   --volume-name my-persistent-volume                             │")
     print("└────────────────────────────────────────────────────────────────────────────────────┘\n")
     
+    print("With GitIngest API (recommended)")
+    print("┌────────────────────────────────────────────────────────────────────────────────────┐")
+    print("│ gitarsenal --gpu A10G --repo-url https://github.com/username/repo.git \\  │")
+    print("│   --use-gitingest                                                │")
+    print("└────────────────────────────────────────────────────────────────────────────────────┘\n")
+    
+    print("With Original API")
+    print("┌────────────────────────────────────────────────────────────────────────────────────┐")
+    print("│ gitarsenal --gpu A10G --repo-url https://github.com/username/repo.git \\  │")
+    print("│   --use-api                                                      │")
+    print("└────────────────────────────────────────────────────────────────────────────────────┘\n")
+    
     print("Available GPU Options:")
     print("  T4, L4, A10G, A100-40GB, A100-80GB, L40S, H100, H200, B200")
 
+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",
+        "https://www.gitarsenal.dev/api/analyze-with-gitingest",
+        "http://localhost:3000/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}")
+            
+            payload = {
+                "repoUrl": repo_url,
+                "gitingestData": gitingest_data
+            }
+            
+            # 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}")
+                    
+                    # 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)
+
 if __name__ == "__main__":
     # Parse command line arguments when script is run directly
     import argparse
@@ -3409,6 +3731,7 @@ if __name__ == "__main__":
     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='Fetch setup commands from API')
+    parser.add_argument('--use-gitingest', action='store_true', help='Use gitingest approach to fetch setup commands')
     parser.add_argument('--show-examples', action='store_true', help='Show usage examples')
     
     args = parser.parse_args()
@@ -3424,8 +3747,18 @@ if __name__ == "__main__":
         
         # If --use-api flag is set and repo_url is provided, fetch setup commands from API
         
+        # If --use-gitingest flag is set and repo_url is provided, use the gitingest approach
+        if args.use_gitingest and args.repo_url:
+            print("🔄 Using gitingest approach to fetch setup commands")
+            api_commands = get_setup_commands_from_gitingest(args.repo_url)
+            if api_commands:
+                setup_commands = api_commands
+                print(f"📋 Using {len(setup_commands)} commands from gitingest API")
+            else:
+                print("⚠️ Failed to get commands from gitingest API, no fallback commands will be used")
+                setup_commands = []
         # If --use-api flag is set and repo_url is provided, fetch setup commands from API
-        if args.use_api and args.repo_url:
+        elif args.use_api and args.repo_url:
             print("🔄 Using API to fetch setup commands")
             api_commands = fetch_setup_commands_from_api(args.repo_url)
             if api_commands: