claude-dev-cli 0.13.3__py3-none-any.whl → 0.16.0__py3-none-any.whl

claude_dev_cli/providers/anthropic.py

@@ -0,0 +1,216 @@
+"""Anthropic (Claude) AI provider implementation."""
+
+import json
+from datetime import datetime
+from typing import Iterator, Optional, List, Dict, Any
+from anthropic import Anthropic, APIError
+
+from claude_dev_cli.providers.base import (
+    AIProvider,
+    ModelInfo,
+    UsageInfo,
+    InsufficientCreditsError,
+    ProviderConnectionError,
+    ModelNotFoundError,
+)
+
+
+class AnthropicProvider(AIProvider):
+    """Anthropic Claude API provider implementation."""
+    
+    # Known Claude models with their capabilities
+    KNOWN_MODELS = {
+        "claude-3-5-haiku-20241022": {
+            "display_name": "Claude 3.5 Haiku",
+            "context_window": 200000,
+            "input_price": 0.80,
+            "output_price": 4.00,
+            "capabilities": ["chat", "code", "analysis"]
+        },
+        "claude-sonnet-4-5-20250929": {
+            "display_name": "Claude Sonnet 4.5",
+            "context_window": 200000,
+            "input_price": 3.00,
+            "output_price": 15.00,
+            "capabilities": ["chat", "code", "analysis", "vision"]
+        },
+        "claude-opus-4-20250514": {
+            "display_name": "Claude Opus 4",
+            "context_window": 200000,
+            "input_price": 15.00,
+            "output_price": 75.00,
+            "capabilities": ["chat", "code", "analysis", "vision", "research"]
+        },
+        # Legacy models
+        "claude-3-5-sonnet-20241022": {
+            "display_name": "Claude 3.5 Sonnet",
+            "context_window": 200000,
+            "input_price": 3.00,
+            "output_price": 15.00,
+            "capabilities": ["chat", "code", "analysis", "vision"]
+        },
+    }
+    
+    def __init__(self, config: Any) -> None:
+        """Initialize Anthropic provider.
+        
+        Args:
+            config: ProviderConfig or APIConfig with api_key
+        """
+        super().__init__(config)
+        
+        # Extract API key from config
+        api_key = getattr(config, 'api_key', None)
+        if not api_key:
+            raise ValueError("Anthropic provider requires api_key in config")
+        
+        self.client = Anthropic(api_key=api_key)
+        self.last_usage: Optional[UsageInfo] = None
+    
+    def call(
+        self,
+        prompt: str,
+        system_prompt: Optional[str] = None,
+        model: Optional[str] = None,
+        max_tokens: Optional[int] = None,
+        temperature: float = 1.0,
+    ) -> str:
+        """Make a synchronous call to Claude API."""
+        model = model or "claude-sonnet-4-5-20250929"
+        max_tokens = max_tokens or 4096
+        
+        kwargs: Dict[str, Any] = {
+            "model": model,
+            "max_tokens": max_tokens,
+            "temperature": temperature,
+            "messages": [{"role": "user", "content": prompt}]
+        }
+        
+        if system_prompt:
+            kwargs["system"] = system_prompt
+        
+        start_time = datetime.utcnow()
+        
+        try:
+            response = self.client.messages.create(**kwargs)
+        except APIError as e:
+            # Check for insufficient credits
+            if e.status_code == 400 and "credit balance" in str(e).lower():
+                raise InsufficientCreditsError(
+                    f"Insufficient credits for Anthropic API: {e}",
+                    provider="anthropic"
+                )
+            elif e.status_code == 404:
+                raise ModelNotFoundError(
+                    f"Model not found: {model}",
+                    model=model,
+                    provider="anthropic"
+                )
+            else:
+                raise ProviderConnectionError(
+                    f"Anthropic API error: {e}",
+                    provider="anthropic"
+                )
+        
+        end_time = datetime.utcnow()
+        duration_ms = int((end_time - start_time).total_seconds() * 1000)
+        
+        # Calculate cost
+        model_info = self.KNOWN_MODELS.get(model, {})
+        input_price = model_info.get("input_price", 0.0)
+        output_price = model_info.get("output_price", 0.0)
+        
+        input_cost = (response.usage.input_tokens / 1_000_000) * input_price
+        output_cost = (response.usage.output_tokens / 1_000_000) * output_price
+        total_cost = input_cost + output_cost
+        
+        # Store usage info
+        self.last_usage = UsageInfo(
+            input_tokens=response.usage.input_tokens,
+            output_tokens=response.usage.output_tokens,
+            duration_ms=duration_ms,
+            model=model,
+            timestamp=end_time,
+            cost_usd=total_cost
+        )
+        
+        # Extract text from response
+        text_blocks = [
+            block.text for block in response.content if hasattr(block, 'text')
+        ]
+        return '\n'.join(text_blocks)
+    
+    def call_streaming(
+        self,
+        prompt: str,
+        system_prompt: Optional[str] = None,
+        model: Optional[str] = None,
+        max_tokens: Optional[int] = None,
+        temperature: float = 1.0,
+    ) -> Iterator[str]:
+        """Make a streaming call to Claude API."""
+        model = model or "claude-sonnet-4-5-20250929"
+        max_tokens = max_tokens or 4096
+        
+        kwargs: Dict[str, Any] = {
+            "model": model,
+            "max_tokens": max_tokens,
+            "temperature": temperature,
+            "messages": [{"role": "user", "content": prompt}]
+        }
+        
+        if system_prompt:
+            kwargs["system"] = system_prompt
+        
+        try:
+            with self.client.messages.stream(**kwargs) as stream:
+                for text in stream.text_stream:
+                    yield text
+        except APIError as e:
+            if e.status_code == 400 and "credit balance" in str(e).lower():
+                raise InsufficientCreditsError(
+                    f"Insufficient credits for Anthropic API: {e}",
+                    provider="anthropic"
+                )
+            else:
+                raise ProviderConnectionError(
+                    f"Anthropic API error: {e}",
+                    provider="anthropic"
+                )
+    
+    def list_models(self) -> List[ModelInfo]:
+        """List available Claude models."""
+        models = []
+        for model_id, info in self.KNOWN_MODELS.items():
+            models.append(ModelInfo(
+                model_id=model_id,
+                display_name=info["display_name"],
+                provider="anthropic",
+                context_window=info["context_window"],
+                input_price_per_mtok=info["input_price"],
+                output_price_per_mtok=info["output_price"],
+                capabilities=info["capabilities"]
+            ))
+        return models
+    
+    def get_last_usage(self) -> Optional[UsageInfo]:
+        """Get usage information from the last API call."""
+        return self.last_usage
+    
+    @property
+    def provider_name(self) -> str:
+        """Get the provider's name."""
+        return "anthropic"
+    
+    def test_connection(self) -> bool:
+        """Test if the Anthropic API is accessible."""
+        try:
+            # Make a minimal API call to test credentials
+            response = self.client.messages.create(
+                model="claude-3-5-haiku-20241022",
+                max_tokens=10,
+                messages=[{"role": "user", "content": "test"}]
+            )
+            return True
+        except APIError:
+            return False

