gitarsenal-cli 1.9.65 → 1.9.67

package/python/test_modalSandboxScript.py

@@ -162,7 +162,10 @@ if token_id is None or token_secret is None:
 # Explicitly set the environment variables again to be sure
 os.environ["MODAL_TOKEN_ID"] = token_id
 os.environ["MODAL_TOKEN_SECRET"] = token_secret
-os.environ["OPENAI_API_KEY"] = openai_api_key
+if openai_api_key:
+    os.environ["OPENAI_API_KEY"] = openai_api_key
+if anthropic_api_key:
+    os.environ["ANTHROPIC_API_KEY"] = anthropic_api_key
 # Also set the old environment variable for backward compatibility
 os.environ["MODAL_TOKEN"] = token_id
 
@@ -198,7 +201,11 @@ def get_stored_credentials():
 # Now modify the create_modal_ssh_container function to use the PersistentShell
 def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_commands=None, 
                                volume_name=None, timeout_minutes=60, ssh_password=None, interactive=False, gpu_count=1):
-    """Create a Modal SSH container with GPU support and tunneling"""
+    """Create a Modal SSH container with GPU support and intelligent repository setup.
+    
+    When repo_url is provided, uses Claude Code Agent for intelligent repository setup.
+    The setup_commands parameter is maintained for backwards compatibility but ignored when using Claude Code Agent.
+    """
     
     # Use interactive mode if specified
     if interactive:
@@ -346,6 +353,8 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
     
     # Get the current directory path for mounting local Python sources
     current_dir = os.path.dirname(os.path.abspath(__file__))
+    # Get the gitarsenal-cli root directory for kill_claude files
+    gitarsenal_root = os.path.dirname(current_dir)
     # print(f"🔍 Current directory for mounting: {current_dir}")
     
     # Use a more stable CUDA base image and avoid problematic packages
@@ -378,12 +387,30 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
             
             # Set up a nice bash prompt
             "echo 'export PS1=\"\\[\\e[1;32m\\]modal:\\[\\e[1;34m\\]\\w\\[\\e[0m\\]$ \"' >> /root/.bashrc",
+            
+            # Create directories for Claude Code Agent
+            "mkdir -p /python/kill_claude/tools /python/kill_claude/prompts",
         )
+        # Mount all local files (must be done after run_commands)
         .add_local_file(os.path.join(current_dir, "shell.py"), "/python/shell.py")  # Mount shell.py
         .add_local_file(os.path.join(current_dir, "command_manager.py"), "/python/command_manager.py")  # Mount command_manager.py
         .add_local_file(os.path.join(current_dir, "fetch_modal_tokens.py"), "/python/fetch_modal_tokens.py")  # Mount fetch_modal_token.py
         .add_local_file(os.path.join(current_dir, "llm_debugging.py"), "/python/llm_debugging.py")  # Mount llm_debugging.py
         .add_local_file(os.path.join(current_dir, "credentials_manager.py"), "/python/credentials_manager.py")  # Mount credentials_manager.py
+        # Mount Claude Code Agent and its dependencies
+        .add_local_file(os.path.join(gitarsenal_root, "kill_claude", "claude_code_agent.py"), "/python/kill_claude/claude_code_agent.py")
+        # Mount the tools and prompts directories manually with key files
+        .add_local_file(os.path.join(gitarsenal_root, "kill_claude", "tools", "__init__.py"), "/python/kill_claude/tools/__init__.py")
+        .add_local_file(os.path.join(gitarsenal_root, "kill_claude", "tools", "bash_tool.py"), "/python/kill_claude/tools/bash_tool.py")
+        .add_local_file(os.path.join(gitarsenal_root, "kill_claude", "tools", "read_tool.py"), "/python/kill_claude/tools/read_tool.py")
+        .add_local_file(os.path.join(gitarsenal_root, "kill_claude", "tools", "write_tool.py"), "/python/kill_claude/tools/write_tool.py")
+        .add_local_file(os.path.join(gitarsenal_root, "kill_claude", "tools", "ls_tool.py"), "/python/kill_claude/tools/ls_tool.py")
+        .add_local_file(os.path.join(gitarsenal_root, "kill_claude", "tools", "edit_tool.py"), "/python/kill_claude/tools/edit_tool.py")
+        .add_local_file(os.path.join(gitarsenal_root, "kill_claude", "tools", "grep_tool.py"), "/python/kill_claude/tools/grep_tool.py")
+        .add_local_file(os.path.join(gitarsenal_root, "kill_claude", "tools", "glob_tool.py"), "/python/kill_claude/tools/glob_tool.py")
+        .add_local_file(os.path.join(gitarsenal_root, "kill_claude", "tools", "todo_write_tool.py"), "/python/kill_claude/tools/todo_write_tool.py")
+        .add_local_file(os.path.join(gitarsenal_root, "kill_claude", "prompts", "claude-code-system-prompt.md"), "/python/kill_claude/prompts/claude-code-system-prompt.md")
+        .add_local_file(os.path.join(gitarsenal_root, "kill_claude", "prompts", "claude-code-agent-prompts.md"), "/python/kill_claude/prompts/claude-code-agent-prompts.md")
 
     )
     print("✅ SSH image built successfully")
