gitarsenal-cli 1.3.8 → 1.3.10

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,129 +2558,301 @@ 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):
-    """Generate setup commands locally using GitIngest analysis without API calls."""
+    """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}")
     
-    print(f"🔍 Analyzing repository: {repo_url}")
+    # Check if gitingest command line tool is available - try multiple possible command names
+    has_gitingest_cli = False
+    gitingest_cmd_name = None
     
-    # Check if gitingest command line tool is available
+    # 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 CLI tool not found: {str(e)}")
-        return generate_fallback_commands(None)
+        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:
-        # Use gitingest CLI tool to analyze the repository directly from URL
-        print(f"🔎 Running GitIngest analysis on {repo_url}...")
-        
-        # Run gitingest command with proper parameters
-        gitingest_run_cmd = [
-            "gitingest",
-            repo_url,
-            "-o", 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")
-            return generate_fallback_commands(None)
-        
-        print(f"✅ GitIngest analysis completed successfully")
-        
-        # Read the output file - GitIngest outputs structured text, not 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_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)",
-            }
+        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
+            ]
             
-            detected_technologies = []
-            for tech, pattern in tech_patterns.items():
-                if re.search(pattern, content):
-                    detected_technologies.append(tech)
+            print(f"🔄 Executing: {' '.join(gitingest_run_cmd)}")
             
-            # 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
-            }
+            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)
             
-            print(f"📄 Processed GitIngest output: Detected language: {detected_language}, Technologies: {', '.join(detected_technologies) if detected_technologies else 'None'}")
+        # 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)
             
-            # Generate commands locally based on the analysis
-            print(f"🔧 Generating setup commands locally based on repository analysis")
-            setup_commands = generate_fallback_commands(gitingest_data)
-            return setup_commands
+        try:
+            print(f"📥 API Response status code: {response.status_code}")
             
-        except FileNotFoundError:
-            print(f"⚠️ Output file not found at {output_file}")
-            return generate_fallback_commands(None)
+            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 GitIngest output: {e}")
-            return generate_fallback_commands(None)
+            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"""
+    print("\n" + "="*80)
+    print("📋 GENERATING FALLBACK SETUP COMMANDS")
+    print("="*80)
     print("Using basic repository analysis to generate setup commands")
     
     # Default commands that work for most repositories
@@ -2700,28 +2872,6 @@ def generate_fallback_commands(gitingest_data):
     detected_technologies = gitingest_data.get("system_info", {}).get("detected_technologies", [])
     primary_package_manager = gitingest_data.get("system_info", {}).get("primary_package_manager", "Unknown")
     
-    # Extract more information from raw text if available
-    if "raw_text" in gitingest_data and gitingest_data["raw_text"]:
-        raw_text = gitingest_data["raw_text"]
-        
-        # Look for additional technologies in raw text
-        import re
-        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)",
-        }
-        
-        for tech, pattern in tech_patterns.items():
-            if re.search(pattern, raw_text) and tech.lower() not in [t.lower() for t in detected_technologies]:
-                detected_technologies.append(tech)
-    
     # Add language-specific commands
     language_commands = []
     
@@ -2729,21 +2879,12 @@ def generate_fallback_commands(gitingest_data):
     print(f"📋 Detected technologies: {', '.join(detected_technologies) if detected_technologies else 'None'}")
     print(f"📋 Detected package manager: {primary_package_manager}")
     
-    # Check for specific technologies and add appropriate commands
-    has_python = any(tech.lower() == "python" for tech in detected_technologies) or detected_language.lower() == "python"
-    has_js = any(tech.lower() in ["javascript", "node", "nodejs"] for tech in detected_technologies)
-    has_ts = any(tech.lower() == "typescript" for tech in detected_technologies)
-    has_go = any(tech.lower() in ["go", "golang"] for tech in detected_technologies)
-    has_pytorch = any(tech.lower() in ["pytorch", "torch"] for tech in detected_technologies)
-    has_tensorflow = any(tech.lower() == "tensorflow" for tech in detected_technologies)
-    
     # Python-specific commands
-    if has_python:
+    if detected_language == "Python" or primary_package_manager == "pip":
         print("📦 Adding Python-specific setup commands")
-        language_commands.append("apt-get install -y python3 python3-pip python3-dev")
         
         # Check for requirements.txt
-        language_commands.extend([
+        requirements_check = [
             "if [ -f requirements.txt ]; then",
             "  echo 'Installing from requirements.txt'",
             "  pip install -r requirements.txt",
@@ -2751,56 +2892,72 @@ def generate_fallback_commands(gitingest_data):
             "  echo 'Installing from setup.py'",
             "  pip install -e .",
             "fi"
-        ])
+        ]
+        language_commands.extend(requirements_check)
+        
+        # Add common Python packages
+        language_commands.append("pip install pytest numpy pandas matplotlib")
     
     # JavaScript/Node.js specific commands
-    if has_js or has_ts:
+    elif detected_language in ["JavaScript", "TypeScript"] or primary_package_manager in ["npm", "yarn", "pnpm"]:
         print("📦 Adding JavaScript/Node.js-specific setup commands")
-        language_commands.append("curl -fsSL https://deb.nodesource.com/setup_18.x | bash -")
-        language_commands.append("apt-get install -y nodejs")
         
