gac 3.6.0__py3-none-any.whl → 3.10.10__py3-none-any.whl

gac/providers/replicate.py

@@ -1,98 +1,156 @@
 """Replicate API provider for gac."""
 
-import os
+import time
+from typing import Any
 
 import httpx
 
 from gac.errors import AIError
+from gac.providers.base import GenericHTTPProvider, ProviderConfig
+from gac.utils import get_ssl_verify
+
+
+class ReplicateProvider(GenericHTTPProvider):
+    """Replicate API provider with async prediction polling."""
+
+    config = ProviderConfig(
+        name="Replicate",
+        api_key_env="REPLICATE_API_TOKEN",
+        base_url="https://api.replicate.com/v1",
+    )
+
+    def _get_api_url(self, model: str | None = None) -> str:
+        """Get Replicate API URL with /predictions endpoint."""
+        return f"{self.config.base_url}/predictions"
+
+    def _build_headers(self) -> dict[str, str]:
+        """Build headers with Token-based authorization."""
+        headers = super()._build_headers()
+        # Replace Bearer token with Token format
+        if "Authorization" in headers:
+            del headers["Authorization"]
+        headers["Authorization"] = f"Token {self.api_key}"
+        return headers
+
+    def _build_request_body(
+        self, messages: list[dict[str, Any]], temperature: float, max_tokens: int, model: str, **kwargs: Any
+    ) -> dict[str, Any]:
+        """Build Replicate prediction payload with message-to-prompt conversion."""
+        # Convert messages to a single prompt for Replicate
+        prompt_parts = []
+        system_message = None
+
+        for message in messages:
+            role = message.get("role")
+            content = message.get("content", "")
+
+            if role == "system":
+                system_message = content
+            elif role == "user":
+                prompt_parts.append(f"Human: {content}")
+            elif role == "assistant":
+                prompt_parts.append(f"Assistant: {content}")
+
+        # Add system message at the beginning if present
+        if system_message:
+            prompt_parts.insert(0, f"System: {system_message}")
+
+        # Add final assistant prompt
+        prompt_parts.append("Assistant:")
+        full_prompt = "\n\n".join(prompt_parts)
+
+        # Replicate prediction payload
+        return {
+            "version": model,  # Replicate uses version string as model identifier
+            "input": {
+                "prompt": full_prompt,
+                "temperature": temperature,
+                "max_tokens": max_tokens,
+            },
+        }
+
+    def generate(
+        self,
+        model: str,
+        messages: list[dict[str, Any]],
+        temperature: float = 0.7,
+        max_tokens: int = 1024,
+        **kwargs: Any,
+    ) -> str:
+        """Override generate to handle Replicate's async polling mechanism."""
+        # Build request components
+        try:
+            url = self._get_api_url(model)
+        except AIError:
+            raise
+        except Exception as e:
+            raise AIError.model_error(f"Error calling {self.config.name} AI API: {e!s}") from e
+
+        try:
+            headers = self._build_headers()
+        except AIError:
+            raise
+        except Exception as e:
+            raise AIError.model_error(f"Error calling {self.config.name} AI API: {e!s}") from e
+
+        try:
+            body = self._build_request_body(messages, temperature, max_tokens, model, **kwargs)
+        except AIError:
+            raise
+        except Exception as e:
+            raise AIError.model_error(f"Error calling {self.config.name} AI API: {e!s}") from e
 