@@ -409,8 +436,8 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
         serialized=True,
         volumes=volumes_config if volumes_config else None,
     )
-    def ssh_container_function(ssh_password=None, repo_url=None, repo_name=None, setup_commands=None, openai_api_key=None, stored_credentials=None):
-        """Start SSH container with password authentication and optional setup."""
+    def ssh_container_function(ssh_password=None, repo_url=None, repo_name=None, setup_commands=None, openai_api_key=None, anthropic_api_key=None, stored_credentials=None):
+        """Start SSH container with password authentication and intelligent repository setup using Claude Code Agent."""
         import subprocess
         import time
         import os
@@ -487,273 +514,96 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
         # Start SSH service
         subprocess.run(["service", "ssh", "start"], check=True)
         
-        # Preprocess setup commands using LLM to inject credentials
-        if setup_commands:
-            print(f"🔧 Preprocessing {len(setup_commands)} setup commands with LLM to inject credentials...")
-            api_key = os.environ.get("OPENAI_API_KEY")
-            processed_commands = preprocess_commands_with_llm(setup_commands, stored_credentials, api_key)
-            print(f"⚙️ Running {len(processed_commands)} preprocessed setup commands with dynamic command list...")
-            
-            # Display all setup commands that will be executed
-            print("\n" + "="*80)
-            print("📋 SETUP COMMANDS TO BE EXECUTED")
-            print("="*80)
-            for i, cmd in enumerate(processed_commands, 1):
-                print(f"  {i:2d}. {cmd}")
-            print("="*80 + "\n")
+        # Use Claude Code Agent for intelligent repository setup
+        if repo_url:
+            print("🤖 Using Claude Code Agent for intelligent repository setup...")
             
-            # Create command list manager with processed commands
-            cmd_manager = CommandListManager(processed_commands)
+            # Set up environment variables for the Claude Code Agent
+            if openai_api_key:
+                os.environ['OPENAI_API_KEY'] = openai_api_key
+            if anthropic_api_key:
+                os.environ['ANTHROPIC_API_KEY'] = anthropic_api_key
             
-            # Create persistent shell instance starting in /root
-            shell = PersistentShell(working_dir="/root", timeout=300)
+            # Set up Anthropic API key from stored credentials
+            anthropic_api_key = None
+            if stored_credentials:
+                # Look for Anthropic API key in various possible names
+                for key_name in ['ANTHROPIC_API_KEY', 'anthropic_api_key', 'anthropic-api-key']:
+                    if key_name in stored_credentials:
+                        anthropic_api_key = stored_credentials[key_name]
+                        os.environ['ANTHROPIC_API_KEY'] = anthropic_api_key
+                        print(f"✅ Set Anthropic API key from stored credentials")
+                        break
+                        
+                if not anthropic_api_key:
+                    print("⚠️ No Anthropic API key found in stored credentials")
+                    print("💡 Claude Code Agent will require an Anthropic API key for operation")
             
             try:
-                # Start the persistent shell
-                shell.start()
+                print("🔧 Running Claude Code Agent for repository setup...")
                 
-                # Track how many commands have been executed since last analysis
-                commands_since_analysis = 0
+                print("\n" + "="*80)
+                print("🤖 CLAUDE CODE AGENT REPOSITORY SETUP")
+                print("="*80)
+                print(f"Repository: {repo_url}")
+                print(f"Working Directory: /root")
+                if stored_credentials:
+                    print(f"Available Credentials: {len(stored_credentials)} items")
+                print("="*80 + "\n")
                 
