comit-cli 1.0.0__py3-none-any.whl

comit/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.0.0"

comit/ai/__init__.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+from comit.ai.base import (
+    ComitAIError,
+    APIKeyMissingError,
+    AIAuthenticationError,
+    AIServiceError,
+    AIResponseError,
+    UnsupportedProviderError,
+    AIProvider,
+)
+from comit.ai.groq_provider import GroqProvider
+from comit.ai.gemini_provider import GeminiProvider
+from comit.ai.openai_provider import OpenAIProvider
+from comit.ai.ollama_provider import OllamaProvider
+from comit.ai.factory import (
+    SUPPORTED_PROVIDERS,
+    get_provider,
+    get_default_provider,
+    generate_commit_message,
+)
+
+__all__ = [
+    "ComitAIError",
+    "APIKeyMissingError",
+    "AIAuthenticationError",
+    "AIServiceError",
+    "AIResponseError",
+    "UnsupportedProviderError",
+    "AIProvider",
+    "GroqProvider",
+    "GeminiProvider",
+    "OpenAIProvider",
+    "OllamaProvider",
+    "SUPPORTED_PROVIDERS",
+    "get_provider",
+    "get_default_provider",
+    "generate_commit_message",
+]

comit/ai/base.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import List, Optional, Union
+
+from comit.commit.context import CommitContext
+
+
+class ComitAIError(Exception):
+    pass
+
+
+class APIKeyMissingError(ComitAIError):
+    pass
+
+
+class AIAuthenticationError(ComitAIError):
+    pass
+
+
+class AIServiceError(ComitAIError):
+    pass
+
+
+class AIResponseError(ComitAIError):
+    pass
+
+
+class UnsupportedProviderError(ComitAIError):
+    pass
+
+
+class AIProvider(ABC):
+    @abstractmethod
+    def generate_commit_message(
+        self,
+        context: Union[CommitContext, str, None] = None,
+        recent_commits: Optional[List[str]] = None,
+        avoid_messages: Optional[List[str]] = None,
+        diff: Optional[str] = None,
+    ) -> str:
+        pass

comit/ai/factory.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+from typing import List, Optional, Union
+
+from comit.ai.base import (
+    AIProvider,
+    UnsupportedProviderError,
+)
+from comit.ai.groq_provider import GroqProvider
+from comit.ai.gemini_provider import GeminiProvider
+from comit.ai.openai_provider import OpenAIProvider
+from comit.ai.ollama_provider import OllamaProvider
+from comit.commit.context import CommitContext
+from comit.config import get_provider as config_get_provider
+
+SUPPORTED_PROVIDERS = ("groq", "gemini", "openai", "ollama")
+
+
+def get_provider(
+    provider_name: Optional[str] = None,
+    model: Optional[str] = None,
+    api_key: Optional[str] = None,
+) -> AIProvider:
+    name = (provider_name or config_get_provider()).strip().lower()
+
+    if name == "groq":
+        return GroqProvider(api_key=api_key, model=model)
+    elif name == "gemini":
+        return GeminiProvider(api_key=api_key, model=model)
+    elif name == "openai":
+        return OpenAIProvider(api_key=api_key, model=model)
+    elif name == "ollama":
+        return OllamaProvider(model=model)
+    else:
+        supported_str = ", ".join(SUPPORTED_PROVIDERS)
+        raise UnsupportedProviderError(
+            f"Unsupported AI provider '{name}'. Supported providers: {supported_str}"
+        )
+
+
+def get_default_provider() -> AIProvider:
+    return get_provider()
+
+
+def generate_commit_message(
+    context: Union[CommitContext, str, None] = None,
+    recent_commits: Optional[List[str]] = None,
+    avoid_messages: Optional[List[str]] = None,
+    diff: Optional[str] = None,
+    provider: Optional[AIProvider] = None,
+) -> str:
+    if provider is None:
+        provider = get_default_provider()
+    target = context if context is not None else (diff or "")
+    return provider.generate_commit_message(
+        context=target,
+        recent_commits=recent_commits,
+        avoid_messages=avoid_messages,
+    )

comit/ai/gemini_provider.py

