gitarsenal-cli 1.3.6 → 1.3.8

package/package.json

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

package/python/fetch_modal_tokens.py

@@ -41,12 +41,12 @@ def fetch_tokens_from_proxy(proxy_url=None, api_key=None):
     # Check if we have the necessary information
     if not proxy_url:
         print("❌ No proxy URL provided or found in environment")
-        print("💡 Set MODAL_PROXY_URL environment variable or use --proxy-url argument")
+        # print("💡 Set MODAL_PROXY_URL environment variable or use --proxy-url argument")
         return None, None
         
     if not api_key:
         print("❌ No API key provided or found in environment")
-        print("💡 Set MODAL_PROXY_API_KEY environment variable or use --proxy-api-key argument")
+        # print("💡 Set MODAL_PROXY_API_KEY environment variable or use --proxy-api-key argument")
         return None, None
     
     # Ensure the URL ends with a slash
@@ -103,7 +103,7 @@ def get_tokens():
     # Set the tokens in environment variables
     os.environ["MODAL_TOKEN_ID"] = token_id
     os.environ["MODAL_TOKEN_SECRET"] = token_secret
-    print(f"✅ Set MODAL_TOKEN_ID and MODAL_TOKEN_SECRET environment variables")
+    # print(f"✅ Set MODAL_TOKEN_ID and MODAL_TOKEN_SECRET environment variables")
     
     return token_id, token_secret
 
@@ -119,25 +119,25 @@ if __name__ == "__main__":
     # Set proxy URL and API key in environment variables if provided
     if args.proxy_url:
         os.environ["MODAL_PROXY_URL"] = args.proxy_url
-        print(f"✅ Set MODAL_PROXY_URL from command line")
+        # print(f"✅ Set MODAL_PROXY_URL from command line")
     
     if args.proxy_api_key:
         os.environ["MODAL_PROXY_API_KEY"] = args.proxy_api_key
-        print(f"✅ Set MODAL_PROXY_API_KEY from command line")
+        # print(f"✅ Set MODAL_PROXY_API_KEY from command line")
     
     # Get tokens
     token_id, token_secret = get_tokens()
-    print(f"Token ID: [HIDDEN]")
-    print(f"Token Secret: [HIDDEN]")
-    
-    # Check if tokens are set in environment variables
-    print(f"\n🔍 DEBUG: Checking environment variables")
-    print(f"🔍 MODAL_TOKEN_ID exists: {'Yes' if os.environ.get('MODAL_TOKEN_ID') else 'No'}")
-    print(f"🔍 MODAL_TOKEN_SECRET exists: {'Yes' if os.environ.get('MODAL_TOKEN_SECRET') else 'No'}")
-    if os.environ.get('MODAL_TOKEN_ID'):
-        print(f"🔍 MODAL_TOKEN_ID length: {len(os.environ.get('MODAL_TOKEN_ID'))}")
-    if os.environ.get('MODAL_TOKEN_SECRET'):
-        print(f"🔍 MODAL_TOKEN_SECRET length: {len(os.environ.get('MODAL_TOKEN_SECRET'))}")
+    # print(f"Token ID: [HIDDEN]")
+    # print(f"Token Secret: [HIDDEN]")
+    
+    # # Check if tokens are set in environment variables
+    # print(f"\n🔍 DEBUG: Checking environment variables")
+    # print(f"🔍 MODAL_TOKEN_ID exists: {'Yes' if os.environ.get('MODAL_TOKEN_ID') else 'No'}")
+    # print(f"🔍 MODAL_TOKEN_SECRET exists: {'Yes' if os.environ.get('MODAL_TOKEN_SECRET') else 'No'}")
+    # if os.environ.get('MODAL_TOKEN_ID'):
+    #     print(f"🔍 MODAL_TOKEN_ID length: {len(os.environ.get('MODAL_TOKEN_ID'))}")
+    # if os.environ.get('MODAL_TOKEN_SECRET'):
+    #     print(f"🔍 MODAL_TOKEN_SECRET length: {len(os.environ.get('MODAL_TOKEN_SECRET'))}")
     
     # Write the tokens to a file for use by other scripts
     tokens_file = Path(__file__).parent / "modal_tokens.json"