-                # Execute commands using the command list manager
-                while cmd_manager.has_pending_commands():
-                    # Get next command to execute
-                    next_cmd, cmd_type = cmd_manager.get_next_command()
-                    
-                    if not next_cmd:
-                        break
-                    
-                    # Box everything printed in this iteration into one block
-                    with _boxed_capture():
-                        # Print status before executing
-                        cmd_manager.print_status()
-                        
-                        # Periodically analyze and update the command list
-                        if commands_since_analysis >= 3 and cmd_type == 'main':
-                            print("\n🔍 Periodic command list analysis...")
-                            api_key = os.environ.get("OPENAI_API_KEY")
-                            cmd_manager.update_command_list_with_llm(api_key)
-                            commands_since_analysis = 0
-                        
-                        # Execute the command
-                        if cmd_type == 'main':
-                            cmd_text = next_cmd['command']
-                            cmd_index = next_cmd['index']
-                            success, stdout, stderr, execution_time = _execute_with_box(
-                                shell, cmd_text, timeout=100,
-                                title_line=f"📋 Executing main command {cmd_index + 1}/{cmd_manager.total_commands}: {cmd_text}",
-                                box=False
-                            )
-                            
-                            # Check if the command was aborted due to waiting for input and an alternative was suggested
-                            if not success and "Command aborted - requires user input" in stderr and shell.suggested_alternative:
-                                alternative_cmd = shell.suggested_alternative
-                                print(f"🔄 Command aborted due to input requirement. Adding suggested alternative: {alternative_cmd}")
-                                
-                                # Add the alternative command with high priority
-                                cmd_manager.add_command_dynamically(alternative_cmd, priority='high')
-                                
-                                # Clear the suggested alternative
-                                shell.suggested_alternative = None
-                            # Check if the command should be removed as suggested by LLM
-                            elif not success and stderr.startswith("Command removed -"):
-                                reason = stderr.replace("Command removed -", "").strip()
-                                print(f"🚫 Removed command as suggested by LLM: {reason}")
-                                # We don't need to do anything else, just mark it as executed and move on
-                            
-                            # Mark command as executed
-                            cmd_manager.mark_command_executed(
-                                cmd_index, 'main', success, stdout, stderr, execution_time
-                            )
-                            
-                            # Increment counter for periodic analysis
-                            commands_since_analysis += 1
-                            
-                            if not success:
-                                print(f"⚠️ Command failed, attempting LLM debugging...")
-                                
-                                # Call LLM for debugging
-                                try:
-                                    current_dir = shell.get_cwd()
-                                    
-                                    # Use unified LLM debugging function
-                                    fix_command = call_llm_for_debug(cmd_text, stderr, current_dir=current_dir, sandbox=shell)
-                                    
-                                    if fix_command:
-                                        # Get the current debug model to show the correct provider name
-                                        from llm_debugging import get_current_debug_model
-                                        current_model = get_current_debug_model()
-                                        print(f"🔧 {current_model.capitalize()} suggested fix command: {fix_command}")
-                                        
-                                        # Add the fix to the command list manager
-                                        fix_index = cmd_manager.add_suggested_fix(cmd_text, fix_command, "LLM suggested fix")
-                                        
-                                        # Execute the fix command
-                                        fix_success, fix_stdout, fix_stderr, fix_execution_time = _execute_with_box(
-                                            shell, fix_command, timeout=300,
-                                            title_line=f"🔧 Executing suggested fix: {fix_command}",
-                                            box=False
-                                        )
-                                        
-                                        # Mark fix command as executed
-                                        cmd_manager.mark_command_executed(
-                                            fix_index, 'fix', fix_success, fix_stdout, fix_stderr, fix_execution_time
-                                        )
-                                        
-                                        if fix_success:
-                                            print(f"✅ Fix command succeeded")
-                                            
-                                            # Check if we should skip the original command
-                                            api_key = os.environ.get("OPENAI_API_KEY")
-                                            should_skip, skip_reason = cmd_manager.should_skip_original_command(
-                                                cmd_text, fix_command, fix_stdout, fix_stderr, api_key
-                                            )
-                                            
-                                            if should_skip:
-                                                print(f"🔄 Skipping original command: {skip_reason}")
-                                                
-                                                # Mark the original command as successful without running it
-                                                cmd_manager.mark_command_executed(
-                                                    cmd_index, 'main', True, 
-                                                    f"Command skipped after successful fix: {skip_reason}", 
-                                                    "", execution_time
-                                                )
-                                                
-                                                print(f"✅ Original command marked as successful (skipped)")
-                                                
-                                                # After a successful fix and skipping the original command,
-                                                # analyze and update the entire command list
-                                                print("\n🔍 Analyzing and updating remaining commands based on fix results...")
-                                                cmd_manager.update_command_list_with_llm(api_key)
-                                            else:
-                                                # Retry the original command
-                                                print(f"🔄 Retrying original command: {cmd_text}")
-                                                retry_success, retry_stdout, retry_stderr, retry_execution_time = _execute_with_box(
-                                                    shell, cmd_text, timeout=300,
-                                                    title_line=f"🔄 Retrying command: {cmd_text}",
-                                                    box=False
-                                                )
-                                                
-                                                # Update the original command status
-                                                cmd_manager.mark_command_executed(
-                                                    cmd_index, 'main', retry_success, retry_stdout, retry_stderr, retry_execution_time
-                                                )
-                                                
-                                                if retry_success:
-                                                    print(f"✅ Original command succeeded after fix!")
-                                                    
-                                                    # After a successful fix and successful retry,
-                                                    # analyze and update the entire command list
-                                                    print("\n🔍 Analyzing and updating remaining commands based on fix results...")
-                                                    cmd_manager.update_command_list_with_llm(api_key)
-                                                else:
-                                                    print(f"⚠️ Original command still failed after fix, continuing...")
-                                        else:
-                                            print(f"❌ Fix command failed: {fix_stderr}")
-                                            print(f"⚠️ First fix attempt failed; continuing without web search...")
-                                            
-                                            # No web-search retry; continue
-                                            print(f"⚠️ Continuing with remaining commands...")
-                                    else:
-                                        # Get the current debug model to show the correct provider name
-                                        from llm_debugging import get_current_debug_model
-                                        current_model = get_current_debug_model()
-                                        print(f"❌ No fix suggested by {current_model.capitalize()}")
-                                        print(f"⚠️ Continuing with remaining commands...")
-                                        
-                                except Exception as debug_e:
-                                    print(f"❌ LLM debugging failed: {debug_e}")
-                                    print(f"⚠️ Continuing with remaining commands...")
-                    
-                            elif cmd_type == 'fix':
-                                cmd_text = next_cmd['fix_command']
-                                cmd_index = next_cmd['index']
-                                success, stdout, stderr, execution_time = _execute_with_box(
-                                    shell, cmd_text, timeout=300,
-                                    title_line=f"🔧 Executing fix command {cmd_index + 1}: {cmd_text}",
-                                    box=False
-                                )
-                        
-                        # Check if the fix command was aborted due to waiting for input and an alternative was suggested
-                        if not success and "Command aborted - requires user input" in stderr and shell.suggested_alternative:
-                            alternative_cmd = shell.suggested_alternative
-                            print(f"🔄 Fix command aborted due to input requirement. Adding suggested alternative: {alternative_cmd}")
-                            
-                            # Add the alternative command with high priority
-                            cmd_manager.add_command_dynamically(alternative_cmd, priority='high')
-                            
-                            # Clear the suggested alternative
-                            shell.suggested_alternative = None
-                        # Check if the fix command should be removed as suggested by LLM
-                        elif not success and stderr.startswith("Command removed -"):
-                            reason = stderr.replace("Command removed -", "").strip()
-                            print(f"🚫 Removed fix command as suggested by LLM: {reason}")
-                            # We don't need to do anything else, just mark it as executed and move on
-                        
-                        # Mark fix command as executed
-                        cmd_manager.mark_command_executed(
-                            cmd_index, 'fix', success, stdout, stderr, execution_time
-                        )
+                # Call Claude Code Agent directly as subprocess with real-time output
+                claude_prompt = f"clone and setup {repo_url}"
+                print(f"🚀 Executing: python /python/kill_claude/claude_code_agent.py \"{claude_prompt}\"")
+                print("\n" + "="*60)
+                print("🎉 CLAUDE CODE AGENT OUTPUT (LIVE)")
+                print("="*60)
                 
