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

claude_dev_cli/providers/ollama.py

@@ -0,0 +1,283 @@
+"""Ollama local AI provider implementation."""
+
+import json
+from datetime import datetime
+from typing import Iterator, Optional, List, Dict, Any
+
+from claude_dev_cli.providers.base import (
+    AIProvider,
+    ModelInfo,
+    UsageInfo,
+    ProviderConnectionError,
+    ModelNotFoundError,
+    ProviderError,
+)
+
+# Try to import requests, handle gracefully if not installed
+try:
+    import requests
+    REQUESTS_AVAILABLE = True
+except ImportError:
+    REQUESTS_AVAILABLE = False
+    requests = None  # type: ignore
+
+
+class OllamaProvider(AIProvider):
+    """Ollama local model provider implementation.
+    
+    Provides zero-cost local inference with models like:
+    - llama2, mistral, codellama, phi, deepseek-coder, mixtral, etc.
+    """
+    
+    # Known model templates for common models
+    KNOWN_MODELS = {
+        "mistral": {
+            "display_name": "Mistral 7B",
+            "context_window": 8192,
+            "capabilities": ["chat", "code"]
+        },
+        "llama2": {
+            "display_name": "Llama 2",
+            "context_window": 4096,
+            "capabilities": ["chat", "general"]
+        },
+        "codellama": {
+            "display_name": "Code Llama",
+            "context_window": 16384,
+            "capabilities": ["code", "chat"]
+        },
+        "phi": {
+            "display_name": "Phi",
+            "context_window": 2048,
+            "capabilities": ["chat", "reasoning"]
+        },
+        "deepseek-coder": {
+            "display_name": "DeepSeek Coder",
+            "context_window": 16384,
+            "capabilities": ["code"]
+        },
+        "mixtral": {
+            "display_name": "Mixtral 8x7B",
+            "context_window": 32768,
+            "capabilities": ["chat", "code", "analysis"]
+        },
+    }
+    
+    def __init__(self, config: Any) -> None:
+        """Initialize Ollama provider.
+        
+        Args:
+            config: ProviderConfig with optional base_url
+        
+        Raises:
+            RuntimeError: If requests library is not installed
+        """
+        super().__init__(config)
+        
+        if not REQUESTS_AVAILABLE:
+            raise RuntimeError(
+                "Ollama provider requires the requests package. "
+                "Install it with: pip install 'claude-dev-cli[ollama]'"
+            )
+        
+        # No API key needed for local!
+        self.base_url = getattr(config, 'base_url', None) or "http://localhost:11434"
+        self.timeout = 120  # Local inference can be slow
+        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 Ollama API."""
+        model = model or "mistral"
+        
+        # Build messages for chat endpoint
+        messages = []
+        if system_prompt:
+            messages.append({"role": "system", "content": system_prompt})
+        messages.append({"role": "user", "content": prompt})
+        
+        start_time = datetime.utcnow()
+        
+        try:
+            # Use chat endpoint (preferred for conversational use)
+            response = requests.post(
+                f"{self.base_url}/api/chat",
+                json={
+                    "model": model,
+                    "messages": messages,
+                    "stream": False,
+                    "options": {
+                        "temperature": temperature,
+                        "num_predict": max_tokens or 4096,
+                    }
+                },
+                timeout=self.timeout
+            )
+            response.raise_for_status()
+            data = response.json()
+            
+        except requests.ConnectionError:
+            raise ProviderConnectionError(
+                "Cannot connect to Ollama. Is it running? Start with: ollama serve",
+                provider="ollama"
+            )
+        except requests.Timeout:
+            raise ProviderError(
+                f"Ollama request timed out after {self.timeout}s. "
+                "Local models can be slow - consider using a smaller model."
+            )
+        except requests.HTTPError as e:
+            if e.response.status_code == 404:
+                raise ModelNotFoundError(
+                    f"Model '{model}' not found. Pull it with: ollama pull {model}",
+                    model=model,
+                    provider="ollama"
+                )
+            raise ProviderError(f"Ollama API error: {e}")
+        
+        end_time = datetime.utcnow()
+        duration_ms = int((end_time - start_time).total_seconds() * 1000)
+        
+        # Extract response
+        response_text = data.get("message", {}).get("content", "")
+        
+        # Get token counts if available
+        prompt_tokens = data.get("prompt_eval_count", 0)
+        completion_tokens = data.get("eval_count", 0)
+        
+        # Store usage info (always zero cost!)
+        self.last_usage = UsageInfo(
+            input_tokens=prompt_tokens,
+            output_tokens=completion_tokens,
+            duration_ms=duration_ms,
+            model=model,
+            timestamp=end_time,
+            cost_usd=0.0  # Free!
+        )
+        
+        return response_text
+    
+    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 Ollama API."""
+        model = model or "mistral"
+        
+        # Build messages
+        messages = []
+        if system_prompt:
+            messages.append({"role": "system", "content": system_prompt})
+        messages.append({"role": "user", "content": prompt})
+        
+        try:
+            response = requests.post(
+                f"{self.base_url}/api/chat",
+                json={
+                    "model": model,
+                    "messages": messages,
+                    "stream": True,
+                    "options": {
+                        "temperature": temperature,
+                        "num_predict": max_tokens or 4096,
+                    }
+                },
+                stream=True,
+                timeout=self.timeout
+            )
+            response.raise_for_status()
+            
+            # Stream chunks
+            for line in response.iter_lines():
+                if line:
+                    chunk = json.loads(line)
+                    if "message" in chunk:
+                        content = chunk["message"].get("content", "")
+                        if content:
+                            yield content
+                            
+        except requests.ConnectionError:
+            raise ProviderConnectionError(
+                "Cannot connect to Ollama. Is it running? Start with: ollama serve",
+                provider="ollama"
+            )
+        except requests.HTTPError as e:
+            if e.response.status_code == 404:
+                raise ModelNotFoundError(
+                    f"Model '{model}' not found. Pull it with: ollama pull {model}",
+                    model=model,
+                    provider="ollama"
+                )
+            raise ProviderError(f"Ollama API error: {e}")
+    
+    def list_models(self) -> List[ModelInfo]:
+        """List available Ollama models."""
+        try:
+            response = requests.get(
+                f"{self.base_url}/api/tags",
+                timeout=10
+            )
+            response.raise_for_status()
+            data = response.json()
+            
+            models = []
+            for model_data in data.get("models", []):
+                model_name = model_data.get("name", "")
+                base_name = model_name.split(":")[0]  # Remove tag (e.g., "mistral:7b" -> "mistral")
+                
+                # Get info from known models or use defaults
+                info = self.KNOWN_MODELS.get(base_name, {
+                    "display_name": model_name,
+                    "context_window": 4096,
+                    "capabilities": ["chat"]
+                })
+                
+                models.append(ModelInfo(
+                    model_id=model_name,
+                    display_name=info.get("display_name", model_name),
+                    provider="ollama",
+                    context_window=info.get("context_window", 4096),
+                    input_price_per_mtok=0.0,  # Free!
+                    output_price_per_mtok=0.0,  # Free!
+                    capabilities=info.get("capabilities", ["chat"])
+                ))
+            
+            return models
+            
+        except requests.ConnectionError:
+            raise ProviderConnectionError(
+                "Cannot connect to Ollama. Is it running? Start with: ollama serve",
+                provider="ollama"
+            )
+        except Exception as e:
+            raise ProviderError(f"Failed to list Ollama models: {e}")
+    
+    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 "ollama"
+    
+    def test_connection(self) -> bool:
+        """Test if Ollama is accessible."""
+        try:
+            response = requests.get(
+                f"{self.base_url}/api/version",
+                timeout=5
+            )
+            return response.status_code == 200
+        except Exception:
+            return False

claude_dev_cli/providers/openai.py

@@ -0,0 +1,268 @@
+"""OpenAI (GPT-4, GPT-3.5) AI provider implementation."""
+
+from datetime import datetime
+from typing import Iterator, Optional, List, Dict, Any
+
+from claude_dev_cli.providers.base import (
+    AIProvider,
+    ModelInfo,
+    UsageInfo,
+    InsufficientCreditsError,
+    ProviderConnectionError,
+    ModelNotFoundError,
+    ProviderError,
+)
+
+# Try to import openai, handle gracefully if not installed
+try:
+    from openai import OpenAI, APIError, AuthenticationError, RateLimitError, NotFoundError
+    OPENAI_AVAILABLE = True
+except ImportError:
+    OPENAI_AVAILABLE = False
+    OpenAI = None  # type: ignore
+    APIError = Exception  # type: ignore
+    AuthenticationError = Exception  # type: ignore
+    RateLimitError = Exception  # type: ignore
+    NotFoundError = Exception  # type: ignore
+
+
+class OpenAIProvider(AIProvider):
+    """OpenAI GPT API provider implementation."""
+    
+    # Known OpenAI models with their capabilities
+    KNOWN_MODELS = {
+        "gpt-4-turbo-preview": {
+            "display_name": "GPT-4 Turbo",
+            "context_window": 128000,
+            "input_price": 10.00,
+            "output_price": 30.00,
+            "capabilities": ["chat", "code", "analysis", "vision"]
+        },
+        "gpt-4-turbo": {
+            "display_name": "GPT-4 Turbo",
+            "context_window": 128000,
+            "input_price": 10.00,
+            "output_price": 30.00,
+            "capabilities": ["chat", "code", "analysis", "vision"]
+        },
+        "gpt-4": {
+            "display_name": "GPT-4",
+            "context_window": 8192,
+            "input_price": 30.00,
+            "output_price": 60.00,
+            "capabilities": ["chat", "code", "analysis"]
+        },
+        "gpt-3.5-turbo": {
+            "display_name": "GPT-3.5 Turbo",
+            "context_window": 16385,
+            "input_price": 0.50,
+            "output_price": 1.50,
+            "capabilities": ["chat", "code"]
+        },
+    }
+    
+    def __init__(self, config: Any) -> None:
+        """Initialize OpenAI provider.
+        
+        Args:
+            config: ProviderConfig with api_key and optional base_url
+        
+        Raises:
+            RuntimeError: If openai SDK is not installed
+        """
+        super().__init__(config)
+        
+        if not OPENAI_AVAILABLE:
+            raise RuntimeError(
+                "OpenAI provider requires the openai package. "
+                "Install it with: pip install 'claude-dev-cli[openai]'"
+            )
+        
+        # Extract API key from config
+        api_key = getattr(config, 'api_key', None)
+        if not api_key:
+            raise ValueError("OpenAI provider requires api_key in config")
+        
+        # Get optional base_url for custom endpoints (Azure, proxies, etc.)
+        base_url = getattr(config, 'base_url', None)
+        
+        # Initialize OpenAI client
+        client_kwargs: Dict[str, Any] = {"api_key": api_key}
+        if base_url:
+            client_kwargs["base_url"] = base_url
+        
+        self.client = OpenAI(**client_kwargs)
+        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 OpenAI API."""
+        model = model or "gpt-4-turbo-preview"
+        max_tokens = max_tokens or 4096
+        
+        # Build messages array (OpenAI format)
+        messages: List[Dict[str, str]] = []
+        if system_prompt:
+            messages.append({"role": "system", "content": system_prompt})
+        messages.append({"role": "user", "content": prompt})
+        
+        start_time = datetime.utcnow()
+        
+        try:
+            response = self.client.chat.completions.create(
+                model=model,
+                messages=messages,  # type: ignore
+                max_tokens=max_tokens,
+                temperature=temperature
+            )
+        except AuthenticationError as e:
+            raise ProviderConnectionError(
+                f"OpenAI authentication failed: {e}",
+                provider="openai"
+            )
+        except RateLimitError as e:
+            raise ProviderError(f"OpenAI rate limit exceeded: {e}")
+        except NotFoundError as e:
+            raise ModelNotFoundError(
+                f"Model not found: {model}",
+                model=model,
+                provider="openai"
+            )
+        except APIError as e:
+            # Check for quota/billing issues
+            error_message = str(e).lower()
+            if "quota" in error_message or "billing" in error_message or "insufficient" in error_message:
+                raise InsufficientCreditsError(
+                    f"Insufficient OpenAI credits: {e}",
+                    provider="openai"
+                )
+            raise ProviderConnectionError(
+                f"OpenAI API error: {e}",
+                provider="openai"
+            )
+        
+        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_tokens = response.usage.prompt_tokens if response.usage else 0
+        output_tokens = response.usage.completion_tokens if response.usage else 0
+        
+        input_cost = (input_tokens / 1_000_000) * input_price
+        output_cost = (output_tokens / 1_000_000) * output_price
+        total_cost = input_cost + output_cost
+        
+        # Store usage info
+        self.last_usage = UsageInfo(
+            input_tokens=input_tokens,
+            output_tokens=output_tokens,
+            duration_ms=duration_ms,
+            model=model,
+            timestamp=end_time,
+            cost_usd=total_cost
+        )
+        
+        # Extract text from response
+        if response.choices and len(response.choices) > 0:
+            message = response.choices[0].message
+            return message.content or ""
+        return ""
+    
+    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 OpenAI API."""
+        model = model or "gpt-4-turbo-preview"
+        max_tokens = max_tokens or 4096
+        
+        # Build messages array
+        messages: List[Dict[str, str]] = []
+        if system_prompt:
+            messages.append({"role": "system", "content": system_prompt})
+        messages.append({"role": "user", "content": prompt})
+        
+        try:
+            stream = self.client.chat.completions.create(
+                model=model,
+                messages=messages,  # type: ignore
+                max_tokens=max_tokens,
+                temperature=temperature,
+                stream=True
+            )
+            
+            for chunk in stream:
+                if chunk.choices and len(chunk.choices) > 0:
+                    delta = chunk.choices[0].delta
+                    if delta.content:
+                        yield delta.content
+                        
+        except AuthenticationError as e:
+            raise ProviderConnectionError(
+                f"OpenAI authentication failed: {e}",
+                provider="openai"
+            )
+        except RateLimitError as e:
+            raise ProviderError(f"OpenAI rate limit exceeded: {e}")
+        except APIError as e:
+            error_message = str(e).lower()
+            if "quota" in error_message or "billing" in error_message:
+                raise InsufficientCreditsError(
+                    f"Insufficient OpenAI credits: {e}",
+                    provider="openai"
+                )
+            raise ProviderConnectionError(
+                f"OpenAI API error: {e}",
+                provider="openai"
+            )
+    
+    def list_models(self) -> List[ModelInfo]:
+        """List available OpenAI models."""
+        models = []
+        for model_id, info in self.KNOWN_MODELS.items():
+            models.append(ModelInfo(
+                model_id=model_id,
+                display_name=info["display_name"],
+                provider="openai",
+                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 "openai"
+    
+    def test_connection(self) -> bool:
+        """Test if the OpenAI API is accessible."""
+        try:
+            # Make a minimal API call to test credentials
+            response = self.client.chat.completions.create(
+                model="gpt-3.5-turbo",
+                messages=[{"role": "user", "content": "test"}],
+                max_tokens=5
+            )
+            return True
+        except Exception:
+            return False

claude_dev_cli/workflows.py

@@ -130,6 +130,7 @@ class WorkflowEngine:
             generate_tests, code_review, debug_code, 
             generate_docs, refactor_code, git_commit_message
         )
+        from claude_dev_cli.core import ClaudeClient
         
         # Map commands to functions
         command_map = {
@@ -141,11 +142,23 @@ class WorkflowEngine:
             'git commit': git_commit_message,
         }
         
+        # Handle special commands that need different execution
+        if command == 'ask':
+            return self._execute_ask_command(interpolated_args)
+        elif command in ['generate code', 'generate feature']:
+            # These are CLI-only commands that would need file generation logic
+            # For now, redirect to shell equivalent
+            return StepResult(
+                success=False,
+                output="",
+                error=f"Command '{command}' not yet supported in workflows. Use shell step with 'cdc {command}' instead."
+            )
+        
         if command not in command_map:
             return StepResult(
                 success=False,
                 output="",
-                error=f"Unknown command: {command}"
+                error=f"Unknown command: {command}. Supported: {', '.join(command_map.keys())}, ask"
             )
         
         try:
@@ -159,6 +172,8 @@ class WorkflowEngine:
                 func_args['error_message'] = interpolated_args['error']
             if 'api' in interpolated_args:
                 func_args['api_config_name'] = interpolated_args['api']
+            if 'model' in interpolated_args:
+                func_args['model'] = interpolated_args['model']
             
             # Execute
             result = func(**func_args)
@@ -180,6 +195,39 @@ class WorkflowEngine:
                 error=str(e)
             )
     
+    def _execute_ask_command(self, args: Dict[str, Any]) -> StepResult:
+        """Execute an ask command step."""
+        try:
+            from claude_dev_cli.core import ClaudeClient
+            
+            prompt = args.get('prompt', args.get('question', ''))
+            if not prompt:
+                return StepResult(
+                    success=False,
+                    output="",
+                    error="ask command requires 'prompt' or 'question' argument"
+                )
+            
+            api = args.get('api')
+            model = args.get('model')
+            system = args.get('system')
+            
+            client = ClaudeClient(api_config_name=api)
+            result = client.call(prompt, system_prompt=system, model=model)
+            
+            return StepResult(
+                success=True,
+                output=result,
+                metadata={'command': 'ask'}
+            )
+        
+        except Exception as e:
+            return StepResult(
+                success=False,
+                output="",
+                error=str(e)
+            )
+    
     def _execute_shell_step(self, step: Dict[str, Any], context: WorkflowContext) -> StepResult:
         """Execute a shell command step."""
         command = step['shell']