gac 1.1.0__py3-none-any.whl → 1.2.0__py3-none-any.whl

gac/__init__.py

@@ -4,12 +4,12 @@ from gac.__version__ import __version__
 from gac.ai import generate_commit_message
 from gac.git import get_staged_files, push_changes
 from gac.prompt import build_prompt, clean_commit_message
-from gac.providers.anthropic import generate as anthropic_generate
-from gac.providers.cerebras import generate as cerebras_generate
-from gac.providers.groq import generate as groq_generate
-from gac.providers.ollama import generate as ollama_generate
-from gac.providers.openai import generate as openai_generate
-from gac.providers.openrouter import generate as openrouter_generate
+from gac.providers.anthropic import call_anthropic_api as anthropic_generate
+from gac.providers.cerebras import call_cerebras_api as cerebras_generate
+from gac.providers.groq import call_groq_api as groq_generate
+from gac.providers.ollama import call_ollama_api as ollama_generate
+from gac.providers.openai import call_openai_api as openai_generate
+from gac.providers.openrouter import call_openrouter_api as openrouter_generate
 
 __all__ = [
     "__version__",

gac/__version__.py

@@ -1,3 +1,3 @@
 """Version information for gac package."""
 
-__version__ = "1.1.0"
+__version__ = "1.2.0"

gac/ai.py

@@ -6,14 +6,17 @@ It consolidates all AI-related functionality including token counting and commit
 
 import logging
 
+from gac.ai_utils import generate_with_retries
 from gac.constants import EnvDefaults
 from gac.errors import AIError
-from gac.providers.anthropic import generate as anthropic_generate
-from gac.providers.cerebras import generate as cerebras_generate
-from gac.providers.groq import generate as groq_generate
-from gac.providers.ollama import generate as ollama_generate
-from gac.providers.openai import generate as openai_generate
-from gac.providers.openrouter import generate as openrouter_generate
+from gac.providers import (
+    call_anthropic_api,
+    call_cerebras_api,
+    call_groq_api,
+    call_ollama_api,
+    call_openai_api,
+    call_openrouter_api,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -48,33 +51,36 @@ def generate_commit_message(
         >>> generate_commit_message(model, (system_prompt, user_prompt))
         'docs: Update README with installation instructions'
     """
-    try:
-        _, _ = model.split(":", 1)
-    except ValueError as err:
-        raise AIError.model_error(
-            f"Invalid model format: {model}. Please use the format 'provider:model_name'."
-        ) from err
+    # Handle both old (string) and new (tuple) prompt formats
+    if isinstance(prompt, tuple):
+        system_prompt, user_prompt = prompt
+    else:
+        # Backward compatibility: treat string as user prompt with no system prompt
+        system_prompt = ""
+        user_prompt = prompt
 
-    # Parse the model string to extract provider and model name
-    try:
-        provider, model_name = model.split(":", 1)
-    except ValueError as err:
-        raise AIError.model_error(
-            f"Invalid model format: {model}. Please use the format 'provider:model_name'."
-        ) from err
+    # Provider functions mapping
+    provider_funcs = {
+        "anthropic": call_anthropic_api,
+        "openai": call_openai_api,
+        "groq": call_groq_api,
+        "cerebras": call_cerebras_api,
+        "ollama": call_ollama_api,
+        "openrouter": call_openrouter_api,
+    }
 
-    # Route to the appropriate provider function
-    if provider == "openai":
-        return openai_generate(model_name, prompt, temperature, max_tokens, max_retries, quiet)
-    elif provider == "anthropic":
-        return anthropic_generate(model_name, prompt, temperature, max_tokens, max_retries, quiet)
-    elif provider == "groq":
-        return groq_generate(model_name, prompt, temperature, max_tokens, max_retries, quiet)
-    elif provider == "cerebras":
-        return cerebras_generate(model_name, prompt, temperature, max_tokens, max_retries, quiet)
-    elif provider == "ollama":
-        return ollama_generate(model_name, prompt, temperature, max_tokens, max_retries, quiet)
-    elif provider == "openrouter":
-        return openrouter_generate(model_name, prompt, temperature, max_tokens, max_retries, quiet)
-    else:
-        raise AIError.model_error(f"Unsupported provider: {provider}")
+    # Generate the commit message using centralized retry logic
+    try:
+        return generate_with_retries(
+            provider_funcs=provider_funcs,
+            model=model,
+            system_prompt=system_prompt,
+            user_prompt=user_prompt,
+            temperature=temperature,
+            max_tokens=max_tokens,
+            max_retries=max_retries,
+            quiet=quiet,
+        )
+    except Exception as e:
+        logger.error(f"Failed to generate commit message: {e}")
+        raise AIError.model_error(f"Failed to generate commit message: {e}") from e

gac/ai_utils.py

@@ -5,13 +5,16 @@ This module provides utility functions that support the AI provider implementati
 
 import logging
 import os
+import time
 from functools import lru_cache
 from typing import Any
 
 import httpx
 import tiktoken
+from halo import Halo
 
 from gac.constants import Utility
+from gac.errors import AIError
 
 logger = logging.getLogger(__name__)
 
@@ -132,3 +135,95 @@ def _classify_error(error_str: str) -> str:
         return "model"
     else:
         return "unknown"
+
+
+def generate_with_retries(
+    provider_funcs: dict,
+    model: str,
+    system_prompt: str,
+    user_prompt: str,
+    temperature: float,
+    max_tokens: int,
+    max_retries: int,
+    quiet: bool = False,
+) -> str:
+    """Generate content with retry logic using direct API calls."""
+    # Parse model string to determine provider and actual model
+    if ":" not in model:
+        raise AIError.model_error(f"Invalid model format. Expected 'provider:model', got '{model}'")
+
+    provider, model_name = model.split(":", 1)
+
+    # Validate provider
+    supported_providers = ["anthropic", "openai", "groq", "cerebras", "ollama", "openrouter"]
+    if provider not in supported_providers:
+        raise AIError.model_error(f"Unsupported provider: {provider}. Supported providers: {supported_providers}")
+
+    messages = [
+        {"role": "system", "content": system_prompt},
+        {"role": "user", "content": user_prompt},
+    ]
+
+    # Set up spinner
+    if quiet:
+        spinner = None
+    else:
+        spinner = Halo(text=f"Generating commit message with {provider} {model_name}...", spinner="dots")
+        spinner.start()
+
+    last_exception = None
+
+    for attempt in range(max_retries):
+        try:
+            if not quiet and attempt > 0:
+                if spinner:
+                    spinner.text = f"Retry {attempt + 1}/{max_retries} with {provider} {model_name}..."
+                logger.info(f"Retry attempt {attempt + 1}/{max_retries}")
+
+            # Call the appropriate provider function
+            provider_func = provider_funcs.get(provider)
+            if not provider_func:
+                raise AIError.model_error(f"Provider function not found for: {provider}")
+
+            content = provider_func(model=model_name, messages=messages, temperature=temperature, max_tokens=max_tokens)
+
+            if spinner:
+                spinner.succeed(f"Generated commit message with {provider} {model_name}")
+
+            if content:
+                return content.strip()
+            else:
+                raise AIError.model_error("Empty response from AI model")
+
+        except Exception as e:
+            last_exception = e
+            error_type = _classify_error(str(e))
+
+            if error_type in ["authentication", "model"]:
+                # Don't retry these errors
+                if spinner:
+                    spinner.fail(f"Failed to generate commit message with {provider} {model_name}")
+                raise AIError.authentication_error(f"AI generation failed: {str(e)}") from e
+
+            if attempt < max_retries - 1:
+                # Exponential backoff
+                wait_time = 2**attempt
+                if not quiet:
+                    logger.warning(f"AI generation failed (attempt {attempt + 1}), retrying in {wait_time}s: {str(e)}")
+
+                if spinner:
+                    for i in range(wait_time, 0, -1):
+                        spinner.text = f"Retry {attempt + 1}/{max_retries} in {i}s..."
+                        time.sleep(1)
+                else:
+                    time.sleep(wait_time)
+            else:
+                logger.error(f"AI generation failed after {max_retries} attempts: {str(e)}")
+
+    if spinner:
+        spinner.fail(f"Failed to generate commit message with {provider} {model_name}")
+
+    # If we get here, all retries failed
+    raise AIError.model_error(
+        f"AI generation failed after {max_retries} attempts: {str(last_exception)}"
+    ) from last_exception

gac/providers/__init__.py

@@ -1 +1,17 @@
-"""AI providers submodule for gac."""
+"""AI provider implementations for commit message generation."""
+
+from .anthropic import call_anthropic_api
+from .cerebras import call_cerebras_api
+from .groq import call_groq_api
+from .ollama import call_ollama_api
+from .openai import call_openai_api
+from .openrouter import call_openrouter_api
+
+__all__ = [
+    "call_anthropic_api",
+    "call_cerebras_api",
+    "call_groq_api",
+    "call_ollama_api",
+    "call_openai_api",
+    "call_openrouter_api",
+]

gac/providers/anthropic.py

@@ -1,141 +1,42 @@
-"""Anthropic API provider for gac."""
+"""Anthropic AI provider implementation."""
 
-import logging
 import os
-import time
 
 import httpx
-from halo import Halo
 
-from gac.ai_utils import _classify_error
-from gac.constants import EnvDefaults
 from gac.errors import AIError
 
-logger = logging.getLogger(__name__)
 
-
-def generate(
-    model: str,
-    prompt: str | tuple[str, str],
-    temperature: float = EnvDefaults.TEMPERATURE,
-    max_tokens: int = EnvDefaults.MAX_OUTPUT_TOKENS,
-    max_retries: int = EnvDefaults.MAX_RETRIES,
-    quiet: bool = False,
-) -> str:
-    """Generate commit message using Anthropic API with retry logic.
-
-    Args:
-        model: The model name (e.g., 'claude-3-5-haiku-latest', 'claude-3-opus-latest')
-        prompt: Either a string prompt or tuple of (system_prompt, user_prompt)
-        temperature: Controls randomness (0.0-1.0)
-        max_tokens: Maximum tokens in the response
-        max_retries: Number of retry attempts if generation fails
-        quiet: If True, suppress progress indicators
-
-    Returns:
-        A formatted commit message string
-
-    Raises:
-        AIError: If generation fails after max_retries attempts
-    """
+def call_anthropic_api(model: str, messages: list[dict], temperature: float, max_tokens: int) -> str:
+    """Call Anthropic API directly."""
     api_key = os.getenv("ANTHROPIC_API_KEY")
     if not api_key:
-        raise AIError.model_error("ANTHROPIC_API_KEY environment variable not set")
-
-    # Handle both old (string) and new (tuple) prompt formats
-    if isinstance(prompt, tuple):
-        system_prompt, user_prompt = prompt
-        messages = [{"role": "user", "content": user_prompt}]
-        payload = {
-            "model": model,
-            "messages": messages,
-            "system": system_prompt,
-            "temperature": temperature,
-            "max_tokens": max_tokens,
-        }
-    else:
-        # Backward compatibility: treat string as user prompt
-        messages = [{"role": "user", "content": prompt}]
-        payload = {
-            "model": model,
-            "messages": messages,
-            "temperature": temperature,
-            "max_tokens": max_tokens,
-        }
-
-    headers = {
-        "Content-Type": "application/json",
-        "x-api-key": api_key,
-        "anthropic-version": "2023-06-01",
-    }
-
-    return _make_request_with_retry(
-        url="https://api.anthropic.com/v1/messages",
-        headers=headers,
-        payload=payload,
-        provider_name=f"Anthropic {model}",
-        max_retries=max_retries,
-        quiet=quiet,
-        response_parser=lambda r: r["content"][0]["text"],
-    )
-
-
-def _make_request_with_retry(
-    url: str,
-    headers: dict,
-    payload: dict,
-    provider_name: str,
-    max_retries: int,
-    quiet: bool,
-    response_parser: callable,
-) -> str:
-    """Make HTTP request with retry logic and common error handling."""
-    if quiet:
-        spinner = None
-    else:
-        spinner = Halo(text=f"Generating commit message with {provider_name}...", spinner="dots")
-        spinner.start()
-
-    last_error = None
-    retry_count = 0
-
-    while retry_count < max_retries:
-        try:
-            logger.debug(f"Trying with {provider_name} (attempt {retry_count + 1}/{max_retries})")
-
-            with httpx.Client(timeout=30.0) as client:
-                response = client.post(url, headers=headers, json=payload)
-                response.raise_for_status()
-
-                response_data = response.json()
-                message = response_parser(response_data)
-
-                if spinner:
-                    spinner.succeed(f"Generated commit message with {provider_name}")
-
-                return message
-
-        except Exception as e:
-            last_error = e
-            retry_count += 1
-
-            if retry_count == max_retries:
-                logger.warning(f"Error generating commit message: {e}. Giving up.")
-                break
-
-            wait_time = 2**retry_count
-            logger.warning(f"Error generating commit message: {e}. Retrying in {wait_time}s...")
-            if spinner:
-                for i in range(wait_time, 0, -1):
-                    spinner.text = f"Retry {retry_count}/{max_retries} in {i}s..."
-                    time.sleep(1)
-            else:
-                time.sleep(wait_time)
-
-    if spinner:
-        spinner.fail(f"Failed to generate commit message with {provider_name}")
-
-    error_type = _classify_error(str(last_error))
-    raise AIError(
-        f"Failed to generate commit message after {max_retries} attempts: {last_error}", error_type=error_type
-    )
+        raise AIError.model_error("ANTHROPIC_API_KEY not found in environment variables")
+
+    url = "https://api.anthropic.com/v1/messages"
+    headers = {"x-api-key": api_key, "anthropic-version": "2023-06-01", "content-type": "application/json"}
+
+    # Convert messages to Anthropic format
+    anthropic_messages = []
+    system_message = ""
+
+    for msg in messages:
+        if msg["role"] == "system":
+            system_message = msg["content"]
+        else:
+            anthropic_messages.append({"role": msg["role"], "content": msg["content"]})
+
+    data = {"model": model, "messages": anthropic_messages, "temperature": temperature, "max_tokens": max_tokens}
+
+    if system_message:
+        data["system"] = system_message
+
+    try:
+        response = httpx.post(url, headers=headers, json=data, timeout=120)
+        response.raise_for_status()
+        response_data = response.json()
+        return response_data["content"][0]["text"]
+    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:
+        raise AIError.model_error(f"Error calling Anthropic API: {str(e)}") from e

gac/providers/cerebras.py

@@ -1,134 +1,29 @@
-"""Cerebras API provider for gac."""
+"""Cerebras AI provider implementation."""
 
-import logging
 import os
-import time
 
 import httpx
-from halo import Halo
 
-from gac.ai_utils import _classify_error
-from gac.constants import EnvDefaults
 from gac.errors import AIError
 
-logger = logging.getLogger(__name__)
 
-
-def generate(
-    model: str,
-    prompt: str | tuple[str, str],
-    temperature: float = EnvDefaults.TEMPERATURE,
-    max_tokens: int = EnvDefaults.MAX_OUTPUT_TOKENS,
-    max_retries: int = EnvDefaults.MAX_RETRIES,
-    quiet: bool = False,
-) -> str:
-    """Generate commit message using Cerebras API with retry logic.
-
-    Args:
-        model: The model name (e.g., 'llama3.1-8b', 'llama3.1-70b')
-        prompt: Either a string prompt or tuple of (system_prompt, user_prompt)
-        temperature: Controls randomness (0.0-1.0)
-        max_tokens: Maximum tokens in the response
-        max_retries: Number of retry attempts if generation fails
-        quiet: If True, suppress progress indicators
-
-    Returns:
-        A formatted commit message string
-
-    Raises:
-        AIError: If generation fails after max_retries attempts
-    """
+def call_cerebras_api(model: str, messages: list[dict], temperature: float, max_tokens: int) -> str:
+    """Call Cerebras API directly."""
     api_key = os.getenv("CEREBRAS_API_KEY")
     if not api_key:
-        raise AIError.model_error("CEREBRAS_API_KEY environment variable not set")
-
-    # Handle both old (string) and new (tuple) prompt formats
-    if isinstance(prompt, tuple):
-        system_prompt, user_prompt = prompt
-        messages = [{"role": "system", "content": system_prompt}, {"role": "user", "content": user_prompt}]
-    else:
-        # Backward compatibility: treat string as user prompt
-        messages = [{"role": "user", "content": prompt}]
-
-    payload = {
-        "model": model,
-        "messages": messages,
-        "temperature": temperature,
-        "max_tokens": max_tokens,
-    }
-
-    headers = {
-        "Content-Type": "application/json",
-        "Authorization": f"Bearer {api_key}",
-    }
-
-    return _make_request_with_retry(
-        url="https://api.cerebras.ai/v1/chat/completions",
-        headers=headers,
-        payload=payload,
-        provider_name=f"Cerebras {model}",
-        max_retries=max_retries,
-        quiet=quiet,
-        response_parser=lambda r: r["choices"][0]["message"]["content"],
-    )
-
-
-def _make_request_with_retry(
-    url: str,
-    headers: dict,
-    payload: dict,
-    provider_name: str,
-    max_retries: int,
-    quiet: bool,
-    response_parser: callable,
-) -> str:
-    """Make HTTP request with retry logic and common error handling."""
-    if quiet:
-        spinner = None
-    else:
-        spinner = Halo(text=f"Generating commit message with {provider_name}...", spinner="dots")
-        spinner.start()
-
-    last_error = None
-    retry_count = 0
-
-    while retry_count < max_retries:
-        try:
-            logger.debug(f"Trying with {provider_name} (attempt {retry_count + 1}/{max_retries})")
-
-            with httpx.Client(timeout=30.0) as client:
-                response = client.post(url, headers=headers, json=payload)
-                response.raise_for_status()
-
-                response_data = response.json()
-                message = response_parser(response_data)
-
-                if spinner:
-                    spinner.succeed(f"Generated commit message with {provider_name}")
-
-                return message
-
-        except Exception as e:
-            last_error = e
-            retry_count += 1
-
-            if retry_count == max_retries:
-                logger.warning(f"Error generating commit message: {e}. Giving up.")
-                break
-
-            wait_time = 2**retry_count
-            logger.warning(f"Error generating commit message: {e}. Retrying in {wait_time}s...")
-            if spinner:
-                for i in range(wait_time, 0, -1):
-                    spinner.text = f"Retry {retry_count}/{max_retries} in {i}s..."
-                    time.sleep(1)
-            else:
-                time.sleep(wait_time)
-
-    if spinner:
-        spinner.fail(f"Failed to generate commit message with {provider_name}")
-
-    error_type = _classify_error(str(last_error))
-    raise AIError(
-        f"Failed to generate commit message after {max_retries} attempts: {last_error}", error_type=error_type
-    )
+        raise AIError.model_error("CEREBRAS_API_KEY not found in environment variables")
+
+    url = "https://api.cerebras.ai/v1/chat/completions"
+    headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
+
+    data = {"model": model, "messages": messages, "temperature": temperature, "max_tokens": max_tokens}
+
+    try:
+        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"]
+    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:
+        raise AIError.model_error(f"Error calling Cerebras API: {str(e)}") from e

gac/providers/groq.py

@@ -2,133 +2,50 @@
 
 import logging
 import os
-import time
 
 import httpx
-from halo import Halo
 
-from gac.ai_utils import _classify_error
-from gac.constants import EnvDefaults
 from gac.errors import AIError
 
 logger = logging.getLogger(__name__)
 
 
-def generate(
-    model: str,
-    prompt: str | tuple[str, str],
-    temperature: float = EnvDefaults.TEMPERATURE,
-    max_tokens: int = EnvDefaults.MAX_OUTPUT_TOKENS,
-    max_retries: int = EnvDefaults.MAX_RETRIES,
-    quiet: bool = False,
-) -> str:
-    """Generate commit message using Groq API with retry logic.
-
-    Args:
-        model: The model name (e.g., 'llama3-8b-8192', 'llama3-70b-8192')
-        prompt: Either a string prompt or tuple of (system_prompt, user_prompt)
-        temperature: Controls randomness (0.0-1.0)
-        max_tokens: Maximum tokens in the response
-        max_retries: Number of retry attempts if generation fails
-        quiet: If True, suppress progress indicators
-
-    Returns:
-        A formatted commit message string
-
-    Raises:
-        AIError: If generation fails after max_retries attempts
-    """
+def call_groq_api(model: str, messages: list[dict], temperature: float, max_tokens: int) -> str:
+    """Call Groq API directly."""
     api_key = os.getenv("GROQ_API_KEY")
     if not api_key:
-        raise AIError.model_error("GROQ_API_KEY environment variable not set")
-
-    # Handle both old (string) and new (tuple) prompt formats
-    if isinstance(prompt, tuple):
-        system_prompt, user_prompt = prompt
-        messages = [{"role": "system", "content": system_prompt}, {"role": "user", "content": user_prompt}]
-    else:
-        # Backward compatibility: treat string as user prompt
-        messages = [{"role": "user", "content": prompt}]
-
-    payload = {
-        "model": model,
-        "messages": messages,
-        "temperature": temperature,
-        "max_tokens": max_tokens,
-    }
-
-    headers = {
-        "Content-Type": "application/json",
-        "Authorization": f"Bearer {api_key}",
-    }
-
-    return _make_request_with_retry(
-        url="https://api.groq.com/openai/v1/chat/completions",
-        headers=headers,
-        payload=payload,
-        provider_name=f"Groq {model}",
-        max_retries=max_retries,
-        quiet=quiet,
-        response_parser=lambda r: r["choices"][0]["message"]["content"],
-    )
-
-
-def _make_request_with_retry(
-    url: str,
-    headers: dict,
-    payload: dict,
-    provider_name: str,
-    max_retries: int,
-    quiet: bool,
-    response_parser: callable,
-) -> str:
-    """Make HTTP request with retry logic and common error handling."""
-    if quiet:
-        spinner = None
-    else:
-        spinner = Halo(text=f"Generating commit message with {provider_name}...", spinner="dots")
-        spinner.start()
-
-    last_error = None
-    retry_count = 0
-
-    while retry_count < max_retries:
-        try:
-            logger.debug(f"Trying with {provider_name} (attempt {retry_count + 1}/{max_retries})")
-
-            with httpx.Client(timeout=30.0) as client:
-                response = client.post(url, headers=headers, json=payload)
-                response.raise_for_status()
-
-                response_data = response.json()
-                message = response_parser(response_data)
-
-                if spinner:
-                    spinner.succeed(f"Generated commit message with {provider_name}")
-
-                return message
-
-        except Exception as e:
-            last_error = e
-            retry_count += 1
-
-            if retry_count == max_retries:
-                logger.warning(f"Error generating commit message: {e}. Giving up.")
-                break
-
-            wait_time = 2**retry_count
-            logger.warning(f"Error generating commit message: {e}. Retrying in {wait_time}s...")
-            if spinner:
-                for i in range(wait_time, 0, -1):
-                    spinner.text = f"Retry {retry_count}/{max_retries} in {i}s..."
-                    time.sleep(1)
+        raise AIError.model_error("GROQ_API_KEY not found in environment variables")
+
+    url = "https://api.groq.com/openai/v1/chat/completions"
+    headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
+
+    data = {"model": model, "messages": messages, "temperature": temperature, "max_tokens": max_tokens}
+
+    try:
+        response = httpx.post(url, headers=headers, json=data, timeout=120)
+        response.raise_for_status()
+        response_data = response.json()
+
+        # Debug logging to understand response structure
+        logger.debug(f"Groq API response: {response_data}")
+
+        # Handle different response formats
+        if "choices" in response_data and len(response_data["choices"]) > 0:
+            choice = response_data["choices"][0]
+            if "message" in choice and "content" in choice["message"]:
+                content = choice["message"]["content"]
+                logger.debug(f"Found content in message.content: {content}")
+                return content
+            elif "text" in choice:
+                content = choice["text"]
+                logger.debug(f"Found content in choice.text: {content}")
+                return content
             else:
-                time.sleep(wait_time)
-
-    if spinner:
-        spinner.fail(f"Failed to generate commit message with {provider_name}")
-
-    error_type = _classify_error(str(last_error))
-    raise AIError(
-        f"Failed to generate commit message after {max_retries} attempts: {last_error}", error_type=error_type
-    )
+                logger.debug(f"Choice structure: {choice}")
+
+        # If we can't find content in the expected places, raise an error
+        raise AIError.model_error(f"Unexpected response format from Groq API: {response_data}")
+    except httpx.HTTPStatusError as e:
+        raise AIError.model_error(f"Groq API error: {e.response.status_code} - {e.response.text}") from e
+    except Exception as e:
+        raise AIError.model_error(f"Error calling Groq API: {str(e)}") from e

gac/providers/ollama.py

@@ -1,135 +1,35 @@
-"""Ollama API provider for gac."""
+"""Ollama AI provider implementation."""
 
-import logging
 import os
-import time
 
 import httpx
-from halo import Halo
 
-from gac.ai_utils import _classify_error
-from gac.constants import EnvDefaults
 from gac.errors import AIError
 
-logger = logging.getLogger(__name__)
 
-
-def generate(
-    model: str,
-    prompt: str | tuple[str, str],
-    temperature: float = EnvDefaults.TEMPERATURE,
-    max_tokens: int = EnvDefaults.MAX_OUTPUT_TOKENS,
-    max_retries: int = EnvDefaults.MAX_RETRIES,
-    quiet: bool = False,
-) -> str:
-    """Generate commit message using Ollama API with retry logic.
-
-    Args:
-        model: The model name (e.g., 'llama3', 'mistral')
-        prompt: Either a string prompt or tuple of (system_prompt, user_prompt)
-        temperature: Controls randomness (0.0-1.0)
-        max_tokens: Maximum tokens in the response (note: Ollama uses 'num_predict')
-        max_retries: Number of retry attempts if generation fails
-        quiet: If True, suppress progress indicators
-
-    Returns:
-        A formatted commit message string
-
-    Raises:
-        AIError: If generation fails after max_retries attempts
-    """
-    # Handle both old (string) and new (tuple) prompt formats
-    if isinstance(prompt, tuple):
-        system_prompt, user_prompt = prompt
-        messages = [{"role": "system", "content": system_prompt}, {"role": "user", "content": user_prompt}]
-    else:
-        # Backward compatibility: treat string as user prompt
-        messages = [{"role": "user", "content": prompt}]
-
-    payload = {
-        "model": model,
-        "messages": messages,
-        "stream": False,
-        "options": {
-            "temperature": temperature,
-            "num_predict": max_tokens,
-        },
-    }
-
-    headers = {
-        "Content-Type": "application/json",
-    }
-
-    # Ollama typically runs locally on port 11434
-    ollama_url = os.getenv("OLLAMA_URL", "http://localhost:11434")
-
-    return _make_request_with_retry(
-        url=f"{ollama_url}/api/chat",
-        headers=headers,
-        payload=payload,
-        provider_name=f"Ollama {model}",
-        max_retries=max_retries,
-        quiet=quiet,
-        response_parser=lambda r: r["message"]["content"],
-    )
-
-
-def _make_request_with_retry(
-    url: str,
-    headers: dict,
-    payload: dict,
-    provider_name: str,
-    max_retries: int,
-    quiet: bool,
-    response_parser: callable,
-) -> str:
-    """Make HTTP request with retry logic and common error handling."""
-    if quiet:
-        spinner = None
-    else:
-        spinner = Halo(text=f"Generating commit message with {provider_name}...", spinner="dots")
-        spinner.start()
-
-    last_error = None
-    retry_count = 0
-
-    while retry_count < max_retries:
-        try:
-            logger.debug(f"Trying with {provider_name} (attempt {retry_count + 1}/{max_retries})")
-
-            with httpx.Client(timeout=30.0) as client:
-                response = client.post(url, headers=headers, json=payload)
-                response.raise_for_status()
-
-                response_data = response.json()
-                message = response_parser(response_data)
-
-                if spinner:
-                    spinner.succeed(f"Generated commit message with {provider_name}")
-
-                return message
-
-        except Exception as e:
-            last_error = e
-            retry_count += 1
-
-            if retry_count == max_retries:
-                logger.warning(f"Error generating commit message: {e}. Giving up.")
-                break
-
-            wait_time = 2**retry_count
-            logger.warning(f"Error generating commit message: {e}. Retrying in {wait_time}s...")
-            if spinner:
-                for i in range(wait_time, 0, -1):
-                    spinner.text = f"Retry {retry_count}/{max_retries} in {i}s..."
-                    time.sleep(1)
-            else:
-                time.sleep(wait_time)
-
-    if spinner:
-        spinner.fail(f"Failed to generate commit message with {provider_name}")
-
-    error_type = _classify_error(str(last_error))
-    raise AIError(
-        f"Failed to generate commit message after {max_retries} attempts: {last_error}", error_type=error_type
-    )
+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")
+
+    url = f"{api_url.rstrip('/')}/api/chat"
+    data = {"model": model, "messages": messages, "temperature": temperature, "stream": False}
+
+    try:
+        response = httpx.post(url, json=data, timeout=120)
+        response.raise_for_status()
+        response_data = response.json()
+
+        # Handle different response formats from Ollama
+        if "message" in response_data and "content" in response_data["message"]:
+            return response_data["message"]["content"]
+        elif "response" in response_data:
+            return response_data["response"]
+        else:
+            # Fallback: return the full response as string
+            return str(response_data)
+    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:
+        raise AIError.model_error(f"Ollama API error: {e.response.status_code} - {e.response.text}") from e
+    except Exception as e:
+        raise AIError.model_error(f"Error calling Ollama API: {str(e)}") from e

gac/providers/openai.py

@@ -1,134 +1,29 @@
 """OpenAI API provider for gac."""
 
-import logging
 import os
-import time
 
 import httpx
-from halo import Halo
 
-from gac.ai_utils import _classify_error
-from gac.constants import EnvDefaults
 from gac.errors import AIError
 
-logger = logging.getLogger(__name__)
 
-
-def generate(
-    model: str,
-    prompt: str | tuple[str, str],
-    temperature: float = EnvDefaults.TEMPERATURE,
-    max_tokens: int = EnvDefaults.MAX_OUTPUT_TOKENS,
-    max_retries: int = EnvDefaults.MAX_RETRIES,
-    quiet: bool = False,
-) -> str:
-    """Generate commit message using OpenAI API with retry logic.
-
-    Args:
-        model: The model name (e.g., 'gpt-4', 'gpt-3.5-turbo')
-        prompt: Either a string prompt or tuple of (system_prompt, user_prompt)
-        temperature: Controls randomness (0.0-1.0)
-        max_tokens: Maximum tokens in the response
-        max_retries: Number of retry attempts if generation fails
-        quiet: If True, suppress progress indicators
-
-    Returns:
-        A formatted commit message string
-
-    Raises:
-        AIError: If generation fails after max_retries attempts
-    """
+def call_openai_api(model: str, messages: list[dict], temperature: float, max_tokens: int) -> str:
+    """Call OpenAI API directly."""
     api_key = os.getenv("OPENAI_API_KEY")
     if not api_key:
-        raise AIError.model_error("OPENAI_API_KEY environment variable not set")
-
-    # Handle both old (string) and new (tuple) prompt formats
-    if isinstance(prompt, tuple):
-        system_prompt, user_prompt = prompt
-        messages = [{"role": "system", "content": system_prompt}, {"role": "user", "content": user_prompt}]
-    else:
-        # Backward compatibility: treat string as user prompt
-        messages = [{"role": "user", "content": prompt}]
-
-    payload = {
-        "model": model,
-        "messages": messages,
-        "temperature": temperature,
-        "max_tokens": max_tokens,
-    }
-
-    headers = {
-        "Content-Type": "application/json",
-        "Authorization": f"Bearer {api_key}",
-    }
-
-    return _make_request_with_retry(
-        url="https://api.openai.com/v1/chat/completions",
-        headers=headers,
-        payload=payload,
-        provider_name=f"OpenAI {model}",
-        max_retries=max_retries,
-        quiet=quiet,
-        response_parser=lambda r: r["choices"][0]["message"]["content"],
-    )
-
-
-def _make_request_with_retry(
-    url: str,
-    headers: dict,
-    payload: dict,
-    provider_name: str,
-    max_retries: int,
-    quiet: bool,
-    response_parser: callable,
-) -> str:
-    """Make HTTP request with retry logic and common error handling."""
-    if quiet:
-        spinner = None
-    else:
-        spinner = Halo(text=f"Generating commit message with {provider_name}...", spinner="dots")
-        spinner.start()
-
-    last_error = None
-    retry_count = 0
-
-    while retry_count < max_retries:
-        try:
-            logger.debug(f"Trying with {provider_name} (attempt {retry_count + 1}/{max_retries})")
-
-            with httpx.Client(timeout=30.0) as client:
-                response = client.post(url, headers=headers, json=payload)
-                response.raise_for_status()
-
-                response_data = response.json()
-                message = response_parser(response_data)
-
-                if spinner:
-                    spinner.succeed(f"Generated commit message with {provider_name}")
-
-                return message
-
-        except Exception as e:
-            last_error = e
-            retry_count += 1
-
-            if retry_count == max_retries:
-                logger.warning(f"Error generating commit message: {e}. Giving up.")
-                break
-
-            wait_time = 2**retry_count
-            logger.warning(f"Error generating commit message: {e}. Retrying in {wait_time}s...")
-            if spinner:
-                for i in range(wait_time, 0, -1):
-                    spinner.text = f"Retry {retry_count}/{max_retries} in {i}s..."
-                    time.sleep(1)
-            else:
-                time.sleep(wait_time)
-
-    if spinner:
-        spinner.fail(f"Failed to generate commit message with {provider_name}")
-
-    error_type = _classify_error(str(last_error))
-    raise AIError(
-        f"Failed to generate commit message after {max_retries} attempts: {last_error}", error_type=error_type
-    )
+        raise AIError.model_error("OPENAI_API_KEY not found in environment variables")
+
+    url = "https://api.openai.com/v1/chat/completions"
+    headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
+
+    data = {"model": model, "messages": messages, "temperature": temperature, "max_tokens": max_tokens}
+
+    try:
+        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"]
+    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:
+        raise AIError.model_error(f"Error calling OpenAI API: {str(e)}") from e

gac/providers/openrouter.py

@@ -1,50 +1,25 @@
 """OpenRouter API provider for gac."""
 
-import logging
 import os
-import time
 
 import httpx
-from halo import Halo
 
-from gac.ai_utils import _classify_error
-from gac.constants import EnvDefaults
 from gac.errors import AIError
 
-logger = logging.getLogger(__name__)
 
-
-def generate(
-    model: str,
-    prompt: str | tuple[str, str],
-    temperature: float = EnvDefaults.TEMPERATURE,
-    max_tokens: int = EnvDefaults.MAX_OUTPUT_TOKENS,
-    max_retries: int = EnvDefaults.MAX_RETRIES,
-    quiet: bool = False,
-) -> str:
-    """Generate commit message using OpenRouter API with retry logic."""
+def call_openrouter_api(model: str, messages: list[dict], temperature: float, max_tokens: int) -> str:
+    """Call OpenRouter API directly."""
     api_key = os.getenv("OPENROUTER_API_KEY")
     if not api_key:
         raise AIError.model_error("OPENROUTER_API_KEY environment variable not set")
 
-    if isinstance(prompt, tuple):
-        system_prompt, user_prompt = prompt
-        messages = [{"role": "system", "content": system_prompt}, {"role": "user", "content": user_prompt}]
-    else:
-        messages = [{"role": "user", "content": prompt}]
-
-    payload = {
-        "model": model,
-        "messages": messages,
-        "temperature": temperature,
-        "max_tokens": max_tokens,
-    }
-
+    url = "https://openrouter.ai/api/v1/chat/completions"
     headers = {
         "Content-Type": "application/json",
         "Authorization": f"Bearer {api_key}",
     }
 
+    # Add optional headers if environment variables are set
     site_url = os.getenv("OPENROUTER_SITE_URL")
     if site_url:
         headers["HTTP-Referer"] = site_url
@@ -53,73 +28,19 @@ def generate(
     if site_name:
         headers["X-Title"] = site_name
 
-    return _make_request_with_retry(
-        url="https://openrouter.ai/api/v1/chat/completions",
-        headers=headers,
-        payload=payload,
-        provider_name=f"OpenRouter {model}",
-        max_retries=max_retries,
-        quiet=quiet,
-        response_parser=lambda r: r["choices"][0]["message"]["content"],
-    )
-
-
-def _make_request_with_retry(
-    url: str,
-    headers: dict,
-    payload: dict,
-    provider_name: str,
-    max_retries: int,
-    quiet: bool,
-    response_parser: callable,
-) -> str:
-    """Make HTTP request with retry logic and common error handling."""
-    if quiet:
-        spinner = None
-    else:
-        spinner = Halo(text=f"Generating commit message with {provider_name}...", spinner="dots")
-        spinner.start()
-
-    last_error = None
-    retry_count = 0
-
-    while retry_count < max_retries:
-        try:
-            logger.debug(f"Trying with {provider_name} (attempt {retry_count + 1}/{max_retries})")
-
-            with httpx.Client(timeout=30.0) as client:
-                response = client.post(url, headers=headers, json=payload)
-                response.raise_for_status()
-
-                response_data = response.json()
-                message = response_parser(response_data)
-
-                if spinner:
-                    spinner.succeed(f"Generated commit message with {provider_name}")
-
-                return message
-
-        except Exception as e:
-            last_error = e
-            retry_count += 1
-
-            if retry_count == max_retries:
-                logger.warning(f"Error generating commit message: {e}. Giving up.")
-                break
-
-            wait_time = 2**retry_count
-            logger.warning(f"Error generating commit message: {e}. Retrying in {wait_time}s...")
-            if spinner:
-                for i in range(wait_time, 0, -1):
-                    spinner.text = f"Retry {retry_count}/{max_retries} in {i}s..."
-                    time.sleep(1)
-            else:
-                time.sleep(wait_time)
-
-    if spinner:
-        spinner.fail(f"Failed to generate commit message with {provider_name}")
+    data = {
+        "model": model,
+        "messages": messages,
+        "temperature": temperature,
+        "max_tokens": max_tokens,
+    }
 
-    error_type = _classify_error(str(last_error))
-    raise AIError(
-        f"Failed to generate commit message after {max_retries} attempts: {last_error}", error_type=error_type
-    )
+    try:
+        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"]
+    except httpx.HTTPStatusError as e:
+        raise AIError.model_error(f"OpenRouter API error: {e.response.status_code} - {e.response.text}") from e
+    except Exception as e:
+        raise AIError.model_error(f"Error calling OpenRouter API: {str(e)}") from e

{gac-1.1.0.dist-info → gac-1.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gac
-Version: 1.1.0
+Version: 1.2.0
 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.2.0.dist-info/RECORD

@@ -0,0 +1,28 @@
+gac/__init__.py,sha256=HFWgSVNbTAFhgetCRWI1WrtyE7zC7IHvoBOrfDGUurM,989
+gac/__version__.py,sha256=_cfu33DyI3jZln3bUKxhnDn1AeCj66_yLEqy9IJASqs,66
+gac/ai.py,sha256=RcZKXiyx9Wll2e-dRx0jNzQPzojVYE7OaSEDclE2MKc,2979
+gac/ai_utils.py,sha256=p63lxYp4AqzBgbYkYyNUKLecIszTVvBp4Wkm2hKlMlc,7854
+gac/cli.py,sha256=eQS8S7v6p0CfN9wtr239ujYGTi9rKl-KV7STX2U-C3w,4581
+gac/config.py,sha256=wSgEDjtis7Vk1pv5VPvYmJyD9-tymDS6GiUHjnCMbIM,1486
+gac/config_cli.py,sha256=v9nFHZO1RvK9fzHyuUS6SG-BCLHMsdOMDwWamBhVVh4,1608
+gac/constants.py,sha256=MAxdASGncfZY1TdKGdhJZ0wvTBEU3gTN6KEdw8n3Bd8,4844
+gac/diff_cli.py,sha256=wnVQ9OFGnM0d2Pj9WVjWbo0jxqIuRHVAwmb8wU9Pa3E,5676
+gac/errors.py,sha256=3vIRMQ2QF3sP9_rPfXAFuu5ZSjIVX4FxM-FAuiR8N-8,7416
+gac/git.py,sha256=MS2m4fv8h4mau1djFG1aje9NXTmkGsjPO9w18LqNGX0,6031
+gac/init_cli.py,sha256=e4z9-4NhoUn2DUyApIru8JR-W7HuNq2VeeXkR9aXHLo,1868
+gac/main.py,sha256=POay7l6ihm3oF9ajGWx9cA40Pu-NVz5x_OzQOYPDoX8,12011
+gac/preprocess.py,sha256=krrLPHsccYMdn_YAtUrppBJIoRgevxGWusDwhE40LEo,15366
+gac/prompt.py,sha256=_fv24XU3DZE_S72vcdUYnNkmy-_KXnr1Vlc-9okop7E,17263
+gac/utils.py,sha256=W3ladtmsH01MNLdckQYTzYrYbTGEdzCKI36he9C-y_E,3945
+gac/providers/__init__.py,sha256=iGwZmV-cFqL3AeFE0vc6KpHwm-RLWcVSU17c7IvJg2s,456
+gac/providers/anthropic.py,sha256=esf6pq6nRdqD0mpKz_IQNXmXe5WnkoSA2b1isrrRB4o,1514
+gac/providers/cerebras.py,sha256=eE9lAjEzrATIo941vv97I2DSmpnXYBCJ9HkVIb-6Whg,1130
+gac/providers/groq.py,sha256=EPivjTg3TUqynBofnatlIxKzFTpLPP4psVb562Dsx5o,2040
+gac/providers/ollama.py,sha256=Bp94DvortQssDhekuNdJ7fKLeWpWASYXSssJNCuGszg,1383
+gac/providers/openai.py,sha256=1l-Wu7ETXXaJ7cNB3OD5ivf4_72iIEP9bPFMQst8JWI,1109
+gac/providers/openrouter.py,sha256=Vs0MXfv9KCldfEUD2roTwcXqs89tgE3ndNqRKoqdJQs,1473
+gac-1.2.0.dist-info/METADATA,sha256=fbK0j24cpsMWVJXnybrXyQ6MzMS791bpdIKu2vvG7-c,8558
+gac-1.2.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+gac-1.2.0.dist-info/entry_points.txt,sha256=tdjN-XMmcWfL92swuRAjT62bFLOAwk9bTMRLGP5Z4aI,36
+gac-1.2.0.dist-info/licenses/LICENSE,sha256=vOab37NouL1PNs5BswnPayrMCqaN2sqLfMQfqPDrpZg,1103
+gac-1.2.0.dist-info/RECORD,,

gac-1.1.0.dist-info/RECORD

@@ -1,28 +0,0 @@
-gac/__init__.py,sha256=-knZC1oRylbJUv5uGk3fP_dHaaLHG76duAEWxLUi1eg,940
-gac/__version__.py,sha256=JSz2jRyqqtKTmDkhJ8NI5pr2e0rhFqSSkokXslLdc2M,66
-gac/ai.py,sha256=-Wd9cr5yK-UvR14AHvBeHrpa28KXu0bYZjJS02U-q90,3419
-gac/ai_utils.py,sha256=DFiM0Wzp-kremo33_i5SEYpms7tE13ipKLCCr_-AZPU,4327
-gac/cli.py,sha256=eQS8S7v6p0CfN9wtr239ujYGTi9rKl-KV7STX2U-C3w,4581
-gac/config.py,sha256=wSgEDjtis7Vk1pv5VPvYmJyD9-tymDS6GiUHjnCMbIM,1486
-gac/config_cli.py,sha256=v9nFHZO1RvK9fzHyuUS6SG-BCLHMsdOMDwWamBhVVh4,1608
-gac/constants.py,sha256=MAxdASGncfZY1TdKGdhJZ0wvTBEU3gTN6KEdw8n3Bd8,4844
-gac/diff_cli.py,sha256=wnVQ9OFGnM0d2Pj9WVjWbo0jxqIuRHVAwmb8wU9Pa3E,5676
-gac/errors.py,sha256=3vIRMQ2QF3sP9_rPfXAFuu5ZSjIVX4FxM-FAuiR8N-8,7416
-gac/git.py,sha256=MS2m4fv8h4mau1djFG1aje9NXTmkGsjPO9w18LqNGX0,6031
-gac/init_cli.py,sha256=e4z9-4NhoUn2DUyApIru8JR-W7HuNq2VeeXkR9aXHLo,1868
-gac/main.py,sha256=POay7l6ihm3oF9ajGWx9cA40Pu-NVz5x_OzQOYPDoX8,12011
-gac/preprocess.py,sha256=krrLPHsccYMdn_YAtUrppBJIoRgevxGWusDwhE40LEo,15366
-gac/prompt.py,sha256=_fv24XU3DZE_S72vcdUYnNkmy-_KXnr1Vlc-9okop7E,17263
-gac/utils.py,sha256=W3ladtmsH01MNLdckQYTzYrYbTGEdzCKI36he9C-y_E,3945
-gac/providers/__init__.py,sha256=_JawPCV_ZCtI18bBqVCbQkkbLetSQqOBcj2b19KRuX0,38
-gac/providers/anthropic.py,sha256=v0JApD6dNfIbxBoFbpf4GBWc4PsVPgcEcw1GDEWhoeM,4382
-gac/providers/cerebras.py,sha256=rWtndVj9q1w-EIfLyP4NJ10GFPnlfiu43ZminTdWP1s,4166
-gac/providers/groq.py,sha256=K7hrHaYfGn25hnDedR6FBEOqb0r0Y65zQRYso5w3xGE,4156
-gac/providers/ollama.py,sha256=qzX4qMsQeZUh8oPOWFIszhsvgioSnoLi82wO8G13pOI,4139
-gac/providers/openai.py,sha256=VKH7SQE6O4UB1c15KXIBL5UP1Fj3Ed4XQDrqENEPmBo,4150
-gac/providers/openrouter.py,sha256=vU4zIwtnyz9hjWokJwORwX3bZjYtF2MWqz8xxE-srsA,3753
-gac-1.1.0.dist-info/METADATA,sha256=VImMQAbgQT23S1czOiINsmy4tnloF8MRcb9_TSvasrI,8558
-gac-1.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-gac-1.1.0.dist-info/entry_points.txt,sha256=tdjN-XMmcWfL92swuRAjT62bFLOAwk9bTMRLGP5Z4aI,36
-gac-1.1.0.dist-info/licenses/LICENSE,sha256=vOab37NouL1PNs5BswnPayrMCqaN2sqLfMQfqPDrpZg,1103
-gac-1.1.0.dist-info/RECORD,,