gac 0.19.1__py3-none-any.whl → 1.0.1__py3-none-any.whl

gac/__init__.py

@@ -2,6 +2,13 @@
 
 from gac.__version__ import __version__
 from gac.ai import generate_commit_message
+from gac.ai_providers import (
+    anthropic_generate,
+    cerebras_generate,
+    groq_generate,
+    ollama_generate,
+    openai_generate,
+)
 from gac.git import get_staged_files, push_changes
 from gac.prompt import build_prompt, clean_commit_message
 
@@ -12,4 +19,9 @@ __all__ = [
     "clean_commit_message",
     "get_staged_files",
     "push_changes",
+    "anthropic_generate",
+    "cerebras_generate",
+    "groq_generate",
+    "ollama_generate",
+    "openai_generate",
 ]

gac/__version__.py

@@ -1,3 +1,3 @@
 """Version information for gac package."""
 
-__version__ = "0.19.1"
+__version__ = "1.0.1"

gac/ai.py

@@ -5,14 +5,20 @@ It consolidates all AI-related functionality including token counting and commit
 """
 
 import logging
-import time
+import os
 from functools import lru_cache
 from typing import Any
 
-import aisuite as ai
+import httpx
 import tiktoken
-from halo import Halo
 
+from gac.ai_providers import (
+    anthropic_generate,
+    cerebras_generate,
+    groq_generate,
+    ollama_generate,
+    openai_generate,
+)
 from gac.constants import EnvDefaults, Utility
 from gac.errors import AIError
 
@@ -26,19 +32,10 @@ def count_tokens(content: str | list[dict[str, str]] | dict[str, Any], model: st
         return 0
 
     if model.startswith("anthropic"):
-        import anthropic
-
-        try:
-            client = anthropic.Anthropic()
-
-            # Use the messages.count_tokens API for accurate counting
-            model_name = model.split(":", 1)[1] if ":" in model else "claude-3-5-haiku-latest"
-            response = client.messages.count_tokens(model=model_name, messages=[{"role": "user", "content": text}])
-
-            return response.input_tokens
-        except Exception:
-            # Fallback to simple estimation for Anthropic models
-            return len(text) // 4
+        anthropic_tokens = anthropic_count_tokens(text, model)
+        if anthropic_tokens is not None:
+            return anthropic_tokens
+        return len(text) // 4
 
     try:
         encoding = get_encoding(model)
@@ -48,6 +45,60 @@ def count_tokens(content: str | list[dict[str, str]] | dict[str, Any], model: st
         return len(text) // 4
 
 
+def anthropic_count_tokens(text: str, model: str) -> int | None:
+    """Call Anthropic's token count endpoint and return the token usage.
+
+    Returns the token count when successful, otherwise ``None`` so callers can
+    fall back to a heuristic estimate.
+    """
+    api_key = os.getenv("ANTHROPIC_API_KEY")
+    if not api_key:
+        logger.debug("ANTHROPIC_API_KEY not set; using heuristic token estimation for Anthropic model")
+        return None
+
+    model_name = model.split(":", 1)[1] if ":" in model else "claude-3-5-haiku-latest"
+    headers = {
+        "Content-Type": "application/json",
+        "x-api-key": api_key,
+        "anthropic-version": "2023-06-01",
+    }
+    payload = {
+        "model": model_name,
+        "messages": [
+            {
+                "role": "user",
+                "content": [
+                    {
+                        "type": "text",
+                        "text": text,
+                    }
+                ],
+            }
+        ],
+    }
+
+    try:
+        response = httpx.post(
+            "https://api.anthropic.com/v1/messages/count_tokens",
+            headers=headers,
+            json=payload,
+            timeout=30.0,
+        )
+        response.raise_for_status()
+        data = response.json()
+
+        if "input_tokens" in data:
+            return data["input_tokens"]
+        if "usage" in data and "input_tokens" in data["usage"]:
+            return data["usage"]["input_tokens"]
+
+        logger.warning("Unexpected response format from Anthropic token count API: %s", data)
+    except Exception as exc:
+        logger.warning("Failed to retrieve Anthropic token count via HTTP: %s", exc)
+
+    return None
+
+
 def extract_text_content(content: str | list[dict[str, str]] | dict[str, Any]) -> str:
     """Extract text content from various input formats."""
     if isinstance(content, str):
@@ -77,7 +128,7 @@ def generate_commit_message(
     max_retries: int = EnvDefaults.MAX_RETRIES,
     quiet: bool = False,
 ) -> str:
-    """Generate a commit message using aisuite.
+    """Generate a commit message using direct API calls to AI providers.
 
     Args:
         model: The model to use in provider:model_name format (e.g., 'anthropic:claude-3-5-haiku-latest')
@@ -106,76 +157,24 @@ def generate_commit_message(
             f"Invalid model format: {model}. Please use the format 'provider:model_name'."
         ) from err
 
-    client = ai.Client()
-
-    # 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}]
+    # 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
 
-    if quiet:
-        spinner = None
+    # 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)
     else:
-        spinner = Halo(text=f"Generating commit message with {model}...", spinner="dots")
-        spinner.start()
-
-    last_error = None
-
-    retry_count = 0
-    while retry_count < max_retries:
-        try:
-            logger.debug(f"Trying with model {model} (attempt {retry_count + 1}/{max_retries})")
-            response = client.chat.completions.create(
-                model=model,
-                messages=messages,
-                temperature=temperature,
-                max_tokens=max_tokens,
-            )
-
-            message = response.choices[0].message.content if hasattr(response, "choices") else response.content
-
-            if spinner:
-                spinner.succeed(f"Generated commit message with {model}")
-
-            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("Failed to generate commit message")
-
-    error_str = str(last_error).lower()
-
-    if "api key" in error_str or "unauthorized" in error_str or "authentication" in error_str:
-        error_type = "authentication"
-    elif "timeout" in error_str:
-        error_type = "timeout"
-    elif "rate limit" in error_str or "too many requests" in error_str:
-        error_type = "rate_limit"
-    elif "connect" in error_str or "network" in error_str:
-        error_type = "connection"
-    elif "model" in error_str or "not found" in error_str:
-        error_type = "model"
-    else:
-        error_type = "unknown"
-
-    raise AIError(
-        f"Failed to generate commit message after {max_retries} attempts: {last_error}", error_type=error_type
-    )
+        raise AIError.model_error(f"Unsupported provider: {provider}")

gac/ai_providers.py

@@ -0,0 +1,404 @@
+"""Direct HTTP API calls to AI providers using httpx.
+
+This module provides functions for making direct HTTP API calls to various AI providers.
+Each provider has its own function to generate commit messages using only httpx.
+"""
+
+import logging
+import os
+import time
+
+import httpx
+from halo import Halo
+
+from gac.constants import EnvDefaults
+from gac.errors import AIError
+
+logger = logging.getLogger(__name__)
+
+
+def _classify_error(error_str: str) -> str:
+    """Classify error types based on error message content."""
+    error_str = error_str.lower()
+
+    if (
+        "api key" in error_str
+        or "unauthorized" in error_str
+        or "authentication" in error_str
+        or "invalid api key" in error_str
+    ):
+        return "authentication"
+    elif "timeout" in error_str or "timed out" in error_str or "request timeout" in error_str:
+        return "timeout"
+    elif "rate limit" in error_str or "too many requests" in error_str or "rate limit exceeded" in error_str:
+        return "rate_limit"
+    elif "connect" in error_str or "network" in error_str or "network connection failed" in error_str:
+        return "connection"
+    elif "model" in error_str or "not found" in error_str or "model not found" in error_str:
+        return "model"
+    else:
+        return "unknown"
+
+
+def anthropic_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
+    """
+    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 cerebras_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
+    """
+    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 groq_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
+    """
+    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 ollama_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 openai_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
+    """
+    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
+    )

{gac-0.19.1.dist-info → gac-1.0.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gac
-Version: 0.19.1
+Version: 1.0.1
 Summary: AI-powered Git commit message generator with multi-provider support
 Project-URL: Homepage, https://github.com/cellwebb/gac
 Project-URL: Documentation, https://github.com/cellwebb/gac#readme
@@ -20,19 +20,15 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Requires-Python: >=3.10
-Requires-Dist: aisuite>=0.1.11
 Requires-Dist: anthropic>=0.68.0
-Requires-Dist: cerebras-cloud-sdk==1.49.0
 Requires-Dist: click>=8.3.0
-Requires-Dist: docstring-parser
-Requires-Dist: groq>=0.31.1
 Requires-Dist: halo
-Requires-Dist: ollama>=0.5.4
-Requires-Dist: openai>=1.108.1
+Requires-Dist: httpx>=0.28.0
 Requires-Dist: pydantic>=2.11.9
 Requires-Dist: python-dotenv>=1.1.1
 Requires-Dist: questionary
 Requires-Dist: rich>=14.1.0
+Requires-Dist: sumy
 Requires-Dist: tiktoken>=0.11.0
 Provides-Extra: dev
 Requires-Dist: build; extra == 'dev'

{gac-0.19.1.dist-info → gac-1.0.1.dist-info}/RECORD

@@ -1,6 +1,7 @@
-gac/__init__.py,sha256=z9yGInqtycFIT3g1ca24r-A3699hKVaRqGUI79wsmMc,415
-gac/__version__.py,sha256=hyGMebb4FUEdQREZTwJbEWXUpawroToZSIoTm_-QyVs,67
-gac/ai.py,sha256=vncnizPce4QbbpddjVORdK2X95rIJwWbJxmIhjscQSU,6357
+gac/__init__.py,sha256=T3KAW47ZmvB5AozG_uL92ryBYgp-2LNEztBaxaY3dJE,674
+gac/__version__.py,sha256=8Yc4NMnplKKb2pLEFCgKeKRVX9Q-31V40n444l7Ao5M,66
+gac/ai.py,sha256=E0vfkWyqYvNJFAbOYvHG-tnwcQakAYm34oHMbKM5GIk,6267
+gac/ai_providers.py,sha256=QiVSspn0cauxl7m1Chn6nw1kAO1ByAuPiQqZWyZZCys,13210
 gac/cli.py,sha256=eQS8S7v6p0CfN9wtr239ujYGTi9rKl-KV7STX2U-C3w,4581
 gac/config.py,sha256=wSgEDjtis7Vk1pv5VPvYmJyD9-tymDS6GiUHjnCMbIM,1486
 gac/config_cli.py,sha256=v9nFHZO1RvK9fzHyuUS6SG-BCLHMsdOMDwWamBhVVh4,1608
@@ -13,8 +14,8 @@ gac/main.py,sha256=WI7mxIbL05neQr1VfoopOeZKIonwpwFeZCt_4VFewPY,11987
 gac/preprocess.py,sha256=4igtZ9OTHgTpqwlJmbcGaqzmdD0HHCZJwsZ9eG118Gk,15360
 gac/prompt.py,sha256=_fv24XU3DZE_S72vcdUYnNkmy-_KXnr1Vlc-9okop7E,17263
 gac/utils.py,sha256=W3ladtmsH01MNLdckQYTzYrYbTGEdzCKI36he9C-y_E,3945
-gac-0.19.1.dist-info/METADATA,sha256=jpY9N8ZkA0n30pqIf_5yOxXZVHBtbzUm2FkROBYt9YE,8496
-gac-0.19.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-gac-0.19.1.dist-info/entry_points.txt,sha256=tdjN-XMmcWfL92swuRAjT62bFLOAwk9bTMRLGP5Z4aI,36
-gac-0.19.1.dist-info/licenses/LICENSE,sha256=s11puNmYfzwoSwG96nhOJe268Y1QFckr8-Hmzo3_eJE,1087
-gac-0.19.1.dist-info/RECORD,,
+gac-1.0.1.dist-info/METADATA,sha256=iEfp3b1Mx12iwon4aD6QDE8foNYrn-dN9yCmwhuKQTU,8351
+gac-1.0.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+gac-1.0.1.dist-info/entry_points.txt,sha256=tdjN-XMmcWfL92swuRAjT62bFLOAwk9bTMRLGP5Z4aI,36
+gac-1.0.1.dist-info/licenses/LICENSE,sha256=vOab37NouL1PNs5BswnPayrMCqaN2sqLfMQfqPDrpZg,1103
+gac-1.0.1.dist-info/RECORD,,

{gac-0.19.1.dist-info → gac-1.0.1.dist-info}/licenses/LICENSE

@@ -1,6 +1,6 @@
 # MIT License
 
-Copyright (c) 2025 cellwebb <cell@criteria.dev>
+Copyright (c) 2025 cellwebb <cellwebb@users.noreply.github.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
 documentation files (the "Software"), to deal in the Software without restriction, including without limitation the