gitarsenal-cli 1.9.23 → 1.9.24

package/.venv_status.json

@@ -1 +1 @@
-{"created":"2025-08-07T07:09:00.867Z","packages":["modal","gitingest","requests","anthropic"],"uv_version":"uv 0.8.4 (Homebrew 2025-07-30)"}
+{"created":"2025-08-07T09:48:26.761Z","packages":["modal","gitingest","requests","anthropic"],"uv_version":"uv 0.8.4 (Homebrew 2025-07-30)"}

package/package.json

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

package/python/command_manager.py

@@ -3,7 +3,15 @@ import time
 import requests
 import re
 import json
-import re
+
+# Import the LLM debugging function
+try:
+    from llm_debugging import call_llm_for_batch_debug
+except ImportError:
+    # Fallback: define a simple version if the import fails
+    def call_llm_for_batch_debug(failed_commands, api_key=None, current_dir=None, sandbox=None):
+        print("⚠️ LLM batch debugging not available")
+        return []
 
 class CommandListManager:
     """Manages a dynamic list of setup commands with status tracking and LLM-suggested fixes."""

package/python/llm_debugging.py

@@ -5,6 +5,98 @@ import requests
 import openai
 import anthropic
 
+
+def get_stored_credentials():
+    """Load stored credentials from ~/.gitarsenal/credentials.json"""
+    import json
+    from pathlib import Path
+    
+    try:
+        credentials_file = Path.home() / ".gitarsenal" / "credentials.json"
+        if credentials_file.exists():
+            with open(credentials_file, 'r') as f:
+                credentials = json.load(f)
+            return credentials
+        else:
+            return {}
+    except Exception as e:
+        print(f"⚠️ Error loading stored credentials: {e}")
+        return {}
+
+def generate_auth_context(stored_credentials):
+    """Generate simple authentication context for the OpenAI prompt"""
+    if not stored_credentials:
+        return "No stored credentials available."
+    
+    auth_context = "Available stored credentials (use actual values in commands):\n"
+    
+    for key, value in stored_credentials.items():
+        # Mask the actual value for security in logs, but provide the real value
+        masked_value = value[:8] + "..." if len(value) > 8 else "***"
+        auth_context += f"- {key}: {masked_value} (actual value: {value})\n"
+    
+    return auth_context
+
+def get_current_debug_model():
+    """Get the currently configured debugging model preference"""
+    return os.environ.get("GITARSENAL_DEBUG_MODEL", "openai")
+
+def call_llm_for_debug(command, error_output, api_key=None, current_dir=None, sandbox=None):
+    """Unified function to call LLM for debugging - routes to OpenAI or Anthropic based on configuration"""
+    current_model = get_current_debug_model()
+    
+    print(f"🔍 DEBUG: Using {current_model.upper()} for debugging...")
+    
+    if current_model == "anthropic":
+        # Try to get Anthropic API key if not provided
+        if not api_key:
+            # First try environment variable
+            api_key = os.environ.get("ANTHROPIC_API_KEY")
+            
+            # If not in environment, try to fetch from server using fetch_modal_tokens
+            if not api_key:
+                try:
+                    from fetch_modal_tokens import get_tokens
+                    _, _, _, api_key = get_tokens()
+                except Exception as e:
+                    print(f"⚠️ Error fetching Anthropic API key from server: {e}")
+            
+            # Then try credentials manager
+            if not api_key:
+                try:
+                    from credentials_manager import CredentialsManager
+                    credentials_manager = CredentialsManager()
+                    api_key = credentials_manager.get_anthropic_api_key()
+                except Exception as e:
+                    print(f"⚠️ Error getting Anthropic API key from credentials manager: {e}")
+        
+        return call_anthropic_for_debug(command, error_output, api_key, current_dir, sandbox)
+    else:
+        # Default to OpenAI
+        # Try to get OpenAI API key if not provided
+        if not api_key:
+            # First try environment variable
+            api_key = os.environ.get("OPENAI_API_KEY")
+            
+            # If not in environment, try to fetch from server using fetch_modal_tokens
+            if not api_key:
+                try:
+                    from fetch_modal_tokens import get_tokens
+                    _, _, api_key, _ = get_tokens()
+                except Exception as e:
+                    print(f"⚠️ Error fetching OpenAI API key from server: {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 Exception as e:
+                    print(f"⚠️ Error getting OpenAI API key from credentials manager: {e}")
+        
+        return call_openai_for_debug(command, error_output, api_key, current_dir, sandbox)
+
 def call_openai_for_debug(command, error_output, api_key=None, current_dir=None, sandbox=None):
     """Call OpenAI to debug a failed command and suggest a fix"""
     print("\n🔍 DEBUG: Starting LLM debugging...")
@@ -1058,4 +1150,220 @@ Return only the command to fix the issue, nothing else."""
         print(f"❌ Error processing Anthropic response: {e}")
         print(f"🔍 DEBUG: Exception type: {type(e).__name__}")
         print(f"🔍 DEBUG: Exception details: {str(e)}")
-        return None
+        return None
+
+
+def call_llm_for_batch_debug(failed_commands, api_key=None, current_dir=None, sandbox=None):
+    """Unified function to call LLM for batch debugging - routes to OpenAI or Anthropic based on configuration"""
+    current_model = get_current_debug_model()
+    
+    print(f"🔍 DEBUG: Using {current_model.upper()} for batch debugging...")
+    
+    if current_model == "anthropic":
+        # Try to get Anthropic API key if not provided
+        if not api_key:
+            # First try environment variable
+            api_key = os.environ.get("ANTHROPIC_API_KEY")
+            
+            # If not in environment, try to fetch from server using fetch_modal_tokens
+            if not api_key:
+                try:
+                    from fetch_modal_tokens import get_tokens
+                    _, _, _, api_key = get_tokens()
+                except Exception as e:
+                    print(f"⚠️ Error fetching Anthropic API key from server: {e}")
+            
+            # Then try credentials manager
+            if not api_key:
+                try:
+                    from credentials_manager import CredentialsManager
+                    credentials_manager = CredentialsManager()
+                    api_key = credentials_manager.get_anthropic_api_key()
+                except Exception as e:
+                    print(f"⚠️ Error getting Anthropic API key from credentials manager: {e}")
+        
+        return call_anthropic_for_batch_debug(failed_commands, api_key, current_dir, sandbox)
+    else:
+        # Default to OpenAI
+        # Try to get OpenAI API key if not provided
+        if not api_key:
+            # First try environment variable
+            api_key = os.environ.get("OPENAI_API_KEY")
+            
+            # If not in environment, try to fetch from server using fetch_modal_tokens
+            if not api_key:
+                try:
+                    from fetch_modal_tokens import get_tokens
+                    _, _, api_key, _ = get_tokens()
+                except Exception as e:
+                    print(f"⚠️ Error fetching OpenAI API key from server: {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 Exception as e:
+                    print(f"⚠️ Error getting OpenAI API key from credentials manager: {e}")
+        
+        return call_openai_for_batch_debug(failed_commands, api_key, current_dir, sandbox)
+
+def call_anthropic_for_batch_debug(failed_commands, api_key=None, current_dir=None, sandbox=None):
+    """Call Anthropic Claude to debug multiple failed commands and suggest fixes for all of them at once"""
+    print("\n🔍 DEBUG: Starting batch Anthropic Claude debugging...")
+    print(f"🔍 DEBUG: Analyzing {len(failed_commands)} failed commands")
+    
+    if not failed_commands:
+        print("⚠️ No failed commands to analyze")
+        return []
+    
+    if not api_key:
+        print("🔍 DEBUG: No Anthropic API key provided, searching for one...")
+        
+        # First try environment variable
+        api_key = os.environ.get("ANTHROPIC_API_KEY")
+        print(f"🔍 DEBUG: API key from environment: {'Found' if api_key else 'Not found'}")
+        if api_key:
+            print(f"🔍 DEBUG: Environment API key value: {api_key}")
+        
+        # If not in environment, try to fetch from server using fetch_modal_tokens
+        if not api_key:
+            try:
+                print("🔍 DEBUG: Trying to fetch API key from server...")
+                from fetch_modal_tokens import get_tokens
+                _, _, _, api_key = get_tokens()
+                if api_key:
+                    # Set in environment for this session
+                    os.environ["ANTHROPIC_API_KEY"] = api_key
+                else:
+                    print("⚠️ Could not fetch Anthropic API key from server")
+            except Exception as e:
+                print(f"⚠️ Error fetching API key from server: {e}")
+        
+        # Then try credentials manager
+        if not api_key:
+            print("🔍 DEBUG: Trying credentials manager...")
+            try:
+                from credentials_manager import CredentialsManager
+                credentials_manager = CredentialsManager()
+                api_key = credentials_manager.get_anthropic_api_key()
+                if api_key:
+                    print(f"🔍 DEBUG: API key from credentials manager: Found")
+                    print(f"🔍 DEBUG: Credentials manager API key value: {api_key}")
+                    # Set in environment for this session
+                    os.environ["ANTHROPIC_API_KEY"] = api_key
+                else:
+                    print("⚠️ Could not fetch Anthropic API key from credentials manager")
+            except Exception as e:
+                print(f"⚠️ Error fetching API key from credentials manager: {e}")
+        
+        if not api_key:
+            print("❌ No Anthropic API key available for batch debugging")
+            return []
+    
+    # Prepare context for batch analysis
+    context_parts = []
+    context_parts.append(f"Current directory: {current_dir}")
+    context_parts.append(f"Sandbox available: {sandbox is not None}")
+    
+    # Add failed commands with their errors
+    for i, failed_cmd in enumerate(failed_commands, 1):
+        cmd_type = failed_cmd.get('type', 'main')
+        original_cmd = failed_cmd.get('original_command', '')
+        cmd_text = failed_cmd['command']
+        stderr = failed_cmd.get('stderr', '')
+        stdout = failed_cmd.get('stdout', '')
+        
+        context_parts.append(f"\n--- Failed Command {i} ({cmd_type}) ---")
+        context_parts.append(f"Command: {cmd_text}")
+        if original_cmd and original_cmd != cmd_text:
+            context_parts.append(f"Original Command: {original_cmd}")
+        if stderr:
+            context_parts.append(f"Error Output: {stderr}")
+        if stdout:
+            context_parts.append(f"Standard Output: {stdout}")
+    
+    # Create the prompt for batch analysis
+    prompt = f"""You are a debugging assistant analyzing multiple failed commands. 
+
+Context:
+{chr(10).join(context_parts)}
+
+Please analyze each failed command and provide a fix command for each one. For each failed command, respond with:
+
+FIX_COMMAND_{i}: <the fix command>
+REASON_{i}: <brief explanation of why the original command failed and how the fix addresses it>
+
+Guidelines:
+- For file not found errors, first search for the file using 'find . -name filename -type f'
+- For missing packages, use appropriate package managers (pip, apt-get, npm)
+- For Git SSH authentication failures, convert SSH URLs to HTTPS URLs
+- For permission errors, suggest commands with sudo if appropriate
+- For network issues, suggest retry commands or alternative URLs
+- Keep each fix command simple and focused on the specific error
+
+Provide fixes for all {len(failed_commands)} failed commands:"""
+
+    # Set up headers for Anthropic API
+    headers = {
+        "x-api-key": api_key,
+        "anthropic-version": "2023-06-01",
+        "content-type": "application/json"
+    }
+    
+    payload = {
+        "model": "claude-3-5-sonnet-20241022",  # Use a more capable model for batch analysis
+        "max_tokens": 1000,
+        "messages": [
+            {"role": "user", "content": prompt}
+        ]
+    }
+    
+    try:
+        print(f"🤖 Calling Anthropic Claude for batch debugging of {len(failed_commands)} commands...")
+        response = requests.post(
+            "https://api.anthropic.com/v1/messages",
+            headers=headers,
+            json=payload,
+            timeout=60
+        )
+        
+        if response.status_code == 200:
+            result = response.json()
+            content = result['content'][0]['text']
+            print(f"✅ Batch analysis completed")
+            
+            # Parse the response to extract fix commands
+            fixes = []
+            for i in range(1, len(failed_commands) + 1):
+                fix_pattern = f"FIX_COMMAND_{i}: (.+)"
+                reason_pattern = f"REASON_{i}: (.+)"
+                
+                fix_match = re.search(fix_pattern, content, re.MULTILINE)
+                reason_match = re.search(reason_pattern, content, re.MULTILINE)
+                
+                if fix_match:
+                    fix_command = fix_match.group(1).strip()
+                    reason = reason_match.group(1).strip() if reason_match else "Anthropic Claude suggested fix"
+                    
+                    # Clean up the fix command
+                    if fix_command.startswith('`') and fix_command.endswith('`'):
+                        fix_command = fix_command[1:-1]
+                    
+                    fixes.append({
+                        'original_command': failed_commands[i-1]['command'],
+                        'fix_command': fix_command,
+                        'reason': reason,
+                        'command_index': i-1
+                    })
+            
+            print(f"🔧 Generated {len(fixes)} fix commands from batch analysis")
+            return fixes
+        else:
+            print(f"❌ Anthropic API error: {response.status_code} - {response.text}")
+            return []
+            
+    except Exception as e:
+        print(f"❌ Error during batch debugging: {e}")
+        return []

package/python/shell.py

@@ -5,6 +5,23 @@ import time
 import uuid
 import re
 
+def get_stored_credentials():
+    """Load stored credentials from ~/.gitarsenal/credentials.json"""
+    import json
+    from pathlib import Path
+    
+    try:
+        credentials_file = Path.home() / ".gitarsenal" / "credentials.json"
+        if credentials_file.exists():
+            with open(credentials_file, 'r') as f:
+                credentials = json.load(f)
+            return credentials
+        else:
+            return {}
+    except Exception as e:
+        print(f"⚠️ Error loading stored credentials: {e}")
+        return {}
+
 class PersistentShell:
     """A persistent bash shell using subprocess.Popen for executing commands with state persistence."""