claude-dev-cli 0.2.0__tar.gz → 0.3.1__tar.gz

{claude_dev_cli-0.2.0/src/claude_dev_cli.egg-info → claude_dev_cli-0.3.1}/PKG-INFO

@@ -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.2.0 → claude_dev_cli-0.3.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "claude-dev-cli"
-version = "0.2.0"
+version = "0.3.1"
 description = "A powerful CLI tool for developers using Claude AI with multi-API routing, test generation, code review, and usage tracking"
 readme = "README.md"
 requires-python = ">=3.9"
@@ -38,12 +38,16 @@ dependencies = [
 toon = [
     "toon-format>=0.9.0",
 ]
+plugins = [
+    "pygments>=2.0.0",
+]
 dev = [
     "pytest>=7.0.0",
     "black>=23.0.0",
     "ruff>=0.1.0",
     "mypy>=1.0.0",
     "toon-format>=0.9.0",
+    "pygments>=2.0.0",
 ]
 
 [project.urls]

{claude_dev_cli-0.2.0 → claude_dev_cli-0.3.1}/src/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-0.2.0 → claude_dev_cli-0.3.1}/src/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-0.2.0 → claude_dev_cli-0.3.1}/src/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-0.3.1/src/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-0.3.1/src/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-0.3.1/src/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-0.3.1/src/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()