claude_dev_cli/providers/base.py

@@ -0,0 +1,168 @@
+"""Abstract base class for AI providers."""
+
+from abc import ABC, abstractmethod
+from typing import Iterator, Optional, Dict, Any, List
+from dataclasses import dataclass
+from datetime import datetime
+
+
+@dataclass
+class ModelInfo:
+    """Information about an AI model."""
+    
+    model_id: str
+    display_name: str
+    provider: str
+    context_window: int
+    input_price_per_mtok: float
+    output_price_per_mtok: float
+    capabilities: List[str]  # e.g., ["chat", "code", "vision"]
+
+
+@dataclass
+class UsageInfo:
+    """Usage information for a single API call."""
+    
+    input_tokens: int
+    output_tokens: int
+    duration_ms: int
+    model: str
+    timestamp: datetime
+    cost_usd: float
+
+
+class AIProvider(ABC):
+    """Abstract base class for AI provider implementations.
+    
+    All AI providers (Anthropic, OpenAI, Ollama, etc.) must implement this interface.
+    This allows the CLI to work with any provider transparently.
+    """
+    
+    def __init__(self, config: Any) -> None:
+        """Initialize provider with configuration.
+        
+        Args:
+            config: Provider-specific configuration (ProviderConfig)
+        """
+        self.config = config
+    
+    @abstractmethod
+    def call(
+        self,
+        prompt: str,
+        system_prompt: Optional[str] = None,
+        model: Optional[str] = None,
+        max_tokens: Optional[int] = None,
+        temperature: float = 1.0,
+    ) -> str:
+        """Make a synchronous call to the AI provider.
+        
+        Args:
+            prompt: User prompt/message
+            system_prompt: Optional system prompt for context
+            model: Model ID or profile name to use
+            max_tokens: Maximum tokens in response
+            temperature: Sampling temperature (0.0-2.0)
+            
+        Returns:
+            The AI's text response
+            
+        Raises:
+            ProviderError: On API errors
+            InsufficientCreditsError: When credits are too low
+        """
+        pass
+    
+    @abstractmethod
+    def call_streaming(
+        self,
+        prompt: str,
+        system_prompt: Optional[str] = None,
+        model: Optional[str] = None,
+        max_tokens: Optional[int] = None,
+        temperature: float = 1.0,
+    ) -> Iterator[str]:
+        """Make a streaming call to the AI provider.
+        
+        Args:
+            prompt: User prompt/message
+            system_prompt: Optional system prompt for context
+            model: Model ID or profile name to use
+            max_tokens: Maximum tokens in response
+            temperature: Sampling temperature (0.0-2.0)
+            
+        Yields:
+            Text chunks as they arrive from the provider
+            
+        Raises:
+            ProviderError: On API errors
+            InsufficientCreditsError: When credits are too low
+        """
+        pass
+    
+    @abstractmethod
+    def list_models(self) -> List[ModelInfo]:
+        """List available models from this provider.
+        
+        Returns:
+            List of ModelInfo objects describing available models
+        """
+        pass
+    
+    @abstractmethod
+    def get_last_usage(self) -> Optional[UsageInfo]:
+        """Get usage information from the last API call.
+        
+        Returns:
+            UsageInfo for the most recent call, or None if no calls made
+        """
+        pass
+    
+    @property
+    @abstractmethod
+    def provider_name(self) -> str:
+        """Get the provider's name (e.g., 'anthropic', 'openai', 'ollama').
+        
+        Returns:
+            Provider name string
+        """
+        pass
+    
+    @abstractmethod
+    def test_connection(self) -> bool:
+        """Test if the provider is accessible and credentials are valid.
+        
+        Returns:
+            True if connection successful, False otherwise
+        """
+        pass
+
+
+class ProviderError(Exception):
+    """Base exception for provider errors."""
+    pass
+
+
+class InsufficientCreditsError(ProviderError):
+    """Raised when API credits are insufficient."""
+    
+    def __init__(self, message: str, provider: str) -> None:
+        super().__init__(message)
+        self.provider = provider
+
+
+class ProviderConnectionError(ProviderError):
+    """Raised when provider connection fails."""
+    
+    def __init__(self, message: str, provider: str) -> None:
+        super().__init__(message)
+        self.provider = provider
+
+
+class ModelNotFoundError(ProviderError):
+    """Raised when requested model is not available."""
+    
+    def __init__(self, message: str, model: str, provider: str) -> None:
+        super().__init__(message)
+        self.model = model
+        self.provider = provider