@@ -0,0 +1,125 @@
+from __future__ import annotations
+
+from typing import List, Optional, Union
+
+from comit.ai.base import (
+    AIProvider,
+    APIKeyMissingError,
+    AIAuthenticationError,
+    AIServiceError,
+    AIResponseError,
+)
+from comit.commit.context import CommitContext
+from comit.config import get_api_key, get_model
+from comit.prompts import SYSTEM_PROMPT, build_commit_prompt, sanitize_commit_message
+
+
+class GeminiProvider(AIProvider):
+    def __init__(self, api_key: Optional[str] = None, model: Optional[str] = None):
+        self.api_key = get_api_key(api_key, provider="gemini")
+        if not self.api_key:
+            raise APIKeyMissingError(
+                "GEMINI_API_KEY is not configured.\n"
+                "Run 'git ai settings set-key --provider gemini' or export GEMINI_API_KEY in your shell."
+            )
+
+        self.model = get_model(model, provider="gemini")
+        self._client = None
+
+    def _get_client(self):
+        if self._client is None:
+            try:
+                from google import genai
+                self._client = genai.Client(api_key=self.api_key)
+            except ImportError as exc:
+                raise AIServiceError(
+                    "The 'google-genai' package is not installed. Please run: pip install google-genai"
+                ) from exc
+            except Exception as exc:
+                raise AIServiceError(f"Failed to initialize Gemini client: {exc}") from exc
+        return self._client
+
+    def generate_commit_message(
+        self,
+        context: Union[CommitContext, str, None] = None,
+        recent_commits: Optional[List[str]] = None,
+        avoid_messages: Optional[List[str]] = None,
+        diff: Optional[str] = None,
+    ) -> str:
+        target = context if context is not None else (diff or "")
+        client = self._get_client()
+        user_prompt = build_commit_prompt(target, recent_commits=recent_commits, avoid_messages=avoid_messages)
+        temperature = 0.7 if avoid_messages else 0.2
+
+        try:
+            from google.genai import types
+            config = types.GenerateContentConfig(
+                system_instruction=SYSTEM_PROMPT,
+                temperature=temperature,
+                max_output_tokens=250,
+            )
+        except ImportError:
+            config = {
+                "system_instruction": SYSTEM_PROMPT,
+                "temperature": temperature,
+                "max_output_tokens": 250,
+            }
+
+        try:
+            response = client.models.generate_content(
+                model=self.model,
+                contents=user_prompt,
+                config=config,
+            )
+        except Exception as exc:
+            err_msg = str(exc).lower()
+            if "api_key_invalid" in err_msg or "unauthenticated" in err_msg or "401" in err_msg or "403" in err_msg or "permission denied" in err_msg:
+                raise AIAuthenticationError(
+                    "Gemini authentication failed. Please verify that your GEMINI_API_KEY is valid."
+                ) from exc
+            if "resource_exhausted" in err_msg or "429" in err_msg or "quota" in err_msg:
+                raise AIServiceError(
+                    "Gemini rate limit reached. Please wait a moment and try again."
+                ) from exc
+            raise AIServiceError(f"Gemini API returned an error: {exc}") from exc
+
+        if not response or not hasattr(response, "text") or not response.text:
+            raise AIResponseError("Gemini API returned an empty response. Please try again.")
+
+        cleaned = sanitize_commit_message(response.text)
+
+        if avoid_messages and cleaned in avoid_messages:
+            try:
+                stronger_prompt = (
+                    f"{user_prompt}\n\n"
+                    "CRITICAL: The previous message was already generated. You MUST produce a distinct alternative phrasing."
+                )
+                try:
+                    from google.genai import types
+                    retry_config = types.GenerateContentConfig(
+                        system_instruction=SYSTEM_PROMPT,
+                        temperature=0.9,
+                        max_output_tokens=250,
+                    )
+                except ImportError:
+                    retry_config = {
+                        "system_instruction": SYSTEM_PROMPT,
+                        "temperature": 0.9,
+                        "max_output_tokens": 250,
+                    }
+                retry_response = client.models.generate_content(
+                    model=self.model,
+                    contents=stronger_prompt,
+                    config=retry_config,
+                )
+                if retry_response and hasattr(retry_response, "text") and retry_response.text:
+                    retry_cleaned = sanitize_commit_message(retry_response.text)
+                    if retry_cleaned:
+                        return retry_cleaned
+            except Exception:
+                pass
+
+        if not cleaned:
+            raise AIResponseError("Failed to extract a valid commit message from the AI response.")
+
+        return cleaned

