codepp 0.0.437__py3-none-any.whl

code_puppy/hook_engine/registry.py

@@ -0,0 +1,106 @@
+"""
+Registry management for hooks.
+
+Builds and manages the HookRegistry from configuration dictionaries.
+"""
+
+import logging
+import re
+from typing import Any, Dict
+
+from .models import HookConfig, HookRegistry
+
+logger = logging.getLogger(__name__)
+
+# Supported event types
+SUPPORTED_EVENT_TYPES = [
+    "PreToolUse",
+    "PostToolUse",
+    "SessionStart",
+    "SessionEnd",
+    "PreCompact",
+    "UserPromptSubmit",
+    "Notification",
+    "Stop",
+    "SubagentStop",
+]
+
+
+def build_registry_from_config(config: Dict[str, Any]) -> HookRegistry:
+    """
+    Build a HookRegistry from a configuration dictionary.
+
+    Args:
+        config: Hook configuration dictionary
+
+    Returns:
+        Populated HookRegistry
+    """
+    registry = HookRegistry()
+
+    for event_type, hook_groups in config.items():
+        if event_type.startswith("_"):
+            continue  # skip comment keys
+
+        if not isinstance(hook_groups, list):
+            logger.warning(f"Hook groups for '{event_type}' must be a list, skipping")
+            continue
+
+        for group in hook_groups:
+            if not isinstance(group, dict):
+                continue
+
+            matcher = group.get("matcher", "*")
+            hooks_data = group.get("hooks", [])
+
+            for hook_data in hooks_data:
+                if not isinstance(hook_data, dict):
+                    continue
+                if hook_data.get("type") == "command" and not hook_data.get("command"):
+                    continue
+
+                try:
+                    hook = HookConfig(
+                        matcher=matcher,
+                        type=hook_data.get("type", "command"),
+                        command=hook_data.get("command", hook_data.get("prompt", "")),
+                        timeout=hook_data.get("timeout", 5000),
+                        once=hook_data.get("once", False),
+                        enabled=hook_data.get("enabled", True),
+                        id=hook_data.get("id"),
+                    )
+                    registry.add_hook(event_type, hook)
+                except (ValueError, KeyError) as e:
+                    logger.warning(f"Skipping invalid hook in {event_type}: {e}")
+
+    return registry
+
+
+def get_registry_stats(registry: HookRegistry) -> Dict[str, Any]:
+    """Get statistics about a registry."""
+    stats: Dict[str, Any] = {
+        "total_hooks": registry.count_hooks(),
+        "enabled_hooks": 0,
+        "disabled_hooks": 0,
+        "by_event": {},
+    }
+
+    def _to_attr(event_type: str) -> str:
+        s1 = re.sub("(.)([A-Z][a-z]+)", r"\1_\2", event_type)
+        return re.sub("([a-z0-9])([A-Z])", r"\1_\2", s1).lower()
+
+    for event_type in SUPPORTED_EVENT_TYPES:
+        attr = _to_attr(event_type)
+        hooks = getattr(registry, attr, [])
+        enabled = sum(1 for h in hooks if h.enabled)
+        disabled = len(hooks) - enabled
+        stats["enabled_hooks"] += enabled
+        stats["disabled_hooks"] += disabled
+        if hooks:
+            stats["by_event"][event_type] = {
+                "total": len(hooks),
+                "enabled": enabled,
+                "disabled": disabled,
+            }
+
+    return stats

code_puppy/hook_engine/validator.py

