gac 1.4.2__tar.gz → 1.5.1__tar.gz

{gac-1.4.2 → gac-1.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gac
-Version: 1.4.2
+Version: 1.5.1
 Summary: AI-powered Git commit message generator with multi-provider support
 Project-URL: Homepage, https://github.com/cellwebb/gac
 Project-URL: Documentation, https://github.com/cellwebb/gac#readme

{gac-1.4.2 → gac-1.5.1}/src/gac/__version__.py

@@ -1,3 +1,3 @@
 """Version information for gac package."""
 
-__version__ = "1.4.2"
+__version__ = "1.5.1"

{gac-1.4.2 → gac-1.5.1}/src/gac/ai.py

@@ -12,7 +12,9 @@ from gac.errors import AIError
 from gac.providers import (
     call_anthropic_api,
     call_cerebras_api,
+    call_gemini_api,
     call_groq_api,
+    call_lmstudio_api,
     call_ollama_api,
     call_openai_api,
     call_openrouter_api,
@@ -71,6 +73,8 @@ def generate_commit_message(
         "openrouter": call_openrouter_api,
         "zai": call_zai_api,
         "zai-coding": call_zai_coding_api,
+        "gemini": call_gemini_api,
+        "lmstudio": call_lmstudio_api,
     }
 
     # Generate the commit message using centralized retry logic

{gac-1.4.2 → gac-1.5.1}/src/gac/ai_utils.py

@@ -93,7 +93,18 @@ def generate_with_retries(
     provider, model_name = model.split(":", 1)
 
     # Validate provider
-    supported_providers = ["anthropic", "openai", "groq", "cerebras", "ollama", "openrouter", "zai", "zai-coding"]
+    supported_providers = [
+        "anthropic",
+        "cerebras",
+        "gemini",
+        "groq",
+        "lmstudio",
+        "ollama",
+        "openai",
+        "openrouter",
+        "zai",
+        "zai-coding",
+    ]
     if provider not in supported_providers:
         raise AIError.model_error(f"Unsupported provider: {provider}. Supported providers: {supported_providers}")
 

{gac-1.4.2 → gac-1.5.1}/src/gac/init_cli.py

@@ -22,7 +22,9 @@ def init() -> None:
     providers = [
         ("Anthropic", "claude-3-5-haiku-latest"),
         ("Cerebras", "qwen-3-coder-480b"),
+        ("Gemini", "gemini-2.5-flash"),
         ("Groq", "meta-llama/llama-4-maverick-17b-128e-instruct"),
+        ("LM Studio", "deepseek-r1-distill-qwen-7b"),
         ("Ollama", "gemma3"),
         ("OpenAI", "gpt-4.1-mini"),
         ("OpenRouter", "openrouter/auto"),

{gac-1.4.2 → gac-1.5.1}/src/gac/providers/__init__.py

@@ -2,7 +2,9 @@
 
 from .anthropic import call_anthropic_api
 from .cerebras import call_cerebras_api
+from .gemini import call_gemini_api
 from .groq import call_groq_api
+from .lmstudio import call_lmstudio_api
 from .ollama import call_ollama_api
 from .openai import call_openai_api
 from .openrouter import call_openrouter_api
@@ -11,7 +13,9 @@ from .zai import call_zai_api, call_zai_coding_api
 __all__ = [
     "call_anthropic_api",
     "call_cerebras_api",
+    "call_gemini_api",
     "call_groq_api",
+    "call_lmstudio_api",
     "call_ollama_api",
     "call_openai_api",
     "call_openrouter_api",

{gac-1.4.2 → gac-1.5.1}/src/gac/providers/anthropic.py

@@ -35,7 +35,12 @@ def call_anthropic_api(model: str, messages: list[dict], temperature: float, max
         response = httpx.post(url, headers=headers, json=data, timeout=120)
         response.raise_for_status()
         response_data = response.json()
-        return response_data["content"][0]["text"]
+        content = response_data["content"][0]["text"]
+        if content is None:
+            raise AIError.model_error("Anthropic API returned null content")
+        if content == "":
+            raise AIError.model_error("Anthropic API returned empty content")
+        return content
     except httpx.HTTPStatusError as e:
         raise AIError.model_error(f"Anthropic API error: {e.response.status_code} - {e.response.text}") from e
     except Exception as e:

{gac-1.4.2 → gac-1.5.1}/src/gac/providers/cerebras.py

@@ -22,7 +22,12 @@ def call_cerebras_api(model: str, messages: list[dict], temperature: float, max_
         response = httpx.post(url, headers=headers, json=data, timeout=120)
         response.raise_for_status()
         response_data = response.json()
-        return response_data["choices"][0]["message"]["content"]
+        content = response_data["choices"][0]["message"]["content"]
+        if content is None:
+            raise AIError.model_error("Cerebras API returned null content")
+        if content == "":
+            raise AIError.model_error("Cerebras API returned empty content")
+        return content
     except httpx.HTTPStatusError as e:
         raise AIError.model_error(f"Cerebras API error: {e.response.status_code} - {e.response.text}") from e
     except Exception as e:

gac-1.5.1/src/gac/providers/gemini.py

@@ -0,0 +1,70 @@
+"""Gemini AI provider implementation."""
+
+import os
+from typing import Any
+
+import httpx
+
+from gac.errors import AIError
+
+
+def call_gemini_api(model: str, messages: list[dict[str, Any]], temperature: float, max_tokens: int) -> str:
+    """Call Gemini API directly."""
+    api_key = os.getenv("GEMINI_API_KEY")
+    if not api_key:
+        raise AIError.model_error("GEMINI_API_KEY not found in environment variables")
+
+    url = f"https://generativelanguage.googleapis.com/v1beta/models/{model}:generateContent"
+
+    # Build contents array following 2025 Gemini API format
+    contents = []
+
+    # Add system instruction as first content with role "system" (2025 format)
+    for msg in messages:
+        if msg["role"] == "system":
+            contents.append({"role": "system", "parts": [{"text": msg["content"]}]})
+            break
+
+    # Add user and assistant messages
+    for msg in messages:
+        if msg["role"] == "user":
+            contents.append({"role": "user", "parts": [{"text": msg["content"]}]})
+        elif msg["role"] == "assistant":
+            contents.append(
+                {
+                    "role": "model",  # Gemini uses "model" instead of "assistant"
+                    "parts": [{"text": msg["content"]}],
+                }
+            )
+
+    payload: dict[str, Any] = {
+        "contents": contents,
+        "generationConfig": {"temperature": temperature, "maxOutputTokens": max_tokens},
+    }
+
+    headers = {"x-goog-api-key": api_key, "Content-Type": "application/json"}
+
+    try:
+        response = httpx.post(url, headers=headers, json=payload, timeout=120)
+        response.raise_for_status()
+        response_data = response.json()
+
+        # Check for candidates and proper response structure
+        if not response_data.get("candidates"):
+            raise AIError.model_error("Gemini API response missing candidates")
+
+        candidate = response_data["candidates"][0]
+        if "content" not in candidate or "parts" not in candidate["content"] or not candidate["content"]["parts"]:
+            raise AIError.model_error("Gemini API response has invalid content structure")
+
+        content = candidate["content"]["parts"][0].get("text")
+        if content is None or content == "":
+            raise AIError.model_error("Gemini API response missing text content")
+
+        return content
+    except AIError:
+        raise
+    except httpx.HTTPStatusError as e:
+        raise AIError.model_error(f"Gemini API error: {e.response.status_code} - {e.response.text}") from e
+    except Exception as e:
+        raise AIError.model_error(f"Error calling Gemini API: {str(e)}") from e

gac-1.5.1/src/gac/providers/lmstudio.py

@@ -0,0 +1,55 @@
+"""LM Studio AI provider implementation."""
+
+import os
+from typing import Any
+
+import httpx
+
+from gac.errors import AIError
+
+
+def call_lmstudio_api(model: str, messages: list[dict[str, Any]], temperature: float, max_tokens: int) -> str:
+    """Call LM Studio's OpenAI-compatible API."""
+    api_url = os.getenv("LMSTUDIO_API_URL", "http://localhost:1234")
+    api_url = api_url.rstrip("/")
+
+    url = f"{api_url}/v1/chat/completions"
+
+    headers = {"Content-Type": "application/json"}
+    api_key = os.getenv("LMSTUDIO_API_KEY")
+    if api_key:
+        headers["Authorization"] = f"Bearer {api_key}"
+
+    payload: dict[str, Any] = {
+        "model": model,
+        "messages": messages,
+        "temperature": temperature,
+        "max_tokens": max_tokens,
+        "stream": False,
+    }
+
+    try:
+        response = httpx.post(url, headers=headers, json=payload, timeout=120)
+        response.raise_for_status()
+        response_data = response.json()
+        choices = response_data.get("choices") or []
+        if not choices:
+            raise AIError.model_error("LM Studio API response missing choices")
+
+        message = choices[0].get("message") or {}
+        content = message.get("content")
+        if content:
+            return content
+
+        # Some OpenAI-compatible servers return text field directly
+        content = choices[0].get("text")
+        if content:
+            return content
+
+        raise AIError.model_error("LM Studio API response missing content")
+    except httpx.ConnectError as e:
+        raise AIError.connection_error(f"LM Studio connection failed: {str(e)}") from e
+    except httpx.HTTPStatusError as e:
+        raise AIError.model_error(f"LM Studio API error: {e.response.status_code} - {e.response.text}") from e
+    except Exception as e:
+        raise AIError.model_error(f"Error calling LM Studio API: {str(e)}") from e

{gac-1.4.2 → gac-1.5.1}/src/gac/providers/ollama.py

@@ -10,23 +10,34 @@ from gac.errors import AIError
 def call_ollama_api(model: str, messages: list[dict], temperature: float, max_tokens: int) -> str:
     """Call Ollama API directly."""
     api_url = os.getenv("OLLAMA_API_URL", "http://localhost:11434")
+    api_key = os.getenv("OLLAMA_API_KEY")
 
     url = f"{api_url.rstrip('/')}/api/chat"
     data = {"model": model, "messages": messages, "temperature": temperature, "stream": False}
+    headers = {"Content-Type": "application/json"}
+    if api_key:
+        headers["Authorization"] = f"Bearer {api_key}"
 
     try:
-        response = httpx.post(url, json=data, timeout=120)
+        response = httpx.post(url, headers=headers, json=data, timeout=120)
         response.raise_for_status()
         response_data = response.json()
 
+        content = None
         # Handle different response formats from Ollama
         if "message" in response_data and "content" in response_data["message"]:
-            return response_data["message"]["content"]
+            content = response_data["message"]["content"]
         elif "response" in response_data:
-            return response_data["response"]
+            content = response_data["response"]
         else:
             # Fallback: return the full response as string
-            return str(response_data)
+            content = str(response_data)
+
+        if content is None:
+            raise AIError.model_error("Ollama API returned null content")
+        if content == "":
+            raise AIError.model_error("Ollama API returned empty content")
+        return content
     except httpx.ConnectError as e:
         raise AIError.connection_error(f"Ollama connection failed. Make sure Ollama is running: {str(e)}") from e
     except httpx.HTTPStatusError as e:

{gac-1.4.2 → gac-1.5.1}/src/gac/providers/openai.py

@@ -22,7 +22,12 @@ def call_openai_api(model: str, messages: list[dict], temperature: float, max_to
         response = httpx.post(url, headers=headers, json=data, timeout=120)
         response.raise_for_status()
         response_data = response.json()
-        return response_data["choices"][0]["message"]["content"]
+        content = response_data["choices"][0]["message"]["content"]
+        if content is None:
+            raise AIError.model_error("OpenAI API returned null content")
+        if content == "":
+            raise AIError.model_error("OpenAI API returned empty content")
+        return content
     except httpx.HTTPStatusError as e:
         raise AIError.model_error(f"OpenAI API error: {e.response.status_code} - {e.response.text}") from e
     except Exception as e:

{gac-1.4.2 → gac-1.5.1}/src/gac/providers/openrouter.py

@@ -30,7 +30,12 @@ def call_openrouter_api(model: str, messages: list[dict], temperature: float, ma
         response = httpx.post(url, headers=headers, json=data, timeout=120)
         response.raise_for_status()
         response_data = response.json()
-        return response_data["choices"][0]["message"]["content"]
+        content = response_data["choices"][0]["message"]["content"]
+        if content is None:
+            raise AIError.model_error("OpenRouter API returned null content")
+        if content == "":
+            raise AIError.model_error("OpenRouter API returned empty content")
+        return content
     except httpx.HTTPStatusError as e:
         # Handle specific HTTP status codes
         status_code = e.response.status_code