claude-dev-cli 0.8.2__tar.gz → 0.8.4__tar.gz

{claude_dev_cli-0.8.2/src/claude_dev_cli.egg-info → claude_dev_cli-0.8.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-dev-cli
-Version: 0.8.2
+Version: 0.8.4
 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
@@ -44,6 +44,13 @@ Dynamic: license-file
 
 # Claude Dev CLI
 
+[![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-257%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)
+
 A powerful command-line tool for developers using Claude AI with multi-API routing, test generation, code review, and comprehensive usage tracking.
 
 ## Features
@@ -99,19 +106,39 @@ A powerful command-line tool for developers using Claude AI with multi-API routi
 
 ## Installation
 
-### Basic Installation
+### Via Homebrew (macOS/Linux)
 
 ```bash
-pip install claude-dev-cli
+# Add the tap
+brew tap thinmanj/tap
+
+# Install
+brew install claude-dev-cli
+
+# Or in one command
+brew install thinmanj/tap/claude-dev-cli
 ```
 
-### With TOON Support (Recommended for Cost Savings)
+### Via pip
 
 ```bash
-# Install with TOON format support for 30-60% token reduction
+# Basic installation
+pip install claude-dev-cli
+
+# With TOON support (30-60% token reduction)
 pip install claude-dev-cli[toon]
 ```
 
+### Via pipx (Recommended for CLI tools)
+
+```bash
+# Isolated installation
+pipx install claude-dev-cli
+
+# With TOON support
+pipx install claude-dev-cli[toon]
+```
+
 ## Quick Start
 
 ### 1. Set Up API Keys
@@ -266,7 +293,33 @@ cdc template list --user
 - **explain-code**: Detailed code explanation
 - **api-design**: API design assistance
 
-### 6. Usage Tracking
+### 6. Conversation History & Summarization (NEW in v0.8.3)
+
+```bash
+# List recent conversations
+cdc history list
+
+# Search conversations
+cdc history list --search "python decorators"
+
+# Export conversation
+cdc history export 20240109_143022 -o chat.md
+
+# Summarize to reduce token usage
+cdc history summarize --latest
+cdc history summarize 20240109_143022 --keep-recent 6
+
+# Delete old conversations
+cdc history delete 20240109_143022
+```
+
+**Auto-Summarization** in interactive mode:
+- Automatically triggers when conversation exceeds 8,000 tokens
+- Keeps recent messages (default: 4 pairs), summarizes older ones
+- Reduces API costs by ~30-50% in long conversations
+- Shows token savings after summarization
+
+### 7. Usage Tracking
 
 ```bash
 # View all usage

{claude_dev_cli-0.8.2 → claude_dev_cli-0.8.4}/README.md

@@ -1,5 +1,12 @@
 # Claude Dev CLI
 
+[![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-257%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)
+
 A powerful command-line tool for developers using Claude AI with multi-API routing, test generation, code review, and comprehensive usage tracking.
 
 ## Features
@@ -55,19 +62,39 @@ A powerful command-line tool for developers using Claude AI with multi-API routi
 
 ## Installation
 
-### Basic Installation
+### Via Homebrew (macOS/Linux)
 
 ```bash
-pip install claude-dev-cli
+# Add the tap
+brew tap thinmanj/tap
+
+# Install
+brew install claude-dev-cli
+
+# Or in one command
+brew install thinmanj/tap/claude-dev-cli
 ```
 
-### With TOON Support (Recommended for Cost Savings)
+### Via pip
 
 ```bash
-# Install with TOON format support for 30-60% token reduction
+# Basic installation
+pip install claude-dev-cli
+
+# With TOON support (30-60% token reduction)
 pip install claude-dev-cli[toon]
 ```
 
+### Via pipx (Recommended for CLI tools)
+
+```bash
+# Isolated installation
+pipx install claude-dev-cli
+
+# With TOON support
+pipx install claude-dev-cli[toon]
+```
+
 ## Quick Start
 
 ### 1. Set Up API Keys
@@ -222,7 +249,33 @@ cdc template list --user
 - **explain-code**: Detailed code explanation
 - **api-design**: API design assistance
 
-### 6. Usage Tracking
+### 6. Conversation History & Summarization (NEW in v0.8.3)
+
+```bash
+# List recent conversations
+cdc history list
+
+# Search conversations
+cdc history list --search "python decorators"
+
+# Export conversation
+cdc history export 20240109_143022 -o chat.md
+
+# Summarize to reduce token usage
+cdc history summarize --latest
+cdc history summarize 20240109_143022 --keep-recent 6
+
+# Delete old conversations
+cdc history delete 20240109_143022
+```
+
+**Auto-Summarization** in interactive mode:
+- Automatically triggers when conversation exceeds 8,000 tokens
+- Keeps recent messages (default: 4 pairs), summarizes older ones
+- Reduces API costs by ~30-50% in long conversations
+- Shows token savings after summarization
+
+### 7. Usage Tracking
 
 ```bash
 # View all usage

{claude_dev_cli-0.8.2 → claude_dev_cli-0.8.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "claude-dev-cli"
-version = "0.8.2"
+version = "0.8.4"
 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.8.2 → claude_dev_cli-0.8.4}/src/claude_dev_cli/__init__.py

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

{claude_dev_cli-0.8.2 → claude_dev_cli-0.8.4}/src/claude_dev_cli/cli.py

@@ -145,6 +145,7 @@ def interactive(
     config = Config()
     history_dir = config.config_dir / "history"
     conv_history = ConversationHistory(history_dir)
+    summ_config = config.get_summarization_config()
     
     # Load or create conversation
     if continue_conversation:
@@ -203,6 +204,42 @@ def interactive(
                 full_response = ''.join(response_buffer)
                 conversation.add_message("assistant", full_response)
                 
+                # Check if auto-summarization is needed
+                if summ_config.auto_summarize and conversation.should_summarize(threshold_tokens=summ_config.threshold_tokens):
+                    console.print("\n[yellow]⚠ Conversation getting long, summarizing older messages...[/yellow]")
+                    old_messages, recent_messages = conversation.compress_messages(keep_recent=summ_config.keep_recent_messages)
+                    
+                    if old_messages:
+                        # Build summary prompt
+                        conversation_text = []
+                        if conversation.summary:
+                            conversation_text.append(f"Previous summary:\n{conversation.summary}\n\n")
+                        
+                        conversation_text.append("Conversation to summarize:\n")
+                        for msg in old_messages:
+                            role_name = "User" if msg.role == "user" else "Assistant"
+                            conversation_text.append(f"{role_name}: {msg.content}\n")
+                        
+                        summary_prompt = (
+                            "Please provide a concise summary of this conversation that captures:"
+                            "\n1. Main topics discussed"
+                            "\n2. Key questions asked and answers provided"
+                            "\n3. Important decisions or conclusions"
+                            "\n4. Any action items or follow-ups mentioned"
+                            "\n\nKeep the summary under 300 words but retain all important context."
+                            "\n\n" + "".join(conversation_text)
+                        )
+                        
+                        # Get summary (use same client)
+                        new_summary = client.call(summary_prompt)
+                        
+                        # Update conversation
+                        conversation.summary = new_summary
+                        conversation.messages = recent_messages
+                        
+                        tokens_saved = len("".join(conversation_text)) // 4
+                        console.print(f"[dim]✓ Summarized older messages (~{tokens_saved:,} tokens saved)[/dim]")
+                
                 # Auto-save periodically
                 if save and len(conversation.messages) % 10 == 0:
                     conv_history.save_conversation(conversation)
@@ -341,6 +378,100 @@ def history_export(ctx: click.Context, conversation_id: str, format: str, output
         click.echo(content)
 
 
+@history.command('summarize')
+@click.argument('conversation_id', required=False)
+@click.option('--keep-recent', type=int, default=4, help='Number of recent message pairs to keep')
+@click.option('--latest', is_flag=True, help='Summarize the latest conversation')
+@click.pass_context
+def history_summarize(
+    ctx: click.Context, 
+    conversation_id: Optional[str], 
+    keep_recent: int,
+    latest: bool
+) -> None:
+    """Summarize a conversation to reduce token usage.
+    
+    Older messages are compressed into an AI-generated summary while keeping
+    recent messages intact. This reduces context window usage and costs.
+    
+    Examples:
+        cdc history summarize 20240109_143022
+        cdc history summarize --latest
+        cdc history summarize --latest --keep-recent 6
+    """
+    console = ctx.obj['console']
+    config = Config()
+    conv_history = ConversationHistory(config.config_dir / "history")
+    
+    # Determine which conversation to summarize
+    if latest:
+        conv = conv_history.get_latest_conversation()
+        if not conv:
+            console.print("[red]No conversations found[/red]")
+            sys.exit(1)
+        conversation_id = conv.conversation_id
+    elif not conversation_id:
+        console.print("[red]Error: Provide conversation_id or use --latest[/red]")
+        console.print("\nUsage: cdc history summarize CONVERSATION_ID")
+        console.print("   or: cdc history summarize --latest")
+        sys.exit(1)
+    
+    # Load conversation to show stats
+    conv = conv_history.load_conversation(conversation_id)
+    if not conv:
+        console.print(f"[red]Conversation {conversation_id} not found[/red]")
+        sys.exit(1)
+    
+    # Show before stats
+    tokens_before = conv.estimate_tokens()
+    messages_before = len(conv.messages)
+    console.print(f"\n[cyan]Conversation:[/cyan] {conversation_id}")
+    console.print(f"[dim]Messages: {messages_before} | Estimated tokens: {tokens_before:,}[/dim]\n")
+    
+    if messages_before <= keep_recent:
+        console.print(f"[yellow]Too few messages to summarize ({messages_before} <= {keep_recent})[/yellow]")
+        return
+    
+    # Summarize
+    with console.status("[bold blue]Generating summary..."):
+        summary = conv_history.summarize_conversation(conversation_id, keep_recent)
+    
+    if not summary:
+        console.print("[red]Failed to generate summary[/red]")
+        sys.exit(1)
+    
+    # Reload and show after stats
+    conv = conv_history.load_conversation(conversation_id)
+    if conv:
+        tokens_after = conv.estimate_tokens()
+        messages_after = len(conv.messages)
+        
+        token_savings = tokens_before - tokens_after
+        savings_percent = (token_savings / tokens_before * 100) if tokens_before > 0 else 0
+        
+        console.print("[green]✓ Conversation summarized[/green]\n")
+        console.print(f"[dim]Messages:[/dim] {messages_before} → {messages_after}")
+        console.print(f"[dim]Tokens:[/dim] {tokens_before:,} → {tokens_after:,} ({token_savings:,} saved, {savings_percent:.1f}%)\n")
+        console.print("[bold]Summary:[/bold]")
+        console.print(Panel(summary, border_style="blue"))
+
+
+@history.command('delete')
+@click.argument('conversation_id')
+@click.pass_context
+def history_delete(ctx: click.Context, conversation_id: str) -> None:
+    """Delete a conversation."""
+    console = ctx.obj['console']
+    config = Config()
+    conv_history = ConversationHistory(config.config_dir / "history")
+    
+    if conv_history.delete_conversation(conversation_id):
+        console.print(f"[green]✓[/green] Deleted conversation: {conversation_id}")
+    else:
+        console.print(f"[red]Conversation {conversation_id} not found[/red]")
+        sys.exit(1)
+
+
 @main.group()
 def config() -> None:
     """Manage configuration."""

{claude_dev_cli-0.8.2 → claude_dev_cli-0.8.4}/src/claude_dev_cli/config.py

@@ -21,6 +21,15 @@ class ContextConfig(BaseModel):
     include_tests: bool = True  # Include test files by default
 
 
+class SummarizationConfig(BaseModel):
+    """Conversation summarization configuration."""
+    
+    auto_summarize: bool = True  # Enable automatic summarization
+    threshold_tokens: int = 8000  # Token threshold for auto-summarization
+    keep_recent_messages: int = 4  # Number of recent message pairs to keep
+    summary_max_words: int = 300  # Maximum words in generated summary
+
+
 class APIConfig(BaseModel):
     """Configuration for a Claude API key."""
     
@@ -75,6 +84,13 @@ class Config:
     
     def _ensure_config_dir(self) -> None:
         """Ensure configuration directory exists."""
+        # Check if config_dir exists as a file (not directory)
+        if self.config_dir.exists() and not self.config_dir.is_dir():
+            raise RuntimeError(
+                f"Configuration path {self.config_dir} exists but is not a directory. "
+                f"Please remove or rename this file."
+            )
+        
         self.config_dir.mkdir(parents=True, exist_ok=True)
         self.usage_log.touch(exist_ok=True)
     
@@ -87,12 +103,33 @@ class Config:
                 "default_model": "claude-3-5-sonnet-20241022",
                 "max_tokens": 4096,
                 "context": ContextConfig().model_dump(),
+                "summarization": SummarizationConfig().model_dump(),
             }
             self._save_config(default_config)
             return default_config
         
-        with open(self.config_file, 'r') as f:
-            return json.load(f)
+        # Check if config_file is actually a directory
+        if self.config_file.is_dir():
+            raise RuntimeError(
+                f"Configuration file {self.config_file} is a directory. "
+                f"Please remove this directory."
+            )
+        
+        try:
+            with open(self.config_file, 'r') as f:
+                config = json.load(f)
+                
+                # Ensure required keys exist (for backwards compatibility)
+                if "context" not in config:
+                    config["context"] = ContextConfig().model_dump()
+                if "summarization" not in config:
+                    config["summarization"] = SummarizationConfig().model_dump()
+                
+                return config
+        except (json.JSONDecodeError, IOError) as e:
+            raise RuntimeError(
+                f"Failed to load configuration from {self.config_file}: {e}"
+            )
     
     def _save_config(self, data: Optional[Dict] = None) -> None:
         """Save configuration to file."""
@@ -263,3 +300,8 @@ class Config:
         """Get context gathering configuration."""
         context_data = self._data.get("context", {})
         return ContextConfig(**context_data) if context_data else ContextConfig()
+    
+    def get_summarization_config(self) -> SummarizationConfig:
+        """Get conversation summarization configuration."""
+        summ_data = self._data.get("summarization", {})
+        return SummarizationConfig(**summ_data) if summ_data else SummarizationConfig()

{claude_dev_cli-0.8.2 → claude_dev_cli-0.8.4}/src/claude_dev_cli/history.py

@@ -39,11 +39,13 @@ class Conversation:
         self,
         conversation_id: Optional[str] = None,
         created_at: Optional[datetime] = None,
-        updated_at: Optional[datetime] = None
+        updated_at: Optional[datetime] = None,
+        summary: Optional[str] = None
     ):
-        self.conversation_id = conversation_id or datetime.utcnow().strftime("%Y%m%d_%H%M%S")
+        self.conversation_id = conversation_id or datetime.utcnow().strftime("%Y%m%d_%H%M%S_%f")
         self.created_at = created_at or datetime.utcnow()
         self.updated_at = updated_at or datetime.utcnow()
+        self.summary = summary  # AI-generated summary of older messages
         self.messages: List[Message] = []
     
     def add_message(self, role: str, content: str) -> None:
@@ -62,14 +64,37 @@ class Conversation:
                 return summary
         return "(empty conversation)"
     
+    def estimate_tokens(self) -> int:
+        """Estimate token count for the conversation."""
+        # Rough estimation: ~4 characters per token
+        total_chars = len(self.summary or "")
+        for msg in self.messages:
+            total_chars += len(msg.content)
+        return total_chars // 4
+    
+    def should_summarize(self, threshold_tokens: int = 8000) -> bool:
+        """Check if conversation should be summarized."""
+        return self.estimate_tokens() > threshold_tokens and len(self.messages) > 4
+    
+    def compress_messages(self, keep_recent: int = 4) -> tuple[List[Message], List[Message]]:
+        """Split messages into old (to summarize) and recent (to keep)."""
+        if len(self.messages) <= keep_recent:
+            return [], self.messages
+        
+        split_point = len(self.messages) - keep_recent
+        return self.messages[:split_point], self.messages[split_point:]
+    
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dictionary for storage."""
-        return {
+        data = {
             "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]
         }
+        if self.summary:
+            data["summary"] = self.summary
+        return data
     
     @classmethod
     def from_dict(cls, data: Dict[str, Any]) -> "Conversation":
@@ -77,7 +102,8 @@ class Conversation:
         conv = cls(
             conversation_id=data["conversation_id"],
             created_at=datetime.fromisoformat(data["created_at"]),
-            updated_at=datetime.fromisoformat(data["updated_at"])
+            updated_at=datetime.fromisoformat(data["updated_at"]),
+            summary=data.get("summary")
         )
         conv.messages = [Message.from_dict(msg) for msg in data.get("messages", [])]
         return conv
@@ -187,3 +213,63 @@ class ConversationHistory:
             return json.dumps(conv.to_dict(), indent=2)
         
         return None
+    
+    def summarize_conversation(
+        self,
+        conversation_id: str,
+        keep_recent: int = 4
+    ) -> Optional[str]:
+        """Summarize older messages in a conversation, keeping recent ones.
+        
+        Args:
+            conversation_id: The conversation to summarize
+            keep_recent: Number of recent message pairs to keep unsummarized
+            
+        Returns:
+            The generated summary or None if conversation not found
+        """
+        from claude_dev_cli.core import ClaudeClient
+        
+        conv = self.load_conversation(conversation_id)
+        if not conv:
+            return None
+        
+        # Split messages
+        old_messages, recent_messages = conv.compress_messages(keep_recent)
+        
+        if not old_messages:
+            return "No messages to summarize (too few messages)"
+        
+        # Build summary prompt
+        conversation_text = []
+        if conv.summary:
+            conversation_text.append(f"Previous summary:\n{conv.summary}\n\n")
+        
+        conversation_text.append("Conversation to summarize:\n")
+        for msg in old_messages:
+            role_name = "User" if msg.role == "user" else "Assistant"
+            conversation_text.append(f"{role_name}: {msg.content}\n")
+        
+        prompt = (
+            "Please provide a concise summary of this conversation that captures:"
+            "\n1. Main topics discussed"
+            "\n2. Key questions asked and answers provided"
+            "\n3. Important decisions or conclusions"
+            "\n4. Any action items or follow-ups mentioned"
+            "\n\nKeep the summary under 300 words but retain all important context."
+            "\n\n" + "".join(conversation_text)
+        )
+        
+        # Get summary from Claude
+        client = ClaudeClient()
+        new_summary = client.call(prompt)
+        
+        # Update conversation
+        conv.summary = new_summary
+        conv.messages = recent_messages
+        conv.updated_at = datetime.utcnow()
+        
+        # Save updated conversation
+        self.save_conversation(conv)
+        
+        return new_summary

{claude_dev_cli-0.8.2 → claude_dev_cli-0.8.4/src/claude_dev_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-dev-cli
-Version: 0.8.2
+Version: 0.8.4
 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
@@ -44,6 +44,13 @@ Dynamic: license-file
 
 # Claude Dev CLI
 
+[![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-257%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)
+
 A powerful command-line tool for developers using Claude AI with multi-API routing, test generation, code review, and comprehensive usage tracking.
 
 ## Features
@@ -99,19 +106,39 @@ A powerful command-line tool for developers using Claude AI with multi-API routi
 
 ## Installation
 
-### Basic Installation
+### Via Homebrew (macOS/Linux)
 
 ```bash
-pip install claude-dev-cli
+# Add the tap
+brew tap thinmanj/tap
+
+# Install
+brew install claude-dev-cli
+
+# Or in one command
+brew install thinmanj/tap/claude-dev-cli
 ```
 
-### With TOON Support (Recommended for Cost Savings)
+### Via pip
 
 ```bash
-# Install with TOON format support for 30-60% token reduction
+# Basic installation
+pip install claude-dev-cli
+
+# With TOON support (30-60% token reduction)
 pip install claude-dev-cli[toon]
 ```
 
+### Via pipx (Recommended for CLI tools)
+
+```bash
+# Isolated installation
+pipx install claude-dev-cli
+
+# With TOON support
+pipx install claude-dev-cli[toon]
+```
+
 ## Quick Start
 
 ### 1. Set Up API Keys
@@ -266,7 +293,33 @@ cdc template list --user
 - **explain-code**: Detailed code explanation
 - **api-design**: API design assistance
 
-### 6. Usage Tracking
+### 6. Conversation History & Summarization (NEW in v0.8.3)
+
+```bash
+# List recent conversations
+cdc history list
+
+# Search conversations
+cdc history list --search "python decorators"
+
+# Export conversation
+cdc history export 20240109_143022 -o chat.md
+
+# Summarize to reduce token usage
+cdc history summarize --latest
+cdc history summarize 20240109_143022 --keep-recent 6
+
+# Delete old conversations
+cdc history delete 20240109_143022
+```
+
+**Auto-Summarization** in interactive mode:
+- Automatically triggers when conversation exceeds 8,000 tokens
+- Keeps recent messages (default: 4 pairs), summarizes older ones
+- Reduces API costs by ~30-50% in long conversations
+- Shows token savings after summarization
+
+### 7. Usage Tracking
 
 ```bash
 # View all usage

{claude_dev_cli-0.8.2 → claude_dev_cli-0.8.4}/src/claude_dev_cli.egg-info/SOURCES.txt

@@ -33,6 +33,7 @@ tests/test_config.py
 tests/test_context.py
 tests/test_core.py
 tests/test_diff_editor.py
+tests/test_history.py
 tests/test_secure_storage.py
 tests/test_template_manager.py
 tests/test_toon_utils.py

{claude_dev_cli-0.8.2 → claude_dev_cli-0.8.4}/tests/test_config.py

@@ -70,6 +70,28 @@ class TestConfig:
         assert config.config_dir.exists()
         assert config.usage_log.exists()
     
+    def test_config_dir_as_file_raises(self, temp_home: Path) -> None:
+        """Test that having config path as file raises error."""
+        # Create config path as a file instead of directory
+        config_path = temp_home / ".claude-dev-cli"
+        config_path.write_text("invalid file")
+        
+        with pytest.raises(RuntimeError, match="exists but is not a directory"):
+            Config()
+    
+    def test_config_file_as_dir_raises(self, temp_home: Path) -> None:
+        """Test that having config.json as directory raises error."""
+        # Create config directory
+        config_dir = temp_home / ".claude-dev-cli"
+        config_dir.mkdir(parents=True, exist_ok=True)
+        
+        # Create config.json as a directory
+        config_file = config_dir / "config.json"
+        config_file.mkdir()
+        
+        with pytest.raises(RuntimeError, match="is a directory"):
+            Config()
+    
     def test_init_creates_default_config(self, temp_home: Path) -> None:
         """Test that Config.__init__ creates default config file."""
         config = Config()

claude_dev_cli-0.8.4/tests/test_history.py

@@ -0,0 +1,488 @@
+"""Tests for conversation history and summarization."""
+
+import json
+import pytest
+from datetime import datetime
+from pathlib import Path
+from unittest.mock import Mock, patch, MagicMock
+
+from claude_dev_cli.history import Message, Conversation, ConversationHistory
+
+
+class TestMessage:
+    """Tests for Message class."""
+    
+    def test_message_creation(self):
+        """Test creating a message."""
+        msg = Message("user", "Hello, Claude!")
+        assert msg.role == "user"
+        assert msg.content == "Hello, Claude!"
+        assert isinstance(msg.timestamp, datetime)
+    
+    def test_message_to_dict(self):
+        """Test converting message to dictionary."""
+        msg = Message("assistant", "Hello! How can I help?")
+        data = msg.to_dict()
+        
+        assert data["role"] == "assistant"
+        assert data["content"] == "Hello! How can I help?"
+        assert "timestamp" in data
+    
+    def test_message_from_dict(self):
+        """Test creating message from dictionary."""
+        data = {
+            "role": "user",
+            "content": "Test message",
+            "timestamp": "2024-01-09T12:00:00"
+        }
+        msg = Message.from_dict(data)
+        
+        assert msg.role == "user"
+        assert msg.content == "Test message"
+        assert isinstance(msg.timestamp, datetime)
+
+
+class TestConversation:
+    """Tests for Conversation class."""
+    
+    def test_conversation_creation(self):
+        """Test creating a conversation."""
+        conv = Conversation()
+        assert conv.conversation_id is not None
+        assert isinstance(conv.created_at, datetime)
+        assert isinstance(conv.updated_at, datetime)
+        assert len(conv.messages) == 0
+        assert conv.summary is None
+    
+    def test_conversation_with_summary(self):
+        """Test creating conversation with summary."""
+        summary = "This is a test summary"
+        conv = Conversation(summary=summary)
+        assert conv.summary == summary
+    
+    def test_add_message(self):
+        """Test adding messages to conversation."""
+        conv = Conversation()
+        conv.add_message("user", "First message")
+        conv.add_message("assistant", "First response")
+        
+        assert len(conv.messages) == 2
+        assert conv.messages[0].role == "user"
+        assert conv.messages[0].content == "First message"
+        assert conv.messages[1].role == "assistant"
+    
+    def test_get_summary_with_messages(self):
+        """Test getting conversation summary."""
+        conv = Conversation()
+        conv.add_message("user", "What is Python?")
+        conv.add_message("assistant", "Python is a programming language...")
+        
+        summary = conv.get_summary(20)
+        assert summary == "What is Python?"
+    
+    def test_get_summary_truncated(self):
+        """Test summary truncation."""
+        conv = Conversation()
+        long_message = "a" * 150
+        conv.add_message("user", long_message)
+        
+        summary = conv.get_summary(100)
+        assert len(summary) <= 103  # 100 + "..."
+        assert summary.endswith("...")
+    
+    def test_get_summary_empty(self):
+        """Test summary of empty conversation."""
+        conv = Conversation()
+        summary = conv.get_summary()
+        assert summary == "(empty conversation)"
+    
+    def test_estimate_tokens_no_messages(self):
+        """Test token estimation for empty conversation."""
+        conv = Conversation()
+        tokens = conv.estimate_tokens()
+        assert tokens == 0
+    
+    def test_estimate_tokens_with_messages(self):
+        """Test token estimation with messages."""
+        conv = Conversation()
+        # Each character ~= 0.25 tokens, so 400 chars ~= 100 tokens
+        conv.add_message("user", "a" * 200)
+        conv.add_message("assistant", "b" * 200)
+        
+        tokens = conv.estimate_tokens()
+        assert tokens == 100  # 400 chars / 4
+    
+    def test_estimate_tokens_with_summary(self):
+        """Test token estimation includes summary."""
+        conv = Conversation(summary="Summary text here" * 10)  # 170 chars
+        conv.add_message("user", "a" * 230)  # 230 chars
+        
+        # Total: 400 chars / 4 = 100 tokens
+        tokens = conv.estimate_tokens()
+        assert tokens == 100
+    
+    def test_should_summarize_below_threshold(self):
+        """Test should_summarize returns False below threshold."""
+        conv = Conversation()
+        conv.add_message("user", "a" * 100)
+        conv.add_message("assistant", "b" * 100)
+        
+        # 200 chars = 50 tokens, below 8000 threshold
+        assert not conv.should_summarize(threshold_tokens=8000)
+    
+    def test_should_summarize_above_threshold(self):
+        """Test should_summarize returns True above threshold."""
+        conv = Conversation()
+        # Add enough messages to exceed 1000 token threshold
+        for i in range(10):
+            conv.add_message("user", "a" * 200)  # 200 chars = 50 tokens
+            conv.add_message("assistant", "b" * 200)  # 200 chars = 50 tokens
+        
+        # Total: 2000 chars = 500 tokens, above 400 threshold
+        assert conv.should_summarize(threshold_tokens=400)
+    
+    def test_should_summarize_too_few_messages(self):
+        """Test should_summarize returns False with too few messages."""
+        conv = Conversation()
+        # Even with many tokens, need minimum message count
+        conv.add_message("user", "a" * 4000)  # 1000 tokens
+        
+        assert not conv.should_summarize(threshold_tokens=500)
+    
+    def test_compress_messages_few_messages(self):
+        """Test compress_messages with too few messages."""
+        conv = Conversation()
+        conv.add_message("user", "message 1")
+        conv.add_message("assistant", "response 1")
+        
+        old, recent = conv.compress_messages(keep_recent=4)
+        assert len(old) == 0
+        assert len(recent) == 2
+    
+    def test_compress_messages_split(self):
+        """Test compress_messages splits correctly."""
+        conv = Conversation()
+        for i in range(10):
+            conv.add_message("user", f"message {i}")
+            conv.add_message("assistant", f"response {i}")
+        
+        # Total: 20 messages, keep 4 recent
+        old, recent = conv.compress_messages(keep_recent=4)
+        assert len(old) == 16
+        assert len(recent) == 4
+        assert recent[0].content == "message 8"
+        assert recent[-1].content == "response 9"
+    
+    def test_to_dict(self):
+        """Test converting conversation to dictionary."""
+        conv = Conversation()
+        conv.add_message("user", "test")
+        data = conv.to_dict()
+        
+        assert "conversation_id" in data
+        assert "created_at" in data
+        assert "updated_at" in data
+        assert "messages" in data
+        assert len(data["messages"]) == 1
+    
+    def test_to_dict_with_summary(self):
+        """Test to_dict includes summary."""
+        conv = Conversation(summary="Test summary")
+        data = conv.to_dict()
+        
+        assert data["summary"] == "Test summary"
+    
+    def test_from_dict(self):
+        """Test creating conversation from dictionary."""
+        data = {
+            "conversation_id": "test_123",
+            "created_at": "2024-01-09T12:00:00",
+            "updated_at": "2024-01-09T12:05:00",
+            "summary": "Test summary",
+            "messages": [
+                {
+                    "role": "user",
+                    "content": "Hello",
+                    "timestamp": "2024-01-09T12:01:00"
+                }
+            ]
+        }
+        
+        conv = Conversation.from_dict(data)
+        assert conv.conversation_id == "test_123"
+        assert conv.summary == "Test summary"
+        assert len(conv.messages) == 1
+        assert conv.messages[0].content == "Hello"
+
+
+class TestConversationHistory:
+    """Tests for ConversationHistory class."""
+    
+    @pytest.fixture
+    def temp_history_dir(self, tmp_path):
+        """Create a temporary history directory."""
+        return tmp_path / "history"
+    
+    @pytest.fixture
+    def conv_history(self, temp_history_dir):
+        """Create a ConversationHistory instance."""
+        return ConversationHistory(temp_history_dir)
+    
+    def test_init_creates_directory(self, temp_history_dir):
+        """Test initialization creates directory."""
+        ConversationHistory(temp_history_dir)
+        assert temp_history_dir.exists()
+    
+    def test_save_conversation(self, conv_history, temp_history_dir):
+        """Test saving a conversation."""
+        conv = Conversation()
+        conv.add_message("user", "test")
+        
+        conv_history.save_conversation(conv)
+        
+        # Check file exists
+        file_path = temp_history_dir / f"{conv.conversation_id}.json"
+        assert file_path.exists()
+        
+        # Check content
+        with open(file_path) as f:
+            data = json.load(f)
+        assert data["conversation_id"] == conv.conversation_id
+        assert len(data["messages"]) == 1
+    
+    def test_load_conversation(self, conv_history):
+        """Test loading a conversation."""
+        # Save first
+        conv = Conversation()
+        conv.add_message("user", "test message")
+        conv_history.save_conversation(conv)
+        
+        # Load
+        loaded = conv_history.load_conversation(conv.conversation_id)
+        assert loaded is not None
+        assert loaded.conversation_id == conv.conversation_id
+        assert len(loaded.messages) == 1
+        assert loaded.messages[0].content == "test message"
+    
+    def test_load_nonexistent_conversation(self, conv_history):
+        """Test loading a conversation that doesn't exist."""
+        loaded = conv_history.load_conversation("nonexistent_id")
+        assert loaded is None
+    
+    def test_list_conversations(self, conv_history):
+        """Test listing conversations."""
+        import time
+        # Create multiple conversations with small delays to ensure ordering
+        for i in range(3):
+            conv = Conversation()
+            conv.add_message("user", f"message {i}")
+            conv_history.save_conversation(conv)
+            time.sleep(0.01)  # Small delay to ensure different timestamps
+        
+        conversations = conv_history.list_conversations()
+        assert len(conversations) == 3
+    
+    def test_list_conversations_with_limit(self, conv_history):
+        """Test listing conversations with limit."""
+        import time
+        for i in range(5):
+            conv = Conversation()
+            conv.add_message("user", f"message {i}")
+            conv_history.save_conversation(conv)
+            time.sleep(0.01)
+        
+        conversations = conv_history.list_conversations(limit=2)
+        assert len(conversations) == 2
+    
+    def test_list_conversations_with_search(self, conv_history):
+        """Test searching conversations."""
+        import time
+        conv1 = Conversation()
+        conv1.add_message("user", "Python programming")
+        conv_history.save_conversation(conv1)
+        time.sleep(0.01)
+        
+        conv2 = Conversation()
+        conv2.add_message("user", "JavaScript coding")
+        conv_history.save_conversation(conv2)
+        
+        # Search for Python
+        results = conv_history.list_conversations(search_query="Python")
+        assert len(results) == 1
+        assert "Python" in results[0].messages[0].content
+    
+    def test_delete_conversation(self, conv_history, temp_history_dir):
+        """Test deleting a conversation."""
+        conv = Conversation()
+        conv_history.save_conversation(conv)
+        
+        # Verify it exists
+        file_path = temp_history_dir / f"{conv.conversation_id}.json"
+        assert file_path.exists()
+        
+        # Delete
+        result = conv_history.delete_conversation(conv.conversation_id)
+        assert result is True
+        assert not file_path.exists()
+    
+    def test_delete_nonexistent_conversation(self, conv_history):
+        """Test deleting a conversation that doesn't exist."""
+        result = conv_history.delete_conversation("nonexistent")
+        assert result is False
+    
+    def test_get_latest_conversation(self, conv_history):
+        """Test getting the latest conversation."""
+        # Create conversations with delay to ensure ordering
+        conv1 = Conversation()
+        conv1.add_message("user", "first")
+        conv_history.save_conversation(conv1)
+        
+        import time
+        time.sleep(0.01)  # Small delay
+        
+        conv2 = Conversation()
+        conv2.add_message("user", "second")
+        conv_history.save_conversation(conv2)
+        
+        latest = conv_history.get_latest_conversation()
+        assert latest is not None
+        assert latest.messages[0].content == "second"
+    
+    def test_export_conversation_markdown(self, conv_history):
+        """Test exporting conversation as markdown."""
+        conv = Conversation()
+        conv.add_message("user", "Hello")
+        conv.add_message("assistant", "Hi there!")
+        conv_history.save_conversation(conv)
+        
+        markdown = conv_history.export_conversation(conv.conversation_id, "markdown")
+        assert markdown is not None
+        assert "Hello" in markdown
+        assert "Hi there!" in markdown
+        assert "**You:**" in markdown
+        assert "**Claude:**" in markdown
+    
+    def test_export_conversation_json(self, conv_history):
+        """Test exporting conversation as JSON."""
+        conv = Conversation()
+        conv.add_message("user", "Test")
+        conv_history.save_conversation(conv)
+        
+        json_str = conv_history.export_conversation(conv.conversation_id, "json")
+        assert json_str is not None
+        
+        data = json.loads(json_str)
+        assert data["conversation_id"] == conv.conversation_id
+    
+    def test_export_nonexistent_conversation(self, conv_history):
+        """Test exporting a conversation that doesn't exist."""
+        result = conv_history.export_conversation("nonexistent", "markdown")
+        assert result is None
+    
+    @patch('claude_dev_cli.core.ClaudeClient')
+    def test_summarize_conversation(self, mock_client_class, conv_history):
+        """Test summarizing a conversation."""
+        # Setup mock
+        mock_client = Mock()
+        mock_client.call.return_value = "This is a test summary of the conversation."
+        mock_client_class.return_value = mock_client
+        
+        # Create conversation with enough messages
+        conv = Conversation()
+        for i in range(6):
+            conv.add_message("user", f"Question {i}")
+            conv.add_message("assistant", f"Answer {i}")
+        conv_history.save_conversation(conv)
+        
+        # Summarize
+        summary = conv_history.summarize_conversation(conv.conversation_id, keep_recent=4)
+        
+        assert summary is not None
+        assert "test summary" in summary
+        
+        # Verify conversation was updated
+        updated_conv = conv_history.load_conversation(conv.conversation_id)
+        assert updated_conv.summary == summary
+        assert len(updated_conv.messages) == 4  # Only recent messages kept
+    
+    @patch('claude_dev_cli.core.ClaudeClient')
+    def test_summarize_with_previous_summary(self, mock_client_class, conv_history):
+        """Test summarizing with existing summary."""
+        mock_client = Mock()
+        mock_client.call.return_value = "Updated summary"
+        mock_client_class.return_value = mock_client
+        
+        # Create conversation with existing summary
+        conv = Conversation(summary="Previous summary")
+        for i in range(6):
+            conv.add_message("user", f"Message {i}")
+            conv.add_message("assistant", f"Response {i}")
+        conv_history.save_conversation(conv)
+        
+        # Summarize
+        summary = conv_history.summarize_conversation(conv.conversation_id, keep_recent=2)
+        
+        # Check that call included previous summary
+        call_args = mock_client.call.call_args[0][0]
+        assert "Previous summary" in call_args
+    
+    def test_summarize_too_few_messages(self, conv_history):
+        """Test summarizing with too few messages."""
+        conv = Conversation()
+        conv.add_message("user", "Only one message")
+        conv_history.save_conversation(conv)
+        
+        result = conv_history.summarize_conversation(conv.conversation_id, keep_recent=4)
+        assert "too few messages" in result.lower()
+    
+    def test_summarize_nonexistent_conversation(self, conv_history):
+        """Test summarizing a conversation that doesn't exist."""
+        result = conv_history.summarize_conversation("nonexistent")
+        assert result is None
+
+
+class TestConversationPersistence:
+    """Tests for conversation persistence and data integrity."""
+    
+    def test_roundtrip_conversation(self, tmp_path):
+        """Test saving and loading preserves all data."""
+        history = ConversationHistory(tmp_path)
+        
+        # Create conversation with all features
+        conv = Conversation(summary="Initial summary")
+        conv.add_message("user", "First question")
+        conv.add_message("assistant", "First answer")
+        conv.add_message("user", "Second question")
+        
+        # Save
+        history.save_conversation(conv)
+        
+        # Load
+        loaded = history.load_conversation(conv.conversation_id)
+        
+        # Verify everything matches
+        assert loaded.conversation_id == conv.conversation_id
+        assert loaded.summary == conv.summary
+        assert len(loaded.messages) == len(conv.messages)
+        assert loaded.messages[0].content == conv.messages[0].content
+        assert loaded.messages[1].role == conv.messages[1].role
+    
+    def test_conversation_update(self, tmp_path):
+        """Test updating a conversation."""
+        history = ConversationHistory(tmp_path)
+        
+        # Create and save
+        conv = Conversation()
+        conv.add_message("user", "Original message")
+        history.save_conversation(conv)
+        
+        # Load, modify, save
+        loaded = history.load_conversation(conv.conversation_id)
+        loaded.add_message("assistant", "New response")
+        loaded.summary = "Added summary"
+        history.save_conversation(loaded)
+        
+        # Load again and verify
+        final = history.load_conversation(conv.conversation_id)
+        assert len(final.messages) == 2
+        assert final.summary == "Added summary"