-                # After all commands are processed, do a final batch analysis of any remaining failed commands
-                failed_commands = cmd_manager.get_failed_commands_for_llm()
-                if failed_commands:
-                    print(f"\n🔍 Final batch analysis of {len(failed_commands)} failed commands...")
-                    current_dir = shell.get_cwd()
+                # Use Popen for real-time output streaming
+                process = subprocess.Popen(
+                    ["python", "/python/kill_claude/claude_code_agent.py", claude_prompt],
+                    cwd="/root",
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.STDOUT,  # Merge stderr into stdout
+                    text=True,
+                    bufsize=1,  # Line buffered
+                    universal_newlines=True
+                )
+                
+                # Stream output in real-time
+                try:
+                    while True:
+                        output = process.stdout.readline()
+                        if output == '' and process.poll() is not None:
+                            break
+                        if output:
+                            print(output.rstrip())
                     
-                    # Get the correct API key for the current debug model
-                    from llm_debugging import get_current_debug_model, get_api_key
-                    current_model = get_current_debug_model()
-                    api_key = get_api_key(current_model)
+                    # Wait for process to complete and get return code
+                    return_code = process.wait(timeout=600)  # 10 minute timeout
                     
-                    # Use batch analysis to get additional fixes
-                    additional_fixes = cmd_manager.analyze_failed_commands_with_llm(api_key, current_dir, shell)
+                    print("\n" + "="*60)
+                    if return_code == 0:
+                        print("✅ Claude Code Agent completed successfully!")
+                    else:
+                        print(f"⚠️ Claude Code Agent exited with code: {return_code}")
+                    print("="*60)
                     
