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

claude_dev_cli/__init__.py

@@ -9,7 +9,7 @@ Features:
 - Interactive and single-shot modes
 """
 
-__version__ = "0.13.0"
+__version__ = "0.16.0"
 __author__ = "Julio"
 __license__ = "MIT"
 

claude_dev_cli/cli.py

@@ -479,37 +479,103 @@ def config() -> None:
 
 
 @config.command('add')
+@click.argument('provider', type=click.Choice(['anthropic', 'openai', 'ollama'], case_sensitive=False), default='anthropic')
 @click.argument('name')
-@click.option('--api-key', help='API key (or set {NAME}_ANTHROPIC_API_KEY env var)')
+@click.option('--api-key', help='API key (or set {NAME}_<PROVIDER>_API_KEY env var; not needed for ollama)')
 @click.option('--description', help='Description of this API config')
 @click.option('--default', is_flag=True, help='Set as default API config')
+@click.option('--base-url', help='Custom API base URL (for Azure, proxies, or local Ollama server)')
 @click.pass_context
 def config_add(
     ctx: click.Context,
+    provider: str,
     name: str,
     api_key: Optional[str],
     description: Optional[str],
-    default: bool
+    default: bool,
+    base_url: Optional[str]
 ) -> None:
-    """Add a new API configuration."""
+    """Add a new provider configuration.
+    
+    PROVIDER: Provider type (anthropic, openai, or ollama)
+    NAME: Configuration name
+    
+    Examples:
+      cdc config add anthropic personal --default
+      cdc config add openai work-openai --api-key sk-...
+      cdc config add ollama local --default
+      cdc config add ollama remote --base-url http://server:11434
+    """
     console = ctx.obj['console']
     
     try:
+        from claude_dev_cli.providers.factory import ProviderFactory
+        
+        # Check if provider is available
+        if not ProviderFactory.is_provider_available(provider):
+            console.print(f"[red]Error: {provider} provider not available[/red]")
+            if provider == 'openai':
+                console.print("Install with: pip install 'claude-dev-cli[openai]'")
+            elif provider == 'ollama':
+                console.print("Install with: pip install 'claude-dev-cli[ollama]'")
+            sys.exit(1)
+        
         config = Config()
-        config.add_api_config(
+        
+        # Get API key from environment if not provided (skip for ollama)
+        if api_key is None and provider not in ['ollama']:
+            env_var = f"{name.upper()}_{provider.upper()}_API_KEY"
+            api_key = os.environ.get(env_var)
+            if not api_key:
+                # Try generic env var for provider
+                generic_env = f"{provider.upper()}_API_KEY"
+                api_key = os.environ.get(generic_env)
+            if not api_key:
+                raise ValueError(
+                    f"API key not provided and {env_var} environment variable not set"
+                )
+        
+        # Check if name already exists
+        api_configs = config._data.get("api_configs", [])
+        for cfg in api_configs:
+            if cfg["name"] == name:
+                raise ValueError(f"Config with name '{name}' already exists")
+        
+        # Store API key in secure storage (if provided)
+        if api_key:
+            config.secure_storage.store_key(name, api_key)
+        
+        # If this is the first config or make_default is True, set as default
+        if default or not api_configs:
+            for cfg in api_configs:
+                cfg["default"] = False
+        
+        # Create provider config
+        from claude_dev_cli.config import ProviderConfig
+        provider_config = ProviderConfig(
             name=name,
-            api_key=api_key,
+            provider=provider,
+            api_key="",  # Empty string indicates key is in secure storage (or not needed)
+            base_url=base_url,
             description=description,
-            make_default=default
+            default=default or not api_configs
         )
-        console.print(f"[green]✓[/green] Added API config: {name}")
         
-        # Show storage method
-        storage_method = config.secure_storage.get_storage_method()
-        if storage_method == "keyring":
-            console.print("[dim]🔐 Stored securely in system keyring[/dim]")
+        api_configs.append(provider_config.model_dump())
+        config._data["api_configs"] = api_configs
+        config._save_config()
+        
+        console.print(f"[green]✓[/green] Added {provider} config: {name}")
+        
+        # Show storage method (if API key was stored)
+        if api_key:
+            storage_method = config.secure_storage.get_storage_method()
+            if storage_method == "keyring":
+                console.print("[dim]🔐 Stored securely in system keyring[/dim]")
+            else:
+                console.print("[dim]🔒 Stored in encrypted file (keyring unavailable)[/dim]")
         else:
-            console.print("[dim]🔒 Stored in encrypted file (keyring unavailable)[/dim]")
+            console.print("[dim]ℹ️  No API key needed for local provider[/dim]")
     except Exception as e:
         console.print(f"[red]Error: {e}[/red]")
         sys.exit(1)
@@ -575,7 +641,8 @@ def config_list(ctx: click.Context) -> None:
     
     for cfg in api_configs:
         default_marker = " [bold green](default)[/bold green]" if cfg.default else ""
-        console.print(f"• {cfg.name}{default_marker}")
+        provider = getattr(cfg, 'provider', 'anthropic')  # Default to anthropic for backward compatibility
+        console.print(f"• {cfg.name}{default_marker} [dim]({provider})[/dim]")
         if cfg.description:
             console.print(f"  {cfg.description}")
         console.print(f"  API Key: {cfg.api_key[:15]}...")
@@ -1270,7 +1337,7 @@ Use proper directory structure and include proper error handling, documentation,
             
             # Confirm or auto-accept
             if not yes and not dry_run:
-                if not multi_file.confirm(console):
+                if not multi_file.confirm(console, output_path):
                     console.print("[yellow]Cancelled[/yellow]")
                     return
             
@@ -1489,7 +1556,7 @@ def gen_feature(
         
         # Confirm or auto-accept
         if not yes:
-            if not multi_file.confirm(console):
+            if not multi_file.confirm(console, base_path):
                 console.print("[yellow]Cancelled[/yellow]")
                 return
         
@@ -1855,7 +1922,7 @@ def refactor(
             
             # Confirm or auto-accept
             if not yes:
-                if not multi_file.confirm(console):
+                if not multi_file.confirm(console, base_path):
                     console.print("[yellow]Cancelled[/yellow]")
                     return
             
@@ -2439,6 +2506,157 @@ def template_use(ctx: click.Context, name: str, api: Optional[str], model: Optio
         sys.exit(1)
 
 
+@main.group()
+def ollama() -> None:
+    """Manage Ollama local models."""
+    pass
+
+
+@ollama.command('list')
+@click.option('-a', '--api', help='Ollama config to use (default: local ollama)')
+@click.pass_context
+def ollama_list(ctx: click.Context, api: Optional[str]) -> None:
+    """List available Ollama models."""
+    console = ctx.obj['console']
+    
+    try:
+        from claude_dev_cli.providers.ollama import OllamaProvider
+        from claude_dev_cli.providers.base import ProviderConnectionError
+        from claude_dev_cli.config import Config, ProviderConfig
+        from rich.table import Table
+        
+        # Get config or use default local
+        config = Config()
+        provider_config = None
+        if api:
+            api_config = config.get_provider_config(api)
+            if not api_config or api_config.provider != 'ollama':
+                console.print(f"[red]Error: '{api}' is not an ollama config[/red]")
+                sys.exit(1)
+            provider_config = api_config
+        else:
+            # Use default local ollama
+            provider_config = ProviderConfig(
+                name="local",
+                provider="ollama",
+                base_url="http://localhost:11434"
+            )
+        
+        provider = OllamaProvider(provider_config)
+        
+        with console.status("[bold blue]Fetching models from Ollama..."):
+            models = provider.list_models()
+        
+        if not models:
+            console.print("[yellow]No models found.[/yellow]")
+            console.print("\nPull a model with: ollama pull mistral")
+            console.print("Or use: cdc ollama pull mistral")
+            return
+        
+        table = Table(show_header=True, header_style="bold magenta")
+        table.add_column("Model", style="cyan")
+        table.add_column("Display Name")
+        table.add_column("Context", justify="right")
+        table.add_column("Cost", justify="right")
+        table.add_column("Capabilities")
+        
+        for model in models:
+            capabilities = ", ".join(model.capabilities)
+            table.add_row(
+                model.model_id,
+                model.display_name,
+                f"{model.context_window:,}",
+                "[green]FREE[/green]",
+                capabilities
+            )
+        
+        console.print(table)
+        console.print(f"\n[dim]Found {len(models)} model(s)[/dim]")
+        
+    except ProviderConnectionError:
+        console.print("[red]Error: Cannot connect to Ollama[/red]")
+        console.print("\nMake sure Ollama is running:")
+        console.print("  ollama serve")
+        console.print("\nOr install Ollama from: https://ollama.ai")
+        sys.exit(1)
+    except ImportError:
+        console.print("[red]Error: Ollama provider not installed[/red]")
+        console.print("Install with: pip install 'claude-dev-cli[ollama]'")
+        sys.exit(1)
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+        sys.exit(1)
+
+
+@ollama.command('pull')
+@click.argument('model')
+@click.pass_context
+def ollama_pull(ctx: click.Context, model: str) -> None:
+    """Pull an Ollama model.
+    
+    Examples:
+      cdc ollama pull mistral
+      cdc ollama pull codellama
+      cdc ollama pull mixtral
+    """
+    console = ctx.obj['console']
+    
+    console.print(f"[yellow]Pulling {model} via Ollama CLI...[/yellow]")
+    console.print("[dim]This will use the 'ollama pull' command directly[/dim]\n")
+    
+    import subprocess
+    try:
+        # Use ollama CLI directly - it shows progress
+        result = subprocess.run(
+            ['ollama', 'pull', model],
+            check=True
+        )
+        
+        if result.returncode == 0:
+            console.print(f"\n[green]✓[/green] Successfully pulled {model}")
+            console.print(f"\nUse it with: cdc ask -m {model} 'your question'")
+    except FileNotFoundError:
+        console.print("[red]Error: ollama command not found[/red]")
+        console.print("\nInstall Ollama from: https://ollama.ai")
+        sys.exit(1)
+    except subprocess.CalledProcessError:
+        console.print(f"[red]Error: Failed to pull {model}[/red]")
+        sys.exit(1)
+
+
+@ollama.command('show')
+@click.argument('model')
+@click.pass_context
+def ollama_show(ctx: click.Context, model: str) -> None:
+    """Show details about an Ollama model.
+    
+    Examples:
+      cdc ollama show mistral
+      cdc ollama show codellama
+    """
+    console = ctx.obj['console']
+    
+    import subprocess
+    try:
+        # Use ollama CLI for detailed info
+        result = subprocess.run(
+            ['ollama', 'show', model],
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        
+        console.print(result.stdout)
+    except FileNotFoundError:
+        console.print("[red]Error: ollama command not found[/red]")
+        console.print("\nInstall Ollama from: https://ollama.ai")
+        sys.exit(1)
+    except subprocess.CalledProcessError:
+        console.print(f"[red]Error: Model '{model}' not found[/red]")
+        console.print(f"\nPull it first: cdc ollama pull {model}")
+        sys.exit(1)
+
+
 @main.group()
 def warp() -> None:
     """Warp terminal integration."""

claude_dev_cli/config.py

@@ -31,25 +31,43 @@ class SummarizationConfig(BaseModel):
 
 
 class APIConfig(BaseModel):
-    """Configuration for a Claude API key."""
+    """Configuration for a Claude API key.
+    
+    DEPRECATED: Use ProviderConfig instead. Maintained for backward compatibility.
+    """
     
     name: str
     api_key: str
     description: Optional[str] = None
     default: bool = False
     default_model_profile: Optional[str] = None  # Default model profile for this API
+    # Added for provider compatibility
+    provider: str = "anthropic"  # Always anthropic for APIConfig
+
+
+class ProviderConfig(BaseModel):
+    """Configuration for an AI provider (Anthropic, OpenAI, Ollama, etc.)."""
+    
+    name: str  # User-friendly name (e.g., "personal-claude", "work-openai")
+    provider: str  # Provider type: "anthropic", "openai", "ollama", "lmstudio"
+    api_key: Optional[str] = None  # Not needed for local providers
+    base_url: Optional[str] = None  # Custom endpoint URL (for local/enterprise)
+    description: Optional[str] = None
+    default: bool = False
+    default_model_profile: Optional[str] = None
 
 
 class ModelProfile(BaseModel):
     """Model profile with pricing information."""
     
     name: str  # User-friendly alias (e.g., "fast", "smart", "powerful")
-    model_id: str  # Actual Claude model ID
+    model_id: str  # Provider-specific model ID
     description: Optional[str] = None
     input_price_per_mtok: float  # Input cost per million tokens (USD)
     output_price_per_mtok: float  # Output cost per million tokens (USD)
     use_cases: List[str] = Field(default_factory=list)  # Task types
-    api_config_name: Optional[str] = None  # Tied to specific API config, or None for global
+    provider: str = "anthropic"  # Provider type: "anthropic", "openai", "ollama"
+    api_config_name: Optional[str] = None  # Tied to specific API/provider config, or None for global
 
 
 class ProjectProfile(BaseModel):
@@ -168,36 +186,104 @@ class Config:
             json.dump(data, f, indent=2)
     
     def _get_default_model_profiles(self) -> List[Dict]:
-        """Get default model profiles with current Anthropic pricing."""
-        return [
+        """Get default model profiles for all providers."""
+        profiles = [
+            # Anthropic (Claude) profiles
             {
                 "name": "fast",
                 "model_id": "claude-3-5-haiku-20241022",
-                "description": "Fast and economical for simple tasks",
+                "description": "Fast and economical for simple tasks (Claude)",
                 "input_price_per_mtok": 0.80,
                 "output_price_per_mtok": 4.00,
                 "use_cases": ["quick", "simple", "classification"],
+                "provider": "anthropic",
                 "api_config_name": None
             },
             {
                 "name": "smart",
                 "model_id": "claude-sonnet-4-5-20250929",
-                "description": "Balanced performance and cost for most tasks",
+                "description": "Balanced performance and cost for most tasks (Claude)",
                 "input_price_per_mtok": 3.00,
                 "output_price_per_mtok": 15.00,
                 "use_cases": ["general", "coding", "analysis"],
+                "provider": "anthropic",
                 "api_config_name": None
             },
             {
                 "name": "powerful",
                 "model_id": "claude-opus-4-20250514",
-                "description": "Maximum capability for complex tasks",
+                "description": "Maximum capability for complex tasks (Claude)",
                 "input_price_per_mtok": 15.00,
                 "output_price_per_mtok": 75.00,
                 "use_cases": ["complex", "research", "creative"],
+                "provider": "anthropic",
                 "api_config_name": None
-            }
+            },
+            # OpenAI (GPT) profiles - only added if OpenAI provider available
+            {
+                "name": "fast-openai",
+                "model_id": "gpt-3.5-turbo",
+                "description": "Fast and economical for simple tasks (OpenAI)",
+                "input_price_per_mtok": 0.50,
+                "output_price_per_mtok": 1.50,
+                "use_cases": ["quick", "simple", "chat"],
+                "provider": "openai",
+                "api_config_name": None
+            },
+            {
+                "name": "smart-openai",
+                "model_id": "gpt-4-turbo",
+                "description": "Balanced performance and cost for most tasks (OpenAI)",
+                "input_price_per_mtok": 10.00,
+                "output_price_per_mtok": 30.00,
+                "use_cases": ["general", "coding", "analysis"],
+                "provider": "openai",
+                "api_config_name": None
+            },
+            {
+                "name": "powerful-openai",
+                "model_id": "gpt-4",
+                "description": "High capability for complex tasks (OpenAI)",
+                "input_price_per_mtok": 30.00,
+                "output_price_per_mtok": 60.00,
+                "use_cases": ["complex", "research", "reasoning"],
+                "provider": "openai",
+                "api_config_name": None
+            },
+            # Ollama (Local) profiles - zero cost!
+            {
+                "name": "fast-local",
+                "model_id": "mistral",
+                "description": "Fast local inference with Mistral 7B (zero cost)",
+                "input_price_per_mtok": 0.0,
+                "output_price_per_mtok": 0.0,
+                "use_cases": ["quick", "chat", "general"],
+                "provider": "ollama",
+                "api_config_name": None
+            },
+            {
+                "name": "smart-local",
+                "model_id": "mixtral",
+                "description": "Powerful local inference with Mixtral 8x7B (zero cost)",
+                "input_price_per_mtok": 0.0,
+                "output_price_per_mtok": 0.0,
+                "use_cases": ["general", "analysis", "chat"],
+                "provider": "ollama",
+                "api_config_name": None
+            },
+            {
+                "name": "code-local",
+                "model_id": "codellama",
+                "description": "Code-focused local inference with Code Llama (zero cost)",
+                "input_price_per_mtok": 0.0,
+                "output_price_per_mtok": 0.0,
+                "use_cases": ["coding", "refactoring", "debugging"],
+                "provider": "ollama",
+                "api_config_name": None
+            },
         ]
+        
+        return profiles
     
     def _auto_migrate_keys(self) -> None:
         """Automatically migrate plaintext API keys to secure storage."""

claude_dev_cli/core.py

@@ -3,17 +3,22 @@
 import json
 from datetime import datetime
 from pathlib import Path
-from typing import Optional, Dict, Any, List
-from anthropic import Anthropic
+from typing import Optional, Dict, Any, List, Union
 
-from claude_dev_cli.config import Config
+from claude_dev_cli.config import Config, APIConfig, ProviderConfig
+from claude_dev_cli.providers.factory import ProviderFactory
+from claude_dev_cli.providers.base import AIProvider
 
 
 class ClaudeClient:
-    """Claude API client with multi-key routing and usage tracking."""
+    """AI client with multi-provider support and routing.
+    
+    Backward compatible wrapper around provider system.
+    Uses AIProvider abstraction to support Anthropic, OpenAI, Ollama, etc.
+    """
     
     def __init__(self, config: Optional[Config] = None, api_config_name: Optional[str] = None):
-        """Initialize Claude client.
+        """Initialize AI client.
         
         API routing hierarchy (highest to lowest priority):
         1. Explicit api_config_name parameter
@@ -35,7 +40,10 @@ class ClaudeClient:
                 "No API configuration found. Run 'cdc config add' to set up an API key."
             )
         
-        self.client = Anthropic(api_key=self.api_config.api_key)
+        # Create provider using factory pattern
+        # APIConfig is treated as ProviderConfig with provider="anthropic"
+        self.provider = ProviderFactory.create(self.api_config)
+        
         self.model = self.config.get_model()
         self.max_tokens = self.config.get_max_tokens()
     
@@ -86,7 +94,7 @@ class ClaudeClient:
         temperature: float = 1.0,
         stream: bool = False
     ) -> str:
-        """Make a call to Claude API.
+        """Make a call to AI provider.
         
         Args:
             model: Model ID or profile name (e.g., 'fast', 'smart', 'powerful')
@@ -100,34 +108,25 @@ class ClaudeClient:
         if project_profile and project_profile.system_prompt and not system_prompt:
             system_prompt = project_profile.system_prompt
         
-        kwargs: Dict[str, Any] = {
-            "model": resolved_model,
-            "max_tokens": max_tokens,
-            "temperature": temperature,
-            "messages": [{"role": "user", "content": prompt}]
-        }
-        
-        if system_prompt:
-            kwargs["system"] = system_prompt
-        
-        start_time = datetime.utcnow()
-        response = self.client.messages.create(**kwargs)
-        end_time = datetime.utcnow()
-        
-        # Log usage
-        self._log_usage(
+        # Call provider
+        response = self.provider.call(
             prompt=prompt,
-            response=response,
+            system_prompt=system_prompt,
             model=resolved_model,
-            duration_ms=int((end_time - start_time).total_seconds() * 1000),
-            api_config_name=self.api_config.name
+            max_tokens=max_tokens,
+            temperature=temperature
         )
         
-        # Extract text from response
-        text_blocks = [
-            block.text for block in response.content if hasattr(block, 'text')
-        ]
-        return '\n'.join(text_blocks)
+        # Log usage
+        usage = self.provider.get_last_usage()
+        if usage:
+            self._log_usage(
+                prompt=prompt,
+                usage=usage,
+                api_config_name=self.api_config.name
+            )
+        
+        return response
     
     def call_streaming(
         self,
@@ -137,7 +136,7 @@ class ClaudeClient:
         max_tokens: Optional[int] = None,
         temperature: float = 1.0
     ):
-        """Make a streaming call to Claude API.
+        """Make a streaming call to AI provider.
         
         Args:
             model: Model ID or profile name (e.g., 'fast', 'smart', 'powerful')
@@ -151,37 +150,33 @@ class ClaudeClient:
         if project_profile and project_profile.system_prompt and not system_prompt:
             system_prompt = project_profile.system_prompt
         
-        kwargs: Dict[str, Any] = {
-            "model": resolved_model,
-            "max_tokens": max_tokens,
-            "temperature": temperature,
-            "messages": [{"role": "user", "content": prompt}]
-        }
-        
-        if system_prompt:
-            kwargs["system"] = system_prompt
-        
-        with self.client.messages.stream(**kwargs) as stream:
-            for text in stream.text_stream:
-                yield text
+        # Use provider's streaming method
+        for text in self.provider.call_streaming(
+            prompt=prompt,
+            system_prompt=system_prompt,
+            model=resolved_model,
+            max_tokens=max_tokens,
+            temperature=temperature
+        ):
+            yield text
     
     def _log_usage(
         self,
         prompt: str,
-        response: Any,
-        model: str,
-        duration_ms: int,
+        usage: Any,  # UsageInfo from provider
         api_config_name: str
     ) -> None:
         """Log API usage to file."""
         log_entry = {
-            "timestamp": datetime.utcnow().isoformat(),
+            "timestamp": usage.timestamp.isoformat(),
             "api_config": api_config_name,
-            "model": model,
+            "model": usage.model,
             "prompt_preview": prompt[:100],
-            "input_tokens": response.usage.input_tokens,
-            "output_tokens": response.usage.output_tokens,
-            "duration_ms": duration_ms,
+            "input_tokens": usage.input_tokens,
+            "output_tokens": usage.output_tokens,
+            "duration_ms": usage.duration_ms,
+            "cost_usd": usage.cost_usd,
+            "provider": self.provider.provider_name
         }
         
         with open(self.config.usage_log, 'a') as f: