claude-dev-cli 0.3.1__tar.gz → 0.5.0__tar.gz

{claude_dev_cli-0.3.1/src/claude_dev_cli.egg-info → claude_dev_cli-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-dev-cli
-Version: 0.3.1
+Version: 0.5.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
@@ -26,6 +26,8 @@ Requires-Dist: anthropic>=0.18.0
 Requires-Dist: click>=8.1.0
 Requires-Dist: rich>=13.0.0
 Requires-Dist: pydantic>=2.0.0
+Requires-Dist: keyring>=24.0.0
+Requires-Dist: cryptography>=41.0.0
 Provides-Extra: toon
 Requires-Dist: toon-format>=0.9.0; extra == "toon"
 Provides-Extra: plugins
@@ -46,9 +48,10 @@ A powerful command-line tool for developers using Claude AI with multi-API routi
 ## Features
 
 ### 🔑 Multi-API Key Management
+- **Secure Storage**: API keys stored in system keyring (macOS Keychain, Linux Secret Service, Windows Credential Locker)
 - Route tasks to different Claude API keys (personal, client, enterprise)
 - Automatic API selection based on project configuration
-- Environment variable support for secure key management
+- Automatic migration from plaintext to secure storage
 
 ### 🧪 Developer Tools
 - **Test Generation**: Automatic pytest test generation for Python code
@@ -98,13 +101,17 @@ pip install claude-dev-cli[toon]
 # Add your personal API key
 export PERSONAL_ANTHROPIC_API_KEY="sk-ant-..."
 cdc config add personal --default --description "My personal API key"
+# 🔐 Stored securely in system keyring
 
 # Add client's API key
 export CLIENT_ANTHROPIC_API_KEY="sk-ant-..."
 cdc config add client --description "Client's Enterprise API"
 
-# List configured APIs
+# List configured APIs (shows storage method)
 cdc config list
+
+# Manually migrate existing keys (automatic on first run)
+cdc config migrate-keys
 ```
 
 ### 2. Basic Usage
@@ -186,22 +193,37 @@ cat large_data.json | cdc toon encode | cdc ask "analyze this data"
 
 ## Configuration
 
+### Secure API Key Storage
+
+**🔐 Your API keys are stored securely and never in plain text.**
+
+- **macOS**: Keychain
+- **Linux**: Secret Service API (GNOME Keyring, KWallet)
+- **Windows**: Windows Credential Locker
+- **Fallback**: Encrypted file (if keyring unavailable)
+
+Keys are automatically migrated from plaintext on first run. You can also manually migrate:
+
+```bash
+cdc config migrate-keys
+```
+
 ### Global Configuration
 
-Configuration is stored in `~/.claude-dev-cli/config.json`:
+Configuration metadata is stored in `~/.claude-dev-cli/config.json` (API keys are NOT in this file):
 
 ```json
 {
   "api_configs": [
     {
       "name": "personal",
-      "api_key": "sk-ant-...",
+      "api_key": "",  // Empty - actual key in secure storage
       "description": "My personal API key",
       "default": true
     },
     {
       "name": "client",
-      "api_key": "sk-ant-...",
+      "api_key": "",  // Empty - actual key in secure storage
       "description": "Client's Enterprise API",
       "default": false
     }

{claude_dev_cli-0.3.1 → claude_dev_cli-0.5.0}/README.md

@@ -5,9 +5,10 @@ A powerful command-line tool for developers using Claude AI with multi-API routi
 ## Features
 
 ### 🔑 Multi-API Key Management
+- **Secure Storage**: API keys stored in system keyring (macOS Keychain, Linux Secret Service, Windows Credential Locker)
 - Route tasks to different Claude API keys (personal, client, enterprise)
 - Automatic API selection based on project configuration
-- Environment variable support for secure key management
+- Automatic migration from plaintext to secure storage
 
 ### 🧪 Developer Tools
 - **Test Generation**: Automatic pytest test generation for Python code
@@ -57,13 +58,17 @@ pip install claude-dev-cli[toon]
 # Add your personal API key
 export PERSONAL_ANTHROPIC_API_KEY="sk-ant-..."
 cdc config add personal --default --description "My personal API key"
+# 🔐 Stored securely in system keyring
 
 # Add client's API key
 export CLIENT_ANTHROPIC_API_KEY="sk-ant-..."
 cdc config add client --description "Client's Enterprise API"
 
-# List configured APIs
+# List configured APIs (shows storage method)
 cdc config list
+
+# Manually migrate existing keys (automatic on first run)
+cdc config migrate-keys
 ```
 
 ### 2. Basic Usage
@@ -145,22 +150,37 @@ cat large_data.json | cdc toon encode | cdc ask "analyze this data"
 
 ## Configuration
 
+### Secure API Key Storage
+
+**🔐 Your API keys are stored securely and never in plain text.**
+
+- **macOS**: Keychain
+- **Linux**: Secret Service API (GNOME Keyring, KWallet)
+- **Windows**: Windows Credential Locker
+- **Fallback**: Encrypted file (if keyring unavailable)
+
+Keys are automatically migrated from plaintext on first run. You can also manually migrate:
+
+```bash
+cdc config migrate-keys
+```
+
 ### Global Configuration
 
-Configuration is stored in `~/.claude-dev-cli/config.json`:
+Configuration metadata is stored in `~/.claude-dev-cli/config.json` (API keys are NOT in this file):
 
 ```json
 {
   "api_configs": [
     {
       "name": "personal",
-      "api_key": "sk-ant-...",
+      "api_key": "",  // Empty - actual key in secure storage
       "description": "My personal API key",
       "default": true
     },
     {
       "name": "client",
-      "api_key": "sk-ant-...",
+      "api_key": "",  // Empty - actual key in secure storage
       "description": "Client's Enterprise API",
       "default": false
     }

{claude_dev_cli-0.3.1 → claude_dev_cli-0.5.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "claude-dev-cli"
-version = "0.3.1"
+version = "0.5.0"
 description = "A powerful CLI tool for developers using Claude AI with multi-API routing, test generation, code review, and usage tracking"
 readme = "README.md"
 requires-python = ">=3.9"
@@ -32,6 +32,8 @@ dependencies = [
     "click>=8.1.0",
     "rich>=13.0.0",
     "pydantic>=2.0.0",
+    "keyring>=24.0.0",
+    "cryptography>=41.0.0",
 ]
 
 [project.optional-dependencies]

{claude_dev_cli-0.3.1 → claude_dev_cli-0.5.0}/src/claude_dev_cli/cli.py

@@ -1,5 +1,6 @@
 """Command-line interface for Claude Dev CLI."""
 
+import os
 import sys
 from pathlib import Path
 from typing import Optional
@@ -23,6 +24,7 @@ from claude_dev_cli.commands import (
 from claude_dev_cli.usage import UsageTracker
 from claude_dev_cli import toon_utils
 from claude_dev_cli.plugins import load_plugins
+from claude_dev_cli.history import ConversationHistory, Conversation
 
 console = Console()
 
@@ -112,11 +114,36 @@ def ask(
 
 @main.command()
 @click.option('-a', '--api', help='API config to use')
+@click.option('--continue', 'continue_conversation', is_flag=True, 
+              help='Continue the last conversation')
+@click.option('--save/--no-save', default=True, help='Save conversation history')
 @click.pass_context
-def interactive(ctx: click.Context, api: Optional[str]) -> None:
+def interactive(
+    ctx: click.Context, 
+    api: Optional[str],
+    continue_conversation: bool,
+    save: bool
+) -> None:
     """Start interactive chat mode."""
     console = ctx.obj['console']
     
+    # Setup conversation history
+    config = Config()
+    history_dir = config.config_dir / "history"
+    conv_history = ConversationHistory(history_dir)
+    
+    # Load or create conversation
+    if continue_conversation:
+        conversation = conv_history.get_latest_conversation()
+        if conversation:
+            console.print(f"[green]↶ Continuing conversation from {conversation.updated_at.strftime('%Y-%m-%d %H:%M')}[/green]")
+            console.print(f"[dim]Messages: {len(conversation.messages)}[/dim]\n")
+        else:
+            console.print("[yellow]No previous conversation found, starting new one[/yellow]\n")
+            conversation = Conversation()
+    else:
+        conversation = Conversation()
+    
     console.print(Panel.fit(
         "Claude Dev CLI - Interactive Mode\n"
         "Type 'exit' or 'quit' to end\n"
@@ -127,30 +154,179 @@ def interactive(ctx: click.Context, api: Optional[str]) -> None:
     
     try:
         client = ClaudeClient(api_config_name=api)
+        response_buffer = []
         
         while True:
             try:
                 user_input = console.input("\n[bold cyan]You:[/bold cyan] ").strip()
                 
                 if user_input.lower() in ['exit', 'quit']:
+                    if save and conversation.messages:
+                        conv_history.save_conversation(conversation)
+                        console.print(f"\n[dim]💾 Saved conversation: {conversation.conversation_id}[/dim]")
                     break
+                
+                if user_input.lower() == 'clear':
+                    conversation = Conversation()
+                    console.print("[yellow]Conversation cleared[/yellow]")
+                    continue
+                
                 if not user_input:
                     continue
                 
+                # Add user message to history
+                conversation.add_message("user", user_input)
+                
+                # Get response
                 console.print("\n[bold green]Claude:[/bold green] ", end='')
+                response_buffer = []
                 for chunk in client.call_streaming(user_input):
                     console.print(chunk, end='')
+                    response_buffer.append(chunk)
                 console.print()
                 
+                # Add assistant response to history
+                full_response = ''.join(response_buffer)
+                conversation.add_message("assistant", full_response)
+                
+                # Auto-save periodically
+                if save and len(conversation.messages) % 10 == 0:
+                    conv_history.save_conversation(conversation)
+                
             except KeyboardInterrupt:
                 console.print("\n\n[yellow]Interrupted. Type 'exit' to quit.[/yellow]")
                 continue
     
     except Exception as e:
         console.print(f"[red]Error: {e}[/red]")
+        if save and conversation.messages:
+            conv_history.save_conversation(conversation)
         sys.exit(1)
 
 
+@main.group()
+def completion() -> None:
+    """Shell completion installation."""
+    pass
+
+
+@completion.command('install')
+@click.option('--shell', type=click.Choice(['bash', 'zsh', 'fish', 'auto']), default='auto',
+              help='Shell type (auto-detects if not specified)')
+@click.pass_context
+def completion_install(ctx: click.Context, shell: str) -> None:
+    """Install shell completion for cdc command."""
+    console = ctx.obj['console']
+    
+    # Auto-detect shell if needed
+    if shell == 'auto':
+        shell_path = os.environ.get('SHELL', '')
+        if 'zsh' in shell_path:
+            shell = 'zsh'
+        elif 'bash' in shell_path:
+            shell = 'bash'
+        elif 'fish' in shell_path:
+            shell = 'fish'
+        else:
+            console.print("[red]Could not auto-detect shell[/red]")
+            console.print("Please specify: --shell bash|zsh|fish")
+            sys.exit(1)
+    
+    console.print(f"[cyan]Installing completion for {shell}...[/cyan]\n")
+    
+    if shell == 'zsh':
+        console.print("Add this to your ~/.zshrc:\n")
+        console.print("[yellow]eval \"$(_CDC_COMPLETE=zsh_source cdc)\"[/yellow]\n")
+        console.print("Then run: [cyan]source ~/.zshrc[/cyan]")
+    elif shell == 'bash':
+        console.print("Add this to your ~/.bashrc:\n")
+        console.print("[yellow]eval \"$(_CDC_COMPLETE=bash_source cdc)\"[/yellow]\n")
+        console.print("Then run: [cyan]source ~/.bashrc[/cyan]")
+    elif shell == 'fish':
+        console.print("Add this to ~/.config/fish/completions/cdc.fish:\n")
+        console.print("[yellow]_CDC_COMPLETE=fish_source cdc | source[/yellow]\n")
+        console.print("Then reload: [cyan]exec fish[/cyan]")
+    
+    console.print("\n[green]✓[/green] Instructions displayed above")
+    console.print("[dim]Completion will provide command and option suggestions[/dim]")
+
+
+@completion.command('generate')
+@click.option('--shell', type=click.Choice(['bash', 'zsh', 'fish']), required=True,
+              help='Shell type')
+@click.pass_context
+def completion_generate(ctx: click.Context, shell: str) -> None:
+    """Generate completion script for shell."""
+    import subprocess
+    import sys
+    
+    env_var = f"_CDC_COMPLETE={shell}_source"
+    result = subprocess.run(
+        [sys.executable, '-m', 'claude_dev_cli.cli'],
+        env={**os.environ, '_CDC_COMPLETE': f'{shell}_source'},
+        capture_output=True,
+        text=True
+    )
+    
+    if result.returncode == 0:
+        click.echo(result.stdout)
+    else:
+        ctx.obj['console'].print(f"[red]Error generating completion: {result.stderr}[/red]")
+        sys.exit(1)
+
+
+@main.group()
+def history() -> None:
+    """Manage conversation history."""
+    pass
+
+
+@history.command('list')
+@click.option('-n', '--limit', type=int, default=10, help='Number of conversations to show')
+@click.option('-s', '--search', help='Search conversations')
+@click.pass_context
+def history_list(ctx: click.Context, limit: int, search: Optional[str]) -> None:
+    """List conversation history."""
+    console = ctx.obj['console']
+    config = Config()
+    conv_history = ConversationHistory(config.config_dir / "history")
+    
+    conversations = conv_history.list_conversations(limit=limit, search_query=search)
+    
+    if not conversations:
+        console.print("[yellow]No conversations found[/yellow]")
+        return
+    
+    for conv in conversations:
+        summary = conv.get_summary(80)
+        console.print(f"\n[cyan]{conv.conversation_id}[/cyan]")
+        console.print(f"[dim]{conv.updated_at.strftime('%Y-%m-%d %H:%M')} | {len(conv.messages)} messages[/dim]")
+        console.print(f"  {summary}")
+
+
+@history.command('export')
+@click.argument('conversation_id')
+@click.option('--format', type=click.Choice(['markdown', 'json']), default='markdown')
+@click.option('-o', '--output', type=click.Path(), help='Output file')
+@click.pass_context
+def history_export(ctx: click.Context, conversation_id: str, format: str, output: Optional[str]) -> None:
+    """Export a conversation."""
+    console = ctx.obj['console']
+    config = Config()
+    conv_history = ConversationHistory(config.config_dir / "history")
+    
+    content = conv_history.export_conversation(conversation_id, format)
+    if not content:
+        console.print(f"[red]Conversation {conversation_id} not found[/red]")
+        sys.exit(1)
+    
+    if output:
+        Path(output).write_text(content)
+        console.print(f"[green]✓[/green] Exported to {output}")
+    else:
+        click.echo(content)
+
+
 @main.group()
 def config() -> None:
     """Manage configuration."""
@@ -182,6 +358,49 @@ def config_add(
             make_default=default
         )
         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]")
+        else:
+            console.print("[dim]🔒 Stored in encrypted file (keyring unavailable)[/dim]")
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+        sys.exit(1)
+
+
+@config.command('migrate-keys')
+@click.pass_context
+def config_migrate_keys(ctx: click.Context) -> None:
+    """Manually migrate API keys to secure storage."""
+    console = ctx.obj['console']
+    
+    try:
+        config = Config()
+        
+        # Check if any keys need migration
+        api_configs = config._data.get("api_configs", [])
+        plaintext_keys = {c["name"]: c.get("api_key", "") 
+                         for c in api_configs 
+                         if c.get("api_key")}
+        
+        if not plaintext_keys:
+            console.print("[green]✓[/green] All keys are already in secure storage.")
+            storage_method = config.secure_storage.get_storage_method()
+            console.print(f"[dim]Using: {storage_method}[/dim]")
+            return
+        
+        console.print(f"[yellow]Found {len(plaintext_keys)} plaintext key(s)[/yellow]")
+        console.print("Migrating to secure storage...\n")
+        
+        # Trigger migration
+        config._auto_migrate_keys()
+        
+        console.print(f"[green]✓[/green] Migrated {len(plaintext_keys)} key(s) to secure storage.")
+        storage_method = config.secure_storage.get_storage_method()
+        console.print(f"[dim]Using: {storage_method}[/dim]")
+        
     except Exception as e:
         console.print(f"[red]Error: {e}[/red]")
         sys.exit(1)
@@ -201,6 +420,14 @@ def config_list(ctx: click.Context) -> None:
         console.print("Run 'cdc config add' to add one.")
         return
     
+    # Show storage method
+    storage_method = config.secure_storage.get_storage_method()
+    storage_display = {
+        "keyring": "🔐 System Keyring (Secure)",
+        "encrypted_file": "🔒 Encrypted File (Fallback)"
+    }.get(storage_method, storage_method)
+    console.print(f"\n[dim]Storage: {storage_display}[/dim]\n")
+    
     for cfg in api_configs:
         default_marker = " [bold green](default)[/bold green]" if cfg.default else ""
         console.print(f"• {cfg.name}{default_marker}")

{claude_dev_cli-0.3.1 → claude_dev_cli-0.5.0}/src/claude_dev_cli/config.py

@@ -6,6 +6,8 @@ from pathlib import Path
 from typing import Dict, Optional, List
 from pydantic import BaseModel, Field
 
+from claude_dev_cli.secure_storage import SecureStorage
+
 
 class APIConfig(BaseModel):
     """Configuration for a Claude API key."""
@@ -39,6 +41,12 @@ class Config:
         
         self._ensure_config_dir()
         self._data: Dict = self._load_config()
+        
+        # Initialize secure storage
+        self.secure_storage = SecureStorage(self.config_dir)
+        
+        # Auto-migrate if plaintext keys exist
+        self._auto_migrate_keys()
     
     def _ensure_config_dir(self) -> None:
         """Ensure configuration directory exists."""
@@ -68,6 +76,22 @@ class Config:
         with open(self.config_file, 'w') as f:
             json.dump(data, f, indent=2)
     
+    def _auto_migrate_keys(self) -> None:
+        """Automatically migrate plaintext API keys to secure storage."""
+        api_configs = self._data.get("api_configs", [])
+        migrated = False
+        
+        for config in api_configs:
+            if "api_key" in config and config["api_key"]:
+                # Migrate this key to secure storage
+                self.secure_storage.store_key(config["name"], config["api_key"])
+                # Remove from plaintext config
+                config["api_key"] = ""  # Empty string indicates key is in secure storage
+                migrated = True
+        
+        if migrated:
+            self._save_config()
+    
     def add_api_config(
         self,
         name: str,
@@ -91,14 +115,18 @@ class Config:
             if config["name"] == name:
                 raise ValueError(f"API config with name '{name}' already exists")
         
+        # Store API key in secure storage
+        self.secure_storage.store_key(name, api_key)
+        
         # 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
         
+        # Store metadata without the actual key (empty string indicates secure storage)
         api_config = APIConfig(
             name=name,
-            api_key=api_key,
+            api_key="",  # Empty string indicates key is in secure storage
             description=description,
             default=make_default or not api_configs
         )
@@ -111,21 +139,53 @@ class Config:
         """Get API configuration by name or default."""
         api_configs = self._data.get("api_configs", [])
         
+        config_data = None
         if name:
             for config in api_configs:
                 if config["name"] == name:
-                    return APIConfig(**config)
+                    config_data = config
+                    break
         else:
             # Return default
             for config in api_configs:
                 if config.get("default", False):
-                    return APIConfig(**config)
+                    config_data = config
+                    break
         
-        return None
+        if not config_data:
+            return None
+        
+        # Retrieve actual API key from secure storage
+        api_key = self.secure_storage.get_key(config_data["name"])
+        if not api_key:
+            # Fallback to plaintext if not in secure storage (shouldn't happen after migration)
+            api_key = config_data.get("api_key", "")
+        
+        # Return config with actual key
+        return APIConfig(
+            name=config_data["name"],
+            api_key=api_key,
+            description=config_data.get("description"),
+            default=config_data.get("default", False)
+        )
     
     def list_api_configs(self) -> List[APIConfig]:
         """List all API configurations."""
-        return [APIConfig(**c) for c in self._data.get("api_configs", [])]
+        configs = []
+        for c in self._data.get("api_configs", []):
+            # Retrieve actual API key from secure storage
+            api_key = self.secure_storage.get_key(c["name"])
+            if not api_key:
+                # Fallback to plaintext
+                api_key = c.get("api_key", "")
+            
+            configs.append(APIConfig(
+                name=c["name"],
+                api_key=api_key,
+                description=c.get("description"),
+                default=c.get("default", False)
+            ))
+        return configs
     
     def add_project_profile(
         self,