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

{claude_dev_cli-0.4.0/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.4.0
+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

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "claude-dev-cli"
-version = "0.4.0"
+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"

{claude_dev_cli-0.4.0 → 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."""

claude_dev_cli-0.5.0/src/claude_dev_cli/history.py

@@ -0,0 +1,189 @@
+"""Conversation history management for interactive mode."""
+
+import json
+from datetime import datetime
+from pathlib import Path
+from typing import List, Optional, Dict, Any
+
+
+class Message:
+    """Represents a single message in a conversation."""
+    
+    def __init__(self, role: str, content: str, timestamp: Optional[datetime] = None):
+        self.role = role  # "user" or "assistant"
+        self.content = content
+        self.timestamp = timestamp or datetime.utcnow()
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for storage."""
+        return {
+            "role": self.role,
+            "content": self.content,
+            "timestamp": self.timestamp.isoformat()
+        }
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "Message":
+        """Create from dictionary."""
+        return cls(
+            role=data["role"],
+            content=data["content"],
+            timestamp=datetime.fromisoformat(data["timestamp"])
+        )
+
+
+class Conversation:
+    """Represents a conversation with messages."""
+    
+    def __init__(
+        self,
+        conversation_id: Optional[str] = None,
+        created_at: Optional[datetime] = None,
+        updated_at: Optional[datetime] = None
+    ):
+        self.conversation_id = conversation_id or datetime.utcnow().strftime("%Y%m%d_%H%M%S")
+        self.created_at = created_at or datetime.utcnow()
+        self.updated_at = updated_at or datetime.utcnow()
+        self.messages: List[Message] = []
+    
+    def add_message(self, role: str, content: str) -> None:
+        """Add a message to the conversation."""
+        message = Message(role, content)
+        self.messages.append(message)
+        self.updated_at = datetime.utcnow()
+    
+    def get_summary(self, max_length: int = 100) -> str:
+        """Get a summary of the conversation (first user message)."""
+        for msg in self.messages:
+            if msg.role == "user":
+                summary = msg.content[:max_length]
+                if len(msg.content) > max_length:
+                    summary += "..."
+                return summary
+        return "(empty conversation)"
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for storage."""
+        return {
+            "conversation_id": self.conversation_id,
+            "created_at": self.created_at.isoformat(),
+            "updated_at": self.updated_at.isoformat(),
+            "messages": [msg.to_dict() for msg in self.messages]
+        }
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "Conversation":
+        """Create from dictionary."""
+        conv = cls(
+            conversation_id=data["conversation_id"],
+            created_at=datetime.fromisoformat(data["created_at"]),
+            updated_at=datetime.fromisoformat(data["updated_at"])
+        )
+        conv.messages = [Message.from_dict(msg) for msg in data.get("messages", [])]
+        return conv
+
+
+class ConversationHistory:
+    """Manages conversation history storage and retrieval."""
+    
+    def __init__(self, history_dir: Path):
+        self.history_dir = history_dir
+        self.history_dir.mkdir(parents=True, exist_ok=True)
+    
+    def _get_conversation_file(self, conversation_id: str) -> Path:
+        """Get the file path for a conversation."""
+        return self.history_dir / f"{conversation_id}.json"
+    
+    def save_conversation(self, conversation: Conversation) -> None:
+        """Save a conversation to disk."""
+        file_path = self._get_conversation_file(conversation.conversation_id)
+        with open(file_path, 'w') as f:
+            json.dump(conversation.to_dict(), f, indent=2)
+    
+    def load_conversation(self, conversation_id: str) -> Optional[Conversation]:
+        """Load a conversation from disk."""
+        file_path = self._get_conversation_file(conversation_id)
+        if not file_path.exists():
+            return None
+        
+        try:
+            with open(file_path, 'r') as f:
+                data = json.load(f)
+            return Conversation.from_dict(data)
+        except Exception:
+            return None
+    
+    def list_conversations(
+        self,
+        limit: Optional[int] = None,
+        search_query: Optional[str] = None
+    ) -> List[Conversation]:
+        """List all conversations, optionally filtered and limited."""
+        conversations = []
+        
+        for file_path in sorted(self.history_dir.glob("*.json"), reverse=True):
+            try:
+                with open(file_path, 'r') as f:
+                    data = json.load(f)
+                conv = Conversation.from_dict(data)
+                
+                # Apply search filter if provided
+                if search_query:
+                    search_lower = search_query.lower()
+                    found = False
+                    for msg in conv.messages:
+                        if search_lower in msg.content.lower():
+                            found = True
+                            break
+                    if not found:
+                        continue
+                
+                conversations.append(conv)
+                
+                if limit and len(conversations) >= limit:
+                    break
+            except Exception:
+                continue
+        
+        return conversations
+    
+    def delete_conversation(self, conversation_id: str) -> bool:
+        """Delete a conversation."""
+        file_path = self._get_conversation_file(conversation_id)
+        if file_path.exists():
+            file_path.unlink()
+            return True
+        return False
+    
+    def get_latest_conversation(self) -> Optional[Conversation]:
+        """Get the most recent conversation."""
+        conversations = self.list_conversations(limit=1)
+        return conversations[0] if conversations else None
+    
+    def export_conversation(
+        self,
+        conversation_id: str,
+        output_format: str = "markdown"
+    ) -> Optional[str]:
+        """Export a conversation to a specific format."""
+        conv = self.load_conversation(conversation_id)
+        if not conv:
+            return None
+        
+        if output_format == "markdown":
+            lines = [f"# Conversation: {conv.conversation_id}"]
+            lines.append(f"\nCreated: {conv.created_at.strftime('%Y-%m-%d %H:%M:%S')}")
+            lines.append(f"Updated: {conv.updated_at.strftime('%Y-%m-%d %H:%M:%S')}\n")
+            
+            for msg in conv.messages:
+                role_display = "**You:**" if msg.role == "user" else "**Claude:**"
+                lines.append(f"\n## {role_display}\n")
+                lines.append(msg.content)
+                lines.append("")
+            
+            return "\n".join(lines)
+        
+        elif output_format == "json":
+            return json.dumps(conv.to_dict(), indent=2)
+        
+        return None

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-dev-cli
-Version: 0.4.0
+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

{claude_dev_cli-0.4.0 → claude_dev_cli-0.5.0}/src/claude_dev_cli.egg-info/SOURCES.txt

@@ -7,6 +7,7 @@ src/claude_dev_cli/cli.py
 src/claude_dev_cli/commands.py
 src/claude_dev_cli/config.py
 src/claude_dev_cli/core.py
+src/claude_dev_cli/history.py
 src/claude_dev_cli/secure_storage.py
 src/claude_dev_cli/templates.py
 src/claude_dev_cli/toon_utils.py