gitarsenal-cli 1.9.86 → 1.9.87

package/.venv_status.json

@@ -1 +1 @@
-{"created":"2025-08-20T12:56:37.874Z","packages":["modal","gitingest","requests","anthropic"],"uv_version":"uv 0.8.4 (Homebrew 2025-07-30)"}
+{"created":"2025-08-20T13:10:12.929Z","packages":["modal","gitingest","requests","anthropic"],"uv_version":"uv 0.8.4 (Homebrew 2025-07-30)"}

package/kill_claude/claude_code_agent.py

@@ -33,8 +33,11 @@ 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.prompt import Prompt, Confirm, IntPrompt
 from rich import print as rprint
+from rich.layout import Layout
+from rich.live import Live
+from pathlib import Path
 
 def load_tool_modules():
     """Load all tool modules from the tools directory."""
@@ -617,6 +620,10 @@ The following {len(TOOL_SCHEMAS)} tools are loaded and available:
             return self._get_bash_output(tool_input)
         elif tool_name == "KillBash":
             return self._kill_bash(tool_input)
+        elif tool_name == "WebSearch":
+            return self._web_search(tool_input)
+        elif tool_name == "WebFetch":
+            return self._web_fetch(tool_input)
         else:
             return f"Tool {tool_name} not implemented"
     
@@ -844,6 +851,60 @@ The following {len(TOOL_SCHEMAS)} tools are loaded and available:
         except Exception as e:
             return f"Error searching: {str(e)}"
     
+    def _web_search(self, tool_input: Dict[str, Any]) -> str:
+        """Handle WebSearch tool - search the web for information."""
+        query = tool_input.get('query', '')
+        allowed_domains = tool_input.get('allowed_domains', [])
+        blocked_domains = tool_input.get('blocked_domains', [])
+        
+        if not query:
+            return "Error: No search query provided"
+        
+        # Since we don't have actual web search capability, return a mock response
+        # In a real implementation, this would use a search API like Google, Bing, or DuckDuckGo
+        domain_filter = ""
+        if allowed_domains:
+            domain_filter = f" (restricted to: {', '.join(allowed_domains)})"
+        elif blocked_domains:
+            domain_filter = f" (excluding: {', '.join(blocked_domains)})"
+        
+        return f"""Web search results for: "{query}"{domain_filter}
+
+⚠️  Note: WebSearch is not fully implemented in this demo version.
+
+In a production environment, this would:
+• Search the web using APIs like Google Search API, Bing API, or similar
+• Return formatted search results with titles, snippets, and URLs
+• Support domain filtering as specified
+• Provide up-to-date information beyond the AI's knowledge cutoff
+
+Query processed: "{query}"
+Domain restrictions: {domain_filter if domain_filter else "None"}"""
+    
+    def _web_fetch(self, tool_input: Dict[str, Any]) -> str:
+        """Handle WebFetch tool - fetch content from a URL."""
+        url = tool_input.get('url', '')
+        prompt = tool_input.get('prompt', '')
+        
+        if not url:
+            return "Error: No URL provided"
+        
+        # Since we don't have actual web fetching capability, return a mock response
+        # In a real implementation, this would fetch the URL content and process it
+        return f"""WebFetch results for: {url}
+
+⚠️  Note: WebFetch is not fully implemented in this demo version.
+
+In a production environment, this would:
+• Fetch content from the specified URL
+• Convert HTML to markdown if needed
+• Process the content with the provided prompt: "{prompt}"
+• Return the AI model's analysis of the fetched content
+• Handle redirects and various content types
+
+URL to fetch: {url}
+Processing prompt: "{prompt}" """
+    
     def process_query(self, user_input: str) -> str:
         """
         Main method to process user queries using the Anthropic API.
@@ -1152,7 +1213,10 @@ def setup():
 [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]"""
+   [cyan]python claude_code_agent.py query "your question"[/cyan]
+
+[bold cyan]5. Quick setup:[/bold cyan]
+   [cyan]python claude_code_agent.py configure[/cyan]"""
     
     console.print(Panel(
         Columns([
@@ -1164,6 +1228,287 @@ def setup():
         padding=(1, 1)
     ))
 
+@app.command()
+def configure(
+    reset: bool = typer.Option(False, "--reset", "-r", help="Reset configuration to defaults")
+):
+    """🔧 Interactive configuration wizard"""
+    console = Console()
+    config_file = Path.home() / ".claude_code_agent.json"
+    
+    if reset:
+        if config_file.exists():
+            config_file.unlink()
+        console.print("✓ [green]Configuration reset to defaults[/green]")
+        return
+    
+    console.print(Panel(
+        "[bold blue]🔧 Claude Code Agent Configuration Wizard[/bold blue]\n" +
+        "This will help you set up your preferences and API credentials.",
+        title="Configuration Wizard",
+        border_style="blue"
+    ))
+    
+    # Load existing config
+    config = {}
+    if config_file.exists():
+        with open(config_file) as f:
+            config = json.load(f)
+        console.print(f"[dim]Found existing config at: {config_file}[/dim]")
+    
+    # API Key configuration
+    current_api_key = config.get('api_key') or os.getenv('ANTHROPIC_API_KEY')
+    if current_api_key:
+        console.print(f"✓ [green]API Key is already configured[/green]")
+        if not Confirm.ask("Would you like to update it?"):
+            api_key = current_api_key
+        else:
+            api_key = typer.prompt("Enter your Anthropic API key", hide_input=True)
+    else:
+        console.print("✗ [red]API Key not found[/red]")
+        api_key = typer.prompt("Enter your Anthropic API key", hide_input=True)
+    
+    # Model selection
+    models = [
+        "claude-sonnet-4-20250514",
+        "claude-3-5-sonnet-20241022", 
+        "claude-3-opus-20240229",
+        "claude-3-haiku-20240307"
+    ]
+    current_model = config.get('default_model', models[0])
+    console.print(f"\nCurrent model: [cyan]{current_model}[/cyan]")
+    
+    model_choice = typer.prompt(
+        "Select model", 
+        type=typer.Choice(models),
+        default=current_model
+    )
+    
+    # Timeout configuration
+    current_timeout = config.get('default_timeout', 120)
+    timeout = IntPrompt.ask(
+        "Default timeout (seconds)", 
+        default=current_timeout,
+        show_default=True
+    )
+    
+    # Tool preferences
+    console.print("\n[bold]Tool Preferences:[/bold]")
+    use_progress_bars = Confirm.ask(
+        "Show progress bars for long operations?", 
+        default=config.get('use_progress_bars', True)
+    )
+    
+    auto_todos = Confirm.ask(
+        "Automatically create todo lists for complex tasks?",
+        default=config.get('auto_todos', True) 
+    )
+    
+    syntax_highlighting = Confirm.ask(
+        "Enable syntax highlighting for code files?",
+        default=config.get('syntax_highlighting', True)
+    )
+    
+    # Save configuration
+    new_config = {
+        'api_key': api_key,
+        'default_model': model_choice,
+        'default_timeout': timeout,
+        'use_progress_bars': use_progress_bars,
+        'auto_todos': auto_todos,
+        'syntax_highlighting': syntax_highlighting,
+        'configured_at': str(datetime.now())
+    }
+    
+    # Ensure config directory exists
+    config_file.parent.mkdir(exist_ok=True)
+    
+    with open(config_file, 'w') as f:
+        json.dump(new_config, f, indent=2)
+    
+    # Show summary
+    summary_table = Table(title="Configuration Summary", show_header=True)
+    summary_table.add_column("Setting", style="yellow")
+    summary_table.add_column("Value", style="green")
+    
+    summary_table.add_row("API Key", "✓ Configured" if api_key else "✗ Missing")
+    summary_table.add_row("Model", model_choice)
+    summary_table.add_row("Timeout", f"{timeout}s")
+    summary_table.add_row("Progress Bars", "✓ Enabled" if use_progress_bars else "✗ Disabled")
+    summary_table.add_row("Auto Todos", "✓ Enabled" if auto_todos else "✗ Disabled")
+    summary_table.add_row("Syntax Highlighting", "✓ Enabled" if syntax_highlighting else "✗ Disabled")
+    summary_table.add_row("Config File", str(config_file))
+    
+    console.print(Panel(
+        summary_table,
+        title="✓ Configuration Complete",
+        border_style="green"
+    ))
+
+@app.command()
+def browse():
+    """📁 Interactive file browser"""
+    console = Console()
+    current_dir = Path.cwd()
+    
+    while True:
+        # List directory contents
+        items = []
+        if current_dir.parent != current_dir:  # Not root
+            items.append((".. (parent directory)", current_dir.parent, "dir"))
+        
+        for item in sorted(current_dir.iterdir()):
+            if item.is_dir():
+                items.append((f"{item.name}/", item, "dir"))
+            else:
+                size = item.stat().st_size
+                size_str = f"{size:,} bytes" if size < 1024 else f"{size//1024:,} KB"
+                items.append((f"{item.name} ({size_str})", item, "file"))
+        
+        # Create selection table
+        table = Table(title=f"Directory: {current_dir}", show_header=True)
+        table.add_column("#", style="dim", width=3)
+        table.add_column("Type", width=4)
+        table.add_column("Name", style="cyan")
+        
+        for i, (display_name, path, item_type) in enumerate(items, 1):
+            icon = "📁" if item_type == "dir" else "📄"
+            table.add_row(str(i), icon, display_name)
+        
+        console.clear()
+        console.print(table)
+        
+        # Get user choice
+        console.print("\n[dim]Commands: [cyan]number[/cyan] to select, [cyan]q[/cyan] to quit, [cyan]r[/cyan] to read file[/dim]")
+        choice = typer.prompt("Select item")
+        
+        if choice.lower() == 'q':
+            break
+        elif choice.lower() == 'r':
+            file_num = typer.prompt("File number to read", type=int)
+            if 1 <= file_num <= len(items):
+                selected_path = items[file_num - 1][1]
+                if selected_path.is_file():
+                    try:
+                        # Read file directly without requiring API key
+                        with open(selected_path, 'r', encoding='utf-8') as f:
+                            lines = f.readlines()
+                        
+                        # Format with line numbers
+                        formatted_lines = []
+                        for i, line in enumerate(lines[:100], 1):  # Limit to 100 lines
+                            clean_line = line.rstrip('\n\r')
+                            if len(clean_line) > 2000:
+                                clean_line = clean_line[:2000] + "..."
+                            formatted_lines.append(f"{i:>5}→{clean_line}")
+                        
+                        content = '\n'.join(formatted_lines)
+                        if len(lines) > 100:
+                            content += f"\n... (showing first 100 lines of {len(lines)} total)"
+                        
+                        console.print(Panel(
+                            content,
+                            title=f"📄 {selected_path.name}",
+                            border_style="blue"
+                        ))
+                        typer.prompt("Press Enter to continue")
+                    except Exception as e:
+                        console.print(f"[red]✗ Error reading file: {e}[/red]")
+        else:
+            try:
+                choice_num = int(choice)
+                if 1 <= choice_num <= len(items):
+                    selected_path = items[choice_num - 1][1]
+                    if selected_path.is_dir():
+                        current_dir = selected_path
+                    else:
+                        console.print(f"Selected file: [cyan]{selected_path}[/cyan]")
+                        break
+            except ValueError:
+                console.print("[red]Invalid choice[/red]")
+                typer.prompt("Press Enter to continue")
+
+@app.command()
+def templates():
+    """🎨 Manage project templates"""
+    console = Console()
+    
+    # Built-in templates
+    builtin_templates = {
+        "python-basic": {
+            "description": "Basic Python project structure",
+            "files": {
+                "main.py": "#!/usr/bin/env python3\n\nif __name__ == '__main__':\n    print('Hello, World!')\n",
+                "requirements.txt": "",
+                "README.md": "# Project\n\nDescription here.\n"
+            }
+        },
+        "python-package": {
+            "description": "Python package with setup.py",
+            "files": {
+                "setup.py": "from setuptools import setup, find_packages\n\nsetup(\n    name='my-package',\n    version='0.1.0',\n    packages=find_packages(),\n)\n",
+                "my_package/__init__.py": "",
+                "my_package/main.py": "def main():\n    pass\n",
+                "requirements.txt": "",
+                "README.md": "# My Package\n"
+            }
+        },
+        "claude-agent": {
+            "description": "Claude Code Agent project structure",
+            "files": {
+                "main.py": "#!/usr/bin/env python3\nfrom claude_code_agent import ClaudeCodeAgent\n\ndef main():\n    agent = ClaudeCodeAgent()\n    agent.interactive_mode()\n\nif __name__ == '__main__':\n    main()\n",
+                "requirements.txt": "anthropic>=0.25.0\ntyper>=0.12.0\nrich>=13.0.0\n",
+                "README.md": "# Claude Agent Project\n\nA project using Claude Code Agent.\n",
+                ".env.example": "ANTHROPIC_API_KEY=your_key_here\n"
+            }
+        }
+    }
+    
+    # List available templates
+    table = Table(title="Available Templates", show_header=True)
+    table.add_column("Name", style="cyan")
+    table.add_column("Description", style="yellow")
+    table.add_column("Files", style="green")
+    
+    for name, template in builtin_templates.items():
+        file_count = len(template["files"])
+        table.add_row(name, template["description"], f"{file_count} files")
+    
+    console.print(table)
+    
+    template_name = typer.prompt("Select template to create")
+    if template_name not in builtin_templates:
+        console.print(f"[red]✗ Template '{template_name}' not found[/red]")
+        return
+    
+    project_name = typer.prompt("Project name")
+    project_dir = Path.cwd() / project_name
+    
+    if project_dir.exists():
+        if not Confirm.ask(f"Directory {project_name} exists. Continue?"):
+            return
+    
+    project_dir.mkdir(exist_ok=True)
+    template = builtin_templates[template_name]
+    
+    # Create files with progress bar
+    with Progress() as progress:
+        task = progress.add_task("Creating project...", total=len(template["files"]))
+        
+        for file_path, content in template["files"].items():
+            full_path = project_dir / file_path
+            full_path.parent.mkdir(parents=True, exist_ok=True)
+            full_path.write_text(content)
+            progress.advance(task)
+    
+    console.print(Panel(
+        f"✓ [green]Project '{project_name}' created successfully![/green]\n" +
+        f"Location: [cyan]{project_dir}[/cyan]\n" +
+        f"Template: [yellow]{template_name}[/yellow]",
+        title="Project Created",
+        border_style="green"
+    ))
+
 def main():
     """Main entry point - delegate to Typer app."""
     app()

package/package.json

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