enhanced-git 1.0.0__py3-none-any.whl

gitai/constants.py

@@ -0,0 +1,134 @@
+"""Constants and templates for GitAI."""
+
+from typing import Final
+
+# Commit message prompts
+COMMIT_SYSTEM_PROMPT: Final[
+    str
+] = """You are an expert release engineer. Output plain text only, no code fences.
+Follow Conventional Commits strictly. Do not invent changes."""
+
+COMMIT_USER_PROMPT_SINGLE: Final[
+    str
+] = """Generate a Conventional Commit message from this unified diff.
+
+Rules:
+- Subject < 70 chars: type(optional-scope): message
+- Sentence case, no trailing period in subject
+- Include a short body with bullet points only if helpful
+- Wrap body at 72 columns
+- Do not invent changes; reflect only what the diff shows
+
+Diff:
+{diff}"""
+
+COMMIT_USER_PROMPT_MERGE: Final[
+    str
+] = """Given these chunk summaries of staged changes, produce one Conventional Commit message.
+Follow the same rules as above. Prefer the most representative type(scope).
+
+Chunk summaries:
+{chunk_summaries}"""
+
+# Changelog prompts
+CHANGELOG_SYSTEM_PROMPT: Final[str] = (
+    """You are an expert technical writer. Output markdown bullets only. Do not invent facts."""
+)
+
+CHANGELOG_USER_PROMPT: Final[
+    str
+] = """Polish these grouped commit bullets for a changelog. Improve clarity and brevity.
+Do not add or invent items. Keep issue/PR references unchanged.
+
+Grouped bullets:
+{grouped_bullets}"""
+
+# Type mappings for heuristics
+TYPE_HINTS_PATH: Final[dict[str, str]] = {
+    "tests/": "test",
+    "_test.": "test",
+    "docs/": "docs",
+    ".md": "docs",
+    "mkdocs.yml": "docs",
+    ".github/workflows/": "ci",
+    "Dockerfile": "ci",
+    "docker-compose": "ci",
+    "Makefile": "build",
+    "pyproject.toml": "build",
+    "setup.py": "build",
+    "requirements": "build",
+}
+
+TYPE_HINTS_CONTENT: Final[dict[str, str]] = {
+    "add": "feat",
+    "new": "feat",
+    "create": "feat",
+    "remove": "feat",
+    "delete": "feat",
+    "fix": "fix",
+    "bug": "fix",
+    "error": "fix",
+    "issue": "fix",
+    "refactor": "refactor",
+    "rename": "chore",
+    "move": "chore",
+    "update": "feat",
+    "improve": "feat",
+    "enhance": "feat",
+    "optimize": "perf",
+    "performance": "perf",
+    "speed": "perf",
+    "test": "test",
+    "testing": "test",
+    "doc": "docs",
+    "document": "docs",
+    "readme": "docs",
+    "ci": "ci",
+    "build": "ci",
+    "config": "ci",
+    "chore": "chore",
+    "maintenance": "chore",
+}
+
+# Conventional Commit types in display order
+CHANGELOG_SECTIONS: Final[list[str]] = [
+    "Features",
+    "Fixes",
+    "Performance",
+    "Documentation",
+    "Refactoring",
+    "CI",
+    "Build",
+    "Tests",
+    "Chore",
+    "Other",
+]
+
+# Type to section mapping
+TYPE_TO_SECTION: Final[dict[str, str]] = {
+    "feat": "Features",
+    "fix": "Fixes",
+    "perf": "Performance",
+    "docs": "Documentation",
+    "refactor": "Refactoring",
+    "ci": "CI",
+    "build": "Build",
+    "test": "Tests",
+    "chore": "Chore",
+}
+
+# File size limits
+MAX_CHUNK_SIZE: Final[int] = 6000  # characters
+MAX_SUBJECT_LENGTH: Final[int] = 100
+BODY_WRAP_WIDTH: Final[int] = 72
+CHANGELOG_WRAP_WIDTH: Final[int] = 100
+
+# Default timeouts
+DEFAULT_TIMEOUT: Final[int] = 45
+
+# Git hook content
+HOOK_CONTENT: Final[
+    str
+] = """#!/usr/bin/env sh
+git-ai commit --hook "$1" || exit 0
+"""

gitai/diff.py