package/python/fix_modal_token_advanced.py

@@ -24,24 +24,22 @@ try:
     # First, try to import the fetch_modal_tokens module
     from fetch_modal_tokens import get_tokens
     TOKEN_ID, TOKEN_SECRET = get_tokens()
-    print(f"✅ Using tokens from proxy server or defaults")
+    # print(f"✅ Using tokens from proxy server or defaults")
 except ImportError:
     # If the module is not available, use hardcoded tokens
-    TOKEN_ID = "ak-sLhYqCjkvixiYcb9LAuCHp"
-    TOKEN_SECRET = "as-fPzD0Zm0dl6IFAEkhaH9pq"  # Real token secret from fr8mafia profile
-    print(f"⚠️ Using default tokens")
+    # print(f"⚠️ Using default tokens")
 
-print("🔧 Advanced Modal Token Fixer")
+# print("🔧 Advanced Modal Token Fixer")
 
 # Approach 1: Set environment variables
-print("\n📋 Approach 1: Setting environment variables")
+# print("\n📋 Approach 1: Setting environment variables")
 os.environ["MODAL_TOKEN_ID"] = TOKEN_ID
 os.environ["MODAL_TOKEN_SECRET"] = TOKEN_SECRET
-print(f"✅ Set MODAL_TOKEN_ID = [HIDDEN]")
-print(f"✅ Set MODAL_TOKEN_SECRET = [HIDDEN]")
+# print(f"✅ Set MODAL_TOKEN_ID = [HIDDEN]")
+# print(f"✅ Set MODAL_TOKEN_SECRET = [HIDDEN]")
 
 # Approach 2: Create token files in various formats
-print("\n📋 Approach 2: Creating token files in various formats")
+# print("\n📋 Approach 2: Creating token files in various formats")
 modal_dir = Path.home() / ".modal"
 modal_dir.mkdir(exist_ok=True)
 
@@ -53,7 +51,7 @@ with open(token_file, 'w') as f:
         "token_secret": TOKEN_SECRET
     }
     json.dump(token_data, f)
-print(f"✅ Created token file at {token_file}")
+# print(f"✅ Created token file at {token_file}")
 
 # Format 2: Alternative token.json format
 token_file_alt = modal_dir / "token_alt.json"
@@ -63,14 +61,14 @@ with open(token_file_alt, 'w') as f:
         "secret": TOKEN_SECRET
     }
     json.dump(token_data_alt, f)
-print(f"✅ Created alternative token file at {token_file_alt}")
+# print(f"✅ Created alternative token file at {token_file_alt}")
 
 # Format 3: Create .modalconfig file
 modalconfig_file = Path.home() / ".modalconfig"
 with open(modalconfig_file, 'w') as f:
     f.write(f"token_id = {TOKEN_ID}\n")
     f.write(f"token_secret = {TOKEN_SECRET}\n")
-print(f"✅ Created .modalconfig file at {modalconfig_file}")
+# print(f"✅ Created .modalconfig file at {modalconfig_file}")
 
 # Format 4: Create config.json file
 config_file = modal_dir / "config.json"
@@ -80,10 +78,10 @@ with open(config_file, 'w') as f:
         "token_secret": TOKEN_SECRET
     }
     json.dump(config_data, f)
-print(f"✅ Created config.json file at {config_file}")
+# print(f"✅ Created config.json file at {config_file}")
 
 # Approach 3: Use Modal CLI to set token
-print("\n📋 Approach 3: Using Modal CLI")
+# print("\n📋 Approach 3: Using Modal CLI")
 try:
     # Use the CLI to set the token directly
     result = subprocess.run(
@@ -92,17 +90,17 @@ try:
     )
     
     if result.returncode == 0:
-        print(f"✅ Successfully set token via Modal CLI")
+        # print(f"✅ Successfully set token via Modal CLI")
     else:
-        print(f"❌ Failed to set token via Modal CLI: {result.stderr}")
+        # print(f"❌ Failed to set token via Modal CLI: {result.stderr}")
 except Exception as e:
-    print(f"❌ Error using Modal CLI: {e}")
+    # print(f"❌ Error using Modal CLI: {e}")
 
 # Approach 4: Use Modal Python API to set token
-print("\n📋 Approach 4: Using Modal Python API")
+# print("\n📋 Approach 4: Using Modal Python API")
 try:
     import modal
-    print(f"✅ Successfully imported Modal")
+    # print(f"✅ Successfully imported Modal")
     
     # Try to set token directly in Modal's config
     try:
@@ -114,49 +112,49 @@ try:
             if hasattr(modal.config, '_auth_config'):
                 modal.config._auth_config.token_id = TOKEN_ID
                 modal.config._auth_config.token_secret = TOKEN_SECRET
-                print(f"✅ Set tokens via _auth_config")
+                # print(f"✅ Set tokens via _auth_config")
         except Exception as e:
-            print(f"❌ Error setting tokens via _auth_config: {e}")
+            # print(f"❌ Error setting tokens via _auth_config: {e}")
             
         try:
             # Approach 4.2: Set token via set_token() if it exists
             if hasattr(modal.config, 'set_token'):
                 modal.config.set_token(TOKEN_ID, TOKEN_SECRET)
-                print(f"✅ Set tokens via set_token()")
+                # print(f"✅ Set tokens via set_token()")
         except Exception as e:
-            print(f"❌ Error setting tokens via set_token(): {e}")
+            # print(f"❌ Error setting tokens via set_token(): {e}")
             
         try:
             # Approach 4.3: Set token via Config
             if hasattr(modal.config, 'Config'):
                 modal.config.Config.token_id = TOKEN_ID
                 modal.config.Config.token_secret = TOKEN_SECRET
-                print(f"✅ Set tokens via Config")
+                # print(f"✅ Set tokens via Config")
         except Exception as e:
-            print(f"❌ Error setting tokens via Config: {e}")
+            # print(f"❌ Error setting tokens via Config: {e}")
             
         # Approach 4.4: Inspect modal.config and try to find token-related attributes
-        print("\n🔍 Inspecting modal.config for token-related attributes...")
+        # print("\n🔍 Inspecting modal.config for token-related attributes...")
         for name in dir(modal.config):
             if "token" in name.lower() or "auth" in name.lower():
-                print(f"Found potential token-related attribute: {name}")
+                # print(f"Found potential token-related attribute: {name}")
                 try:
                     attr = getattr(modal.config, name)
                     if hasattr(attr, "token_id"):
-                        print(f"  - Setting token_id in {name}")
+                        # print(f"  - Setting token_id in {name}")
                         setattr(attr, "token_id", TOKEN_ID)
                     if hasattr(attr, "token_secret"):
-                        print(f"  - Setting token_secret in {name}")
+                        # print(f"  - Setting token_secret in {name}")
                         setattr(attr, "token_secret", TOKEN_SECRET)
                 except Exception as e:
-                    print(f"  - Error setting tokens in {name}: {e}")
+                    # print(f"  - Error setting tokens in {name}: {e}")
     except Exception as e:
-        print(f"❌ Error setting tokens in Modal config: {e}")
+        # print(f"❌ Error setting tokens in Modal config: {e}")
 except Exception as e:
     print(f"❌ Error importing Modal: {e}")
 
 # Approach 5: Monkey-patch Modal's authentication system
-print("\n📋 Approach 5: Monkey-patching Modal's authentication system")
+# print("\n📋 Approach 5: Monkey-patching Modal's authentication system")
 try:
     import modal
     
@@ -174,7 +172,7 @@ try:
             try:
                 module = getattr(modal, module_name)
                 auth_related.append((module_name, module))
-                print(f"Found potential auth-related module: {module_name}")
+                # print(f"Found potential auth-related module: {module_name}")
             except Exception:
                 pass
     
@@ -187,25 +185,25 @@ try:
                         try:
                             original_func = getattr(module, func_name)
                             if callable(original_func):