-                    if additional_fixes:
-                        print(f"🔧 Executing {len(additional_fixes)} additional fix commands...")
-                        
-                        # Execute the additional fix commands
-                        for fix_index in additional_fixes:
-                            fix_cmd = cmd_manager.suggested_fixes[fix_index]
-                            cmd_text = fix_cmd['fix_command']
-                            success, stdout, stderr, execution_time = _execute_with_box(
-                                shell, cmd_text, timeout=300,
-                                title_line=f"🔧 Executing additional fix: {cmd_text}",
-                                box=False
-                            )
-                            
-                            # Check if the fix command was aborted due to waiting for input and an alternative was suggested
-                            if not success and "Command aborted - requires user input" in stderr and shell.suggested_alternative:
-                                alternative_cmd = shell.suggested_alternative
-                                print(f"🔄 Additional fix command aborted due to input requirement. Adding suggested alternative: {alternative_cmd}")
-                                
-                                # Add the alternative command with high priority
-                                cmd_manager.add_command_dynamically(alternative_cmd, priority='high')
-                                
-                                # Clear the suggested alternative
-                                shell.suggested_alternative = None
-                            # Check if the additional fix command should be removed as suggested by LLM
-                            elif not success and stderr.startswith("Command removed -"):
-                                reason = stderr.replace("Command removed -", "").strip()
-                                print(f"🚫 Removed additional fix command as suggested by LLM: {reason}")
-                                # We don't need to do anything else, just mark it as executed and move on
-                            
-                            # Mark fix command as executed
-                            cmd_manager.mark_command_executed(
-                                fix_index, 'fix', success, stdout, stderr, execution_time
-                            )
-                
-                # Print final status
-                print("\n" + "="*60)
-                print("🎉 SETUP COMMANDS EXECUTION COMPLETED")
-                print("="*60)
-                cmd_manager.print_status()
+                except subprocess.TimeoutExpired:
+                    print("\n⚠️ Claude Code Agent timed out after 10 minutes")
+                    process.kill()
+                    process.wait()
+                except Exception as stream_error:
+                    print(f"\n⚠️ Error streaming output: {stream_error}")
+                    process.kill()
+                    process.wait()
                 
             except Exception as e:
-                print(f"❌ Error during setup command execution: {e}")
-            finally:
-                # Clean up the shell
-                shell.cleanup()
+                print(f"❌ Error during repository setup: {e}")
+                print("⚠️ Proceeding without setup...")
+                import traceback
+                traceback.print_exc()
+        else:
+            print("⚠️ No repository URL provided, skipping setup")
         
         # Create SSH tunnel
         with modal.forward(22, unencrypted=True) as tunnel:
@@ -791,15 +641,17 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
             with app.run():
                 # Get the API key from environment
                 api_key = os.environ.get("OPENAI_API_KEY")
