claude-dev-cli 0.1.0__py3-none-any.whl

claude_dev_cli/config.py

@@ -0,0 +1,174 @@
+"""Configuration management for Claude Dev CLI."""
+
+import json
+import os
+from pathlib import Path
+from typing import Dict, Optional, List
+from pydantic import BaseModel, Field
+
+
+class APIConfig(BaseModel):
+    """Configuration for a Claude API key."""
+    
+    name: str
+    api_key: str
+    description: Optional[str] = None
+    default: bool = False
+
+
+class ProjectProfile(BaseModel):
+    """Project-specific configuration."""
+    
+    name: str
+    api_config: str  # Name of the API config to use
+    system_prompt: Optional[str] = None
+    allowed_commands: List[str] = Field(default_factory=lambda: ["all"])
+
+
+class Config:
+    """Manages configuration for Claude Dev CLI."""
+    
+    CONFIG_DIR = Path.home() / ".claude-dev-cli"
+    CONFIG_FILE = CONFIG_DIR / "config.json"
+    USAGE_LOG = CONFIG_DIR / "usage.jsonl"
+    
+    def __init__(self) -> None:
+        """Initialize configuration."""
+        self.config_dir = self.CONFIG_DIR
+        self.config_file = self.CONFIG_FILE
+        self.usage_log = self.USAGE_LOG
+        self._ensure_config_dir()
+        self._data: Dict = self._load_config()
+    
+    def _ensure_config_dir(self) -> None:
+        """Ensure configuration directory exists."""
+        self.config_dir.mkdir(parents=True, exist_ok=True)
+        self.usage_log.touch(exist_ok=True)
+    
+    def _load_config(self) -> Dict:
+        """Load configuration from file."""
+        if not self.config_file.exists():
+            default_config = {
+                "api_configs": [],
+                "project_profiles": [],
+                "default_model": "claude-3-5-sonnet-20241022",
+                "max_tokens": 4096,
+            }
+            self._save_config(default_config)
+            return default_config
+        
+        with open(self.config_file, 'r') as f:
+            return json.load(f)
+    
+    def _save_config(self, data: Optional[Dict] = None) -> None:
+        """Save configuration to file."""
+        if data is None:
+            data = self._data
+        
+        with open(self.config_file, 'w') as f:
+            json.dump(data, f, indent=2)
+    
+    def add_api_config(
+        self,
+        name: str,
+        api_key: Optional[str] = None,
+        description: Optional[str] = None,
+        make_default: bool = False
+    ) -> None:
+        """Add a new API configuration."""
+        # Get API key from env if not provided
+        if api_key is None:
+            env_var = f"{name.upper()}_ANTHROPIC_API_KEY"
+            api_key = os.environ.get(env_var)
+            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 = self._data.get("api_configs", [])
+        for config in api_configs:
+            if config["name"] == name:
+                raise ValueError(f"API config with name '{name}' already exists")
+        
+        # If this is the first config or make_default is True, set as default
+        if make_default or not api_configs:
+            for config in api_configs:
+                config["default"] = False
+        
+        api_config = APIConfig(
+            name=name,
+            api_key=api_key,
+            description=description,
+            default=make_default or not api_configs
+        )
+        
+        api_configs.append(api_config.model_dump())
+        self._data["api_configs"] = api_configs
+        self._save_config()
+    
+    def get_api_config(self, name: Optional[str] = None) -> Optional[APIConfig]:
+        """Get API configuration by name or default."""
+        api_configs = self._data.get("api_configs", [])
+        
+        if name:
+            for config in api_configs:
+                if config["name"] == name:
+                    return APIConfig(**config)
+        else:
+            # Return default
+            for config in api_configs:
+                if config.get("default", False):
+                    return APIConfig(**config)
+        
+        return None
+    
+    def list_api_configs(self) -> List[APIConfig]:
+        """List all API configurations."""
+        return [APIConfig(**c) for c in self._data.get("api_configs", [])]
+    
+    def add_project_profile(
+        self,
+        name: str,
+        api_config: str,
+        system_prompt: Optional[str] = None,
+        allowed_commands: Optional[List[str]] = None
+    ) -> None:
+        """Add a project profile."""
+        profiles = self._data.get("project_profiles", [])
+        
+        profile = ProjectProfile(
+            name=name,
+            api_config=api_config,
+            system_prompt=system_prompt,
+            allowed_commands=allowed_commands or ["all"]
+        )
+        
+        profiles.append(profile.model_dump())
+        self._data["project_profiles"] = profiles
+        self._save_config()
+    
+    def get_project_profile(self, cwd: Optional[Path] = None) -> Optional[ProjectProfile]:
+        """Get project profile for current directory."""
+        if cwd is None:
+            cwd = Path.cwd()
+        
+        # Check for .claude-dev-cli file in current or parent directories
+        current = cwd
+        while current != current.parent:
+            config_file = current / ".claude-dev-cli"
+            if config_file.exists():
+                with open(config_file, 'r') as f:
+                    data = json.load(f)
+                    return ProjectProfile(**data)
+            current = current.parent
+        
+        return None
+    
+    def get_model(self) -> str:
+        """Get default model."""
+        return self._data.get("default_model", "claude-3-5-sonnet-20241022")
+    
+    def get_max_tokens(self) -> int:
+        """Get default max tokens."""
+        return self._data.get("max_tokens", 4096)