-                                print(f"  - Patching {name}.{func_name} to return token_id")
+                                # print(f"  - Patching {name}.{func_name} to return token_id")
                                 setattr(module, func_name, get_token_id)
                         except Exception as e:
-                            print(f"  - Error patching {name}.{func_name}: {e}")
+                            # print(f"  - Error patching {name}.{func_name}: {e}")
                     elif "token_secret" in func_name.lower() or "token" in func_name.lower():
                         try:
                             original_func = getattr(module, func_name)
                             if callable(original_func):
-                                print(f"  - Patching {name}.{func_name} to return token_secret")
+                                # print(f"  - Patching {name}.{func_name} to return token_secret")
                                 setattr(module, func_name, get_token_secret)
                         except Exception as e:
-                            print(f"  - Error patching {name}.{func_name}: {e}")
+                            # print(f"  - Error patching {name}.{func_name}: {e}")
     
-    print(f"✅ Monkey-patching completed")
+    # print(f"✅ Monkey-patching completed")
 except Exception as e:
-    print(f"❌ Error during monkey-patching: {e}")
+    # print(f"❌ Error during monkey-patching: {e}")
 
 # Approach 6: Test Modal authentication
-print("\n📋 Approach 6: Testing Modal authentication")
+# print("\n📋 Approach 6: Testing Modal authentication")
 try:
     import modal
     
@@ -217,14 +215,14 @@ try:
         return "Hello, world!"
     
     # Try to run the function to test authentication
-    print("Creating a test Modal app...")
+    # print("Creating a test Modal app...")
     with app.run() as running_app:
-        print("Running the test function...")
+        # print("Running the test function...")
         result = running_app.hello.remote()
-        print(f"✅ Successfully ran Modal function: {result}")
-        print("🎉 Modal authentication is working!")
+        # print(f"✅ Successfully ran Modal function: {result}")
+        # print("🎉 Modal authentication is working!")
         
 except Exception as e:
-    print(f"❌ Error testing Modal authentication: {e}")
+    # print(f"❌ Error testing Modal authentication: {e}")
 
-print("\n✅ Done fixing Modal token. Please try your command again.") 
+# print("\n✅ Done fixing Modal token. Please try your command again.") 

package/python/test_modalSandboxScript.py

@@ -27,19 +27,19 @@ args, unknown = parser.parse_known_args()
 # Set proxy URL and API key in environment variables if provided
 if args.proxy_url:
     os.environ["MODAL_PROXY_URL"] = args.proxy_url
-    print(f"✅ Set MODAL_PROXY_URL from command line")
+    # print(f"✅ Set MODAL_PROXY_URL from command line")
     
 if args.proxy_api_key:
     os.environ["MODAL_PROXY_API_KEY"] = args.proxy_api_key
-    print(f"✅ Set MODAL_PROXY_API_KEY from command line")
+    # print(f"✅ Set MODAL_PROXY_API_KEY from command line")
 
 # First, try to fetch tokens from the proxy server
 try:
     # Import the fetch_modal_tokens module
-    print("🔄 Fetching tokens from proxy server...")
+    # print("🔄 Fetching tokens from proxy server...")
     from fetch_modal_tokens import get_tokens
     token_id, token_secret = get_tokens()
-    print(f"✅ Tokens fetched successfully")
+    # print(f"✅ Tokens fetched successfully")
     
     # Explicitly set the environment variables again to be sure
     os.environ["MODAL_TOKEN_ID"] = token_id
@@ -56,26 +56,26 @@ except Exception as e:
     # Apply the comprehensive Modal token solution as fallback
     try:
         # Import the comprehensive solution module
-        print("🔄 Applying comprehensive Modal token solution...")
+        # print("🔄 Applying comprehensive Modal token solution...")
         import modal_token_solution
-        print("✅ Comprehensive Modal token solution applied")
+        # print("✅ Comprehensive Modal token solution applied")
         
         # Set token variables for later use
         token = modal_token_solution.TOKEN_ID  # For backward compatibility
     except Exception as e:
-        print(f"⚠️ Error applying comprehensive Modal token solution: {e}")
+        # print(f"⚠️ Error applying comprehensive Modal token solution: {e}")
         
         # Fall back to the authentication patch
         try:
             # Import the patch module
-            print("🔄 Falling back to Modal authentication patch...")
+            # print("🔄 Falling back to Modal authentication patch...")
             import modal_auth_patch
-            print("✅ Modal authentication patch applied")
+            # print("✅ Modal authentication patch applied")
             
             # Set token variables for later use
             token = modal_auth_patch.TOKEN_ID  # For backward compatibility
         except Exception as e:
-            print(f"⚠️ Error applying Modal authentication patch: {e}")
+            # print(f"⚠️ Error applying Modal authentication patch: {e}")
             
             # Fall back to fix_modal_token.py
             try:
@@ -115,17 +115,17 @@ except Exception as e:
                 token = "ak-sLhYqCjkvixiYcb9LAuCHp"  # Default token ID
 
 # Print debug info
-print(f"🔍 DEBUG: Checking environment variables")
-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'))}")
-print(f"✅ Token setup completed")
+# print(f"🔍 DEBUG: Checking environment variables")
+# 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'))}")
+# print(f"✅ Token setup completed")
 
 # Import modal after token setup
 import modal
@@ -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 container
+    # Try to open a new terminal window and connect to the containera
     if container_id:
         print("🖥️ Attempting to open new terminal window...")
         # Use osascript to open a new terminal with the modal shell command
@@ -2559,198 +2559,128 @@ 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 - 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()
-                            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")
-                                gitingest_data = {
-                                    "system_info": {
-                                        "detected_language": "Unknown",
-                                        "detected_technologies": [],
-                                    },
-                                    "repository_analysis": {
-                                        "summary": content[:5000],  # First 5000 chars as summary
-                                        "content_preview": content[:10000]  # First 10000 chars as preview
-                                    },
-                                    "success": True
-                                }
-                    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"📤 API Request payload prepared (GitIngest data size: {len(json.dumps(gitingest_data))} bytes)")
+        print(f"🔄 Executing: {' '.join(gitingest_run_cmd)}")
         
-        # Make the API request
-        print(f"🌐 Making POST request to: {api_url}")
+        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:
-            response = requests.post(api_url, json=payload, timeout=60)
+            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}")
-                        # 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"Error response: {response.text[:500]}...")
-                # Return fallback commands
-                return generate_fallback_commands(gitingest_data)
-        except requests.exceptions.Timeout:
-            print("❌ API request timed out after 60 seconds")
-            print("⚠️ Using fallback commands instead")
-            # Return fallback commands
-            return generate_fallback_commands(gitingest_data)
-        except requests.exceptions.ConnectionError:
-            print(f"❌ Connection error: Could not connect to {api_url}")
-            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)
+            # 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'}")
+            
+            # 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 the temporary directory
+        # Clean up temporary directory
         print(f"🧹 Cleaning up temporary directory...")
-        shutil.rmtree(temp_dir, ignore_errors=True)
+        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"
+    ]
 
 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
@@ -2770,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 = []
     
@@ -2777,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",
@@ -2790,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."""
@@ -3309,24 +3254,24 @@ def cleanup_modal_token():
         # Remove token from environment variables
         if "MODAL_TOKEN_ID" in os.environ:
             del os.environ["MODAL_TOKEN_ID"]
-            print("✅ Removed token ID from environment")
+            # print("✅ Removed token ID from environment")
         
         if "MODAL_TOKEN" in os.environ:
             del os.environ["MODAL_TOKEN"]
-            print("✅ Removed token from environment")
+            # print("✅ Removed token from environment")
             
         if "MODAL_TOKEN_SECRET" in os.environ:
             del os.environ["MODAL_TOKEN_SECRET"]
-            print("✅ Removed token secret from environment")
+            # print("✅ Removed token secret from environment")
         
         # Delete ~/.modal.toml file
         home_dir = os.path.expanduser("~")
         modal_toml = os.path.join(home_dir, ".modal.toml")
         if os.path.exists(modal_toml):
             os.remove(modal_toml)
-            print(f"✅ Deleted token file at {modal_toml}")
+            # print(f"✅ Deleted token file at {modal_toml}")
         
-        print("✅ Token cleanup completed successfully")
+        # print("✅ Token cleanup completed successfully")
     except Exception as e:
         print(f"❌ Error during token cleanup: {e}")
 
@@ -3492,12 +3437,12 @@ if __name__ == "__main__":
             ssh_password=ssh_password
         )
     except KeyboardInterrupt:
-        print("\n\n🛑 Execution interrupted")
-        print("🧹 Cleaning up resources...")
+        # print("\n\n🛑 Execution interrupted")
+        # print("🧹 Cleaning up resources...")
         cleanup_modal_token()
         sys.exit(1)
     except Exception as e:
-        print(f"\n❌ Error: {e}")
-        print("🧹 Cleaning up resources...")
+        # print(f"\n❌ Error: {e}")
+        # print("🧹 Cleaning up resources...")
         cleanup_modal_token()
         sys.exit(1)

package/python/emoji_fix_patch.py

@@ -1,79 +0,0 @@
-#!/usr/bin/env python3
-"""
-This script removes emojis from the test_modalSandboxScript.py file to fix syntax errors.
-"""
-
-import re
-import sys
-import shutil
-from pathlib import Path
-
-def remove_emojis(script_path):
-    """
-    Remove emojis from the Python script to fix syntax errors.
-    """
-    print(f"Removing emojis from {script_path}...")
-    
-    # Make a backup of the original file
-    backup_path = f"{script_path}.emoji_backup"
-    shutil.copy2(script_path, backup_path)
-    
-    # Read the file
-    with open(script_path, 'r', encoding='utf-8', errors='ignore') as f:
-        content = f.read()
-    
-    # Emoji pattern - matches most common emoji characters
-    emoji_pattern = re.compile(
-        "["
-        "\U0001F1E0-\U0001F1FF"  # flags (iOS)
-        "\U0001F300-\U0001F5FF"  # symbols & pictographs
-        "\U0001F600-\U0001F64F"  # emoticons
-        "\U0001F680-\U0001F6FF"  # transport & map symbols
-        "\U0001F700-\U0001F77F"  # alchemical symbols
-        "\U0001F780-\U0001F7FF"  # Geometric Shapes
-        "\U0001F800-\U0001F8FF"  # Supplemental Arrows-C
-        "\U0001F900-\U0001F9FF"  # Supplemental Symbols and Pictographs
-        "\U0001FA00-\U0001FA6F"  # Chess Symbols
-        "\U0001FA70-\U0001FAFF"  # Symbols and Pictographs Extended-A
-        "\U00002702-\U000027B0"  # Dingbats
-        "\U000024C2-\U0001F251" 
-        "]+", flags=re.UNICODE)
-    
-    # Simply remove all emojis
-    content = emoji_pattern.sub('', content)
-    
-    # Fix common syntax issues after emoji removal
-    content = re.sub(r'print\(\s*\)', r'print()', content)
-    content = re.sub(r'print\(\s*"', r'print("', content)
-    
-    # Fix specific syntax errors
-    content = re.sub(r'print\(\s*container\'s', r'print("container\'s', content)
-    
-    # Write the modified content back to the file
-    with open(script_path, 'w', encoding='utf-8') as f:
-        f.write(content)
-    
-    print(f"Emoji removal complete. Original file backed up to {backup_path}")
-    return True
-
-def main():
-    """
-    Main entry point for the script.
-    """
-    # Get the path to the script
-    script_dir = Path(__file__).parent
-    script_path = script_dir / "test_modalSandboxScript.py"
-    
-    if not script_path.exists():
-        print(f"Error: Script not found at {script_path}")
-        return 1
-    
-    try:
-        remove_emojis(script_path)
-        return 0
-    except Exception as e:
-        print(f"Error removing emojis: {e}")
-        return 1
-
-if __name__ == "__main__":
-    sys.exit(main())