claude-dev-cli 0.13.0__py3-none-any.whl → 0.13.3__py3-none-any.whl

claude_dev_cli/__init__.py

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

claude_dev_cli/cli.py

@@ -1270,7 +1270,7 @@ Use proper directory structure and include proper error handling, documentation,
             
             # Confirm or auto-accept
             if not yes and not dry_run:
-                if not multi_file.confirm(console):
+                if not multi_file.confirm(console, output_path):
                     console.print("[yellow]Cancelled[/yellow]")
                     return
             
@@ -1489,7 +1489,7 @@ def gen_feature(
         
         # Confirm or auto-accept
         if not yes:
-            if not multi_file.confirm(console):
+            if not multi_file.confirm(console, base_path):
                 console.print("[yellow]Cancelled[/yellow]")
                 return
         
@@ -1855,7 +1855,7 @@ def refactor(
             
             # Confirm or auto-accept
             if not yes:
-                if not multi_file.confirm(console):
+                if not multi_file.confirm(console, base_path):
                     console.print("[yellow]Cancelled[/yellow]")
                     return
             

claude_dev_cli/multi_file_handler.py

@@ -3,11 +3,50 @@
 import re
 import difflib
 from pathlib import Path
-from typing import List, Tuple, Optional, Literal
-from dataclasses import dataclass
+from typing import List, Tuple, Optional, Literal, Dict, Any
+from dataclasses import dataclass, field
 from rich.console import Console
 from rich.tree import Tree
 from rich.panel import Panel
+from rich.syntax import Syntax
+from io import StringIO
+
+try:
+    from unidiff import PatchSet
+    UNIDIFF_AVAILABLE = True
+except ImportError:
+    UNIDIFF_AVAILABLE = False
+
+
+@dataclass
+class HunkWrapper:
+    """Wrapper around unidiff.Hunk with approval state."""
+    hunk: Any  # unidiff.Hunk
+    approved: bool = False
+    
+    @property
+    def source_start(self) -> int:
+        """Get source start line number."""
+        return self.hunk.source_start if hasattr(self.hunk, 'source_start') else 0
+    
+    @property
+    def source_length(self) -> int:
+        """Get source length."""
+        return self.hunk.source_length if hasattr(self.hunk, 'source_length') else 0
+    
+    @property
+    def target_start(self) -> int:
+        """Get target start line number."""
+        return self.hunk.target_start if hasattr(self.hunk, 'target_start') else 0
+    
+    @property
+    def target_length(self) -> int:
+        """Get target length."""
+        return self.hunk.target_length if hasattr(self.hunk, 'target_length') else 0
+    
+    def __str__(self) -> str:
+        """Format hunk as unified diff text."""
+        return str(self.hunk)
 
 
 @dataclass
@@ -17,6 +56,7 @@ class FileChange:
     content: str
     change_type: Literal["create", "modify", "delete"]
     original_content: Optional[str] = None
+    hunks: List[HunkWrapper] = field(default_factory=list)
     
     @property
     def line_count(self) -> int:
@@ -36,11 +76,83 @@ class FileChange:
             original_lines,
             new_lines,
             fromfile=f"a/{self.path}",
-            tofile=f"b/{self.path}",
-            lineterm=''
+            tofile=f"b/{self.path}"
         ))
         
         return ''.join(diff_lines) if diff_lines else None
+    
+    def parse_hunks(self) -> None:
+        """Parse diff into individual hunks using unidiff library."""
+        if self.change_type != "modify" or not self.diff:
+            return
+        
+        if not UNIDIFF_AVAILABLE:
+            # Fallback: no hunk parsing available
+            self.hunks = []
+            return
+        
+        self.hunks = []
+        
+        try:
+            # Parse the diff with unidiff
+            patch = PatchSet(StringIO(self.diff))
+            
+            # Extract all hunks from all patched files
+            for patched_file in patch:
+                for hunk in patched_file:
+                    self.hunks.append(HunkWrapper(hunk=hunk, approved=False))
+                    
+        except Exception:
+            # If unidiff fails, fall back to empty hunks list
+            self.hunks = []
+    
+    def apply_approved_hunks(self) -> str:
+        """Apply only approved hunks using unidiff's line access methods."""
+        if self.change_type != "modify" or not self.original_content:
+            return self.content
+        
+        # If no hunks parsed, caller decides what to do
+        # In write_all, we check if hunks exist before calling this
+        if not self.hunks:
+            return self.content
+        
+        # If no hunks approved, return original
+        if not any(h.approved for h in self.hunks):
+            return self.original_content
+        
+        # If all hunks approved, return new content
+        if all(h.approved for h in self.hunks):
+            return self.content
+        
+        # Apply only approved hunks
+        original_lines = self.original_content.splitlines(keepends=True)
+        result_lines = original_lines.copy()
+        
+        # Sort hunks by position (reversed for bottom-up application)
+        sorted_hunks = sorted(
+            [h for h in self.hunks if h.approved],
+            key=lambda h: h.source_start,
+            reverse=True
+        )
+        
+        for wrapper in sorted_hunks:
+            hunk = wrapper.hunk
+            
+            # Calculate indices for replacement
+            start_idx = wrapper.source_start - 1
+            end_idx = start_idx + wrapper.source_length
+            
+            # Extract new lines using unidiff's line iteration
+            new_lines = []
+            for line in hunk:
+                if line.is_added or line.is_context:
+                    # Get line value (already includes newline)
+                    new_lines.append(line.value)
+            
+            # Replace section
+            result_lines[start_idx:end_idx] = new_lines
+        
+        return ''.join(result_lines)
 
 
 class MultiFileResponse:
@@ -254,13 +366,25 @@ class MultiFileResponse:
         base_path.mkdir(parents=True, exist_ok=True)
         
         for file_change in self.files:
+            # Skip files marked for skipping
+            if hasattr(file_change, 'change_type') and file_change.change_type == 'skip':
+                continue
+            
+            # Skip empty content for create (marked as rejected)
+            if file_change.change_type == 'create' and not file_change.content:
+                continue
+            
             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]")
+                    if file_change.hunks and any(h.approved for h in file_change.hunks):
+                        approved_count = sum(1 for h in file_change.hunks if h.approved)
+                        console.print(f"[dim]Would modify: {file_change.path} ({approved_count}/{len(file_change.hunks)} hunks)[/dim]")
+                    else:
+                        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
@@ -274,29 +398,60 @@ class MultiFileResponse:
                 # 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}")
+                # For modify with hunks, apply only approved hunks
+                if file_change.change_type == 'modify' and file_change.hunks:
+                    # Only write if at least one hunk is approved
+                    if not any(h.approved for h in file_change.hunks):
+                        console.print(f"[dim]Skipped: {file_change.path} (no hunks approved)[/dim]")
+                        continue
+                    
+                    content_to_write = file_change.apply_approved_hunks()
+                    full_path.write_text(content_to_write)
+                    approved_count = sum(1 for h in file_change.hunks if h.approved)
+                    console.print(f"[yellow]✓[/yellow] Modified: {file_change.path} ({approved_count}/{len(file_change.hunks)} hunks)")
+                else:
+                    # Write file normally (no hunks or create operation)
+                    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:
+    def confirm(self, console: Console, base_path: Optional[Path] = None) -> bool:
         """Interactive confirmation prompt.
         
+        Args:
+            console: Rich console for output
+            base_path: Base directory for file operations (needed for edit/save)
+        
         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()
+            response = console.input("\n[cyan]Continue?[/cyan] [dim](Y/n/preview/patch/edit/save/help)[/dim] ").strip().lower()
             
             if response in ('y', 'yes', ''):
                 return True
             elif response in ('n', 'no'):
                 return False
+            elif response == 'patch':
+                # Use hunk-by-hunk confirmation
+                return self.confirm_with_hunks(console)
+            elif response == 'edit':
+                # Open files in editor for manual editing
+                if base_path:
+                    self._edit_files(console, base_path)
+                else:
+                    console.print("[red]Edit not available (no base path provided)[/red]")
+            elif response == 'save':
+                # Save to custom location
+                if base_path:
+                    return self._save_to_location(console, base_path)
+                else:
+                    console.print("[red]Save not available (no base path provided)[/red]")
             elif response == 'preview':
                 # Show individual file contents
                 for i, file_change in enumerate(self.files, 1):
@@ -315,13 +470,242 @@ class MultiFileResponse:
             elif response == 'help':
                 console.print("""
 [bold]Options:[/bold]
-  y, yes    - Proceed with changes
-  n, no     - Cancel
+  y, yes    - Proceed with all changes
+  n, no     - Cancel all changes
+  patch     - Review changes hunk-by-hunk (like git add -p)
+  edit      - Open files in $EDITOR before applying
+  save      - Save to custom location/filename
   preview   - Show file contents/diffs
   help      - Show this help
 """)
             else:
                 console.print("[red]Invalid response. Type 'help' for options.[/red]")
+    
+    def confirm_with_hunks(self, console: Console) -> bool:
+        """Interactive hunk-by-hunk confirmation (like git add -p).
+        
+        Returns True if at least some changes approved, False if all cancelled.
+        """
+        if not self.files:
+            return False
+        
+        # Parse hunks for all modify operations
+        for file_change in self.files:
+            if file_change.change_type == 'modify':
+                file_change.parse_hunks()
+        
+        has_any_approval = False
+        
+        for file_change in self.files:
+            console.print(f"\n[bold cyan]File:[/bold cyan] {file_change.path}")
+            
+            if file_change.change_type == 'create':
+                console.print(f"[green]Create new file ({file_change.line_count} lines)[/green]")
+                response = self._ask_file_action(console, "create")
+                if response == 'y':
+                    # Mark as approved (keep as-is)
+                    has_any_approval = True
+                elif response == 'n':
+                    # Remove from files list
+                    file_change.content = ''  # Mark for skip
+                elif response == 'q':
+                    return has_any_approval
+                    
+            elif file_change.change_type == 'delete':
+                console.print("[red]Delete file[/red]")
+                response = self._ask_file_action(console, "delete")
+                if response == 'y':
+                    has_any_approval = True
+                elif response == 'n':
+                    file_change.change_type = 'skip'  # Mark for skip
+                elif response == 'q':
+                    return has_any_approval
+                    
+            elif file_change.change_type == 'modify':
+                if not file_change.hunks:
+                    console.print("[yellow]No hunks to review[/yellow]")
+                    continue
+                
+                console.print(f"[yellow]Modify file ({len(file_change.hunks)} hunk(s))[/yellow]")
+                
+                for hunk_idx, hunk in enumerate(file_change.hunks, 1):
+                    console.print(f"\n[bold]Hunk {hunk_idx}/{len(file_change.hunks)}:[/bold]")
+                    
+                    # Show hunk with syntax highlighting
+                    hunk_text = str(hunk)
+                    console.print(Panel(
+                        Syntax(hunk_text, "diff", theme="monokai", line_numbers=False),
+                        border_style="yellow",
+                        title=f"[bold]{file_change.path}[/bold]"
+                    ))
+                    
+                    while True:
+                        response = console.input(
+                            "[cyan]Apply this hunk?[/cyan] [dim](y/n/s=skip file/q=quit/help)[/dim] "
+                        ).strip().lower()
+                        
+                        if response in ('y', 'yes', ''):
+                            hunk.approved = True
+                            has_any_approval = True
+                            break
+                        elif response in ('n', 'no'):
+                            hunk.approved = False
+                            break
+                        elif response in ('s', 'skip'):
+                            # Skip remaining hunks in this file
+                            break
+                        elif response in ('q', 'quit'):
+                            return has_any_approval
+                        elif response == 'help':
+                            console.print("""
+[bold]Hunk Options:[/bold]
+  y, yes   - Apply this hunk
+  n, no    - Skip this hunk
+  s, skip  - Skip remaining hunks in this file
+  q, quit  - Quit and apply approved hunks so far
+  help     - Show this help
+""")
+                        else:
+                            console.print("[red]Invalid response. Type 'help' for options.[/red]")
+                    
+                    if response in ('s', 'skip'):
+                        break
+        
+        return has_any_approval
+    
+    def _ask_file_action(self, console: Console, action: str) -> str:
+        """Ask for confirmation on file-level action.
+        
+        Returns: 'y' (yes), 'n' (no), 's' (skip), 'q' (quit)
+        """
+        while True:
+            response = console.input(
+                f"[cyan]{action.capitalize()} this file?[/cyan] [dim](y/n/s=skip/q=quit)[/dim] "
+            ).strip().lower()
+            
+            if response in ('y', 'yes', 'n', 'no', 's', 'skip', 'q', 'quit', ''):
+                if response == '':
+                    return 'y'
+                if response in ('skip',):
+                    return 's'
+                if response in ('quit',):
+                    return 'q'
+                return response[0]  # Return first character
+            else:
+                console.print("[red]Invalid response. Use y/n/s/q[/red]")
+    
+    def _edit_files(self, console: Console, base_path: Path) -> None:
+        """Open files in editor for manual editing before applying.
+        
+        Args:
+            console: Rich console for output
+            base_path: Base directory for file operations
+        """
+        import os
+        import subprocess
+        import tempfile
+        
+        editor = os.environ.get('EDITOR', 'vi')
+        
+        console.print(f"\n[cyan]Opening files in {editor}...[/cyan]")
+        console.print("[dim]Save and close editor to continue[/dim]\n")
+        
+        for file_change in self.files:
+            if file_change.change_type == 'delete':
+                console.print(f"[dim]Skipping delete operation: {file_change.path}[/dim]")
+                continue
+            
+            # Write content to temp file
+            with tempfile.NamedTemporaryFile(mode='w', suffix=f'_{Path(file_change.path).name}', delete=False) as tf:
+                tf.write(file_change.content)
+                temp_path = tf.name
+            
+            try:
+                console.print(f"[bold]Editing:[/bold] {file_change.path}")
+                
+                # Open in editor
+                result = subprocess.run([editor, temp_path])
+                
+                if result.returncode == 0:
+                    # Read edited content
+                    with open(temp_path, 'r') as f:
+                        edited_content = f.read()
+                    
+                    # Update file change with edited content
+                    file_change.content = edited_content
+                    console.print(f"[green]✓[/green] Updated: {file_change.path}")
+                else:
+                    console.print(f"[yellow]Editor exited with error, keeping original content[/yellow]")
+            finally:
+                # Clean up temp file
+                try:
+                    os.unlink(temp_path)
+                except:
+                    pass
+        
+        console.print("\n[green]Editing complete![/green]")
+    
+    def _save_to_location(self, console: Console, base_path: Path) -> bool:
+        """Save files to custom location.
+        
+        Args:
+            console: Rich console for output
+            base_path: Base directory for file operations
+        
+        Returns: True if saved successfully, False otherwise
+        """
+        console.print("\n[cyan]Save options:[/cyan]")
+        
+        if len(self.files) == 1:
+            # Single file - ask for filename
+            console.print("[dim]Enter filename (or path) to save to:[/dim]")
+            filename = console.input("[cyan]Filename:[/cyan] ").strip()
+            
+            if not filename:
+                console.print("[yellow]Cancelled[/yellow]")
+                return False
+            
+            save_path = Path(filename)
+            if not save_path.is_absolute():
+                save_path = base_path / save_path
+            
+            # Create parent directories
+            save_path.parent.mkdir(parents=True, exist_ok=True)
+            
+            # Write file
+            file_change = self.files[0]
+            save_path.write_text(file_change.content)
+            console.print(f"[green]✓[/green] Saved to: {save_path}")
+            return False  # Don't continue with original write
+        else:
+            # Multiple files - ask for directory
+            console.print(f"[dim]Enter directory to save {len(self.files)} file(s) to:[/dim]")
+            dirname = console.input("[cyan]Directory:[/cyan] ").strip()
+            
+            if not dirname:
+                console.print("[yellow]Cancelled[/yellow]")
+                return False
+            
+            save_dir = Path(dirname)
+            if not save_dir.is_absolute():
+                save_dir = base_path / save_dir
+            
+            # Create directory
+            save_dir.mkdir(parents=True, exist_ok=True)
+            
+            # Write all files
+            for file_change in self.files:
+                if file_change.change_type == 'delete':
+                    console.print(f"[dim]Skipping delete operation: {file_change.path}[/dim]")
+                    continue
+                
+                file_path = save_dir / file_change.path
+                file_path.parent.mkdir(parents=True, exist_ok=True)
+                file_path.write_text(file_change.content)
+                console.print(f"[green]✓[/green] Saved: {file_path}")
+            
+            console.print(f"\n[green]All files saved to: {save_dir}[/green]")
+            return False  # Don't continue with original write
 
 
 def extract_code_blocks(text: str) -> List[Tuple[str, str, str]]:

{claude_dev_cli-0.13.0.dist-info → claude_dev_cli-0.13.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-dev-cli
-Version: 0.13.0
+Version: 0.13.3
 Summary: A powerful CLI tool for developers using Claude AI with multi-API routing, test generation, code review, and usage tracking
 Author-email: Julio <thinmanj@users.noreply.github.com>
 License: MIT
@@ -29,6 +29,7 @@ Requires-Dist: pydantic>=2.0.0
 Requires-Dist: keyring>=24.0.0
 Requires-Dist: cryptography>=41.0.0
 Requires-Dist: pyyaml>=6.0.0
+Requires-Dist: unidiff>=0.7.0
 Provides-Extra: toon
 Requires-Dist: toon-format>=0.1.0; extra == "toon"
 Provides-Extra: plugins
@@ -315,8 +316,108 @@ cdc generate feature --file spec.md --yes  # Apply without confirmation
 
 # Interactive feature implementation
 cdc generate feature --description "Add logging" src/ --interactive
+
+# Hunk-by-hunk approval (like git add -p) - NEW in v0.13.1
+cdc generate feature -f spec.md
+# At confirmation prompt, type 'patch' to review changes hunk-by-hunk
+# Options: y (yes), n (no), s (skip file), q (quit), help
+```
+
+### 3.1 Interactive Diff Approval (v0.13.1+)
+
+When applying file modifications, you can review and approve changes hunk-by-hunk, similar to `git add -p`:
+
+```bash
+# After generating feature/refactor changes:
+cdc generate feature -f spec.md
+
+# At the confirmation prompt:
+Continue? (Y/n/preview/patch/help) patch
+
+# For each file:
+File: src/main.py
+Modify file (3 hunk(s))
+
+Hunk 1/3:
+[Shows diff with syntax highlighting]
+@@ -10,3 +10,5 @@
+ def main():
+-    print("old")
++    print("new")
++    logging.info("Started")
+
+Apply this hunk? (y/n/s=skip file/q=quit/help) y  # Approve this hunk
+
+Hunk 2/3:
+[Shows next diff]
+Apply this hunk? (y/n/s=skip file/q=quit/help) n  # Skip this hunk
+
+Hunk 3/3:
+[Shows final diff]
+Apply this hunk? (y/n/s=skip file/q=quit/help) s  # Skip remaining in file
+
+# File operations options:
+Create this file? (y/n/s=skip/q=quit) y  # For new files
+Delete this file? (y/n/s=skip/q=quit) n  # For file deletions
+```
+
+**Options:**
+- `y, yes` - Apply this hunk/file
+- `n, no` - Skip this hunk (keeps original)
+- `s, skip` - Skip remaining hunks in current file
+- `q, quit` - Stop reviewing and apply approved changes so far
+- `edit` - Open files in $EDITOR before applying
+- `save` - Save to custom location
+- `help` - Show help message
+
+**Benefits:**
+- Fine-grained control over changes
+- Keep original code for some hunks while applying others
+- Syntax-highlighted diffs for easy review
+- Edit files before applying for manual tweaks
+- Save to custom location without -o flag
+- Safe: only approved hunks are written
+
+### 3.2 Edit and Save Options (v0.13.2+)
+
+Before applying changes, you can edit files or save to custom locations:
+
+#### Edit in $EDITOR
+```bash
+cdc generate feature -f spec.md
+
+# At confirmation:
+Continue? (Y/n/preview/patch/edit/save/help) edit
+
+# Opens each file in your $EDITOR (vi, nano, code, etc.)
+# Make manual adjustments, save and close
+# Changes are applied after editing
 ```
 
+#### Save to Custom Location
+```bash
+cdc generate code -d "REST API" -o /tmp/output
+
+# At confirmation:
+Continue? (Y/n/preview/patch/edit/save/help) save
+
+# Single file:
+Filename: my-custom-name.py  # Save to custom filename
+
+# Multiple files:
+Directory: /path/to/output/  # Save entire project elsewhere
+```
+
+**Use Cases:**
+- **Edit**: Make manual tweaks before applying (fix formatting, adjust logic)
+- **Save**: Try changes elsewhere before applying to project
+- **Edit + Preview**: Review, edit, then apply with confidence
+- **Save for later**: Generate code, save it, review offline, apply manually
+
+**Environment Variables:**
+- `$EDITOR`: Your preferred editor (e.g., `export EDITOR=nano`)
+- Defaults to `vi` if `$EDITOR` not set
+
 ### 4. Developer Commands
 
 ```bash

{claude_dev_cli-0.13.0.dist-info → claude_dev_cli-0.13.3.dist-info}/RECORD

@@ -1,12 +1,12 @@
-claude_dev_cli/__init__.py,sha256=m1PPg9TBL_opaZdRHkV3d_MDa4IFCPqCFE0KUyBlpVg,470
-claude_dev_cli/cli.py,sha256=pIIZv3AT0gCF4faTVSlY_d6F-ya9L3gYoVeUTlq07VY,100412
+claude_dev_cli/__init__.py,sha256=ouhf-Bq_KvlUTS5g2fBYhDTVnw6j58pIS02Nrr91GbE,470
+claude_dev_cli/cli.py,sha256=q_vAEQrY52J5kQJCfm-jqD0ygRDnCc2eR_7NCVz1fJo,100447
 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/multi_file_handler.py,sha256=QU0M7X8g-5e1A6UwVISJNmQqSZ9GUGkeBlMe3d0vb-M,29364
 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
@@ -20,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.13.0.dist-info/licenses/LICENSE,sha256=DGueuJwMJtMwgLO5mWlS0TaeBrFwQuNpNZ22PU9J2bw,1062
-claude_dev_cli-0.13.0.dist-info/METADATA,sha256=vzv4dlBOqJ5Y-tz6OgcafaMq1ponwWgYdVhZIkYD13U,24788
-claude_dev_cli-0.13.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-claude_dev_cli-0.13.0.dist-info/entry_points.txt,sha256=zymgUIIVpFTARkFmxAuW2A4BQsNITh_L0uU-XunytHg,85
-claude_dev_cli-0.13.0.dist-info/top_level.txt,sha256=m7MF6LOIuTe41IT5Fgt0lc-DK1EgM4gUU_IZwWxK0pg,15
-claude_dev_cli-0.13.0.dist-info/RECORD,,
+claude_dev_cli-0.13.3.dist-info/licenses/LICENSE,sha256=DGueuJwMJtMwgLO5mWlS0TaeBrFwQuNpNZ22PU9J2bw,1062
+claude_dev_cli-0.13.3.dist-info/METADATA,sha256=JmMfGjBrcLRx_mvHHLPJ5kUo9Qp1evnEo_N0OVFWvZ8,27704
+claude_dev_cli-0.13.3.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+claude_dev_cli-0.13.3.dist-info/entry_points.txt,sha256=zymgUIIVpFTARkFmxAuW2A4BQsNITh_L0uU-XunytHg,85
+claude_dev_cli-0.13.3.dist-info/top_level.txt,sha256=m7MF6LOIuTe41IT5Fgt0lc-DK1EgM4gUU_IZwWxK0pg,15
+claude_dev_cli-0.13.3.dist-info/RECORD,,