claude_dev_cli/core.py

@@ -0,0 +1,132 @@
+"""Core Claude API client with routing and tracking."""
+
+import json
+from datetime import datetime
+from pathlib import Path
+from typing import Optional, Dict, Any, List
+from anthropic import Anthropic
+
+from claude_dev_cli.config import Config
+
+
+class ClaudeClient:
+    """Claude API client with multi-key routing and usage tracking."""
+    
+    def __init__(self, config: Optional[Config] = None, api_config_name: Optional[str] = None):
+        """Initialize Claude client."""
+        self.config = config or Config()
+        
+        # Determine which API config to use
+        project_profile = self.config.get_project_profile()
+        if project_profile:
+            api_config_name = project_profile.api_config
+        
+        self.api_config = self.config.get_api_config(api_config_name)
+        if not self.api_config:
+            raise ValueError(
+                "No API configuration found. Run 'cdc config add' to set up an API key."
+            )
+        
+        self.client = Anthropic(api_key=self.api_config.api_key)
+        self.model = self.config.get_model()
+        self.max_tokens = self.config.get_max_tokens()
+    
+    def call(
+        self,
+        prompt: str,
+        system_prompt: Optional[str] = None,
+        model: Optional[str] = None,
+        max_tokens: Optional[int] = None,
+        temperature: float = 1.0,
+        stream: bool = False
+    ) -> str:
+        """Make a call to Claude API."""
+        model = model or self.model
+        max_tokens = max_tokens or self.max_tokens
+        
+        # Check project profile for system prompt
+        project_profile = self.config.get_project_profile()
+        if project_profile and project_profile.system_prompt and not system_prompt:
+            system_prompt = project_profile.system_prompt
+        
+        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()
+        response = self.client.messages.create(**kwargs)
+        end_time = datetime.utcnow()
+        
+        # Log usage
+        self._log_usage(
+            prompt=prompt,
+            response=response,
+            model=model,
+            duration_ms=int((end_time - start_time).total_seconds() * 1000),
+            api_config_name=self.api_config.name
+        )
+        
+        # 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
+    ):
+        """Make a streaming call to Claude API."""
+        model = model or self.model
+        max_tokens = max_tokens or self.max_tokens
+        
+        # Check project profile for system prompt
+        project_profile = self.config.get_project_profile()
+        if project_profile and project_profile.system_prompt and not system_prompt:
+            system_prompt = project_profile.system_prompt
+        
+        kwargs: Dict[str, Any] = {
+            "model": 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
+    
+    def _log_usage(
+        self,
+        prompt: str,
+        response: Any,
+        model: str,
+        duration_ms: int,
+        api_config_name: str
+    ) -> None:
+        """Log API usage to file."""
+        log_entry = {
+            "timestamp": datetime.utcnow().isoformat(),
+            "api_config": api_config_name,
+            "model": model,
+            "prompt_preview": prompt[:100],
+            "input_tokens": response.usage.input_tokens,
+            "output_tokens": response.usage.output_tokens,
+            "duration_ms": duration_ms,
+        }
+        
+        with open(self.config.usage_log, 'a') as f:
+            f.write(json.dumps(log_entry) + '\n')

claude_dev_cli/templates.py

@@ -0,0 +1,104 @@
+"""Prompt templates for various commands."""
+
+TEST_GENERATION_PROMPT = """Generate comprehensive pytest tests for the following Python code from {filename}.
+
+Code:
+```python
+{code}
+```
+
+Requirements:
+- Use pytest framework
+- Include fixtures where appropriate
+- Test normal cases, edge cases, and error conditions
+- Use descriptive test names
+- Add docstrings to test functions
+- Mock external dependencies if needed
+
+Please provide only the test code without explanations."""
+
+CODE_REVIEW_PROMPT = """Review the following Python code from {filename} for:
+
+1. **Bugs and Logic Errors**: Identify potential bugs
+2. **Security Issues**: Check for vulnerabilities
+3. **Performance**: Suggest optimizations
+4. **Best Practices**: Python idioms and patterns
+5. **Code Quality**: Readability and maintainability
+
+Code:
+```python
+{code}
+```
+
+Please provide a structured review with specific line numbers where applicable."""
+
+DEBUG_PROMPT = """Analyze the following error and code to identify the root cause and provide a fix.
+
+File: {filename}
+
+Code:
+```python
+{code}
+```
+
+Error:
+```
+{error}
+```
+
+Please provide:
+1. Root cause analysis
+2. Specific fix with code
+3. Explanation of why the error occurred"""
+
+DOCS_GENERATION_PROMPT = """Generate comprehensive documentation for the following Python code from {filename}.
+
+Code:
+```python
+{code}
+```
+
+Please provide:
+1. Module-level docstring
+2. Function/class docstrings in Google style
+3. Usage examples
+4. A README section explaining the module
+
+Use clear, concise language suitable for developers."""
+
+REFACTOR_PROMPT = """Analyze the following Python code from {filename} and suggest refactoring improvements.
+
+Code:
+```python
+{code}
+```
+
+Focus on:
+1. Code duplication (DRY principle)
+2. Function/class complexity
+3. Naming conventions
+4. Code organization
+5. Design patterns that could be applied
+6. Type hints and documentation
+
+Please provide refactored code with explanations."""
+
+GIT_COMMIT_PROMPT = """Generate a conventional commit message for the following git diff.
+
+Diff:
+```
+{diff}
+```
+
+Format:
+```
+<type>(<scope>): <subject>
+
+<body>
+
+<footer>
+```
+
+Types: feat, fix, docs, style, refactor, test, chore
+
+Keep the subject under 50 characters. Use present tense. Be specific about what changed and why."""

claude_dev_cli/usage.py

@@ -0,0 +1,202 @@
+"""Usage tracking and statistics."""
+
+import json
+from collections import defaultdict
+from datetime import datetime, timedelta
+from pathlib import Path
+from typing import Optional, Dict, Any, List
+
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+
+from claude_dev_cli.config import Config
+
+
+# Pricing per 1M tokens (as of Dec 2024)
+MODEL_PRICING = {
+    "claude-3-5-sonnet-20241022": {"input": 3.00, "output": 15.00},
+    "claude-3-5-sonnet-20240620": {"input": 3.00, "output": 15.00},
+    "claude-3-opus-20240229": {"input": 15.00, "output": 75.00},
+    "claude-3-sonnet-20240229": {"input": 3.00, "output": 15.00},
+    "claude-3-haiku-20240307": {"input": 0.25, "output": 1.25},
+}
+
+
+class UsageTracker:
+    """Track and display API usage statistics."""
+    
+    def __init__(self, config: Optional[Config] = None):
+        """Initialize usage tracker."""
+        self.config = config or Config()
+    
+    def _read_logs(
+        self,
+        days: Optional[int] = None,
+        api_config: Optional[str] = None
+    ) -> List[Dict[str, Any]]:
+        """Read usage logs with optional filters."""
+        if not self.config.usage_log.exists():
+            return []
+        
+        cutoff = None
+        if days:
+            cutoff = datetime.utcnow() - timedelta(days=days)
+        
+        logs = []
+        with open(self.config.usage_log, 'r') as f:
+            for line in f:
+                try:
+                    entry = json.loads(line)
+                    timestamp = datetime.fromisoformat(entry["timestamp"])
+                    
+                    # Apply filters
+                    if cutoff and timestamp < cutoff:
+                        continue
+                    if api_config and entry.get("api_config") != api_config:
+                        continue
+                    
+                    logs.append(entry)
+                except json.JSONDecodeError:
+                    continue
+        
+        return logs
+    
+    def _calculate_cost(self, model: str, input_tokens: int, output_tokens: int) -> float:
+        """Calculate cost for a given usage."""
+        pricing = MODEL_PRICING.get(model, {"input": 3.00, "output": 15.00})
+        
+        input_cost = (input_tokens / 1_000_000) * pricing["input"]
+        output_cost = (output_tokens / 1_000_000) * pricing["output"]
+        
+        return input_cost + output_cost
+    
+    def display_usage(
+        self,
+        console: Console,
+        days: Optional[int] = None,
+        api_config: Optional[str] = None
+    ) -> None:
+        """Display usage statistics."""
+        logs = self._read_logs(days=days, api_config=api_config)
+        
+        if not logs:
+            console.print("[yellow]No usage data found.[/yellow]")
+            return
+        
+        # Calculate totals
+        total_input = 0
+        total_output = 0
+        total_cost = 0.0
+        total_calls = len(logs)
+        
+        by_api = defaultdict(lambda: {"input": 0, "output": 0, "calls": 0, "cost": 0.0})
+        by_date = defaultdict(lambda: {"input": 0, "output": 0, "calls": 0, "cost": 0.0})
+        by_model = defaultdict(lambda: {"input": 0, "output": 0, "calls": 0, "cost": 0.0})
+        
+        for entry in logs:
+            input_tokens = entry["input_tokens"]
+            output_tokens = entry["output_tokens"]
+            model = entry["model"]
+            api = entry["api_config"]
+            date = entry["timestamp"][:10]
+            
+            cost = self._calculate_cost(model, input_tokens, output_tokens)
+            
+            total_input += input_tokens
+            total_output += output_tokens
+            total_cost += cost
+            
+            by_api[api]["input"] += input_tokens
+            by_api[api]["output"] += output_tokens
+            by_api[api]["calls"] += 1
+            by_api[api]["cost"] += cost
+            
+            by_date[date]["input"] += input_tokens
+            by_date[date]["output"] += output_tokens
+            by_date[date]["calls"] += 1
+            by_date[date]["cost"] += cost
+            
+            by_model[model]["input"] += input_tokens
+            by_model[model]["output"] += output_tokens
+            by_model[model]["calls"] += 1
+            by_model[model]["cost"] += cost
+        
+        # Display summary
+        title = "Usage Summary"
+        if days:
+            title += f" (Last {days} days)"
+        if api_config:
+            title += f" - {api_config}"
+        
+        summary = f"""[bold]Total Calls:[/bold] {total_calls:,}
+[bold]Input Tokens:[/bold] {total_input:,}
+[bold]Output Tokens:[/bold] {total_output:,}
+[bold]Total Tokens:[/bold] {total_input + total_output:,}
+[bold]Estimated Cost:[/bold] ${total_cost:.2f}"""
+        
+        console.print(Panel(summary, title=title, border_style="green"))
+        
+        # Display by API config
+        if len(by_api) > 1:
+            console.print("\n[bold]By API Config:[/bold]")
+            api_table = Table(show_header=True, header_style="bold cyan")
+            api_table.add_column("API Config")
+            api_table.add_column("Calls", justify="right")
+            api_table.add_column("Input Tokens", justify="right")
+            api_table.add_column("Output Tokens", justify="right")
+            api_table.add_column("Cost", justify="right")
+            
+            for api_name in sorted(by_api.keys()):
+                stats = by_api[api_name]
+                api_table.add_row(
+                    api_name,
+                    f"{stats['calls']:,}",
+                    f"{stats['input']:,}",
+                    f"{stats['output']:,}",
+                    f"${stats['cost']:.2f}"
+                )
+            
+            console.print(api_table)
+        
+        # Display by model
+        if len(by_model) > 1:
+            console.print("\n[bold]By Model:[/bold]")
+            model_table = Table(show_header=True, header_style="bold cyan")
+            model_table.add_column("Model")
+            model_table.add_column("Calls", justify="right")
+            model_table.add_column("Input Tokens", justify="right")
+            model_table.add_column("Output Tokens", justify="right")
+            model_table.add_column("Cost", justify="right")
+            
+            for model_name in sorted(by_model.keys()):
+                stats = by_model[model_name]
+                model_table.add_row(
+                    model_name.split("-")[-1],  # Show short version
+                    f"{stats['calls']:,}",
+                    f"{stats['input']:,}",
+                    f"{stats['output']:,}",
+                    f"${stats['cost']:.2f}"
+                )
+            
+            console.print(model_table)
+        
+        # Display by date (last 7 days)
+        console.print("\n[bold]By Date:[/bold]")
+        date_table = Table(show_header=True, header_style="bold cyan")
+        date_table.add_column("Date")
+        date_table.add_column("Calls", justify="right")
+        date_table.add_column("Tokens", justify="right")
+        date_table.add_column("Cost", justify="right")
+        
+        for date in sorted(by_date.keys(), reverse=True)[:7]:
+            stats = by_date[date]
+            total_tokens = stats['input'] + stats['output']
+            date_table.add_row(
+                date,
+                f"{stats['calls']:,}",
+                f"{total_tokens:,}",
+                f"${stats['cost']:.2f}"
+            )
+        
+        console.print(date_table)