claude-dev-cli 0.9.0__py3-none-any.whl → 0.10.0__py3-none-any.whl

claude_dev_cli/__init__.py

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

claude_dev_cli/cli.py

@@ -606,6 +606,199 @@ def config_set_model(ctx: click.Context, model: str) -> None:
         sys.exit(1)
 
 
+@main.group()
+def model() -> None:
+    """Manage model profiles and pricing."""
+    pass
+
+
+@model.command('add')
+@click.argument('name')
+@click.argument('model_id')
+@click.option('--input-price', type=float, required=True, help='Input price per Mtok (USD)')
+@click.option('--output-price', type=float, required=True, help='Output price per Mtok (USD)')
+@click.option('--description', help='Model profile description')
+@click.option('--api-config', help='Tie to specific API config')
+@click.option('--default', is_flag=True, help='Set as default')
+@click.pass_context
+def model_add(
+    ctx: click.Context,
+    name: str,
+    model_id: str,
+    input_price: float,
+    output_price: float,
+    description: Optional[str],
+    api_config: Optional[str],
+    default: bool
+) -> None:
+    """Add a model profile.
+    
+    Examples:
+      cdc model add fast claude-3-5-haiku-20241022 --input-price 0.80 --output-price 4.00
+      cdc model add enterprise-smart claude-sonnet-4-5-20250929 --input-price 2.50 --output-price 12.50 --api-config enterprise
+    """
+    console = ctx.obj['console']
+    
+    try:
+        config = Config()
+        config.add_model_profile(
+            name=name,
+            model_id=model_id,
+            input_price=input_price,
+            output_price=output_price,
+            description=description,
+            api_config_name=api_config,
+            make_default=default
+        )
+        
+        scope = f" for API '{api_config}'" if api_config else " (global)"
+        console.print(f"[green]✓[/green] Model profile '{name}' added{scope}")
+        console.print(f"[dim]Model: {model_id}[/dim]")
+        console.print(f"[dim]Pricing: ${input_price}/Mtok input, ${output_price}/Mtok output[/dim]")
+        
+        if default:
+            console.print(f"[green]Set as default{scope}[/green]")
+    
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+        sys.exit(1)
+
+
+@model.command('list')
+@click.option('--api-config', help='Filter by API config')
+@click.pass_context
+def model_list(ctx: click.Context, api_config: Optional[str]) -> None:
+    """List model profiles."""
+    console = ctx.obj['console']
+    
+    try:
+        from rich.table import Table
+        
+        config = Config()
+        profiles = config.list_model_profiles(api_config_name=api_config)
+        
+        if not profiles:
+            console.print("[yellow]No model profiles found.[/yellow]")
+            console.print("Run 'cdc model add' to create one.")
+            return
+        
+        # Get default profile
+        default_profile = config.get_default_model_profile(api_config_name=api_config)
+        
+        table = Table(show_header=True, header_style="bold magenta")
+        table.add_column("Name", style="cyan")
+        table.add_column("Model ID", style="green")
+        table.add_column("Input $/Mtok", justify="right", style="yellow")
+        table.add_column("Output $/Mtok", justify="right", style="yellow")
+        table.add_column("Scope", style="blue")
+        table.add_column("Description")
+        
+        for profile in profiles:
+            default_marker = " ⭐" if profile.name == default_profile else ""
+            scope = profile.api_config_name or "global"
+            
+            table.add_row(
+                profile.name + default_marker,
+                profile.model_id,
+                f"${profile.input_price_per_mtok:.2f}",
+                f"${profile.output_price_per_mtok:.2f}",
+                scope,
+                profile.description or ""
+            )
+        
+        console.print(table)
+        console.print(f"\n[dim]Default profile: {default_profile} ⭐[/dim]")
+    
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+        sys.exit(1)
+
+
+@model.command('show')
+@click.argument('name')
+@click.pass_context
+def model_show(ctx: click.Context, name: str) -> None:
+    """Show model profile details."""
+    console = ctx.obj['console']
+    
+    try:
+        config = Config()
+        profile = config.get_model_profile(name)
+        
+        if not profile:
+            console.print(f"[red]Model profile '{name}' not found[/red]")
+            sys.exit(1)
+        
+        scope = profile.api_config_name or "global"
+        cost_1k_in = profile.input_price_per_mtok / 1000
+        cost_1k_out = profile.output_price_per_mtok / 1000
+        
+        console.print(Panel(
+            f"[bold]{profile.name}[/bold]\n\n"
+            f"[dim]{profile.description or 'No description'}[/dim]\n\n"
+            f"Model ID: [green]{profile.model_id}[/green]\n"
+            f"Scope: [blue]{scope}[/blue]\n\n"
+            f"Pricing:\n"
+            f"  Input:  ${profile.input_price_per_mtok:.2f}/Mtok (${cost_1k_in:.4f}/1K tokens)\n"
+            f"  Output: ${profile.output_price_per_mtok:.2f}/Mtok (${cost_1k_out:.4f}/1K tokens)\n\n"
+            f"Use cases: {', '.join(profile.use_cases) if profile.use_cases else 'None specified'}",
+            title="Model Profile",
+            border_style="blue"
+        ))
+    
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+        sys.exit(1)
+
+
+@model.command('remove')
+@click.argument('name')
+@click.pass_context
+def model_remove(ctx: click.Context, name: str) -> None:
+    """Remove a model profile."""
+    console = ctx.obj['console']
+    
+    try:
+        config = Config()
+        if config.remove_model_profile(name):
+            console.print(f"[green]✓[/green] Model profile '{name}' removed")
+        else:
+            console.print(f"[red]Model profile '{name}' not found[/red]")
+            sys.exit(1)
+    
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+        sys.exit(1)
+
+
+@model.command('set-default')
+@click.argument('name')
+@click.option('--api-config', help='Set default for specific API config')
+@click.pass_context
+def model_set_default(ctx: click.Context, name: str, api_config: Optional[str]) -> None:
+    """Set default model profile.
+    
+    Examples:
+      cdc model set-default smart
+      cdc model set-default enterprise-smart --api-config enterprise
+    """
+    console = ctx.obj['console']
+    
+    try:
+        config = Config()
+        
+        if api_config:
+            config.set_api_default_model_profile(api_config, name)
+            console.print(f"[green]✓[/green] Default model for API '{api_config}' set to: {name}")
+        else:
+            config.set_default_model_profile(name)
+            console.print(f"[green]✓[/green] Global default model set to: {name}")
+    
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+        sys.exit(1)
+
+
 @main.group()
 def generate() -> None:
     """Generate code, tests, and documentation."""

