diffsage 1.2.0__py3-none-any.whl

diffsage/parsers/commit_message_parser.py

@@ -0,0 +1,43 @@
+from diffsage.exceptions import InvalidCommitMessageError
+from diffsage.models.commit_message import CommitMessage
+
+
+class CommitMessageParser:
+    @staticmethod
+    def parse(message: str) -> CommitMessage:
+        lines = message.splitlines()
+
+        if not lines:
+            raise InvalidCommitMessageError("Commit message is empty.")
+
+        header = lines[0]
+        body = lines[1:]
+
+        if ":" not in header:
+            raise InvalidCommitMessageError(
+                "Commit message header must use '<type>: <subject>' format."
+            )
+
+        header_parts = header.split(":", maxsplit=1)
+        prefix = header_parts[0].strip()
+        subject = header_parts[1].strip()
+
+        if "(" in prefix:
+            type_part = prefix.split("(", maxsplit=1)[0]
+            scope_part = prefix.split("(", maxsplit=1)[1].rstrip(")")
+        else:
+            type_part = prefix
+            scope_part = None
+
+        if not type_part:
+            raise InvalidCommitMessageError("Commit message type is missing.")
+
+        if not subject:
+            raise InvalidCommitMessageError("Commit message subject is missing.")
+
+        return CommitMessage(
+            type=type_part,
+            scope=scope_part,
+            subject=subject,
+            body=body,
+        )

diffsage/providers/base.py

@@ -0,0 +1,8 @@
+from abc import ABC, abstractmethod
+
+from diffsage.models.provider import ProviderRequest, ProviderResponse
+
+
+class BaseProvider(ABC):
+    @abstractmethod
+    def generate(self, request: ProviderRequest) -> ProviderResponse: ...

diffsage/providers/factory.py

@@ -0,0 +1,14 @@
+from diffsage.config.settings import Settings
+from diffsage.exceptions.base import ConfigError
+from diffsage.models.credentials import Credential
+from diffsage.providers.base import BaseProvider
+from diffsage.providers.gemini_provider import GeminiProvider
+
+
+def create_provider(settings: Settings, credential: Credential) -> BaseProvider:
+    """Create the configured AI provider."""
+
+    if settings.provider == "gemini":
+        return GeminiProvider(settings, credential)
+
+    raise ConfigError(f"Unsupported provider: {settings.provider}")

diffsage/providers/gemini_provider.py

@@ -0,0 +1,77 @@
+import time
+
+from google import genai
+from google.genai import errors as genai_errors
+from google.genai import types
+
+from diffsage.config.settings import Settings
+from diffsage.exceptions import (
+    AuthenticationError,
+    ModelNotFoundError,
+    ProviderError,
+    ProviderUnavailableError,
+    RateLimitError,
+)
+from diffsage.models.credentials import Credential
+from diffsage.models.provider import ProviderRequest, ProviderResponse
+from diffsage.providers.base import BaseProvider
+
+
+class GeminiProvider(BaseProvider):
+    """Google Gemini provider implementation."""
+
+    def __init__(self, settings: Settings, credential: Credential) -> None:
+        self._settings = settings
+        self._credential = credential
+
+        self._client = genai.Client(api_key=self._credential.api_key)
+
+    def generate(self, request: ProviderRequest) -> ProviderResponse:
+        start_time = time.perf_counter()
+
+        timeout_ms = self._settings.timeout * 1000
+
+        config = types.GenerateContentConfig(
+            temperature=request.temperature,
+            max_output_tokens=request.max_tokens,
+            http_options=types.HttpOptions(timeout=timeout_ms),
+        )
+
+        try:
+            response = self._client.models.generate_content(
+                model=request.model, contents=request.prompt, config=config
+            )
+        except genai_errors.APIError as e:
+            status = e.status
+
+            if status == "NOT_FOUND":
+                raise ModelNotFoundError(f"Model '{request.model}' was not found.") from e
+
+            elif status == "UNAUTHENTICATED":
+                raise AuthenticationError("Authentication with Gemini failed.") from e
+
+            elif status == "INVALID_ARGUMENT":
+                if e.code == 400:
+                    raise AuthenticationError(
+                        "Authentication with Gemini failed. Please check your API Key."
+                    ) from e
+
+            elif status == "RESOURCE_EXHAUSTED":
+                raise RateLimitError("Gemini API rate limit exceeded.") from e
+
+            elif status in ("UNAVAILABLE", "DEADLINE_EXCEEDED"):
+                raise ProviderUnavailableError("Gemini service is currently unavailable.") from e
+
+            raise ProviderError(f"Gemini API request failed: {e}") from e
+
+        latency_ms = round((time.perf_counter() - start_time) * 1000)
+
+        return ProviderResponse(
+            content=response.candidates[0].content.parts[0].text,
+            provider="gemini",
+            model=response.model_version,
+            input_tokens=response.usage_metadata.prompt_token_count,
+            output_tokens=response.usage_metadata.candidates_token_count,
+            finish_reason=response.candidates[0].finish_reason.value,
+            latency_ms=latency_ms,
+        )