claude_dev_cli/providers/factory.py

@@ -0,0 +1,114 @@
+"""Factory for creating AI provider instances."""
+
+from typing import Any
+
+from claude_dev_cli.providers.base import AIProvider, ProviderError
+from claude_dev_cli.providers.anthropic import AnthropicProvider
+
+# Try to import OpenAI provider, graceful fallback if not installed
+try:
+    from claude_dev_cli.providers.openai import OpenAIProvider
+    OPENAI_PROVIDER_AVAILABLE = True
+except (ImportError, RuntimeError):
+    OpenAIProvider = None  # type: ignore
+    OPENAI_PROVIDER_AVAILABLE = False
+
+# Try to import Ollama provider, graceful fallback if not installed
+try:
+    from claude_dev_cli.providers.ollama import OllamaProvider
+    OLLAMA_PROVIDER_AVAILABLE = True
+except (ImportError, RuntimeError):
+    OllamaProvider = None  # type: ignore
+    OLLAMA_PROVIDER_AVAILABLE = False
+
+
+class ProviderFactory:
+    """Factory for creating AI provider instances based on configuration."""
+    
+    # Build registry of available providers
+    @staticmethod
+    def _build_provider_registry() -> dict:
+        """Build registry of available providers based on installed dependencies."""
+        registry = {
+            "anthropic": AnthropicProvider,
+        }
+        
+        # Add OpenAI if available
+        if OPENAI_PROVIDER_AVAILABLE and OpenAIProvider:
+            registry["openai"] = OpenAIProvider
+        
+        # Add Ollama if available
+        if OLLAMA_PROVIDER_AVAILABLE and OllamaProvider:
+            registry["ollama"] = OllamaProvider
+        
+        # Future providers:
+        # "lmstudio": LMStudioProvider,  # v0.16.0
+        
+        return registry
+    
+    # Registry of available providers
+    _PROVIDERS = None
+    
+    @staticmethod
+    def create(config: Any) -> AIProvider:
+        """Create a provider instance based on configuration.
+        
+        Args:
+            config: Provider configuration (ProviderConfig or APIConfig)
+                    Must have 'provider' attribute or defaults to 'anthropic'
+                    
+        Returns:
+            AIProvider instance
+            
+        Raises:
+            ProviderError: If provider type is unknown or unavailable
+        """
+        # Build registry if not already done
+        if ProviderFactory._PROVIDERS is None:
+            ProviderFactory._PROVIDERS = ProviderFactory._build_provider_registry()
+        
+        # Determine provider type
+        provider_type = getattr(config, 'provider', 'anthropic')
+        
+        # Look up provider class
+        provider_class = ProviderFactory._PROVIDERS.get(provider_type.lower())
+        
+        if not provider_class:
+            available = ", ".join(ProviderFactory._PROVIDERS.keys())
+            raise ProviderError(
+                f"Unknown provider: {provider_type}. "
+                f"Available providers: {available}"
+            )
+        
+        # Instantiate and return provider
+        try:
+            return provider_class(config)
+        except Exception as e:
+            raise ProviderError(
+                f"Failed to initialize {provider_type} provider: {e}"
+            )
+    
+    @staticmethod
+    def list_providers() -> list[str]:
+        """List available provider types.
+        
+        Returns:
+            List of provider type names (e.g., ['anthropic', 'openai'])
+        """
+        if ProviderFactory._PROVIDERS is None:
+            ProviderFactory._PROVIDERS = ProviderFactory._build_provider_registry()
+        return list(ProviderFactory._PROVIDERS.keys())
+    
+    @staticmethod
+    def is_provider_available(provider_type: str) -> bool:
+        """Check if a provider type is available.
+        
+        Args:
+            provider_type: Provider type name (e.g., 'anthropic', 'openai')
+            
+        Returns:
+            True if provider is available, False otherwise
+        """
+        if ProviderFactory._PROVIDERS is None:
+            ProviderFactory._PROVIDERS = ProviderFactory._build_provider_registry()
+        return provider_type.lower() in ProviderFactory._PROVIDERS