claude-dev-cli 0.2.0__py3-none-any.whl → 0.3.1__py3-none-any.whl

claude_dev_cli/cli.py

@@ -22,6 +22,7 @@ from claude_dev_cli.commands import (
 )
 from claude_dev_cli.usage import UsageTracker
 from claude_dev_cli import toon_utils
+from claude_dev_cli.plugins import load_plugins
 
 console = Console()
 
@@ -35,6 +36,17 @@ def main(ctx: click.Context) -> None:
     ctx.obj['console'] = console
 
 
+# Load plugins after main group is defined
+# Silently load plugins - they'll register their commands
+try:
+    plugins = load_plugins()
+    for plugin in plugins:
+        plugin.register_commands(main)
+except Exception:
+    # Don't fail if plugins can't load - continue without them
+    pass
+
+
 @main.command()
 @click.argument('prompt', required=False)
 @click.option('-f', '--file', type=click.Path(exists=True), help='Include file content in prompt')

claude_dev_cli/config.py

@@ -28,15 +28,15 @@ class ProjectProfile(BaseModel):
 class Config:
     """Manages configuration for Claude Dev CLI."""
     
-    CONFIG_DIR = Path.home() / ".claude-dev-cli"
-    CONFIG_FILE = CONFIG_DIR / "config.json"
-    USAGE_LOG = CONFIG_DIR / "usage.jsonl"
-    
     def __init__(self) -> None:
         """Initialize configuration."""
-        self.config_dir = self.CONFIG_DIR
-        self.config_file = self.CONFIG_FILE
-        self.usage_log = self.USAGE_LOG
+        # Determine home directory (respects HOME env var for testing)
+        home = Path(os.environ.get("HOME", str(Path.home())))
+        
+        self.config_dir = home / ".claude-dev-cli"
+        self.config_file = self.config_dir / "config.json"
+        self.usage_log = self.config_dir / "usage.jsonl"
+        
         self._ensure_config_dir()
         self._data: Dict = self._load_config()
     

claude_dev_cli/core.py

@@ -13,13 +13,21 @@ class ClaudeClient:
     """Claude API client with multi-key routing and usage tracking."""
     
     def __init__(self, config: Optional[Config] = None, api_config_name: Optional[str] = None):
-        """Initialize Claude client."""
+        """Initialize Claude client.
+        
+        API routing hierarchy (highest to lowest priority):
+        1. Explicit api_config_name parameter
+        2. Project-specific .claude-dev-cli file
+        3. Default API config
+        """
         self.config = config or Config()
         
-        # Determine which API config to use
-        project_profile = self.config.get_project_profile()
-        if project_profile:
-            api_config_name = project_profile.api_config
+        # Determine which API config to use based on hierarchy
+        if not api_config_name:
+            # Check for project profile if no explicit config provided
+            project_profile = self.config.get_project_profile()
+            if project_profile:
+                api_config_name = project_profile.api_config
         
         self.api_config = self.config.get_api_config(api_config_name)
         if not self.api_config:

claude_dev_cli/plugins/__init__.py

@@ -0,0 +1,42 @@
+"""Plugin system for Claude Dev CLI."""
+
+from typing import List
+from pathlib import Path
+import importlib
+import importlib.util
+
+from .base import Plugin
+
+
+def discover_plugins() -> List[Plugin]:
+    """Discover and load all plugins from the plugins directory.
+    
+    Returns:
+        List of loaded plugin instances
+    """
+    plugins = []
+    plugin_dir = Path(__file__).parent
+    
+    # Look for plugin directories (those with plugin.py)
+    for item in plugin_dir.iterdir():
+        if item.is_dir() and (item / "plugin.py").exists() and item.name != "__pycache__":
+            try:
+                # Use proper import instead of spec loading to handle relative imports
+                plugin_module_name = f"claude_dev_cli.plugins.{item.name}.plugin"
+                module = importlib.import_module(plugin_module_name)
+                
+                # Look for plugin registration function
+                if hasattr(module, "register_plugin"):
+                    plugin = module.register_plugin()
+                    plugins.append(plugin)
+            except Exception as e:
+                # Silently skip plugins that fail to load
+                pass
+    
+    return plugins
+
+
+# Alias for backwards compatibility and clearer intent
+load_plugins = discover_plugins
+
+__all__ = ["Plugin", "discover_plugins", "load_plugins"]

