gitarsenal-cli 1.4.5 → 1.4.7

package/package.json

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

package/python/gitarsenal.py

@@ -126,6 +126,7 @@ def main():
     ssh_parser.add_argument("--timeout", type=int, default=60, help="Container timeout in minutes (default: 60)")
     ssh_parser.add_argument("--use-proxy", action="store_true", help="Use Modal proxy service instead of direct Modal API")
     ssh_parser.add_argument("--wait", action="store_true", help="Wait for container to be ready")
+    ssh_parser.add_argument("--interactive", action="store_true", help="Run in interactive mode with prompts")
     
     # Sandbox command
     sandbox_parser = subparsers.add_parser("sandbox", help="Create a Modal sandbox")
@@ -195,7 +196,8 @@ def main():
                     repo_url=args.repo_url,
                     repo_name=args.repo_name,
                     volume_name=args.volume_name,
-                    timeout_minutes=args.timeout
+                    timeout_minutes=args.timeout,
+                    interactive=args.interactive
                 )
                 if result:
                     print("✅ SSH container created successfully")

package/python/test_modalSandboxScript.py

@@ -13,7 +13,7 @@ import argparse
 from pathlib import Path
 
 # Parse command-line arguments
-parser = argparse.ArgumentParser(description='Launch a Modal sandbox')
+parser = argparse.ArgumentParser()
 parser.add_argument('--proxy-url', help='URL of the proxy server')
 parser.add_argument('--proxy-api-key', help='API key for the proxy server')
 parser.add_argument('--gpu', default='A10G', help='GPU type to use')
@@ -720,85 +720,85 @@ Do not provide any explanations, just the exact command to run.
         print(f"❌ All model attempts failed. Last error: {last_error}")
         return None
     
-            # Process the response
-        try:
-            fix_command = result["choices"][0]["message"]["content"].strip()
-            
-            # Save the original response for debugging
-            original_response = fix_command
+    # Process the response
+    try:
+        fix_command = result["choices"][0]["message"]["content"].strip()
+        
+        # Save the original response for debugging
+        original_response = fix_command
+        
+        # Extract just the command if it's wrapped in backticks or explanation
+        if "```" in fix_command:
+            # Extract content between backticks
+            import re
+            code_blocks = re.findall(r'```(?:bash|sh)?\s*(.*?)\s*```', fix_command, re.DOTALL)
+            if code_blocks:
+                fix_command = code_blocks[0].strip()
+                print(f"✅ Extracted command from code block: {fix_command}")
+        
+        # If the response still has explanatory text, try to extract just the command
+        if len(fix_command.split('\n')) > 1:
+            # First try to find lines that look like commands (start with common command prefixes)
+            command_prefixes = ['sudo', 'apt', 'pip', 'npm', 'yarn', 'git', 'cd', 'mv', 'cp', 'rm', 'mkdir', 'touch', 
+                              'chmod', 'chown', 'echo', 'cat', 'python', 'python3', 'node', 'export',
+                              'curl', 'wget', 'docker', 'make', 'gcc', 'g++', 'javac', 'java',
+                              'conda', 'uv', 'poetry', 'nvm', 'rbenv', 'pyenv', 'rustup']
             
-            # Extract just the command if it's wrapped in backticks or explanation
-            if "```" in fix_command:
-                # Extract content between backticks
-                import re
-                code_blocks = re.findall(r'```(?:bash|sh)?\s*(.*?)\s*```', fix_command, re.DOTALL)
-                if code_blocks:
-                    fix_command = code_blocks[0].strip()
-                    print(f"✅ Extracted command from code block: {fix_command}")
+            # Check for lines that start with common command prefixes
+            command_lines = [line.strip() for line in fix_command.split('\n') 
+                           if any(line.strip().startswith(prefix) for prefix in command_prefixes)]
             
-            # If the response still has explanatory text, try to extract just the command
-            if len(fix_command.split('\n')) > 1:
-                # First try to find lines that look like commands (start with common command prefixes)
-                command_prefixes = ['sudo', 'apt', 'pip', 'npm', 'yarn', 'git', 'cd', 'mv', 'cp', 'rm', 'mkdir', 'touch', 
-                                  'chmod', 'chown', 'echo', 'cat', 'python', 'python3', 'node', 'export',
-                                  'curl', 'wget', 'docker', 'make', 'gcc', 'g++', 'javac', 'java',
-                                  'conda', 'uv', 'poetry', 'nvm', 'rbenv', 'pyenv', 'rustup']
-                
-                # Check for lines that start with common command prefixes
+            if command_lines:
+                # Use the first command line found
+                fix_command = command_lines[0]
+                print(f"✅ Identified command by prefix: {fix_command}")
+            else:
+                # Try to find lines that look like commands (contain common shell patterns)
+                shell_patterns = [' | ', ' > ', ' >> ', ' && ', ' || ', ' ; ', '$(',  '`', ' -y ', ' --yes ']
                 command_lines = [line.strip() for line in fix_command.split('\n') 
-                               if any(line.strip().startswith(prefix) for prefix in command_prefixes)]
+                              if any(pattern in line for pattern in shell_patterns)]
                 
                 if command_lines:
                     # Use the first command line found
                     fix_command = command_lines[0]
-                    print(f"✅ Identified command by prefix: {fix_command}")
+                    print(f"✅ Identified command by shell pattern: {fix_command}")
                 else:
-                    # Try to find lines that look like commands (contain common shell patterns)
-                    shell_patterns = [' | ', ' > ', ' >> ', ' && ', ' || ', ' ; ', '$(',  '`', ' -y ', ' --yes ']
-                    command_lines = [line.strip() for line in fix_command.split('\n') 
-                                  if any(pattern in line for pattern in shell_patterns)]
-                    
-                    if command_lines:
-                        # Use the first command line found
-                        fix_command = command_lines[0]
-                        print(f"✅ Identified command by shell pattern: {fix_command}")
-                    else:
-                        # Fall back to the shortest non-empty line as it's likely the command
-                        lines = [line.strip() for line in fix_command.split('\n') if line.strip()]
-                        if lines:
-                            # Exclude very short lines that are likely not commands
-                            valid_lines = [line for line in lines if len(line) > 5]
-                            if valid_lines:
-                                fix_command = min(valid_lines, key=len)
-                            else:
-                                fix_command = min(lines, key=len)
-                            print(f"✅ Selected shortest line as command: {fix_command}")
-            
-            # Clean up the command - remove any trailing periods or quotes
-            fix_command = fix_command.rstrip('.;"\'')
-            
-            # Remove common prefixes that LLMs sometimes add
-            prefixes_to_remove = [
-                "Run: ", "Execute: ", "Try: ", "Command: ", "Fix: ", "Solution: ",
-                "You should run: ", "You can run: ", "You need to run: "
-            ]
-            for prefix in prefixes_to_remove:
-                if fix_command.startswith(prefix):
-                    fix_command = fix_command[len(prefix):].strip()
-                    print(f"✅ Removed prefix: {prefix}")
-                    break
-            
-            # If the command is still multi-line or very long, it might not be a valid command
-            if len(fix_command.split('\n')) > 1 or len(fix_command) > 500:
-                print("⚠️ Extracted command appears invalid (multi-line or too long)")
-                print("🔍 Original response from LLM:")
-                print("-" * 60)
-                print(original_response)
-                print("-" * 60)
-                print("⚠️ Using best guess for command")
-            
-            print(f"🔧 Suggested fix: {fix_command}")
-            return fix_command
+                    # Fall back to the shortest non-empty line as it's likely the command
+                    lines = [line.strip() for line in fix_command.split('\n') if line.strip()]
+                    if lines:
+                        # Exclude very short lines that are likely not commands
+                        valid_lines = [line for line in lines if len(line) > 5]
+                        if valid_lines:
+                            fix_command = min(valid_lines, key=len)
+                        else:
+                            fix_command = min(lines, key=len)
+                        print(f"✅ Selected shortest line as command: {fix_command}")
+        
+        # Clean up the command - remove any trailing periods or quotes
+        fix_command = fix_command.rstrip('.;"\'')
+        
+        # Remove common prefixes that LLMs sometimes add
+        prefixes_to_remove = [
+            "Run: ", "Execute: ", "Try: ", "Command: ", "Fix: ", "Solution: ",
+            "You should run: ", "You can run: ", "You need to run: "
+        ]
+        for prefix in prefixes_to_remove:
+            if fix_command.startswith(prefix):
+                fix_command = fix_command[len(prefix):].strip()
+                print(f"✅ Removed prefix: {prefix}")
+                break
+        
+        # If the command is still multi-line or very long, it might not be a valid command
+        if len(fix_command.split('\n')) > 1 or len(fix_command) > 500:
+            print("⚠️ Extracted command appears invalid (multi-line or too long)")
+            print("🔍 Original response from LLM:")
+            print("-" * 60)
+            print(original_response)
+            print("-" * 60)
+            print("⚠️ Using best guess for command")
+        
+        print(f"🔧 Suggested fix: {fix_command}")
+        return fix_command
     except Exception as e:
         print(f"❌ Error processing OpenAI response: {e}")
         return None
@@ -2583,9 +2583,39 @@ def ssh_container_function(ssh_password, repo_url=None, repo_name=None, setup_co
 # Now modify the create_modal_ssh_container function to use the standalone ssh_container_function
 
 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):