+                # print(f"🔐 API key: {api_key}")
                 
                 # Get stored credentials from local file
                 stored_credentials = get_stored_credentials()
+                # print(f"🔐 Stored credentials: {stored_credentials}")
                 if stored_credentials:
                     print(f"🔐 Found {len(stored_credentials)} stored credentials to send to container")
                 else:
                     print("⚠️ No stored credentials found")
                 
-                ssh_container_function.remote(ssh_password, repo_url, repo_name, setup_commands, api_key, stored_credentials)
+                ssh_container_function.remote(ssh_password, repo_url, repo_name, setup_commands, api_key, anthropic_api_key, stored_credentials)
                 
         # Clean up Modal token after container is successfully created
         cleanup_modal_token()
@@ -1256,17 +1108,12 @@ def show_usage_examples():
     print("│ gitarsenal --auth                         # Interactive auth management         │")
     print("└────────────────────────────────────────────────────────────────────────────────────┘\n")
     
-    print("Basic Container Creation")
+    print("Basic Container Creation with Claude Code Agent")
     print("┌────────────────────────────────────────────────────────────────────────┐")
     print("│ gitarsenal --gpu A10G --repo-url https://github.com/username/repo.git  │")
+    print("│ # Claude Code Agent will intelligently clone and setup the repository  │")
     print("└────────────────────────────────────────────────────────────────────────┘\n")
     
-    print("With Setup Commands")
-    print("┌────────────────────────────────────────────────────────────────────────────────────────────────────┐")
-    print("│ gitarsenal --gpu A100 --repo-url https://github.com/username/repo.git \\           │")
-    print("│   --setup-commands \"pip install -r requirements.txt\" \"python setup.py install\"  │")
-    print("└────────────────────────────────────────────────────────────────────────────────────────────────────┘\n")
-    
     print("With Persistent Storage")
     print("┌────────────────────────────────────────────────────────────────────────────────────┐")
     print("│ gitarsenal --gpu A10G --repo-url https://github.com/username/repo.git \\  │")
@@ -1279,21 +1126,16 @@ def show_usage_examples():
     print("│   --repo-url https://github.com/username/repo.git                │")
     print("└────────────────────────────────────────────────────────────────────────────────────┘\n")
     
-    print("With GitIngest API (default)")
+    print("Intelligent Repository Setup (default)")
     print("┌────────────────────────────────────────────────────────────────────────────────────┐")
     print("│ gitarsenal --gpu A10G --repo-url https://github.com/username/repo.git             │")
+    print("│ # Claude Code Agent analyzes repo and sets up environment automatically           │")
     print("└────────────────────────────────────────────────────────────────────────────────────┘\n")
     
-    print("Without GitIngest API")
-    print("┌────────────────────────────────────────────────────────────────────────────────────┐")
-    print("│ gitarsenal --gpu A10G --repo-url https://github.com/username/repo.git \\  │")
-    print("│   --no-gitingest                                                │")
-    print("└────────────────────────────────────────────────────────────────────────────────────┘\n")
-    
-    print("With Original API")
+    print("With Manual Setup Commands (Advanced)")
     print("┌────────────────────────────────────────────────────────────────────────────────────┐")
-    print("│ gitarsenal --gpu A10G --repo-url https://github.com/username/repo.git \\  │")
-    print("│   --use-api                                                      │")
+    print("│ gitarsenal --gpu A10G --setup-commands \"pip install torch\" \"python train.py\"     │")
+    print("│ # Only use when not providing --repo-url (bypasses Claude Code Agent)            │")
     print("└────────────────────────────────────────────────────────────────────────────────────┘\n")
     
     print("Development Mode (Skip Authentication)")
@@ -1314,15 +1156,20 @@ def show_usage_examples():
     print("  • With --gpu: Uses specified GPU without prompting")
     print("  • Without --gpu: Shows interactive GPU selection menu")
     print()
+    print("Repository Setup Behavior:")
+    print("  • With --repo-url: Claude Code Agent intelligently clones and sets up repository")
+    print("  • Without --repo-url: Manual container setup (no automatic repository setup)")
+    print("  • Legacy --setup-commands: Only used when --repo-url not provided")
+    print()
     print("Examples:")
-    print("  # First time setup (will prompt for registration):")
+    print("  # Intelligent repository setup (recommended):")
     print("  gitarsenal --gpu A10G --repo-url https://github.com/username/repo.git")
     print()
