gitarsenal-cli 1.8.3 → 1.8.4

package/package.json

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

package/python/test_modalSandboxScript.py

@@ -1616,7 +1616,6 @@ Consider the current directory, system information, directory contents, and avai
 IMPORTANT GUIDELINES:
 1. For any commands that might ask for yes/no confirmation, use the appropriate non-interactive flag:
    - For apt/apt-get: use -y or --yes
-   - For pip: use --no-input
    - For rm: use -f or --force
 
 2. If the error indicates a file is not found:
@@ -3860,6 +3859,152 @@ def prompt_for_gpu():
                 print("✅ Using default GPU: A10G")
                 return "A10G"
 
+
+
+def preprocess_commands_with_llm(setup_commands, stored_credentials, api_key=None):
+    """
+    Use LLM to preprocess setup commands and inject available credentials.
+    
+    Args:
+        setup_commands: List of setup commands
+        stored_credentials: Dictionary of stored credentials
+        api_key: OpenAI API key for LLM calls
+        
+    Returns:
+        List of processed commands with credentials injected
+    """
+    if not setup_commands or not stored_credentials:
+        return setup_commands
+    
+    try:
+        # Create context for the LLM
+        credentials_info = "\n".join([f"- {key}: {value[:8]}..." for key, value in stored_credentials.items()])
+        
+        prompt = f"""
+You are a command preprocessing assistant. Your task is to modify setup commands to use available credentials and make them non-interactive.
+
+AVAILABLE CREDENTIALS:
+{credentials_info}
+
+ORIGINAL COMMANDS:
+{chr(10).join([f"{i+1}. {cmd}" for i, cmd in enumerate(setup_commands)])}
+
+INSTRUCTIONS:
+1. Replace any authentication commands with token-based versions using available credentials
+2. Make all commands non-interactive (add --yes, --no-input, -y flags where needed)
+3. Use environment variables or direct token injection where appropriate
+4. Skip commands that cannot be made non-interactive due to missing credentials
+5. Add any necessary environment variable exports
+
+Return the modified commands as a JSON array of strings. If a command should be skipped, prefix it with "# SKIPPED: ".
+
+Example transformations:
+- "huggingface-cli login" → "huggingface-cli login --token $HUGGINGFACE_TOKEN"
+- "npm install" → "npm install --yes"
+
+Return only the JSON array, no other text.
+"""
+        
+        if not api_key:
+            print("⚠️ No OpenAI API key available for command preprocessing")
+            return setup_commands
+        
+        # Call OpenAI API
+        import openai
+        client = openai.OpenAI(api_key=api_key)
+        
+        response = client.chat.completions.create(
+            model="gpt-3.5-turbo",
+            messages=[
+                {"role": "system", "content": "You are a command preprocessing assistant that modifies setup commands to use available credentials and make them non-interactive."},
+                {"role": "user", "content": prompt}
+            ],
+            temperature=0.1,
+            max_tokens=2000
+        )
+        
+        result = response.choices[0].message.content.strip()
+        
+        # Debug: Print the raw response
+        print(f"🔍 LLM Response: {result[:200]}...")
+        
+        # Parse the JSON response
+        import json
+        try:
+            processed_commands = json.loads(result)
+            if isinstance(processed_commands, list):
+                print(f"🔧 LLM preprocessed {len(processed_commands)} commands")
+                for i, cmd in enumerate(processed_commands):
+                    if cmd != setup_commands[i]:
+                        print(f"  {i+1}. {setup_commands[i]} → {cmd}")
+                return processed_commands
+            else:
+                print("⚠️ LLM returned invalid format, using fallback preprocessing")
+                return fallback_preprocess_commands(setup_commands, stored_credentials)
+        except json.JSONDecodeError as e:
+            print(f"⚠️ Failed to parse LLM response: {e}")
+            print("🔄 Using fallback preprocessing...")
+            return fallback_preprocess_commands(setup_commands, stored_credentials)
+            
+    except Exception as e:
+        print(f"⚠️ LLM preprocessing failed: {e}")
+        print("🔄 Using fallback preprocessing...")
+        return fallback_preprocess_commands(setup_commands, stored_credentials)
+
+def fallback_preprocess_commands(setup_commands, stored_credentials):
+    """
+    Fallback preprocessing function that manually handles common credential injection patterns.
+    
+    Args:
+        setup_commands: List of setup commands
+        stored_credentials: Dictionary of stored credentials
+        
+    Returns:
+        List of processed commands with credentials injected
+    """
+    if not setup_commands or not stored_credentials:
+        return setup_commands
+    
+    processed_commands = []
+    
+    for i, command in enumerate(setup_commands):
+        processed_command = command
+        
+        # Handle Hugging Face login
+        if 'huggingface-cli login' in command and '--token' not in command:
+            if 'HUGGINGFACE_TOKEN' in stored_credentials:
+                processed_command = f"huggingface-cli login --token $HUGGINGFACE_TOKEN"
+                print(f"🔧 Fallback: Injected HF token into command {i+1}")
+            else:
+                processed_command = f"# SKIPPED: {command} (no HF token available)"
+                print(f"🔧 Fallback: Skipped command {i+1} (no HF token)")
+        
+        # Handle OpenAI API key
+        elif 'openai' in command.lower() and 'api_key' not in command.lower():
+            if 'OPENAI_API_KEY' in stored_credentials:
+                processed_command = f"export OPENAI_API_KEY=$OPENAI_API_KEY && {command}"
+                print(f"🔧 Fallback: Added OpenAI API key export to command {i+1}")
+        
+        # Handle npm install
+        elif 'npm install' in command and '--yes' not in command and '--no-interactive' not in command:
+            processed_command = command.replace('npm install', 'npm install --yes')
+            print(f"🔧 Fallback: Made npm install non-interactive in command {i+1}")
+        
+        # Handle git clone
+        elif command.strip().startswith('git clone') and '--depth 1' not in command:
+            processed_command = command.replace('git clone', 'git clone --depth 1')
+            print(f"🔧 Fallback: Made git clone non-interactive in command {i+1}")
+        
+        # Handle apt-get install
+        elif 'apt-get install' in command and '-y' not in command:
+            processed_command = command.replace('apt-get install', 'apt-get install -y')
+            print(f"🔧 Fallback: Made apt-get install non-interactive in command {i+1}")
+        
+        processed_commands.append(processed_command)
+    
+    print(f"🔧 Fallback preprocessing completed: {len(processed_commands)} commands")
+    return processed_commands
+
 # Replace the existing GPU argument parsing in the main section
 if __name__ == "__main__":
     # Parse command line arguments when script is run directly