-
-def call_replicate_api(model: str, messages: list[dict], temperature: float, max_tokens: int) -> str:
-    """Call Replicate API directly."""
-    api_key = os.getenv("REPLICATE_API_TOKEN")
-    if not api_key:
-        raise AIError.authentication_error("REPLICATE_API_TOKEN not found in environment variables")
-
-    # Replicate uses a different endpoint for language models
-    url = "https://api.replicate.com/v1/predictions"
-    headers = {"Authorization": f"Token {api_key}", "Content-Type": "application/json"}
-
-    # Convert messages to a single prompt for Replicate
-    prompt_parts = []
-    system_message = None
-
-    for message in messages:
-        role = message.get("role")
-        content = message.get("content", "")
-
-        if role == "system":
-            system_message = content
-        elif role == "user":
-            prompt_parts.append(f"Human: {content}")
-        elif role == "assistant":
-            prompt_parts.append(f"Assistant: {content}")
-
-    # Add system message at the beginning if present
-    if system_message:
-        prompt_parts.insert(0, f"System: {system_message}")
-
-    # Add final assistant prompt
-    prompt_parts.append("Assistant:")
-    full_prompt = "\n\n".join(prompt_parts)
-
-    # Replicate prediction payload
-    data = {
-        "version": model,  # Replicate uses version string as model identifier
-        "input": {
-            "prompt": full_prompt,
-            "temperature": temperature,
-            "max_tokens": max_tokens,
-        },
-    }
-
-    try:
         # Create prediction
-        response = httpx.post(url, headers=headers, json=data, timeout=120)
-        response.raise_for_status()
-        prediction_data = response.json()
-
-        # Get the prediction URL to check status
+        try:
+            response = httpx.post(url, json=body, headers=headers, timeout=self.config.timeout, verify=get_ssl_verify())
+            response.raise_for_status()
+            prediction_data = response.json()
+        except httpx.HTTPStatusError as e:
+            if e.response.status_code == 429:
+                raise AIError.rate_limit_error(f"Replicate API rate limit exceeded: {e.response.text}") from e
+            elif e.response.status_code == 401:
+                raise AIError.authentication_error(f"Replicate API authentication failed: {e.response.text}") from e
+            raise AIError.model_error(f"Replicate API error: {e.response.status_code} - {e.response.text}") from e
+        except httpx.TimeoutException as e:
+            raise AIError.timeout_error(f"Replicate API request timed out: {str(e)}") from e
+        except Exception as e:
+            raise AIError.model_error(f"Error calling Replicate API: {str(e)}") from e
+
+        # Poll for completion
         get_url = f"https://api.replicate.com/v1/predictions/{prediction_data['id']}"
-
-        # Poll for completion (Replicate predictions are async)
         max_wait_time = 120
         wait_interval = 2
         elapsed_time = 0
 
         while elapsed_time < max_wait_time:
-            get_response = httpx.get(get_url, headers=headers, timeout=120)
-            get_response.raise_for_status()
-            status_data = get_response.json()
-
-            if status_data["status"] == "succeeded":
-                content = status_data["output"]
-                if not content:
-                    raise AIError.model_error("Replicate API returned empty content")
-                return content
-            elif status_data["status"] == "failed":
-                raise AIError.model_error(f"Replicate prediction failed: {status_data.get('error', 'Unknown error')}")
-            elif status_data["status"] in ["starting", "processing"]:
-                import time
-
-                time.sleep(wait_interval)
-                elapsed_time += wait_interval
-            else:
-                raise AIError.model_error(f"Replicate API returned unknown status: {status_data['status']}")
+            try:
+                get_response = httpx.get(get_url, headers=headers, timeout=self.config.timeout, verify=get_ssl_verify())
+                get_response.raise_for_status()
+                status_data = get_response.json()
+
+                if status_data["status"] == "succeeded":
+                    content = status_data["output"]
+                    if not content:
+                        raise AIError.model_error("Replicate API returned empty content")
+                    return content
+                elif status_data["status"] == "failed":
+                    raise AIError.model_error(
+                        f"Replicate prediction failed: {status_data.get('error', 'Unknown error')}"
+                    )
+                elif status_data["status"] in ["starting", "processing"]:
+                    time.sleep(wait_interval)
+                    elapsed_time += wait_interval
+                else:
+                    raise AIError.model_error(f"Replicate API returned unknown status: {status_data['status']}")
+            except httpx.HTTPStatusError as e:
+                if e.response.status_code == 429:
+                    raise AIError.rate_limit_error(f"Replicate API rate limit exceeded: {e.response.text}") from e
+                raise AIError.model_error(f"Replicate API error: {e.response.status_code} - {e.response.text}") from e
+            except httpx.TimeoutException as e:
+                raise AIError.timeout_error(f"Replicate API request timed out: {str(e)}") from e
+            except AIError:
+                raise
+            except Exception as e:
+                raise AIError.model_error(f"Error polling Replicate API: {str(e)}") from e
 
         raise AIError.timeout_error("Replicate API prediction timed out")