claude_dev_cli/plugins/base.py

@@ -0,0 +1,53 @@
+"""Base plugin interface for Claude Dev CLI."""
+
+from abc import ABC, abstractmethod
+from typing import Optional
+import click
+
+
+class Plugin(ABC):
+    """Base class for all plugins."""
+    
+    def __init__(self, name: str, version: str, description: str = ""):
+        """Initialize plugin.
+        
+        Args:
+            name: Plugin name
+            version: Plugin version
+            description: Plugin description
+        """
+        self.name = name
+        self.version = version
+        self.description = description
+    
+    @abstractmethod
+    def register_commands(self, cli: click.Group) -> None:
+        """Register plugin commands with the CLI.
+        
+        Args:
+            cli: Click group to register commands to
+        """
+        pass
+    
+    def before_apply(self, original: str, proposed: str) -> Optional[str]:
+        """Hook called before applying changes.
+        
+        Args:
+            original: Original content
+            proposed: Proposed changes
+            
+        Returns:
+            Modified proposed content or None to keep original
+        """
+        return None
+    
+    def after_apply(self, result: str) -> Optional[str]:
+        """Hook called after applying changes.
+        
+        Args:
+            result: Result after changes applied
+            
+        Returns:
+            Modified result or None to keep original
+        """
+        return None

claude_dev_cli/plugins/diff_editor/__init__.py

@@ -0,0 +1,3 @@
+"""Interactive diff editor plugin for reviewing AI-generated code changes."""
+
+__version__ = "0.1.0"

claude_dev_cli/plugins/diff_editor/plugin.py

@@ -0,0 +1,98 @@
+"""Diff editor plugin registration."""
+
+from pathlib import Path
+from typing import Optional
+
+import click
+from rich.console import Console
+from rich.panel import Panel
+from rich.syntax import Syntax
+
+from claude_dev_cli.plugins.base import Plugin
+from .viewer import DiffViewer
+
+
+class DiffEditorPlugin(Plugin):
+    """Interactive diff editor plugin."""
+    
+    def __init__(self):
+        super().__init__(
+            name="diff-editor",
+            version="0.1.0",
+            description="Interactive diff viewer for reviewing code changes"
+        )
+        self.console = Console()
+    
+    def register_commands(self, cli: click.Group) -> None:
+        """Register diff editor commands."""
+        
+        @cli.command("diff")
+        @click.argument("original", type=click.Path(exists=True))
+        @click.argument("proposed", type=click.Path(exists=True))
+        @click.option(
+            "--keybindings",
+            "-k",
+            type=click.Choice(["nvim", "fresh", "auto"]),
+            default="auto",
+            help="Keybinding mode (nvim, fresh, or auto-detect)"
+        )
+        @click.option(
+            "--output",
+            "-o",
+            type=click.Path(),
+            help="Output file path for accepted changes"
+        )
+        def diff_command(
+            original: str,
+            proposed: str,
+            keybindings: str,
+            output: Optional[str]
+        ) -> None:
+            """Interactively review differences between two files."""
+            viewer = DiffViewer(
+                original_path=Path(original),
+                proposed_path=Path(proposed),
+                keybinding_mode=keybindings,
+                console=self.console
+            )
+            
+            result = viewer.run()
+            
+            if result and output:
+                with open(output, "w") as f:
+                    f.write(result)
+                self.console.print(f"\n[green]✓[/green] Changes saved to: {output}")
+            elif result:
+                self.console.print("\n[bold]Final result:[/bold]")
+                self.console.print(result)
+        
+        @cli.command("apply-diff")
+        @click.argument("file_path", type=click.Path(exists=True))
+        @click.option(
+            "--keybindings",
+            "-k",
+            type=click.Choice(["nvim", "fresh", "auto"]),
+            default="auto",
+            help="Keybinding mode"
+        )
+        @click.option(
+            "--in-place",
+            "-i",
+            is_flag=True,
+            help="Edit file in place"
+        )
+        def apply_diff_command(
+            file_path: str,
+            keybindings: str,
+            in_place: bool
+        ) -> None:
+            """Apply AI-suggested changes to a file interactively."""
+            self.console.print(
+                f"[yellow]This would apply changes to {file_path} interactively[/yellow]"
+            )
+            self.console.print("Feature coming soon!")
+
+
+def register_plugin() -> Plugin:
+    """Register the diff editor plugin."""
+    return DiffEditorPlugin()

