gitarsenal-cli 1.9.83 → 1.9.85

package/.venv_status.json

@@ -1 +1 @@
-{"created":"2025-08-18T08:57:32.974Z","packages":["modal","gitingest","requests","anthropic"],"uv_version":"uv 0.8.4 (Homebrew 2025-07-30)"}
+{"created":"2025-08-20T12:21:13.646Z","packages":["modal","gitingest","requests","anthropic"],"uv_version":"uv 0.8.4 (Homebrew 2025-07-30)"}

package/bin/gitarsenal.js

@@ -208,83 +208,113 @@ async function previewRecommendations(repoUrl, optsOrShowSummary = true) {
 
 function printGpuTorchCudaSummary(result) {
   try {
-    console.log(chalk.bold('\n📊 RESULT SUMMARY (GPU/Torch/CUDA)'));
-    console.log('────────────────────────────────────────────────────────');
+    console.log();
+    console.log(chalk.bold.cyan('  ⚙️  Analysis Results'));
+    console.log(chalk.dim('  ─────────────────'));
+    console.log();
 
     const cuda = result.cudaRecommendation;
     if (cuda) {
-      console.log(chalk.bold('🎯 CUDA Recommendation'));
-      if (cuda.recommendedCudaVersion) console.log(`  - CUDA:  ${cuda.recommendedCudaVersion}`);
-      if (Array.isArray(cuda.compatibleTorchVersions) && cuda.compatibleTorchVersions.length)
-        console.log(`  - Torch Compatibility:  ${cuda.compatibleTorchVersions.join(', ')}`);
-      if (cuda.dockerImage) console.log(`  - Docker Image:  ${cuda.dockerImage}`);
+      console.log(chalk.bold.yellow('  🎯 CUDA Configuration'));
+      if (cuda.recommendedCudaVersion) {
+        console.log(chalk.dim('     Version: ') + chalk.white(cuda.recommendedCudaVersion));
+      }
+      if (Array.isArray(cuda.compatibleTorchVersions) && cuda.compatibleTorchVersions.length) {
+        console.log(chalk.dim('     Torch:   ') + chalk.white(cuda.compatibleTorchVersions.join(', ')));
+      }
+      if (cuda.dockerImage) {
+        console.log(chalk.dim('     Image:   ') + chalk.white(cuda.dockerImage));
+      }
       if (Array.isArray(cuda.installCommands) && cuda.installCommands.length) {
-        console.log('  - Install Commands:');
-        cuda.installCommands.forEach((c) => console.log(`    $ ${c}`));
+        console.log(chalk.dim('     Commands:'));
+        cuda.installCommands.forEach((c) => {
+          console.log(chalk.dim('       $ ') + chalk.cyan(c));
+        });
+      }
+      if (cuda.notes) {
+        console.log(chalk.dim('     Notes:   ') + chalk.gray(cuda.notes));
       }
-      if (cuda.notes) console.log(`  - Notes:  ${cuda.notes}`);
       console.log();
     }
 
     const torch = result.torchRecommendation;
     if (torch) {
-      console.log(chalk.bold('🔥 PyTorch Recommendation'));
-      if (torch.recommendedTorchVersion) console.log(`  - Torch:  ${torch.recommendedTorchVersion}`);
-      if (torch.cudaVariant) console.log(`  - CUDA Variant:  ${torch.cudaVariant}`);
+      console.log(chalk.bold.red('  🔥 PyTorch Setup'));
+      if (torch.recommendedTorchVersion) {
+        console.log(chalk.dim('     Version: ') + chalk.white(torch.recommendedTorchVersion));
+      }
+      if (torch.cudaVariant) {
+        console.log(chalk.dim('     CUDA:    ') + chalk.white(torch.cudaVariant));
+      }
       if (torch.pipInstallCommand) {
-        console.log('  - Install:');
-        console.log(`    $ ${torch.pipInstallCommand}`);
+        console.log(chalk.dim('     Install:'));
+        console.log(chalk.dim('       $ ') + chalk.cyan(torch.pipInstallCommand));
+      }
+      if (Array.isArray(torch.extraPackages) && torch.extraPackages.length) {
+        console.log(chalk.dim('     Extras:  ') + chalk.white(torch.extraPackages.join(', ')));
+      }
+      if (torch.notes) {
+        console.log(chalk.dim('     Notes:   ') + chalk.gray(torch.notes));
       }
-      if (Array.isArray(torch.extraPackages) && torch.extraPackages.length)
-        console.log(`  - Extra Packages:  ${torch.extraPackages.join(', ')}`);
-      if (torch.notes) console.log(`  - Notes:  ${torch.notes}`);
       console.log();
     }
 
     const gpu = result.gpuRecommendation;
     if (gpu) {
-      console.log(chalk.bold('🖥️ GPU Recommendation'));
-      if (gpu.minimumVramGb !== undefined) console.log(`  - Min VRAM: ${gpu.minimumVramGb} GB`);
-      if (gpu.recommendedVramGb !== undefined) console.log(`  - Recommended VRAM: ${gpu.recommendedVramGb} GB`);
-      if (gpu.minComputeCapability) console.log(`  - Min Compute Capability: ${gpu.minComputeCapability}`);
-      if (Array.isArray(gpu.recommendedModels) && gpu.recommendedModels.length)
-        console.log(`  - Recommended Models:  ${gpu.recommendedModels.join(', ')}`);
-      if (Array.isArray(gpu.budgetOptions) && gpu.budgetOptions.length)
-        console.log(`  - Budget Options:  ${gpu.budgetOptions.join(', ')}`);
-      if (Array.isArray(gpu.cloudInstances) && gpu.cloudInstances.length)
-        console.log(`  - Cloud Instances:  ${gpu.cloudInstances.join(', ')}`);
-      if (gpu.notes) console.log(`  - Notes:  ${gpu.notes}`);
+      console.log(chalk.bold.green('  🖥️  Hardware Requirements'));
+      if (gpu.minimumVramGb !== undefined) {
+        console.log(chalk.dim('     Min VRAM:      ') + chalk.white(`${gpu.minimumVramGb} GB`));
+      }
+      if (gpu.recommendedVramGb !== undefined) {
+        console.log(chalk.dim('     Optimal VRAM:  ') + chalk.white(`${gpu.recommendedVramGb} GB`));
+      }
+      if (gpu.minComputeCapability) {
+        console.log(chalk.dim('     Min Compute:   ') + chalk.white(gpu.minComputeCapability));
+      }
+      if (Array.isArray(gpu.recommendedModels) && gpu.recommendedModels.length) {
+        console.log(chalk.dim('     Recommended:   ') + chalk.white(gpu.recommendedModels.join(', ')));
+      }
+      if (Array.isArray(gpu.budgetOptions) && gpu.budgetOptions.length) {
+        console.log(chalk.dim('     Budget:        ') + chalk.white(gpu.budgetOptions.join(', ')));
+      }
+      if (Array.isArray(gpu.cloudInstances) && gpu.cloudInstances.length) {
+        console.log(chalk.dim('     Cloud:         ') + chalk.white(gpu.cloudInstances.join(', ')));
+      }
+      if (gpu.notes) {
+        console.log(chalk.dim('     Notes:         ') + chalk.gray(gpu.notes));
+      }
       console.log();
     }
 
-    // Print API key requirements if available
+    // Enhanced API key display
     if (result.requiredApiKeys && Array.isArray(result.requiredApiKeys) && result.requiredApiKeys.length > 0) {
-      // Separate critical and optional API keys
       const criticalKeys = result.requiredApiKeys.filter(key => key.priority === 'critical' || key.required);
       const optionalKeys = result.requiredApiKeys.filter(key => key.priority === 'optional' || !key.required);
       
       if (criticalKeys.length > 0) {
-        console.log(chalk.bold('🔑 CRITICAL API KEYS'));
+        console.log(chalk.bold.red('  🔑 Required API Keys'));
         criticalKeys.forEach(apiKey => {
-          console.log(`  - ${apiKey.name} ${chalk.red('(REQUIRED)')}`);
-          console.log(`    Service: ${apiKey.service}`);
-          console.log(`    Purpose: ${apiKey.description}`);
-          if (apiKey.example) console.log(`    Format: ${apiKey.example}`);
-          if (apiKey.documentation_url) console.log(`    Docs: ${apiKey.documentation_url}`);
-          console.log();
+          console.log(chalk.dim('     • ') + chalk.white(apiKey.name) + ' ' + chalk.red('(required)'));
+          console.log(chalk.dim('       Service: ') + chalk.gray(apiKey.service));
+          console.log(chalk.dim('       Purpose: ') + chalk.gray(apiKey.description));
+          if (apiKey.documentation_url) {
+            console.log(chalk.dim('       Docs:    ') + chalk.blue(apiKey.documentation_url));
+          }
         });
+        console.log();
       }
       
       if (optionalKeys.length > 0) {
-        console.log(chalk.bold('🔧 OPTIONAL API KEYS'));
+        console.log(chalk.bold.yellow('  🔧 Optional Enhancements'));
         optionalKeys.forEach(apiKey => {
-          console.log(`  - ${apiKey.name} ${chalk.yellow('(OPTIONAL)')}`);
-          console.log(`    Service: ${apiKey.service}`);
-          console.log(`    Purpose: ${apiKey.description}`);
-          if (apiKey.example) console.log(`    Format: ${apiKey.example}`);
-          if (apiKey.documentation_url) console.log(`    Docs: ${apiKey.documentation_url}`);
-          console.log();
+          console.log(chalk.dim('     • ') + chalk.white(apiKey.name) + ' ' + chalk.yellow('(optional)'));
+          console.log(chalk.dim('       Service: ') + chalk.gray(apiKey.service));
+          console.log(chalk.dim('       Purpose: ') + chalk.gray(apiKey.description));
+          if (apiKey.documentation_url) {
+            console.log(chalk.dim('       Docs:    ') + chalk.blue(apiKey.documentation_url));
+          }
         });
+        console.log();
       }
     }
   } catch {}
@@ -646,11 +676,11 @@ async function fetchFullSetupAndRecs(repoUrl, storedCredentials = null) {
           console.log(chalk.gray('🐛 DEBUG: Received response from API:'));
           console.log(chalk.gray('  - Response has commands:', !!data.commands));
           console.log(chalk.gray('  - Commands count:', data.commands ? data.commands.length : 0));
-          console.log(chalk.gray('  - Response has API keys:', !!data.requiredApiKeys));
-          console.log(chalk.gray('  - API keys count:', data.requiredApiKeys ? data.requiredApiKeys.length : 0));
-          console.log(chalk.gray('  - Response has GPU rec:', !!data.gpuRecommendation));
-          console.log(chalk.gray('  - Response has CUDA rec:', !!data.cudaRecommendation));
-          console.log(chalk.gray('  - Response has Torch rec:', !!data.torchRecommendation));
+          // console.log(chalk.gray('  - Response has API keys:', !!data.requiredApiKeys));
+          // console.log(chalk.gray('  - API keys count:', data.requiredApiKeys ? data.requiredApiKeys.length : 0));
+          // console.log(chalk.gray('  - Response has GPU rec:', !!data.gpuRecommendation));
+          // console.log(chalk.gray('  - Response has CUDA rec:', !!data.cudaRecommendation));
+          // console.log(chalk.gray('  - Response has Torch rec:', !!data.torchRecommendation));
           spinner.succeed('Repository analysis complete');
           return data;
         }
@@ -673,7 +703,7 @@ async function fetchFullSetupAndRecs(repoUrl, storedCredentials = null) {
 // Function to send user data to web application
 async function sendUserData(userId, userName, userEmail) {
   try {
-    console.log(chalk.blue(`🔗 Attempting to register user: ${userName} (${userId})`));
+    console.log(chalk.blue(`Attempting to register user: ${userName} (${userId})`));
     
     const userData = {
       email: userEmail,  // Use userId as email (assuming it's an email)
@@ -701,7 +731,7 @@ async function sendUserData(userId, userName, userEmail) {
       webhookUrl = process.env.GITARSENAL_WEBHOOK_URL;
     }
   
-    console.log(chalk.gray(`📦 Data: ${data}`));
+    console.log(chalk.gray(`Data: ${data}`));
     
     const urlObj = new URL(webhookUrl);
     const options = {
@@ -729,10 +759,10 @@ async function sendUserData(userId, userName, userEmail) {
         res.on('end', () => {
           
           if (res.statusCode >= 200 && res.statusCode < 300) {
-            console.log(chalk.green('✅ User registered on GitArsenal dashboard'));
+            console.log(chalk.green('User registered on GitArsenal dashboard'));
             resolve(responseData);
           } else if (res.statusCode === 409) {
-            console.log(chalk.green('✅ User already exists on GitArsenal dashboard'));
+            console.log(chalk.green('User already exists on GitArsenal dashboard'));
             resolve(responseData);
           } else {
             console.log(chalk.yellow(`⚠️  Failed to register user (status: ${res.statusCode})`));
@@ -970,6 +1000,7 @@ activateVirtualEnvironment();
 // Check for updates
 updateNotifier({ pkg }).notify();
 
+
 // Display banner
 
 try {
@@ -986,6 +1017,26 @@ try {
   }));
 }
 
+// Display info box first
+console.log(boxen(
+  chalk.bold.cyan('🚀 GitArsenal - GPU-Accelerated Development Environments') + '\n\n' +
+  chalk.white('Secure, cloud-based development environments with GPU acceleration.') + '\n' +
+  chalk.white('Everything runs safely in isolated containers - no risk to your system.') + '\n\n' +
+  chalk.green('✅ No local installation required') + '\n' +
+  chalk.green('✅ Instant access to powerful GPUs') + '\n' +
+  chalk.green('✅ Pre-configured for any repository') + '\n' +
+  chalk.green('✅ Secure cloud isolation') + '\n\n' +
+  chalk.gray('Your code is processed securely in the cloud.') + '\n' +
+  chalk.gray('No worries about dependencies or compatibility issues.'),
+  {
+    padding: 1,
+    margin: 0,
+    borderStyle: 'round',
+    borderColor: 'cyan',
+    fullscreen: true
+  }
+));
+
 // Set up main command
 program
   .version(version)
@@ -1070,7 +1121,7 @@ async function runContainerCommand(options) {
     const { userId, userName, userEmail } = userCredentials;
 
     // Register user on dashboard immediately after collecting credentials
-    console.log(chalk.blue('\n📝 Registering user on GitArsenal dashboard...'));
+    console.log(chalk.blue('\nRegistering user on GitArsenal dashboard...'));
     // Send user data immediately so the dashboard records users
     await sendUserData(userId, userName, userEmail);
 
@@ -1317,7 +1368,7 @@ async function handleKeysAdd(options) {
     const { userId, userName } = userCredentials;
     
     // Register user on dashboard
-    console.log(chalk.blue('\n📝 Registering user on GitArsenal dashboard...'));
+    console.log(chalk.blue('\nRegistering user on GitArsenal dashboard...'));
     // Note: User data will be sent by the Python script after authentication
     // await sendUserData(userId, userName);
     
@@ -1393,7 +1444,7 @@ async function handleKeysList() {
     const { userId, userName } = userCredentials;
     
     // Register user on dashboard
-    console.log(chalk.blue('\n📝 Registering user on GitArsenal dashboard...'));
+    console.log(chalk.blue('\nRegistering user on GitArsenal dashboard...'));
     // Note: User data will be sent by the Python script after authentication
     // await sendUserData(userId, userName);
     
@@ -1429,7 +1480,7 @@ async function handleKeysView(options) {
     const { userId, userName } = userCredentials;
     
     // Register user on dashboard
-    console.log(chalk.blue('\n📝 Registering user on GitArsenal dashboard...'));
+    console.log(chalk.blue('\nRegistering user on GitArsenal dashboard...'));
     // Note: User data will be sent by the Python script after authentication
     // await sendUserData(userId, userName);
     
@@ -1481,7 +1532,7 @@ async function handleKeysDelete(options) {
     const { userId, userName } = userCredentials;
     
     // Register user on dashboard
-    console.log(chalk.blue('\n📝 Registering user on GitArsenal dashboard...'));
+    console.log(chalk.blue('\nRegistering user on GitArsenal dashboard...'));
     // Note: User data will be sent by the Python script after authentication
     // await sendUserData(userId, userName);
     

package/kill_claude/README.md

@@ -69,7 +69,7 @@ kill_claude/
 1. **Clone or download** all the files to a directory
 2. **Install dependencies** (if needed):
    ```bash
-   pip install dataclasses  # Python 3.6 only, built-in for 3.7+
+   uv pip install dataclasses  # Python 3.6 only, built-in for 3.7+
    ```
 3. **Make the main script executable**:
    ```bash
@@ -138,7 +138,7 @@ python example_usage.py
 ### Code Execution  
 - `"run pytest"` - Execute commands
 - `"git status"` - Git operations
-- `"npm install express"` - Package management
+- `"uv pip install express"` - Package management
 
 ### Web Access
 - `"fetch https://api.github.com"` - Fetch web content

package/kill_claude/TUI_IMPROVEMENTS.md

@@ -0,0 +1,130 @@
+# 🎨 TUI Improvements for Claude Code Agent
+
+## Overview
+
+The Claude Code Agent now features a beautiful Terminal User Interface (TUI) powered by [Typer](https://typer.tiangolo.com/) and [Rich](https://rich.readthedocs.io/), providing:
+
+- **Beautiful colored output** with syntax highlighting
+- **Professional command-line interface** with proper help system  
+- **Rich formatting** for tool execution results
+- **Progress indicators** for long-running operations
+- **Structured panels** for better information organization
+
+## New Commands
+
+### Interactive Mode
+```bash
+python claude_code_agent.py interactive
+# or
+python claude_code_agent.py interactive --api-key your_key
+```
+
+### Single Query
+```bash
+python claude_code_agent.py query "your question here"
+# or  
+python claude_code_agent.py query "read main.py" --api-key your_key
+```
+
+### Setup Information
+```bash
+python claude_code_agent.py setup
+```
+
+### Help
+```bash
+python claude_code_agent.py --help
+```
+
+## Key Improvements
+
+### 1. Tool Execution Display
+- **Before**: Simple print statements with basic emojis
+- **After**: Rich panels with proper formatting, parameter tables, and progress indicators
+
+### 2. File Content Display  
+- **Before**: Plain text output
+- **After**: Syntax highlighted code with proper line numbers and file type detection
+
+### 3. Error Handling
+- **Before**: Plain error messages
+- **After**: Beautiful error panels with helpful instructions
+
+### 4. Help System
+- **Before**: Single text block
+- **After**: Organized columns with categorized commands and examples
+
+### 5. Status Display
+- **Before**: Simple text list  
+- **After**: Professional tables and trees showing system information
+
+### 6. Interactive Mode
+- **Before**: Basic input/output
+- **After**: Rich prompts, welcome banners, and formatted responses
+
+## Technical Details
+
+### Dependencies Added
+- `typer>=0.12.0` - Modern CLI framework
+- `rich>=13.0.0` - Rich text formatting and TUI components
+
+### Key Features Implemented
+
+#### Rich Console Integration
+- All output now uses Rich Console for beautiful formatting
+- Automatic color detection and fallback for different terminals
+- Consistent styling across all output types
+
+#### Smart Content Formatting
+- **Code files**: Automatic syntax highlighting based on file extension
+- **Directory listings**: Clean tree-like structure with proper indentation  
+- **Command output**: Color-coded based on success/error status
+- **Todo lists**: Professional tables with status indicators
+
+#### Progress Indicators
+- Spinning progress indicators for tool execution
+- Non-blocking progress display that disappears when complete
+- Clear visual feedback for long-running operations
+
+#### Error Handling
+- Beautiful error panels with clear instructions
+- Structured error information with proper styling
+- Helpful suggestions for common configuration issues
+
+### Backwards Compatibility
+
+The agent maintains full backwards compatibility:
+- `python claude_code_agent.py` still starts interactive mode
+- Single arguments are still treated as queries
+- All existing functionality preserved
+
+## Usage Examples
+
+### Beautiful File Reading
+When you run `query "read main.py"`, you now see:
+- Syntax highlighted code
+- Proper line numbers
+- Clean panel borders
+- File path information
+
+### Enhanced Todo Management  
+Todo lists are now displayed as professional tables with:
+- Status indicators (⏳ Pending, 🔄 In Progress, ✅ Completed)
+- Organized columns
+- Clean borders and styling
+
+### Improved Error Messages
+Configuration errors show:
+- Clear problem description
+- Step-by-step solutions
+- Proper color coding
+- Professional panel layout
+
+## Future Enhancements
+
+The TUI foundation enables future improvements like:
+- Interactive file selection
+- Real-time command output streaming  
+- Tabbed interfaces for multiple operations
+- Interactive configuration wizard
+- Dashboard views for project statistics

package/kill_claude/claude_code_agent.py

@@ -24,6 +24,17 @@ from typing import List, Dict, Any, Optional, Union
 from dataclasses import dataclass
 from enum import Enum
 import anthropic
+import typer
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+from rich.columns import Columns
+from rich.text import Text
+from rich.progress import Progress, SpinnerColumn, TextColumn
+from rich.tree import Tree
+from rich.syntax import Syntax
+from rich.prompt import Prompt
+from rich import print as rprint
 
 def load_tool_modules():
     """Load all tool modules from the tools directory."""
@@ -412,61 +423,165 @@ The following {len(TOOL_SCHEMAS)} tools are loaded and available:
         tool_name = tool_call.name
         tool_input = tool_call.input
         
-        # Print clean tool usage information like Claude Code
+        # Initialize Rich console for beautiful output
+        console = Console()
+        
+        # Create tool execution panel
+        tool_title = f"🛠️ Using Tool: {tool_name}"
         if total_calls > 1:
-            print(f"🛠️  Using tool: {tool_name}")
-        else:
-            print(f"🛠️  Using tool: {tool_name}")
-            
-        # Show parameters in a clean format
+            tool_title += f" ({call_num}/{total_calls})"
+        
+        # Format parameters beautifully
         if tool_input:
             # Special handling for TodoWrite to show actual todos
             if tool_name == "TodoWrite" and "todos" in tool_input:
                 todos = tool_input["todos"]
-                print(f"   Parameters: todos=[{len(todos)} items]")
-                if todos:
-                    print("   Todo Items:")
-                    for i, todo in enumerate(todos, 1):
-                        status_emoji = {"pending": "⏳", "in_progress": "🔄", "completed": "✅"}.get(todo.get("status", "pending"), "❓")
-                        content = todo.get("content", "No description")
-                        if len(content) > 60:
-                            content = content[:60] + "..."
-                        print(f"     {i}. {status_emoji} {content}")
+                
+                # Create todo table
+                todo_table = Table(show_header=True, header_style="bold magenta")
+                todo_table.add_column("#", style="dim", width=3)
+                todo_table.add_column("Status", width=10)
+                todo_table.add_column("Task", style="cyan")
+                
+                for i, todo in enumerate(todos, 1):
+                    status_emoji = {"pending": "⏳ Pending", "in_progress": "🔄 In Progress", "completed": "✅ Completed"}.get(todo.get("status", "pending"), "❓ Unknown")
+                    content = todo.get("content", "No description")
+                    if len(content) > 80:
+                        content = content[:80] + "..."
+                    todo_table.add_row(str(i), status_emoji, content)
+                
+                params_panel = Panel(
+                    todo_table,
+                    title=f"Todo List ({len(todos)} items)",
+                    border_style="blue"
+                )
             else:
-                params_display = []
+                # Format other parameters in a table
+                param_table = Table(show_header=True, header_style="bold green")
+                param_table.add_column("Parameter", style="yellow", width=20)
+                param_table.add_column("Value", style="white")
+                
                 for key, value in tool_input.items():
-                    if isinstance(value, str) and len(value) > 80:
-                        params_display.append(f"{key}={value[:80]}...")
-                    elif isinstance(value, list) and len(value) > 3:
-                        params_display.append(f"{key}=[{len(value)} items]")
+                    if isinstance(value, str) and len(value) > 100:
+                        display_value = value[:100] + "..."
+                    elif isinstance(value, list) and len(value) > 5:
+                        display_value = f"[List with {len(value)} items]"
+                    elif isinstance(value, dict):
+                        display_value = f"[Dict with {len(value)} keys]"
                     else:
-                        params_display.append(f"{key}={value}")
-                print(f"   Parameters: {', '.join(params_display)}")
+                        display_value = str(value)
+                    param_table.add_row(key, display_value)
+                
+                params_panel = Panel(
+                    param_table,
+                    title="Parameters",
+                    border_style="green"
+                )
+            
+            # Display tool info with parameters
+            console.print(Panel(
+                params_panel,
+                title=tool_title,
+                border_style="bright_blue",
+                padding=(0, 1)
+            ))
+        else:
+            # Display simple tool info without parameters
+            console.print(Panel(
+                "[dim]No parameters[/dim]",
+                title=tool_title,
+                border_style="bright_blue",
+                padding=(0, 1)
+            ))
         
         try:
-            # Execute the tool
-            result = self._execute_builtin_tool(tool_name, tool_input)
-            
-            # Print success message
-            print(f"\n✅ Tool {tool_name} completed successfully")
+            # Execute the tool with progress indicator
+            with Progress(
+                SpinnerColumn(),
+                TextColumn("[progress.description]{task.description}"),
+                console=console,
+                transient=True
+            ) as progress:
+                task = progress.add_task(f"Executing {tool_name}...", total=None)
+                result = self._execute_builtin_tool(tool_name, tool_input)
             
-            # Print result in a clean format
+            # Display success message with result
             if result and result.strip():
-                print(f"\n📋 Tool Result:")
-                # Truncate very long results for readability
-                if len(result) > 5000:
-                    print(result[:5000] + f"\n\n[Output truncated - showing first 5000 characters of {len(result)} total]")
+                # Format result based on content type
+                if tool_name == "Read" and "→" in result:  # File content with line numbers
+                    # Syntax highlight for code files
+                    if any(ext in str(tool_input.get('file_path', '')) for ext in ['.py', '.js', '.ts', '.json', '.yaml', '.md']):
+                        file_ext = str(tool_input.get('file_path', '')).split('.')[-1] if '.' in str(tool_input.get('file_path', '')) else 'text'
+                        lexer = {
+                            'py': 'python', 'js': 'javascript', 'ts': 'typescript', 
+                            'json': 'json', 'yaml': 'yaml', 'yml': 'yaml', 'md': 'markdown'
+                        }.get(file_ext, 'text')
+                        
+                        # Clean the line numbers for syntax highlighting
+                        clean_content = '\n'.join(line.split('→', 1)[1] if '→' in line else line for line in result.split('\n'))
+                        syntax = Syntax(clean_content, lexer, line_numbers=True, theme="monokai")
+                        result_panel = Panel(
+                            syntax,
+                            title=f"📄 File Content: {tool_input.get('file_path', 'Unknown')}",
+                            border_style="green"
+                        )
+                    else:
+                        result_panel = Panel(
+                            result,
+                            title="📄 File Content",
+                            border_style="green"
+                        )
+                elif tool_name == "LS":  # Directory listing
+                    result_panel = Panel(
+                        result,
+                        title="📁 Directory Contents",
+                        border_style="blue"
+                    )
+                elif tool_name == "Bash":  # Command output
+                    result_panel = Panel(
+                        Text(result, style="green" if "Error" not in result else "red"),
+                        title="💻 Command Output",
+                        border_style="yellow"
+                    )
                 else:
-                    print(result)
+                    # Truncate very long results for readability
+                    display_result = result
+                    if len(result) > 5000:
+                        display_result = result[:5000] + f"\n\n[dim][Output truncated - showing first 5000 characters of {len(result)} total][/dim]"
+                    
+                    result_panel = Panel(
+                        display_result,
+                        title="📋 Tool Result",
+                        border_style="green"
+                    )
+                
+                # Success panel
+                success_panel = Panel(
+                    f"✅ [bold green]Tool {tool_name} completed successfully[/bold green]",
+                    border_style="green",
+                    padding=(0, 1)
+                )
+                
+                console.print(success_panel)
+                console.print(result_panel)
             else:
-                print(f"\n📋 Tool Result: (no output)")
+                console.print(Panel(
+                    "✅ [bold green]Tool completed successfully[/bold green]\n[dim](no output)[/dim]",
+                    title=f"Tool {tool_name}",
+                    border_style="green",
+                    padding=(0, 1)
+                ))
             
-            print()  # Empty line for readability
+            console.print()  # Empty line for readability
             return result if result is not None else ""
                 
         except Exception as e:
-            print(f"\n❌ Tool {tool_name} failed: {str(e)}")
-            print()
+            console.print(Panel(
+                f"❌ [bold red]Tool {tool_name} failed:[/bold red]\n{str(e)}",
+                border_style="red",
+                padding=(0, 1)
+            ))
+            console.print()
             return f"Error executing {tool_name}: {str(e)}"
     
     def _execute_builtin_tool(self, tool_name: str, tool_input: Dict[str, Any]) -> str:
@@ -752,19 +867,35 @@ The following {len(TOOL_SCHEMAS)} tools are loaded and available:
     
     def interactive_mode(self):
         """
-        Run the agent in interactive mode, similar to Claude Code's CLI.
+        Run the agent in interactive mode with beautiful TUI using Rich and Typer.
         """
-        print("🤖 Claude Code Agent - Interactive Mode")
-        print("Powered by Anthropic API with claude-sonnet-4-20250514")
-        print("Type 'help' for available commands, 'exit' to quit")
-        print("-" * 60)
+        console = Console()
+        
+        # Welcome banner
+        welcome_panel = Panel(
+            "[bold blue]🤖 Claude Code Agent[/bold blue]\n" +
+            "[dim]Powered by Anthropic API with claude-sonnet-4-20250514[/dim]\n\n" +
+            "[yellow]Commands:[/yellow]\n" +
+            "• Type your request naturally\n" +
+            "• 'help' - Show available commands\n" +
+            "• 'status' - Show current status\n" +
+            "• 'exit' - Quit the agent",
+            title="🚀 Welcome to Interactive Mode",
+            border_style="bright_blue",
+            padding=(1, 2)
+        )
+        console.print(welcome_panel)
         
         while True:
             try:
-                user_input = input("\n👤 You: ").strip()
+                # Use Rich prompt for better input experience
+                user_input = Prompt.ask("\n[bold cyan]👤 You[/bold cyan]").strip()
                 
                 if user_input.lower() in ['exit', 'quit', 'bye']:
-                    print("👋 Goodbye!")
+                    console.print(Panel(
+                        "[bold yellow]👋 Thank you for using Claude Code Agent![/bold yellow]",
+                        border_style="yellow"
+                    ))
                     break
                 elif user_input.lower() == 'help':
                     self.show_help()
@@ -775,108 +906,281 @@ The following {len(TOOL_SCHEMAS)} tools are loaded and available:
                 elif not user_input:
                     continue
                 
-                print("🤖 Claude Code Agent:")
+                # Show that Claude is thinking
+                thinking_panel = Panel(
+                    "[bold blue]🤖 Claude Code Agent[/bold blue] is processing your request...",
+                    border_style="blue",
+                    padding=(0, 1)
+                )
+                console.print(thinking_panel)
+                
                 response = self.process_query(user_input)
                 if response.strip():
-                    print(response)
+                    response_panel = Panel(
+                        response,
+                        title="🤖 Claude Code Agent Response",
+                        border_style="bright_green",
+                        padding=(0, 1)
+                    )
+                    console.print(response_panel)
                 
             except KeyboardInterrupt:
-                print("\n\n👋 Goodbye!")
+                console.print("\n\n[bold yellow]👋 Goodbye![/bold yellow]")
                 break
             except Exception as e:
-                print(f"❌ Error: {str(e)}")
+                console.print(Panel(
+                    f"[bold red]❌ Error:[/bold red] {str(e)}",
+                    border_style="red"
+                ))
     
     def show_help(self):
-        """Show help information."""
-        help_text = """
-Available commands and capabilities:
-
-📁 File Operations:
-  - read <file>          : Read file contents
-  - list [directory]     : List files and directories
-  - find <pattern>       : Find files matching pattern
-  - edit <file>          : Edit file contents
-
-🔍 Search:
-  - search <term>        : Search in files
-  - web search <term>    : Search the web
-
-⚙️  Code Execution:
-  - run <command>        : Execute bash commands
-  - npm/pip/git commands : Execute package manager commands
-
-🌐 Web Access:
-  - fetch <url>          : Fetch content from URL
-  - web search <query>   : Search the web
-
-📋 Task Management:
-  - Complex tasks automatically create todo lists
-  - Multi-step operations are tracked
-
-💡 Examples:
-  - "read main.py"
-  - "search for TODO comments"
-  - "run pytest tests/"
-  - "implement user authentication system"
-  - "web search latest Python features 2024"
-
-Special commands:
-  - help    : Show this help
-  - status  : Show current status
-  - exit    : Quit the agent
-
-This agent uses the real Anthropic API with claude-sonnet-4-20250514
-and implements all Claude Code tools with proper system prompts.
-        """
-        print(help_text)
+        """Show help information with beautiful formatting."""
+        console = Console()
+        
+        # Create help sections
+        file_ops = Table(show_header=False, box=None, padding=(0, 1))
+        file_ops.add_column(style="yellow")
+        file_ops.add_column(style="white")
+        file_ops.add_row("read <file>", "Read file contents")
+        file_ops.add_row("list [directory]", "List files and directories")
+        file_ops.add_row("find <pattern>", "Find files matching pattern")
+        file_ops.add_row("edit <file>", "Edit file contents")
+        
+        search_ops = Table(show_header=False, box=None, padding=(0, 1))
+        search_ops.add_column(style="yellow")
+        search_ops.add_column(style="white")
+        search_ops.add_row("search <term>", "Search in files")
+        search_ops.add_row("web search <term>", "Search the web")
+        
+        code_ops = Table(show_header=False, box=None, padding=(0, 1))
+        code_ops.add_column(style="yellow")
+        code_ops.add_column(style="white")
+        code_ops.add_row("run <command>", "Execute bash commands")
+        code_ops.add_row("npm/uv pip/git commands", "Execute package manager commands")
+        
+        web_ops = Table(show_header=False, box=None, padding=(0, 1))
+        web_ops.add_column(style="yellow")
+        web_ops.add_column(style="white")
+        web_ops.add_row("fetch <url>", "Fetch content from URL")
+        web_ops.add_row("web search <query>", "Search the web")
+        
+        examples = Table(show_header=False, box=None, padding=(0, 1))
+        examples.add_column(style="green")
+        examples.add_row('"read main.py"')
+        examples.add_row('"search for TODO comments"')
+        examples.add_row('"run pytest tests/"')
+        examples.add_row('"implement user authentication system"')
+        examples.add_row('"web search latest Python features 2024"')
+        
+        special = Table(show_header=False, box=None, padding=(0, 1))
+        special.add_column(style="cyan")
+        special.add_column(style="white")
+        special.add_row("help", "Show this help")
+        special.add_row("status", "Show current status")
+        special.add_row("exit", "Quit the agent")
+        
+        # Create main help layout
+        help_panels = [
+            Panel(file_ops, title="📁 File Operations", border_style="blue"),
+            Panel(search_ops, title="🔍 Search", border_style="green"),
+            Panel(code_ops, title="⚙️ Code Execution", border_style="yellow"),
+            Panel(web_ops, title="🌐 Web Access", border_style="magenta"),
+            Panel("Complex tasks automatically create todo lists\nMulti-step operations are tracked", title="📋 Task Management", border_style="cyan"),
+            Panel(examples, title="💡 Examples", border_style="bright_green"),
+            Panel(special, title="🎮 Special Commands", border_style="red")
+        ]
+        
+        # Display help in columns
+        console.print(Panel(
+            Columns(help_panels, equal=True, expand=True),
+            title="🆘 Claude Code Agent Help",
+            subtitle="Powered by Anthropic API with claude-sonnet-4-20250514",
+            border_style="bright_blue",
+            padding=(1, 2)
+        ))
     
     def show_status(self):
-        """Show current status."""
-        print(f"""
-📊 Claude Code Agent Status:
-
-🔧 Configuration:
-  - API Key: {'✅ Set' if self.api_key else '❌ Missing'}
-  - Model: claude-sonnet-4-20250514
-  - Working Directory: {self.working_dir}
-  - Git Repository: {'Yes' if self.is_git_repo else 'No'}
+        """Show current status with beautiful formatting."""
+        console = Console()
+        
+        # Configuration status
+        config_table = Table(show_header=False, box=None)
+        config_table.add_column("Setting", style="yellow")
+        config_table.add_column("Value", style="green")
+        config_table.add_row("API Key", "✅ Set" if self.api_key else "❌ Missing")
+        config_table.add_row("Model", "claude-sonnet-4-20250514")
+        config_table.add_row("Working Directory", self.working_dir)
+        config_table.add_row("Git Repository", "Yes" if self.is_git_repo else "No")
+        
+        # Session status
+        session_table = Table(show_header=False, box=None)
+        session_table.add_column("Metric", style="yellow")
+        session_table.add_column("Count", style="cyan")
+        session_table.add_row("Conversation Messages", str(len(self.conversation_history)))
+        session_table.add_row("Todo Items", str(len(self.todo_list)))
+        session_table.add_row("Loaded Prompts", str(len(PROMPT_CONTENT)))
+        session_table.add_row("Available Tools", str(len(TOOL_SCHEMAS)))
+        
+        # Tools tree
+        tools_tree = Tree("🛠️ Available Tools")
+        for tool in TOOL_SCHEMAS:
+            tools_tree.add(f"[cyan]{tool['name']}[/cyan]")
+        
+        # Status panels
+        status_panels = [
+            Panel(config_table, title="🔧 Configuration", border_style="blue"),
+            Panel(session_table, title="📝 Session", border_style="green"),
+            Panel(tools_tree, title="🛠️ Tools", border_style="yellow")
+        ]
+        
+        console.print(Panel(
+            Columns(status_panels, equal=True),
+            title="📊 Claude Code Agent Status",
+            border_style="bright_blue",
+            padding=(1, 1)
+        ))
 
-📝 Session:
-  - Conversation History: {len(self.conversation_history)} messages
-  - Todo Items: {len(self.todo_list)} items
 
-📋 Loaded Prompts: {len(PROMPT_CONTENT)} markdown files
-  
-🛠️  Available Tools: {len(TOOL_SCHEMAS)} tools loaded from modules
-  - {', '.join([tool['name'] for tool in TOOL_SCHEMAS])}
-        """)
+# Create Typer app
+app = typer.Typer(
+    name="claude-code-agent",
+    help="🤖 Claude Code Agent - Anthropic API Integration with Beautiful TUI",
+    add_completion=False,
+    rich_markup_mode="rich"
+)
 
+@app.command()
+def interactive(
+    api_key: str = typer.Option(None, "--api-key", "-k", help="Anthropic API key (or set ANTHROPIC_API_KEY env var)"),
+):
+    """🚀 Start interactive mode with beautiful TUI."""
+    console = Console()
+    
+    try:
+        agent = ClaudeCodeAgent(api_key=api_key)
+        agent.interactive_mode()
+    except ValueError as e:
+        console.print(Panel(
+            f"[bold red]❌ Configuration Error:[/bold red]\n{str(e)}\n\n" +
+            "[yellow]To fix this:[/yellow]\n" +
+            "1. Get your Anthropic API key from: https://console.anthropic.com/\n" +
+            "2. Set environment variable: [cyan]export ANTHROPIC_API_KEY=your_key_here[/cyan]\n" +
+            "3. Or use: [cyan]--api-key your_key[/cyan] parameter",
+            title="Setup Required",
+            border_style="red"
+        ))
+        raise typer.Exit(1)
+    except Exception as e:
+        console.print(Panel(
+            f"[bold red]❌ Error:[/bold red] {str(e)}",
+            border_style="red"
+        ))
+        raise typer.Exit(1)
 
-def main():
-    """Main entry point for the Claude Code Agent."""
+@app.command()
+def query(
+    prompt: str = typer.Argument(..., help="Your query or command"),
+    api_key: str = typer.Option(None, "--api-key", "-k", help="Anthropic API key (or set ANTHROPIC_API_KEY env var)"),
+):
+    """💬 Process a single query and exit."""
+    console = Console()
+    
     try:
-        agent = ClaudeCodeAgent()
+        agent = ClaudeCodeAgent(api_key=api_key)
+        
+        # Show processing indicator
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            console=console,
+            transient=True
+        ) as progress:
+            task = progress.add_task("Processing your query...", total=None)
+            response = agent.process_query(prompt)
         
-        if len(sys.argv) > 1:
-            # Process single query from command line
-            query = ' '.join(sys.argv[1:])
-            response = agent.process_query(query)
-            print(response)
+        if response.strip():
+            console.print(Panel(
+                response,
+                title="🤖 Claude Code Agent Response",
+                border_style="bright_green"
+            ))
         else:
-            # Interactive mode
-            agent.interactive_mode()
+            console.print("[dim]No response generated.[/dim]")
             
     except ValueError as e:
-        print(f"❌ Configuration Error: {str(e)}")
-        print("\nTo fix this:")
-        print("1. Get your Anthropic API key from: https://console.anthropic.com/")
-        print("2. Set environment variable: export ANTHROPIC_API_KEY=your_key_here")
-        print("3. Or pass it as parameter: ClaudeCodeAgent(api_key='your_key')")
-        sys.exit(1)
+        console.print(Panel(
+            f"[bold red]❌ Configuration Error:[/bold red]\n{str(e)}\n\n" +
+            "[yellow]To fix this:[/yellow]\n" +
+            "1. Get your Anthropic API key from: https://console.anthropic.com/\n" +
+            "2. Set environment variable: [cyan]export ANTHROPIC_API_KEY=your_key_here[/cyan]\n" +
+            "3. Or use: [cyan]--api-key your_key[/cyan] parameter",
+            title="Setup Required",
+            border_style="red"
+        ))
+        raise typer.Exit(1)
     except Exception as e:
-        print(f"❌ Error: {str(e)}")
-        sys.exit(1)
+        console.print(Panel(
+            f"[bold red]❌ Error:[/bold red] {str(e)}",
+            border_style="red"
+        ))
+        raise typer.Exit(1)
+
+@app.command()
+def setup():
+    """⚙️ Show setup instructions and system info."""
+    console = Console()
+    
+    # System info
+    system_info = Table(show_header=False, box=None)
+    system_info.add_column("Property", style="yellow")
+    system_info.add_column("Value", style="cyan")
+    system_info.add_row("Platform", os.uname().sysname if hasattr(os, 'uname') else 'unknown')
+    system_info.add_row("Working Directory", os.getcwd())
+    system_info.add_row("Git Repository", "Yes" if os.path.exists('.git') else "No")
+    system_info.add_row("API Key Status", "✅ Set" if os.getenv('ANTHROPIC_API_KEY') else "❌ Missing")
+    
+    # Setup instructions
+    setup_instructions = """[bold yellow]1. Get your API key:[/bold yellow]
+   Visit: https://console.anthropic.com/
+
+[bold yellow]2. Set environment variable:[/bold yellow]
+   [cyan]export ANTHROPIC_API_KEY=your_key_here[/cyan]
+
+[bold yellow]3. Install dependencies:[/bold yellow]
+   [cyan]uv pip install -r requirements.txt[/cyan]
+
+[bold yellow]4. Run the agent:[/bold yellow]
+   [cyan]python claude_code_agent.py interactive[/cyan]
+   or
+   [cyan]python claude_code_agent.py query "your question"[/cyan]"""
+    
+    console.print(Panel(
+        Columns([
+            Panel(system_info, title="🔍 System Info", border_style="blue"),
+            Panel(setup_instructions, title="📋 Setup Instructions", border_style="green")
+        ], equal=True),
+        title="⚙️ Claude Code Agent Setup",
+        border_style="bright_blue",
+        padding=(1, 1)
+    ))
+
+def main():
+    """Main entry point - delegate to Typer app."""
+    app()
 
 
 if __name__ == "__main__":
-    main()
+    # Support legacy mode for backwards compatibility
+    if len(sys.argv) == 1:
+        # No arguments - start interactive mode
+        app(["interactive"])
+    elif len(sys.argv) == 2 and sys.argv[1] not in ["interactive", "query", "setup", "--help", "-h"]:
+        # Single argument that's not a command - treat as query
+        app(["query", sys.argv[1]])
+    elif len(sys.argv) > 2 and sys.argv[1] not in ["interactive", "query", "setup"]:
+        # Multiple arguments not starting with command - treat as query
+        query_text = " ".join(sys.argv[1:])
+        app(["query", query_text])
+    else:
+        # Use normal Typer command parsing
+        app()

package/kill_claude/requirements.txt

@@ -1 +1,3 @@
-anthropic>=0.25.0
+anthropic>=0.25.0
+typer>=0.12.0
+rich>=13.0.0

package/kill_claude/tools/bash_tool.py

@@ -51,7 +51,7 @@ class BashTool:
                     "type": "string"
                 },
                 "description": {
-                    "description": " Clear, concise description of what this command does in 5-10 words. Examples:\nInput: ls\nOutput: Lists files in current directory\n\nInput: git status\nOutput: Shows working tree status\n\nInput: npm install\nOutput: Installs package dependencies\n\nInput: mkdir foo\nOutput: Creates directory 'foo'",
+                    "description": " Clear, concise description of what this command does in 5-10 words. Examples:\nInput: ls\nOutput: Lists files in current directory\n\nInput: git status\nOutput: Shows working tree status\n\nInput: uv pip install\nOutput: Installs package dependencies\n\nInput: mkdir foo\nOutput: Creates directory 'foo'",
                     "type": "string"
                 },
                 "run_in_background": {

package/lib/sandbox.js

@@ -150,22 +150,26 @@ async function runContainer(options) {
     return new Promise((resolve, reject) => {
       pythonProcess.on('close', (code) => {
         if (code === 0) {
-          console.log(chalk.green('✅ Container launched successfully'));
+          console.log(chalk.green('✓ Environment ready'));
+          console.log(chalk.dim('  Your secure development environment is now active'));
           resolve();
         } else {
-          console.log(chalk.red(`❌ Container launch failed with exit code ${code}`));
+          console.log(chalk.red('✗ Launch failed'));
+          console.log(chalk.dim(`  Exit code: ${code}`));
           reject(new Error(`Process exited with code ${code}`));
         }
       });
       
       // Handle process errors
       pythonProcess.on('error', (error) => {
-        console.log(chalk.red(`❌ Failed to start Python process: ${error.message}`));
+        console.log(chalk.red('✗ Process error'));
+        console.log(chalk.dim(`  ${error.message}`));
         reject(error);
       });
     });
   } catch (error) {
-    console.log(chalk.red(`❌ Error launching container: ${error.message}`));
+    console.log(chalk.red('✗ Launch error'));
+    console.log(chalk.dim(`  ${error.message}`));
     throw error;
   }
 }

package/package.json

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