+                               volume_name=None, timeout_minutes=60, ssh_password=None, interactive=False):
     """Create a Modal SSH container with GPU support and tunneling"""
     
+    # Use interactive mode if specified
+    if interactive:
+        # If GPU type is not specified, prompt for it
+        if not gpu_type:
+            gpu_type = prompt_for_gpu()
+            
+        # If repo URL is not specified, prompt for it
+        if not repo_url:
+            try:
+                repo_url = input("? Enter GitHub repository URL: ").strip()
+                if not repo_url:
+                    print("❌ Repository URL is required.")
+                    return None
+            except KeyboardInterrupt:
+                print("\n🛑 Setup cancelled.")
+                return None
+                
+        # If volume name is not specified, ask about persistent volume
+        if not volume_name:
+            try:
+                use_volume = input("? Use persistent volume for faster installs? (Y/n): ").strip().lower()
+                if use_volume in ('', 'y', 'yes'):
+                    volume_name = input("? Enter volume name: ").strip()
+                    if not volume_name:
+                        volume_name = "gitarsenal-volume"
+                        print(f"Using default volume name: {volume_name}")
+            except KeyboardInterrupt:
+                print("\n🛑 Setup cancelled.")
+                return None
+    
     # Check if Modal is authenticated
     try:
         # Print all environment variables for debugging
@@ -4064,13 +4094,74 @@ def get_setup_commands_from_gitingest(repo_url):
     print("❌ All API endpoints failed")
     return generate_fallback_commands(gitingest_data)
 
+def prompt_for_gpu():
+    """
+    Prompt the user to select a GPU type from available options.
+    Returns the selected GPU type.
+    """
+    # Define available GPU types and their specifications
+    gpu_specs = {
+        'T4': {'gpu': 'T4', 'memory': '16GB'},
+        'L4': {'gpu': 'L4', 'memory': '24GB'},
+        'A10G': {'gpu': 'A10G', 'memory': '24GB'},
+        'A100-40GB': {'gpu': 'A100-SXM4-40GB', 'memory': '40GB'},
+        'A100-80GB': {'gpu': 'A100-80GB', 'memory': '80GB'},
+        'L40S': {'gpu': 'L40S', 'memory': '48GB'},
+        'H100': {'gpu': 'H100', 'memory': '80GB'},
+        'H200': {'gpu': 'H200', 'memory': '141GB'},
+        'B200': {'gpu': 'B200', 'memory': '141GB'}
+    }
+    
+    print("\n📊 Available GPU Options:")
+    print("┌─────────────┬──────────┐")
+    print("│ GPU Type    │ Memory   │")
+    print("├─────────────┼──────────┤")
+    
+    # Create a list to keep track of valid options
+    options = []
+    
+    # Display GPU options
+    for i, (gpu_type, specs) in enumerate(gpu_specs.items(), 1):
+        options.append(gpu_type)
+        print(f"│ {i}. {gpu_type:<8} │ {specs['memory']:<7} │")
+    
+    print("└─────────────┴──────────┘")
+    
+    # Prompt for selection
+    while True:
+        try:
+            choice = input("\n🔍 Select GPU type (number or name, default is A10G): ").strip()
+            
+            # Default to A10G if empty
+            if not choice:
+                return "A10G"
+            
+            # Check if input is a number
+            if choice.isdigit():
+                index = int(choice) - 1
+                if 0 <= index < len(options):
+                    return options[index]
+                else:
+                    print(f"❌ Invalid selection. Please enter a number between 1 and {len(options)}.")
+            # Check if input is a valid GPU type
+            elif choice in options:
+                return choice
+            else:
+                print(f"❌ Invalid GPU type. Please select from the available options.")
+        except KeyboardInterrupt:
+            print("\n🛑 Selection cancelled.")
+            sys.exit(1)
+        except Exception as e:
+            print(f"❌ Error: {e}")
+
+# Replace the existing GPU argument parsing in the main section
 if __name__ == "__main__":
     # Parse command line arguments when script is run directly
     import argparse
     import sys
     
-    parser = argparse.ArgumentParser(description='Create a Modal SSH container with GPU')
-    parser.add_argument('--gpu', type=str, default='A10G', help='GPU type (default: A10G)')
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--gpu', type=str, help='GPU type (e.g., A10G, T4, A100-80GB)')
     parser.add_argument('--repo-url', type=str, help='Repository URL to clone')
     parser.add_argument('--repo-name', type=str, help='Repository name override')
     parser.add_argument('--setup-commands', type=str, nargs='+', help='Setup commands to run (deprecated)')
