claude-dev-cli 0.1.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

claude_dev_cli/__init__.py

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

claude_dev_cli/cli.py

@@ -21,6 +21,8 @@ from claude_dev_cli.commands import (
     git_commit_message,
 )
 from claude_dev_cli.usage import UsageTracker
+from claude_dev_cli import toon_utils
+from claude_dev_cli.plugins import load_plugins
 
 console = Console()
 
@@ -34,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')
@@ -394,5 +407,124 @@ def usage(ctx: click.Context, days: Optional[int], api: Optional[str]) -> None:
         sys.exit(1)
 
 
+@main.group()
+def toon() -> None:
+    """TOON format conversion tools."""
+    pass
+
+
+@toon.command('encode')
+@click.argument('input_file', type=click.Path(exists=True), required=False)
+@click.option('-o', '--output', type=click.Path(), help='Output file')
+@click.pass_context
+def toon_encode(ctx: click.Context, input_file: Optional[str], output: Optional[str]) -> None:
+    """Convert JSON to TOON format."""
+    console = ctx.obj['console']
+    
+    if not toon_utils.is_toon_available():
+        console.print("[red]TOON support not installed.[/red]")
+        console.print("Install with: [cyan]pip install claude-dev-cli[toon][/cyan]")
+        sys.exit(1)
+    
+    try:
+        import json
+        
+        # Read input
+        if input_file:
+            with open(input_file, 'r') as f:
+                data = json.load(f)
+        elif not sys.stdin.isatty():
+            data = json.load(sys.stdin)
+        else:
+            console.print("[red]Error: No input provided[/red]")
+            console.print("Usage: cdc toon encode [FILE] or pipe JSON via stdin")
+            sys.exit(1)
+        
+        # Convert to TOON
+        toon_str = toon_utils.to_toon(data)
+        
+        # Output
+        if output:
+            with open(output, 'w') as f:
+                f.write(toon_str)
+            console.print(f"[green]✓[/green] Converted to TOON: {output}")
+        else:
+            console.print(toon_str)
+    
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+        sys.exit(1)
+
+
+@toon.command('decode')
+@click.argument('input_file', type=click.Path(exists=True), required=False)
+@click.option('-o', '--output', type=click.Path(), help='Output file')
+@click.pass_context
+def toon_decode(ctx: click.Context, input_file: Optional[str], output: Optional[str]) -> None:
+    """Convert TOON format to JSON."""
+    console = ctx.obj['console']
+    
+    if not toon_utils.is_toon_available():
+        console.print("[red]TOON support not installed.[/red]")
+        console.print("Install with: [cyan]pip install claude-dev-cli[toon][/cyan]")
+        sys.exit(1)
+    
+    try:
+        import json
+        
+        # Read input
+        if input_file:
+            with open(input_file, 'r') as f:
+                toon_str = f.read()
+        elif not sys.stdin.isatty():
+            toon_str = sys.stdin.read()
+        else:
+            console.print("[red]Error: No input provided[/red]")
+            console.print("Usage: cdc toon decode [FILE] or pipe TOON via stdin")
+            sys.exit(1)
+        
+        # Convert from TOON
+        data = toon_utils.from_toon(toon_str)
+        
+        # Output
+        json_str = json.dumps(data, indent=2)
+        if output:
+            with open(output, 'w') as f:
+                f.write(json_str)
+            console.print(f"[green]✓[/green] Converted to JSON: {output}")
+        else:
+            console.print(json_str)
+    
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+        sys.exit(1)
+
+
+@toon.command('info')
+@click.pass_context
+def toon_info(ctx: click.Context) -> None:
+    """Show TOON format installation status and token savings info."""
+    console = ctx.obj['console']
+    
+    if toon_utils.is_toon_available():
+        console.print("[green]✓[/green] TOON format support is installed")
+        console.print("\n[bold]About TOON:[/bold]")
+        console.print("• Token-Oriented Object Notation")
+        console.print("• 30-60% fewer tokens than JSON")
+        console.print("• Optimized for LLM prompts")
+        console.print("• Human-readable and lossless")
+        console.print("\n[bold]Usage:[/bold]")
+        console.print("  cdc toon encode data.json -o data.toon")
+        console.print("  cdc toon decode data.toon -o data.json")
+        console.print("  cat data.json | cdc toon encode")
+    else:
+        console.print("[yellow]TOON format support not installed[/yellow]")
+        console.print("\nInstall with: [cyan]pip install claude-dev-cli[toon][/cyan]")
+        console.print("\n[bold]Benefits:[/bold]")
+        console.print("• Reduce API costs by 30-60%")
+        console.print("• Faster LLM response times")
+        console.print("• Same data, fewer tokens")
+
+
 if __name__ == '__main__':
     main(obj={})

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,314 @@
+"""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
+
+
+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
+    
+    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 _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]")
+            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]")
+            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"]:
+                hunk.accepted = True
+                self.current_hunk_idx += 1
+            elif choice in kb["reject"]:
+                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["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/toon_utils.py

@@ -0,0 +1,117 @@
+"""TOON format utilities for token-efficient LLM communication."""
+
+from typing import Any, Optional
+
+# Try to import toon-format, but make it optional
+try:
+    from toon_format import encode as toon_encode, decode as toon_decode
+    TOON_AVAILABLE = True
+except ImportError:
+    TOON_AVAILABLE = False
+    toon_encode = None
+    toon_decode = None
+
+
+def is_toon_available() -> bool:
+    """Check if TOON format support is available."""
+    return TOON_AVAILABLE
+
+
+def to_toon(data: Any) -> str:
+    """
+    Convert Python data to TOON format.
+    
+    Args:
+        data: Python dict, list, or primitive to encode
+        
+    Returns:
+        TOON-formatted string
+        
+    Raises:
+        ImportError: If toon-format is not installed
+    """
+    if not TOON_AVAILABLE:
+        raise ImportError(
+            "TOON format support not installed. "
+            "Install with: pip install claude-dev-cli[toon]"
+        )
+    
+    return toon_encode(data)
+
+
+def from_toon(toon_str: str) -> Any:
+    """
+    Convert TOON format back to Python data.
+    
+    Args:
+        toon_str: TOON-formatted string
+        
+    Returns:
+        Python dict, list, or primitive
+        
+    Raises:
+        ImportError: If toon-format is not installed
+    """
+    if not TOON_AVAILABLE:
+        raise ImportError(
+            "TOON format support not installed. "
+            "Install with: pip install claude-dev-cli[toon]"
+        )
+    
+    return toon_decode(toon_str)
+
+
+def format_for_llm(data: Any, use_toon: bool = True) -> str:
+    """
+    Format data for LLM consumption, preferring TOON if available.
+    
+    Args:
+        data: Data to format
+        use_toon: Whether to use TOON format if available (default: True)
+        
+    Returns:
+        Formatted string (TOON if available and requested, else JSON)
+    """
+    import json
+    
+    if use_toon and TOON_AVAILABLE:
+        try:
+            return to_toon(data)
+        except Exception:
+            # Fall back to JSON if TOON encoding fails
+            pass
+    
+    return json.dumps(data, indent=2)
+
+
+def auto_detect_format(content: str) -> tuple[str, Any]:
+    """
+    Auto-detect if content is TOON or JSON and decode accordingly.
+    
+    Args:
+        content: String content to decode
+        
+    Returns:
+        Tuple of (format_name, decoded_data)
+        
+    Raises:
+        ValueError: If content cannot be parsed as either format
+    """
+    import json
+    
+    # Try TOON first if available
+    if TOON_AVAILABLE:
+        try:
+            data = from_toon(content)
+            return ("toon", data)
+        except Exception:
+            pass
+    
+    # Try JSON
+    try:
+        data = json.loads(content)
+        return ("json", data)
+    except json.JSONDecodeError:
+        pass
+    
+    raise ValueError("Content is neither valid TOON nor JSON")

{claude_dev_cli-0.1.0.dist-info → claude_dev_cli-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-dev-cli
-Version: 0.1.0
+Version: 0.3.0
 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
@@ -26,11 +26,14 @@ Requires-Dist: anthropic>=0.18.0
 Requires-Dist: click>=8.1.0
 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: 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"
 Dynamic: license-file
 
 # Claude Dev CLI
@@ -63,12 +66,27 @@ A powerful command-line tool for developers using Claude AI with multi-API routi
 - **Interactive**: Chat mode with conversation history
 - **Streaming**: Real-time responses
 
+### 🎒 TOON Format Support (Optional)
+- **Token Reduction**: 30-60% fewer tokens than JSON
+- **Cost Savings**: Reduce API costs significantly
+- **Format Conversion**: JSON ↔ TOON with CLI tools
+- **Auto-fallback**: Works without TOON installed
+
 ## Installation
 
+### Basic Installation
+
 ```bash
 pip install claude-dev-cli
 ```
 
+### With TOON Support (Recommended for Cost Savings)
+
+```bash
+# Install with TOON format support for 30-60% token reduction
+pip install claude-dev-cli[toon]
+```
+
 ## Quick Start
 
 ### 1. Set Up API Keys
@@ -141,6 +159,28 @@ cdc usage --days 7
 cdc usage --api client
 ```
 
+### 5. TOON Format (Optional - Reduces Tokens by 30-60%)
+
+```bash
+# Check if TOON is installed
+cdc toon info
+
+# Convert JSON to TOON
+echo '{"users": [{"id": 1, "name": "Alice"}]}' | cdc toon encode
+# Output:
+# users[1]{id,name}:
+# 1,Alice
+
+# Convert file
+cdc toon encode data.json -o data.toon
+
+# Convert TOON back to JSON
+cdc toon decode data.toon -o data.json
+
+# Use in workflows
+cat large_data.json | cdc toon encode | cdc ask "analyze this data"
+```
+
 ## Configuration
 
 ### Global Configuration

claude_dev_cli-0.3.0.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=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/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=wm8TG-aOrCV0f1NaL-Jwi93UaksfApESQpjmPPRIQTs,11597
+claude_dev_cli-0.3.0.dist-info/licenses/LICENSE,sha256=DGueuJwMJtMwgLO5mWlS0TaeBrFwQuNpNZ22PU9J2bw,1062
+claude_dev_cli-0.3.0.dist-info/METADATA,sha256=lR6Z4dFk6UaXzPHBwLX9hi7eiKEHaI9I0Hcg1yVCR9w,10325
+claude_dev_cli-0.3.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+claude_dev_cli-0.3.0.dist-info/entry_points.txt,sha256=zymgUIIVpFTARkFmxAuW2A4BQsNITh_L0uU-XunytHg,85
+claude_dev_cli-0.3.0.dist-info/top_level.txt,sha256=m7MF6LOIuTe41IT5Fgt0lc-DK1EgM4gUU_IZwWxK0pg,15
+claude_dev_cli-0.3.0.dist-info/RECORD,,

claude_dev_cli-0.1.0.dist-info/RECORD

@@ -1,13 +0,0 @@
-claude_dev_cli/__init__.py,sha256=O2wq4c3zAUKOJ6liwykkHMqEyhhasrv69ybnAmP9BNU,469
-claude_dev_cli/cli.py,sha256=s5nYAvNQDYXfNXFs9NbVRib3EasqXMZayJNekl3JRX4,11574
-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/usage.py,sha256=32rs0_dUn6ihha3vCfT3rwnvel_-sED7jvLpO7gu-KQ,7446
-claude_dev_cli-0.1.0.dist-info/licenses/LICENSE,sha256=DGueuJwMJtMwgLO5mWlS0TaeBrFwQuNpNZ22PU9J2bw,1062
-claude_dev_cli-0.1.0.dist-info/METADATA,sha256=mdYAz3MjH7qEZ-aOBsM3Jml8NNJUQz2HJvsSQZMioMM,9313
-claude_dev_cli-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-claude_dev_cli-0.1.0.dist-info/entry_points.txt,sha256=zymgUIIVpFTARkFmxAuW2A4BQsNITh_L0uU-XunytHg,85
-claude_dev_cli-0.1.0.dist-info/top_level.txt,sha256=m7MF6LOIuTe41IT5Fgt0lc-DK1EgM4gUU_IZwWxK0pg,15
-claude_dev_cli-0.1.0.dist-info/RECORD,,