diffsage/services/ai_service.py

@@ -0,0 +1,63 @@
+import time
+
+from diffsage.config.settings import Settings
+from diffsage.exceptions import CredentialNotFoundError, ProviderUnavailableError
+from diffsage.models.provider import ProviderRequest, ProviderResponse
+from diffsage.providers.base import BaseProvider
+from diffsage.providers.factory import create_provider
+from diffsage.services.credentials_service import CredentialService
+
+
+class AIService:
+    """Coordinates AI provider interactions."""
+
+    def __init__(
+        self,
+        settings: Settings,
+        credential_service: CredentialService,
+        provider: BaseProvider | None = None,
+    ) -> None:
+        self._settings = settings
+
+        if provider is not None:
+            self._provider = provider
+        else:
+            credential = credential_service.get_credential(
+                settings.provider,
+                "default",
+            )
+
+            if credential is None:
+                raise CredentialNotFoundError(
+                    settings.provider,
+                    "default",
+                )
+
+            self._provider = create_provider(settings, credential)
+
+    def _ask_once(self, prompt: str) -> ProviderResponse:
+        request = ProviderRequest(
+            prompt=prompt,
+            model=self._settings.ai_model,
+            temperature=0.2,
+            max_tokens=1000,
+        )
+
+        return self._provider.generate(request)
+
+    def _backoff_delay(self, attempt: int) -> int:
+        return 2**attempt
+
+    def ask(self, prompt: str) -> ProviderResponse:
+        total_attempts = self._settings.max_retries + 1
+
+        for attempt in range(total_attempts):
+            try:
+                return self._ask_once(prompt)
+
+            except ProviderUnavailableError:
+                if attempt == total_attempts - 1:
+                    raise
+
+                delay = self._backoff_delay(attempt)
+                time.sleep(delay)

diffsage/services/commit_service.py

@@ -0,0 +1,38 @@
+from diffsage.exceptions import NoStagedChangesError, NotGitRepositoryError
+from diffsage.git.client import GitClient
+from diffsage.logging.logger import get_logger
+from diffsage.services.ai_service import AIService
+from diffsage.services.git_service import GitService
+from diffsage.services.prompt_service import PromptService
+
+logger = get_logger(__name__)
+
+
+class CommitService:
+    def __init__(
+        self,
+        git_client: GitClient,
+        git_service: GitService,
+        prompt_service: PromptService,
+        ai_service: AIService,
+    ) -> None:
+        self._git_client = git_client
+        self._git_service = git_service
+        self._prompt_service = prompt_service
+        self._ai_service = ai_service
+
+    def generate_commit_message(self) -> str:
+        if not self._git_client.is_git_repository():
+            raise NotGitRepositoryError
+
+        if not self._git_client.staged_diff():
+            raise NoStagedChangesError
+
+        context = self._git_service.build_commit_context()
+        prompt = self._prompt_service.build_commit_prompt(context)
+
+        logger.info("Generating commit message.")
+        response = self._ai_service.ask(prompt)
+        logger.info("Commit message generated successfully.")
+
+        return response.content

diffsage/services/config_service.py