-
-    except httpx.HTTPStatusError as e:
-        if e.response.status_code == 429:
-            raise AIError.rate_limit_error(f"Replicate API rate limit exceeded: {e.response.text}") from e
-        elif e.response.status_code == 401:
-            raise AIError.authentication_error(f"Replicate API authentication failed: {e.response.text}") from e
-        raise AIError.model_error(f"Replicate API error: {e.response.status_code} - {e.response.text}") from e
-    except httpx.TimeoutException as e:
-        raise AIError.timeout_error(f"Replicate API request timed out: {str(e)}") from e
-    except Exception as e:
-        raise AIError.model_error(f"Error calling Replicate API: {str(e)}") from e

gac/providers/streamlake.py

@@ -2,50 +2,30 @@
 
 import os
 
-import httpx
-
 from gac.errors import AIError
-
-
-def call_streamlake_api(model: str, messages: list[dict], temperature: float, max_tokens: int) -> str:
-    """Call StreamLake (Vanchin) chat completions API."""
-    api_key = os.getenv("STREAMLAKE_API_KEY") or os.getenv("VC_API_KEY")
-    if not api_key:
-        raise AIError.authentication_error(
-            "STREAMLAKE_API_KEY not found in environment variables (VC_API_KEY alias also not set)"
-        )
-
-    url = "https://vanchin.streamlake.ai/api/gateway/v1/endpoints/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()
-        choices = response_data.get("choices")
-        if not choices:
-            raise AIError.model_error("StreamLake API returned no choices")
-
-        message = choices[0].get("message", {})
-        content = message.get("content")
-        if content is None:
-            raise AIError.model_error("StreamLake API returned null content")
-        if content == "":
-            raise AIError.model_error("StreamLake API returned empty content")
-
-        return content
-    except httpx.HTTPStatusError as e:
-        if e.response.status_code == 429:
-            raise AIError.rate_limit_error(f"StreamLake API rate limit exceeded: {e.response.text}") from e
-        raise AIError.model_error(f"StreamLake API error: {e.response.status_code} - {e.response.text}") from e
-    except httpx.TimeoutException as e:
-        raise AIError.timeout_error(f"StreamLake API request timed out: {str(e)}") from e
-    except Exception as e:  # noqa: BLE001 - convert to AIError
-        raise AIError.model_error(f"Error calling StreamLake API: {str(e)}") from e
+from gac.providers.base import OpenAICompatibleProvider, ProviderConfig
+
+
+class StreamlakeProvider(OpenAICompatibleProvider):
+    """StreamLake (Vanchin) OpenAI-compatible provider with alternative env vars."""
+
+    config = ProviderConfig(
+        name="StreamLake",
+        api_key_env="STREAMLAKE_API_KEY",
+        base_url="https://vanchin.streamlake.ai/api/gateway/v1/endpoints",
+    )
+
+    def _get_api_url(self, model: str | None = None) -> str:
+        """Get StreamLake API URL with /chat/completions endpoint."""
+        return f"{self.config.base_url}/chat/completions"
+
+    def _get_api_key(self) -> str:
+        """Get API key from environment with fallback to VC_API_KEY."""
+        api_key = os.getenv(self.config.api_key_env)
+        if not api_key:
+            api_key = os.getenv("VC_API_KEY")
+        if not api_key:
+            raise AIError.authentication_error(
+                "STREAMLAKE_API_KEY not found in environment variables (VC_API_KEY alias also not set)"
+            )
+        return api_key

