gitarsenal-cli 1.9.80 → 1.9.82

package/.venv_status.json

@@ -1 +1 @@
-{"created":"2025-08-18T04:28:55.195Z","packages":["modal","gitingest","requests","anthropic"],"uv_version":"uv 0.8.4 (Homebrew 2025-07-30)"}
+{"created":"2025-08-18T07:17:19.626Z","packages":["modal","gitingest","requests","anthropic"],"uv_version":"uv 0.8.4 (Homebrew 2025-07-30)"}

package/bin/gitarsenal.js

@@ -89,7 +89,7 @@ function activateVirtualEnvironment() {
   process.env.PYTHON_EXECUTABLE = pythonPath;
   process.env.PIP_EXECUTABLE = pipPath;
   
-  console.log(chalk.green('✅ Virtual environment activated successfully'));
+  // console.log(chalk.green('✅ Virtual environment activated successfully'));
   
   return true;
 }
@@ -629,7 +629,7 @@ async function fetchFullSetupAndRecs(repoUrl, storedCredentials = null) {
 
     for (const url of endpoints) {
       try {
-        spinner.text = `Analyzing repository: ${url}`;
+        spinner.text = `Analyzing repository...`;
         const res = await fetch(url, {
           method: 'POST',
           headers: { 'Content-Type': 'application/json', 'User-Agent': 'GitArsenal-CLI/1.0' },

package/lib/sandbox.js

@@ -34,6 +34,7 @@ function getPythonScriptPath() {
  * @param {string} options.volumeName - Volume name
  * @param {Array<string>} options.setupCommands - Setup commands
  * @param {boolean} options.showExamples - Whether to show usage examples
+ * @param {Object} options.analysisData - Repository analysis data from best_gpu endpoint
  * @returns {Promise<void>}
  */
 async function runContainer(options) {
@@ -47,7 +48,8 @@ async function runContainer(options) {
     yes = false,
     userId,
     userName,
-    userEmail
+    userEmail,
+    analysisData
   } = options;
   
   // Get the path to the Python script
@@ -116,6 +118,12 @@ async function runContainer(options) {
     args.push('--display-name', userName);
     // console.log(chalk.gray(`🔍 Debug: Passing user credentials to Python script`));
   }
+
+  // Add analysis data if provided
+  if (analysisData) {
+    args.push('--analysis-data', JSON.stringify(analysisData));
+    console.log(chalk.gray(`🔍 Debug: Passing analysis data to Python script`));
+  }
   
   // Handle manual setup commands if provided
   if (setupCommands.length > 0) {

package/package.json

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

package/python/test_modalSandboxScript.py

@@ -38,6 +38,154 @@ def get_stored_credentials():
         return {}
 
 
+def parse_analysis_data(analysis_data_json):
+    """Parse analysis data JSON string and return structured data"""
+    if not analysis_data_json:
+        return None
+    
+    try:
+        import json
+        analysis_data = json.loads(analysis_data_json)
+        return analysis_data
+    except json.JSONDecodeError as e:
+        print(f"⚠️ Error parsing analysis data: {e}")
+        return None
+    except Exception as e:
+        print(f"⚠️ Unexpected error parsing analysis data: {e}")
+        return None
+
+
+def select_base_image_from_analysis(analysis_data):
+    """Select the appropriate Docker base image based on CUDA recommendations from analysis"""
+    # Default fallback image
+    default_image = "nvidia/cuda:12.4.1-devel-ubuntu22.04"
+    default_python = "3.11"
+    
+    if not analysis_data:
+        print("🐳 No analysis data available, using default CUDA image")
+        return default_image, default_python
+    
+    # Extract CUDA recommendation
+    cuda_rec = analysis_data.get('cudaRecommendation', {})
+    if not cuda_rec:
+        print("🐳 No CUDA recommendation found, using default CUDA image")
+        return default_image, default_python
+    
+    recommended_cuda = cuda_rec.get('recommendedCudaVersion', '')
+    docker_image = cuda_rec.get('dockerImage', '')
+    
+    print(f"🔍 CUDA Analysis Results:")
+    print(f"  - Recommended CUDA Version: {recommended_cuda}")
+    print(f"  - Recommended Docker Image: {docker_image}")
+    print(f"  - Full CUDA Recommendation: {cuda_rec}")
+    
+    # If a specific docker image is recommended, use it
+    if docker_image:
+        print(f"🔍 Validating recommended Docker image: {docker_image}")
+        # Validate that the recommended Docker image follows expected patterns
+        is_valid_image = False
+        
+        # Check if it's a pytorch image or other specialized image
+        if 'pytorch' in docker_image.lower():
+            print(f"🐳 Using PyTorch-optimized image: {docker_image}")
+            return docker_image, "3.11"  # PyTorch images usually have Python pre-installed
+        elif 'tensorflow' in docker_image.lower():
+            print(f"🐳 Using TensorFlow-optimized image: {docker_image}")
+            return docker_image, "3.11"
+        elif 'nvidia/cuda' in docker_image.lower():
+            # Instead of regex validation, use a whitelist of known good images
+            # This prevents using images that match the pattern but don't exist
+            known_good_images = {
+                # CUDA 12.x images
+                'nvidia/cuda:12.4.1-devel-ubuntu22.04',
+                'nvidia/cuda:12.4.1-runtime-ubuntu22.04',
+                'nvidia/cuda:12.3.2-devel-ubuntu22.04',
+                'nvidia/cuda:12.3.2-runtime-ubuntu22.04',
+                'nvidia/cuda:12.2.2-devel-ubuntu22.04',
+                'nvidia/cuda:12.2.2-runtime-ubuntu22.04',
+                'nvidia/cuda:12.1.0-devel-ubuntu22.04',
+                'nvidia/cuda:12.1.0-runtime-ubuntu22.04',
+                'nvidia/cuda:12.0.1-devel-ubuntu22.04',
+                # CUDA 11.x images
+                'nvidia/cuda:11.8.0-devel-ubuntu22.04',
+                'nvidia/cuda:11.8.0-runtime-ubuntu22.04',
+                'nvidia/cuda:11.8.0-cudnn8-devel-ubuntu22.04',
+                'nvidia/cuda:11.8.0-cudnn8-runtime-ubuntu22.04',
+                'nvidia/cuda:11.7.1-devel-ubuntu22.04',
+                'nvidia/cuda:11.7.1-runtime-ubuntu22.04',
+                'nvidia/cuda:11.7.1-cudnn8-devel-ubuntu22.04',
+                'nvidia/cuda:11.7.1-cudnn8-runtime-ubuntu22.04',
+                'nvidia/cuda:11.6.2-devel-ubuntu20.04',
+                'nvidia/cuda:11.6.2-runtime-ubuntu20.04',
+            }
+            
+            if docker_image.lower() in known_good_images:
+                print(f"🐳 Using verified NVIDIA CUDA image: {docker_image}")
+                return docker_image, "3.11"
+            else:
+                print(f"⚠️ NVIDIA CUDA image not in whitelist: {docker_image}")
+                print(f"🔄 Falling back to CUDA version mapping...")
+                # Continue to version mapping below
+        else:
+            print(f"🐳 Using custom recommended image: {docker_image}")
+            return docker_image, "3.11"
+    
+    # Map CUDA versions to appropriate base images
+    cuda_image_mapping = {
+        '12.4': 'nvidia/cuda:12.4.1-devel-ubuntu22.04',
+        '12.3': 'nvidia/cuda:12.3.2-devel-ubuntu22.04', 
+        '12.2': 'nvidia/cuda:12.2.2-devel-ubuntu22.04',
+        '12.1': 'nvidia/cuda:12.1.0-devel-ubuntu22.04',
+        '12.0': 'nvidia/cuda:12.0.1-devel-ubuntu22.04',
+        '11.8': 'nvidia/cuda:11.8.0-devel-ubuntu22.04',
+        '11.7': 'nvidia/cuda:11.7.1-devel-ubuntu22.04',
+        '11.6': 'nvidia/cuda:11.6.2-devel-ubuntu20.04',
+        # Add some runtime variants for better compatibility
+        '11.8-runtime': 'nvidia/cuda:11.8.0-runtime-ubuntu22.04',
+        '11.7-runtime': 'nvidia/cuda:11.7.1-runtime-ubuntu22.04',
+        '12.1-runtime': 'nvidia/cuda:12.1.0-runtime-ubuntu22.04',
+    }
+    
+    # Extract major.minor version from recommended CUDA version
+    if recommended_cuda:
+        # Handle versions like "12.4", "CUDA 12.4", "12.4.0", "11.8-runtime", etc.
+        import re
+        version_match = re.search(r'(\d+\.\d+)', recommended_cuda)
+        if version_match:
+            cuda_version = version_match.group(1)
+            
+            # First try exact match
+            if cuda_version in cuda_image_mapping:
+                selected_image = cuda_image_mapping[cuda_version]
+                print(f"🐳 Selected CUDA {cuda_version} image: {selected_image}")
+                return selected_image, "3.11"
+            
+            # Try with -runtime suffix if original recommended image was runtime
+            if 'runtime' in docker_image.lower() or 'runtime' in recommended_cuda.lower():
+                runtime_key = f"{cuda_version}-runtime"
+                if runtime_key in cuda_image_mapping:
+                    selected_image = cuda_image_mapping[runtime_key]
+                    print(f"🐳 Selected CUDA {cuda_version} runtime image: {selected_image}")
+                    return selected_image, "3.11"
+            
+            # If no exact match, try to find the closest version
+            available_versions = [v for v in cuda_image_mapping.keys() if not v.endswith('-runtime')]
+            available_versions.sort(reverse=True)  # Sort descending to prefer newer versions
+            
+            for available_version in available_versions:
+                if available_version.startswith(cuda_version.split('.')[0]):  # Same major version
+                    selected_image = cuda_image_mapping[available_version]
+                    print(f"🐳 Selected closest CUDA {available_version} image for requested {cuda_version}: {selected_image}")
+                    return selected_image, "3.11"
+            
+            print(f"⚠️ CUDA version {cuda_version} not in mapping, using default")
+        else:
+            print(f"⚠️ Could not parse CUDA version from: {recommended_cuda}")
+    
+    print(f"🐳 Using default CUDA image: {default_image}")
+    return default_image, default_python
+
+
 # Global SSH container function (must be at global scope for Modal)
 def ssh_container_function(ssh_password=None, repo_url=None, repo_name=None, setup_commands=None, openai_api_key=None, anthropic_api_key=None, stored_credentials=None):
     """Start SSH container with password authentication and intelligent repository setup using Agent."""
@@ -312,11 +460,13 @@ def ssh_container_function(ssh_password=None, repo_url=None, repo_name=None, set
 
 # Create Modal SSH container with GPU support and intelligent repository setup using Agent
 def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_commands=None, 
-                               volume_name=None, timeout_minutes=60, ssh_password=None, interactive=False, gpu_count=1):
+                               volume_name=None, timeout_minutes=60, ssh_password=None, interactive=False, gpu_count=1, analysis_data=None):
     """Create a Modal SSH container with GPU support and intelligent repository setup.
     
     When repo_url is provided, uses Agent for intelligent repository setup.
     The setup_commands parameter is maintained for backwards compatibility but ignored when using Agent.
+    Args:
+        analysis_data: Repository analysis data from best_gpu endpoint for dynamic image selection
     """
     
     # Use interactive mode if specified
@@ -468,14 +618,29 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
     # Get the gitarsenal-cli root directory for kill_claude files
     gitarsenal_root = os.path.dirname(current_dir)
     
-    # Choose base image to avoid CUDA segfault issues
-    print("⚠️ Using CUDA base image - this may cause segfaults on some systems")
-    base_image = modal.Image.from_registry("nvidia/cuda:12.4.0-devel-ubuntu22.04", add_python="3.11")
-    # base_image = modal.Image.debian_slim()
+    # Select base image dynamically based on analysis data
+    base_image_name, python_version = select_base_image_from_analysis(analysis_data)
+    print(f"🐳 Building image with: {base_image_name} (Python {python_version})")
+    
+    try:
+        base_image = modal.Image.from_registry(base_image_name, add_python=python_version)
+    except Exception as e:
+        print(f"⚠️ Failed to load recommended image {base_image_name}: {e}")
+        print("🐳 Falling back to default CUDA image")
+        base_image = modal.Image.from_registry("nvidia/cuda:12.4.1-devel-ubuntu22.04", add_python="3.11")
     
     # Build the SSH image with the chosen base
     ssh_image = (
         base_image
+        # Set timezone and debconf to non-interactive mode to prevent prompts
+        .env({"DEBIAN_FRONTEND": "noninteractive", "TZ": "UTC"})
+        .run_commands(
+            # Configure timezone and package management non-interactively
+            "ln -snf /usr/share/zoneinfo/UTC /etc/localtime",
+            "echo UTC > /etc/timezone",
+            # Configure dpkg to avoid interactive prompts
+            "echo 'debconf debconf/frontend select Noninteractive' | debconf-set-selections"
+        )
         .apt_install(
             "openssh-server", "sudo", "curl", "wget", "vim", "htop", "git", 
             "python3", "python3-pip"
@@ -907,6 +1072,9 @@ if __name__ == "__main__":
     parser.add_argument('--user-name', type=str, help='Username (passed from JavaScript CLI)')
     parser.add_argument('--display-name', type=str, help='Display name (passed from JavaScript CLI)')
     
+    # Analysis data argument (passed from JavaScript CLI)
+    parser.add_argument('--analysis-data', type=str, help='Repository analysis data as JSON string (from best_gpu endpoint)')
+    
     args = parser.parse_args()
     
     # Initialize tokens (import here to avoid container import issues)
@@ -1024,6 +1192,18 @@ if __name__ == "__main__":
         gpu_type = "A10G"
         args.gpu = gpu_type
     
+    # Parse analysis data if provided
+    analysis_data = None
+    if args.analysis_data:
+        print("🔍 Parsing repository analysis data...")
+        analysis_data = parse_analysis_data(args.analysis_data)
+        if analysis_data:
+            print("✅ Analysis data parsed successfully")
+        else:
+            print("⚠️ Failed to parse analysis data, proceeding without it")
+    else:
+        print("ℹ️ No analysis data provided")
+    
     # Display configuration after GPU selection
     print("\n📋 Container Configuration:")
     print(f"Repository URL: {args.repo_url or 'Not specified'}")
@@ -1202,6 +1382,7 @@ if __name__ == "__main__":
             ssh_password=ssh_password,
             interactive=args.interactive,
             gpu_count=getattr(args, 'gpu_count', 1),
+            analysis_data=analysis_data,  # Pass parsed analysis_data instead of raw args.analysis_data
         )
         
         if result: