shadowzzh

agent_new.py

agent_new.py
"""
Comprehensive Coding Agent - Modular implementation with pure Python tools
All tools implemented without command-line dependencies
"""

import os
import json
from typing import List, Dict, Any, Optional, Iterator
from pathlib import Path
from datetime import datetime
import anthropic

from system_state import SystemState
from tool_registry import ToolRegistry


class CodingAgent:
    """Main coding agent with streaming support and modular tool system"""
    
    def __init__(self, api_key: str, model: str = "claude-sonnet-4-20250514", base_url: Optional[str] = None):
        """
        Initialize coding agent
        
        Args:
            api_key: API key for Anthropic/OpenRouter
            model: Model identifier
            base_url: Optional base URL for OpenRouter or other providers
        """
        self.api_key = api_key
        self.model = model
        self.base_url = base_url
        self.system_state = SystemState()
        self.tool_registry = ToolRegistry()
        self.messages: List[Dict[str, Any]] = []
        self.tools = self._load_tools()
        self.system_prompt = self._load_system_prompt()
        
        # Initialize Anthropic client
        if base_url:
            self.client = anthropic.Anthropic(api_key=api_key, base_url=base_url)
        else:
            self.client = anthropic.Anthropic(api_key=api_key)
    
    def _load_tools(self) -> List[Dict[str, Any]]:
        """Load tool definitions from tools.json"""
        tools_file = Path(__file__).parent / "tools.json"
        with open(tools_file, 'r') as f:
            data = json.load(f)
        return data["tools"]
    
    def _load_system_prompt(self) -> str:
        """Load system prompt from system-prompt.md"""
        prompt_file = Path(__file__).parent / "system-prompt.md"
        with open(prompt_file, 'r') as f:
            content = f.read()
        
        # Inject current environment information
        content = content.replace("${Working directory}", self.system_state.current_directory)
        content = content.replace("${current_branch}", self._get_git_branch())
        content = content.replace("${main_branch}", self._get_main_branch())
        content = content.replace("${Last 5 Recent commits}", self._get_recent_commits())
        
        return content
    
    def _get_git_branch(self) -> str:
        """Get current git branch"""
        try:
            import subprocess
            return subprocess.getoutput("git branch --show-current") or "unknown"
        except:
            return "unknown"
    
    def _get_main_branch(self) -> str:
        """Get main branch name"""
        try:
            import subprocess
            branches = subprocess.getoutput("git branch -a")
            if "main" in branches:
                return "main"
            elif "master" in branches:
                return "master"
            return "main"
        except:
            return "main"
    
    def _get_git_status(self) -> str:
        """Get git status"""
        try:
            import subprocess
            return subprocess.getoutput("git status --short") or "No changes"
        except:
            return "Not a git repository"
    
    def _get_recent_commits(self) -> str:
        """Get recent commits"""
        try:
            import subprocess
            return subprocess.getoutput("git log --oneline -5") or "No commits"
        except:
            return "Not a git repository"
    
    def run(self, user_message: str, max_iterations: int = 50) -> Iterator[Dict[str, Any]]:
        """
        Run agent with streaming output
        
        Args:
            user_message: User's input message
            max_iterations: Maximum number of agent iterations
            
        Yields:
            Streaming events with type and content
        """
        # Add user message with timestamp
        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        self.messages.append({
            "role": "user",
            "content": f"[{timestamp}] {user_message}"
        })
        
        yield {"type": "user_message", "content": user_message, "timestamp": timestamp}
        
        for iteration in range(max_iterations):
            yield {"type": "iteration_start", "iteration": iteration + 1}
            
            # Prepare messages with system hint
            messages_with_hint = self.messages.copy()
            
            # Add system hint as a user message at the end
            system_hint = self.system_state.get_system_hint()
            messages_with_hint.append({
                "role": "user",
                "content": f"<system_hint>\n{system_hint}\n</system_hint>"
            })
            
            # Call Claude API with streaming
            try:
                with self.client.messages.stream(
                    model=self.model,
                    system=self.system_prompt,
                    messages=messages_with_hint,
                    tools=self.tools
                ) as stream:
                    assistant_message = {"role": "assistant", "content": []}
                    current_text = ""
                    current_tool_use = None
                    
                    for event in stream:
                        if event.type == "content_block_start":
                            if event.content_block.type == "text":
                                current_text = ""
                            elif event.content_block.type == "tool_use":
                                current_tool_use = {
                                    "type": "tool_use",
                                    "id": event.content_block.id,
                                    "name": event.content_block.name,
                                    "input": {}
                                }
                        
                        elif event.type == "content_block_delta":
                            if event.delta.type == "text_delta":
                                current_text += event.delta.text
                                yield {
                                    "type": "text_delta",
                                    "delta": event.delta.text,
                                    "accumulated": current_text
                                }
                            elif event.delta.type == "input_json_delta":
                                # Accumulate tool input
                                if current_tool_use:
                                    try:
                                        current_tool_use["input"] = json.loads(
                                            event.delta.partial_json
                                        )
                                    except:
                                        pass
                        
                        elif event.type == "content_block_stop":
                            if current_text:
                                assistant_message["content"].append({
                                    "type": "text",
                                    "text": current_text
                                })
                                current_text = ""
                            elif current_tool_use:
                                assistant_message["content"].append(current_tool_use)
                                yield {
                                    "type": "tool_call",
                                    "tool": current_tool_use["name"],
                                    "input": current_tool_use["input"]
                                }
                                current_tool_use = None
                    
                    # Add assistant message to history
                    self.messages.append(assistant_message)
                    
                    # Check if we have tool calls to execute
                    tool_calls = [
                        block for block in assistant_message["content"]
                        if block.get("type") == "tool_use"
                    ]
                    
                    if not tool_calls:
                        # No tool calls, agent is done
                        yield {"type": "done", "final_message": assistant_message}
                        break
                    
                    # Execute tool calls
                    tool_results = []
                    for tool_call in tool_calls:
                        tool_name = tool_call["name"]
                        tool_input = tool_call["input"]
                        
                        yield {
                            "type": "tool_execution_start",
                            "tool": tool_name,
                            "input": tool_input
                        }
                        
                        # Get tool instance and execute
                        try:
                            tool = self.tool_registry.get_tool(tool_name, self.system_state)
                            result = tool.execute(tool_input)
                            result_dict = result.to_dict()
                        except Exception as e:
                            result_dict = {
                                "error": str(e),
                                "tool": tool_name
                            }
                        
                        yield {
                            "type": "tool_execution_complete",
                            "tool": tool_name,
                            "result": result_dict
                        }
                        
                        tool_results.append({
                            "type": "tool_result",
                            "tool_use_id": tool_call["id"],
                            "content": json.dumps(result_dict, ensure_ascii=False)
                        })
                    
                    # Add tool results to messages
                    self.messages.append({
                        "role": "user",
                        "content": tool_results
                    })
                    
                    yield {"type": "iteration_end", "iteration": iteration + 1}
            
            except Exception as e:
                yield {"type": "error", "error": str(e)}
                break
        
        else:
            # Reached max iterations
            yield {"type": "max_iterations_reached", "max_iterations": max_iterations}
    
    def reset(self):
        """Reset agent state"""
        self.messages = []
        self.system_state = SystemState()


def main():
    """Example usage"""
    api_key = os.getenv("ANTHROPIC_API_KEY")
    if not api_key:
        print("Error: ANTHROPIC_API_KEY environment variable not set")
        return
    
    agent = CodingAgent(api_key=api_key)
    
    user_query = "List all Python files in the current directory using the Glob tool"
    
    print(f"User: {user_query}\n")
    
    for event in agent.run(user_query):
        if event["type"] == "text_delta":
            print(event["delta"], end="", flush=True)
        elif event["type"] == "tool_call":
            print(f"\n[Calling tool: {event['tool']}]")
        elif event["type"] == "tool_execution_complete":
            print(f"[Tool completed]")
        elif event["type"] == "done":
            print("\n\nAgent completed successfully!")
        elif event["type"] == "error":
            print(f"\n\nError: {event['error']}")


if __name__ == "__main__":
    main()