@@ -4145,89 +4290,3 @@ if __name__ == "__main__":
         # print("🧹 Cleaning up resources...")
         cleanup_modal_token()
         sys.exit(1)
-
-def preprocess_commands_with_llm(setup_commands, stored_credentials, api_key=None):
-    """
-    Use LLM to preprocess setup commands and inject available credentials.
-    
-    Args:
-        setup_commands: List of setup commands
-        stored_credentials: Dictionary of stored credentials
-        api_key: OpenAI API key for LLM calls
-        
-    Returns:
-        List of processed commands with credentials injected
-    """
-    if not setup_commands or not stored_credentials:
-        return setup_commands
-    
-    try:
-        # Create context for the LLM
-        credentials_info = "\n".join([f"- {key}: {value[:8]}..." for key, value in stored_credentials.items()])
-        
-        prompt = f"""
-You are a command preprocessing assistant. Your task is to modify setup commands to use available credentials and make them non-interactive.
-
-AVAILABLE CREDENTIALS:
-{credentials_info}
-
-ORIGINAL COMMANDS:
-{chr(10).join([f"{i+1}. {cmd}" for i, cmd in enumerate(setup_commands)])}
-
-INSTRUCTIONS:
-1. Replace any authentication commands with token-based versions using available credentials
-2. Make all commands non-interactive (add --yes, --no-input, -y flags where needed)
-3. Use environment variables or direct token injection where appropriate
-4. Skip commands that cannot be made non-interactive due to missing credentials
-5. Add any necessary environment variable exports
-
-Return the modified commands as a JSON array of strings. If a command should be skipped, prefix it with "# SKIPPED: ".
-
-Example transformations:
-- "huggingface-cli login" → "huggingface-cli login --token $HUGGINGFACE_TOKEN"
-- "npm install" → "npm install --yes"
-- "pip install package" → "pip install package --no-input"
-
-Return only the JSON array, no other text.
-"""
-        
-        if not api_key:
-            print("⚠️ No OpenAI API key available for command preprocessing")
-            return setup_commands
-        
-        # Call OpenAI API
-        import openai
-        client = openai.OpenAI(api_key=api_key)
-        
-        response = client.chat.completions.create(
-            model="gpt-3.5-turbo",
-            messages=[
-                {"role": "system", "content": "You are a command preprocessing assistant that modifies setup commands to use available credentials and make them non-interactive."},
-                {"role": "user", "content": prompt}
-            ],
-            temperature=0.1,
-            max_tokens=2000
-        )
-        
-        result = response.choices[0].message.content.strip()
-        
-        # Parse the JSON response
-        import json
-        try:
-            processed_commands = json.loads(result)
-            if isinstance(processed_commands, list):
-                print(f"🔧 LLM preprocessed {len(processed_commands)} commands")
-                for i, cmd in enumerate(processed_commands):
-                    if cmd != setup_commands[i]:
-                        print(f"  {i+1}. {setup_commands[i]} → {cmd}")
-                return processed_commands
-            else:
-                print("⚠️ LLM returned invalid format, using original commands")
-                return setup_commands
-        except json.JSONDecodeError:
-            print("⚠️ Failed to parse LLM response, using original commands")
-            return setup_commands
-            
-    except Exception as e:
-        print(f"⚠️ LLM preprocessing failed: {e}")
-        return setup_commands