claude_dev_cli/plugins/diff_editor/viewer.py

@@ -0,0 +1,367 @@
+"""Interactive diff viewer with multiple keybinding modes."""
+
+import difflib
+from pathlib import Path
+from typing import List, Optional, Tuple
+import os
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.syntax import Syntax
+from rich.table import Table
+from rich.text import Text
+
+try:
+    from pygments import lexers
+    from pygments.util import ClassNotFound
+    PYGMENTS_AVAILABLE = True
+except ImportError:
+    PYGMENTS_AVAILABLE = False
+
+
+class Hunk:
+    """Represents a single diff hunk."""
+    
+    def __init__(
+        self,
+        original_lines: List[str],
+        proposed_lines: List[str],
+        original_start: int,
+        proposed_start: int
+    ):
+        self.original_lines = original_lines
+        self.proposed_lines = proposed_lines
+        self.original_start = original_start
+        self.proposed_start = proposed_start
+        self.accepted = None  # None = undecided, True = accepted, False = rejected
+    
+    def get_context(self) -> str:
+        """Get a brief context description of this hunk."""
+        if self.proposed_lines:
+            first_line = self.proposed_lines[0].strip()
+            return first_line[:50] if len(first_line) > 50 else first_line
+        return "deletion"
+
+
+class DiffViewer:
+    """Interactive diff viewer with multiple keybinding modes."""
+    
+    def __init__(
+        self,
+        original_path: Path,
+        proposed_path: Path,
+        keybinding_mode: str = "auto",
+        console: Optional[Console] = None
+    ):
+        self.original_path = original_path
+        self.proposed_path = proposed_path
+        self.console = console or Console()
+        
+        # Detect keybinding mode
+        if keybinding_mode == "auto":
+            self.keybinding_mode = self._detect_keybinding_mode()
+        else:
+            self.keybinding_mode = keybinding_mode
+        
+        # Load files
+        with open(original_path) as f:
+            self.original_content = f.read()
+            self.original_lines = self.original_content.splitlines(keepends=True)
+        
+        with open(proposed_path) as f:
+            self.proposed_content = f.read()
+            self.proposed_lines = self.proposed_content.splitlines(keepends=True)
+        
+        # Generate hunks
+        self.hunks = self._generate_hunks()
+        self.current_hunk_idx = 0
+        self.filename = proposed_path.name
+        
+        # Detect lexer for syntax highlighting
+        self.lexer_name = self._detect_lexer()
+        
+        # History stack for undo support
+        self.history: List[Tuple[int, Optional[bool]]] = []
+    
+    def _detect_keybinding_mode(self) -> str:
+        """Auto-detect keybinding preference from environment."""
+        # Check if user has vim/nvim in their environment
+        editor = os.environ.get("EDITOR", "").lower()
+        visual = os.environ.get("VISUAL", "").lower()
+        
+        if "vim" in editor or "vim" in visual or "nvim" in editor or "nvim" in visual:
+            return "nvim"
+        return "fresh"
+    
+    def _detect_lexer(self) -> Optional[str]:
+        """Detect appropriate lexer for syntax highlighting based on filename."""
+        if not PYGMENTS_AVAILABLE:
+            return None
+        
+        try:
+            lexer = lexers.get_lexer_for_filename(str(self.proposed_path))
+            return lexer.name
+        except ClassNotFound:
+            return None
+    
+    def _generate_hunks(self) -> List[Hunk]:
+        """Generate hunks from diff."""
+        hunks = []
+        differ = difflib.Differ()
+        diff = list(differ.compare(self.original_lines, self.proposed_lines))
+        
+        i = 0
+        while i < len(diff):
+            # Find start of a hunk (lines that differ)
+            while i < len(diff) and diff[i].startswith("  "):
+                i += 1
+            
+            if i >= len(diff):
+                break
+            
+            # Collect the hunk
+            original_lines = []
+            proposed_lines = []
+            original_start = i
+            proposed_start = i
+            
+            while i < len(diff) and not diff[i].startswith("  "):
+                line = diff[i]
+                if line.startswith("- "):
+                    original_lines.append(line[2:])
+                elif line.startswith("+ "):
+                    proposed_lines.append(line[2:])
+                elif line.startswith("? "):
+                    # Skip hint lines
+                    pass
+                i += 1
+            
+            if original_lines or proposed_lines:
+                hunks.append(Hunk(
+                    original_lines,
+                    proposed_lines,
+                    original_start,
+                    proposed_start
+                ))
+        
+        return hunks
+    
+    def _get_keybindings(self) -> dict:
+        """Get keybindings based on mode."""
+        if self.keybinding_mode == "nvim":
+            return {
+                "accept": ["y", "a"],
+                "reject": ["n", "d"],
+                "edit": ["e", "c"],
+                "split": ["s"],
+                "quit": ["q", "ZZ"],
+                "accept_all": ["A"],
+                "reject_all": ["D"],
+                "undo": ["u"],
+                "help": ["?", "h"],
+                "next": ["j", "n"],
+                "prev": ["k", "p"],
+                "goto_first": ["gg"],
+                "goto_last": ["G"],
+            }
+        else:  # fresh mode
+            return {
+                "accept": ["y", "Enter"],
+                "reject": ["n", "Backspace"],
+                "edit": ["e"],
+                "split": ["s"],
+                "quit": ["q", "Esc"],
+                "accept_all": ["Ctrl-A"],
+                "reject_all": ["Ctrl-R"],
+                "undo": ["Ctrl-Z"],
+                "help": ["F1", "?"],
+                "next": ["Down", "j"],
+                "prev": ["Up", "k"],
+                "goto_first": ["Home"],
+                "goto_last": ["End"],
+            }
+    
+    def _show_help(self) -> None:
+        """Display help panel."""
+        kb = self._get_keybindings()
+        mode_name = "Neovim" if self.keybinding_mode == "nvim" else "Fresh"
+        
+        table = Table(title=f"{mode_name} Keybindings", show_header=True)
+        table.add_column("Action", style="cyan")
+        table.add_column("Keys", style="green")
+        
+        table.add_row("Accept hunk", " or ".join(kb["accept"]))
+        table.add_row("Reject hunk", " or ".join(kb["reject"]))
+        table.add_row("Edit hunk", " or ".join(kb["edit"]))
+        table.add_row("Split hunk", " or ".join(kb["split"]))
+        table.add_row("Next hunk", " or ".join(kb["next"]))
+        table.add_row("Previous hunk", " or ".join(kb["prev"]))
+        table.add_row("Accept all", " or ".join(kb["accept_all"]))
+        table.add_row("Reject all", " or ".join(kb["reject_all"]))
+        table.add_row("Undo", " or ".join(kb["undo"]))
+        table.add_row("Quit", " or ".join(kb["quit"]))
+        table.add_row("Help", " or ".join(kb["help"]))
+        
+        self.console.print(table)
+        self.console.print("\n[dim]Press any key to continue...[/dim]")
+        self.console.input()
+    
+    def _display_hunk(self, hunk: Hunk) -> None:
+        """Display a single hunk with syntax highlighting."""
+        self.console.clear()
+        
+        # Title
+        mode_indicator = "🎹 Neovim" if self.keybinding_mode == "nvim" else "✨ Fresh"
+        self.console.print(
+            Panel(
+                f"{mode_indicator} Mode | {self.filename}",
+                title=f"Hunk {self.current_hunk_idx + 1}/{len(self.hunks)}",
+                border_style="blue"
+            )
+        )
+        
+        # Show original (if any deletions)
+        if hunk.original_lines:
+            self.console.print("\n[bold red]━━━ Original (-):[/bold red]")
+            code = "".join(hunk.original_lines)
+            if self.lexer_name and code.strip():
+                syntax = Syntax(code, self.lexer_name, theme="monokai", line_numbers=False)
+                # Wrap in red for deletions
+                for line in code.splitlines():
+                    self.console.print(f"[red]- {line}[/red]")
+            else:
+                for line in hunk.original_lines:
+                    self.console.print(f"[red]- {line}[/red]", end="")
+        
+        # Show proposed (if any additions)
+        if hunk.proposed_lines:
+            self.console.print("\n[bold green]━━━ Proposed (+):[/bold green]")
+            code = "".join(hunk.proposed_lines)
+            if self.lexer_name and code.strip():
+                syntax = Syntax(code, self.lexer_name, theme="monokai", line_numbers=False)
+                # Wrap in green for additions
+                for line in code.splitlines():
+                    self.console.print(f"[green]+ {line}[/green]")
+            else:
+                for line in hunk.proposed_lines:
+                    self.console.print(f"[green]+ {line}[/green]", end="")
+        
+        # Context
+        context = hunk.get_context()
+        self.console.print(f"\n[dim]Context: {context}[/dim]")
+        
+        # Status
+        status = "✓ Accepted" if hunk.accepted is True else "✗ Rejected" if hunk.accepted is False else "? Undecided"
+        self.console.print(f"Status: {status}\n")
+    
+    def _show_prompt(self) -> None:
+        """Show action prompt based on keybinding mode."""
+        kb = self._get_keybindings()
+        
+        if self.keybinding_mode == "nvim":
+            prompt = (
+                f"[cyan][y]es [n]o [e]dit [s]plit | "
+                f"[j]next [k]prev [q]uit [?]help[/cyan]"
+            )
+        else:  # fresh
+            prompt = (
+                f"[cyan][y]es [n]o [e]dit [s]plit | "
+                f"[↓]next [↑]prev [q]uit [?]help[/cyan]"
+            )
+        
+        self.console.print(prompt)
+    
+    def run(self) -> Optional[str]:
+        """Run the interactive diff viewer.
+        
+        Returns:
+            Final content with accepted changes or None if cancelled
+        """
+        if not self.hunks:
+            self.console.print("[yellow]No differences found[/yellow]")
+            return self.original_content
+        
+        # Show initial help
+        self._show_help()
+        
+        while self.current_hunk_idx < len(self.hunks):
+            hunk = self.hunks[self.current_hunk_idx]
+            self._display_hunk(hunk)
+            self._show_prompt()
+            
+            # Get user input
+            choice = self.console.input("\nYour choice: ").strip().lower()
+            
+            kb = self._get_keybindings()
+            
+            # Process choice
+            if choice in kb["accept"]:
+                # Save history before changing
+                self.history.append((self.current_hunk_idx, hunk.accepted))
+                hunk.accepted = True
+                self.current_hunk_idx += 1
+            elif choice in kb["reject"]:
+                # Save history before changing
+                self.history.append((self.current_hunk_idx, hunk.accepted))
+                hunk.accepted = False
+                self.current_hunk_idx += 1
+            elif choice in kb["edit"]:
+                self.console.print("[yellow]Edit mode not yet implemented[/yellow]")
+                self.console.input("Press Enter to continue...")
+            elif choice in kb["split"]:
+                self.console.print("[yellow]Split mode not yet implemented[/yellow]")
+                self.console.input("Press Enter to continue...")
+            elif choice in kb["next"]:
+                if self.current_hunk_idx < len(self.hunks) - 1:
+                    self.current_hunk_idx += 1
+            elif choice in kb["prev"]:
+                if self.current_hunk_idx > 0:
+                    self.current_hunk_idx -= 1
+            elif choice in kb["accept_all"]:
+                for h in self.hunks[self.current_hunk_idx:]:
+                    h.accepted = True
+                break
+            elif choice in kb["reject_all"]:
+                for h in self.hunks[self.current_hunk_idx:]:
+                    h.accepted = False
+                break
+            elif choice in kb["undo"]:
+                if self.history:
+                    # Restore previous state
+                    hunk_idx, prev_state = self.history.pop()
+                    self.hunks[hunk_idx].accepted = prev_state
+                    self.current_hunk_idx = hunk_idx
+                    self.console.print("[yellow]↶ Undone last action[/yellow]")
+                    self.console.input("Press Enter to continue...")
+                else:
+                    self.console.print("[yellow]No actions to undo[/yellow]")
+                    self.console.input("Press Enter to continue...")
+            elif choice in kb["quit"]:
+                self.console.print("[yellow]Quitting without applying changes[/yellow]")
+                return None
+            elif choice in kb["help"]:
+                self._show_help()
+            else:
+                self.console.print(f"[red]Unknown command: {choice}[/red]")
+                self.console.input("Press Enter to continue...")
+        
+        # Apply accepted changes
+        return self._apply_changes()
+    
+    def _apply_changes(self) -> str:
+        """Apply accepted changes and return final content."""
+        result_lines = list(self.original_lines)
+        
+        # Apply hunks in reverse order to maintain line numbers
+        for hunk in reversed(self.hunks):
+            if hunk.accepted:
+                # Remove original lines
+                for _ in hunk.original_lines:
+                    if hunk.original_start < len(result_lines):
+                        result_lines.pop(hunk.original_start)
+                
+                # Insert proposed lines
+                for i, line in enumerate(hunk.proposed_lines):
+                    result_lines.insert(hunk.original_start + i, line)
+        
+        return "".join(result_lines)