@@ -0,0 +1,167 @@
+"""Diff collection and chunking functionality."""
+
+import re
+from typing import Any
+
+from .constants import MAX_CHUNK_SIZE
+from .util import run
+
+
+class DiffChunk:
+    """Represents a chunk of diff content."""
+
+    def __init__(self, content: str, files: list[str]):
+        self.content = content
+        self.files = files
+        self.size = len(content)
+
+    def __str__(self) -> str:
+        return f"DiffChunk({len(self.files)} files, {self.size} chars)"
+
+
+class StagedDiff:
+    """Represents staged changes in a git repository."""
+
+    def __init__(self, raw_diff: str):
+        self.raw_diff = raw_diff
+        self.files = self._extract_files()
+        self.stats = self._extract_stats()
+
+    def _extract_files(self) -> list[str]:
+        """Extract file paths from diff."""
+        files = []
+        lines = self.raw_diff.split("\n")
+
+        for line in lines:
+            if line.startswith("diff --git"):
+                # extract file paths from diff --git a/path b/path
+                match = re.search(r"diff --git a/(.+) b/(.+)", line)
+                if match:
+                    file_path = match.group(2)  # use b/path (new path)
+                    files.append(file_path)
+
+        return files
+
+    def _extract_stats(self) -> dict[str, Any]:
+        """Extract statistics from diff."""
+        stats = {
+            "files_changed": len(self.files),
+            "additions": 0,
+            "deletions": 0,
+            "renames": 0,
+            "new_files": 0,
+        }
+
+        lines = self.raw_diff.split("\n")
+        for line in lines:
+            if line.startswith("+++ b/") and line.endswith("(new file)"):
+                stats["new_files"] += 1
+            elif line.startswith("rename"):
+                stats["renames"] += 1
+            elif line.startswith("+") and not line.startswith("+++"):
+                stats["additions"] += 1
+            elif line.startswith("-") and not line.startswith("---"):
+                stats["deletions"] += 1
+
+        return stats
+
+    def is_empty(self) -> bool:
+        """Check if diff is empty."""
+        return not self.raw_diff.strip()
+
+    def chunk_by_files(self, max_size: int = MAX_CHUNK_SIZE) -> list[DiffChunk]:
+        """Chunk diff by files to stay within size limits."""
+        if self.is_empty():
+            return []
+
+        chunks = []
+        current_chunk = ""
+        current_files: list[str] = []
+
+        # split diff by file boundaries
+        file_sections = re.split(r"(?=diff --git)", self.raw_diff)
+
+        for section in file_sections:
+            if not section.strip():
+                continue
+
+            # extract file path from this section
+            file_match = re.search(r"diff --git a/(.+) b/(.+)", section)
+            if file_match:
+                file_path = file_match.group(2)
+
+                # check if adding this file would exceed the chunk size
+                if len(current_chunk + section) > max_size and current_chunk:
+                    # create chunk with current content
+                    chunks.append(DiffChunk(current_chunk.strip(), current_files))
+                    current_chunk = section
+                    current_files = [file_path]
+                else:
+                    current_chunk += section
+                    current_files.append(file_path)
+
+        # add remaining content as final chunk
+        if current_chunk.strip():
+            chunks.append(DiffChunk(current_chunk.strip(), current_files))
+
+        return chunks
+
+
+def get_staged_diff() -> StagedDiff:
+    """Get staged diff from git."""
+    try:
+        raw_diff = run(["git", "diff", "--staged", "-U0"])
+        return StagedDiff(raw_diff)
+    except SystemExit:
+        # return empty diff if command fails
+        return StagedDiff("")
+
+
+def get_diff_between_refs(since_ref: str, to_ref: str = "HEAD") -> str:
+    """Get diff between two git references."""
+    try:
+        return run(
+            [
+                "git",
+                "log",
+                "--pretty=format:%H%n%s%n%b---END---",
+                f"{since_ref}..{to_ref}",
+            ]
+        )
+    except SystemExit:
+        return ""
+
+
+def get_commit_history(since_ref: str, to_ref: str = "HEAD") -> list[dict[str, str]]:
+    """Get commit history between two references."""
+    try:
+        log_output = run(
+            [
+                "git",
+                "log",
+                "--pretty=format:%H%n%s%n%b---END---",
+                f"{since_ref}..{to_ref}",
+            ]
+        )
+
+        commits = []
+        sections = log_output.split("---END---")
+
+        for section in sections:
+            lines = section.strip().split("\n")
+            if len(lines) >= 2:
+                commit_hash = lines[0]
+                subject = lines[1]
+                body = "\n".join(lines[2:]) if len(lines) > 2 else ""
+
+                commits.append(
+                    {
+                        "hash": commit_hash,
+                        "subject": subject,
+                        "body": body,
+                    }
+                )
+
+        return commits
+    except SystemExit:
+        return []

gitai/hook.py