gac/providers/synthetic.py

@@ -1,42 +1,40 @@
 """Synthetic.new API provider for gac."""
 
 import os
-
-import httpx
+from typing import Any
 
 from gac.errors import AIError
-
-
-def call_synthetic_api(model: str, messages: list[dict], temperature: float, max_tokens: int) -> str:
-    """Call Synthetic API directly."""
-    # Handle model names without hf: prefix
-    if not model.startswith("hf:"):
-        model = f"hf:{model}"
-
-    api_key = os.getenv("SYNTHETIC_API_KEY") or os.getenv("SYN_API_KEY")
-    if not api_key:
-        raise AIError.authentication_error("SYNTHETIC_API_KEY or SYN_API_KEY not found in environment variables")
-
-    url = "https://api.synthetic.new/openai/v1/chat/completions"
-    headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
-
-    data = {"model": model, "messages": messages, "temperature": temperature, "max_completion_tokens": max_tokens}
-
-    try:
-        response = httpx.post(url, headers=headers, json=data, timeout=120)
-        response.raise_for_status()
-        response_data = response.json()
-        content = response_data["choices"][0]["message"]["content"]
-        if content is None:
-            raise AIError.model_error("Synthetic.new API returned null content")
-        if content == "":
-            raise AIError.model_error("Synthetic.new API returned empty content")
-        return content
-    except httpx.HTTPStatusError as e:
-        if e.response.status_code == 429:
-            raise AIError.rate_limit_error(f"Synthetic.new API rate limit exceeded: {e.response.text}") from e
-        raise AIError.model_error(f"Synthetic.new API error: {e.response.status_code} - {e.response.text}") from e
-    except httpx.TimeoutException as e:
-        raise AIError.timeout_error(f"Synthetic.new API request timed out: {str(e)}") from e
-    except Exception as e:
-        raise AIError.model_error(f"Error calling Synthetic.new API: {str(e)}") from e
+from gac.providers.base import OpenAICompatibleProvider, ProviderConfig
+
+
+class SyntheticProvider(OpenAICompatibleProvider):
+    """Synthetic.new OpenAI-compatible provider with alternative env vars and model preprocessing."""
+
+    config = ProviderConfig(
+        name="Synthetic",
+        api_key_env="SYNTHETIC_API_KEY",
+        base_url="https://api.synthetic.new/openai/v1/chat/completions",
+    )
+
+    def _get_api_key(self) -> str:
+        """Get API key from environment with fallback to SYN_API_KEY."""
+        api_key = os.getenv(self.config.api_key_env)
+        if not api_key:
+            api_key = os.getenv("SYN_API_KEY")
+        if not api_key:
+            raise AIError.authentication_error("SYNTHETIC_API_KEY or SYN_API_KEY not found in environment variables")
+        return api_key
+
+    def _build_request_body(
+        self, messages: list[dict[str, Any]], temperature: float, max_tokens: int, model: str, **kwargs: Any
+    ) -> dict[str, Any]:
+        """Build request body with model name preprocessing and max_completion_tokens."""
+        # Auto-add hf: prefix if not present
+        if not model.startswith("hf:"):
+            model = f"hf:{model}"
+
+        data = super()._build_request_body(messages, temperature, max_tokens, model, **kwargs)
+        data["max_completion_tokens"] = data.pop("max_tokens")
+        # Ensure the prefixed model is used
+        data["model"] = model
+        return data

gac/providers/together.py

@@ -1,38 +1,15 @@
 """Together AI API provider for gac."""
 
-import os
+from gac.providers.base import OpenAICompatibleProvider, ProviderConfig
 
-import httpx
 
-from gac.errors import AIError
+class TogetherProvider(OpenAICompatibleProvider):
+    config = ProviderConfig(
+        name="Together",
+        api_key_env="TOGETHER_API_KEY",
+        base_url="https://api.together.xyz/v1",
+    )
 
