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

claude_dev_cli/__init__.py

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

claude_dev_cli/cli.py

@@ -57,6 +57,7 @@ except Exception:
 @click.option('-a', '--api', help='API config to use')
 @click.option('-m', '--model', help='Claude model to use')
 @click.option('--stream/--no-stream', default=True, help='Stream response')
+@click.option('--auto-context', is_flag=True, help='Automatically include git, dependencies, and related files')
 @click.pass_context
 def ask(
     ctx: click.Context,
@@ -65,7 +66,8 @@ def ask(
     system: Optional[str],
     api: Optional[str],
     model: Optional[str],
-    stream: bool
+    stream: bool,
+    auto_context: bool
 ) -> None:
     """Ask Claude a question (single-shot mode)."""
     console = ctx.obj['console']
@@ -73,7 +75,18 @@ def ask(
     # Build prompt
     prompt_parts = []
     
-    if file:
+    # Gather context if requested
+    if auto_context and file:
+        from claude_dev_cli.context import ContextGatherer
+        
+        with console.status("[bold blue]Gathering context..."):
+            gatherer = ContextGatherer()
+            context = gatherer.gather_for_file(Path(file))
+            context_info = context.format_for_prompt()
+        
+        console.print("[dim]✓ Context gathered[/dim]")
+        prompt_parts.append(context_info)
+    elif file:
         with open(file, 'r') as f:
             file_content = f.read()
             prompt_parts.append(f"File: {file}\n\n{file_content}\n\n")
@@ -448,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
@@ -517,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")
@@ -584,19 +631,42 @@ def gen_docs(
 @click.argument('file_path', type=click.Path(exists=True))
 @click.option('-a', '--api', help='API config to use')
 @click.option('-i', '--interactive', is_flag=True, help='Interactive follow-up questions')
+@click.option('--auto-context', is_flag=True, help='Automatically include git, dependencies, and related files')
 @click.pass_context
 def review(
     ctx: click.Context,
     file_path: str,
     api: Optional[str],
-    interactive: bool
+    interactive: bool,
+    auto_context: bool
 ) -> None:
     """Review code for bugs and improvements."""
     console = ctx.obj['console']
     
     try:
+        # Gather context if requested
+        context_info = ""
+        if auto_context:
+            from claude_dev_cli.context import ContextGatherer
+            
+            with console.status("[bold blue]Gathering context..."):
+                gatherer = ContextGatherer()
+                context = gatherer.gather_for_review(Path(file_path))
+                context_info = context.format_for_prompt()
+            
+            console.print("[dim]✓ Context gathered (git, dependencies, tests)[/dim]")
+        
         with console.status("[bold blue]Reviewing code..."):
-            result = code_review(file_path, api_config_name=api)
+            # If we have context, prepend it to the file analysis
+            if context_info:
+                # Read file separately for context-aware review
+                result = code_review(file_path, api_config_name=api)
+                # The context module already includes the file, so we use it differently
+                client = ClaudeClient(api_config_name=api)
+                enhanced_prompt = f"{context_info}\n\nPlease review this code for bugs and improvements."
+                result = client.call(enhanced_prompt)
+            else:
+                result = code_review(file_path, api_config_name=api)
         
         md = Markdown(result)
         console.print(md)
@@ -633,12 +703,14 @@ def review(
 @click.option('-f', '--file', type=click.Path(exists=True), help='File to debug')
 @click.option('-e', '--error', help='Error message to analyze')
 @click.option('-a', '--api', help='API config to use')
+@click.option('--auto-context', is_flag=True, help='Automatically include git context and parse error details')
 @click.pass_context
 def debug(
     ctx: click.Context,
     file: Optional[str],
     error: Optional[str],
-    api: Optional[str]
+    api: Optional[str],
+    auto_context: bool
 ) -> None:
     """Debug code and analyze errors."""
     console = ctx.obj['console']
@@ -648,13 +720,33 @@ def debug(
     if not sys.stdin.isatty():
         stdin_content = sys.stdin.read().strip()
     
+    error_text = error or stdin_content
+    
     try:
-        with console.status("[bold blue]Analyzing error..."):
-            result = debug_code(
-                file_path=file,
-                error_message=error or stdin_content,
-                api_config_name=api
-            )
+        # Gather context if requested
+        if auto_context and error_text:
+            from claude_dev_cli.context import ContextGatherer
+            
+            with console.status("[bold blue]Gathering context..."):
+                gatherer = ContextGatherer()
+                file_path = Path(file) if file else None
+                context = gatherer.gather_for_error(error_text, file_path=file_path)
+                context_info = context.format_for_prompt()
+            
+            console.print("[dim]✓ Context gathered (error details, git context)[/dim]")
+            
+            # Use context-aware analysis
+            client = ClaudeClient(api_config_name=api)
+            enhanced_prompt = f"{context_info}\n\nPlease analyze this error and suggest fixes."
+            result = client.call(enhanced_prompt)
+        else:
+            # Original behavior
+            with console.status("[bold blue]Analyzing error..."):
+                result = debug_code(
+                    file_path=file,
+                    error_message=error_text,
+                    api_config_name=api
+                )
         
         md = Markdown(result)
         console.print(md)
@@ -669,20 +761,38 @@ def debug(
 @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='Automatically include git, dependencies, and related files')
 @click.pass_context
 def refactor(
     ctx: click.Context,
     file_path: str,
     output: Optional[str],
     api: Optional[str],
-    interactive: bool
+    interactive: bool,
+    auto_context: bool
 ) -> None:
     """Suggest refactoring improvements."""
     console = ctx.obj['console']
     
     try:
-        with console.status("[bold blue]Analyzing code..."):
-            result = refactor_code(file_path, api_config_name=api)
+        # Gather context if requested
+        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))
+                context_info = context.format_for_prompt()
+            
+            console.print("[dim]✓ Context gathered[/dim]")
+            
+            # Use context-aware refactoring
+            client = ClaudeClient(api_config_name=api)
+            enhanced_prompt = f"{context_info}\n\nPlease suggest refactoring improvements for the main file."
+            result = client.call(enhanced_prompt)
+        else:
+            with console.status("[bold blue]Analyzing code..."):
+                result = refactor_code(file_path, api_config_name=api)
         
         if interactive:
             console.print("\n[bold]Initial Refactoring:[/bold]\n")
@@ -740,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"))

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."""
     
@@ -25,6 +37,19 @@ class ProjectProfile(BaseModel):
     api_config: str  # Name of the API config to use
     system_prompt: Optional[str] = None
     allowed_commands: List[str] = Field(default_factory=lambda: ["all"])
+    
+    # Project memory - preferences and patterns
+    auto_context: bool = False  # Default value for --auto-context flag
+    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:
@@ -61,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
@@ -232,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

@@ -0,0 +1,559 @@
+"""Intelligent context gathering for AI operations."""
+
+import ast
+import json
+import re
+import subprocess
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Set
+from dataclasses import dataclass, field
+
+
+@dataclass
+class ContextItem:
+    """A single piece of context information."""
+    type: str  # 'file', 'git', 'dependency', 'error'
+    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')
+            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':
+            return f"# Dependencies\n\n{self.content}\n"
+        elif self.type == 'error':
+            return f"# Error Context\n\n{self.content}\n"
+        else:
+            return self.content
+
+
+@dataclass
+class Context:
+    """Collection of context items."""
+    items: List[ContextItem] = field(default_factory=list)
+    
+    def add(self, item: ContextItem) -> None:
+        """Add a context item."""
+        self.items.append(item)
+    
+    def format_for_prompt(self) -> str:
+        """Format all context items for inclusion in a prompt."""
+        if not self.items:
+            return ""
+        
+        parts = ["# Context Information\n"]
+        for item in self.items:
+            parts.append(item.format_for_prompt())
+        
+        return "\n".join(parts)
+    
+    def get_by_type(self, context_type: str) -> List[ContextItem]:
+        """Get all context items of a specific type."""
+        return [item for item in self.items if item.type == context_type]
+
+
+class GitContext:
+    """Gather Git-related context."""
+    
+    def __init__(self, cwd: Optional[Path] = None):
+        self.cwd = cwd or Path.cwd()
+    
+    def is_git_repo(self) -> bool:
+        """Check if current directory is a git repository."""
+        try:
+            result = subprocess.run(
+                ['git', 'rev-parse', '--git-dir'],
+                cwd=self.cwd,
+                capture_output=True,
+                text=True
+            )
+            return result.returncode == 0
+        except Exception:
+            return False
+    
+    def get_current_branch(self) -> Optional[str]:
+        """Get the current git branch."""
+        try:
+            result = subprocess.run(
+                ['git', 'rev-parse', '--abbrev-ref', 'HEAD'],
+                cwd=self.cwd,
+                capture_output=True,
+                text=True,
+                check=True
+            )
+            return result.stdout.strip()
+        except Exception:
+            return None
+    
+    def get_recent_commits(self, count: int = 5) -> List[Dict[str, str]]:
+        """Get recent commit messages."""
+        try:
+            result = subprocess.run(
+                ['git', '--no-pager', 'log', f'-{count}', '--pretty=format:%h|%s|%an|%ar'],
+                cwd=self.cwd,
+                capture_output=True,
+                text=True,
+                check=True
+            )
+            
+            commits = []
+            for line in result.stdout.strip().split('\n'):
+                if line:
+                    parts = line.split('|', 3)
+                    if len(parts) == 4:
+                        commits.append({
+                            'hash': parts[0],
+                            'message': parts[1],
+                            'author': parts[2],
+                            'date': parts[3]
+                        })
+            return commits
+        except Exception:
+            return []
+    
+    def get_staged_diff(self) -> Optional[str]:
+        """Get diff of staged changes."""
+        try:
+            result = subprocess.run(
+                ['git', '--no-pager', 'diff', '--cached'],
+                cwd=self.cwd,
+                capture_output=True,
+                text=True,
+                check=True
+            )
+            return result.stdout if result.stdout else None
+        except Exception:
+            return None
+    
+    def get_unstaged_diff(self) -> Optional[str]:
+        """Get diff of unstaged changes."""
+        try:
+            result = subprocess.run(
+                ['git', '--no-pager', 'diff'],
+                cwd=self.cwd,
+                capture_output=True,
+                text=True,
+                check=True
+            )
+            return result.stdout if result.stdout else None
+        except Exception:
+            return None
+    
+    def get_modified_files(self) -> List[str]:
+        """Get list of modified files."""
+        try:
+            result = subprocess.run(
+                ['git', 'status', '--porcelain'],
+                cwd=self.cwd,
+                capture_output=True,
+                text=True,
+                check=True
+            )
+            
+            files = []
+            for line in result.stdout.strip().split('\n'):
+                if line:
+                    # Format: "XY filename"
+                    parts = line.strip().split(maxsplit=1)
+                    if len(parts) == 2:
+                        files.append(parts[1])
+            return files
+        except Exception:
+            return []
+    
+    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()
+        if branch:
+            parts.append(f"Branch: {branch}")
+        
+        commits = self.get_recent_commits(5)
+        if commits:
+            parts.append("\nRecent commits:")
+            for commit in commits:
+                parts.append(f"  {commit['hash']} - {commit['message']} ({commit['date']})")
+        
+        modified = self.get_modified_files()
+        if modified:
+            parts.append(f"\nModified files: {', '.join(modified[:10])}")
+        
+        if include_diff:
+            staged = self.get_staged_diff()
+            if staged:
+                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"
+        
+        return ContextItem(
+            type='git',
+            content=content,
+            metadata={'branch': branch, 'modified_count': len(modified)}
+        )
+
+
+class DependencyAnalyzer:
+    """Analyze project dependencies and imports."""
+    
+    def __init__(self, project_root: Path):
+        self.project_root = project_root
+    
+    def find_python_imports(self, file_path: Path) -> Set[str]:
+        """Extract imports from a Python file."""
+        imports = set()
+        
+        try:
+            with open(file_path, 'r') as f:
+                tree = ast.parse(f.read())
+            
+            for node in ast.walk(tree):
+                if isinstance(node, ast.Import):
+                    for name in node.names:
+                        imports.add(name.name.split('.')[0])
+                elif isinstance(node, ast.ImportFrom):
+                    if node.module:
+                        imports.add(node.module.split('.')[0])
+        except Exception:
+            pass
+        
+        return imports
+    
+    def find_related_files(self, file_path: Path, max_depth: int = 2) -> List[Path]:
+        """Find files related to the given file through imports."""
+        if not file_path.suffix == '.py':
+            return []
+        
+        related = []
+        imports = self.find_python_imports(file_path)
+        
+        # Look for local modules
+        for imp in imports:
+            # Try as module file
+            module_file = self.project_root / f"{imp}.py"
+            if module_file.exists() and module_file != file_path:
+                related.append(module_file)
+            
+            # Try as package
+            package_init = self.project_root / imp / "__init__.py"
+            if package_init.exists():
+                related.append(package_init)
+        
+        return related[:5]  # Limit to avoid too many files
+    
+    def get_dependency_files(self) -> List[Path]:
+        """Find dependency configuration files."""
+        files = []
+        
+        # Python
+        for name in ['requirements.txt', 'setup.py', 'pyproject.toml', 'Pipfile']:
+            file = self.project_root / name
+            if file.exists():
+                files.append(file)
+        
+        # Node.js
+        for name in ['package.json', 'package-lock.json']:
+            file = self.project_root / name
+            if file.exists():
+                files.append(file)
+        
+        # Other
+        for name in ['Gemfile', 'go.mod', 'Cargo.toml']:
+            file = self.project_root / name
+            if file.exists():
+                files.append(file)
+        
+        return files
+    
+    def gather(self, target_file: Optional[Path] = None) -> ContextItem:
+        """Gather dependency context."""
+        parts = []
+        
+        # Include dependency files
+        dep_files = self.get_dependency_files()
+        if dep_files:
+            parts.append("Dependency files:")
+            for file in dep_files[:3]:  # Limit
+                parts.append(f"  - {file.name}")
+                try:
+                    content = file.read_text()
+                    # Include only relevant parts
+                    if file.suffix == '.json':
+                        data = json.loads(content)
+                        if 'dependencies' in data:
+                            parts.append(f"    Dependencies: {', '.join(list(data['dependencies'].keys())[:10])}")
+                    elif file.suffix == '.txt':
+                        lines = content.split('\n')[:20]
+                        parts.append(f"    Requirements: {', '.join([l.split('==')[0] for l in lines if l and not l.startswith('#')])}")
+                except Exception:
+                    pass
+        
+        # Related files if target specified
+        if target_file and target_file.exists():
+            related = self.find_related_files(target_file)
+            if related:
+                parts.append(f"\nRelated files for {target_file.name}:")
+                for file in related:
+                    parts.append(f"  - {file.relative_to(self.project_root)}")
+        
+        content = "\n".join(parts) if parts else "No dependency context found"
+        
+        return ContextItem(
+            type='dependency',
+            content=content,
+            metadata={'dependency_files': [str(f) for f in dep_files]}
+        )
+
+
+class ErrorContext:
+    """Parse and format error context."""
+    
+    @staticmethod
+    def parse_traceback(error_text: str) -> Dict[str, Any]:
+        """Parse Python traceback into structured data."""
+        lines = error_text.split('\n')
+        
+        # Find traceback start
+        traceback_start = -1
+        for i, line in enumerate(lines):
+            if 'Traceback' in line:
+                traceback_start = i
+                break
+        
+        if traceback_start == -1:
+            return {'raw': error_text}
+        
+        # Extract frames
+        frames = []
+        current_frame = {}
+        
+        for line in lines[traceback_start + 1:]:
+            if line.startswith('  File '):
+                if current_frame:
+                    frames.append(current_frame)
+                
+                # Parse: File "path", line X, in function
+                match = re.match(r'\s*File "([^"]+)", line (\d+), in (.+)', line)
+                if match:
+                    current_frame = {
+                        'file': match.group(1),
+                        'line': int(match.group(2)),
+                        'function': match.group(3)
+                    }
+            elif line.startswith('    ') and current_frame:
+                current_frame['code'] = line.strip()
+            elif line and not line.startswith(' '):
+                # Error message
+                if current_frame:
+                    frames.append(current_frame)
+                    current_frame = {}
+                
+                error_type = line.split(':')[0] if ':' in line else line
+                error_message = line.split(':', 1)[1].strip() if ':' in line else ''
+                
+                return {
+                    'frames': frames,
+                    'error_type': error_type,
+                    'error_message': error_message,
+                    'raw': error_text
+                }
+        
+        return {'frames': frames, 'raw': error_text}
+    
+    @staticmethod
+    def format_for_ai(error_text: str) -> str:
+        """Format error for AI consumption."""
+        parsed = ErrorContext.parse_traceback(error_text)
+        
+        if 'error_type' not in parsed:
+            return error_text
+        
+        parts = [
+            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')}")
+            if 'code' in frame:
+                parts.append(f"     > {frame['code']}")
+        
+        return "\n".join(parts)
+    
+    def gather(self, error_text: str) -> ContextItem:
+        """Gather error context."""
+        formatted = self.format_for_ai(error_text)
+        parsed = self.parse_traceback(error_text)
+        
+        return ContextItem(
+            type='error',
+            content=formatted,
+            metadata=parsed
+        )
+
+
+class ContextGatherer:
+    """Main context gathering coordinator."""
+    
+    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,
+        max_lines: Optional[int] = None
+    ) -> Context:
+        """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():
+            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():
+            context.add(self.git.gather(include_diff=False))
+        
+        # Add dependency context
+        if include_dependencies:
+            context.add(self.dependencies.gather(target_file=file_path if include_related else None))
+        
+        return context
+    
+    def gather_for_error(
+        self,
+        error_text: str,
+        file_path: Optional[Path] = None,
+        include_git: bool = True,
+        max_lines: Optional[int] = None
+    ) -> Context:
+        """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():
+            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():
+            context.add(self.git.gather(include_diff=False))
+        
+        return context
+    
+    def gather_for_review(
+        self,
+        file_path: Path,
+        include_git: bool = True,
+        include_tests: bool = True,
+        max_lines: Optional[int] = None
+    ) -> Context:
+        """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,
+            max_lines=max_lines
+        )
+        
+        max_lines = max_lines or self.max_file_lines
+        
+        # Try to find test file
+        if include_tests:
+            test_patterns = [
+                self.project_root / "tests" / f"test_{file_path.name}",
+                self.project_root / f"test_{file_path.name}",
+                file_path.parent / f"test_{file_path.name}"
+            ]
+            
+            for test_file in test_patterns:
+                if test_file.exists():
+                    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.7.0.dist-info → claude_dev_cli-0.8.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-dev-cli
-Version: 0.7.0
+Version: 0.8.1
 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,6 +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 (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
+- **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
 - **Cost Savings**: Reduce API costs significantly
@@ -149,14 +160,20 @@ 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
 
+# Code review with auto-context (includes git, dependencies, tests)
+cdc review mymodule.py --auto-context
+
 # Code review with interactive follow-up questions
 cdc review mymodule.py --interactive
 
-# Debug errors
-python script.py 2>&1 | cdc debug
+# Debug errors with intelligent error parsing
+python script.py 2>&1 | cdc debug --auto-context
 
 # Generate documentation
 cdc generate docs mymodule.py
@@ -164,8 +181,11 @@ cdc generate docs mymodule.py
 # Generate docs with interactive refinement
 cdc generate docs mymodule.py --interactive
 
-# Refactor suggestions
-cdc refactor legacy_code.py
+# 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
 
 # Refactor with interactive refinement
 cdc refactor legacy_code.py --interactive
@@ -173,6 +193,32 @@ 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)
+
+```bash
+# Auto-context includes: git info, dependencies, related files
+
+# Review with full project context
+cdc review mymodule.py --auto-context
+# ✓ Context gathered (git, dependencies, tests)
+
+# Debug with parsed error details
+python broken.py 2>&1 | cdc debug -f broken.py --auto-context
+# ✓ Context gathered (error details, git context)
+
+# Ask questions with file context
+cdc ask -f mycode.py --auto-context "how can I improve this?"
+# ✓ Context gathered
+
+# Refactor with related files
+cdc refactor app.py --auto-context
+# Automatically includes imported modules and dependencies
 ```
 
 ### 5. Custom Templates

{claude_dev_cli-0.7.0.dist-info → claude_dev_cli-0.8.1.dist-info}/RECORD

@@ -1,7 +1,8 @@
-claude_dev_cli/__init__.py,sha256=sRGmW8jYKXWyBKqr2_-3AornNC32eNj4sESrXfoTUoQ,469
-claude_dev_cli/cli.py,sha256=feTRI1fQoDPJiB7JM45ZU2I1jEjXX643191H_U0rMio,44612
+claude_dev_cli/__init__.py,sha256=0g1KP2ohJ45KCYW9EkcRcTA885E4Gqm1kDQbmIOdC-k,469
+claude_dev_cli/cli.py,sha256=FjVq9QanwxM8WqSZPPM4-b50v9Ycy9ZDHEg9gBo-kCk,51304
 claude_dev_cli/commands.py,sha256=RKGx2rv56PM6eErvA2uoQ20hY8babuI5jav8nCUyUOk,3964
-claude_dev_cli/config.py,sha256=RGX0sKplHUsrJJmU-4FuWWjoTbQVgWaMT8DgRUofrR4,8134
+claude_dev_cli/config.py,sha256=OLx0xWDf1RIK6RIxl5OKVS4aOSMZZOKxBDmzfQX-muk,9745
+claude_dev_cli/context.py,sha256=Z3QYq4ZHAqpuv_xPZtXcBeWf0LCelzkybj8cBz2nBAo,19523
 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
@@ -16,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.7.0.dist-info/licenses/LICENSE,sha256=DGueuJwMJtMwgLO5mWlS0TaeBrFwQuNpNZ22PU9J2bw,1062
-claude_dev_cli-0.7.0.dist-info/METADATA,sha256=YIN5U4urelKIEFjhd-s2EyHsPb-qEvhhqDwOek2hjPw,13364
-claude_dev_cli-0.7.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-claude_dev_cli-0.7.0.dist-info/entry_points.txt,sha256=zymgUIIVpFTARkFmxAuW2A4BQsNITh_L0uU-XunytHg,85
-claude_dev_cli-0.7.0.dist-info/top_level.txt,sha256=m7MF6LOIuTe41IT5Fgt0lc-DK1EgM4gUU_IZwWxK0pg,15
-claude_dev_cli-0.7.0.dist-info/RECORD,,
+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,,