comit/ai/groq_provider.py

@@ -0,0 +1,121 @@
+from __future__ import annotations
+
+from typing import List, Optional, Union
+
+from comit.ai.base import (
+    AIProvider,
+    APIKeyMissingError,
+    AIAuthenticationError,
+    AIServiceError,
+    AIResponseError,
+)
+from comit.commit.context import CommitContext
+from comit.config import get_api_key, get_model
+from comit.prompts import SYSTEM_PROMPT, build_commit_prompt, sanitize_commit_message
+
+
+class GroqProvider(AIProvider):
+    def __init__(self, api_key: Optional[str] = None, model: Optional[str] = None):
+        self.api_key = get_api_key(api_key, provider="groq")
+        if not self.api_key:
+            raise APIKeyMissingError(
+                "GROQ_API_KEY is not configured.\n"
+                "Run 'git ai settings set-key' or export GROQ_API_KEY in your shell."
+            )
+
+        self.model = get_model(model, provider="groq")
+        self._client = None
+
+    def _get_client(self):
+        if self._client is None:
+            try:
+                from groq import Groq
+                self._client = Groq(api_key=self.api_key)
+            except ImportError as exc:
+                raise AIServiceError(
+                    "The 'groq' package is not installed. Please run: pip install groq"
+                ) from exc
+            except Exception as exc:
+                raise AIServiceError(f"Failed to initialize Groq client: {exc}") from exc
+        return self._client
+
+    def generate_commit_message(
+        self,
+        context: Union[CommitContext, str, None] = None,
+        recent_commits: Optional[List[str]] = None,
+        avoid_messages: Optional[List[str]] = None,
+        diff: Optional[str] = None,
+    ) -> str:
+        try:
+            import groq
+        except ImportError as exc:
+            raise AIServiceError(
+                "The 'groq' package is not installed. Please run: pip install groq"
+            ) from exc
+
+        target = context if context is not None else (diff or "")
+        client = self._get_client()
+        user_prompt = build_commit_prompt(target, recent_commits=recent_commits, avoid_messages=avoid_messages)
+        temperature = 0.7 if avoid_messages else 0.2
+
+        try:
+            response = client.chat.completions.create(
+                model=self.model,
+                messages=[
+                    {"role": "system", "content": SYSTEM_PROMPT},
+                    {"role": "user", "content": user_prompt},
+                ],
+                temperature=temperature,
+                max_tokens=250,
+            )
+        except groq.AuthenticationError as exc:
+            raise AIAuthenticationError(
+                "Groq authentication failed. Please verify that your GROQ_API_KEY is valid."
+            ) from exc
+        except groq.RateLimitError as exc:
+            raise AIServiceError(
+                "Groq rate limit reached. Please wait a moment and try again."
+            ) from exc
+        except groq.APIConnectionError as exc:
+            raise AIServiceError(
+                "Could not connect to the Groq API. Please check your internet connection."
+            ) from exc
+        except groq.APIStatusError as exc:
+            raise AIServiceError(
+                f"Groq API returned an error (status {exc.status_code}): {exc.message}"
+            ) from exc
+        except Exception as exc:
+            raise AIServiceError(f"Unexpected error while calling Groq API: {exc}") from exc
+
+        if not response.choices or not response.choices[0].message.content:
+            raise AIResponseError("Groq API returned an empty response. Please try again.")
+
+        raw_message = response.choices[0].message.content
+        cleaned = sanitize_commit_message(raw_message)
+
+        if avoid_messages and cleaned in avoid_messages:
+            try:
+                stronger_prompt = (
+                    f"{user_prompt}\n\n"
+                    "CRITICAL: The previous message was already generated. You MUST produce a distinct alternative phrasing."
+                )
+                retry_response = client.chat.completions.create(
+                    model=self.model,
+                    messages=[
+                        {"role": "system", "content": SYSTEM_PROMPT},
+                        {"role": "user", "content": stronger_prompt},
+                    ],
+                    temperature=0.9,
+                    max_tokens=250,
+                )
+                if retry_response.choices and retry_response.choices[0].message.content:
+                    retry_cleaned = sanitize_commit_message(retry_response.choices[0].message.content)
+                    if retry_cleaned:
+                        return retry_cleaned
+            except Exception:
+                pass
+
+        if not cleaned:
+            raise AIResponseError("Failed to extract a valid commit message from the AI response.")
+
+        return cleaned

