gitarsenal-cli 1.4.4 → 1.4.5

package/package.json

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

package/python/test_modalSandboxScript.py

@@ -356,22 +356,48 @@ def call_openai_for_debug(command, error_output, api_key=None, current_dir=None,
         print("⚠️ Error output is empty. Cannot effectively debug the command.")
         print("⚠️ Skipping OpenAI debugging due to lack of error information.")
         return None
-        
+    
+    # Try to get API key from multiple sources
     if not api_key:
-        # Try to get API key from environment
+        # First try environment variable
         api_key = os.environ.get("OPENAI_API_KEY")
         
-    if not api_key:
-        # Use the CredentialsManager to get the API key
-        try:
-            from credentials_manager import CredentialsManager
-            credentials_manager = CredentialsManager()
-            api_key = credentials_manager.get_openai_api_key()
-            if not api_key:
-                print("❌ No API key provided. Skipping debugging.")
-                return None
-        except ImportError:
-            # Fall back to direct input if credentials_manager module is not available
+        # Store the API key in a persistent file if found
+        if api_key:
+            try:
+                os.makedirs(os.path.expanduser("~/.gitarsenal"), exist_ok=True)
+                with open(os.path.expanduser("~/.gitarsenal/openai_key"), "w") as f:
+                    f.write(api_key)
+                print("✅ Saved OpenAI API key for future use")
+            except Exception as e:
+                print(f"⚠️ Could not save API key: {e}")
+        
+        # Try to load from saved file if not in environment
+        if not api_key:
+            try:
+                key_file = os.path.expanduser("~/.gitarsenal/openai_key")
+                if os.path.exists(key_file):
+                    with open(key_file, "r") as f:
+                        api_key = f.read().strip()
+                    if api_key:
+                        print("✅ Loaded OpenAI API key from saved file")
+                        # Also set in environment for this session
+                        os.environ["OPENAI_API_KEY"] = api_key
+            except Exception as e:
+                print(f"⚠️ Could not load saved API key: {e}")
+        
+        # Then try credentials manager
+        if not api_key:
+            try:
+                from credentials_manager import CredentialsManager
+                credentials_manager = CredentialsManager()
+                api_key = credentials_manager.get_openai_api_key()
+            except ImportError:
+                # Fall back to direct input if credentials_manager is not available
+                pass
+        
+        # Finally, prompt the user if still no API key
+        if not api_key:
             print("\n" + "="*60)
             print("🔑 OPENAI API KEY REQUIRED FOR DEBUGGING")
             print("="*60)
@@ -386,6 +412,8 @@ def call_openai_for_debug(command, error_output, api_key=None, current_dir=None,
                     print("❌ No API key provided. Skipping debugging.")
                     return None
                 print("✅ API key received successfully!")
+                # Save the API key to environment for future use in this session
+                os.environ["OPENAI_API_KEY"] = api_key
             except KeyboardInterrupt:
                 print("\n❌ API key input cancelled by user.")
                 return None
@@ -393,9 +421,11 @@ def call_openai_for_debug(command, error_output, api_key=None, current_dir=None,
                 print(f"❌ Error getting API key: {e}")
                 return None
     
-    # Get current directory context
+    # Gather additional context to help with debugging
     directory_context = ""
     system_info = ""
+    command_history = ""
+    file_context = ""
     
     if sandbox:
         try:
@@ -409,6 +439,7 @@ def call_openai_for_debug(command, error_output, api_key=None, current_dir=None,
             uname -a
             echo -e "\nPython Information:"
             python --version
+            pip --version
             echo -e "\nPackage Manager:"
             which apt 2>/dev/null && echo "apt available" || echo "apt not available"
             which yum 2>/dev/null && echo "yum available" || echo "yum not available"
@@ -463,6 +494,72 @@ Directory contents:
 {parent_context}
 """
             print("✅ Directory context gathered successfully")
+            
+            # Check for relevant files that might provide additional context
+            # For example, if error mentions a specific file, try to get its content
+            relevant_files = []
+            error_files = re.findall(r'(?:No such file or directory|cannot open|not found): ([^\s:]+)', error_output)
+            if error_files:
+                for file_path in error_files:
+                    # Clean up the file path
+                    file_path = file_path.strip("'\"")
+                    if not os.path.isabs(file_path):
+                        file_path = os.path.join(current_dir, file_path)
+                    
+                    # Try to get the parent directory if the file doesn't exist
+                    if '/' in file_path:
+                        parent_file_dir = os.path.dirname(file_path)
+                        relevant_files.append(parent_file_dir)
+            
+            # Look for package.json, requirements.txt, etc.
+            common_config_files = ["package.json", "requirements.txt", "pyproject.toml", "setup.py", 
+                                 "Pipfile", "Dockerfile", "docker-compose.yml", "Makefile"]
+            
+            for config_file in common_config_files:
+                check_cmd = f"test -f {current_dir}/{config_file}"
+                check_result = sandbox.exec("bash", "-c", check_cmd)
+                check_result.wait()
+                if check_result.returncode == 0:
+                    relevant_files.append(f"{current_dir}/{config_file}")
+            
+            # Get content of relevant files
+            if relevant_files:
+                file_context = "\nRelevant file contents:\n"
+                for file_path in relevant_files[:2]:  # Limit to 2 files to avoid too much context
+                    try:
+                        file_check_cmd = f"test -f {file_path}"
+                        file_check = sandbox.exec("bash", "-c", file_check_cmd)
+                        file_check.wait()
+                        
+                        if file_check.returncode == 0:
+                            # It's a file, get its content
+                            cat_cmd = f"cat {file_path}"
+                            cat_result = sandbox.exec("bash", "-c", cat_cmd)
+                            file_content = ""
+                            for line in cat_result.stdout:
+                                file_content += _to_str(line)
+                            cat_result.wait()
+                            
+                            # Truncate if too long
+                            if len(file_content) > 1000:
+                                file_content = file_content[:1000] + "\n... (truncated)"
+                            
+                            file_context += f"\n--- {file_path} ---\n{file_content}\n"
+                        else:
+                            # It's a directory, list its contents
+                            ls_cmd = f"ls -la {file_path}"
+                            ls_dir_result = sandbox.exec("bash", "-c", ls_cmd)
+                            dir_content = ""
+                            for line in ls_dir_result.stdout:
+                                dir_content += _to_str(line)
+                            ls_dir_result.wait()
+                            
+                            file_context += f"\n--- Directory: {file_path} ---\n{dir_content}\n"
+                    except Exception as e:
+                        print(f"⚠️ Error getting content of {file_path}: {e}")
+                
+                print(f"✅ Additional file context gathered from {len(relevant_files)} relevant files")
+            
         except Exception as e:
             print(f"⚠️ Error getting directory context: {e}")
             directory_context = f"\nCurrent directory: {current_dir}\n"
@@ -494,6 +591,8 @@ But it failed with this error:
 ```
 {system_info}
 {directory_context}
+{file_context}
+
 Please analyze the error and provide ONLY a single terminal command that would fix the issue.
 Consider the current directory, system information, and directory contents carefully before suggesting a solution.
 
@@ -507,29 +606,127 @@ Do not provide any explanations, just the exact command to run.
 """
     
     # Prepare the API request payload
-    payload = {
-        "model": "gpt-4.1",
-        "messages": [
-            {"role": "system", "content": "You are a debugging assistant. Provide only the terminal command to fix the issue, analyze the issue first understand why its happening and then provide the command to fix the issue. If you see missing pytest errors, suggest 'pip install pytest'. For wandb login issues, suggest 'wandb login YOUR_API_KEY' and the system will handle prompting for the actual key."},
-            {"role": "user", "content": prompt}
-        ],
-        "temperature": 0.2,
-        "max_tokens": 300
-    }
+    # Try to use GPT-4 first, but fall back to other models if needed
+    models_to_try = [
+        "gpt-4o-mini",        # First choice: GPT-4o (most widely available)
+    ]
     
-    try:
-        print("🤖 Calling OpenAI to debug the failed command...")
-        response = requests.post(
-            "https://api.openai.com/v1/chat/completions",
-            headers=headers,
-            json=payload,
-            timeout=30
-        )
+    # Check if we have a preferred model in environment
+    preferred_model = os.environ.get("OPENAI_MODEL")
+    if preferred_model:
+        # Insert the preferred model at the beginning of the list
+        models_to_try.insert(0, preferred_model)
+        print(f"✅ Using preferred model from environment: {preferred_model}")
         
-        if response.status_code == 200:
-            result = response.json()
+    # Remove duplicates while preserving order
+    models_to_try = list(dict.fromkeys(models_to_try))
+    
+    # Function to make the API call with a specific model
+    def try_api_call(model_name, retries=2, backoff_factor=1.5):
+        payload = {
+            "model": model_name,
+            "messages": [
+                {"role": "system", "content": "You are a debugging assistant. Provide only the terminal command to fix the issue, analyze the issue first understand why its happening and then provide the command to fix the issue. If you see missing pytest errors, suggest 'pip install pytest'. For wandb login issues, suggest 'wandb login YOUR_API_KEY' and the system will handle prompting for the actual key."},
+                {"role": "user", "content": prompt}
+            ],
+            "temperature": 0.2,
+            "max_tokens": 300
+        }
+        
+        # Add specific handling for common errors
+        last_error = None
+        for attempt in range(retries + 1):
+            try:
+                if attempt > 0:
+                    # Exponential backoff
+                    wait_time = backoff_factor * (2 ** (attempt - 1))
+                    print(f"⏱️ Retrying in {wait_time:.1f} seconds... (attempt {attempt+1}/{retries+1})")
+                    time.sleep(wait_time)
+                
+                print(f"🤖 Calling OpenAI with {model_name} model to debug the failed command...")
+                response = requests.post(
+                    "https://api.openai.com/v1/chat/completions",
+                    headers=headers,
+                    json=payload,
+                    timeout=45  # Increased timeout for reliability
+                )
+                
+                # Handle specific status codes
+                if response.status_code == 200:
+                    return response.json(), None
+                elif response.status_code == 401:
+                    error_msg = "Authentication error: Invalid API key"
+                    print(f"❌ {error_msg}")
+                    # Don't retry auth errors
+                    return None, error_msg
+                elif response.status_code == 429:
+                    error_msg = "Rate limit exceeded or quota reached"
+                    print(f"⚠️ {error_msg}")
+                    # Always retry rate limit errors with increasing backoff
+                    last_error = error_msg
+                    continue
+                elif response.status_code == 500:
+                    error_msg = "OpenAI server error"
+                    print(f"⚠️ {error_msg}")
+                    # Retry server errors
+                    last_error = error_msg
+                    continue
+                else:
+                    error_msg = f"Status code: {response.status_code}, Response: {response.text}"
+                    print(f"⚠️ OpenAI API error: {error_msg}")
+                    last_error = error_msg
+                    # Only retry if we have attempts left
+                    if attempt < retries:
+                        continue
+                    return None, error_msg
+            except requests.exceptions.Timeout:
+                error_msg = "Request timed out"
+                print(f"⚠️ {error_msg}")
+                last_error = error_msg
+                # Always retry timeouts
+                continue
+            except requests.exceptions.ConnectionError:
+                error_msg = "Connection error"
+                print(f"⚠️ {error_msg}")
+                last_error = error_msg
+                # Always retry connection errors
+                continue
+            except Exception as e:
+                error_msg = str(e)
+                print(f"⚠️ Unexpected error: {error_msg}")
+                last_error = error_msg
+                # Only retry if we have attempts left
+                if attempt < retries:
+                    continue
+                return None, error_msg
+        
+        # If we get here, all retries failed
+        return None, last_error
+    
+    # Try each model in sequence until one works
+    result = None
+    last_error = None
+    
+    for model in models_to_try:
+        result, error = try_api_call(model)
+        if result:
+            print(f"✅ Successfully got response from {model}")
+            break
+        else:
+            print(f"⚠️ Failed to get response from {model}: {error}")
+            last_error = error
+    
+    if not result:
+        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
+            
             # Extract just the command if it's wrapped in backticks or explanation
             if "```" in fix_command:
                 # Extract content between backticks
@@ -537,21 +734,73 @@ Do not provide any explanations, just the exact command to run.
                 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:
-                # Take 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:
-                    fix_command = min(lines, key=len)
+                # 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
+                command_lines = [line.strip() for line in fix_command.split('\n') 
+                               if any(line.strip().startswith(prefix) for prefix in 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(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
-        else:
-            print(f"❌ OpenAI API error: {response.status_code} - {response.text}")
-            return None
     except Exception as e:
-        print(f"❌ Error calling OpenAI API: {e}")
+        print(f"❌ Error processing OpenAI response: {e}")
         return None
 
 def prompt_for_hf_token():

package/python/fetched_credentials.json

@@ -1,8 +0,0 @@
-{
-  "token_id": "ak-sLhYqCjkvixiYcb9LAuCHp",
-  "token_secret": "as-fPzD0Zm0dl6IFAEkhaH9pq",
-  "openai_api_key": "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",
-  "modalTokenId": "ak-sLhYqCjkvixiYcb9LAuCHp",
-  "modalTokenSecret": "as-fPzD0Zm0dl6IFAEkhaH9pq",
-  "openaiApiKey": "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"
-}

package/python/modal_tokens.json

@@ -1,4 +0,0 @@
-{
-  "token_id": "ak-sLhYqCjkvixiYcb9LAuCHp",
-  "token_secret": "as-fPzD0Zm0dl6IFAEkhaH9pq"
-}