-
-def call_together_api(model: str, messages: list[dict], temperature: float, max_tokens: int) -> str:
-    """Call Together AI API directly."""
-    api_key = os.getenv("TOGETHER_API_KEY")
-    if not api_key:
-        raise AIError.authentication_error("TOGETHER_API_KEY not found in environment variables")
-
-    url = "https://api.together.xyz/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()
-        content = response_data["choices"][0]["message"]["content"]
-        if content is None:
-            raise AIError.model_error("Together AI API returned null content")
-        if content == "":
-            raise AIError.model_error("Together AI API returned empty content")
-        return content
-    except httpx.HTTPStatusError as e:
-        if e.response.status_code == 429:
-            raise AIError.rate_limit_error(f"Together AI API rate limit exceeded: {e.response.text}") from e
-        raise AIError.model_error(f"Together AI API error: {e.response.status_code} - {e.response.text}") from e
-    except httpx.TimeoutException as e:
-        raise AIError.timeout_error(f"Together AI API request timed out: {str(e)}") from e
-    except Exception as e:
-        raise AIError.model_error(f"Error calling Together AI API: {str(e)}") from e
+    def _get_api_url(self, model: str | None = None) -> str:
+        """Get Together API URL with /chat/completions endpoint."""
+        return f"{self.config.base_url}/chat/completions"

gac/providers/zai.py

@@ -1,59 +1,31 @@
 """Z.AI API provider for gac."""
 
-import os
-
-import httpx
-
-from gac.errors import AIError
-
-
-def _call_zai_api_impl(
-    url: str, api_name: str, model: str, messages: list[dict], temperature: float, max_tokens: int
-) -> str:
-    """Internal implementation for Z.AI API calls."""
-    api_key = os.getenv("ZAI_API_KEY")
-    if not api_key:
-        raise AIError.authentication_error("ZAI_API_KEY not found in environment variables")
-
-    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()
-
-        # Handle different possible response structures
-        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"]
-                if content is None:
-                    raise AIError.model_error(f"{api_name} API returned null content")
-                if content == "":
-                    raise AIError.model_error(f"{api_name} API returned empty content")
-                return content
-            else:
-                raise AIError.model_error(f"{api_name} API response missing content: {response_data}")
-        else:
-            raise AIError.model_error(f"{api_name} API unexpected response structure: {response_data}")
-    except httpx.HTTPStatusError as e:
-        if e.response.status_code == 429:
-            raise AIError.rate_limit_error(f"{api_name} API rate limit exceeded: {e.response.text}") from e
-        raise AIError.model_error(f"{api_name} API error: {e.response.status_code} - {e.response.text}") from e
-    except httpx.TimeoutException as e:
-        raise AIError.timeout_error(f"{api_name} API request timed out: {str(e)}") from e
-    except Exception as e:
-        raise AIError.model_error(f"Error calling {api_name} API: {str(e)}") from e
-
-
-def call_zai_api(model: str, messages: list[dict], temperature: float, max_tokens: int) -> str:
-    """Call Z.AI regular API directly."""
-    url = "https://api.z.ai/api/paas/v4/chat/completions"
-    return _call_zai_api_impl(url, "Z.AI", model, messages, temperature, max_tokens)
-
-
-def call_zai_coding_api(model: str, messages: list[dict], temperature: float, max_tokens: int) -> str:
-    """Call Z.AI coding API directly."""
-    url = "https://api.z.ai/api/coding/paas/v4/chat/completions"
-    return _call_zai_api_impl(url, "Z.AI coding", model, messages, temperature, max_tokens)
+from gac.providers.base import OpenAICompatibleProvider, ProviderConfig
+
+
+class ZAIProvider(OpenAICompatibleProvider):
+    """Z.AI regular API provider with OpenAI-compatible format."""
+
+    config = ProviderConfig(
+        name="Z.AI",
+        api_key_env="ZAI_API_KEY",
+        base_url="https://api.z.ai/api/paas/v4",
+    )
+
+    def _get_api_url(self, model: str | None = None) -> str:
+        """Get Z.AI API URL with /chat/completions endpoint."""
+        return f"{self.config.base_url}/chat/completions"
+
+
+class ZAICodingProvider(OpenAICompatibleProvider):
+    """Z.AI coding API provider with OpenAI-compatible format."""
+
+    config = ProviderConfig(
+        name="Z.AI Coding",
+        api_key_env="ZAI_API_KEY",
+        base_url="https://api.z.ai/api/coding/paas/v4",
+    )
+
+    def _get_api_url(self, model: str | None = None) -> str:
+        """Get Z.AI Coding API URL with /chat/completions endpoint."""
+        return f"{self.config.base_url}/chat/completions"

