gitarsenal-cli 1.3.7 → 1.3.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitarsenal-cli",
-  "version": "1.3.7",
+  "version": "1.3.8",
   "description": "CLI tool for creating Modal sandboxes with GitHub repositories",
   "main": "index.js",
   "bin": {

package/python/test_modalSandboxScript.py

@@ -2559,215 +2559,111 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
         return None
 
 def fetch_setup_commands_from_api(repo_url):
-    """Fetch setup commands from the GitIngest API using real repository analysis."""
+    """Generate setup commands locally using GitIngest analysis without API calls."""
     import tempfile
     import subprocess
     import os
     import shutil
     import json
     
-    api_url = "https://git-arsenal.vercel.app/api/analyze-with-gitingest"
+    print(f"🔍 Analyzing repository: {repo_url}")
     
-    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
+    # Check if gitingest command line tool is available
     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)}")
+        print(f"❌ GitIngest CLI tool not found: {str(e)}")
+        return generate_fallback_commands(None)
     
     # Create a temporary directory for output
     temp_dir = tempfile.mkdtemp(prefix="repo_analysis_")
     output_file = os.path.join(temp_dir, "digest.json")
     
     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 - 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_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)
-                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"
-        }
+        # 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)}")
         
-        print(f"📤 API Request payload prepared (GitIngest data size: {len(json.dumps(gitingest_data))} bytes)")
+        result = subprocess.run(gitingest_run_cmd, capture_output=True, text=True)
         
-        # Make the API request with a shorter timeout to avoid long waits
-        print(f"🌐 Making POST request to: {api_url}")
+        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:
-            response = requests.post(api_url, json=payload, timeout=30)  # Reduced timeout to 30 seconds
+            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)",
+            }
             
-            print(f"📥 API Response status code: {response.status_code}")
+            detected_technologies = []
+            for tech, pattern in tech_patterns.items():
+                if re.search(pattern, content):
+                    detected_technologies.append(tech)
             
-            if response.status_code == 200:
-                try:
-                    data = response.json()
-                    print(f"📄 API Response data received")
-                    
-                    # 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}")
-                        
-                        # 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}")
-            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
-            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.")
+            # 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
+            }
             
-            # 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 making API request: {e}")
+            print(f"📄 Processed GitIngest output: Detected language: {detected_language}, Technologies: {', '.join(detected_technologies) if detected_technologies else 'None'}")
             
-            # 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
+            # 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
+            
+        except FileNotFoundError:
+            print(f"⚠️ Output file not found at {output_file}")
+            return generate_fallback_commands(None)
+        except Exception as e:
+            print(f"⚠️ Error processing GitIngest output: {e}")
+            return generate_fallback_commands(None)
     finally:
         # Clean up temporary directory
         print(f"🧹 Cleaning up temporary directory...")
@@ -2785,9 +2681,6 @@ def fetch_setup_commands_from_api(repo_url):
 
 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
@@ -2807,6 +2700,28 @@ 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 = []
     
@@ -2814,12 +2729,21 @@ 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 detected_language == "Python" or primary_package_manager == "pip":
+    if has_python:
         print("📦 Adding Python-specific setup commands")
+        language_commands.append("apt-get install -y python3 python3-pip python3-dev")
         
         # Check for requirements.txt
-        requirements_check = [
+        language_commands.extend([
             "if [ -f requirements.txt ]; then",
             "  echo 'Installing from requirements.txt'",
             "  pip install -r requirements.txt",
@@ -2827,72 +2751,56 @@ 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
-    elif detected_language in ["JavaScript", "TypeScript"] or primary_package_manager in ["npm", "yarn", "pnpm"]:
+    if has_js or has_ts:
         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 Node.js if not available
-        language_commands.append("apt-get install -y nodejs npm")
+        # Install TypeScript if detected
+        if has_ts:
+            language_commands.append("npm install -g typescript ts-node")
         
         # Check for package.json
-        package_json_check = [
+        language_commands.extend([
             "if [ -f package.json ]; then",
-            "  echo 'Installing from package.json'",
+            "  echo 'Installing npm dependencies'",
             "  npm install",
             "fi"
-        ]
-        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)
+        ])
     
-    # Go specific commands
-    elif detected_language == "Go" or primary_package_manager == "go":
+    # Go-specific commands
+    if has_go:
         print("📦 Adding Go-specific setup commands")
-        
-        language_commands.append("apt-get install -y golang-go")
-        language_commands.append("go mod tidy")
+        language_commands.append("apt-get install -y golang")
+        language_commands.extend([
+            "if [ -f go.mod ]; then",
+            "  echo 'Installing Go dependencies'",
+            "  go mod download",
+            "fi"
+        ])
     
-    # 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")
+    # PyTorch-specific commands
+    if has_pytorch:
+        print("📦 Adding PyTorch-specific setup commands")
+        language_commands.append("pip install torch torchvision torchaudio")
     
-    # Combine all commands
-    all_commands = default_commands + language_commands
+    # TensorFlow-specific commands
+    if has_tensorflow:
+        print("📦 Adding TensorFlow-specific setup commands")
+        language_commands.append("pip install tensorflow tensorflow-gpu")
     
-    # Fix the commands
-    fixed_commands = fix_setup_commands(all_commands)
+    # Combine default commands with language-specific commands
+    all_commands = default_commands + language_commands
     
+    # Print the generated commands
     print("\n📋 Generated fallback setup commands:")
-    for i, cmd in enumerate(fixed_commands, 1):
+    for i, cmd in enumerate(all_commands, 1):
         print(f"  {i}. {cmd}")
     
-    return fixed_commands
+    return all_commands
 
 def generate_basic_repo_analysis_from_url(repo_url):
     """Generate basic repository analysis data from a repository URL."""