claude-dev-cli 0.8.1__py3-none-any.whl → 0.8.3__py3-none-any.whl

claude_dev_cli/__init__.py

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

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."""
@@ -884,6 +1015,107 @@ def git_commit(ctx: click.Context, api: Optional[str], auto_context: bool) -> No
         sys.exit(1)
 
 
+@main.group()
+def context() -> None:
+    """Context gathering tools and information."""
+    pass
+
+
+@context.command('summary')
+@click.argument('file_path', type=click.Path(exists=True))
+@click.option('--include-git/--no-git', default=True, help='Include git context')
+@click.option('--include-deps/--no-deps', default=True, help='Include dependencies')
+@click.option('--include-tests/--no-tests', default=True, help='Include test files')
+@click.pass_context
+def context_summary(
+    ctx: click.Context,
+    file_path: str,
+    include_git: bool,
+    include_deps: bool,
+    include_tests: bool
+) -> None:
+    """Show what context would be gathered for a file."""
+    from claude_dev_cli.context import ContextGatherer
+    from rich.table import Table
+    
+    console = ctx.obj['console']
+    
+    try:
+        file_path_obj = Path(file_path)
+        gatherer = ContextGatherer()
+        
+        # Gather context
+        with console.status("[bold blue]Analyzing context..."):
+            context = gatherer.gather_for_review(
+                file_path_obj,
+                include_git=include_git,
+                include_tests=include_tests
+            )
+        
+        # Display summary
+        console.print(f"\n[bold cyan]Context Summary for:[/bold cyan] {file_path}\n")
+        
+        table = Table(show_header=True, header_style="bold magenta")
+        table.add_column("Type", style="cyan")
+        table.add_column("Content", style="white")
+        table.add_column("Size", justify="right", style="yellow")
+        table.add_column("Lines", justify="right", style="green")
+        table.add_column("Truncated", justify="center", style="red")
+        
+        total_chars = 0
+        total_lines = 0
+        
+        for item in context.items:
+            lines = len(item.content.split('\n'))
+            chars = len(item.content)
+            truncated = "✓" if item.metadata.get('truncated') else ""
+            
+            # Format content preview
+            if item.type == 'file':
+                content = item.metadata.get('path', 'unknown')
+                if item.metadata.get('is_test'):
+                    content += " [TEST]"
+            elif item.type == 'git':
+                branch = item.metadata.get('branch', 'unknown')
+                modified = item.metadata.get('modified_count', 0)
+                content = f"Branch: {branch}, {modified} modified files"
+            elif item.type == 'dependency':
+                dep_files = item.metadata.get('dependency_files', [])
+                content = f"{len(dep_files)} dependency files"
+            else:
+                content = item.type
+            
+            table.add_row(
+                item.type.title(),
+                content[:60] + "..." if len(content) > 60 else content,
+                f"{chars:,}",
+                f"{lines:,}",
+                truncated
+            )
+            
+            total_chars += chars
+            total_lines += lines
+        
+        console.print(table)
+        
+        # Show totals
+        console.print(f"\n[bold]Total:[/bold]")
+        console.print(f"  Characters: [yellow]{total_chars:,}[/yellow]")
+        console.print(f"  Lines: [green]{total_lines:,}[/green]")
+        console.print(f"  Estimated tokens: [cyan]~{total_chars // 4:,}[/cyan] (rough estimate)")
+        
+        # Show any truncation warnings
+        truncated_items = [item for item in context.items if item.metadata.get('truncated')]
+        if truncated_items:
+            console.print(f"\n[yellow]⚠ {len(truncated_items)} item(s) truncated to fit size limits[/yellow]")
+        
+        console.print(f"\n[dim]Use --auto-context with commands to include this context[/dim]")
+    
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+        sys.exit(1)
+
+
 @main.command('usage')
 @click.option('--days', type=int, help='Filter by days')
 @click.option('--api', help='Filter by API config')

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."""
     
@@ -87,6 +96,7 @@ 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
@@ -263,3 +273,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/context.py

@@ -339,10 +339,25 @@ class DependencyAnalyzer:
 
 
 class ErrorContext:
-    """Parse and format error context."""
+    """Parse and format error context for multiple languages."""
     
     @staticmethod
-    def parse_traceback(error_text: str) -> Dict[str, Any]:
+    def detect_language(error_text: str) -> str:
+        """Detect programming language from error format."""
+        if 'Traceback (most recent call last):' in error_text or 'File "' in error_text:
+            return 'python'
+        elif 'at ' in error_text and ('.js:' in error_text or '.ts:' in error_text):
+            return 'javascript'
+        elif 'panic:' in error_text and '.go:' in error_text:
+            return 'go'
+        elif 'thread' in error_text and 'panicked at' in error_text and '.rs:' in error_text:
+            return 'rust'
+        elif 'at ' in error_text and '.java:' in error_text:
+            return 'java'
+        return 'unknown'
+    
+    @staticmethod
+    def parse_python_traceback(error_text: str) -> Dict[str, Any]:
         """Parse Python traceback into structured data."""
         lines = error_text.split('\n')
         
@@ -391,24 +406,183 @@ class ErrorContext:
                     'raw': error_text
                 }
         
-        return {'frames': frames, 'raw': error_text}
+        return {'frames': frames, 'raw': error_text, 'language': 'python'}
+    
+    @staticmethod
+    def parse_javascript_stack(error_text: str) -> Dict[str, Any]:
+        """Parse JavaScript/TypeScript stack trace."""
+        lines = error_text.split('\n')
+        frames = []
+        error_type = None
+        error_message = None
+        
+        for line in lines:
+            # Error message usually first: "Error: message" or "TypeError: message"
+            if not error_type and (':' in line and not line.strip().startswith('at')):
+                parts = line.split(':', 1)
+                error_type = parts[0].strip()
+                error_message = parts[1].strip() if len(parts) > 1 else ''
+            # Stack frame: "at functionName (file.js:line:col)" or "at file.js:line:col"
+            elif line.strip().startswith('at '):
+                match = re.search(r'at\s+(?:(.+?)\s+)?\(([^)]+)\)|(\S+)$', line)
+                if match:
+                    function = match.group(1) or 'anonymous'
+                    location = match.group(2) or match.group(3)
+                    if location and ':' in location:
+                        parts = location.rsplit(':', 2)
+                        frames.append({
+                            'file': parts[0],
+                            'line': int(parts[1]) if len(parts) > 1 and parts[1].isdigit() else None,
+                            'column': int(parts[2]) if len(parts) > 2 and parts[2].isdigit() else None,
+                            'function': function
+                        })
+        
+        return {
+            'frames': frames,
+            'error_type': error_type,
+            'error_message': error_message,
+            'raw': error_text,
+            'language': 'javascript'
+        }
+    
+    @staticmethod
+    def parse_go_panic(error_text: str) -> Dict[str, Any]:
+        """Parse Go panic trace."""
+        lines = error_text.split('\n')
+        frames = []
+        error_message = None
+        
+        for line in lines:
+            # Panic message: "panic: message"
+            if line.startswith('panic:'):
+                error_message = line.replace('panic:', '').strip()
+            # Stack frame: "function(args)" followed by "\tfile.go:line +0xhex"
+            elif '\t' in line and '.go:' in line:
+                match = re.search(r'([^/\s]+\.go):(\d+)', line)
+                if match:
+                    frames.append({
+                        'file': match.group(1),
+                        'line': int(match.group(2)),
+                        'function': 'goroutine'
+                    })
+        
+        return {
+            'frames': frames,
+            'error_type': 'panic',
+            'error_message': error_message,
+            'raw': error_text,
+            'language': 'go'
+        }
+    
+    @staticmethod
+    def parse_rust_panic(error_text: str) -> Dict[str, Any]:
+        """Parse Rust panic message."""
+        lines = error_text.split('\n')
+        frames = []
+        error_message = None
+        
+        for line in lines:
+            # Panic message: "thread 'main' panicked at 'message', file.rs:line:col"
+            if 'panicked at' in line:
+                match = re.search(r"panicked at '([^']+)', ([^:]+):(\d+):(\d+)", line)
+                if match:
+                    error_message = match.group(1)
+                    frames.append({
+                        'file': match.group(2),
+                        'line': int(match.group(3)),
+                        'column': int(match.group(4)),
+                        'function': 'panic'
+                    })
+            # Stack backtrace frames
+            elif '.rs:' in line:
+                match = re.search(r'([^/\s]+\.rs):(\d+):(\d+)', line)
+                if match:
+                    frames.append({
+                        'file': match.group(1),
+                        'line': int(match.group(2)),
+                        'column': int(match.group(3)),
+                        'function': 'unknown'
+                    })
+        
+        return {
+            'frames': frames,
+            'error_type': 'panic',
+            'error_message': error_message,
+            'raw': error_text,
+            'language': 'rust'
+        }
+    
+    @staticmethod
+    def parse_java_stack(error_text: str) -> Dict[str, Any]:
+        """Parse Java stack trace."""
+        lines = error_text.split('\n')
+        frames = []
+        error_type = None
+        error_message = None
+        
+        for line in lines:
+            # Exception message: "java.lang.NullPointerException: message"
+            if not error_type and 'Exception' in line or 'Error' in line:
+                parts = line.split(':', 1)
+                error_type = parts[0].strip().split('.')[-1]  # Get last part of package
+                error_message = parts[1].strip() if len(parts) > 1 else ''
+            # Stack frame: "at package.Class.method(File.java:line)"
+            elif line.strip().startswith('at '):
+                match = re.search(r'at\s+([^(]+)\(([^:]+\.java):(\d+)\)', line)
+                if match:
+                    frames.append({
+                        'function': match.group(1),
+                        'file': match.group(2),
+                        'line': int(match.group(3))
+                    })
+        
+        return {
+            'frames': frames,
+            'error_type': error_type,
+            'error_message': error_message,
+            'raw': error_text,
+            'language': 'java'
+        }
+    
+    @staticmethod
+    def parse_traceback(error_text: str) -> Dict[str, Any]:
+        """Parse error/traceback with language auto-detection."""
+        language = ErrorContext.detect_language(error_text)
+        
+        if language == 'python':
+            return ErrorContext.parse_python_traceback(error_text)
+        elif language == 'javascript':
+            return ErrorContext.parse_javascript_stack(error_text)
+        elif language == 'go':
+            return ErrorContext.parse_go_panic(error_text)
+        elif language == 'rust':
+            return ErrorContext.parse_rust_panic(error_text)
+        elif language == 'java':
+            return ErrorContext.parse_java_stack(error_text)
+        else:
+            return {'raw': error_text, 'language': 'unknown'}
     
     @staticmethod
     def format_for_ai(error_text: str) -> str:
-        """Format error for AI consumption."""
+        """Format error for AI consumption with language detection."""
         parsed = ErrorContext.parse_traceback(error_text)
         
         if 'error_type' not in parsed:
             return error_text
         
+        language = parsed.get('language', 'unknown')
         parts = [
+            f"Language: {language.title()}",
             f"Error Type: {parsed['error_type']}",
             f"Error Message: {parsed.get('error_message', 'N/A')}",
             "\nStack Trace:"
         ]
         
         for i, frame in enumerate(parsed.get('frames', []), 1):
-            parts.append(f"  {i}. {frame.get('file', 'unknown')}:{frame.get('line', '?')} in {frame.get('function', 'unknown')}")
+            file_loc = f"{frame.get('file', 'unknown')}:{frame.get('line', '?')}"
+            if 'column' in frame:
+                file_loc += f":{frame.get('column', '?')}"
+            parts.append(f"  {i}. {file_loc} in {frame.get('function', 'unknown')}")
             if 'code' in frame:
                 parts.append(f"     > {frame['code']}")
         

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.1.dist-info → claude_dev_cli-0.8.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-dev-cli
-Version: 0.8.1
+Version: 0.8.3
 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
@@ -85,7 +92,8 @@ A powerful command-line tool for developers using Claude AI with multi-API routi
   - `git commit`, `generate tests`, `generate docs` (v0.8.1)
 - **Git Integration**: Automatically include branch, commits, modified files
 - **Dependency Analysis**: Parse imports and include related files
-- **Error Parsing**: Structured Python traceback parsing
+- **Multi-Language Error Parsing** (v0.8.2): Python, JavaScript/TypeScript, Go, Rust, Java
+- **Context Summary** (v0.8.2): Preview context before API calls with `cdc context summary`
 - **Smart Truncation**: Prevent token limits with configurable file size limits
 - **Project Memory**: Remember preferences per project
 - **Global Config**: Set context defaults in `~/.claude-dev-cli/config.json`
@@ -98,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
@@ -199,7 +227,7 @@ git add .
 cdc git commit --auto-context
 ```
 
-### 4. Context-Aware Operations (NEW in v0.8.0)
+### 4. Context-Aware Operations (v0.8.0+)
 
 ```bash
 # Auto-context includes: git info, dependencies, related files
@@ -208,9 +236,16 @@ cdc git commit --auto-context
 cdc review mymodule.py --auto-context
 # ✓ Context gathered (git, dependencies, tests)
 
-# Debug with parsed error details
+# Debug with parsed error details (multi-language support)
 python broken.py 2>&1 | cdc debug -f broken.py --auto-context
+node app.js 2>&1 | cdc debug --auto-context  # JavaScript/TypeScript
+go run main.go 2>&1 | cdc debug --auto-context  # Go
 # ✓ Context gathered (error details, git context)
+# Supports: Python, JavaScript, TypeScript, Go, Rust, Java
+
+# Preview context before making API calls - NEW in v0.8.2
+cdc context summary mymodule.py
+# Shows: files, sizes, lines, estimated tokens, truncation warnings
 
 # Ask questions with file context
 cdc ask -f mycode.py --auto-context "how can I improve this?"
@@ -258,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.1.dist-info → claude_dev_cli-0.8.3.dist-info}/RECORD

@@ -1,10 +1,10 @@
-claude_dev_cli/__init__.py,sha256=0g1KP2ohJ45KCYW9EkcRcTA885E4Gqm1kDQbmIOdC-k,469
-claude_dev_cli/cli.py,sha256=FjVq9QanwxM8WqSZPPM4-b50v9Ycy9ZDHEg9gBo-kCk,51304
+claude_dev_cli/__init__.py,sha256=4-FONrbZl8GAHKPOWIDbvA7AmSZsTv8CRep1rwl1w5Y,469
+claude_dev_cli/cli.py,sha256=hy2HjU7oEWgGwNB7apBKFQmzjhYrxhHxTqtJ18iePZE,61164
 claude_dev_cli/commands.py,sha256=RKGx2rv56PM6eErvA2uoQ20hY8babuI5jav8nCUyUOk,3964
-claude_dev_cli/config.py,sha256=OLx0xWDf1RIK6RIxl5OKVS4aOSMZZOKxBDmzfQX-muk,9745
-claude_dev_cli/context.py,sha256=Z3QYq4ZHAqpuv_xPZtXcBeWf0LCelzkybj8cBz2nBAo,19523
+claude_dev_cli/config.py,sha256=hisG91dUfDwuSdBhmYovU-rrGv__nFq-6fp7S288cSw,10471
+claude_dev_cli/context.py,sha256=1TlLzpREFZDEIuU7RAtlkjxARKWZpnxHHvK283sUAZE,26714
 claude_dev_cli/core.py,sha256=yaLjEixDvPzvUy4fJ2UB7nMpPPLyKACjR-RuM-1OQBY,4780
-claude_dev_cli/history.py,sha256=iQlqgTnXCsyCq5q-XaDl7V5MyPKQ3bx7o_k76-xWSAA,6863
+claude_dev_cli/history.py,sha256=v952xORhxZD0ayrrMaIbTLfe6kOW5fYryoeEmQLlQPg,10163
 claude_dev_cli/secure_storage.py,sha256=TK3WOaU7a0yTOtzdP_t_28fDRp2lovANNAC6MBdm4nQ,7096
 claude_dev_cli/template_manager.py,sha256=ZFXOtRIoB6hpf8kLSF9TWJfvUPJt9b-PyEv3qTBK7Zs,8600
 claude_dev_cli/templates.py,sha256=lKxH943ySfUKgyHaWa4W3LVv91SgznKgajRtSRp_4UY,2260
@@ -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.8.1.dist-info/licenses/LICENSE,sha256=DGueuJwMJtMwgLO5mWlS0TaeBrFwQuNpNZ22PU9J2bw,1062
-claude_dev_cli-0.8.1.dist-info/METADATA,sha256=3QFSQUey2f4wMFgtrImtuPgQoD_-Bk2me891eCrCyhY,15223
-claude_dev_cli-0.8.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-claude_dev_cli-0.8.1.dist-info/entry_points.txt,sha256=zymgUIIVpFTARkFmxAuW2A4BQsNITh_L0uU-XunytHg,85
-claude_dev_cli-0.8.1.dist-info/top_level.txt,sha256=m7MF6LOIuTe41IT5Fgt0lc-DK1EgM4gUU_IZwWxK0pg,15
-claude_dev_cli-0.8.1.dist-info/RECORD,,
+claude_dev_cli-0.8.3.dist-info/licenses/LICENSE,sha256=DGueuJwMJtMwgLO5mWlS0TaeBrFwQuNpNZ22PU9J2bw,1062
+claude_dev_cli-0.8.3.dist-info/METADATA,sha256=zgkMO_8g4hwJ7ccfDqGqXM-d3OfghrhxsWt7JK0evgs,17356
+claude_dev_cli-0.8.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+claude_dev_cli-0.8.3.dist-info/entry_points.txt,sha256=zymgUIIVpFTARkFmxAuW2A4BQsNITh_L0uU-XunytHg,85
+claude_dev_cli-0.8.3.dist-info/top_level.txt,sha256=m7MF6LOIuTe41IT5Fgt0lc-DK1EgM4gUU_IZwWxK0pg,15
+claude_dev_cli-0.8.3.dist-info/RECORD,,