-        # Install TypeScript if detected
-        if has_ts:
-            language_commands.append("npm install -g typescript ts-node")
+        # Install Node.js if not available
+        language_commands.append("apt-get install -y nodejs npm")
         
         # Check for package.json
-        language_commands.extend([
+        package_json_check = [
             "if [ -f package.json ]; then",
-            "  echo 'Installing npm dependencies'",
+            "  echo 'Installing from package.json'",
             "  npm install",
             "fi"
-        ])
-    
-    # Go-specific commands
-    if has_go:
-        print("📦 Adding Go-specific setup commands")
-        language_commands.append("apt-get install -y golang")
-        language_commands.extend([
-            "if [ -f go.mod ]; then",
-            "  echo 'Installing Go dependencies'",
-            "  go mod download",
+        ]
+        language_commands.extend(package_json_check)
+    
+    # Java specific commands
+    elif detected_language == "Java" or primary_package_manager in ["maven", "gradle"]:
+        print("📦 Adding Java-specific setup commands")
+        
+        language_commands.append("apt-get install -y openjdk-11-jdk maven gradle")
+        
+        # Check for Maven or Gradle
+        build_check = [
+            "if [ -f pom.xml ]; then",
+            "  echo 'Building with Maven'",
+            "  mvn clean install -DskipTests",
+            "elif [ -f build.gradle ]; then",
+            "  echo 'Building with Gradle'",
+            "  gradle build --no-daemon",
             "fi"
-        ])
+        ]
+        language_commands.extend(build_check)
     
-    # PyTorch-specific commands
-    if has_pytorch:
-        print("📦 Adding PyTorch-specific setup commands")
-        language_commands.append("pip install torch torchvision torchaudio")
+    # Go specific commands
+    elif detected_language == "Go" or primary_package_manager == "go":
+        print("📦 Adding Go-specific setup commands")
+        
+        language_commands.append("apt-get install -y golang-go")
+        language_commands.append("go mod tidy")
     
-    # TensorFlow-specific commands
-    if has_tensorflow:
-        print("📦 Adding TensorFlow-specific setup commands")
-        language_commands.append("pip install tensorflow tensorflow-gpu")
+    # Rust specific commands
+    elif detected_language == "Rust" or primary_package_manager == "cargo":
+        print("📦 Adding Rust-specific setup commands")
+        
+        language_commands.append("curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y")
+        language_commands.append("source $HOME/.cargo/env")
+        language_commands.append("cargo build")
     
-    # Combine default commands with language-specific commands
+    # Combine all commands
     all_commands = default_commands + language_commands
     
-    # Print the generated commands
+    # Fix the commands
+    fixed_commands = fix_setup_commands(all_commands)
+    
     print("\n📋 Generated fallback setup commands:")
-    for i, cmd in enumerate(all_commands, 1):
+    for i, cmd in enumerate(fixed_commands, 1):
         print(f"  {i}. {cmd}")
     
-    return all_commands
+    return fixed_commands
 
 def generate_basic_repo_analysis_from_url(repo_url):
     """Generate basic repository analysis data from a repository URL."""
@@ -2968,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 = {
@@ -2978,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
@@ -3296,9 +3471,253 @@ def show_usage_examples():
     print("│   --volume-name my-persistent-volume                             │")
     print("└────────────────────────────────────────────────────────────────────────────────────┘\n")
     
+    print("With GitIngest API (default)")
+    print("┌────────────────────────────────────────────────────────────────────────────────────┐")
+    print("│ gitarsenal --gpu A10G --repo-url https://github.com/username/repo.git             │")
+    print("└────────────────────────────────────────────────────────────────────────────────────┘\n")
+    
+    print("Without GitIngest API")
+    print("┌────────────────────────────────────────────────────────────────────────────────────┐")
+    print("│ gitarsenal --gpu A10G --repo-url https://github.com/username/repo.git \\  │")
+    print("│   --no-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
@@ -3316,7 +3735,9 @@ 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='Fetch setup commands from API')
+    parser.add_argument('--use-api', action='store_true', help='Fetch setup commands from original API')
+    parser.add_argument('--use-gitingest', action='store_true', default=True, help='Use gitingest approach to fetch setup commands (default)')
+    parser.add_argument('--no-gitingest', action='store_true', help='Disable gitingest approach for setup commands')
     parser.add_argument('--show-examples', action='store_true', help='Show usage examples')
     
     args = parser.parse_args()
@@ -3332,13 +3753,27 @@ if __name__ == "__main__":
         
         # If --use-api flag is set and repo_url is provided, fetch setup commands from API
         
+        # Use gitingest by default unless --no-gitingest is set
+        if args.repo_url and (args.use_gitingest and not args.no_gitingest):
+            print("🔄 Using gitingest approach to fetch setup commands (default)")
+            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")
+                if not args.use_api:
+                    print("⚠️ Falling back to basic setup commands")
+                    setup_commands = generate_fallback_commands(None)
+                else:
+                    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:
-            print("🔄 Using API to fetch setup commands")
+        elif args.use_api and args.repo_url:
+            print("🔄 Using original API to fetch setup commands")
             api_commands = fetch_setup_commands_from_api(args.repo_url)
             if api_commands:
                 setup_commands = api_commands
-                print(f"📋 Using {len(setup_commands)} commands from API")
+                print(f"📋 Using {len(setup_commands)} commands from original API")
             else:
                 print("⚠️ Failed to get commands from API, no fallback commands will be used")
                 # Do not fall back to basic setup commands