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

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,57 @@
 
 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: {repr(content)}")
+                if content is None:
+                    logger.warning("Groq API returned None content in message.content")
+                    return ""
+                return content
+            elif "text" in choice:
+                content = choice["text"]
+                logger.debug(f"Found content in choice.text: {repr(content)}")
+                if content is None:
+                    logger.warning("Groq API returned None content in choice.text")
+                    return ""
+                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.warning(f"Unexpected choice structure: {choice}")
+
+        # If we can't find content in the expected places, raise an error
+        logger.error(f"Unexpected response format from Groq API: {response_data}")
+        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