claude_dev_cli/config.py

@@ -37,6 +37,19 @@ class APIConfig(BaseModel):
     api_key: str
     description: Optional[str] = None
     default: bool = False
+    default_model_profile: Optional[str] = None  # Default model profile for this API
+
+
+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
+    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
 
 
 class ProjectProfile(BaseModel):
@@ -46,6 +59,7 @@ class ProjectProfile(BaseModel):
     api_config: str  # Name of the API config to use
     system_prompt: Optional[str] = None
     allowed_commands: List[str] = Field(default_factory=lambda: ["all"])
+    model_profile: Optional[str] = None  # Preferred model profile for this project
     
     # Project memory - preferences and patterns
     auto_context: bool = False  # Default value for --auto-context flag
@@ -108,7 +122,9 @@ class Config:
             default_config = {
                 "api_configs": [],
                 "project_profiles": [],
-                "default_model": "claude-sonnet-4-5-20250929",
+                "model_profiles": self._get_default_model_profiles(),
+                "default_model": "claude-sonnet-4-5-20250929",  # Legacy, kept for backwards compat
+                "default_model_profile": "smart",
                 "max_tokens": 4096,
                 "context": ContextConfig().model_dump(),
                 "summarization": SummarizationConfig().model_dump(),
@@ -132,6 +148,10 @@ class Config:
                     config["context"] = ContextConfig().model_dump()
                 if "summarization" not in config:
                     config["summarization"] = SummarizationConfig().model_dump()
+                if "model_profiles" not in config:
+                    config["model_profiles"] = self._get_default_model_profiles()
+                if "default_model_profile" not in config:
+                    config["default_model_profile"] = "smart"
                 
                 return config
         except (json.JSONDecodeError, IOError) as e:
@@ -147,6 +167,38 @@ class Config:
         with open(self.config_file, 'w') as f:
             json.dump(data, f, indent=2)
     
+    def _get_default_model_profiles(self) -> List[Dict]:
+        """Get default model profiles with current Anthropic pricing."""
+        return [
+            {
+                "name": "fast",
+                "model_id": "claude-3-5-haiku-20241022",
+                "description": "Fast and economical for simple tasks",
+                "input_price_per_mtok": 0.80,
+                "output_price_per_mtok": 4.00,
+                "use_cases": ["quick", "simple", "classification"],
+                "api_config_name": None
+            },
+            {
+                "name": "smart",
+                "model_id": "claude-sonnet-4-5-20250929",
+                "description": "Balanced performance and cost for most tasks",
+                "input_price_per_mtok": 3.00,
+                "output_price_per_mtok": 15.00,
+                "use_cases": ["general", "coding", "analysis"],
+                "api_config_name": None
+            },
+            {
+                "name": "powerful",
+                "model_id": "claude-opus-4-20250514",
+                "description": "Maximum capability for complex tasks",
+                "input_price_per_mtok": 15.00,
+                "output_price_per_mtok": 75.00,
+                "use_cases": ["complex", "research", "creative"],
+                "api_config_name": None
+            }
+        ]
+    
     def _auto_migrate_keys(self) -> None:
         """Automatically migrate plaintext API keys to secure storage."""
         api_configs = self._data.get("api_configs", [])
@@ -322,3 +374,154 @@ class Config:
         """Get conversation summarization configuration."""
         summ_data = self._data.get("summarization", {})
         return SummarizationConfig(**summ_data) if summ_data else SummarizationConfig()
+    
+    # Model Profile Management
+    
+    def add_model_profile(
+        self,
+        name: str,
+        model_id: str,
+        input_price: float,
+        output_price: float,
+        description: Optional[str] = None,
+        use_cases: Optional[List[str]] = None,
+        api_config_name: Optional[str] = None,
+        make_default: bool = False
+    ) -> None:
+        """Add a model profile."""
+        profiles = self._data.get("model_profiles", [])
+        
+        # Check if name already exists
+        for profile in profiles:
+            if profile["name"] == name:
+                raise ValueError(f"Model profile '{name}' already exists")
+        
+        profile = ModelProfile(
+            name=name,
+            model_id=model_id,
+            description=description,
+            input_price_per_mtok=input_price,
+            output_price_per_mtok=output_price,
+            use_cases=use_cases or [],
+            api_config_name=api_config_name
+        )
+        
+        profiles.append(profile.model_dump())
+        self._data["model_profiles"] = profiles
+        
+        if make_default:
+            if api_config_name:
+                # Set as default for specific API config
+                self.set_api_default_model_profile(api_config_name, name)
+            else:
+                # Set as global default
+                self._data["default_model_profile"] = name
+        
+        self._save_config()
+    
+    def get_model_profile(
+        self,
+        name: str,
+        api_config_name: Optional[str] = None
+    ) -> Optional[ModelProfile]:
+        """Get model profile by name.
+        
+        If api_config_name is provided, prefer API-specific profiles.
+        """
+        profiles = self._data.get("model_profiles", [])
+        
+        # First, try to find API-specific profile
+        if api_config_name:
+            for p in profiles:
+                if p["name"] == name and p.get("api_config_name") == api_config_name:
+                    return ModelProfile(**p)
+        
+        # Fall back to global profile (api_config_name = None)
+        for p in profiles:
+            if p["name"] == name and p.get("api_config_name") is None:
+                return ModelProfile(**p)
+        
+        # Fall back to any profile with that name
+        for p in profiles:
+            if p["name"] == name:
+                return ModelProfile(**p)
+        
+        return None
+    
+    def list_model_profiles(
+        self,
+        api_config_name: Optional[str] = None
+    ) -> List[ModelProfile]:
+        """List model profiles.
+        
+        If api_config_name is provided, include both global and API-specific profiles.
+        """
+        profiles = self._data.get("model_profiles", [])
+        result = []
+        
+        for p in profiles:
+            profile_api = p.get("api_config_name")
+            # Include if: global profile OR matches requested API
+            if profile_api is None or (api_config_name and profile_api == api_config_name):
+                result.append(ModelProfile(**p))
+        
+        return result
+    
+    def remove_model_profile(self, name: str) -> bool:
+        """Remove a model profile."""
+        profiles = self._data.get("model_profiles", [])
+        original_count = len(profiles)
+        
+        self._data["model_profiles"] = [
+            p for p in profiles if p["name"] != name
+        ]
+        
+        if len(self._data["model_profiles"]) < original_count:
+            self._save_config()
+            return True
+        return False
+    
+    def set_default_model_profile(self, name: str) -> None:
+        """Set global default model profile."""
+        # Verify profile exists
+        if not self.get_model_profile(name):
+            raise ValueError(f"Model profile '{name}' not found")
+        
+        self._data["default_model_profile"] = name
+        self._save_config()
+    
+    def get_default_model_profile(self, api_config_name: Optional[str] = None) -> str:
+        """Get default model profile name.
+        
+        Resolution order:
+        1. API-specific default
+        2. Global default
+        3. Fallback to 'smart'
+        """
+        # Check API-specific default
+        if api_config_name:
+            api_configs = self._data.get("api_configs", [])
+            for config in api_configs:
+                if config["name"] == api_config_name:
+                    api_default = config.get("default_model_profile")
+                    if api_default:
+                        return api_default
+        
+        # Global default
+        return self._data.get("default_model_profile", "smart")
+    
+    def set_api_default_model_profile(self, api_config_name: str, profile_name: str) -> None:
+        """Set default model profile for a specific API config."""
+        api_configs = self._data.get("api_configs", [])
+        
+        found = False
+        for config in api_configs:
+            if config["name"] == api_config_name:
+                config["default_model_profile"] = profile_name
+                found = True
+                break
+        
+        if not found:
+            raise ValueError(f"API config '{api_config_name}' not found")
+        
+        self._save_config()

claude_dev_cli/core.py

@@ -39,6 +39,44 @@ class ClaudeClient:
         self.model = self.config.get_model()
         self.max_tokens = self.config.get_max_tokens()
     
+    def _resolve_model(self, model_or_profile: Optional[str] = None) -> str:
+        """Resolve model profile name or ID to actual model ID.
+        
+        Resolution hierarchy:
+        1. Explicit model_or_profile parameter (if provided)
+        2. Project-specific model profile
+        3. API-specific default model profile
+        4. Global default model profile
+        5. Legacy default model setting
+        
+        Returns actual model ID for API calls.
+        """
+        # Start with explicit parameter or legacy model setting
+        profile_or_id = model_or_profile or self.model
+        
+        # If no explicit model, check hierarchical defaults
+        if not model_or_profile:
+            # Check project profile
+            project_profile = self.config.get_project_profile()
+            if project_profile and project_profile.model_profile:
+                profile_or_id = project_profile.model_profile
+            else:
+                # Get API or global default profile name
+                profile_or_id = self.config.get_default_model_profile(
+                    api_config_name=self.api_config.name
+                )
+        
+        # Try to resolve as profile name
+        profile = self.config.get_model_profile(
+            profile_or_id,
+            api_config_name=self.api_config.name
+        )
+        if profile:
+            return profile.model_id
+        
+        # Assume it's already a model ID
+        return profile_or_id
+    
     def call(
         self,
         prompt: str,
@@ -48,8 +86,13 @@ class ClaudeClient:
         temperature: float = 1.0,
         stream: bool = False
     ) -> str:
-        """Make a call to Claude API."""
-        model = model or self.model
+        """Make a call to Claude API.
+        
+        Args:
+            model: Model ID or profile name (e.g., 'fast', 'smart', 'powerful')
+        """
+        # Resolve profile name to model ID
+        resolved_model = self._resolve_model(model)
         max_tokens = max_tokens or self.max_tokens
         
         # Check project profile for system prompt
@@ -75,7 +118,7 @@ class ClaudeClient:
         self._log_usage(
             prompt=prompt,
             response=response,
-            model=model,
+            model=resolved_model,
             duration_ms=int((end_time - start_time).total_seconds() * 1000),
             api_config_name=self.api_config.name
         )
@@ -94,8 +137,13 @@ class ClaudeClient:
         max_tokens: Optional[int] = None,
         temperature: float = 1.0
     ):