comit/ai/ollama_provider.py

@@ -0,0 +1,107 @@
+from __future__ import annotations
+
+from typing import List, Optional, Union
+
+from comit.ai.base import (
+    AIProvider,
+    AIServiceError,
+    AIResponseError,
+)
+from comit.commit.context import CommitContext
+from comit.config import get_model, get_ollama_host
+from comit.prompts import SYSTEM_PROMPT, build_commit_prompt, sanitize_commit_message
+
+
+class OllamaProvider(AIProvider):
+    def __init__(self, model: Optional[str] = None, host: Optional[str] = None):
+        self.model = get_model(model, provider="ollama")
+        self.host = get_ollama_host(host)
+        self._client = None
+
+    def _get_client(self):
+        if self._client is None:
+            try:
+                import ollama
+                self._client = ollama.Client(host=self.host)
+            except ImportError as exc:
+                raise AIServiceError(
+                    "The 'ollama' package is not installed. Please run: pip install ollama"
+                ) from exc
+            except Exception as exc:
+                raise AIServiceError(f"Failed to initialize Ollama client: {exc}") from exc
+        return self._client
+
+    def generate_commit_message(
+        self,
+        context: Union[CommitContext, str, None] = None,
+        recent_commits: Optional[List[str]] = None,
+        avoid_messages: Optional[List[str]] = None,
+        diff: Optional[str] = None,
+    ) -> str:
+        target = context if context is not None else (diff or "")
+        client = self._get_client()
+        user_prompt = build_commit_prompt(target, recent_commits=recent_commits, avoid_messages=avoid_messages)
+        temperature = 0.7 if avoid_messages else 0.2
+
+        try:
+            response = client.chat(
+                model=self.model,
+                messages=[
+                    {"role": "system", "content": SYSTEM_PROMPT},
+                    {"role": "user", "content": user_prompt},
+                ],
+                options={"temperature": temperature, "num_predict": 250},
+            )
+        except Exception as exc:
+            err_msg = str(exc)
+            if "ConnectError" in err_msg or "ConnectionRefused" in err_msg or "connection refused" in err_msg.lower() or "Failed to connect" in err_msg:
+                raise AIServiceError(
+                    f"Could not connect to Ollama server at {self.host}. Please ensure the Ollama service is running."
+                ) from exc
+            if "not found" in err_msg.lower() and "model" in err_msg.lower():
+                raise AIServiceError(
+                    f"Ollama model '{self.model}' was not found. Please run 'ollama pull {self.model}' first."
+                ) from exc
+            raise AIServiceError(f"Ollama error: {exc}") from exc
+
+        content = ""
+        if isinstance(response, dict):
+            content = response.get("message", {}).get("content", "")
+        elif hasattr(response, "message") and hasattr(response.message, "content"):
+            content = response.message.content
+
+        if not content:
+            raise AIResponseError("Ollama returned an empty response. Please try again.")
+
+        cleaned = sanitize_commit_message(content)
+
+        if avoid_messages and cleaned in avoid_messages:
+            try:
+                stronger_prompt = (
+                    f"{user_prompt}\n\n"
+                    "CRITICAL: The previous message was already generated. You MUST produce a distinct alternative phrasing."
+                )
+                retry_response = client.chat(
+                    model=self.model,
+                    messages=[
+                        {"role": "system", "content": SYSTEM_PROMPT},
+                        {"role": "user", "content": stronger_prompt},
+                    ],
+                    options={"temperature": 0.9, "num_predict": 250},
+                )
+                retry_content = ""
+                if isinstance(retry_response, dict):
+                    retry_content = retry_response.get("message", {}).get("content", "")
+                elif hasattr(retry_response, "message") and hasattr(retry_response.message, "content"):
+                    retry_content = retry_response.message.content
+                if retry_content:
+                    retry_cleaned = sanitize_commit_message(retry_content)
+                    if retry_cleaned:
+                        return retry_cleaned
+            except Exception:
+                pass
+
+        if not cleaned:
+            raise AIResponseError("Failed to extract a valid commit message from the AI response.")
+
+        return cleaned