@@ -4085,20 +4176,105 @@ if __name__ == "__main__":
     parser.add_argument('--use-gitingest', action='store_true', default=True, help='Use gitingest approach to fetch setup commands (default)')
     parser.add_argument('--no-gitingest', action='store_true', help='Disable gitingest approach for setup commands')
     parser.add_argument('--show-examples', action='store_true', help='Show usage examples')
+    parser.add_argument('--list-gpus', action='store_true', help='List available GPU types with their specifications')
+    parser.add_argument('--interactive', action='store_true', help='Run in interactive mode with prompts')
     
     args = parser.parse_args()
     
+    # If --list-gpus is specified, just show GPU options and exit
+    if args.list_gpus:
+        prompt_for_gpu()
+        sys.exit(0)
+    
     # If no arguments or only --show-examples is provided, show usage examples
     if len(sys.argv) == 1 or args.show_examples:
         show_usage_examples()
         sys.exit(0)
     
+    # Check for dependencies
+    print("⠏ Checking dependencies...")
+    print("--- Dependency Check ---")
+    
+    # Check Python version
+    python_version = sys.version.split()[0]
+    print(f"✓ Python {python_version} found")
+    
+    # Check Modal CLI
+    try:
+        subprocess.run(["modal", "--version"], check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        print("✓ Modal CLI found")
+    except (subprocess.SubprocessError, FileNotFoundError):
+        print("❌ Modal CLI not found. Please install with: pip install modal")
+    
+    # Check Gitingest CLI
+    try:
+        subprocess.run(["gitingest", "--help"], check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        print("✓ Gitingest CLI found")
+    except (subprocess.SubprocessError, FileNotFoundError):
+        print("⚠️ Gitingest CLI not found (optional)")
+    
+    # Check Git
+    try:
+        subprocess.run(["git", "--version"], check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        print("✓ Git found")
+    except (subprocess.SubprocessError, FileNotFoundError):
+        print("❌ Git not found. Please install Git.")
+    
+    print("------------------------")
+    print("\n✔ Dependencies checked")
+    
+    # Always prompt for GPU selection regardless of interactive mode
+    gpu_type = prompt_for_gpu()
+    args.gpu = gpu_type
+    
+    # Interactive mode or missing required arguments
+    if args.interactive or not args.repo_url or not args.volume_name:
+        # Get repository URL if not provided
+        repo_url = args.repo_url
+        if not repo_url:
+            try:
+                repo_url = input("? Enter GitHub repository URL: ").strip()
+                if not repo_url:
+                    print("❌ Repository URL is required.")
+                    sys.exit(1)
+            except KeyboardInterrupt:
+                print("\n🛑 Setup cancelled.")
+                sys.exit(1)
+        
+        # Ask about persistent volume
+        volume_name = args.volume_name
+        if not volume_name:
+            try:
+                use_volume = input("? Use persistent volume for faster installs? (Y/n): ").strip().lower()
+                if use_volume in ('', 'y', 'yes'):
+                    volume_name = input("? Enter volume name: ").strip()
+                    if not volume_name:
+                        volume_name = "gitarsenal-volume"
+                        print(f"Using default volume name: {volume_name}")
+            except KeyboardInterrupt:
+                print("\n🛑 Setup cancelled.")
+                sys.exit(1)
+        
+        # Ask about setup commands
+        use_gitingest = args.use_gitingest and not args.no_gitingest
+        if not args.use_api and not args.setup_commands and not args.setup_commands_json:
+            try:
+                auto_detect = input("? Automatically detect setup commands for this repository? (Y/n): ").strip().lower()
+                if auto_detect in ('n', 'no'):
+                    use_gitingest = False
+            except KeyboardInterrupt:
+                print("\n🛑 Setup cancelled.")
+                sys.exit(1)
+        
+        # Update args with interactive values
+        args.repo_url = repo_url
+        args.volume_name = volume_name
+        args.use_gitingest = use_gitingest
+    
     try:    
         # Get setup commands from file if specified
         setup_commands = args.setup_commands or []
         
-        # If --use-api flag is set and repo_url is provided, fetch setup commands from API
-        
         # Use gitingest by default unless --no-gitingest is set
         if args.repo_url and (args.use_gitingest and not args.no_gitingest):
             print("🔄 Using gitingest approach to fetch setup commands (default)")
@@ -4215,7 +4391,8 @@ if __name__ == "__main__":
             setup_commands=setup_commands,
             volume_name=args.volume_name,
             timeout_minutes=args.timeout,
-            ssh_password=ssh_password
+            ssh_password=ssh_password,
+            interactive=args.interactive
         )
     except KeyboardInterrupt:
         # print("\n\n🛑 Execution interrupted")