claude-dev-cli 0.8.0__py3-none-any.whl → 0.8.2__py3-none-any.whl

claude_dev_cli/__init__.py

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

claude_dev_cli/cli.py

@@ -461,20 +461,37 @@ def generate() -> None:
 @click.option('-o', '--output', type=click.Path(), help='Output file path')
 @click.option('-a', '--api', help='API config to use')
 @click.option('-i', '--interactive', is_flag=True, help='Interactive refinement mode')
+@click.option('--auto-context', is_flag=True, help='Include dependencies and related files')
 @click.pass_context
 def gen_tests(
     ctx: click.Context,
     file_path: str,
     output: Optional[str],
     api: Optional[str],
-    interactive: bool
+    interactive: bool,
+    auto_context: bool
 ) -> None:
     """Generate pytest tests for a Python file."""
     console = ctx.obj['console']
     
     try:
-        with console.status("[bold blue]Generating tests..."):
-            result = generate_tests(file_path, api_config_name=api)
+        if auto_context:
+            from claude_dev_cli.context import ContextGatherer
+            
+            with console.status("[bold blue]Gathering context..."):
+                gatherer = ContextGatherer()
+                context = gatherer.gather_for_file(Path(file_path), include_git=False)
+                context_info = context.format_for_prompt()
+            
+            console.print("[dim]✓ Context gathered (dependencies, related files)[/dim]")
+            
+            # Use context-aware test generation
+            client = ClaudeClient(api_config_name=api)
+            enhanced_prompt = f"{context_info}\n\nPlease generate comprehensive pytest tests for the main file, including fixtures, edge cases, and proper mocking where needed."
+            result = client.call(enhanced_prompt)
+        else:
+            with console.status("[bold blue]Generating tests..."):
+                result = generate_tests(file_path, api_config_name=api)
         
         if interactive:
             # Show initial result
@@ -530,20 +547,37 @@ def gen_tests(
 @click.option('-o', '--output', type=click.Path(), help='Output file path')
 @click.option('-a', '--api', help='API config to use')
 @click.option('-i', '--interactive', is_flag=True, help='Interactive refinement mode')
+@click.option('--auto-context', is_flag=True, help='Include dependencies and related files')
 @click.pass_context
 def gen_docs(
     ctx: click.Context,
     file_path: str,
     output: Optional[str],
     api: Optional[str],
-    interactive: bool
+    interactive: bool,
+    auto_context: bool
 ) -> None:
     """Generate documentation for a Python file."""
     console = ctx.obj['console']
     
     try:
-        with console.status("[bold blue]Generating documentation..."):
-            result = generate_docs(file_path, api_config_name=api)
+        if auto_context:
+            from claude_dev_cli.context import ContextGatherer
+            
+            with console.status("[bold blue]Gathering context..."):
+                gatherer = ContextGatherer()
+                context = gatherer.gather_for_file(Path(file_path), include_git=False)
+                context_info = context.format_for_prompt()
+            
+            console.print("[dim]✓ Context gathered (dependencies, related files)[/dim]")
+            
+            # Use context-aware documentation generation
+            client = ClaudeClient(api_config_name=api)
+            enhanced_prompt = f"{context_info}\n\nPlease generate comprehensive documentation for the main file, including API reference, usage examples, and integration notes."
+            result = client.call(enhanced_prompt)
+        else:
+            with console.status("[bold blue]Generating documentation..."):
+                result = generate_docs(file_path, api_config_name=api)
         
         if interactive:
             console.print("\n[bold]Initial Documentation:[/bold]\n")
@@ -816,14 +850,31 @@ def git() -> None:
 
 @git.command('commit')
 @click.option('-a', '--api', help='API config to use')
+@click.option('--auto-context', is_flag=True, help='Include git history and branch context')
 @click.pass_context
-def git_commit(ctx: click.Context, api: Optional[str]) -> None:
+def git_commit(ctx: click.Context, api: Optional[str], auto_context: bool) -> None:
     """Generate commit message from staged changes."""
     console = ctx.obj['console']
     
     try:
-        with console.status("[bold blue]Analyzing changes..."):
-            result = git_commit_message(api_config_name=api)
+        if auto_context:
+            from claude_dev_cli.context import ContextGatherer
+            
+            with console.status("[bold blue]Gathering context..."):
+                gatherer = ContextGatherer()
+                # Get git context with recent commits and branch info
+                git_context = gatherer.git.gather(include_diff=True)
+                context_info = git_context.format_for_prompt()
+            
+            console.print("[dim]✓ Context gathered (branch, commits, diff)[/dim]")
+            
+            # Use context-aware commit message generation
+            client = ClaudeClient(api_config_name=api)
+            enhanced_prompt = f"{context_info}\n\nPlease generate a concise, conventional commit message for the staged changes. Follow best practices: imperative mood, clear scope, explain what and why."
+            result = client.call(enhanced_prompt)
+        else:
+            with console.status("[bold blue]Analyzing changes..."):
+                result = git_commit_message(api_config_name=api)
         
         console.print("\n[bold green]Suggested commit message:[/bold green]")
         console.print(Panel(result, border_style="green"))
@@ -833,6 +884,107 @@ def git_commit(ctx: click.Context, api: Optional[str]) -> None:
         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

@@ -9,6 +9,18 @@ from pydantic import BaseModel, Field
 from claude_dev_cli.secure_storage import SecureStorage
 
 
+class ContextConfig(BaseModel):
+    """Global context gathering configuration."""
+    
+    auto_context_default: bool = False  # Default for --auto-context flag
+    max_file_lines: int = 1000  # Maximum lines per file in context
+    max_related_files: int = 5  # Maximum related files to include
+    max_diff_lines: int = 200  # Maximum lines of diff to include
+    include_git: bool = True  # Include git context by default
+    include_dependencies: bool = True  # Include dependencies by default
+    include_tests: bool = True  # Include test files by default
+
+
 class APIConfig(BaseModel):
     """Configuration for a Claude API key."""
     
@@ -31,6 +43,13 @@ class ProjectProfile(BaseModel):
     coding_style: Optional[str] = None  # Preferred coding style
     test_framework: Optional[str] = None  # Preferred test framework
     preferences: Dict[str, str] = Field(default_factory=dict)  # Custom preferences
+    
+    # Context gathering configuration
+    max_context_files: int = 5  # Maximum number of related files to include
+    max_diff_lines: int = 200  # Maximum lines of diff to include
+    max_file_lines: int = 1000  # Maximum lines per file in context
+    include_tests_by_default: bool = True  # Include test files in review context
+    context_depth: int = 2  # How deep to search for related modules
 
 
 class Config:
@@ -67,6 +86,7 @@ class Config:
                 "project_profiles": [],
                 "default_model": "claude-3-5-sonnet-20241022",
                 "max_tokens": 4096,
+                "context": ContextConfig().model_dump(),
             }
             self._save_config(default_config)
             return default_config
@@ -238,3 +258,8 @@ class Config:
     def get_max_tokens(self) -> int:
         """Get default max tokens."""
         return self._data.get("max_tokens", 4096)
+    
+    def get_context_config(self) -> ContextConfig:
+        """Get context gathering configuration."""
+        context_data = self._data.get("context", {})
+        return ContextConfig(**context_data) if context_data else ContextConfig()

claude_dev_cli/context.py

@@ -16,11 +16,30 @@ class ContextItem:
     content: str
     metadata: Dict[str, Any] = field(default_factory=dict)
     
+    def truncate(self, max_lines: Optional[int] = None) -> 'ContextItem':
+        """Truncate content to specified number of lines."""
+        if max_lines is None:
+            return self
+        
+        lines = self.content.split('\n')
+        if len(lines) <= max_lines:
+            return self
+        
+        truncated_lines = lines[:max_lines]
+        truncated_lines.append(f"\n... (truncated {len(lines) - max_lines} more lines)")
+        
+        return ContextItem(
+            type=self.type,
+            content='\n'.join(truncated_lines),
+            metadata={**self.metadata, 'truncated': True, 'original_lines': len(lines)}
+        )
+    
     def format_for_prompt(self) -> str:
         """Format this context item for inclusion in a prompt."""
         if self.type == 'file':
             path = self.metadata.get('path', 'unknown')
-            return f"# File: {path}\n\n{self.content}\n"
+            truncated_note = " (truncated)" if self.metadata.get('truncated') else ""
+            return f"# File: {path}{truncated_note}\n\n{self.content}\n"
         elif self.type == 'git':
             return f"# Git Context\n\n{self.content}\n"
         elif self.type == 'dependency':
@@ -165,8 +184,13 @@ class GitContext:
         except Exception:
             return []
     
-    def gather(self, include_diff: bool = False) -> ContextItem:
-        """Gather all git context."""
+    def gather(self, include_diff: bool = False, max_diff_lines: int = 200) -> ContextItem:
+        """Gather all git context.
+        
+        Args:
+            include_diff: Include staged diff in context
+            max_diff_lines: Maximum lines of diff to include
+        """
         parts = []
         
         branch = self.get_current_branch()
@@ -186,7 +210,12 @@ class GitContext:
         if include_diff:
             staged = self.get_staged_diff()
             if staged:
-                parts.append(f"\nStaged changes:\n{staged[:1000]}...")  # Limit size
+                diff_lines = staged.split('\n')
+                if len(diff_lines) > max_diff_lines:
+                    truncated_diff = '\n'.join(diff_lines[:max_diff_lines])
+                    parts.append(f"\nStaged changes (truncated {len(diff_lines) - max_diff_lines} lines):\n{truncated_diff}\n... (diff truncated)")
+                else:
+                    parts.append(f"\nStaged changes:\n{staged}")
         
         content = "\n".join(parts) if parts else "No git context available"
         
@@ -310,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')
         
@@ -362,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']}")
         
@@ -400,29 +603,42 @@ class ErrorContext:
 class ContextGatherer:
     """Main context gathering coordinator."""
     
-    def __init__(self, project_root: Optional[Path] = None):
+    def __init__(self, project_root: Optional[Path] = None, max_file_lines: int = 1000, max_related_files: int = 5):
         self.project_root = project_root or Path.cwd()
         self.git = GitContext(self.project_root)
         self.dependencies = DependencyAnalyzer(self.project_root)
         self.error_parser = ErrorContext()
+        self.max_file_lines = max_file_lines
+        self.max_related_files = max_related_files
     
     def gather_for_file(
         self,
         file_path: Path,
         include_git: bool = True,
         include_dependencies: bool = True,
-        include_related: bool = True
+        include_related: bool = True,
+        max_lines: Optional[int] = None
     ) -> Context:
-        """Gather context for a specific file operation."""
+        """Gather context for a specific file operation.
+        
+        Args:
+            file_path: Path to the file to gather context for
+            include_git: Include git context
+            include_dependencies: Include dependency information
+            include_related: Include related files
+            max_lines: Maximum lines per file (uses instance default if None)
+        """
         context = Context()
+        max_lines = max_lines or self.max_file_lines
         
         # Add the file itself
         if file_path.exists():
-            context.add(ContextItem(
+            item = ContextItem(
                 type='file',
                 content=file_path.read_text(),
                 metadata={'path': str(file_path)}
-            ))
+            )
+            context.add(item.truncate(max_lines))
         
         # Add git context
         if include_git and self.git.is_git_repo():
@@ -438,21 +654,31 @@ class ContextGatherer:
         self,
         error_text: str,
         file_path: Optional[Path] = None,
-        include_git: bool = True
+        include_git: bool = True,
+        max_lines: Optional[int] = None
     ) -> Context:
-        """Gather context for error debugging."""
+        """Gather context for error debugging.
+        
+        Args:
+            error_text: The error message or traceback
+            file_path: Optional file path related to the error
+            include_git: Include git context
+            max_lines: Maximum lines per file (uses instance default if None)
+        """
         context = Context()
+        max_lines = max_lines or self.max_file_lines
         
         # Add error context
         context.add(self.error_parser.gather(error_text))
         
         # Add file if provided
         if file_path and file_path.exists():
-            context.add(ContextItem(
+            item = ContextItem(
                 type='file',
                 content=file_path.read_text(),
                 metadata={'path': str(file_path)}
-            ))
+            )
+            context.add(item.truncate(max_lines))
         
         # Add git context
         if include_git and self.git.is_git_repo():
@@ -464,16 +690,27 @@ class ContextGatherer:
         self,
         file_path: Path,
         include_git: bool = True,
-        include_tests: bool = True
+        include_tests: bool = True,
+        max_lines: Optional[int] = None
     ) -> Context:
-        """Gather context for code review."""
+        """Gather context for code review.
+        
+        Args:
+            file_path: Path to the file to review
+            include_git: Include git context
+            include_tests: Try to find and include test files
+            max_lines: Maximum lines per file (uses instance default if None)
+        """
         context = self.gather_for_file(
             file_path,
             include_git=include_git,
             include_dependencies=True,
-            include_related=True
+            include_related=True,
+            max_lines=max_lines
         )
         
+        max_lines = max_lines or self.max_file_lines
+        
         # Try to find test file
         if include_tests:
             test_patterns = [
@@ -484,11 +721,13 @@ class ContextGatherer:
             
             for test_file in test_patterns:
                 if test_file.exists():
-                    context.add(ContextItem(
+                    item = ContextItem(
                         type='file',
                         content=test_file.read_text(),
                         metadata={'path': str(test_file), 'is_test': True}
-                    ))
+                    )
+                    context.add(item.truncate(max_lines))
                     break
         
         return context
+    

{claude_dev_cli-0.8.0.dist-info → claude_dev_cli-0.8.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-dev-cli
-Version: 0.8.0
+Version: 0.8.2
 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
@@ -79,12 +79,17 @@ A powerful command-line tool for developers using Claude AI with multi-API routi
 - **Variable Substitution**: Use {{variable}} placeholders for dynamic content
 - **Categories**: Organize templates by category (review, testing, debugging, etc.)
 
-### 🧠 Context Intelligence (NEW in v0.8.0)
-- **Auto-Context**: `--auto-context` flag for intelligent context gathering
+### 🧠 Context Intelligence (v0.8.0+)
+- **Auto-Context**: `--auto-context` flag on 7 commands for intelligent context gathering
+  - `ask`, `review`, `debug`, `refactor` (v0.8.0)
+  - `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`
 
 ### 🎒 TOON Format Support (Optional)
 - **Token Reduction**: 30-60% fewer tokens than JSON
@@ -156,6 +161,9 @@ cdc generate tests mymodule.py -o tests/test_mymodule.py
 # Generate tests with interactive refinement
 cdc generate tests mymodule.py --interactive
 
+# Generate tests with context (includes dependencies, related files) - NEW in v0.8.1
+cdc generate tests mymodule.py --auto-context
+
 # Code review
 cdc review mymodule.py
 
@@ -174,6 +182,9 @@ cdc generate docs mymodule.py
 # Generate docs with interactive refinement
 cdc generate docs mymodule.py --interactive
 
+# Generate docs with context (includes dependencies) - NEW in v0.8.1  
+cdc generate docs mymodule.py --auto-context
+
 # Refactor with context (includes related files)
 cdc refactor legacy_code.py --auto-context
 
@@ -183,9 +194,13 @@ cdc refactor legacy_code.py --interactive
 # Git commit message
 git add .
 cdc git commit
+
+# Git commit message with context (includes history, branch) - NEW in v0.8.1
+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
@@ -194,9 +209,16 @@ cdc git commit
 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?"

{claude_dev_cli-0.8.0.dist-info → claude_dev_cli-0.8.2.dist-info}/RECORD

@@ -1,8 +1,8 @@
-claude_dev_cli/__init__.py,sha256=02RgI91qpbUhOce0qyLICGF_7ipeIKMVnPg23VMtzQU,469
-claude_dev_cli/cli.py,sha256=iTL4yIOuRo-e3hFmWIZ78p0WdRIaU-XvmE2ZVUprrHA,48371
+claude_dev_cli/__init__.py,sha256=zz-bOjjR01C_VWxFEsIWbdJui0kBuDLpDfJV7yAFFRc,469
+claude_dev_cli/cli.py,sha256=BjTST8JSd8quldFxs09ZzlAPGt-rFIYhKUCWfj1pIn4,55100
 claude_dev_cli/commands.py,sha256=RKGx2rv56PM6eErvA2uoQ20hY8babuI5jav8nCUyUOk,3964
-claude_dev_cli/config.py,sha256=nsfRa6R0hnHc_15OTVZFmizf2Hl-MQXnJf3GBh13D8o,8477
-claude_dev_cli/context.py,sha256=eKJGvnHpbd_Xr748DRpZ4uN9mp89ZQ3M80E-hWUovME,16766
+claude_dev_cli/config.py,sha256=OLx0xWDf1RIK6RIxl5OKVS4aOSMZZOKxBDmzfQX-muk,9745
+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/secure_storage.py,sha256=TK3WOaU7a0yTOtzdP_t_28fDRp2lovANNAC6MBdm4nQ,7096
@@ -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.0.dist-info/licenses/LICENSE,sha256=DGueuJwMJtMwgLO5mWlS0TaeBrFwQuNpNZ22PU9J2bw,1062
-claude_dev_cli-0.8.0.dist-info/METADATA,sha256=9VF6tdI1W1mKdyq1YeeBE-I4NMzPMxmx5RXzhOIFTrI,14580
-claude_dev_cli-0.8.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-claude_dev_cli-0.8.0.dist-info/entry_points.txt,sha256=zymgUIIVpFTARkFmxAuW2A4BQsNITh_L0uU-XunytHg,85
-claude_dev_cli-0.8.0.dist-info/top_level.txt,sha256=m7MF6LOIuTe41IT5Fgt0lc-DK1EgM4gUU_IZwWxK0pg,15
-claude_dev_cli-0.8.0.dist-info/RECORD,,
+claude_dev_cli-0.8.2.dist-info/licenses/LICENSE,sha256=DGueuJwMJtMwgLO5mWlS0TaeBrFwQuNpNZ22PU9J2bw,1062
+claude_dev_cli-0.8.2.dist-info/METADATA,sha256=4Pyai7Is7NJezxG5ypTm5rML1wEqIlOwHI5GZDlFFs0,15708
+claude_dev_cli-0.8.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+claude_dev_cli-0.8.2.dist-info/entry_points.txt,sha256=zymgUIIVpFTARkFmxAuW2A4BQsNITh_L0uU-XunytHg,85
+claude_dev_cli-0.8.2.dist-info/top_level.txt,sha256=m7MF6LOIuTe41IT5Fgt0lc-DK1EgM4gUU_IZwWxK0pg,15
+claude_dev_cli-0.8.2.dist-info/RECORD,,