claude-dev-cli 0.11.0__py3-none-any.whl → 0.12.1__py3-none-any.whl

claude_dev_cli/__init__.py

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

claude_dev_cli/cli.py

@@ -1060,6 +1060,315 @@ def gen_docs(
         sys.exit(1)
 
 
+@generate.command('code')
+@click.option('--description', help='Inline code specification')
+@click.option('-f', '--file', 'spec_file', type=click.Path(exists=True), help='Read specification from file')
+@click.option('--pdf', type=click.Path(exists=True), help='Read specification from PDF')
+@click.option('--url', help='Fetch specification from URL')
+@click.option('-o', '--output', required=True, type=click.Path(), help='Output file path (required)')
+@click.option('--language', help='Target language (auto-detected from output extension)')
+@click.option('-m', '--model', help='Model profile to use')
+@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 project context')
+@click.pass_context
+def gen_code(
+    ctx: click.Context,
+    description: Optional[str],
+    spec_file: Optional[str],
+    pdf: Optional[str],
+    url: Optional[str],
+    output: str,
+    language: Optional[str],
+    model: Optional[str],
+    api: Optional[str],
+    interactive: bool,
+    auto_context: bool
+) -> None:
+    """Generate code from a specification.
+    
+    Reads specification from text, file, PDF, or URL and generates complete code.
+    
+    Examples:
+      cdc generate code --description "REST API client" -o client.py
+      cdc generate code --file spec.md -o implementation.go
+      cdc generate code --pdf requirements.pdf -o app.js
+      cdc generate code --url https://example.com/spec -o service.py
+    """
+    console = ctx.obj['console']
+    from claude_dev_cli.input_sources import get_input_content
+    from pathlib import Path
+    
+    try:
+        # Get specification content
+        spec_content, source_desc = get_input_content(
+            description=description,
+            file_path=spec_file,
+            pdf_path=pdf,
+            url=url,
+            console=console
+        )
+        
+        # Detect language from output extension if not specified
+        if not language:
+            ext = Path(output).suffix.lstrip('.')
+            language_map = {
+                'py': 'Python',
+                'js': 'JavaScript',
+                'ts': 'TypeScript',
+                'go': 'Go',
+                'rs': 'Rust',
+                'java': 'Java',
+                'cpp': 'C++',
+                'c': 'C',
+                'cs': 'C#',
+                'rb': 'Ruby',
+                'php': 'PHP',
+                'swift': 'Swift',
+                'kt': 'Kotlin',
+            }
+            language = language_map.get(ext, ext.upper() if ext else None)
+        
+        console.print(f"[cyan]Generating code from:[/cyan] {source_desc}")
+        if language:
+            console.print(f"[cyan]Target language:[/cyan] {language}")
+        console.print(f"[cyan]Output:[/cyan] {output}\n")
+        
+        # Build prompt
+        prompt = f"Specification:\n\n{spec_content}\n\n"
+        if language:
+            prompt += f"Generate complete, production-ready {language} code that implements this specification. "
+        else:
+            prompt += "Generate complete, production-ready code that implements this specification. "
+        prompt += "Include proper error handling, documentation, and best practices."
+        
+        # Add context if requested
+        if auto_context:
+            from claude_dev_cli.context import ContextGatherer
+            
+            with console.status("[bold blue]Gathering project context..."):
+                gatherer = ContextGatherer()
+                # Gather context from current directory
+                context = gatherer.gather_for_file(".", include_git=True)
+                context_info = context.format_for_prompt()
+            
+            console.print("[dim]✓ Context gathered[/dim]")
+            prompt = f"{context_info}\n\n{prompt}"
+        
+        # Generate code
+        with console.status(f"[bold blue]Generating code..."):
+            client = ClaudeClient(api_config_name=api)
+            result = client.call(prompt, model=model)
+        
+        # Interactive refinement
+        if interactive:
+            console.print("\n[bold]Initial Code:[/bold]\n")
+            console.print(result)
+            
+            client = ClaudeClient(api_config_name=api)
+            conversation_context = [result]
+            
+            while True:
+                console.print("\n[dim]Commands: 'save' to save and exit, 'exit' to discard, or ask for changes[/dim]")
+                user_input = console.input("[cyan]You:[/cyan] ").strip()
+                
+                if user_input.lower() == 'exit':
+                    console.print("[yellow]Discarded changes[/yellow]")
+                    return
+                
+                if user_input.lower() == 'save':
+                    result = conversation_context[-1]
+                    break
+                
+                if not user_input:
+                    continue
+                
+                # Get refinement
+                refinement_prompt = f"Previous code:\n\n{conversation_context[-1]}\n\nUser request: {user_input}\n\nProvide the updated code."
+                
+                console.print("\n[bold green]Claude:[/bold green] ", end='')
+                response_parts = []
+                for chunk in client.call_streaming(refinement_prompt, model=model):
+                    console.print(chunk, end='')
+                    response_parts.append(chunk)
+                console.print()
+                
+                result = ''.join(response_parts)
+                conversation_context.append(result)
+        
+        # Save output
+        Path(output).write_text(result)
+        console.print(f"\n[green]✓[/green] Code saved to: {output}")
+    
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+        sys.exit(1)
+
+
+@generate.command('feature')
+@click.argument('paths', nargs=-1, type=click.Path(exists=True))
+@click.option('--description', help='Inline feature specification')
+@click.option('-f', '--file', 'spec_file', type=click.Path(exists=True), help='Read specification from file')
+@click.option('--pdf', type=click.Path(exists=True), help='Read specification from PDF')
+@click.option('--url', help='Fetch specification from URL')
+@click.option('--max-files', type=int, default=10, help='Maximum files to modify (default: 10)')
+@click.option('-m', '--model', help='Model profile to use')
+@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 project context')
+@click.option('--preview', is_flag=True, help='Preview changes without applying')
+@click.pass_context
+def gen_feature(
+    ctx: click.Context,
+    paths: tuple,
+    description: Optional[str],
+    spec_file: Optional[str],
+    pdf: Optional[str],
+    url: Optional[str],
+    max_files: int,
+    model: Optional[str],
+    api: Optional[str],
+    interactive: bool,
+    auto_context: bool,
+    preview: bool
+) -> None:
+    """Generate code to add a feature to existing project.
+    
+    Analyzes existing code and generates changes to implement a feature.
+    
+    Examples:
+      cdc generate feature --description "Add authentication" src/
+      cdc generate feature --file feature-spec.md
+      cdc generate feature --pdf requirements.pdf --preview
+      cdc generate feature --url https://example.com/spec src/
+    """
+    console = ctx.obj['console']
+    from claude_dev_cli.input_sources import get_input_content
+    from claude_dev_cli.path_utils import expand_paths, auto_detect_files
+    
+    try:
+        # Get feature specification
+        spec_content, source_desc = get_input_content(
+            description=description,
+            file_path=spec_file,
+            pdf_path=pdf,
+            url=url,
+            console=console
+        )
+        
+        # Determine files to analyze
+        if paths:
+            files = expand_paths(list(paths), max_files=max_files)
+        else:
+            files = auto_detect_files()
+            if files:
+                console.print(f"[dim]Auto-detected {len(files)} file(s) from project[/dim]")
+        
+        if not files:
+            console.print("[yellow]No files found. Specify paths or run in a project directory.[/yellow]")
+            return
+        
+        console.print(f"[cyan]Feature specification from:[/cyan] {source_desc}")
+        console.print(f"[cyan]Analyzing:[/cyan] {len(files)} file(s)\n")
+        
+        # Show files
+        if len(files) > 1:
+            console.print(f"[bold]Files to analyze:[/bold]")
+            for f in files[:5]:
+                console.print(f"  • {f}")
+            if len(files) > 5:
+                console.print(f"  ... and {len(files) - 5} more")
+            console.print()
+        
+        # Build codebase content
+        codebase_content = ""
+        for file_path in files:
+            try:
+                with open(file_path, 'r') as f:
+                    content = f.read()
+                codebase_content += f"\n\n## File: {file_path}\n\n```\n{content}\n```\n"
+            except Exception as e:
+                console.print(f"[yellow]Warning: Could not read {file_path}: {e}[/yellow]")
+        
+        # Build prompt
+        prompt = f"Feature Specification:\n\n{spec_content}\n\n"
+        prompt += f"Existing Codebase:{codebase_content}\n\n"
+        prompt += "Analyze the existing code and provide:\n"
+        prompt += "1. Implementation plan for the feature\n"
+        prompt += "2. List of files to modify or create\n"
+        prompt += "3. Complete code changes (diffs or new files)\n"
+        prompt += "4. Any necessary setup or configuration changes\n\n"
+        prompt += "Be specific and provide complete, working code."
+        
+        # Add context if requested
+        if auto_context:
+            from claude_dev_cli.context import ContextGatherer
+            
+            with console.status("[bold blue]Gathering project context..."):
+                gatherer = ContextGatherer()
+                context = gatherer.gather_for_file(files[0], include_git=True)
+                context_info = context.format_for_prompt()
+            
+            console.print("[dim]✓ Context gathered[/dim]")
+            prompt = f"{context_info}\n\n{prompt}"
+        
+        # Generate feature implementation
+        with console.status(f"[bold blue]Analyzing codebase and generating feature implementation..."):
+            client = ClaudeClient(api_config_name=api)
+            result = client.call(prompt, model=model)
+        
+        # Show result
+        from rich.markdown import Markdown
+        md = Markdown(result)
+        console.print(md)
+        
+        if preview:
+            console.print("\n[yellow]Preview mode - no changes applied[/yellow]")
+            console.print("[dim]Remove --preview flag to apply changes[/dim]")
+            return
+        
+        # Interactive refinement
+        if interactive:
+            client = ClaudeClient(api_config_name=api)
+            conversation_context = [result]
+            
+            while True:
+                console.print("\n[dim]Ask for changes, 'apply' to confirm, or 'exit' to cancel[/dim]")
+                user_input = console.input("[cyan]You:[/cyan] ").strip()
+                
+                if user_input.lower() == 'exit':
+                    console.print("[yellow]Cancelled[/yellow]")
+                    return
+                
+                if user_input.lower() == 'apply':
+                    console.print("[green]✓[/green] Implementation plan ready")
+                    console.print("[dim]Apply the changes manually from the output above[/dim]")
+                    return
+                
+                if not user_input:
+                    continue
+                
+                # Get refinement
+                refinement_prompt = f"Previous implementation plan:\n\n{conversation_context[-1]}\n\nUser request: {user_input}\n\nProvide the updated implementation."
+                
+                console.print("\n[bold green]Claude:[/bold green] ", end='')
+                response_parts = []
+                for chunk in client.call_streaming(refinement_prompt, model=model):
+                    console.print(chunk, end='')
+                    response_parts.append(chunk)
+                console.print()
+                
+                result = ''.join(response_parts)
+                conversation_context.append(result)
+        else:
+            console.print("\n[green]✓[/green] Feature implementation generated")
+            console.print("[dim]Apply the changes manually from the output above[/dim]")
+    
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+        sys.exit(1)
+
+
 @main.command('review')
 @click.argument('paths', nargs=-1, type=click.Path(exists=True))
 @click.option('-a', '--api', help='API config to use')

claude_dev_cli/input_sources.py

@@ -0,0 +1,231 @@
+"""Input source handlers for reading specifications from various sources."""
+
+from pathlib import Path
+from typing import Optional, Tuple
+from rich.console import Console
+
+
+def read_text_input(text: str) -> str:
+    """Read text input directly."""
+    return text
+
+
+def read_file_input(file_path: str) -> str:
+    """Read input from a file.
+    
+    Args:
+        file_path: Path to the file
+        
+    Returns:
+        File contents as string
+        
+    Raises:
+        FileNotFoundError: If file doesn't exist
+        IOError: If file can't be read
+    """
+    path = Path(file_path)
+    if not path.exists():
+        raise FileNotFoundError(f"File not found: {file_path}")
+    
+    return path.read_text(encoding='utf-8')
+
+
+def read_pdf_input(pdf_path: str) -> str:
+    """Read text content from a PDF file.
+    
+    Args:
+        pdf_path: Path to the PDF file
+        
+    Returns:
+        Extracted text from PDF
+        
+    Raises:
+        ImportError: If pypdf is not installed
+        FileNotFoundError: If PDF doesn't exist
+        Exception: If PDF can't be parsed
+    """
+    try:
+        from pypdf import PdfReader
+    except ImportError:
+        raise ImportError(
+            "PDF support requires pypdf. Install with: "
+            "pip install 'claude-dev-cli[generation]'"
+        )
+    
+    path = Path(pdf_path)
+    if not path.exists():
+        raise FileNotFoundError(f"PDF not found: {pdf_path}")
+    
+    try:
+        reader = PdfReader(path)
+        text_parts = []
+        for page in reader.pages:
+            text = page.extract_text()
+            if text:
+                text_parts.append(text)
+        
+        if not text_parts:
+            raise ValueError(f"No text could be extracted from PDF: {pdf_path}")
+        
+        return "\n\n".join(text_parts)
+    except Exception as e:
+        raise Exception(f"Failed to read PDF {pdf_path}: {str(e)}")
+
+
+def read_url_input(url: str) -> str:
+    """Fetch and extract text content from a URL.
+    
+    Args:
+        url: URL to fetch
+        
+    Returns:
+        Extracted text content
+        
+    Raises:
+        ImportError: If requests or beautifulsoup4 are not installed
+        Exception: If URL can't be fetched or parsed
+    """
+    try:
+        import requests
+        from bs4 import BeautifulSoup
+    except ImportError:
+        raise ImportError(
+            "URL support requires requests and beautifulsoup4. Install with: "
+            "pip install 'claude-dev-cli[generation]'"
+        )
+    
+    # Validate URL format
+    if not url.startswith(('http://', 'https://')):
+        raise ValueError(f"Invalid URL format: {url}")
+    
+    try:
+        # Fetch content
+        response = requests.get(url, timeout=30, headers={
+            'User-Agent': 'claude-dev-cli/0.11.0'
+        })
+        response.raise_for_status()
+        
+        # Determine content type
+        content_type = response.headers.get('Content-Type', '').lower()
+        
+        if 'text/plain' in content_type:
+            # Plain text - return as-is
+            return response.text
+        
+        elif 'text/html' in content_type or 'application/xhtml' in content_type:
+            # HTML - extract text
+            soup = BeautifulSoup(response.content, 'html.parser')
+            
+            # Remove script and style elements
+            for script in soup(['script', 'style', 'nav', 'footer', 'header']):
+                script.decompose()
+            
+            # Get text
+            text = soup.get_text(separator='\n', strip=True)
+            
+            # Clean up extra whitespace
+            lines = [line.strip() for line in text.splitlines() if line.strip()]
+            return '\n'.join(lines)
+        
+        elif 'application/json' in content_type:
+            # JSON - return formatted
+            import json
+            return json.dumps(response.json(), indent=2)
+        
+        else:
+            # Unknown content type - try to decode as text
+            return response.text
+    
+    except requests.RequestException as e:
+        raise Exception(f"Failed to fetch URL {url}: {str(e)}")
+    except Exception as e:
+        raise Exception(f"Failed to parse content from {url}: {str(e)}")
+
+
+def get_input_content(
+    description: Optional[str] = None,
+    file_path: Optional[str] = None,
+    pdf_path: Optional[str] = None,
+    url: Optional[str] = None,
+    console: Optional[Console] = None
+) -> Tuple[str, str]:
+    """Get input content from one of the available sources.
+    
+    Args:
+        description: Direct text description
+        file_path: Path to file
+        pdf_path: Path to PDF
+        url: URL to fetch
+        console: Rich console for output
+        
+    Returns:
+        Tuple of (content, source_description)
+        
+    Raises:
+        ValueError: If multiple sources or no sources provided
+        Various exceptions from individual read functions
+    """
+    if console is None:
+        console = Console()
+    
+    # Count how many sources are provided
+    sources = [
+        ('description', description),
+        ('file', file_path),
+        ('pdf', pdf_path),
+        ('url', url)
+    ]
+    provided_sources = [(name, value) for name, value in sources if value]
+    
+    if len(provided_sources) == 0:
+        raise ValueError(
+            "No input source provided. Use one of:\n"
+            "  --description TEXT\n"
+            "  -f/--file PATH\n"
+            "  --pdf PATH\n"
+            "  --url URL"
+        )
+    
+    if len(provided_sources) > 1:
+        source_names = [name for name, _ in provided_sources]
+        raise ValueError(
+            f"Multiple input sources provided: {', '.join(source_names)}. "
+            f"Please use only one."
+        )
+    
+    source_type, source_value = provided_sources[0]
+    
+    # Read from the appropriate source
+    if source_type == 'description':
+        content = read_text_input(source_value)
+        source_desc = "text description"
+    
+    elif source_type == 'file':
+        console.print(f"[cyan]Reading from file:[/cyan] {source_value}")
+        content = read_file_input(source_value)
+        source_desc = f"file: {source_value}"
+    
+    elif source_type == 'pdf':
+        console.print(f"[cyan]Extracting text from PDF:[/cyan] {source_value}")
+        try:
+            content = read_pdf_input(source_value)
+            console.print(f"[green]✓[/green] Extracted {len(content)} characters from PDF")
+            source_desc = f"PDF: {source_value}"
+        except ImportError as e:
+            console.print(f"[red]Error:[/red] {str(e)}")
+            raise
+    
+    elif source_type == 'url':
+        console.print(f"[cyan]Fetching content from URL:[/cyan] {source_value}")
+        try:
+            content = read_url_input(source_value)
+            console.print(f"[green]✓[/green] Fetched {len(content)} characters from URL")
+            source_desc = f"URL: {source_value}"
+        except ImportError as e:
+            console.print(f"[red]Error:[/red] {str(e)}")
+            raise
+    
+    else:
+        raise ValueError(f"Unknown source type: {source_type}")
+    
+    return content, source_desc

claude_dev_cli/multi_file_handler.py

@@ -0,0 +1,348 @@
+"""Multi-file handler for parsing and applying AI-generated file changes."""
+
+import re
+import difflib
+from pathlib import Path
+from typing import List, Tuple, Optional, Literal
+from dataclasses import dataclass
+from rich.console import Console
+from rich.tree import Tree
+from rich.panel import Panel
+
+
+@dataclass
+class FileChange:
+    """Represents a single file change."""
+    path: str
+    content: str
+    change_type: Literal["create", "modify", "delete"]
+    original_content: Optional[str] = None
+    
+    @property
+    def line_count(self) -> int:
+        """Count lines in content."""
+        return len(self.content.splitlines()) if self.content else 0
+    
+    @property
+    def diff(self) -> Optional[str]:
+        """Generate unified diff for modifications."""
+        if self.change_type != "modify" or not self.original_content:
+            return None
+        
+        original_lines = self.original_content.splitlines(keepends=True)
+        new_lines = self.content.splitlines(keepends=True)
+        
+        diff_lines = list(difflib.unified_diff(
+            original_lines,
+            new_lines,
+            fromfile=f"a/{self.path}",
+            tofile=f"b/{self.path}",
+            lineterm=''
+        ))
+        
+        return ''.join(diff_lines) if diff_lines else None
+
+
+class MultiFileResponse:
+    """Parses and handles multi-file AI responses."""
+    
+    def __init__(self):
+        self.files: List[FileChange] = []
+    
+    def parse_response(self, text: str, base_path: Optional[Path] = None) -> None:
+        """Parse AI response to extract file changes.
+        
+        Supports formats:
+        - ## File: path/to/file.ext
+        - ## Create: path/to/file.ext
+        - ## Modify: path/to/file.ext  
+        - ## Delete: path/to/file.ext
+        
+        Args:
+            text: AI response text
+            base_path: Base directory to check for existing files (for modifications)
+        """
+        self.files = []
+        
+        # Pattern to match file markers and code blocks
+        # Matches: ## File: path or ## Create: path or ## Modify: path or ## Delete: path
+        file_pattern = r'^##\s+(File|Create|Modify|Delete):\s*(.+?)$'
+        code_block_pattern = r'```(\w+)?\n(.*?)```'
+        
+        lines = text.split('\n')
+        i = 0
+        
+        while i < len(lines):
+            line = lines[i].strip()
+            match = re.match(file_pattern, line, re.IGNORECASE)
+            
+            if match:
+                action = match.group(1).lower()
+                file_path = match.group(2).strip()
+                
+                # Map actions to change types
+                if action in ('file', 'create'):
+                    change_type = 'create'
+                elif action == 'modify':
+                    change_type = 'modify'
+                elif action == 'delete':
+                    change_type = 'delete'
+                else:
+                    change_type = 'create'
+                
+                # For delete, no content needed
+                if change_type == 'delete':
+                    self.files.append(FileChange(
+                        path=file_path,
+                        content='',
+                        change_type='delete'
+                    ))
+                    i += 1
+                    continue
+                
+                # Extract code block following the file marker
+                remaining_text = '\n'.join(lines[i+1:])
+                code_match = re.search(code_block_pattern, remaining_text, re.DOTALL)
+                
+                if code_match:
+                    content = code_match.group(2).strip()
+                    
+                    # Check if file exists for modifications
+                    original_content = None
+                    if change_type == 'modify' and base_path:
+                        file_full_path = base_path / file_path
+                        if file_full_path.exists():
+                            original_content = file_full_path.read_text()
+                            change_type = 'modify'
+                        else:
+                            # File doesn't exist, treat as create
+                            change_type = 'create'
+                    
+                    self.files.append(FileChange(
+                        path=file_path,
+                        content=content,
+                        change_type=change_type,
+                        original_content=original_content
+                    ))
+                    
+                    # Skip past the code block
+                    lines_used = code_match.group(0).count('\n')
+                    i += lines_used + 1
+                else:
+                    # No code block found, skip this line
+                    i += 1
+            else:
+                i += 1
+    
+    def validate_paths(self, base_path: Path) -> List[str]:
+        """Validate file paths for security.
+        
+        Returns list of validation errors, empty if all valid.
+        """
+        errors = []
+        base_path = base_path.resolve()
+        
+        for file_change in self.files:
+            # Check for absolute paths
+            if Path(file_change.path).is_absolute():
+                errors.append(f"Absolute path not allowed: {file_change.path}")
+                continue
+            
+            # Resolve the path
+            try:
+                full_path = (base_path / file_change.path).resolve()
+                
+                # Check if resolved path is within base_path
+                if not str(full_path).startswith(str(base_path)):
+                    errors.append(f"Path traversal detected: {file_change.path}")
+                    
+            except Exception as e:
+                errors.append(f"Invalid path {file_change.path}: {str(e)}")
+        
+        return errors
+    
+    def build_tree(self, base_path: Path) -> str:
+        """Generate visual directory tree.
+        
+        Returns formatted tree string with colors and status indicators.
+        """
+        if not self.files:
+            return "No files"
+        
+        # Build tree structure
+        tree = Tree(f"[bold cyan]{base_path.name or base_path}/[/bold cyan]")
+        
+        # Group files by directory
+        dirs = {}
+        for file_change in self.files:
+            parts = Path(file_change.path).parts
+            current = dirs
+            
+            for i, part in enumerate(parts[:-1]):
+                if part not in current:
+                    current[part] = {}
+                current = current[part]
+            
+            # Store file info at leaf
+            filename = parts[-1]
+            current[filename] = file_change
+        
+        def add_to_tree(node, items):
+            """Recursively add items to tree."""
+            for name, value in sorted(items.items()):
+                if isinstance(value, dict):
+                    # Directory
+                    branch = node.add(f"[bold blue]{name}/[/bold blue]")
+                    add_to_tree(branch, value)
+                elif isinstance(value, FileChange):
+                    # File
+                    if value.change_type == 'create':
+                        status = "[green](new)[/green]"
+                    elif value.change_type == 'modify':
+                        status = "[yellow](modified)[/yellow]"
+                    elif value.change_type == 'delete':
+                        status = "[red](deleted)[/red]"
+                    else:
+                        status = ""
+                    
+                    lines = f"{value.line_count} lines" if value.line_count > 0 else ""
+                    node.add(f"{name} {status} [dim]{lines}[/dim]")
+        
+        add_to_tree(tree, dirs)
+        
+        return tree
+    
+    def preview(self, console: Console, base_path: Path) -> None:
+        """Show formatted preview with tree and summary."""
+        if not self.files:
+            console.print("[yellow]No files to change[/yellow]")
+            return
+        
+        # Show tree
+        console.print("\n[bold]File Structure:[/bold]")
+        console.print(self.build_tree(base_path))
+        
+        # Summary
+        creates = sum(1 for f in self.files if f.change_type == 'create')
+        modifies = sum(1 for f in self.files if f.change_type == 'modify')
+        deletes = sum(1 for f in self.files if f.change_type == 'delete')
+        total_lines = sum(f.line_count for f in self.files)
+        
+        summary_parts = []
+        if creates:
+            summary_parts.append(f"[green]{creates} created[/green]")
+        if modifies:
+            summary_parts.append(f"[yellow]{modifies} modified[/yellow]")
+        if deletes:
+            summary_parts.append(f"[red]{deletes} deleted[/red]")
+        
+        summary = ", ".join(summary_parts)
+        console.print(f"\n[bold]Summary:[/bold] {summary} ({total_lines} total lines)\n")
+    
+    def write_all(self, base_path: Path, dry_run: bool = False, console: Optional[Console] = None) -> None:
+        """Write all file changes to disk.
+        
+        Args:
+            base_path: Base directory for file operations
+            dry_run: If True, don't actually write files
+            console: Rich console for output
+        """
+        if console is None:
+            console = Console()
+        
+        base_path = base_path.resolve()
+        base_path.mkdir(parents=True, exist_ok=True)
+        
+        for file_change in self.files:
+            full_path = base_path / file_change.path
+            
+            if dry_run:
+                if file_change.change_type == 'create':
+                    console.print(f"[dim]Would create: {file_change.path}[/dim]")
+                elif file_change.change_type == 'modify':
+                    console.print(f"[dim]Would modify: {file_change.path}[/dim]")
+                elif file_change.change_type == 'delete':
+                    console.print(f"[dim]Would delete: {file_change.path}[/dim]")
+                continue
+            
+            # Actual file operations
+            if file_change.change_type == 'delete':
+                if full_path.exists():
+                    full_path.unlink()
+                    console.print(f"[red]✗[/red] Deleted: {file_change.path}")
+            else:
+                # Create parent directories
+                full_path.parent.mkdir(parents=True, exist_ok=True)
+                
+                # Write file
+                full_path.write_text(file_change.content)
+                
+                if file_change.change_type == 'create':
+                    console.print(f"[green]✓[/green] Created: {file_change.path}")
+                elif file_change.change_type == 'modify':
+                    console.print(f"[yellow]✓[/yellow] Modified: {file_change.path}")
+    
+    def confirm(self, console: Console) -> bool:
+        """Interactive confirmation prompt.
+        
+        Returns True if user confirms, False otherwise.
+        """
+        if not self.files:
+            return False
+        
+        while True:
+            response = console.input("\n[cyan]Continue?[/cyan] [dim](Y/n/preview/help)[/dim] ").strip().lower()
+            
+            if response in ('y', 'yes', ''):
+                return True
+            elif response in ('n', 'no'):
+                return False
+            elif response == 'preview':
+                # Show individual file contents
+                for i, file_change in enumerate(self.files, 1):
+                    console.print(f"\n[bold]File {i}/{len(self.files)}:[/bold] {file_change.path}")
+                    
+                    if file_change.change_type == 'delete':
+                        console.print("[red]This file will be deleted[/red]")
+                    elif file_change.change_type == 'modify' and file_change.diff:
+                        console.print("[yellow]Diff:[/yellow]")
+                        console.print(Panel(file_change.diff, border_style="yellow"))
+                    else:
+                        preview = file_change.content[:500]
+                        if len(file_change.content) > 500:
+                            preview += "\n... (truncated)"
+                        console.print(Panel(preview, border_style="green"))
+            elif response == 'help':
+                console.print("""
+[bold]Options:[/bold]
+  y, yes    - Proceed with changes
+  n, no     - Cancel
+  preview   - Show file contents/diffs
+  help      - Show this help
+""")
+            else:
+                console.print("[red]Invalid response. Type 'help' for options.[/red]")
+
+
+def extract_code_blocks(text: str) -> List[Tuple[str, str, str]]:
+    """Extract code blocks from markdown text.
+    
+    Returns list of (file_marker, language, code) tuples.
+    """
+    pattern = r'^##\s+(File|Create|Modify|Delete):\s*(.+?)$.*?```(\w+)?\n(.*?)```'
+    matches = re.findall(pattern, text, re.MULTILINE | re.DOTALL)
+    
+    results = []
+    for match in matches:
+        action = match[0]
+        path = match[1].strip()
+        language = match[2] if match[2] else ''
+        code = match[3].strip()
+        results.append((f"{action}: {path}", language, code))
+    
+    return results
+
+
+def count_lines(content: str) -> int:
+    """Count non-empty lines in content."""
+    return len([line for line in content.splitlines() if line.strip()])

{claude_dev_cli-0.11.0.dist-info → claude_dev_cli-0.12.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-dev-cli
-Version: 0.11.0
+Version: 0.12.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
@@ -33,6 +33,10 @@ Provides-Extra: toon
 Requires-Dist: toon-format>=0.1.0; extra == "toon"
 Provides-Extra: plugins
 Requires-Dist: pygments>=2.0.0; extra == "plugins"
+Provides-Extra: generation
+Requires-Dist: pypdf>=3.0.0; extra == "generation"
+Requires-Dist: requests>=2.28.0; extra == "generation"
+Requires-Dist: beautifulsoup4>=4.0.0; extra == "generation"
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0.0; extra == "dev"
 Requires-Dist: black>=23.0.0; extra == "dev"
@@ -40,13 +44,16 @@ Requires-Dist: ruff>=0.1.0; extra == "dev"
 Requires-Dist: mypy>=1.0.0; extra == "dev"
 Requires-Dist: toon-format>=0.1.0; extra == "dev"
 Requires-Dist: pygments>=2.0.0; extra == "dev"
+Requires-Dist: pypdf>=3.0.0; extra == "dev"
+Requires-Dist: requests>=2.28.0; extra == "dev"
+Requires-Dist: beautifulsoup4>=4.0.0; extra == "dev"
 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-285%20passing-brightgreen.svg)](https://github.com/thinmanj/claude-dev-cli)
+[![Tests](https://img.shields.io/badge/tests-303%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)
@@ -72,6 +79,26 @@ A powerful command-line tool for developers using Claude AI with multi-API routi
   - `smart`: Claude Sonnet 4 ($3.00/$15.00 per Mtok) - default
   - `powerful`: Claude Opus 4 ($15.00/$75.00 per Mtok)
 
+### 🚀 Code Generation (v0.12.0+)
+- **Generate Code from Specs**: Create new code from descriptions, files, PDFs, or URLs
+  - `cdc generate code --description "REST API client" -o client.py`
+  - Multiple input sources: text, files (.md, .txt), PDFs, URLs
+  - Auto-detects target language from file extension
+  - Interactive refinement mode
+- **Add Features to Projects**: Analyze existing code and generate implementation plans
+  - `cdc generate feature --description "Add authentication" src/`
+  - Multi-file analysis and modification
+  - Preview mode to review changes before applying
+  - Supports same input sources as code generation
+- **Multiple Input Sources**:
+  - `--description TEXT`: Inline specification
+  - `-f/--file PATH`: Read from file
+  - `--pdf PATH`: Extract from PDF
+  - `--url URL`: Fetch from URL
+- **Optional Dependencies**: Install with `pip install 'claude-dev-cli[generation]'`
+  - Enables PDF and URL support
+  - Graceful fallback if not installed
+
 ### 📁 Multi-File Support (v0.11.0+)
 - **Batch Processing**: Review, refactor, test, or document multiple files at once
 - **Directory Support**: Process all code files in a directory with `--max-files` limit
@@ -149,8 +176,14 @@ brew install thinmanj/tap/claude-dev-cli
 # Basic installation
 pip install claude-dev-cli
 
+# With code generation support (PDF & URL input)
+pip install claude-dev-cli[generation]
+
 # With TOON support (30-60% token reduction)
 pip install claude-dev-cli[toon]
+
+# With all optional features
+pip install claude-dev-cli[generation,toon]
 ```
 
 ### Via pipx (Recommended for CLI tools)
@@ -159,8 +192,14 @@ pip install claude-dev-cli[toon]
 # Isolated installation
 pipx install claude-dev-cli
 
+# With code generation support
+pipx install claude-dev-cli[generation]
+
 # With TOON support
 pipx install claude-dev-cli[toon]
+
+# With all optional features
+pipx install claude-dev-cli[generation,toon]
 ```
 
 ## Quick Start
@@ -242,7 +281,35 @@ cdc review -m powerful complex_file.py  # More thorough review
 cdc generate tests -m smart mymodule.py  # Balanced approach
 ```
 
-### 3. Developer Commands
+### 3. Code Generation Commands (NEW in v0.12.0)
+
+```bash
+# Generate code from specification
+cdc generate code --description "REST API client for weather data" -o client.py
+cdc generate code --file spec.md -o implementation.go
+cdc generate code --pdf requirements.pdf -o app.js
+cdc generate code --url https://example.com/api-spec -o service.py
+
+# Generate code with interactive refinement
+cdc generate code --description "Database ORM" -o orm.py --interactive
+
+# Generate code with project context
+cdc generate code --file spec.md -o service.py --auto-context
+
+# Add features to existing project
+cdc generate feature --description "Add user authentication with JWT" src/
+cdc generate feature --file feature-spec.md
+cdc generate feature --pdf product-requirements.pdf --preview
+cdc generate feature --url https://example.com/feature-spec
+
+# Preview feature changes before applying
+cdc generate feature --description "Add caching layer" src/ --preview
+
+# Interactive feature implementation
+cdc generate feature --description "Add logging" src/ --interactive
+```
+
+### 4. Developer Commands
 
 ```bash
 # Generate tests (single file)
@@ -316,7 +383,7 @@ git add .
 cdc git commit --auto-context
 ```
 
-### 4. Context-Aware Operations (v0.8.0+)
+### 5. Context-Aware Operations (v0.8.0+)
 
 ```bash
 # Auto-context includes: git info, dependencies, related files
@@ -345,7 +412,7 @@ cdc refactor app.py --auto-context
 # Automatically includes imported modules and dependencies
 ```
 
-### 5. Custom Templates
+### 6. Custom Templates
 
 ```bash
 # List all templates (built-in and user)

{claude_dev_cli-0.11.0.dist-info → claude_dev_cli-0.12.1.dist-info}/RECORD

@@ -1,10 +1,12 @@
-claude_dev_cli/__init__.py,sha256=XSFQv1m1nRRX-T9POeBmjHrA0pylgusfmwtA92XCEzo,470
-claude_dev_cli/cli.py,sha256=RkoR4ocGUfP5A37yl_xObdNdd0QKeyqvEf2YOq1CL0U,79000
+claude_dev_cli/__init__.py,sha256=m4e1TLJ_BCtWjtXr5lJcRupHDnyE30CEI2yqfFmbcWo,470
+claude_dev_cli/cli.py,sha256=GDURdznUC9Dy_B9x8MS-9J3JrMbwiVOofSWHalmsRaU,91797
 claude_dev_cli/commands.py,sha256=RKGx2rv56PM6eErvA2uoQ20hY8babuI5jav8nCUyUOk,3964
 claude_dev_cli/config.py,sha256=ZnPvzwlXsoY9YhqTl4S__fwY1MzJXKIaYK0nIIelNXk,19978
 claude_dev_cli/context.py,sha256=1TlLzpREFZDEIuU7RAtlkjxARKWZpnxHHvK283sUAZE,26714
 claude_dev_cli/core.py,sha256=4tKBgPQzvhM-jtlHaIy2K54vc2yIb4ycNDPLpoIoqN0,6621
 claude_dev_cli/history.py,sha256=26EjNW68JuFQJhUp1j8UdB19S-eYz3eqevkpCOATwP0,10510
+claude_dev_cli/input_sources.py,sha256=pFX5pU8uAUW_iujYdV3z1c_6F0KbKTWMNG0ChvKbxC8,7115
+claude_dev_cli/multi_file_handler.py,sha256=3Rgy9NetKvd4tFhGyeY-44CYApnNShKAEErWOOARrJw,13331
 claude_dev_cli/path_utils.py,sha256=FFwweSkXe9OiG2Dej_UDKcY8-ZCYjL89ow6c7LZGe80,5564
 claude_dev_cli/secure_storage.py,sha256=KcZuQMLTbQpMAi2Cyh-_JkNcK9vHzAITOgjTcM9sr98,8161
 claude_dev_cli/template_manager.py,sha256=wtcrNuxFoJLJIPmIxUzrPKrE8kUvdqEd53EnG3jARhg,9277
@@ -18,9 +20,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.11.0.dist-info/licenses/LICENSE,sha256=DGueuJwMJtMwgLO5mWlS0TaeBrFwQuNpNZ22PU9J2bw,1062
-claude_dev_cli-0.11.0.dist-info/METADATA,sha256=5fvuAb55hqZwnB_j-wzQNFv6ZXZbdnvEbAzt9pvmxtM,21330
-claude_dev_cli-0.11.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-claude_dev_cli-0.11.0.dist-info/entry_points.txt,sha256=zymgUIIVpFTARkFmxAuW2A4BQsNITh_L0uU-XunytHg,85
-claude_dev_cli-0.11.0.dist-info/top_level.txt,sha256=m7MF6LOIuTe41IT5Fgt0lc-DK1EgM4gUU_IZwWxK0pg,15
-claude_dev_cli-0.11.0.dist-info/RECORD,,
+claude_dev_cli-0.12.1.dist-info/licenses/LICENSE,sha256=DGueuJwMJtMwgLO5mWlS0TaeBrFwQuNpNZ22PU9J2bw,1062
+claude_dev_cli-0.12.1.dist-info/METADATA,sha256=HGhP9cVZEsXsOH9hhtZXRhjfqWrQvsdlxUcWAvzEZgU,24018
+claude_dev_cli-0.12.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+claude_dev_cli-0.12.1.dist-info/entry_points.txt,sha256=zymgUIIVpFTARkFmxAuW2A4BQsNITh_L0uU-XunytHg,85
+claude_dev_cli-0.12.1.dist-info/top_level.txt,sha256=m7MF6LOIuTe41IT5Fgt0lc-DK1EgM4gUU_IZwWxK0pg,15
+claude_dev_cli-0.12.1.dist-info/RECORD,,