{claude_dev_cli-0.2.0.dist-info → claude_dev_cli-0.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-dev-cli
-Version: 0.2.0
+Version: 0.3.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
@@ -28,12 +28,15 @@ Requires-Dist: rich>=13.0.0
 Requires-Dist: pydantic>=2.0.0
 Provides-Extra: toon
 Requires-Dist: toon-format>=0.9.0; extra == "toon"
+Provides-Extra: plugins
+Requires-Dist: pygments>=2.0.0; extra == "plugins"
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0.0; extra == "dev"
 Requires-Dist: black>=23.0.0; extra == "dev"
 Requires-Dist: ruff>=0.1.0; extra == "dev"
 Requires-Dist: mypy>=1.0.0; extra == "dev"
 Requires-Dist: toon-format>=0.9.0; extra == "dev"
+Requires-Dist: pygments>=2.0.0; extra == "dev"
 Dynamic: license-file
 
 # Claude Dev CLI

claude_dev_cli-0.3.1.dist-info/RECORD

@@ -0,0 +1,19 @@
+claude_dev_cli/__init__.py,sha256=2ulyIQ3E-s6wBTKyeXAlqHMVA73zUGdaaNUsFiJ-nqs,469
+claude_dev_cli/cli.py,sha256=ekJpBU3d0k9DrE5VoJdKGNgPBsmdB4415up_Yhx_fw0,16174
+claude_dev_cli/commands.py,sha256=RKGx2rv56PM6eErvA2uoQ20hY8babuI5jav8nCUyUOk,3964
+claude_dev_cli/config.py,sha256=-AESk_3Oxq7AoMxvnBIbgplAU9AXQGtlpihEwgtww2s,5826
+claude_dev_cli/core.py,sha256=yaLjEixDvPzvUy4fJ2UB7nMpPPLyKACjR-RuM-1OQBY,4780
+claude_dev_cli/templates.py,sha256=lKxH943ySfUKgyHaWa4W3LVv91SgznKgajRtSRp_4UY,2260
+claude_dev_cli/toon_utils.py,sha256=S3px2UvmNEaltmTa5K-h21n2c0CPvYjZc9mc7kHGqNQ,2828
+claude_dev_cli/usage.py,sha256=32rs0_dUn6ihha3vCfT3rwnvel_-sED7jvLpO7gu-KQ,7446
+claude_dev_cli/plugins/__init__.py,sha256=BdiZlylBzEgnwK2tuEdn8cITxhAZRVbTnDbWhdDhgqs,1340
+claude_dev_cli/plugins/base.py,sha256=H4HQet1I-a3WLCfE9F06Lp8NuFvVoIlou7sIgyJFK-c,1417
+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=LoS6MD48AIQM_9aeBhIuGOYJN1-D6TTxozPV-hkvnTc,13951
+claude_dev_cli-0.3.1.dist-info/licenses/LICENSE,sha256=DGueuJwMJtMwgLO5mWlS0TaeBrFwQuNpNZ22PU9J2bw,1062
+claude_dev_cli-0.3.1.dist-info/METADATA,sha256=oYmNCiM1y__QsoXnp3Cbvw3R21-SpUrepCpQ461v6eg,10447
+claude_dev_cli-0.3.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+claude_dev_cli-0.3.1.dist-info/entry_points.txt,sha256=zymgUIIVpFTARkFmxAuW2A4BQsNITh_L0uU-XunytHg,85
+claude_dev_cli-0.3.1.dist-info/top_level.txt,sha256=m7MF6LOIuTe41IT5Fgt0lc-DK1EgM4gUU_IZwWxK0pg,15
+claude_dev_cli-0.3.1.dist-info/RECORD,,

claude_dev_cli-0.2.0.dist-info/RECORD

@@ -1,14 +0,0 @@
-claude_dev_cli/__init__.py,sha256=2ulyIQ3E-s6wBTKyeXAlqHMVA73zUGdaaNUsFiJ-nqs,469
-claude_dev_cli/cli.py,sha256=vWjUgtYljbzutTcEQxWU6mITtboUWA3E17UynuHrXm0,15833
-claude_dev_cli/commands.py,sha256=RKGx2rv56PM6eErvA2uoQ20hY8babuI5jav8nCUyUOk,3964
-claude_dev_cli/config.py,sha256=YwJjVkW9S1O_iq_2O6YCjYtuFWUCmP18zA7esKDwkKU,5776
-claude_dev_cli/core.py,sha256=97rR9BuNfnhJxFrd7dTdApGyPh6MeGNArcRmaiOY69I,4443
-claude_dev_cli/templates.py,sha256=lKxH943ySfUKgyHaWa4W3LVv91SgznKgajRtSRp_4UY,2260
-claude_dev_cli/toon_utils.py,sha256=S3px2UvmNEaltmTa5K-h21n2c0CPvYjZc9mc7kHGqNQ,2828
-claude_dev_cli/usage.py,sha256=32rs0_dUn6ihha3vCfT3rwnvel_-sED7jvLpO7gu-KQ,7446
-claude_dev_cli-0.2.0.dist-info/licenses/LICENSE,sha256=DGueuJwMJtMwgLO5mWlS0TaeBrFwQuNpNZ22PU9J2bw,1062
-claude_dev_cli-0.2.0.dist-info/METADATA,sha256=uaSOqYhfDsIt3dEAh1iBtJHS8MUM6dWTC_aBJZF8m2M,10325
-claude_dev_cli-0.2.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-claude_dev_cli-0.2.0.dist-info/entry_points.txt,sha256=zymgUIIVpFTARkFmxAuW2A4BQsNITh_L0uU-XunytHg,85
-claude_dev_cli-0.2.0.dist-info/top_level.txt,sha256=m7MF6LOIuTe41IT5Fgt0lc-DK1EgM4gUU_IZwWxK0pg,15
-claude_dev_cli-0.2.0.dist-info/RECORD,,