diffron 0.1.0__py3-none-any.whl

diffron/commit_gen.py

@@ -0,0 +1,151 @@
+"""
+Commit message generation for Diffron.
+
+Generates Conventional Commits format messages from git diffs.
+"""
+
+import os
+from typing import Optional
+
+from .lemonade import LemonadeClient
+from .utils import get_staged_diff
+
+
+# Conventional Commits types
+COMMIT_TYPES = [
+    "feat",     # New feature
+    "fix",      # Bug fix
+    "docs",     # Documentation changes
+    "style",    # Code style changes (formatting, etc.)
+    "refactor", # Code refactoring
+    "perf",     # Performance improvements
+    "test",     # Test additions/modifications
+    "build",    # Build system/external dependencies
+    "ci",       # CI configuration
+    "chore",    # Other changes
+    "revert",   # Revert previous commit
+]
+
+DEFAULT_MAX_CHARS = 4000
+DEFAULT_MAX_TOKENS = 100
+DEFAULT_TEMPERATURE = 0.2
+
+
+def generate_commit_message(
+    diff: Optional[str] = None,
+    max_chars: Optional[int] = None,
+    max_tokens: Optional[int] = None,
+    temperature: Optional[float] = None,
+    client: Optional[LemonadeClient] = None,
+) -> str:
+    """
+    Generate a commit message from a git diff.
+
+    Args:
+        diff: Git diff string. If None, gets staged diff automatically.
+        max_chars: Maximum characters of diff to send. Defaults to 4000.
+        max_tokens: Maximum tokens to generate. Defaults to 100.
+        temperature: Sampling temperature. Defaults to 0.2.
+        client: LemonadeClient instance. Creates new one if not provided.
+
+    Returns:
+        Generated commit message in Conventional Commits format.
+
+    Raises:
+        ValueError: If diff is empty.
+        ConnectionError: If Lemonade is not running.
+    """
+    max_chars = max_chars or int(os.environ.get("DIFFRON_MAX_DIFF_CHARS", DEFAULT_MAX_CHARS))
+    max_tokens = max_tokens or DEFAULT_MAX_TOKENS
+    temperature = temperature if temperature is not None else DEFAULT_TEMPERATURE
+
+    # Get diff if not provided
+    if diff is None:
+        diff = get_staged_diff(max_chars=max_chars)
+
+    if not diff.strip():
+        raise ValueError("No staged changes to generate commit message from.")
+
+    # Create client if not provided
+    if client is None:
+        client = LemonadeClient()
+
+    # Build prompt
+    commit_types = ", ".join(COMMIT_TYPES)
+    prompt = (
+        f"Write a concise Git commit message in Conventional Commits format. "
+        f"Use one of these types: {commit_types}. "
+        f"Format: 'type: description' (e.g., 'feat: add user authentication'). "
+        f"Output ONLY the commit message, nothing else. No quotes, no explanations.\n\n"
+        f"Diff:\n{diff}"
+    )
+
+    messages = [{"role": "user", "content": prompt}]
+
+    # Generate completion
+    response = client.chat_completion(
+        messages=messages,
+        max_tokens=max_tokens,
+        temperature=temperature,
+    )
+
+    # Clean up response
+    commit_message = response.strip()
+
+    # Remove any surrounding quotes
+    if commit_message.startswith('"') and commit_message.endswith('"'):
+        commit_message = commit_message[1:-1]
+    if commit_message.startswith("'") and commit_message.endswith("'"):
+        commit_message = commit_message[1:-1]
+
+    # Remove markdown code blocks if present
+    if commit_message.startswith("```"):
+        lines = commit_message.split("\n")
+        commit_message = "\n".join(
+            line for line in lines
+            if not line.startswith("```")
+        ).strip()
+
+    return commit_message
+
+
+def validate_commit_type(message: str) -> bool:
+    """
+    Validate that a commit message starts with a valid Conventional Commits type.
+
+    Args:
+        message: Commit message to validate.
+
+    Returns:
+        True if valid, False otherwise.
+    """
+    for commit_type in COMMIT_TYPES:
+        if message.lower().startswith(f"{commit_type}:"):
+            return True
+        if message.lower().startswith(f"{commit_type}("):  # With scope
+            return True
+    return False
+
+
+def format_commit_message(
+    commit_type: str,
+    description: str,
+    scope: Optional[str] = None,
+    breaking: bool = False,
+) -> str:
+    """
+    Format a commit message with proper Conventional Commits structure.
+
+    Args:
+        commit_type: Type of commit (feat, fix, etc.).
+        description: Short description of the change.
+        scope: Optional scope (e.g., 'api', 'ui').
+        breaking: Whether this is a breaking change.
+
+    Returns:
+        Formatted commit message.
+    """
+    scope_part = f"({scope})" if scope else ""
+    breaking_part = "!" if breaking else ""
+
+    return f"{commit_type}{scope_part}{breaking_part}: {description}"

diffron/commit_gen.pyi

@@ -0,0 +1,41 @@
+"""
+Commit message generation for Diffron.
+
+Generates Conventional Commits format messages from git diffs.
+"""
+
+from typing import Optional
+from .lemonade import LemonadeClient
+
+
+COMMIT_TYPES: list[str]
+
+DEFAULT_MAX_CHARS: int
+DEFAULT_MAX_TOKENS: int
+DEFAULT_TEMPERATURE: float
+
+
+def generate_commit_message(
+    diff: Optional[str] = None,
+    max_chars: Optional[int] = None,
+    max_tokens: Optional[int] = None,
+    temperature: Optional[float] = None,
+    client: Optional[LemonadeClient] = None,
+) -> str:
+    """Generate a commit message from a git diff."""
+    ...
+
+
+def validate_commit_type(message: str) -> bool:
+    """Validate that a commit message starts with a valid Conventional Commits type."""
+    ...
+
+
+def format_commit_message(
+    commit_type: str,
+    description: str,
+    scope: Optional[str] = None,
+    breaking: bool = False,
+) -> str:
+    """Format a commit message with proper Conventional Commits structure."""
+    ...

diffron/git_hooks.py

@@ -0,0 +1,292 @@
+"""
+Git hooks installation and management for Diffron.
+
+Provides functions to install, uninstall, and verify Diffron Git hooks.
+"""
+
+import os
+import shutil
+import stat
+from pathlib import Path
+from typing import Optional
+
+from .utils import get_git_dir, is_git_repo
+
+
+# Hook file names
+WRAPPER_NAME = "prepare-commit-msg"
+PYTHON_HOOK_NAME = "prepare-commit-msg.py"
+
+# Get the hooks directory (where the template hooks are stored)
+DIFFRON_PACKAGE_DIR = Path(__file__).parent
+HOOKS_TEMPLATE_DIR = DIFFRON_PACKAGE_DIR.parent / "hooks"
+
+
+def install_hooks(
+    repo_path: str = ".",
+    global_install: bool = False,
+) -> bool:
+    """
+    Install Diffron Git hooks to a repository.
+
+    Args:
+        repo_path: Path to the git repository. Defaults to current directory.
+        global_install: If True, install hooks globally for all repositories.
+
+    Returns:
+        True if installation was successful, False otherwise.
+    """
+    if global_install:
+        return _install_global_hooks()
+
+    if not is_git_repo(repo_path):
+        raise ValueError(f"Not a git repository: {repo_path}")
+
+    git_dir = get_git_dir(repo_path)
+    if git_dir is None:
+        raise ValueError(f"Could not find .git directory in: {repo_path}")
+
+    hooks_dir = Path(git_dir) / "hooks"
+    hooks_dir.mkdir(parents=True, exist_ok=True)
+
+    # Copy wrapper script
+    wrapper_src = HOOKS_TEMPLATE_DIR / WRAPPER_NAME
+    wrapper_dst = hooks_dir / WRAPPER_NAME
+
+    if wrapper_src.exists():
+        shutil.copy2(wrapper_src, wrapper_dst)
+        _make_executable(wrapper_dst)
+
+    # Copy Python hook script
+    python_hook_src = HOOKS_TEMPLATE_DIR / PYTHON_HOOK_NAME
+    python_hook_dst = hooks_dir / PYTHON_HOOK_NAME
+
+    if python_hook_src.exists():
+        shutil.copy2(python_hook_src, python_hook_dst)
+        _make_executable(python_hook_dst)
+
+    return True
+
+
+def _install_global_hooks() -> bool:
+    """
+    Install hooks globally using git config core.hooksPath.
+
+    Returns:
+        True if installation was successful, False otherwise.
+    """
+    import subprocess
+
+    # Create global hooks directory in user's home
+    home_dir = Path.home()
+    global_hooks_dir = home_dir / ".diffron-hooks"
+    global_hooks_dir.mkdir(parents=True, exist_ok=True)
+
+    # Copy hook files
+    wrapper_src = HOOKS_TEMPLATE_DIR / WRAPPER_NAME
+
+    # For global install, use the simplified hook that imports from installed package
+    python_hook_src = HOOKS_TEMPLATE_DIR / "prepare-commit-msg-global.py"
+    if not python_hook_src.exists():
+        # Fallback to regular hook if global version doesn't exist
+        python_hook_src = HOOKS_TEMPLATE_DIR / PYTHON_HOOK_NAME
+
+    wrapper_dst = global_hooks_dir / WRAPPER_NAME
+    python_hook_dst = global_hooks_dir / PYTHON_HOOK_NAME
+
+    if wrapper_src.exists():
+        shutil.copy2(wrapper_src, wrapper_dst)
+        _make_executable(wrapper_dst)
+
+    if python_hook_src.exists():
+        shutil.copy2(python_hook_src, python_hook_dst)
+        _make_executable(python_hook_dst)
+
+    # Configure git to use global hooks path
+    hooks_path_str = str(global_hooks_dir).replace("\\", "/")
+    try:
+        subprocess.run(
+            ["git", "config", "--global", "core.hooksPath", hooks_path_str],
+            check=True,
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+        return True
+    except subprocess.SubprocessError:
+        return False
+
+
+def uninstall_hooks(
+    repo_path: str = ".",
+    global_install: bool = False,
+) -> bool:
+    """
+    Remove Diffron Git hooks from a repository.
+
+    Args:
+        repo_path: Path to the git repository. Defaults to current directory.
+        global_install: If True, remove global hooks configuration.
+
+    Returns:
+        True if uninstallation was successful, False otherwise.
+    """
+    import subprocess
+
+    if global_install:
+        # Remove global hooks configuration
+        try:
+            subprocess.run(
+                ["git", "config", "--global", "--unset", "core.hooksPath"],
+                check=True,
+                capture_output=True,
+                text=True,
+                timeout=10,
+            )
+        except subprocess.SubprocessError:
+            pass  # Config might not be set
+
+        # Remove global hooks directory
+        home_dir = Path.home()
+        global_hooks_dir = home_dir / ".diffron-hooks"
+        if global_hooks_dir.exists():
+            try:
+                shutil.rmtree(global_hooks_dir)
+            except Exception:
+                pass
+        return True
+
+    if not is_git_repo(repo_path):
+        raise ValueError(f"Not a git repository: {repo_path}")
+
+    git_dir = get_git_dir(repo_path)
+    if git_dir is None:
+        raise ValueError(f"Could not find .git directory in: {repo_path}")
+
+    hooks_dir = Path(git_dir) / "hooks"
+
+    # Remove hook files
+    wrapper_path = hooks_dir / WRAPPER_NAME
+    python_hook_path = hooks_dir / PYTHON_HOOK_NAME
+
+    removed = False
+
+    if wrapper_path.exists():
+        wrapper_path.unlink()
+        removed = True
+
+    if python_hook_path.exists():
+        python_hook_path.unlink()
+        removed = True
+
+    return removed
+
+
+def is_hooks_installed(
+    repo_path: str = ".",
+    check_global: bool = False,
+) -> bool:
+    """
+    Check if Diffron hooks are installed.
+
+    Args:
+        repo_path: Path to the git repository. Defaults to current directory.
+        check_global: If True, check for global hooks configuration.
+
+    Returns:
+        True if hooks are installed, False otherwise.
+    """
+    import subprocess
+
+    if check_global:
+        # Check global hooks configuration
+        try:
+            result = subprocess.run(
+                ["git", "config", "--global", "core.hooksPath"],
+                capture_output=True,
+                text=True,
+                timeout=10,
+            )
+            if result.returncode == 0 and result.stdout.strip():
+                hooks_path = result.stdout.strip()
+                # Check if it's the diffron hooks directory
+                if ".diffron-hooks" in hooks_path:
+                    return True
+        except subprocess.SubprocessError:
+            pass
+        return False
+
+    if not is_git_repo(repo_path):
+        return False
+
+    git_dir = get_git_dir(repo_path)
+    if git_dir is None:
+        return False
+
+    hooks_dir = Path(git_dir) / "hooks"
+
+    # Check if both hook files exist
+    wrapper_path = hooks_dir / WRAPPER_NAME
+    python_hook_path = hooks_dir / PYTHON_HOOK_NAME
+
+    return wrapper_path.exists() and python_hook_path.exists()
+
+
+def _make_executable(path: Path) -> None:
+    """
+    Make a file executable.
+
+    Args:
+        path: Path to the file.
+    """
+    if os.name == "nt":
+        # Windows doesn't use Unix permissions, but we can still set the flag
+        pass
+    else:
+        # Unix-like systems
+        current_mode = path.stat().st_mode
+        path.chmod(current_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
+
+
+def get_hooks_status(repo_path: str = ".") -> dict:
+    """
+    Get detailed status of hooks installation.
+
+    Args:
+        repo_path: Path to the git repository.
+
+    Returns:
+        Dict with status information.
+    """
+    status = {
+        "is_git_repo": is_git_repo(repo_path),
+        "local_hooks_installed": False,
+        "global_hooks_configured": False,
+        "wrapper_exists": False,
+        "python_hook_exists": False,
+        "git_dir": None,
+        "hooks_dir": None,
+    }
+
+    if status["is_git_repo"]:
+        git_dir = get_git_dir(repo_path)
+        status["git_dir"] = str(git_dir) if git_dir else None
+
+        if git_dir:
+            hooks_dir = Path(git_dir) / "hooks"
+            status["hooks_dir"] = str(hooks_dir)
+
+            wrapper_path = hooks_dir / WRAPPER_NAME
+            python_hook_path = hooks_dir / PYTHON_HOOK_NAME
+
+            status["wrapper_exists"] = wrapper_path.exists()
+            status["python_hook_exists"] = python_hook_path.exists()
+            status["local_hooks_installed"] = (
+                status["wrapper_exists"] and status["python_hook_exists"]
+            )
+
+    status["global_hooks_configured"] = is_hooks_installed(
+        repo_path, check_global=True
+    )
+
+    return status

diffron/git_hooks.pyi

@@ -0,0 +1,52 @@
+"""
+Git hooks installation and management for Diffron.
+
+Provides functions to install, uninstall, and verify Diffron Git hooks.
+"""
+
+from pathlib import Path
+from typing import Optional
+
+
+WRAPPER_NAME: str
+PYTHON_HOOK_NAME: str
+HOOKS_TEMPLATE_DIR: Path
+
+
+def install_hooks(
+    repo_path: str = ".",
+    global_install: bool = False,
+) -> bool:
+    """Install Diffron Git hooks to a repository."""
+    ...
+
+
+def _install_global_hooks() -> bool:
+    """Install hooks globally using git config core.hooksPath."""
+    ...
+
+
+def uninstall_hooks(
+    repo_path: str = ".",
+    global_install: bool = False,
+) -> bool:
+    """Remove Diffron Git hooks from a repository."""
+    ...
+
+
+def is_hooks_installed(
+    repo_path: str = ".",
+    check_global: bool = False,
+) -> bool:
+    """Check if Diffron hooks are installed."""
+    ...
+
+
+def _make_executable(path: Path) -> None:
+    """Make a file executable."""
+    ...
+
+
+def get_hooks_status(repo_path: str = ".") -> dict:
+    """Get detailed status of hooks installation."""
+    ...