@@ -0,0 +1,81 @@
+"""Git hook installation functionality."""
+
+from .constants import HOOK_CONTENT
+from .util import (
+    backup_file,
+    find_git_root,
+    make_executable,
+    print_success,
+    print_warning,
+)
+
+
+def install_commit_msg_hook(force: bool = False) -> None:
+    """Install the commit-msg Git hook."""
+    git_root = find_git_root()
+    hooks_dir = git_root / ".git" / "hooks"
+
+    if not hooks_dir.exists():
+        print_warning(".git/hooks directory not found. Is this a valid git repository?")
+        return
+
+    hook_path = hooks_dir / "commit-msg"
+
+    # check if hook already exists
+    if hook_path.exists() and not force:
+        content = hook_path.read_text().strip()
+        if content == HOOK_CONTENT.strip():
+            print_success("Git-AI commit-msg hook is already installed")
+            return
+
+        print_warning("Existing commit-msg hook found:")
+        print_warning(str(hook_path))
+        print_warning("Use --force to overwrite it, or manually merge the content.")
+
+        # show current content
+        print_warning("Current hook content:")
+        print_warning(content)
+        print_warning("---")
+        print_warning("Git-AI hook content:")
+        print_warning(HOOK_CONTENT.strip())
+
+        # offer to create backup
+        backup = backup_file(hook_path)
+        if backup:
+            print_success(f"Created backup: {backup}")
+
+        return
+
+    # install the hook
+    try:
+        hook_path.write_text(HOOK_CONTENT)
+        make_executable(hook_path)
+        print_success("Installed Git-AI commit-msg hook")
+        print_success("The hook will generate commit messages for your commits.")
+        print_success("To remove it, delete or modify .git/hooks/commit-msg")
+
+    except Exception as e:
+        print_warning(f"Failed to install hook: {e}")
+
+
+def uninstall_commit_msg_hook() -> None:
+    """Remove the Git-AI commit-msg hook."""
+    git_root = find_git_root()
+    hook_path = git_root / ".git" / "hooks" / "commit-msg"
+
+    if not hook_path.exists():
+        print_warning("Git-AI commit-msg hook not found")
+        return
+
+    # check if it's our hook
+    content = hook_path.read_text().strip()
+    if content != HOOK_CONTENT.strip():
+        print_warning("Existing hook doesn't match Git-AI hook content")
+        print_warning("Refusing to remove potentially modified hook")
+        return
+
+    try:
+        hook_path.unlink()
+        print_success("Removed Git-AI commit-msg hook")
+    except Exception as e:
+        print_warning(f"Failed to remove hook: {e}")

gitai/providers/__init__.py

@@ -0,0 +1 @@
+"""LLM providers for GitAI."""

gitai/providers/base.py

@@ -0,0 +1,71 @@
+"""Base protocol for LLM providers."""
+
+from abc import ABC, abstractmethod
+from typing import Any, Protocol
+
+from ..config import Config
+
+
+class LLMProvider(Protocol):
+    """Protocol for LLM providers."""
+
+    @abstractmethod
+    def generate(
+        self,
+        system: str,
+        user: str,
+        *,
+        max_tokens: int | None = None,
+        temperature: float = 0.0,
+        timeout: int = 60,
+    ) -> str:
+        """Generate text using the LLM provider.
+
+        Args:
+            system: System prompt
+            user: User prompt
+            max_tokens: Maximum tokens to generate
+            temperature: Sampling temperature
+            timeout: Request timeout in seconds
+            config: Configuration object
+        Returns:
+            Generated text
+
+        Raises:
+            Exception: If generation fails
+        """
+
+
+class BaseProvider(ABC):
+    """Base class for LLM providers with common functionality."""
+
+    def __init__(self, timeout: int = 60, config: Config = Config.load()):
+        self.timeout = timeout
+        self.debug_mode = config.debug_settings.debug_mode
+
+    @abstractmethod
+    def generate(
+        self,
+        system: str,
+        user: str,
+        *,
+        max_tokens: int | None = None,
+        temperature: float = 0.0,
+        timeout: int = 60,
+    ) -> str:
+        """Generate text using the LLM provider."""
+        pass
+
+
+def create_provider(provider_name: str, **kwargs: Any) -> LLMProvider:
+    """Factory function to create LLM providers."""
+    if provider_name == "openai":
+        from .openai_provider import OpenAIProvider
+
+        return OpenAIProvider(**kwargs)
+    elif provider_name == "ollama":
+        from .ollama_provider import OllamaProvider
+
+        return OllamaProvider(**kwargs)
+    else:
+        raise ValueError(f"Unknown provider: {provider_name}")

gitai/providers/ollama_provider.py