package/scripts/postinstall.js

@@ -15,42 +15,94 @@ const pythonScriptPath = path.join(pythonScriptDir, 'test_modalSandboxScript.py'
 // Path to the original Python script
 const originalScriptPath = path.join(__dirname, '..', '..', '..', 'mcp-server', 'src', 'utils', 'test_modalSandboxScript.py');
 
+// Function to check and install uv
+async function checkAndInstallUv() {
+  try {
+    // Check if uv is already installed
+    await execAsync('uv --version');
+    console.log(chalk.green('✅ uv is already installed'));
+    return true;
+  } catch (error) {
+    console.log(chalk.yellow('⚠️ uv not found. Attempting to install...'));
+    
+    // Try different methods to install uv
+    const installMethods = [
+      'curl -LsSf https://astral.sh/uv/install.sh | sh',
+      'pip install uv',
+      'pip3 install uv',
+      'cargo install uv'
+    ];
+    
+    for (const method of installMethods) {
+      try {
+        console.log(chalk.gray(`🔄 Trying to install uv with: ${method}`));
+        
+        if (method.includes('curl')) {
+          // For curl installation, we need to handle the shell script
+          await execAsync(method, { 
+            env: { ...process.env, SHELL: '/bin/bash' },
+            stdio: 'inherit'
+          });
+        } else {
+          await execAsync(method);
+        }
+        
+        // Verify installation
+        await execAsync('uv --version');
+        console.log(chalk.green('✅ uv installed successfully!'));
+        return true;
+      } catch (installError) {
+        console.log(chalk.gray(`⚠️ ${method} failed, trying next...`));
+      }
+    }
+    
+    console.log(chalk.yellow('⚠️ Could not install uv automatically'));
+    console.log(chalk.yellow('💡 Please install uv manually:'));
+    console.log(chalk.yellow('   curl -LsSf https://astral.sh/uv/install.sh | sh'));
+    console.log(chalk.yellow('   or: pip install uv'));
+    console.log(chalk.yellow('   or: cargo install uv'));
+    return false;
+  }
+}
+
 // Function to install Python packages
 async function installPythonPackages() {
   const packages = ['modal', 'gitingest', 'requests'];
   
   console.log(chalk.yellow(`📦 Installing Python packages: ${packages.join(', ')}`));
   
-  // Try different pip commands
-  const pipCommands = [
+  // Try uv first, then fall back to pip commands
+  const installCommands = [
+    'uv pip install',
     'pip3 install',
     'pip install', 
     'python -m pip install',
     'py -m pip install'
   ];
   
-  for (const pipCommand of pipCommands) {
+  for (const installCommand of installCommands) {
     try {
-      // Check if pip command exists
-      const [pipCmd] = pipCommand.split(' ');
-      await execAsync(`${pipCmd} --version`);
+      // Check if command exists
+      const [cmd] = installCommand.split(' ');
+      await execAsync(`${cmd} --version`);
       
-      console.log(chalk.gray(`🔄 Using: ${pipCommand}`));
+      console.log(chalk.gray(`🔄 Using: ${installCommand}`));
       
-      await execAsync(`${pipCommand} ${packages.join(' ')}`, { 
+      await execAsync(`${installCommand} ${packages.join(' ')}`, { 
         env: { ...process.env, PYTHONIOENCODING: 'utf-8' }
       });
       
       console.log(chalk.green('✅ Python packages installed successfully!'));
       return true;
     } catch (error) {
-      console.log(chalk.gray(`⚠️ ${pipCommand} failed, trying next...`));
+      console.log(chalk.gray(`⚠️ ${installCommand} failed, trying next...`));
     }
   }
   
   console.log(chalk.red('❌ Failed to install Python packages'));
   console.log(chalk.yellow('💡 Please run manually:'));
-  console.log(chalk.yellow('   pip install modal gitingest requests'));
+  console.log(chalk.yellow('   uv pip install modal gitingest requests'));
+  console.log(chalk.yellow('   or: pip install modal gitingest requests'));
   console.log(chalk.yellow('   or: pip3 install modal gitingest requests'));
   return false;
 }
@@ -105,6 +157,10 @@ async function postinstall() {
     console.log(chalk.blue('🔍 Checking Git installation...'));
     await checkGit();
     
+    // Check and install uv if needed
+    console.log(chalk.blue('🔍 Checking for uv package manager...'));
+    await checkAndInstallUv();
+    
     // Install Python packages
     console.log(chalk.blue('🔍 Installing Python dependencies...'));
     await installPythonPackages();

package/test_modalSandboxScript.py

@@ -1616,7 +1616,6 @@ Consider the current directory, system information, directory contents, and avai
 IMPORTANT GUIDELINES:
 1. For any commands that might ask for yes/no confirmation, use the appropriate non-interactive flag:
    - For apt/apt-get: use -y or --yes
-   - For pip: use --no-input
    - For rm: use -f or --force
 
 2. If the error indicates a file is not found:
@@ -3860,6 +3859,152 @@ def prompt_for_gpu():
                 print("✅ Using default GPU: A10G")
                 return "A10G"
 
+
+
+def preprocess_commands_with_llm(setup_commands, stored_credentials, api_key=None):
+    """
+    Use LLM to preprocess setup commands and inject available credentials.
+    
+    Args:
+        setup_commands: List of setup commands
+        stored_credentials: Dictionary of stored credentials
+        api_key: OpenAI API key for LLM calls
+        
+    Returns:
+        List of processed commands with credentials injected
+    """
+    if not setup_commands or not stored_credentials:
+        return setup_commands
+    
+    try:
+        # Create context for the LLM
+        credentials_info = "\n".join([f"- {key}: {value[:8]}..." for key, value in stored_credentials.items()])
+        
+        prompt = f"""
+You are a command preprocessing assistant. Your task is to modify setup commands to use available credentials and make them non-interactive.
+
+AVAILABLE CREDENTIALS:
+{credentials_info}
+
+ORIGINAL COMMANDS:
+{chr(10).join([f"{i+1}. {cmd}" for i, cmd in enumerate(setup_commands)])}
+
+INSTRUCTIONS:
+1. Replace any authentication commands with token-based versions using available credentials
+2. Make all commands non-interactive (add --yes, --no-input, -y flags where needed)
+3. Use environment variables or direct token injection where appropriate
+4. Skip commands that cannot be made non-interactive due to missing credentials
+5. Add any necessary environment variable exports
+
+Return the modified commands as a JSON array of strings. If a command should be skipped, prefix it with "# SKIPPED: ".
+
+Example transformations:
+- "huggingface-cli login" → "huggingface-cli login --token $HUGGINGFACE_TOKEN"
+- "npm install" → "npm install --yes"
+
+Return only the JSON array, no other text.
+"""
+        
+        if not api_key:
+            print("⚠️ No OpenAI API key available for command preprocessing")
+            return setup_commands
+        
+        # Call OpenAI API
+        import openai
+        client = openai.OpenAI(api_key=api_key)
+        
+        response = client.chat.completions.create(
+            model="gpt-3.5-turbo",
+            messages=[
+                {"role": "system", "content": "You are a command preprocessing assistant that modifies setup commands to use available credentials and make them non-interactive."},
+                {"role": "user", "content": prompt}
+            ],
+            temperature=0.1,
+            max_tokens=2000
+        )
+        
+        result = response.choices[0].message.content.strip()
+        
+        # Debug: Print the raw response
+        print(f"🔍 LLM Response: {result[:200]}...")
+        
+        # Parse the JSON response
+        import json
+        try:
+            processed_commands = json.loads(result)
+            if isinstance(processed_commands, list):
+                print(f"🔧 LLM preprocessed {len(processed_commands)} commands")
+                for i, cmd in enumerate(processed_commands):
+                    if cmd != setup_commands[i]:
+                        print(f"  {i+1}. {setup_commands[i]} → {cmd}")
+                return processed_commands
+            else:
+                print("⚠️ LLM returned invalid format, using fallback preprocessing")
+                return fallback_preprocess_commands(setup_commands, stored_credentials)
+        except json.JSONDecodeError as e:
+            print(f"⚠️ Failed to parse LLM response: {e}")
+            print("🔄 Using fallback preprocessing...")
+            return fallback_preprocess_commands(setup_commands, stored_credentials)
+            
+    except Exception as e:
+        print(f"⚠️ LLM preprocessing failed: {e}")
+        print("🔄 Using fallback preprocessing...")
+        return fallback_preprocess_commands(setup_commands, stored_credentials)
+
+def fallback_preprocess_commands(setup_commands, stored_credentials):
+    """
+    Fallback preprocessing function that manually handles common credential injection patterns.
+    
+    Args:
+        setup_commands: List of setup commands
+        stored_credentials: Dictionary of stored credentials
+        
+    Returns:
+        List of processed commands with credentials injected
+    """
+    if not setup_commands or not stored_credentials:
+        return setup_commands
+    
+    processed_commands = []
+    
+    for i, command in enumerate(setup_commands):
+        processed_command = command
+        
+        # Handle Hugging Face login
+        if 'huggingface-cli login' in command and '--token' not in command:
+            if 'HUGGINGFACE_TOKEN' in stored_credentials:
+                processed_command = f"huggingface-cli login --token $HUGGINGFACE_TOKEN"
+                print(f"🔧 Fallback: Injected HF token into command {i+1}")
+            else:
+                processed_command = f"# SKIPPED: {command} (no HF token available)"
+                print(f"🔧 Fallback: Skipped command {i+1} (no HF token)")
+        
+        # Handle OpenAI API key
+        elif 'openai' in command.lower() and 'api_key' not in command.lower():
+            if 'OPENAI_API_KEY' in stored_credentials:
+                processed_command = f"export OPENAI_API_KEY=$OPENAI_API_KEY && {command}"
+                print(f"🔧 Fallback: Added OpenAI API key export to command {i+1}")
+        
+        # Handle npm install
+        elif 'npm install' in command and '--yes' not in command and '--no-interactive' not in command:
+            processed_command = command.replace('npm install', 'npm install --yes')
+            print(f"🔧 Fallback: Made npm install non-interactive in command {i+1}")
+        
+        # Handle git clone
+        elif command.strip().startswith('git clone') and '--depth 1' not in command:
+            processed_command = command.replace('git clone', 'git clone --depth 1')
+            print(f"🔧 Fallback: Made git clone non-interactive in command {i+1}")
+        
+        # Handle apt-get install
+        elif 'apt-get install' in command and '-y' not in command:
+            processed_command = command.replace('apt-get install', 'apt-get install -y')
+            print(f"🔧 Fallback: Made apt-get install non-interactive in command {i+1}")
+        
+        processed_commands.append(processed_command)
+    
+    print(f"🔧 Fallback preprocessing completed: {len(processed_commands)} commands")
+    return processed_commands
+
 # Replace the existing GPU argument parsing in the main section
 if __name__ == "__main__":
     # Parse command line arguments when script is run directly
@@ -4145,89 +4290,3 @@ if __name__ == "__main__":
         # print("🧹 Cleaning up resources...")
         cleanup_modal_token()
         sys.exit(1)
-
-def preprocess_commands_with_llm(setup_commands, stored_credentials, api_key=None):
-    """
-    Use LLM to preprocess setup commands and inject available credentials.
-    
-    Args:
-        setup_commands: List of setup commands
-        stored_credentials: Dictionary of stored credentials
-        api_key: OpenAI API key for LLM calls
-        
-    Returns:
-        List of processed commands with credentials injected
-    """
-    if not setup_commands or not stored_credentials:
-        return setup_commands
-    
-    try:
-        # Create context for the LLM
-        credentials_info = "\n".join([f"- {key}: {value[:8]}..." for key, value in stored_credentials.items()])
-        
-        prompt = f"""
-You are a command preprocessing assistant. Your task is to modify setup commands to use available credentials and make them non-interactive.
-
-AVAILABLE CREDENTIALS:
-{credentials_info}
-
-ORIGINAL COMMANDS:
-{chr(10).join([f"{i+1}. {cmd}" for i, cmd in enumerate(setup_commands)])}
-
-INSTRUCTIONS:
-1. Replace any authentication commands with token-based versions using available credentials
-2. Make all commands non-interactive (add --yes, --no-input, -y flags where needed)
-3. Use environment variables or direct token injection where appropriate
-4. Skip commands that cannot be made non-interactive due to missing credentials
-5. Add any necessary environment variable exports
-
-Return the modified commands as a JSON array of strings. If a command should be skipped, prefix it with "# SKIPPED: ".
-
-Example transformations:
-- "huggingface-cli login" → "huggingface-cli login --token $HUGGINGFACE_TOKEN"
-- "npm install" → "npm install --yes"
-- "pip install package" → "pip install package --no-input"
-
-Return only the JSON array, no other text.
-"""
-        
-        if not api_key:
-            print("⚠️ No OpenAI API key available for command preprocessing")
-            return setup_commands
-        
-        # Call OpenAI API
-        import openai
-        client = openai.OpenAI(api_key=api_key)
-        
-        response = client.chat.completions.create(
-            model="gpt-3.5-turbo",
-            messages=[
-                {"role": "system", "content": "You are a command preprocessing assistant that modifies setup commands to use available credentials and make them non-interactive."},
-                {"role": "user", "content": prompt}
-            ],
-            temperature=0.1,
-            max_tokens=2000
-        )
-        
-        result = response.choices[0].message.content.strip()
-        
-        # Parse the JSON response
-        import json
-        try:
-            processed_commands = json.loads(result)
-            if isinstance(processed_commands, list):
-                print(f"🔧 LLM preprocessed {len(processed_commands)} commands")
-                for i, cmd in enumerate(processed_commands):
-                    if cmd != setup_commands[i]:
-                        print(f"  {i+1}. {setup_commands[i]} → {cmd}")
-                return processed_commands
-            else:
-                print("⚠️ LLM returned invalid format, using original commands")
-                return setup_commands
-        except json.JSONDecodeError:
-            print("⚠️ Failed to parse LLM response, using original commands")
-            return setup_commands
-            
-    except Exception as e:
-        print(f"⚠️ LLM preprocessing failed: {e}")
-        return setup_commands