@@ -0,0 +1,109 @@
+from diffsage.config.loader import load_settings
+from diffsage.config.settings import Settings
+from diffsage.exceptions import InvalidConfigurationValueError, UnknownConfigurationKeyError
+from diffsage.models.config import ConfigReport, ConfigValueReport
+from diffsage.storage.config_repository import ConfigRepository
+
+
+class ConfigService:
+    _ATTRIBUTE_MAP = {
+        "provider": "provider",
+        "model": "ai_model",
+        "timeout": "timeout",
+        "max_retries": "max_retries",
+        "log_level": "log_level",
+    }
+
+    _NORMALIZERS = {
+        "provider": str.lower,
+        "model": str.lower,
+        "log_level": str.upper,
+    }
+
+    def __init__(self, settings: Settings, repository: ConfigRepository) -> None:
+        self._settings = settings
+        self._repository = repository
+
+    def _create_report(self, settings: Settings) -> ConfigReport:
+        return ConfigReport(
+            provider=settings.provider,
+            model=settings.ai_model,
+            timeout=settings.timeout,
+            max_retries=settings.max_retries,
+            log_level=settings.log_level,
+        )
+
+    def get_configuration_raw(self) -> ConfigReport:
+        config = self._repository.list()
+
+        return ConfigReport(
+            provider=config.get("provider"),
+            model=config.get("model"),
+            timeout=config.get("timeout"),
+            max_retries=config.get("max_retries"),
+            log_level=config.get("log_level"),
+        )
+
+    def get_configuration_value_raw(self, key: str) -> ConfigValueReport:
+        if key not in self._ATTRIBUTE_MAP:
+            raise UnknownConfigurationKeyError(key)
+
+        value = self._repository.get(key)
+
+        return ConfigValueReport(
+            key=key,
+            value=value,
+        )
+
+    def get_configuration(self) -> ConfigReport:
+        return self._create_report(self._settings)
+
+    def get_value(self, key: str) -> ConfigValueReport:
+        current_value = self._ATTRIBUTE_MAP.get(key)
+
+        if current_value is None:
+            raise UnknownConfigurationKeyError(key)
+
+        value = getattr(self._settings, current_value)
+
+        return ConfigValueReport(key=key, value=str(value))
+
+    def set_value(self, key: str, value: str) -> ConfigReport:
+        attribute_name = self._ATTRIBUTE_MAP.get(key)
+
+        if attribute_name is None:
+            raise UnknownConfigurationKeyError(key)
+
+        value = value.strip()
+        normalizer = self._NORMALIZERS.get(key)
+
+        if normalizer is not None:
+            value = normalizer(value)
+
+        expected_value = getattr(self._settings, attribute_name)
+
+        try:
+            if isinstance(expected_value, int):
+                converted_value = int(value)
+            else:
+                converted_value = value
+        except ValueError:
+            raise InvalidConfigurationValueError(value) from None
+
+        self._repository.set(key, converted_value)
+
+        updated_settings = load_settings()
+
+        return self._create_report(updated_settings)
+
+    def unset_value(self, key: str) -> ConfigReport:
+        attribute_name = self._ATTRIBUTE_MAP.get(key)
+
+        if attribute_name is None:
+            raise UnknownConfigurationKeyError(key)
+
+        self._repository.unset(key)
+
+        updated_settings = load_settings()
+
+        return self._create_report(updated_settings)

diffsage/services/credentials_service.py

@@ -0,0 +1,61 @@
+from diffsage.models.credentials import Credential
+from diffsage.storage.credentials_repository import CredentialsRepository
+
+
+class CredentialService:
+    _NORMALIZERS = {
+        "provider": str.lower,
+        "name": str.lower,
+    }
+
+    def __init__(self, repository: CredentialsRepository) -> None:
+        self._repository = repository
+
+    def set_credential(self, provider: str, api_key: str, name: str = "default") -> None:
+        provider = self._NORMALIZERS["provider"](provider.strip())
+        name = self._NORMALIZERS["name"](name.strip())
+        api_key = api_key.strip()
+
+        if not provider:
+            raise ValueError("Provider cannot be empty.")
+
+        if not name:
+            raise ValueError("Credential profile name cannot be empty.")
+
+        if not api_key:
+            raise ValueError("API key cannot be empty.")
+
+        credential = Credential(
+            provider=provider,
+            name=name,
+            api_key=api_key,
+        )
+
+        self._repository.save(credential)
+
+    def get_credential(self, provider: str, name: str = "default") -> Credential | None:
+        provider = self._NORMALIZERS["provider"](provider.strip())
+        name = self._NORMALIZERS["name"](name.strip())
+
+        if not provider:
+            raise ValueError("Provider cannot be empty.")
+
+        if not name:
+            raise ValueError("Credential profile name cannot be empty.")
+
+        return self._repository.get(provider, name)
+
+    def list_credentials(self) -> list[Credential]:
+        return self._repository.list()
+
+    def delete_credential(self, provider: str, name: str = "default") -> bool:
+        provider = self._NORMALIZERS["provider"](provider.strip())
+        name = self._NORMALIZERS["name"](name.strip())
+
+        if not provider:
+            raise ValueError("Provider cannot be empty.")
+
+        if not name:
+            raise ValueError("Credential profile cannot be empty.")
+
+        return self._repository.delete(provider, name)

diffsage/services/doctor_service.py

@@ -0,0 +1,47 @@
+import os
+import platform
+import shutil
+import subprocess
+
+from diffsage.config.loader import load_settings
+from diffsage.logging.logger import get_logger
+from diffsage.models.doctor import DoctorReport
+
+logger = get_logger(__name__)
+
+
+class DoctorService:
+    """Runs environment diagnostics."""
+
+    def run(self) -> DoctorReport:
+        logger.info("Loading application settings.")
+
+        settings = load_settings()
+
+        git_path = shutil.which("git")
+        git_installed = git_path is not None
+        git_version = None
+
+        if git_installed:
+            try:
+                result = subprocess.run(
+                    ["git", "--version"],
+                    capture_output=True,
+                    text=True,
+                    check=True,
+                )
+                git_version = result.stdout.strip()
+            except subprocess.SubprocessError:
+                git_version = None
+
+        return DoctorReport(
+            python_version=platform.python_version(),
+            git_installed=git_installed,
+            git_version=git_version,
+            provider=settings.provider,
+            timeout=settings.timeout,
+            max_retries=settings.max_retries,
+            log_level=settings.log_level,
+            virtual_environment=os.getenv("VIRTUAL_ENV") is not None,
+            configuration_loaded=True,
+        )