gac/security.py

@@ -93,7 +93,7 @@ class SecretPatterns:
     ]
 
     @classmethod
-    def get_all_patterns(cls) -> dict[str, re.Pattern]:
+    def get_all_patterns(cls) -> dict[str, re.Pattern[str]]:
         """Get all secret detection patterns.
 
         Returns:

gac/templates/__init__.py

@@ -0,0 +1 @@
+# This package contains prompt templates for gac.

gac/templates/question_generation.txt

@@ -0,0 +1,60 @@
+<role>
+You are an expert code reviewer specializing in identifying missing context and intent in code changes. Your task is to analyze git diffs and generate focused questions that clarify the "why" behind the changes.
+</role>
+
+<focus>
+Analyze the git diff and determine the appropriate number of questions based on change complexity. Generate 1-5 focused questions to clarify intent, motivation, and impact. Your questions should help the developer provide the essential context needed for a meaningful commit message.
+</focus>
+
+<adaptive_guidelines>
+- For very small changes (single file, <10 lines): Ask 1-2 essential questions about core purpose
+- For small changes (few files, <50 lines): Ask 1-3 questions covering intent and impact
+- For medium changes (multiple files, <200 lines): Ask 2-4 questions covering scope, intent, and impact
+- For large changes (many files or substantial modifications): Ask 3-5 questions covering all aspects
+- Always prioritize questions that would most help generate an informative commit message
+- Lean toward fewer questions for straightforward changes
+</adaptive_guidelines>
+
+<guidelines>
+- Focus on WHY the changes were made, not just WHAT was changed
+- Ask about the intent, motivation, or business purpose behind the changes
+- Consider what future developers need to understand about this change
+- Ask about the broader impact or consequences of the changes
+- Target areas where technical implementation doesn't reveal the underlying purpose
+- Keep questions concise and specific
+- Format as a clean list for easy parsing
+</guidelines>
+
+<rules>
+NEVER write or rewrite the commit message; only ask questions.
+DO NOT suggest specific commit message formats or wording.
+DO NOT ask about implementation details that are already clear from the diff.
+DO NOT include any explanations or preamble with your response.
+</rules>
+
+<output_format>
+Respond with ONLY a numbered list of questions, one per line:
+1. First focused question?
+2. Second focused question?
+3. Third focused question?
+4. [etc...]
+</output_format>
+
+<examples>
+Good example questions for small changes:
+1. What problem does this fix?
+2. Why was this approach chosen?
+
+Good example questions for larger changes:
+1. What problem or user need does this change address?
+2. Why was this particular approach chosen over alternatives?
+3. What impact will this have on existing functionality?
+4. What motivated the addition of these new error cases?
+5. Why are these validation rules being added now?
+
+Bad examples (violates rules):
+feat: add user authentication - This is a commit message, not a question
+Should I use "feat" or "fix" for this change? - This asks about formatting, not context
+Why did you rename the variable from x to y? - Too implementation-specific
+You should reformat this as "fix: resolve authentication issue" - This rewrites the message
+</examples>