Comprehensive comparison for AI technology in applications

import anthropic
import os
from typing import List, Dict, Optional
import json
import logging
from datetime import datetime

# Configure logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

class CodeReviewAssistant:
    """
    Production-ready AI code review assistant using Anthropic's Claude API.
    Demonstrates cursor-based streaming for real-time feedback.
    """
    
    def __init__(self, api_key: Optional[str] = None):
        self.api_key = api_key or os.environ.get("ANTHROPIC_API_KEY")
        if not self.api_key:
            raise ValueError("API key must be provided or set in ANTHROPIC_API_KEY env var")
        self.client = anthropic.Anthropic(api_key=self.api_key)
        self.conversation_history: List[Dict] = []
    
    def review_code(self, code: str, language: str, focus_areas: List[str]) -> Dict:
        """
        Review code with streaming response using cursor pattern.
        
        Args:
            code: The code to review
            language: Programming language
            focus_areas: List of areas to focus on (e.g., 'security', 'performance')
        
        Returns:
            Dictionary containing review results and metadata
        """
        try:
            # Build the review prompt
            prompt = self._build_review_prompt(code, language, focus_areas)
            
            # Track streaming response
            full_response = ""
            start_time = datetime.now()
            
            # Stream response with cursor
            with self.client.messages.stream(
                model="claude-3-5-sonnet-20241022",
                max_tokens=2048,
                temperature=0.3,
                messages=[
                    {"role": "user", "content": prompt}
                ]
            ) as stream:
                for text in stream.text_stream:
                    full_response += text
                    # In production, you'd emit this to a websocket or SSE endpoint
                    logger.info(f"Streaming chunk: {text[:50]}...")
            
            # Calculate processing time
            processing_time = (datetime.now() - start_time).total_seconds()
            
            # Parse and structure the response
            review_result = {
                "status": "success",
                "review": full_response,
                "metadata": {
                    "language": language,
                    "focus_areas": focus_areas,
                    "processing_time_seconds": processing_time,
                    "timestamp": datetime.now().isoformat()
                }
            }
            
            # Store in conversation history for context
            self.conversation_history.append({
                "code": code,
                "review": full_response,
                "timestamp": datetime.now().isoformat()
            })
            
            return review_result
            
        except anthropic.APIError as e:
            logger.error(f"API error during code review: {str(e)}")
            return {
                "status": "error",
                "error": str(e),
                "error_type": "api_error"
            }
        except Exception as e:
            logger.error(f"Unexpected error during code review: {str(e)}")
            return {
                "status": "error",
                "error": str(e),
                "error_type": "unexpected_error"
            }
    
    def _build_review_prompt(self, code: str, language: str, focus_areas: List[str]) -> str:
        """Build a structured prompt for code review."""
        focus_str = ", ".join(focus_areas) if focus_areas else "general best practices"
        
        return f"""Please review the following {language} code with focus on: {focus_str}

Provide a structured review covering:
1. Issues found (with severity: critical/high/medium/low)
2. Specific recommendations
3. Code quality score (1-10)

Code to review:
```{language}
{code}
```

Provide actionable feedback in a clear, structured format."""

# Example usage
if __name__ == "__main__":
    assistant = CodeReviewAssistant()
    
    sample_code = """
    def process_payment(amount, user_id):
        # Process payment without validation
        db.execute(f"UPDATE accounts SET balance = balance - {amount} WHERE id = {user_id}")
        return True
    """
    
    result = assistant.review_code(
        code=sample_code,
        language="python",
        focus_areas=["security", "error_handling", "sql_injection"]
    )
    
    print(json.dumps(result, indent=2))