diffsage/services/editor_service.py

@@ -0,0 +1,75 @@
+import os
+import platform
+import shlex
+import subprocess
+import tempfile
+from pathlib import Path
+
+
+class EditorService:
+    def edit(self, text: str) -> str:
+        editor = self._resolve_editor()
+
+        temp_file = self._create_temp_file(text)
+
+        command = shlex.split(editor)
+        command.append(str(temp_file))
+
+        try:
+            subprocess.run(command, check=False)
+            text = temp_file.read_text(encoding="utf-8")
+            return text.rstrip()
+
+        except FileNotFoundError as e:
+            raise RuntimeError(
+                f'Unable to launch "{editor}". Check your EDITOR or VISUAL configuration.'
+            ) from e
+
+        finally:
+            temp_file.unlink(missing_ok=True)
+
+    def _resolve_editor(self) -> str:
+        editor = os.environ.get("VISUAL")
+        if editor:
+            return editor
+
+        editor = os.environ.get("EDITOR")
+        if editor:
+            return editor
+
+        try:
+            result = subprocess.run(
+                [
+                    "git",
+                    "config",
+                    "--global",
+                    "core.editor",
+                ],
+                capture_output=True,
+                text=True,
+                check=True,
+            )
+            editor = result.stdout.strip()
+            if editor:
+                return editor
+
+        except (subprocess.CalledProcessError, FileNotFoundError):
+            pass
+
+        if platform.system() == "Windows":
+            return "notepad"
+
+        return "nano"
+
+    def _create_temp_file(self, text: str) -> Path:
+        with tempfile.NamedTemporaryFile(
+            delete=False,
+            mode="w",
+            encoding="utf-8",
+            suffix=".txt",
+        ) as temp:
+            temp.write(text)
+            temp.flush()
+            path = Path(temp.name)
+
+        return path

diffsage/services/git_service.py

@@ -0,0 +1,20 @@
+from diffsage.git.client import GitClient
+from diffsage.models.git import CommitContext
+
+
+class GitService:
+    def __init__(self, git_client: GitClient):
+        self._git_client = git_client
+
+    def build_commit_context(
+        self,
+        recent_commit_limit: int = 10,
+    ) -> CommitContext:
+        return CommitContext(
+            branch=self._git_client.current_branch(),
+            staged_diff=self._git_client.staged_diff(),
+            unstaged_diff=self._git_client.unstaged_diff(),
+            recent_commits=self._git_client.recent_commits(
+                limit=recent_commit_limit,
+            ),
+        )

diffsage/services/prompt_service.py

@@ -0,0 +1,60 @@
+from diffsage.models.git import CommitContext
+
+
+class PromptService:
+    def _build_commit_context(
+        self,
+        context: CommitContext,
+    ) -> str:
+        lines: list[str] = []
+
+        lines.extend(
+            [
+                "Branch:",
+                context.branch,
+                "",
+                "Staged Diff:",
+                context.staged_diff,
+                "",
+                "Unstaged Diff:",
+                context.unstaged_diff,
+                "",
+                "Recent Commits:",
+            ]
+        )
+
+        for commit in context.recent_commits:
+            lines.append(f"{commit.hash} | {commit.author} | {commit.message} | {commit.date}")
+
+        return "\n".join(lines)
+
+    def _build_commit_instructions(self) -> str:
+        """Build a prompt for generating a Git commit message."""
+
+        return """
+    Generate a concise Conventional Commit message for the following Git diff.
+
+    Requirements:
+    - Return only the commit message.
+    - Follow the Conventional Commits specification.
+    - Keep the subject under 72 characters.
+    - Write the subject in the imperative mood.
+    - Leave exactly one blank line after the subject.
+    - For simple changes, return only the subject line.
+    - For changes affecting multiple files, features, 
+      refactoring, architecture, or significant fixes, always include a body.
+    - If a body is included, it MUST contain 3–6 bullet points.
+    - Use dashes (-) for bullets.
+    - Do not write body paragraphs.
+    - Start each bullet with an imperative verb (e.g., Add, Update, Remove, Refactor, Fix).
+    - End each bullet with a period.
+    - Each bullet should describe one significant change.
+    - Keep each bullet concise.
+    - Do not include Markdown headings, explanations, or code fences.
+
+    Repository Context:
+
+    """.strip()
+
+    def build_commit_prompt(self, context: CommitContext) -> str:
+        return f"{self._build_commit_instructions()}\n\n{self._build_commit_context(context)}"