-    print("  # Subsequent runs (automatic login):")
-    print("  gitarsenal --repo-url https://github.com/username/repo.git")
-    print()
     print("  # Development mode (skip authentication):")
-    print("  gitarsenal --skip-auth --repo-url https://github.com/username/repo.git")
+    print("  gitarsenal --skip-auth --gpu A10G --repo-url https://github.com/username/repo.git")
+    print()
+    print("  # Manual setup (advanced users):")
+    print("  gitarsenal --gpu A10G --setup-commands \"pip install torch\" \"python train.py\"")
 
 def make_api_request_with_retry(url, payload, max_retries=2, timeout=180):
     """Make an API request with retry mechanism."""
@@ -1984,9 +1831,9 @@ if __name__ == "__main__":
     parser.add_argument('--volume-name', type=str, help='Name of the Modal volume for persistent storage')
     parser.add_argument('--timeout', type=int, default=60, help='Container timeout in minutes (default: 60)')
     parser.add_argument('--ssh-password', type=str, help='SSH password (random if not provided)')
-    parser.add_argument('--use-api', action='store_true', help='Fetch setup commands from original API')
-    parser.add_argument('--use-gitingest', action='store_true', default=True, help='Use gitingest approach to fetch setup commands (default)')
-    parser.add_argument('--no-gitingest', action='store_true', help='Disable gitingest approach for setup commands')
+    parser.add_argument('--use-api', action='store_true', help='[DEPRECATED] Fetch setup commands from original API (use --repo-url for Claude Code Agent instead)')
+    parser.add_argument('--use-gitingest', action='store_true', default=True, help='[DEPRECATED] Use gitingest approach (Claude Code Agent is now used when --repo-url is provided)')
+    parser.add_argument('--no-gitingest', action='store_true', help='[DEPRECATED] Disable gitingest approach (no longer needed with Claude Code Agent)')
     parser.add_argument('--show-examples', action='store_true', help='Show usage examples')
     parser.add_argument('--list-gpus', action='store_true', help='List available GPU types with their specifications')
     parser.add_argument('--interactive', action='store_true', help='Run in interactive mode with prompts')
@@ -2118,12 +1965,14 @@ if __name__ == "__main__":
     else:
         print(f"GPU Type: {gpu_type}")
     print(f"Volume: {args.volume_name or 'None'}")
-    if args.use_api:
+    if args.repo_url:
+        print("Repository Setup: Claude Code Agent (intelligent)")
+    elif args.use_api:
         print("Setup Commands: Auto-detect from repository")
     elif args.setup_commands:
         print(f"Setup Commands: {len(args.setup_commands)} custom commands")
     else:
-        print("Setup Commands: Auto-detect from repository")
+        print("Setup Commands: None")
     
     # Confirm settings (skip if --yes specified)
     if not getattr(args, 'yes', False):
@@ -2203,15 +2052,15 @@ if __name__ == "__main__":
         args.use_gitingest = use_gitingest
     
     try:    
-        # Get setup commands from file if specified
+        # Setup commands are no longer used when repo_url is provided (Claude Code Agent handles setup)
         setup_commands = args.setup_commands or []
         
-        # Use gitingest by default unless --no-gitingest is set
-        if args.repo_url and (args.use_gitingest and not args.no_gitingest):
-            # print("🔄 Using gitingest approach to fetch setup commands (default)")
-            api_commands = get_setup_commands_from_gitingest(args.repo_url)
-            setup_commands = api_commands
-            print(f"📋 Using {len(setup_commands)} commands from gitingest API")
+        # Repository setup approach
+        if args.repo_url:
+            print("🤖 Repository setup will be handled by Claude Code Agent in container")
+            setup_commands = []  # Claude Code Agent will handle setup intelligently
+        else:
+            print("⚠️ No repository URL provided - setup commands may be needed manually")
             
         
         # Parse setup commands from JSON if provided
@@ -2265,7 +2114,7 @@ if __name__ == "__main__":
             try:
                 with open(args.setup_script, 'r') as f:
                     script_content = f.read().strip()
-                    # Convert script to individual commands
+                    # Convert script to individual commandsr
                     script_commands = [line.strip() for line in script_content.split('\n') 
                                     if line.strip() and not line.strip().startswith('#')]
                     setup_commands.extend(script_commands)