comit/ai/openai_provider.py

@@ -0,0 +1,107 @@
+from __future__ import annotations
+
+from typing import List, Optional, Union
+
+from comit.ai.base import (
+    AIProvider,
+    APIKeyMissingError,
+    AIAuthenticationError,
+    AIServiceError,
+    AIResponseError,
+)
+from comit.commit.context import CommitContext
+from comit.config import get_api_key, get_model
+from comit.prompts import SYSTEM_PROMPT, build_commit_prompt, sanitize_commit_message
+
+
+class OpenAIProvider(AIProvider):
+    def __init__(self, api_key: Optional[str] = None, model: Optional[str] = None):
+        self.api_key = get_api_key(api_key, provider="openai")
+        if not self.api_key:
+            raise APIKeyMissingError(
+                "OPENAI_API_KEY is not configured.\n"
+                "Run 'git ai settings set-key --provider openai' or export OPENAI_API_KEY in your shell."
+            )
+
+        self.model = get_model(model, provider="openai")
+        self._client = None
+
+    def _get_client(self):
+        if self._client is None:
+            try:
+                from openai import OpenAI
+                self._client = OpenAI(api_key=self.api_key)
+            except ImportError as exc:
+                raise AIServiceError(
+                    "The 'openai' package is not installed. Please run: pip install openai"
+                ) from exc
+            except Exception as exc:
+                raise AIServiceError(f"Failed to initialize OpenAI client: {exc}") from exc
+        return self._client
+
+    def generate_commit_message(
+        self,
+        context: Union[CommitContext, str, None] = None,
+        recent_commits: Optional[List[str]] = None,
+        avoid_messages: Optional[List[str]] = None,
+        diff: Optional[str] = None,
+    ) -> str:
+        target = context if context is not None else (diff or "")
+        client = self._get_client()
+        user_prompt = build_commit_prompt(target, recent_commits=recent_commits, avoid_messages=avoid_messages)
+        temperature = 0.7 if avoid_messages else 0.2
+
+        try:
+            response = client.chat.completions.create(
+                model=self.model,
+                messages=[
+                    {"role": "system", "content": SYSTEM_PROMPT},
+                    {"role": "user", "content": user_prompt},
+                ],
+                temperature=temperature,
+                max_tokens=250,
+            )
+        except Exception as exc:
+            err_msg = str(exc).lower()
+            if "authentication" in err_msg or "incorrect api key" in err_msg or "401" in err_msg or "invalid_api_key" in err_msg:
+                raise AIAuthenticationError(
+                    "OpenAI authentication failed. Please verify that your OPENAI_API_KEY is valid."
+                ) from exc
+            if "rate limit" in err_msg or "429" in err_msg or "quota" in err_msg:
+                raise AIServiceError(
+                    "OpenAI rate limit reached. Please wait a moment and try again."
+                ) from exc
+            raise AIServiceError(f"OpenAI API returned an error: {exc}") from exc
+
+        if not response or not hasattr(response, "choices") or not response.choices or not response.choices[0].message.content:
+            raise AIResponseError("OpenAI API returned an empty response. Please try again.")
+
+        raw_message = response.choices[0].message.content
+        cleaned = sanitize_commit_message(raw_message)
+
+        if avoid_messages and cleaned in avoid_messages:
+            try:
+                stronger_prompt = (
+                    f"{user_prompt}\n\n"
+                    "CRITICAL: The previous message was already generated. You MUST produce a distinct alternative phrasing."
+                )
+                retry_response = client.chat.completions.create(
+                    model=self.model,
+                    messages=[
+                        {"role": "system", "content": SYSTEM_PROMPT},
+                        {"role": "user", "content": stronger_prompt},
+                    ],
+                    temperature=0.9,
+                    max_tokens=250,
+                )
+                if retry_response and retry_response.choices and retry_response.choices[0].message.content:
+                    retry_cleaned = sanitize_commit_message(retry_response.choices[0].message.content)
+                    if retry_cleaned:
+                        return retry_cleaned
+            except Exception:
+                pass
+
+        if not cleaned:
+            raise AIResponseError("Failed to extract a valid commit message from the AI response.")
+
+        return cleaned