@@ -0,0 +1,86 @@
+"""Ollama local LLM provider."""
+
+import json
+
+import requests
+from rich.console import Console
+
+from .base import BaseProvider
+
+console = Console()
+
+
+class OllamaProvider(BaseProvider):
+    """Ollama provider for local LLM models."""
+
+    def __init__(
+        self,
+        base_url: str = "http://localhost:11434",
+        model: str = "qwen2.5-coder:3b",
+        timeout: int = 60,
+    ):
+        super().__init__(timeout)
+        self.base_url = base_url.rstrip("/")
+        self.model = model
+
+    def generate(
+        self,
+        system: str,
+        user: str,
+        *,
+        max_tokens: int | None = None,
+        temperature: float = 0.0,
+        timeout: int = 60,
+    ) -> str:
+        """Generate text using Ollama API."""
+        # combine system and user prompts
+        full_prompt = f"{system}\n\n{user}"
+
+        payload = {
+            "model": self.model,
+            "prompt": full_prompt,
+            "stream": False,
+            "options": {
+                "temperature": temperature,
+                "num_predict": max_tokens,
+            },
+        }
+
+        if self.debug_mode:
+            print(
+                f"Ollama API Call - Model: {self.model}, URL: {self.base_url}/api/generate"
+            )
+            print(f"Payload: {payload}")
+            print("-" * 50)
+
+        with console.status(
+            f"[bold green]Generating with Ollama... using {self.model}", spinner="dots"
+        ):
+            try:
+                response = requests.post(
+                    f"{self.base_url}/api/generate",
+                    json=payload,
+                    timeout=timeout,
+                )
+                response.raise_for_status()
+
+                result = response.json()
+                content = result.get("response", "").strip()
+
+                if not content:
+                    raise ValueError("Empty response from Ollama API")
+                content_str: str = str(content)
+
+                if self.debug_mode:
+                    print(f"Ollama Response received ({len(content_str)} chars)")
+                    print(f"Response: {content_str}")
+                    print("-" * 50)
+
+                return content_str
+
+            except requests.exceptions.RequestException as e:
+                print(f"Ollama API Error: {e}")
+                raise RuntimeError(f"Ollama API error: {e}") from e
+            except json.JSONDecodeError as e:
+                print(f"Ollama JSON Error: {e}")
+                raise RuntimeError(f"Invalid JSON response from Ollama: {e}") from e

gitai/providers/openai_provider.py

@@ -0,0 +1,78 @@
+"""OpenAI-compatible LLM provider."""
+
+import os
+
+from openai import OpenAI
+from rich.console import Console
+
+from .base import BaseProvider
+
+console = Console()
+
+
+class OpenAIProvider(BaseProvider):
+    """OpenAI-compatible LLM provider using the OpenAI Python client."""
+
+    def __init__(
+        self,
+        api_key: str | None = None,
+        base_url: str | None = None,
+        model: str = "gpt-4o-mini",
+        timeout: int = 60,
+    ):
+        super().__init__(timeout)
+        self.api_key = api_key or os.getenv("OPENAI_API_KEY")
+        self.base_url = base_url
+        self.model = model
+        if not self.api_key:
+            raise ValueError("OPENAI_API_KEY environment variable is required")
+        self.client = OpenAI(
+            api_key=self.api_key,
+            base_url=self.base_url,
+            timeout=timeout,
+        )
+
+    def generate(
+        self,
+        system: str,
+        user: str,
+        *,
+        max_tokens: int | None = None,
+        temperature: float = 0.0,
+        timeout: int = 60,
+    ) -> str:
+        """Generate text using OpenAI API."""
+        if self.debug_mode:
+            print(
+                f"OpenAI API Call - Model: {self.model}, Max tokens: {max_tokens}, Temp: {temperature}"
+            )
+
+        # create and start spinner
+        with console.status("[bold blue]Generating with OpenAI...", spinner="dots"):
+            try:
+                response = self.client.chat.completions.create(
+                    model=self.model,
+                    messages=[
+                        {"role": "system", "content": system},
+                        {"role": "user", "content": user},
+                    ],
+                    max_tokens=max_tokens,
+                    temperature=temperature,
+                    timeout=timeout,
+                )
+
+                content = response.choices[0].message.content
+                if content is None:
+                    raise ValueError("Empty response from OpenAI API")
+                content_str: str = str(content)
+
+                if self.debug_mode:
+                    print(f"OpenAI Response received ({len(content_str)} chars)")
+                    print(f"Response: {content_str}")
+                    print("-" * 50)
+
+                return content_str.strip()
+
+            except Exception as e:
+                print(f"OpenAI API Error: {e}")
+                raise RuntimeError(f"OpenAI API error: {e}") from e