-        """Make a streaming call to Claude API."""
-        model = model or self.model
+        """Make a streaming call to Claude API.
+        
+        Args:
+            model: Model ID or profile name (e.g., 'fast', 'smart', 'powerful')
+        """
+        # Resolve profile name to model ID
+        resolved_model = self._resolve_model(model)
         max_tokens = max_tokens or self.max_tokens
         
         # Check project profile for system prompt
@@ -104,7 +152,7 @@ class ClaudeClient:
             system_prompt = project_profile.system_prompt
         
         kwargs: Dict[str, Any] = {
-            "model": model,
+            "model": resolved_model,
             "max_tokens": max_tokens,
             "temperature": temperature,
             "messages": [{"role": "user", "content": prompt}]

claude_dev_cli/usage.py

@@ -13,16 +13,6 @@ 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."""
     
@@ -62,13 +52,30 @@ class UsageTracker:
         
         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"]
-        
+    def _calculate_cost(
+        self,
+        model: str,
+        input_tokens: int,
+        output_tokens: int,
+        api_config_name: Optional[str] = None
+    ) -> float:
+        """Calculate cost for a given usage.
+        
+        Looks up pricing from model profiles. Falls back to:
+        1. Finding profile with matching model_id
+        2. Default Sonnet pricing if no match found
+        """
+        # Try to find profile by model_id
+        profiles = self.config.list_model_profiles(api_config_name=api_config_name)
+        for profile in profiles:
+            if profile.model_id == model:
+                input_cost = (input_tokens / 1_000_000) * profile.input_price_per_mtok
+                output_cost = (output_tokens / 1_000_000) * profile.output_price_per_mtok
+                return input_cost + output_cost
+        
+        # Fallback to default Sonnet pricing
+        input_cost = (input_tokens / 1_000_000) * 3.00
+        output_cost = (output_tokens / 1_000_000) * 15.00
         return input_cost + output_cost
     
     def display_usage(
@@ -101,7 +108,7 @@ class UsageTracker:
             api = entry["api_config"]
             date = entry["timestamp"][:10]
             
-            cost = self._calculate_cost(model, input_tokens, output_tokens)
+            cost = self._calculate_cost(model, input_tokens, output_tokens, api_config_name=api)
             
             total_input += input_tokens
             total_output += output_tokens

{claude_dev_cli-0.9.0.dist-info → claude_dev_cli-0.10.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-dev-cli
-Version: 0.9.0
+Version: 0.10.0
 Summary: A powerful CLI tool for developers using Claude AI with multi-API routing, test generation, code review, and usage tracking
 Author-email: Julio <thinmanj@users.noreply.github.com>
 License: MIT
@@ -46,7 +46,7 @@ Dynamic: license-file
 
 [![PyPI version](https://badge.fury.io/py/claude-dev-cli.svg)](https://badge.fury.io/py/claude-dev-cli)
 [![Python 3.9+](https://img.shields.io/badge/python-3.9+-blue.svg)](https://www.python.org/downloads/)
-[![Tests](https://img.shields.io/badge/tests-259%20passing-brightgreen.svg)](https://github.com/thinmanj/claude-dev-cli)
+[![Tests](https://img.shields.io/badge/tests-260%20passing-brightgreen.svg)](https://github.com/thinmanj/claude-dev-cli)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![Homebrew](https://img.shields.io/badge/homebrew-available-orange.svg)](https://github.com/thinmanj/homebrew-tap)
 [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
@@ -61,6 +61,17 @@ A powerful command-line tool for developers using Claude AI with multi-API routi
 - Automatic API selection based on project configuration
 - Automatic migration from plaintext to secure storage
 
+### 🎯 Model Profiles (v0.10.0+)
+- **Named Profiles**: Use friendly names instead of full model IDs (`fast`, `smart`, `powerful`)
+- **Custom Pricing**: Define input/output costs per Mtok for accurate usage tracking
+- **API-Specific Profiles**: Different models and pricing per API config
+- **Project Defaults**: Set per-project model preferences
+- **Dynamic Resolution**: Profile names automatically resolve to model IDs
+- **Built-in Profiles**:
+  - `fast`: Claude 3.5 Haiku ($0.80/$4.00 per Mtok)
+  - `smart`: Claude Sonnet 4 ($3.00/$15.00 per Mtok) - default
+  - `powerful`: Claude Opus 4 ($15.00/$75.00 per Mtok)
+
 ### 🧪 Developer Tools
 - **Test Generation**: Automatic pytest test generation for Python code
 - **Code Review**: Comprehensive code reviews with security, performance, and best practice checks
@@ -163,9 +174,13 @@ cdc config migrate-keys
 ### 2. Basic Usage
 
 ```bash
-# Ask a question
+# Ask a question (uses 'smart' profile by default)
 cdc ask "explain asyncio in Python"
 
+# Use a specific model profile
+cdc ask -m fast "quick question"  # Uses Haiku (fast & cheap)
+cdc ask -m powerful "complex task"  # Uses Opus 4 (most capable)
+
 # With file context
 cdc ask -f mycode.py "review this code"
 
@@ -179,6 +194,41 @@ cdc interactive
 cdc ask -a client "generate tests for this function"
 ```
 
+### 3. Model Profile Management (v0.10.0+)
+
+```bash
+# List available model profiles
+cdc model list
+# ┌───────────┬──────────────────────────┬────────┬────────┐
+# │ Profile   │ Model ID                 │ Input  │ Output │
+# │ fast      │ claude-3-5-haiku-...     │ $0.80  │ $4.00  │
+# │ smart     │ claude-sonnet-4-...      │ $3.00  │ $15.00 │ ← default
+# │ powerful  │ claude-opus-4-...        │ $15.00 │ $75.00 │
+# └───────────┴──────────────────────────┴────────┴────────┘
+
+# Add a custom profile
+cdc model add lightning claude-3-5-haiku-20241022 \
+  --input-price 0.80 --output-price 4.00 \
+  --description "Ultra-fast model for simple tasks"
+
+# Set default model profile
+cdc model set-default fast  # Use Haiku by default
+
+# Set default for specific API config
+cdc model set-default powerful --api enterprise  # Opus for enterprise API
+
+# Show profile details
+cdc model show smart
+
+# Remove a profile
+cdc model remove lightning
+
+# Use profiles in any command
+cdc ask -m fast "simple question"
+cdc review -m powerful complex_file.py  # More thorough review
+cdc generate tests -m smart mymodule.py  # Balanced approach
+```
+
 ### 3. Developer Commands
 
 ```bash

{claude_dev_cli-0.9.0.dist-info → claude_dev_cli-0.10.0.dist-info}/RECORD

@@ -1,15 +1,15 @@
-claude_dev_cli/__init__.py,sha256=l4Q-KBAPo2Xn0ud4JNvbN7XdOxtSWVsrfW_qGq9BsWY,469
-claude_dev_cli/cli.py,sha256=CmgiAsoNZwz-RVQslESipkMnlte3yGlss87WqmEO1gA,61898
+claude_dev_cli/__init__.py,sha256=VPv4UMGva44cEmCged38XThRzT1wbvPMvPu5IE2nkr0,470
+claude_dev_cli/cli.py,sha256=kdEocOqRYTFsFlsfZMe5LTk9gBj6iIEqOG1JB42L1WI,68521
 claude_dev_cli/commands.py,sha256=RKGx2rv56PM6eErvA2uoQ20hY8babuI5jav8nCUyUOk,3964
-claude_dev_cli/config.py,sha256=LL6FgDrhzp7W841JnFeN8Ozo7mDwh4ZqmB9YPBuMJT8,12310
+claude_dev_cli/config.py,sha256=ZnPvzwlXsoY9YhqTl4S__fwY1MzJXKIaYK0nIIelNXk,19978
 claude_dev_cli/context.py,sha256=1TlLzpREFZDEIuU7RAtlkjxARKWZpnxHHvK283sUAZE,26714
-claude_dev_cli/core.py,sha256=yaLjEixDvPzvUy4fJ2UB7nMpPPLyKACjR-RuM-1OQBY,4780
+claude_dev_cli/core.py,sha256=-EoD-xY0i9RSM-LkQoYvL1Dsaut0eg4mgKFnSm_eZmw,6612
 claude_dev_cli/history.py,sha256=26EjNW68JuFQJhUp1j8UdB19S-eYz3eqevkpCOATwP0,10510
 claude_dev_cli/secure_storage.py,sha256=KcZuQMLTbQpMAi2Cyh-_JkNcK9vHzAITOgjTcM9sr98,8161
 claude_dev_cli/template_manager.py,sha256=wtcrNuxFoJLJIPmIxUzrPKrE8kUvdqEd53EnG3jARhg,9277
 claude_dev_cli/templates.py,sha256=lKxH943ySfUKgyHaWa4W3LVv91SgznKgajRtSRp_4UY,2260
 claude_dev_cli/toon_utils.py,sha256=S3px2UvmNEaltmTa5K-h21n2c0CPvYjZc9mc7kHGqNQ,2828
-claude_dev_cli/usage.py,sha256=32rs0_dUn6ihha3vCfT3rwnvel_-sED7jvLpO7gu-KQ,7446
+claude_dev_cli/usage.py,sha256=7F92mVUenSsONZxmug3ZLbd-8l1qcbqCAzzLbsrJF5Y,7700
 claude_dev_cli/warp_integration.py,sha256=PDufAJecl7uN0DGz6XW4uDSEeu7Ssg53DOIFKm-AXVg,6909
 claude_dev_cli/workflows.py,sha256=WpLq9I_0MmDsJIbCi9-f662JVyn8iKTs1KZ50w-GlZU,12202
 claude_dev_cli/plugins/__init__.py,sha256=BdiZlylBzEgnwK2tuEdn8cITxhAZRVbTnDbWhdDhgqs,1340
@@ -17,9 +17,9 @@ claude_dev_cli/plugins/base.py,sha256=H4HQet1I-a3WLCfE9F06Lp8NuFvVoIlou7sIgyJFK-
 claude_dev_cli/plugins/diff_editor/__init__.py,sha256=gqR5S2TyIVuq-sK107fegsutQ7Z-sgAIEbtc71FhXIM,101
 claude_dev_cli/plugins/diff_editor/plugin.py,sha256=M1bUoqpasD3ZNQo36Fu_8g92uySPZyG_ujMbj5UplsU,3073
 claude_dev_cli/plugins/diff_editor/viewer.py,sha256=1IOXIKw_01ppJx5C1dQt9Kr6U1TdAHT8_iUT5r_q0NM,17169
-claude_dev_cli-0.9.0.dist-info/licenses/LICENSE,sha256=DGueuJwMJtMwgLO5mWlS0TaeBrFwQuNpNZ22PU9J2bw,1062
-claude_dev_cli-0.9.0.dist-info/METADATA,sha256=eM3akR9ZsZkTfsjeNRlySn0uubJUOadurw7yTjbygfk,17356
-claude_dev_cli-0.9.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-claude_dev_cli-0.9.0.dist-info/entry_points.txt,sha256=zymgUIIVpFTARkFmxAuW2A4BQsNITh_L0uU-XunytHg,85
-claude_dev_cli-0.9.0.dist-info/top_level.txt,sha256=m7MF6LOIuTe41IT5Fgt0lc-DK1EgM4gUU_IZwWxK0pg,15
-claude_dev_cli-0.9.0.dist-info/RECORD,,
+claude_dev_cli-0.10.0.dist-info/licenses/LICENSE,sha256=DGueuJwMJtMwgLO5mWlS0TaeBrFwQuNpNZ22PU9J2bw,1062
+claude_dev_cli-0.10.0.dist-info/METADATA,sha256=5KCr5ng6VgwpiLoL07exV5g09zTgfQKXkuNHnukcWdw,19569
+claude_dev_cli-0.10.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+claude_dev_cli-0.10.0.dist-info/entry_points.txt,sha256=zymgUIIVpFTARkFmxAuW2A4BQsNITh_L0uU-XunytHg,85
+claude_dev_cli-0.10.0.dist-info/top_level.txt,sha256=m7MF6LOIuTe41IT5Fgt0lc-DK1EgM4gUU_IZwWxK0pg,15
+claude_dev_cli-0.10.0.dist-info/RECORD,,