gitarsenal-cli 1.3.5 → 1.3.7

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 Modal 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"✅ Modal 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"🔍 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'}")
-print(f"🔍 MODAL_TOKEN exists: {'Yes' if os.environ.get('MODAL_TOKEN') 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'))}")
-if os.environ.get('MODAL_TOKEN'):
-    print(f"🔍 MODAL_TOKEN length: {len(os.environ.get('MODAL_TOKEN'))}")
-print(f"✅ Modal 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
@@ -604,12 +604,12 @@ def create_modal_sandbox(gpu_type, repo_url=None, repo_name=None, setup_commands
         try:
             # This will raise an exception if not authenticated
             modal.config.get_current_workspace_name()
-            print("✅ Modal authentication verified")
+            print("✅ Authentication verified")
         except modal.exception.AuthError:
             print("\n" + "="*80)
-            print("🔑 MODAL AUTHENTICATION REQUIRED")
+            print("🔑 AUTHENTICATION REQUIRED")
             print("="*80)
-            print("GitArsenal requires Modal authentication to create cloud environments.")
+            print("GitArsenal requires authentication to create cloud environments.")
             
             # Try to get token from credentials manager
             modal_token = None
@@ -703,7 +703,7 @@ def create_modal_sandbox(gpu_type, repo_url=None, repo_name=None, setup_commands
         gpu_type = 'A10G'
     
     gpu_spec = gpu_configs[gpu_type]
-    print(f"🚀 Creating Modal sandbox with {gpu_spec['gpu']} GPU ({gpu_spec['memory']}GB VRAM)")
+    print(f"🚀 Creating sandbox with {gpu_spec['gpu']} GPU ({gpu_spec['memory']}GB VRAM)")
     
     # Initialize uv_path variable
     uv_path = ""
@@ -738,7 +738,7 @@ def create_modal_sandbox(gpu_type, repo_url=None, repo_name=None, setup_commands
     # Enable output for image building
     with modal.enable_output():
         # Create a Modal app and sandbox
-        print(f"🚀 Creating Modal sandbox with GPU: {gpu_type.lower()} (App: {app_name})...")
+        print(f"🚀 Creating sandbox with GPU: {gpu_type.lower()} (App: {app_name})...")
         # Always use lookup with create_if_missing=True to properly initialize the app
         app = modal.App.lookup(app_name, create_if_missing=True)
         print(f"Created app: {app_name}")
@@ -947,7 +947,7 @@ def create_modal_sandbox(gpu_type, repo_url=None, repo_name=None, setup_commands
             return str(maybe_bytes)
 
     # Skip the persistent shell approach for now due to async stream complexity
-    print("🔍 Modal's async streams require complex async handling")
+    print("🔍 async streams require complex async handling")
     print("🔄 Switching to individual command execution approach for reliability...")
     
     # Initialize state tracking variables
@@ -2013,7 +2013,7 @@ cd "{current_dir}"
         f.write(container_id)
 
     # Print connection instructions
-    print(f"✅ Modal sandbox created successfully!")
+    print(f"✅ Sandbox created successfully!")
     print(f"📋 Sandbox ID: {sandbox_id}")
     print(f"📋 Container ID: {container_id}")
     if volume:
@@ -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
@@ -2246,12 +2246,12 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
         print("🔍 DEBUG: Checking environment variables")
         modal_token_id = os.environ.get("MODAL_TOKEN_ID")
         modal_token = os.environ.get("MODAL_TOKEN")
-        print(f"🔍 MODAL_TOKEN_ID exists: {'Yes' if modal_token_id else 'No'}")
-        print(f"🔍 MODAL_TOKEN exists: {'Yes' if modal_token else 'No'}")
+        print(f"🔍 token exists: {'Yes' if modal_token_id else 'No'}")
+        print(f"🔍 token exists: {'Yes' if modal_token else 'No'}")
         if modal_token_id:
-            print(f"🔍 MODAL_TOKEN_ID length: {len(modal_token_id)}")
+            print(f"🔍 token length: {len(modal_token_id)}")
         if modal_token:
-            print(f"🔍 MODAL_TOKEN length: {len(modal_token)}")
+            print(f"🔍 token length: {len(modal_token)}")
         
         # Try to access Modal token to check authentication
         try:
@@ -2262,13 +2262,13 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
                 # Try to get from MODAL_TOKEN
                 modal_token = os.environ.get("MODAL_TOKEN")
                 if modal_token:
-                    print("✅ Found token in MODAL_TOKEN environment variable")
+                    print("✅ Found token in environment variable")
                     os.environ["MODAL_TOKEN_ID"] = modal_token
                     modal_token_id = modal_token
-                    print(f"✅ Set MODAL_TOKEN_ID from MODAL_TOKEN (length: {len(modal_token)})")
+                    print(f"✅ Set token (length: {len(modal_token)})")
             
             if modal_token_id:
-                print(f"✅ Modal token found (length: {len(modal_token_id)})")
+                print(f"✅ token found (length: {len(modal_token_id)})")
                 
                 # Use the comprehensive fix_modal_token script
                 try:
@@ -2289,11 +2289,11 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
                         if result.stderr:
                             print(f"Error: {result.stderr}")
                             
-                    print(f"✅ Modal token setup completed")
+                    print(f"✅ token setup completed")
                 except Exception as e:
                     print(f"⚠️ Error running fix_modal_token.py: {e}")
             else:
-                print("❌ No Modal token found in environment variables")
+                print("❌ No token found in environment variables")
                 # Try to get from file as a last resort
                 try:
                     home_dir = os.path.expanduser("~")
@@ -2312,7 +2312,7 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
                             else:
                                 print("❌ Token file does not contain token_id")
                     else:
-                        print("❌ Modal token file not found")
+                        print("❌ token file not found")
                 except Exception as e:
                     print(f"❌ Error loading token from file: {e}")
                 
@@ -2326,9 +2326,9 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
             modal_token_id = os.environ.get("MODAL_TOKEN_ID")
             modal_token = os.environ.get("MODAL_TOKEN")
             if modal_token_id:
-                print(f"🔄 Using MODAL_TOKEN_ID from environment (length: {len(modal_token_id)})")
+                print(f"🔄 Using token from environment (length: {len(modal_token_id)})")
             elif modal_token:
-                print(f"🔄 Using MODAL_TOKEN from environment (length: {len(modal_token)})")
+                print(f"🔄 Using token from environment (length: {len(modal_token)})")
                 os.environ["MODAL_TOKEN_ID"] = modal_token
                 modal_token_id = modal_token
             else:
@@ -2338,7 +2338,7 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
             # Set it in both environment variables
             os.environ["MODAL_TOKEN_ID"] = modal_token_id
             os.environ["MODAL_TOKEN"] = modal_token_id
-            print("✅ Set both MODAL_TOKEN_ID and MODAL_TOKEN environment variables")
+            print("✅ Set both token and id environment variables")
     except Exception as e:
         print(f"⚠️ Error checking Modal authentication: {e}")
         print("Continuing anyway, but Modal operations may fail")
@@ -2364,7 +2364,7 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
         gpu_type = 'A10G'
     
     gpu_spec = gpu_configs[gpu_type]
-    print(f"🚀 Creating Modal SSH container with {gpu_spec['gpu']} GPU ({gpu_spec['memory']}GB VRAM)")
+    print(f"🚀 Creating SSH container with {gpu_spec['gpu']} GPU ({gpu_spec['memory']}GB VRAM)")
     
     # Generate or use provided SSH password
     if not ssh_password:
@@ -2400,16 +2400,16 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
     # Print debug info for authentication
     print("🔍 Modal authentication debug info:")
     modal_token = os.environ.get("MODAL_TOKEN_ID")
-    print(f"  - MODAL_TOKEN_ID in env: {'Yes' if modal_token else 'No'}")
+    print(f"  - token in env: {'Yes' if modal_token else 'No'}")
     print(f"  - Token length: {len(modal_token) if modal_token else 'N/A'}")
     
     # Verify we can create a Modal app
     try:
-        print("🔍 Testing Modal app creation...")
+        print("🔍 Testing app creation...")
         app = modal.App(app_name)
-        print("✅ Created Modal app successfully")
+        print("✅ Created app successfully")
     except Exception as e:
-        print(f"❌ Error creating Modal app: {e}")
+        print(f"❌ Error creating app: {e}")
         return None
 
     # Create SSH-enabled image
@@ -2618,32 +2618,44 @@ def fetch_setup_commands_from_api(repo_url):
             else:
                 print(f"✅ GitIngest analysis completed successfully")
                 
-                # Read the output file - note that the default format might not be JSON
+                # Read the output file - GitIngest outputs structured text, not 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)
+                    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)
@@ -2660,10 +2672,10 @@ def fetch_setup_commands_from_api(repo_url):
         
         print(f"📤 API Request payload prepared (GitIngest data size: {len(json.dumps(gitingest_data))} bytes)")
         
-        # Make the API request
+        # Make the API request with a shorter timeout to avoid long waits
         print(f"🌐 Making POST request to: {api_url}")
         try:
-            response = requests.post(api_url, json=payload, timeout=60)
+            response = requests.post(api_url, json=payload, timeout=30)  # Reduced timeout to 30 seconds
             
             print(f"📥 API Response status code: {response.status_code}")
             
@@ -2708,43 +2720,68 @@ def fetch_setup_commands_from_api(repo_url):
                         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)
+                        
+                        # 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("⚠️ The server took too long to respond. Using fallback commands instead.")
-                # Return fallback commands
-                return generate_fallback_commands(gitingest_data)
+                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"Error response: {response.text[:500]}...")
-                # Return fallback commands
-                return generate_fallback_commands(gitingest_data)
+                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("❌ 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)
+            print(f"❌ API request timed out after 30 seconds")
+            print(f"⚠️ The server took too long to respond. Using fallback commands instead.")
+            
+            # Generate fallback commands based on the gitingest data
+            print("\n" + "="*80)
+            print("📋 GENERATING FALLBACK SETUP COMMANDS")
+            print("="*80)
+            fallback_commands = generate_fallback_commands(gitingest_data)
+            return fallback_commands
+        except Exception as e:
+            print(f"❌ Error making API request: {e}")
+            
+            # Generate fallback commands based on the gitingest data
+            print("\n" + "="*80)
+            print("📋 GENERATING FALLBACK SETUP COMMANDS")
+            print("="*80)
+            fallback_commands = generate_fallback_commands(gitingest_data)
+            return fallback_commands
     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"""
@@ -3302,33 +3339,33 @@ Respond with only 'NAVIGATE' if navigation makes sense, or 'SKIP' if it's redund
         return None
 
 def cleanup_modal_token():
-    """Delete Modal token files and environment variables after SSH container is started"""
-    print("🧹 Cleaning up Modal token for security...")
+    """Delete token files and environment variables after SSH container is started"""
+    print("🧹 Cleaning up tokens for security...")
     
     try:
         # Remove token from environment variables
         if "MODAL_TOKEN_ID" in os.environ:
             del os.environ["MODAL_TOKEN_ID"]
-            print("✅ Removed MODAL_TOKEN_ID from environment")
+            # print("✅ Removed token ID from environment")
         
         if "MODAL_TOKEN" in os.environ:
             del os.environ["MODAL_TOKEN"]
-            print("✅ Removed MODAL_TOKEN from environment")
+            # print("✅ Removed token from environment")
             
         if "MODAL_TOKEN_SECRET" in os.environ:
             del os.environ["MODAL_TOKEN_SECRET"]
-            print("✅ Removed MODAL_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 Modal token file at {modal_toml}")
+            # print(f"✅ Deleted token file at {modal_toml}")
         
-        print("✅ Modal token cleanup completed successfully")
+        # print("✅ Token cleanup completed successfully")
     except Exception as e:
-        print(f"❌ Error during Modal token cleanup: {e}")
+        print(f"❌ Error during token cleanup: {e}")
 
 def show_usage_examples():
     """Display usage examples for the script."""
@@ -3492,12 +3529,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())