gitarsenal-cli 1.9.25 → 1.9.27

package/.venv_status.json

@@ -1 +1 @@
-{"created":"2025-08-07T10:49:35.026Z","packages":["modal","gitingest","requests","anthropic"],"uv_version":"uv 0.8.4 (Homebrew 2025-07-30)"}
+{"created":"2025-08-08T04:25:52.914Z","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.25",
+  "version": "1.9.27",
   "description": "CLI tool for creating Modal sandboxes with GitHub repositories",
   "main": "index.js",
   "bin": {

package/python/command_manager.py

@@ -255,7 +255,7 @@ class CommandListManager:
         
         return all_commands
     
-    def analyze_failed_commands_with_llm(self, api_key=None, current_dir=None, sandbox=None):
+    def analyze_failed_commands_with_llm(self, api_key=None, current_dir=None, sandbox=None, use_web_search=False):
         """Analyze all failed commands using LLM and add suggested fixes."""
         failed_commands = self.get_failed_commands_for_llm()
         
@@ -266,7 +266,7 @@ class CommandListManager:
         print(f"🔍 Analyzing {len(failed_commands)} failed commands with LLM...")
         
         # Use unified batch debugging for efficiency
-        fixes = call_llm_for_batch_debug(failed_commands, api_key, current_dir, sandbox)
+        fixes = call_llm_for_batch_debug(failed_commands, api_key, current_dir, sandbox, use_web_search)
         
         # Add the fixes to the command list
         added_fixes = []
@@ -296,18 +296,17 @@ class CommandListManager:
             tuple: (should_skip, reason)
         """
         try:
+            # Import required helpers once for this function scope
+            from llm_debugging import get_current_debug_model, get_api_key, make_api_request
+            
             # Get API key if not provided
             if not api_key:
-                api_key = os.environ.get("OPENAI_API_KEY")
-                if not api_key:
-                    # Try to load from saved file
-                    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()
+                # Use the same API key retrieval logic as the debugging functions
+                current_model = get_current_debug_model()
+                api_key = get_api_key(current_model)
             
             if not api_key:
-                print("⚠️ No OpenAI API key available for command list analysis")
+                print(f"⚠️ No {current_model} API key available for command list analysis")
                 return False, "No API key available"
             
             # Get all commands for context
@@ -342,23 +341,15 @@ class CommandListManager:
             RUN: <reason>
             """
             
-            # Call OpenAI API
-            import openai
-            client = openai.OpenAI(api_key=api_key)
+            current_model = get_current_debug_model()
             
-            print("🔍 Analyzing if original command should be skipped...")
+            print(f"🔍 Analyzing if original command should be skipped using {current_model}...")
             
-            response = client.chat.completions.create(
-                model="gpt-3.5-turbo",
-                messages=[
-                    {"role": "system", "content": "You are a helpful assistant that analyzes command execution."},
-                    {"role": "user", "content": prompt}
-                ],
-                max_tokens=100,
-                temperature=0.3
-            )
+            response_text = make_api_request(current_model, api_key, prompt)
             
-            response_text = response.choices[0].message.content.strip()
+            if not response_text:
+                print(f"⚠️ Failed to get response from {current_model}")
+                return False, f"Failed to get response from {current_model}"
             
             # Parse the response
             if response_text.startswith("SKIP:"):
@@ -421,18 +412,16 @@ class CommandListManager:
             bool: True if the list was updated, False otherwise
         """
         try:
+            from llm_debugging import get_current_debug_model, get_api_key, make_api_request
             # Get API key if not provided
             if not api_key:
-                api_key = os.environ.get("OPENAI_API_KEY")
-                if not api_key:
-                    # Try to load from saved file
-                    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()
+                # Use the same API key retrieval logic as the debugging functions
+                from llm_debugging import get_current_debug_model, get_api_key
+                current_model = get_current_debug_model()
+                api_key = get_api_key(current_model)
             
             if not api_key:
-                print("⚠️ No OpenAI API key available for command list analysis")
+                print(f"⚠️ No {current_model} API key available for command list analysis")
                 return False
             
             # Get all commands for context
@@ -486,24 +475,18 @@ class CommandListManager:
             Only include commands that need changes (SKIP, MODIFY, ADD_AFTER), not KEEP actions.
             """
             
-            # Call OpenAI API
-            import openai
+            # Use the unified LLM API call
+            from llm_debugging import make_api_request
             import json
-            client = openai.OpenAI(api_key=api_key)
-            
-            print("🔍 Analyzing command list for optimizations...")
-            
-            response = client.chat.completions.create(
-                model="gpt-4o-mini",  # Use a more capable model for this complex task
-                messages=[
-                    {"role": "system", "content": "You are a helpful assistant that analyzes and optimizes command lists."},
-                    {"role": "user", "content": prompt}
-                ],
-                max_tokens=1000,
-                temperature=0.2
-            )
+            current_model = get_current_debug_model()
             
-            response_text = response.choices[0].message.content.strip()
+            print(f"🔍 Analyzing command list for optimizations using {current_model}...")
+            
+            response_text = make_api_request(current_model, api_key, prompt)
+            
+            if not response_text:
+                print(f"⚠️ Failed to get response from {current_model}")
+                return False
             
             # Extract JSON from the response
             try:

package/python/credentials_manager.py

@@ -145,7 +145,7 @@ class CredentialsManager:
         # First try to fetch from server using fetch_modal_tokens (GitArsenal's key)
         try:
             from fetch_modal_tokens import get_tokens
-            _, _, api_key, _ = get_tokens()
+            _, _, api_key, _, _ = get_tokens()
             if api_key and validate_openai_key(api_key):
                 # Set in environment for future use
                 os.environ["OPENAI_API_KEY"] = api_key
@@ -240,6 +240,48 @@ class CredentialsManager:
             
         prompt = "An Anthropic API key is required.\nYou can get your API key from: https://console.anthropic.com/"
         return self.get_credential("anthropic_api_key", prompt, is_password=True, validate_func=validate_anthropic_key)
+
+    def get_groq_api_key(self):
+        """Get Groq API key with validation"""
+        def validate_groq_key(key):
+            # Groq keys are non-empty; basic length check
+            return bool(key) and len(key) > 20
+
+        # First check stored credentials
+        credentials = self.load_credentials()
+        if "groq_api_key" in credentials:
+            stored_key = credentials["groq_api_key"]
+            if validate_groq_key(stored_key):
+                return stored_key
+
+        # Then check environment variable
+        env_key = os.environ.get("GROQ_API_KEY")
+        if env_key and validate_groq_key(env_key):
+            return env_key
+
+        prompt = "A Groq API key is required for Groq models.\nYou can get your key from: https://console.groq.com/keys"
+        return self.get_credential("groq_api_key", prompt, is_password=True, validate_func=validate_groq_key)
+    
+    def get_exa_api_key(self):
+        """Get Exa API key with validation"""
+        def validate_exa_key(key):
+            # Exa API keys are typically 32+ characters
+            return len(key) >= 32
+        
+        # First check stored credentials
+        credentials = self.load_credentials()
+        if "exa_api_key" in credentials:
+            stored_key = credentials["exa_api_key"]
+            if validate_exa_key(stored_key):
+                return stored_key
+        
+        # Then check environment variable
+        env_key = os.environ.get("EXA_API_KEY")
+        if env_key and validate_exa_key(env_key):
+            return env_key
+            
+        prompt = "An Exa API key is required for web search functionality.\nYou can get your API key from: https://exa.ai/"
+        return self.get_credential("exa_api_key", prompt, is_password=True, validate_func=validate_exa_key)
     
     def clear_credential(self, key):
         """Remove a specific credential"""
@@ -285,7 +327,8 @@ class CredentialsManager:
                 "WANDB_API_KEY",
                 "MODAL_TOKEN_ID",
                 "MODAL_TOKEN", 
-                "MODAL_TOKEN_SECRET"
+                "MODAL_TOKEN_SECRET",
+                "GROQ_API_KEY"
             ]
             
             for var in security_vars:

package/python/fetch_modal_tokens.py

@@ -17,7 +17,7 @@ def fetch_default_tokens_from_gitarsenal():
     Fetch default Modal tokens and OpenAI API key from gitarsenal.dev API.
     
     Returns:
-        tuple: (token_id, token_secret, openai_api_key) if successful, (None, None, None) otherwise
+        tuple: (token_id, token_secret, openai_api_key, anthropic_api_key, groq_api_key) if successful, (None, None, None, None, None) otherwise
     """
     endpoint = "https://gitarsenal.dev/api/credentials"
     
@@ -40,29 +40,30 @@ def fetch_default_tokens_from_gitarsenal():
                 token_secret = data.get("modalTokenSecret")
                 openai_api_key = data.get("openaiApiKey")
                 anthropic_api_key = data.get("anthropicApiKey")
+                groq_api_key = data.get("groqApiKey")
                 
                 if token_id and token_secret:
                     # print("✅ Successfully fetched default tokens from gitarsenal.dev")
-                    return token_id, token_secret, openai_api_key, anthropic_api_key
+                    return token_id, token_secret, openai_api_key, anthropic_api_key, groq_api_key
                 else:
                     print("❌ Modal tokens not found in gitarsenal.dev response")
-                    return None, None, None, None
+                    return None, None, None, None, None
             except json.JSONDecodeError:
                 print("❌ Invalid JSON response from gitarsenal.dev")
-                return None, None, None, None
+                return None, None, None, None, None
         else:
             print(f"❌ Failed to fetch from gitarsenal.dev: {response.status_code} - {response.text[:200]}")
-            return None, None, None, None
+            return None, None, None, None, None
             
     except requests.exceptions.Timeout:
         print("❌ Request timeout when fetching from gitarsenal.dev")
-        return None, None, None, None
+        return None, None, None, None, None
     except requests.exceptions.ConnectionError:
         print("❌ Connection failed to gitarsenal.dev")
-        return None, None, None, None
+        return None, None, None, None, None
     except requests.exceptions.RequestException as e:
         print(f"❌ Request failed to gitarsenal.dev: {e}")
-        return None, None, None, None
+        return None, None, None, None, None
 
 def fetch_tokens_from_proxy(proxy_url=None, api_key=None):
     """
@@ -73,7 +74,7 @@ def fetch_tokens_from_proxy(proxy_url=None, api_key=None):
         api_key: API key for authentication
         
     Returns:
-        tuple: (token_id, token_secret, openai_api_key) if successful, (None, None, None) otherwise
+        tuple: (token_id, token_secret, openai_api_key, anthropic_api_key, groq_api_key) if successful, (None, None, None, None, None) otherwise
     """
     # Use environment variables if not provided
     if not proxy_url:
@@ -90,12 +91,12 @@ def fetch_tokens_from_proxy(proxy_url=None, api_key=None):
     if not proxy_url:
         # print("❌ No proxy URL provided or found in environment")
         print("💡 Set MODAL_PROXY_URL environment variable or use --proxy-url argument")
-        return None, None, None, None
+        return None, None, None, None, None
         
     if not api_key:
         print("❌ No API key provided or found in environment")
         print("💡 Set MODAL_PROXY_API_KEY environment variable or use --proxy-api-key argument")
-        return None, None, None, None
+        return None, None, None, None, None
     
     # Ensure the URL ends with a slash
     if not proxy_url.endswith("/"):
@@ -119,48 +120,41 @@ def fetch_tokens_from_proxy(proxy_url=None, api_key=None):
             token_secret = data.get("token_secret")
             openai_api_key = data.get("openai_api_key")
             anthropic_api_key = data.get("anthropic_api_key")
-            
+            groq_api_key = data.get("groq_api_key")
             if token_id and token_secret:
                 print("✅ Successfully fetched tokens from proxy server")
-                return token_id, token_secret, openai_api_key, anthropic_api_key
+                return token_id, token_secret, openai_api_key, anthropic_api_key, groq_api_key
             else:
                 print("❌ Tokens not found in response")
-                return None, None, None, None
+                return None, None, None, None, None
         else:
             print(f"❌ Failed to fetch tokens: {response.status_code} - {response.text}")
-            return None, None, None, None
+            return None, None, None, None, None
     except Exception as e:
         print(f"❌ Error fetching tokens: {e}")
-        return None, None, None, None
+        return None, None, None, None, None
 
 def get_tokens():
     """
-    Get Modal tokens, OpenAI API key, and Anthropic API key, trying to fetch from the proxy server first.
+    Get Modal tokens, OpenAI API key, Anthropic API key, and Groq API key, trying to fetch from the proxy server first.
     Also sets the tokens in environment variables.
     
     Returns:
-        tuple: (token_id, token_secret, openai_api_key, anthropic_api_key)
+        tuple: (token_id, token_secret, openai_api_key, anthropic_api_key, groq_api_key)
     """
     # Try to fetch from the proxy server
-    token_id, token_secret, openai_api_key, anthropic_api_key = fetch_tokens_from_proxy()
+    token_id, token_secret, openai_api_key, anthropic_api_key, groq_api_key = fetch_tokens_from_proxy()
     
     # If we couldn't fetch from the server, try to get default tokens from gitarsenal.dev
     if not token_id or not token_secret:
         # print("⚠️ Proxy server failed, trying to fetch default tokens from gitarsenal.dev")
-        token_id, token_secret, openai_api_key, anthropic_api_key = fetch_default_tokens_from_gitarsenal()
+        token_id, token_secret, openai_api_key, anthropic_api_key, groq_api_key = fetch_default_tokens_from_gitarsenal()
     
     # If we still don't have tokens, we can't proceed
     if not token_id or not token_secret:
         print("❌ Failed to fetch tokens from both proxy server and gitarsenal.dev")
         print("💡 Please check your network connection and API endpoints")
-        return None, None, None, None
-    
-    # Debug print the full token values
-    # print("\n🔍 DEBUG: FULL TOKEN VALUES:")
-    # print(f"🔍 DEBUG: MODAL_TOKEN_ID: {token_id}")
-    # print(f"🔍 DEBUG: MODAL_TOKEN_SECRET: {token_secret}")
-    # print(f"🔍 DEBUG: OPENAI_API_KEY: {openai_api_key}")
-    # print("🔍 DEBUG: END OF TOKEN VALUES\n")
+        return None, None, None, None, None
     
     # Set the tokens in environment variables
     os.environ["MODAL_TOKEN_ID"] = token_id
@@ -175,7 +169,11 @@ def get_tokens():
     if anthropic_api_key:
         os.environ["ANTHROPIC_API_KEY"] = anthropic_api_key
     
-    return token_id, token_secret, openai_api_key, anthropic_api_key
+    # Set Groq API key if available
+    if groq_api_key:
+        os.environ["GROQ_API_KEY"] = groq_api_key
+    
+    return token_id, token_secret, openai_api_key, anthropic_api_key, groq_api_key
 
 if __name__ == "__main__":
     # Parse command-line arguments if run directly
@@ -196,11 +194,12 @@ if __name__ == "__main__":
         print(f"✅ Set MODAL_PROXY_API_KEY from command line")
     
     # Get tokens
-    token_id, token_secret, openai_api_key, anthropic_api_key = get_tokens()
+    token_id, token_secret, openai_api_key, anthropic_api_key, groq_api_key = get_tokens()
     print(f"Token ID: {token_id}")
     print(f"Token Secret: {token_secret}")
     print(f"OpenAI API Key: {openai_api_key[:5] + '...' if openai_api_key else None}")
     print(f"Anthropic API Key: {anthropic_api_key[:5] + '...' if anthropic_api_key else None}")
+    print(f"Groq API Key: {groq_api_key[:5] + '...' if groq_api_key else None}")
     
     # Check if tokens are set in environment variables
     print(f"\n🔍 DEBUG: Checking environment variables")
@@ -208,6 +207,7 @@ if __name__ == "__main__":
     print(f"🔍 MODAL_TOKEN_SECRET exists: {'Yes' if os.environ.get('MODAL_TOKEN_SECRET') else 'No'}")
     print(f"🔍 OPENAI_API_KEY exists: {'Yes' if os.environ.get('OPENAI_API_KEY') else 'No'}")
     print(f"🔍 ANTHROPIC_API_KEY exists: {'Yes' if os.environ.get('ANTHROPIC_API_KEY') else 'No'}")
+    print(f"🔍 GROQ_API_KEY exists: {'Yes' if os.environ.get('GROQ_API_KEY') else 'No'}")
     if os.environ.get('MODAL_TOKEN_ID'):
         print(f"🔍 MODAL_TOKEN_ID length: {len(os.environ.get('MODAL_TOKEN_ID'))}")
     if os.environ.get('MODAL_TOKEN_SECRET'):
@@ -216,6 +216,8 @@ if __name__ == "__main__":
         print(f"🔍 OPENAI_API_KEY length: {len(os.environ.get('OPENAI_API_KEY'))}")
     if os.environ.get('ANTHROPIC_API_KEY'):
         print(f"🔍 ANTHROPIC_API_KEY length: {len(os.environ.get('ANTHROPIC_API_KEY'))}")
+    if os.environ.get('GROQ_API_KEY'):
+        print(f"🔍 GROQ_API_KEY length: {len(os.environ.get('GROQ_API_KEY'))}")
     
     # Write the tokens to a file for use by other scripts
     tokens_file = Path(__file__).parent / "modal_tokens.json"
@@ -224,7 +226,8 @@ if __name__ == "__main__":
             "token_id": token_id,
             "token_secret": token_secret,
             "openai_api_key": openai_api_key,
-            "anthropic_api_key": anthropic_api_key
+            "anthropic_api_key": anthropic_api_key,
+            "groq_api_key": groq_api_key
         }, f)
     print(f"\n✅ Tokens written to {tokens_file}")
     
@@ -279,6 +282,17 @@ if __name__ == "__main__":
         with open(env_file, 'w') as f:
             f.write(env_content)
         print(f"✅ Updated Anthropic API key in {env_file}")
+
+    # Update or add GROQ_API_KEY
+    if groq_api_key:
+        if "GROQ_API_KEY" in env_content:
+            import re
+            env_content = re.sub(r'GROQ_API_KEY=.*\n', f'GROQ_API_KEY={groq_api_key}\n', env_content)
+        else:
+            env_content += f'\nGROQ_API_KEY={groq_api_key}\n'
+        with open(env_file, 'w') as f:
+            f.write(env_content)
+        print(f"✅ Updated Groq API key in {env_file}")
     
     # Try to use the Modal CLI to set the token
     try:

package/python/fix_modal_token.py

@@ -42,7 +42,7 @@ except Exception as e:
 try:
     # First, try to import the fetch_modal_tokens module
     from fetch_modal_tokens import get_tokens
-    TOKEN_ID, TOKEN_SECRET, _, _ = get_tokens()
+    TOKEN_ID, TOKEN_SECRET, _, _, _ = get_tokens()
     
     # Check if we got valid tokens
     if TOKEN_ID is None or TOKEN_SECRET is None: