gitarsenal-cli 1.9.21 → 1.9.23

package/.venv_status.json

@@ -1 +1 @@
-{"created":"2025-08-06T11:52:55.135Z","packages":["modal","gitingest","requests","anthropic"],"uv_version":"uv 0.8.4 (Homebrew 2025-07-30)"}
+{"created":"2025-08-07T07:09:00.867Z","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.21",
+  "version": "1.9.23",
   "description": "CLI tool for creating Modal sandboxes with GitHub repositories",
   "main": "index.js",
   "bin": {

package/python/command_manager.py

@@ -0,0 +1,605 @@
+import os
+import time
+import requests
+import re
+import json
+import re
+
+class CommandListManager:
+    """Manages a dynamic list of setup commands with status tracking and LLM-suggested fixes."""
+    
+    def __init__(self, initial_commands=None):
+        self.commands = []
+        self.executed_commands = []
+        self.failed_commands = []
+        self.suggested_fixes = []
+        self.current_index = 0
+        self.total_commands = 0
+        
+        if initial_commands:
+            self.add_commands(initial_commands)
+    
+    def add_commands(self, commands):
+        """Add new commands to the list."""
+        if isinstance(commands, str):
+            commands = [commands]
+        
+        added_count = 0
+        for cmd in commands:
+            if cmd and cmd.strip():
+                self.commands.append({
+                    'command': cmd.strip(),
+                    'status': 'pending',
+                    'index': len(self.commands),
+                    'stdout': '',
+                    'stderr': '',
+                    'execution_time': None,
+                    'fix_attempts': 0,
+                    'max_fix_attempts': 3
+                })
+                added_count += 1
+        
+        self.total_commands = len(self.commands)
+        if added_count > 0:
+            print(f"📋 Added {added_count} commands to list. Total: {self.total_commands}")
+    
+    def add_command_dynamically(self, command, priority='normal'):
+        """Add a single command dynamically during execution."""
+        if not command or not command.strip():
+            return False
+        
+        new_command = {
+            'command': command.strip(),
+            'status': 'pending',
+            'index': len(self.commands),
+            'stdout': '',
+            'stderr': '',
+            'execution_time': None,
+            'fix_attempts': 0,
+            'max_fix_attempts': 3,
+            'priority': priority
+        }
+        
+        if priority == 'high':
+            # Insert at the beginning of pending commands
+            self.commands.insert(self.current_index, new_command)
+            # Update indices for all commands after insertion
+            for i in range(self.current_index + 1, len(self.commands)):
+                self.commands[i]['index'] = i
+        else:
+            # Add to the end
+            self.commands.append(new_command)
+        
+        self.total_commands = len(self.commands)
+        print(f"📋 Added dynamic command: {command.strip()}")
+        return True
+    
+    def add_suggested_fix(self, original_command, fix_command, reason=""):
+        """Add a LLM-suggested fix for a failed command."""
+        fix_entry = {
+            'original_command': original_command,
+            'fix_command': fix_command,
+            'reason': reason,
+            'status': 'pending',
+            'index': len(self.suggested_fixes),
+            'stdout': '',
+            'stderr': '',
+            'execution_time': None
+        }
+        self.suggested_fixes.append(fix_entry)
+        print(f"🔧 Added suggested fix: {fix_command}")
+        return len(self.suggested_fixes) - 1
+    
+    def get_next_command(self):
+        """Get the next pending command to execute."""
+        # First, try to get a pending command from the main list
+        for i in range(self.current_index, len(self.commands)):
+            if self.commands[i]['status'] == 'pending':
+                return self.commands[i], 'main'
+        
+        # If no pending commands in main list, check suggested fixes
+        for fix in self.suggested_fixes:
+            if fix['status'] == 'pending':
+                return fix, 'fix'
+        
+        return None, None
+    
+    def mark_command_executed(self, command_index, command_type='main', success=True, stdout='', stderr='', execution_time=None):
+        """Mark a command as executed with results."""
+        if command_type == 'main':
+            if 0 <= command_index < len(self.commands):
+                self.commands[command_index].update({
+                    'status': 'success' if success else 'failed',
+                    'stdout': stdout,
+                    'stderr': stderr,
+                    'execution_time': execution_time
+                })
+                
+                if success:
+                    self.executed_commands.append(self.commands[command_index])
+                    print(f"✅ Command {command_index + 1}/{self.total_commands} completed successfully")
+                else:
+                    self.failed_commands.append(self.commands[command_index])
+                    print(f"❌ Command {command_index + 1}/{self.total_commands} failed")
+                
+                self.current_index = max(self.current_index, command_index + 1)
+        
+        elif command_type == 'fix':
+            if 0 <= command_index < len(self.suggested_fixes):
+                self.suggested_fixes[command_index].update({
+                    'status': 'success' if success else 'failed',
+                    'stdout': stdout,
+                    'stderr': stderr,
+                    'execution_time': execution_time
+                })
+                
+                if success:
+                    print(f"✅ Fix command {command_index + 1} completed successfully")
+                else:
+                    print(f"❌ Fix command {command_index + 1} failed")
+    
+    def get_status_summary(self):
+        """Get a summary of command execution status."""
+        total_main = len(self.commands)
+        total_fixes = len(self.suggested_fixes)
+        executed_main = len([c for c in self.commands if c['status'] == 'success'])
+        failed_main = len([c for c in self.commands if c['status'] == 'failed'])
+        pending_main = len([c for c in self.commands if c['status'] == 'pending'])
+        executed_fixes = len([f for f in self.suggested_fixes if f['status'] == 'success'])
+        failed_fixes = len([f for f in self.suggested_fixes if f['status'] == 'failed'])
+        
+        return {
+            'total_main_commands': total_main,
+            'executed_main_commands': executed_main,
+            'failed_main_commands': failed_main,
+            'pending_main_commands': pending_main,
+            'total_fix_commands': total_fixes,
+            'executed_fix_commands': executed_fixes,
+            'failed_fix_commands': failed_fixes,
+            'progress_percentage': (executed_main / total_main * 100) if total_main > 0 else 0
+        }
+    
+    def print_status(self):
+        """Print current status of all commands."""
+        summary = self.get_status_summary()
+        
+        print("\n" + "="*60)
+        print("📋 COMMAND EXECUTION STATUS")
+        print("="*60)
+        
+        # Main commands status
+        print(f"📋 Main Commands: {summary['executed_main_commands']}/{summary['total_main_commands']} completed")
+        print(f"   ✅ Successful: {summary['executed_main_commands']}")
+        print(f"   ❌ Failed: {summary['failed_main_commands']}")
+        print(f"   ⏳ Pending: {summary['pending_main_commands']}")
+        
+        # Fix commands status
+        if summary['total_fix_commands'] > 0:
+            print(f"🔧 Fix Commands: {summary['executed_fix_commands']}/{summary['total_fix_commands']} completed")
+            print(f"   ✅ Successful: {summary['executed_fix_commands']}")
+            print(f"   ❌ Failed: {summary['failed_fix_commands']}")
+        
+        # Progress bar
+        progress = summary['progress_percentage']
+        bar_length = 30
+        filled_length = int(bar_length * progress / 100)
+        bar = '█' * filled_length + '░' * (bar_length - filled_length)
+        print(f"📊 Progress: [{bar}] {progress:.1f}%")
+        
+        # Show current command if any
+        next_cmd, cmd_type = self.get_next_command()
+        if next_cmd:
+            cmd_type_str = "main" if cmd_type == 'main' else "fix"
+            cmd_text = next_cmd.get('command', next_cmd.get('fix_command', 'Unknown command'))
+            print(f"🔄 Current: {cmd_type_str} command - {cmd_text[:50]}...")
+        
+        print("="*60)
+    
+    def get_failed_commands_for_llm(self):
+        """Get failed commands for LLM analysis."""
+        failed_commands = []
+        
+        # Get failed main commands
+        for cmd in self.commands:
+            if cmd['status'] == 'failed':
+                failed_commands.append({
+                    'command': cmd['command'],
+                    'stderr': cmd['stderr'],
+                    'stdout': cmd['stdout'],
+                    'type': 'main'
+                })
+        
+        # Get failed fix commands
+        for fix in self.suggested_fixes:
+            if fix['status'] == 'failed':
+                failed_commands.append({
+                    'command': fix['fix_command'],
+                    'stderr': fix['stderr'],
+                    'stdout': fix['stdout'],
+                    'type': 'fix',
+                    'original_command': fix['original_command']
+                })
+        
+        return failed_commands
+    
+    def has_pending_commands(self):
+        """Check if there are any pending commands."""
+        return any(cmd['status'] == 'pending' for cmd in self.commands) or \
+               any(fix['status'] == 'pending' for fix in self.suggested_fixes)
+    
+    def get_all_commands(self):
+        """Get all commands (main + fixes) in execution order."""
+        all_commands = []
+        
+        # Add main commands
+        for cmd in self.commands:
+            all_commands.append({
+                **cmd,
+                'type': 'main'
+            })
+        
+        # Add fix commands
+        for fix in self.suggested_fixes:
+            all_commands.append({
+                **fix,
+                'type': 'fix'
+            })
+        
+        return all_commands
+    
+    def analyze_failed_commands_with_llm(self, api_key=None, current_dir=None, sandbox=None):
+        """Analyze all failed commands using LLM and add suggested fixes."""
+        failed_commands = self.get_failed_commands_for_llm()
+        
+        if not failed_commands:
+            print("✅ No failed commands to analyze")
+            return []
+        
+        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)
+        
+        # Add the fixes to the command list
+        added_fixes = []
+        for fix in fixes:
+            fix_index = self.add_suggested_fix(
+                fix['original_command'], 
+                fix['fix_command'], 
+                fix['reason']
+            )
+            added_fixes.append(fix_index)
+        
+        print(f"🔧 Added {len(added_fixes)} LLM-suggested fixes to command list")
+        return added_fixes
+    
+    def should_skip_original_command(self, original_command, fix_command, fix_stdout, fix_stderr, api_key=None):
+        """
+        Use LLM to determine if the original command should be skipped after a successful fix.
+        
+        Args:
+            original_command: The original command that failed
+            fix_command: The fix command that succeeded
+            fix_stdout: The stdout from the fix command
+            fix_stderr: The stderr from the fix command
+            api_key: OpenAI API key
+            
+        Returns:
+            tuple: (should_skip, reason)
+        """
+        try:
+            # 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()
+            
+            if not api_key:
+                print("⚠️ No OpenAI API key available for command list analysis")
+                return False, "No API key available"
+            
+            # Get all commands for context
+            all_commands = self.get_all_commands()
+            commands_context = "\n".join([f"{i+1}. {cmd['command']} - {cmd['status']}" for i, cmd in enumerate(all_commands)])
+            
+            # Prepare the prompt
+            prompt = f"""
+            I need to determine if an original command should be skipped after a successful fix command.
+            
+            Original command (failed): {original_command}
+            Fix command (succeeded): {fix_command}
+            
+            Fix command stdout:
+            {fix_stdout}
+            
+            Fix command stderr:
+            {fix_stderr}
+            
+            Current command list:
+            {commands_context}
+            
+            Based on this information, should I skip running the original command again?
+            Consider:
+            1. If the fix command already accomplished what the original command was trying to do
+            2. If running the original command again would be redundant or cause errors
+            3. If the original command is still necessary after the fix
+            
+            Respond with ONLY:
+            SKIP: <reason>
+            or
+            RUN: <reason>
+            """
+            
+            # Call OpenAI API
+            import openai
+            client = openai.OpenAI(api_key=api_key)
+            
+            print("🔍 Analyzing if original command should be skipped...")
+            
+            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 = response.choices[0].message.content.strip()
+            
+            # Parse the response
+            if response_text.startswith("SKIP:"):
+                reason = response_text.replace("SKIP:", "").strip()
+                print(f"🔍 LLM suggests skipping original command: {reason}")
+                return True, reason
+            elif response_text.startswith("RUN:"):
+                reason = response_text.replace("RUN:", "").strip()
+                print(f"🔍 LLM suggests running original command: {reason}")
+                return False, reason
+            else:
+                # Try to interpret a free-form response
+                if "skip" in response_text.lower() and "should" in response_text.lower():
+                    print(f"🔍 Interpreting response as SKIP: {response_text}")
+                    return True, response_text
+                else:
+                    print(f"🔍 Interpreting response as RUN: {response_text}")
+                    return False, response_text
+                
+        except Exception as e:
+            print(f"⚠️ Error analyzing command skip decision: {e}")
+            return False, f"Error: {e}"
+    
+    def replace_command(self, command_index, new_command, reason=""):
+        """
+        Replace a command in the list with a new command.
+        
+        Args:
+            command_index: The index of the command to replace
+            new_command: The new command to use
+            reason: The reason for the replacement
+            
+        Returns:
+            bool: True if the command was replaced, False otherwise
+        """
+        if 0 <= command_index < len(self.commands):
+            old_command = self.commands[command_index]['command']
+            self.commands[command_index]['command'] = new_command
+            self.commands[command_index]['status'] = 'pending'  # Reset status
+            self.commands[command_index]['stdout'] = ''
+            self.commands[command_index]['stderr'] = ''
+            self.commands[command_index]['execution_time'] = None
+            self.commands[command_index]['replacement_reason'] = reason
+            
+            print(f"🔄 Replaced command {command_index + 1}: '{old_command}' with '{new_command}'")
+            print(f"🔍 Reason: {reason}")
+            return True
+        else:
+            print(f"❌ Invalid command index for replacement: {command_index}")
+            return False
+    
+    def update_command_list_with_llm(self, api_key=None):
+        """
+        Use LLM to analyze and update the entire command list.
+        
+        Args:
+            api_key: OpenAI API key
+            
+        Returns:
+            bool: True if the list was updated, False otherwise
+        """
+        try:
+            # 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()
+            
+            if not api_key:
+                print("⚠️ No OpenAI API key available for command list analysis")
+                return False
+            
+            # Get all commands for context
+            all_commands = self.get_all_commands()
+            commands_context = "\n".join([f"{i+1}. {cmd['command']} - {cmd['status']}" 
+                                         for i, cmd in enumerate(all_commands)])
+            
+            # Get executed commands with their outputs for context
+            executed_context = ""
+            for cmd in self.executed_commands:
+                executed_context += f"Command: {cmd['command']}\n"
+                executed_context += f"Status: {cmd['status']}\n"
+                if cmd['stdout']:
+                    executed_context += f"Stdout: {cmd['stdout'][:500]}...\n" if len(cmd['stdout']) > 500 else f"Stdout: {cmd['stdout']}\n"
+                if cmd['stderr']:
+                    executed_context += f"Stderr: {cmd['stderr'][:500]}...\n" if len(cmd['stderr']) > 500 else f"Stderr: {cmd['stderr']}\n"
+                executed_context += "\n"
+            
+            # Prepare the prompt
+            prompt = f"""
+            I need you to analyze and optimize this command list. Some commands have been executed, 
+            and some are still pending. Based on what has already been executed, I need you to:
+            
+            1. Identify any pending commands that are now redundant or unnecessary
+            2. Identify any pending commands that should be modified based on previous command results
+            3. Suggest any new commands that should be added
+            
+            Current command list:
+            {commands_context}
+            
+            Details of executed commands:
+            {executed_context}
+            
+            For each pending command (starting from the next command to be executed), tell me if it should be:
+            1. KEEP: Keep the command as is
+            2. SKIP: Skip the command (mark as completed without running)
+            3. MODIFY: Modify the command (provide the new command)
+            4. ADD_AFTER: Add a new command after this one
+            
+            Format your response as a JSON array of actions:
+            [
+                {{
+                    "command_index": <index>,
+                    "action": "KEEP|SKIP|MODIFY|ADD_AFTER",
+                    "new_command": "<new command if MODIFY or ADD_AFTER>",
+                    "reason": "<reason for this action>"
+                }},
+                ...
+            ]
+            
+            Only include commands that need changes (SKIP, MODIFY, ADD_AFTER), not KEEP actions.
+            """
+            
+            # Call OpenAI API
+            import openai
+            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
+            )
+            
+            response_text = response.choices[0].message.content.strip()
+            
+            # Extract JSON from the response
+            try:
+                # Find JSON array in the response
+                json_match = re.search(r'\[\s*\{.*\}\s*\]', response_text, re.DOTALL)
+                if json_match:
+                    json_str = json_match.group(0)
+                    actions = json.loads(json_str)
+                else:
+                    # Try to parse the entire response as JSON
+                    actions = json.loads(response_text)
+                
+                if not isinstance(actions, list):
+                    print("❌ Invalid response format from LLM - not a list")
+                    return False
+                
+                # Apply the suggested changes
+                changes_made = 0
+                commands_added = 0
+                
+                # Process in reverse order to avoid index shifting issues
+                for action in sorted(actions, key=lambda x: x.get('command_index', 0), reverse=True):
+                    cmd_idx = action.get('command_index')
+                    action_type = action.get('action')
+                    new_cmd = action.get('new_command', '')
+                    reason = action.get('reason', 'No reason provided')
+                    
+                    if cmd_idx is None or action_type is None:
+                        continue
+                    
+                    # Convert to 0-based index if needed
+                    if cmd_idx > 0:  # Assume 1-based index from LLM
+                        cmd_idx -= 1
+                    
+                    # Skip if the command index is invalid
+                    if cmd_idx < 0 or cmd_idx >= len(self.commands):
+                        print(f"❌ Invalid command index: {cmd_idx}")
+                        continue
+                    
+                    # Skip if the command has already been executed
+                    if self.commands[cmd_idx]['status'] != 'pending':
+                        print(f"⚠️ Command {cmd_idx + 1} already executed, skipping action")
+                        continue
+                    
+                    if action_type == "SKIP":
+                        # Mark the command as successful without running it
+                        self.mark_command_executed(
+                            cmd_idx, 'main', True, 
+                            f"Command skipped: {reason}", 
+                            "", 0
+                        )
+                        print(f"🔄 Skipped command {cmd_idx + 1}: {reason}")
+                        changes_made += 1
+                    
+                    elif action_type == "MODIFY":
+                        if new_cmd:
+                            if self.replace_command(cmd_idx, new_cmd, reason):
+                                changes_made += 1
+                        else:
+                            print(f"❌ No new command provided for MODIFY action on command {cmd_idx + 1}")
+                    
+                    elif action_type == "ADD_AFTER":
+                        if new_cmd:
+                            # Add new command after the current one
+                            insert_idx = cmd_idx + 1
+                            new_cmd_obj = {
+                                'command': new_cmd,
+                                'status': 'pending',
+                                'index': insert_idx,
+                                'stdout': '',
+                                'stderr': '',
+                                'execution_time': None,
+                                'fix_attempts': 0,
+                                'max_fix_attempts': 3,
+                                'added_reason': reason
+                            }
+                            
+                            # Insert the new command
+                            self.commands.insert(insert_idx, new_cmd_obj)
+                            
+                            # Update indices for all commands after insertion
+                            for i in range(insert_idx + 1, len(self.commands)):
+                                self.commands[i]['index'] = i
+                            
+                            print(f"➕ Added new command after {cmd_idx + 1}: '{new_cmd}'")
+                            print(f"🔍 Reason: {reason}")
+                            commands_added += 1
+                        else:
+                            print(f"❌ No new command provided for ADD_AFTER action on command {cmd_idx + 1}")
+                
+                # Update total commands count
+                self.total_commands = len(self.commands)
+                
+                print(f"✅ Command list updated: {changes_made} changes made, {commands_added} commands added")
+                return changes_made > 0 or commands_added > 0
+                
+            except json.JSONDecodeError as e:
+                print(f"❌ Failed to parse LLM response as JSON: {e}")
+                print(f"Raw response: {response_text}")
+                return False
+            except Exception as e:
+                print(f"❌ Error updating command list: {e}")
+                return False
+                
+        except Exception as e:
+            print(f"⚠️ Error analyzing command list: {e}")
+            return False