gitarsenal-cli 1.9.64 → 1.9.66

package/kill_claude/claude_code_agent.py

@@ -0,0 +1,848 @@
+#!/usr/bin/env python3
+"""
+Claude Code Agent - Anthropic API Integration
+
+This is the main file that replicates Claude Code's functionality by using the Anthropic API
+with proper tool orchestration and system prompt integration.
+
+Features:
+- Real Anthropic API integration using claude-3-5-sonnet-20241022
+- Dynamic loading of tool implementations from tools/ directory
+- System prompt integration from prompts/ directory
+- Tool orchestration with intelligent selection and execution
+- Task management with TodoWrite integration
+- Interactive CLI mode similar to Claude Code
+"""
+
+import os
+import sys
+import json
+import re
+import glob
+import importlib.util
+from typing import List, Dict, Any, Optional, Union
+from dataclasses import dataclass
+from enum import Enum
+import anthropic
+
+def load_tool_modules():
+    """Load all tool modules from the tools directory."""
+    tools_dir = os.path.join(os.path.dirname(__file__), 'tools')
+    tool_modules = {}
+    
+    for tool_file in glob.glob(os.path.join(tools_dir, '*_tool.py')):
+        if os.path.basename(tool_file) == '__init__.py':
+            continue
+            
+        module_name = os.path.basename(tool_file)[:-3]  # Remove .py
+        spec = importlib.util.spec_from_file_location(module_name, tool_file)
+        if spec and spec.loader:
+            module = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(module)
+            
+            # Find tool class in module
+            for attr_name in dir(module):
+                attr = getattr(module, attr_name)
+                if (hasattr(attr, 'name') and hasattr(attr, 'schema') and 
+                    callable(getattr(attr, 'schema', None))):
+                    tool_modules[attr.name] = attr
+                    break
+    
+    return tool_modules
+
+def load_system_prompts():
+    """Load all markdown files from prompts directory."""
+    prompts_dir = os.path.join(os.path.dirname(__file__), 'prompts')
+    prompt_content = {}
+    
+    for md_file in glob.glob(os.path.join(prompts_dir, '*.md')):
+        filename = os.path.basename(md_file)
+        try:
+            with open(md_file, 'r', encoding='utf-8') as f:
+                content = f.read()
+                prompt_content[filename] = content
+        except Exception as e:
+            print(f"Warning: Could not load {filename}: {e}")
+    
+    return prompt_content
+
+# Load tools and prompts dynamically
+TOOL_MODULES = load_tool_modules()
+PROMPT_CONTENT = load_system_prompts()
+
+# Generate tool schemas from loaded modules
+TOOL_SCHEMAS = []
+for tool_name, tool_class in TOOL_MODULES.items():
+    schema = tool_class.schema()
+    TOOL_SCHEMAS.append({
+        "name": tool_name,
+        "description": getattr(tool_class, '__doc__', f"Tool: {tool_name}"),
+        "input_schema": schema
+    })
+
+# Combine all prompt content into system prompt
+def build_system_prompt():
+    """Build the complete system prompt from all markdown files."""
+    prompt_parts = []
+    
+    # Start with the main system prompt
+    if 'claude-code-system-prompt.md' in PROMPT_CONTENT:
+        prompt_parts.append(PROMPT_CONTENT['claude-code-system-prompt.md'])
+    
+    # Add other prompt files in a logical order
+    prompt_order = [
+        'claude-code-security-constraints.md',
+        'claude-code-response-formatting.md', 
+        'claude-code-task-workflows.md',
+        'claude-code-tool-usage-policies.md',
+        'claude-code-tool-prompts.md',
+        'claude-code-git-workflows.md',
+        'claude-code-hook-system.md',
+        'claude-code-environment-context.md',
+        'claude-code-agent-prompts.md',
+        'claude-code-system-reminders.md',
+        'claude-code-thinking-mode-prompts.md'
+    ]
+    
+    for filename in prompt_order:
+        if filename in PROMPT_CONTENT:
+            prompt_parts.append(f"\n\n# {filename.replace('.md', '').replace('-', ' ').title()}\n")
+            prompt_parts.append(PROMPT_CONTENT[filename])
+    
+    return '\n'.join(prompt_parts)
+
+
+class QueryIntent(Enum):
+    """Different types of user intents that can be handled."""
+    FILE_OPERATION = "file_operation"
+    SEARCH = "search" 
+    CODE_EXECUTION = "code_execution"
+    WEB_ACCESS = "web_access"
+    TASK_MANAGEMENT = "task_management"
+    PLANNING = "planning"
+    INFORMATION = "information"
+    COMPLEX_TASK = "complex_task"
+
+
+@dataclass
+class UserQuery:
+    """Represents a parsed user query with intent and parameters."""
+    text: str
+    intent: QueryIntent
+    confidence: float
+    extracted_params: Dict[str, Any]
+    suggested_tools: List[str]
+
+
+class ClaudeCodeAgent:
+    """
+    Main agent that orchestrates all tools using the Anthropic API.
+    
+    This class replicates Claude Code's behavior by:
+    1. Using the actual Anthropic API with claude-3-5-sonnet-20241022
+    2. Implementing all tool schemas exactly as Claude Code uses them
+    3. Using the proper system prompt for agent control
+    4. Managing tasks with TodoWrite integration
+    5. Providing an interactive CLI interface
+    """
+    
+    def __init__(self, api_key: Optional[str] = None):
+        """Initialize the Claude Code Agent with Anthropic API integration."""
+        # Get API key from parameter or environment
+        self.api_key = api_key or os.getenv('ANTHROPIC_API_KEY')
+        if not self.api_key:
+            raise ValueError(
+                "Anthropic API key is required. Set ANTHROPIC_API_KEY environment variable "
+                "or pass api_key parameter."
+            )
+        
+        # Initialize Anthropic client
+        self.client = anthropic.Anthropic(api_key=self.api_key)
+        
+        # Environment context
+        self.working_dir = os.getcwd()
+        self.platform = os.uname().sysname.lower() if hasattr(os, 'uname') else 'unknown'
+        self.os_version = os.uname().release if hasattr(os, 'uname') else 'unknown'
+        
+        # Check if git repo
+        self.is_git_repo = os.path.exists(os.path.join(self.working_dir, '.git'))
+        
+        # Current date
+        from datetime import datetime
+        self.today_date = datetime.now().strftime('%Y-%m-%d')
+        
+        # Conversation state
+        self.conversation_history = []
+        self.todo_list = []
+        
+        # Tool usage patterns for query parsing
+        self.tool_patterns = {
+            # File operations
+            r'\b(read|open|show|view|cat)\s+(.+\.(py|js|ts|md|txt|json|yaml|yml|html|css))\b': 'Read',
+            r'\b(write|create|make)\s+(file|script)\b': 'Write',
+            r'\b(edit|modify|change|update|replace)\s+(.+)\b': 'Edit',
+            r'\b(list|ls|show)\s+(files|directory|dir)\b': 'LS',
+            
+            # Search operations
+            r'\b(find|search|grep|look\s+for)\s+(.+)\b': 'Grep',
+            r'\b(find|search)\s+files?\s+(.+)\b': 'Glob',
+            
+            # Code execution
+            r'\b(run|execute|bash|shell|command)\s+(.+)\b': 'Bash',
+            r'\b(npm|pip|git|python|node|cargo)\s+(.+)\b': 'Bash',
+            
+            # Web access
+            r'\b(fetch|get|download|web|url)\s+(.+)\b': 'WebFetch',
+            r'\b(search\s+web|google|search\s+for)\s+(.+)\b': 'WebSearch',
+            
+            # Task management
+            r'\b(todo|task|plan|organize)\b': 'TodoWrite',
+            r'\b(help\s+me|implement|build|create)\s+(.+)\b': 'Task',
+        }
+    
+    def get_system_prompt(self) -> str:
+        """Get the system prompt with environment context filled in."""
+        base_prompt = build_system_prompt()
+        
+        # Add environment context
+        env_context = f"""
+
+# Environment Information
+<env>
+Working directory: {self.working_dir}
+Is directory a git repo: {"Yes" if self.is_git_repo else "No"}
+Platform: {self.platform}
+OS Version: {self.os_version}
+Today's date: {self.today_date}
+</env>
+
+# Available Tools
+The following {len(TOOL_SCHEMAS)} tools are loaded and available:
+{', '.join([tool['name'] for tool in TOOL_SCHEMAS])}
+"""
+        
+        return base_prompt + env_context
+    
+    def parse_query(self, query: str) -> UserQuery:
+        """
+        Parse user query to understand intent and extract parameters.
+        
+        Args:
+            query: The user's input query
+            
+        Returns:
+            UserQuery object with parsed information
+        """
+        query_lower = query.lower().strip()
+        
+        # Determine intent based on keywords and patterns
+        intent = QueryIntent.INFORMATION  # default
+        confidence = 0.5
+        extracted_params = {}
+        suggested_tools = []
+        
+        # Check for specific patterns
+        for pattern, tool in self.tool_patterns.items():
+            if re.search(pattern, query_lower):
+                suggested_tools.append(tool)
+                confidence = 0.8
+                
+                # Extract parameters from the match
+                match = re.search(pattern, query_lower)
+                if match and len(match.groups()) > 0:
+                    # Get the last capturing group that has content
+                    for i in range(len(match.groups()), 0, -1):
+                        if match.group(i):
+                            extracted_params['target'] = match.group(i).strip()
+                            break
+        
+        # Determine primary intent
+        if any(tool in ['Read', 'Write', 'Edit', 'LS', 'Glob'] for tool in suggested_tools):
+            intent = QueryIntent.FILE_OPERATION
+        elif any(tool in ['Grep', 'WebSearch'] for tool in suggested_tools):
+            intent = QueryIntent.SEARCH
+        elif 'Bash' in suggested_tools:
+            intent = QueryIntent.CODE_EXECUTION
+        elif any(tool in ['WebFetch', 'WebSearch'] for tool in suggested_tools):
+            intent = QueryIntent.WEB_ACCESS
+        elif 'TodoWrite' in suggested_tools:
+            intent = QueryIntent.TASK_MANAGEMENT
+        elif 'Task' in suggested_tools:
+            intent = QueryIntent.COMPLEX_TASK
+            
+        # Look for complex multi-step queries
+        complex_indicators = ['implement', 'build', 'create', 'develop', 'setup', 'configure']
+        if any(indicator in query_lower for indicator in complex_indicators):
+            intent = QueryIntent.COMPLEX_TASK
+            confidence = 0.9
+            suggested_tools = ['TodoWrite', 'Task'] + suggested_tools
+            
+        return UserQuery(
+            text=query,
+            intent=intent,
+            confidence=confidence,
+            extracted_params=extracted_params,
+            suggested_tools=list(set(suggested_tools))  # Remove duplicates
+        )
+    
+    def should_use_todo_list(self, query: UserQuery) -> bool:
+        """
+        Determine if the query requires using TodoWrite for task management.
+        
+        Based on Claude Code's criteria:
+        - Complex multi-step tasks (3+ steps)
+        - Non-trivial and complex tasks
+        - User explicitly requests todo list
+        - Multiple tasks provided
+        """
+        complex_keywords = [
+            'implement', 'build', 'create', 'develop', 'setup', 'configure',
+            'refactor', 'optimize', 'migrate', 'integrate', 'deploy'
+        ]
+        
+        multi_step_indicators = [
+            'and then', 'after that', 'next', 'also', 'additionally',
+            'first', 'second', 'then', 'finally'
+        ]
+        
+        # Check for complexity
+        has_complex_keywords = any(keyword in query.text.lower() for keyword in complex_keywords)
+        has_multi_step = any(indicator in query.text.lower() for indicator in multi_step_indicators)
+        has_multiple_sentences = len(query.text.split('.')) > 2
+        explicit_todo = 'todo' in query.text.lower() or 'task' in query.text.lower()
+        
+        return (has_complex_keywords or has_multi_step or 
+                has_multiple_sentences or explicit_todo or
+                query.intent == QueryIntent.COMPLEX_TASK)
+    
+    def call_api(self, user_message: str, use_tools: bool = True) -> str:
+        """
+        Make an API call to Claude with proper tool handling - matches Claude Code exactly.
+        
+        Args:
+            user_message: The user's message/query
+            use_tools: Whether to include tools in the API call
+            
+        Returns:
+            Claude's response text
+        """
+        try:
+            # Start conversation with user message
+            messages = self.conversation_history + [
+                {"role": "user", "content": user_message}
+            ]
+            
+            # Continue conversation until Claude stops making tool calls
+            final_response_text = ""
+            
+            while True:
+                # Make API call
+                call_params = {
+                    "model": "claude-sonnet-4-20250514",
+                    "max_tokens": 4096,
+                    "system": self.get_system_prompt(),
+                    "messages": messages
+                }
+                
+                if use_tools:
+                    call_params["tools"] = TOOL_SCHEMAS
+                
+                response = self.client.messages.create(**call_params)
+                
+                # Extract response content and tool calls
+                response_text = ""
+                tool_calls = []
+                
+                for content_block in response.content:
+                    if content_block.type == "text":
+                        response_text += content_block.text
+                    elif content_block.type == "tool_use":
+                        tool_calls.append(content_block)
+                
+                # Add response text to final output
+                if response_text.strip():
+                    final_response_text += response_text
+                
+                # Update conversation with assistant response
+                messages.append({"role": "assistant", "content": response.content})
+                
+                # If no tool calls, we're done
+                if not tool_calls:
+                    break
+                
+                # Execute tool calls
+                if tool_calls:
+                    print(f"🤖 Claude requested {len(tool_calls)} tool call(s)")
+                    tool_results = []
+                    
+                    for i, tool_call in enumerate(tool_calls, 1):
+                        print(f"--- Tool Call {i}/{len(tool_calls)} ---")
+                        result = self.execute_tool_call(tool_call)
+                        
+                        # Display the tool result
+                        if result and result.strip():
+                            print(f"📋 Tool Result:")
+                            print(result)
+                            print()  # Empty line for readability
+                        else:
+                            print("📋 Tool Result: (empty or no output)")
+                            print()
+                        
+                        tool_results.append({
+                            "tool_use_id": tool_call.id,
+                            "type": "tool_result",
+                            "content": str(result)
+                        })
+                    
+                    # Add tool results to conversation
+                    messages.append({
+                        "role": "user",
+                        "content": tool_results
+                    })
+            
+            # Update conversation history
+            self.conversation_history = messages
+            
+            return final_response_text.strip()
+            
+        except Exception as e:
+            return f"Error calling Anthropic API: {str(e)}"
+    
+    def execute_tool_call(self, tool_call) -> str:
+        """
+        Execute a tool call using the loaded tool implementations.
+        
+        Args:
+            tool_call: The tool call object from Claude
+            
+        Returns:
+            Tool execution result as string
+        """
+        tool_name = tool_call.name
+        tool_input = tool_call.input
+        
+        # Print tool usage information
+        print(f"🛠️  Using tool: {tool_name}")
+        if tool_input:
+            # Show key parameters (truncate long values)
+            params_display = []
+            for key, value in tool_input.items():
+                if isinstance(value, str) and len(value) > 50:
+                    params_display.append(f"{key}='{value[:50]}...'")
+                else:
+                    params_display.append(f"{key}={repr(value)}")
+            print(f"   Parameters: {', '.join(params_display)}")
+        print()  # Empty line for readability
+        
+        try:
+            # Always use built-in implementations
+            result = self._execute_builtin_tool(tool_name, tool_input)
+            print(f"✅ Tool {tool_name} completed successfully\n")
+            return result if result is not None else ""
+                
+        except Exception as e:
+            print(f"❌ Tool {tool_name} failed: {str(e)}\n")
+            return f"Error executing {tool_name}: {str(e)}"
+    
+    def _execute_builtin_tool(self, tool_name: str, tool_input: Dict[str, Any]) -> str:
+        """Execute built-in tool implementations."""
+        if tool_name == "Read":
+            return self._read_file(tool_input.get("file_path", ""), 
+                                 tool_input.get("limit"), 
+                                 tool_input.get("offset"))
+        elif tool_name == "LS":
+            return self._list_directory(tool_input.get("path", ""), 
+                                      tool_input.get("ignore", []))
+        elif tool_name == "Bash":
+            return self._execute_command(tool_input.get("command", ""), 
+                                       tool_input.get("timeout", 30000))
+        elif tool_name == "TodoWrite":
+            return self._update_todos(tool_input.get("todos", []))
+        elif tool_name == "Write":
+            return self._write_file(tool_input.get("file_path", ""), 
+                                  tool_input.get("content", ""))
+        elif tool_name == "Edit":
+            return self._edit_file(tool_input.get("file_path", ""),
+                                 tool_input.get("old_string", ""),
+                                 tool_input.get("new_string", ""),
+                                 tool_input.get("replace_all", False))
+        elif tool_name == "Glob":
+            return self._glob_files(tool_input.get("pattern", ""),
+                                  tool_input.get("path"))
+        elif tool_name == "Grep":
+            return self._grep_search(tool_input)
+        elif tool_name == "Task":
+            return self._handle_task(tool_input)
+        elif tool_name == "BashOutput":
+            return self._get_bash_output(tool_input)
+        elif tool_name == "KillBash":
+            return self._kill_bash(tool_input)
+        else:
+            return f"Tool {tool_name} not implemented"
+    
+    def _handle_task(self, tool_input: Dict[str, Any]) -> str:
+        """Handle Task tool - delegate to another agent instance."""
+        description = tool_input.get("description", "")
+        prompt = tool_input.get("prompt", "")
+        subagent_type = tool_input.get("subagent_type", "general-purpose")
+        
+        # For now, just return a message indicating task delegation
+        return f"Task '{description}' has been delegated to {subagent_type} subagent. Prompt: {prompt[:100]}..."
+    
+    def _get_bash_output(self, tool_input: Dict[str, Any]) -> str:
+        """Handle BashOutput tool."""
+        bash_id = tool_input.get("bash_id", "")
+        return f"No background bash sessions are currently running (ID: {bash_id})"
+    
+    def _kill_bash(self, tool_input: Dict[str, Any]) -> str:
+        """Handle KillBash tool."""
+        shell_id = tool_input.get("shell_id", "")
+        return f"No bash session found with ID: {shell_id}"
+    
+    def _read_file(self, file_path: str, limit: Optional[int] = None, offset: Optional[int] = None) -> str:
+        """Read file with Claude Code formatting."""
+        try:
+            if not os.path.exists(file_path):
+                return f"File not found: {file_path}"
+            
+            with open(file_path, 'r', encoding='utf-8') as f:
+                lines = f.readlines()
+            
+            # Apply offset and limit
+            start_idx = (offset or 1) - 1
+            end_idx = start_idx + (limit or len(lines))
+            lines = lines[start_idx:end_idx]
+            
+            # Format with line numbers like Claude Code
+            formatted_lines = []
+            for i, line in enumerate(lines):
+                line_num = start_idx + i + 1
+                # Remove trailing newline and truncate if too long
+                clean_line = line.rstrip('\n')
+                if len(clean_line) > 2000:
+                    clean_line = clean_line[:2000] + "..."
+                formatted_lines.append(f"{line_num:>5}→{clean_line}")
+            
+            return '\n'.join(formatted_lines)
+        except Exception as e:
+            return f"Error reading file: {str(e)}"
+    
+    def _list_directory(self, path: str, ignore: List[str] = None) -> str:
+        """List directory contents with Claude Code formatting."""
+        try:            
+            if not os.path.exists(path):
+                return f"Directory not found: {path}"
+            if not os.path.isdir(path):
+                return f"Not a directory: {path}"
+            
+            items = []
+            all_items = os.listdir(path)
+            
+            for item in sorted(all_items):
+                if ignore:
+                    import fnmatch
+                    if any(fnmatch.fnmatch(item, pattern) for pattern in ignore):
+                        continue
+                
+                item_path = os.path.join(path, item)
+                if os.path.isdir(item_path):
+                    items.append(f"  - {item}/")
+                else:
+                    items.append(f"  - {item}")
+            
+            result = f"- {path}/\n" + '\n'.join(items)
+            return result
+            
+        except Exception as e:
+            return f"Error listing directory: {str(e)}"
+    
+    def _execute_command(self, command: str, timeout_ms: int = 30000) -> str:
+        """Execute bash command."""
+        import subprocess
+        try:
+            timeout_sec = timeout_ms / 1000.0
+            
+            result = subprocess.run(
+                command,
+                shell=True,
+                capture_output=True,
+                text=True,
+                timeout=timeout_sec,
+                cwd=self.working_dir
+            )
+            
+            output_parts = []
+            
+            # Add stdout if present
+            if result.stdout and result.stdout.strip():
+                output_parts.append(result.stdout.strip())
+            
+            # Add stderr if present  
+            if result.stderr and result.stderr.strip():
+                output_parts.append(result.stderr.strip())
+            
+            # If command failed, include exit code
+            if result.returncode != 0:
+                if not output_parts:
+                    output_parts.append(f"Command failed with exit code {result.returncode}")
+                else:
+                    output_parts.insert(0, f"Exit code: {result.returncode}")
+            
+            # If no output at all but success, indicate success
+            if not output_parts and result.returncode == 0:
+                output_parts.append("<system>Tool ran without output or errors</system>")
+            
+            return "\n".join(output_parts)
+            
+        except subprocess.TimeoutExpired:
+            return f"Command timed out after {timeout_sec} seconds"
+        except Exception as e:
+            return f"Error executing command: {str(e)}"
+    
+    def _update_todos(self, todos: List[Dict]) -> str:
+        """Update todo list."""
+        self.todo_list = todos
+        return f"Todos have been modified successfully. Ensure that you continue to use the todo list to track your progress. Please proceed with the current tasks if applicable"
+    
+    def _write_file(self, file_path: str, content: str) -> str:
+        """Write content to file."""
+        try:
+            os.makedirs(os.path.dirname(file_path), exist_ok=True)
+            with open(file_path, 'w', encoding='utf-8') as f:
+                f.write(content)
+            return f"File created successfully at: {file_path}"
+        except Exception as e:
+            return f"Error writing file: {str(e)}"
+    
+    def _edit_file(self, file_path: str, old_string: str, new_string: str, replace_all: bool = False) -> str:
+        """Edit file by replacing strings."""
+        try:
+            if not os.path.exists(file_path):
+                return f"File not found: {file_path}"
+            
+            with open(file_path, 'r', encoding='utf-8') as f:
+                content = f.read()
+            
+            if old_string not in content:
+                return f"String not found in file: {old_string}"
+            
+            if replace_all:
+                new_content = content.replace(old_string, new_string)
+                count = content.count(old_string)
+            else:
+                new_content = content.replace(old_string, new_string, 1)
+                count = 1
+            
+            with open(file_path, 'w', encoding='utf-8') as f:
+                f.write(new_content)
+            
+            return f"The file {file_path} has been updated. Here's the result of running `cat -n` on a snippet of the edited file:\n{self._read_file(file_path, 10, 1)}"
+        except Exception as e:
+            return f"Error editing file: {str(e)}"
+    
+    def _glob_files(self, pattern: str, path: str = None) -> str:
+        """Find files matching glob pattern."""
+        try:
+            import glob as glob_module
+            search_path = os.path.join(path or self.working_dir, pattern)
+            matches = glob_module.glob(search_path, recursive=True)
+            
+            if not matches:
+                return f"No files found matching pattern: {pattern}"
+            
+            # Sort by modification time (most recent first)
+            matches.sort(key=lambda x: os.path.getmtime(x), reverse=True)
+            return '\n'.join(matches[:100])  # Limit to first 100 matches
+        except Exception as e:
+            return f"Error finding files: {str(e)}"
+    
+    def _grep_search(self, tool_input: Dict[str, Any]) -> str:
+        """Search for pattern in files using basic implementation."""
+        try:
+            pattern = tool_input.get('pattern', '')
+            path = tool_input.get('path', self.working_dir)
+            case_insensitive = tool_input.get('-i', False)
+            output_mode = tool_input.get('output_mode', 'files_with_matches')
+            
+            import re as regex
+            flags = regex.IGNORECASE if case_insensitive else 0
+            compiled_pattern = regex.compile(pattern, flags)
+            
+            matches = []
+            search_files = []
+            
+            # Collect files to search
+            if os.path.isfile(path):
+                search_files = [path]
+            else:
+                for root, dirs, files in os.walk(path):
+                    for file in files:
+                        if file.endswith(('.py', '.js', '.ts', '.md', '.txt', '.json', '.yaml', '.yml')):
+                            search_files.append(os.path.join(root, file))
+            
+            for file_path in search_files:
+                try:
+                    with open(file_path, 'r', encoding='utf-8') as f:
+                        content = f.read()
+                        if compiled_pattern.search(content):
+                            matches.append(file_path)
+                except:
+                    continue
+            
+            if output_mode == 'files_with_matches':
+                return '\n'.join(matches) if matches else "No matches found"
+            else:
+                return f"Found {len(matches)} matching files"
+        except Exception as e:
+            return f"Error searching: {str(e)}"
+    
+    def process_query(self, user_input: str) -> str:
+        """
+        Main method to process user queries using the Anthropic API.
+        
+        Args:
+            user_input: The user's query string
+            
+        Returns:
+            Claude's response
+        """
+        if not user_input.strip():
+            return "Please provide a query or command."
+        
+        # Parse the query to understand intent
+        query = self.parse_query(user_input)
+        
+        # Call the Anthropic API with the full system prompt and tools
+        response = self.call_api(user_input, use_tools=True)
+        
+        return response
+    
+    def interactive_mode(self):
+        """
+        Run the agent in interactive mode, similar to Claude Code's CLI.
+        """
+        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)
+        
+        while True:
+            try:
+                user_input = input("\n👤 You: ").strip()
+                
+                if user_input.lower() in ['exit', 'quit', 'bye']:
+                    print("👋 Goodbye!")
+                    break
+                elif user_input.lower() == 'help':
+                    self.show_help()
+                    continue
+                elif user_input.lower() == 'status':
+                    self.show_status()
+                    continue
+                elif not user_input:
+                    continue
+                
+                print("🤖 Claude Code Agent:")
+                response = self.process_query(user_input)
+                print(response)
+                
+            except KeyboardInterrupt:
+                print("\n\n👋 Goodbye!")
+                break
+            except Exception as e:
+                print(f"❌ Error: {str(e)}")
+    
+    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)
+    
+    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'}
+
+📝 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])}
+        """)
+
+
+def main():
+    """Main entry point for the Claude Code Agent."""
+    try:
+        agent = ClaudeCodeAgent()
+        
+        if len(sys.argv) > 1:
+            # Process single query from command line
+            query = ' '.join(sys.argv[1:])
+            response = agent.process_query(query)
+            print(response)
+        else:
+            # Interactive mode
+            agent.interactive_mode()
+            
+    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)
+    except Exception as e:
+        print(f"❌ Error: {str(e)}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()