@@ -0,0 +1,144 @@
+"""
+Configuration validation for hooks.
+
+Validates hook configuration dictionaries and provides actionable error messages.
+"""
+
+import logging
+from typing import Any, Dict, List, Optional, Tuple
+
+logger = logging.getLogger(__name__)
+
+VALID_EVENT_TYPES = [
+    "PreToolUse",
+    "PostToolUse",
+    "SessionStart",
+    "SessionEnd",
+    "PreCompact",
+    "UserPromptSubmit",
+    "Notification",
+    "Stop",
+    "SubagentStop",
+]
+
+VALID_HOOK_TYPES = ["command", "prompt"]
+
+
+def validate_hooks_config(config: Dict[str, Any]) -> Tuple[bool, List[str]]:
+    """
+    Validate a hooks configuration dictionary.
+
+    Returns:
+        Tuple of (is_valid, list_of_error_messages)
+    """
+    errors: List[str] = []
+
+    if not isinstance(config, dict):
+        return False, ["Configuration must be a dictionary"]
+
+    for event_type, hook_groups in config.items():
+        if event_type.startswith("_"):
+            continue  # skip comment keys
+
+        if event_type not in VALID_EVENT_TYPES:
+            errors.append(
+                f"Unknown event type '{event_type}'. "
+                f"Valid types: {', '.join(VALID_EVENT_TYPES)}"
+            )
+            continue
+
+        if not isinstance(hook_groups, list):
+            errors.append(f"'{event_type}' must be a list of hook groups")
+            continue
+
+        for i, group in enumerate(hook_groups):
+            if not isinstance(group, dict):
+                errors.append(
+                    f"'{event_type}[{i}]' must be a dict with 'matcher' and 'hooks'"
+                )
+                continue
+
+            if "matcher" not in group:
+                errors.append(f"'{event_type}[{i}]' missing required field 'matcher'")
+
+            if "hooks" not in group:
+                errors.append(f"'{event_type}[{i}]' missing required field 'hooks'")
+                continue
+
+            if not isinstance(group["hooks"], list):
+                errors.append(f"'{event_type}[{i}].hooks' must be a list")
+                continue
+
+            for j, hook in enumerate(group["hooks"]):
+                hook_errors = _validate_hook(event_type, i, j, hook)
+                errors.extend(hook_errors)
+
+    return len(errors) == 0, errors
+
+
+def _validate_hook(
+    event_type: str, group_idx: int, hook_idx: int, hook: Any
+) -> List[str]:
+    errors: List[str] = []
+    prefix = f"'{event_type}[{group_idx}].hooks[{hook_idx}]'"
+
+    if not isinstance(hook, dict):
+        return [f"{prefix} must be a dict"]
+
+    hook_type = hook.get("type")
+    if not hook_type:
+        errors.append(f"{prefix} missing required field 'type'")
+    elif hook_type not in VALID_HOOK_TYPES:
+        errors.append(
+            f"{prefix} invalid type '{hook_type}'. Must be one of: {', '.join(VALID_HOOK_TYPES)}"
+        )
+
+    if hook_type == "command" and not hook.get("command"):
+        errors.append(f"{prefix} missing required field 'command' for type 'command'")
+    elif hook_type == "prompt" and not hook.get("prompt") and not hook.get("command"):
+        errors.append(
+            f"{prefix} missing required field 'prompt' (or 'command') for type 'prompt'"
+        )
+
+    timeout = hook.get("timeout")
+    if timeout is not None:
+        if not isinstance(timeout, (int, float)) or timeout < 100:
+            errors.append(f"{prefix} 'timeout' must be >= 100ms, got: {timeout}")
+
+    return errors
+
+
+def format_validation_report(
+    is_valid: bool, errors: List[str], suggestions: Optional[List[str]] = None
+) -> str:
+    lines = []
+    if is_valid:
+        lines.append("✓ Configuration is valid")
+    else:
+        lines.append(f"✗ Configuration has {len(errors)} error(s):")
+        for error in errors:
+            lines.append(f"  • {error}")
+
+    if suggestions:
+        lines.append("\nSuggestions:")
+        for suggestion in suggestions:
+            lines.append(f"  → {suggestion}")
+
+    return "\n".join(lines)
+
+
+def get_config_suggestions(config: Dict[str, Any], errors: List[str]) -> List[str]:
+    suggestions: List[str] = []
+
+    for error in errors:
+        if "Unknown event type" in error:
+            suggestions.append("Valid event types are: " + ", ".join(VALID_EVENT_TYPES))
+            break
+
+    if any("missing required field 'command'" in e for e in errors):
+        suggestions.append(
+            "Hook commands should be shell commands like: "
+            "'bash .claude/hooks/my-hook.sh'"
+        )
+
+    return suggestions

code_puppy/http_utils.py

@@ -0,0 +1,361 @@
+"""
+HTTP utilities module for code-puppy.
+
+This module provides functions for creating properly configured HTTP clients.
+"""
+
+import asyncio
+import os
+import socket
+import time
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Dict, Optional, Union
+
+import httpx
+
+if TYPE_CHECKING:
+    import requests
+from code_puppy.config import get_http2
+
+
+@dataclass
+class ProxyConfig:
+    """Configuration for proxy and SSL settings."""
+
+    verify: Union[bool, str, None]
+    trust_env: bool
+    proxy_url: str | None
+    disable_retry: bool
+    http2_enabled: bool
+
+
+def _resolve_proxy_config(verify: Union[bool, str, None] = None) -> ProxyConfig:
+    """Resolve proxy, SSL, and retry settings from environment.
+
+    This centralizes the logic for detecting proxies, determining SSL verification,
+    and checking if retry transport should be disabled.
+    """
+    if verify is None:
+        verify = get_cert_bundle_path()
+
+    http2_enabled = get_http2()
+
+    disable_retry = os.environ.get(
+        "CODE_PUPPY_DISABLE_RETRY_TRANSPORT", ""
+    ).lower() in ("1", "true", "yes")
+
+    has_proxy = bool(
+        os.environ.get("HTTP_PROXY")
+        or os.environ.get("HTTPS_PROXY")
+        or os.environ.get("http_proxy")
+        or os.environ.get("https_proxy")
+    )
+
+    # Determine trust_env and verify based on proxy/retry settings
+    if disable_retry:
+        # Test mode: disable SSL verification for proxy testing
+        verify = False
+        trust_env = True
+    elif has_proxy:
+        # Production proxy: keep SSL verification enabled
+        trust_env = True
+    else:
+        trust_env = False
+
+    # Extract proxy URL
+    proxy_url = None
+    if has_proxy:
+        proxy_url = (
+            os.environ.get("HTTPS_PROXY")
+            or os.environ.get("https_proxy")
+            or os.environ.get("HTTP_PROXY")
+            or os.environ.get("http_proxy")
+        )
+
+    return ProxyConfig(
+        verify=verify,
+        trust_env=trust_env,
+        proxy_url=proxy_url,
+        disable_retry=disable_retry,
+        http2_enabled=http2_enabled,
+    )
+
+
+try:
+    from .reopenable_async_client import ReopenableAsyncClient
+except ImportError:
+    ReopenableAsyncClient = None
+
+try:
+    from .messaging import emit_info, emit_warning
+except ImportError:
+    # Fallback if messaging system is not available
+    def emit_info(content: str, **metadata):
+        pass  # No-op if messaging system is not available
+
+    def emit_warning(content: str, **metadata):
+        pass
+
+
+class RetryingAsyncClient(httpx.AsyncClient):
+    """AsyncClient with built-in rate limit handling (429) and retries.
+
+    This replaces the Tenacity transport with a more direct subclass implementation,
+    which plays nicer with proxies and custom transports (like Antigravity).
+
+    Special handling for Cerebras: Their Retry-After headers are absurdly aggressive
+    (often 60s), so we ignore them and use a 3s base backoff instead.
+    """
+
+    def __init__(
+        self,
+        retry_status_codes: tuple = (429, 502, 503, 504),
+        max_retries: int = 5,
+        model_name: str = "",
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        self.retry_status_codes = retry_status_codes
+        self.max_retries = max_retries
+        self.model_name = model_name.lower() if model_name else ""
+        # Cerebras sends crazy aggressive Retry-After headers (60s), ignore them
+        self._ignore_retry_headers = "cerebras" in self.model_name
+
+    async def send(self, request: httpx.Request, **kwargs: Any) -> httpx.Response:
+        """Send request with automatic retries for rate limits and server errors."""
+        last_response = None
+        last_exception = None
+
+        for attempt in range(self.max_retries + 1):
+            try:
+                response = await super().send(request, **kwargs)
+                last_response = response
+
+                # Check for retryable status
+                if response.status_code not in self.retry_status_codes:
+                    return response
+
+                # Close response if we're going to retry
+                await response.aclose()
+
+                # Determine wait time - Cerebras gets special treatment
+                if self._ignore_retry_headers:
+                    # Cerebras: 3s base with exponential backoff (3s, 6s, 12s...)
+                    wait_time = 3.0 * (2**attempt)
+                else:
+                    # Default exponential backoff: 1s, 2s, 4s...
+                    wait_time = 1.0 * (2**attempt)
+
+                    # Check Retry-After header (only for non-Cerebras)
+                    retry_after = response.headers.get("Retry-After")
+                    if retry_after:
+                        try:
+                            wait_time = float(retry_after)
+                        except ValueError:
+                            # Try parsing http-date
+                            from email.utils import parsedate_to_datetime
+
+                            try:
+                                date = parsedate_to_datetime(retry_after)
+                                wait_time = date.timestamp() - time.time()
+                            except Exception:
+                                pass
+
+                # Cap wait time
+                wait_time = max(0.5, min(wait_time, 60.0))
+
+                if attempt < self.max_retries:
+                    provider_note = (
+                        " (ignoring header)" if self._ignore_retry_headers else ""
+                    )
+                    emit_info(
+                        f"HTTP retry: {response.status_code} received{provider_note}. "
+                        f"Waiting {wait_time:.1f}s (attempt {attempt + 1}/{self.max_retries})"
+                    )
+                    await asyncio.sleep(wait_time)
+
+            except (httpx.ConnectError, httpx.ReadTimeout, httpx.PoolTimeout) as e:
+                last_exception = e
+                wait_time = 1.0 * (2**attempt)
+                if attempt < self.max_retries:
+                    emit_warning(
+                        f"HTTP connection error: {e}. Retrying in {wait_time}s..."
+                    )
+                    await asyncio.sleep(wait_time)
+                else:
+                    raise
+            except Exception:
+                raise
+
+        # Return last response (even if it's an error status)
+        if last_response:
+            return last_response
+
+        # Should catch this in loop, but just in case
+        if last_exception:
+            raise last_exception
+
+        return last_response
+
+
+def get_cert_bundle_path() -> str | None:
+    # First check if SSL_CERT_FILE environment variable is set
+    ssl_cert_file = os.environ.get("SSL_CERT_FILE")
+    if ssl_cert_file and os.path.exists(ssl_cert_file):
+        return ssl_cert_file
+
+
+def create_client(
+    timeout: int = 180,
+    verify: Union[bool, str] = None,
+    headers: Optional[Dict[str, str]] = None,
+    retry_status_codes: tuple = (429, 502, 503, 504),
+) -> httpx.Client:
+    if verify is None:
+        verify = get_cert_bundle_path()
+
+    # Check if HTTP/2 is enabled in config
+    http2_enabled = get_http2()
+
+    # If retry components are available, create a client with retry transport
+    # Note: TenacityTransport was removed. For now we just return a standard client.
+    # Future TODO: Implement RetryingClient(httpx.Client) if needed.
+    return httpx.Client(
+        verify=verify,
+        headers=headers or {},
+        timeout=timeout,
+        http2=http2_enabled,
+    )
+
+
+def create_async_client(
+    timeout: int = 180,
+    verify: Union[bool, str] = None,
+    headers: Optional[Dict[str, str]] = None,
+    retry_status_codes: tuple = (429, 502, 503, 504),
+    model_name: str = "",
+) -> httpx.AsyncClient:
+    config = _resolve_proxy_config(verify)
+
+    if not config.disable_retry:
+        return RetryingAsyncClient(
+            retry_status_codes=retry_status_codes,
+            model_name=model_name,
+            proxy=config.proxy_url,
+            verify=config.verify,
+            headers=headers or {},
+            timeout=timeout,
+            http2=config.http2_enabled,
+            trust_env=config.trust_env,
+        )
+    else:
+        return httpx.AsyncClient(
+            proxy=config.proxy_url,
+            verify=config.verify,
+            headers=headers or {},
+            timeout=timeout,
+            http2=config.http2_enabled,
+            trust_env=config.trust_env,
+        )
+
+
+def create_requests_session(
+    timeout: float = 5.0,
+    verify: Union[bool, str] = None,
+    headers: Optional[Dict[str, str]] = None,
+) -> "requests.Session":
+    import requests
+
+    session = requests.Session()
+
+    if verify is None:
+        verify = get_cert_bundle_path()
+
+    session.verify = verify
+
+    if headers:
+        session.headers.update(headers or {})
+
+    return session
+
+
+def create_auth_headers(
+    api_key: str, header_name: str = "Authorization"
+) -> Dict[str, str]:
+    return {header_name: f"Bearer {api_key}"}
+
+
+def resolve_env_var_in_header(headers: Dict[str, str]) -> Dict[str, str]:
+    resolved_headers = {}
+
+    for key, value in headers.items():
+        if isinstance(value, str):
+            try:
+                expanded = os.path.expandvars(value)
+                resolved_headers[key] = expanded
+            except Exception:
+                resolved_headers[key] = value
+        else:
+            resolved_headers[key] = value
+
+    return resolved_headers
+
+
+def create_reopenable_async_client(
+    timeout: int = 180,
+    verify: Union[bool, str] = None,
+    headers: Optional[Dict[str, str]] = None,
+    retry_status_codes: tuple = (429, 502, 503, 504),
+    model_name: str = "",
+) -> Union[ReopenableAsyncClient, httpx.AsyncClient]:
+    config = _resolve_proxy_config(verify)
+
+    base_kwargs = {
+        "proxy": config.proxy_url,
+        "verify": config.verify,
+        "headers": headers or {},
+        "timeout": timeout,
+        "http2": config.http2_enabled,
+        "trust_env": config.trust_env,
+    }
+
+    if ReopenableAsyncClient is not None:
+        client_class = (
+            RetryingAsyncClient if not config.disable_retry else httpx.AsyncClient
+        )
+        kwargs = {**base_kwargs, "client_class": client_class}
+        if not config.disable_retry:
+            kwargs["retry_status_codes"] = retry_status_codes
+            kwargs["model_name"] = model_name
+        return ReopenableAsyncClient(**kwargs)
+    else:
+        # Fallback to RetryingAsyncClient or plain AsyncClient
+        if not config.disable_retry:
+            return RetryingAsyncClient(
+                retry_status_codes=retry_status_codes,
+                model_name=model_name,
+                **base_kwargs,
+            )
+        else:
+            return httpx.AsyncClient(**base_kwargs)
+
+
+def is_cert_bundle_available() -> bool:
+    cert_path = get_cert_bundle_path()
+    if cert_path is None:
+        return False
+    return os.path.exists(cert_path) and os.path.isfile(cert_path)
+
+
+def find_available_port(start_port=8090, end_port=9010, host="127.0.0.1"):
+    for port in range(start_port, end_port + 1):
+        try:
+            # Try to bind to the port to check if it's available
+            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+                sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+                sock.bind((host, port))
+                return port
+        except OSError:
+            # Port is in use, try the next one
+            continue
+    return None