code-puppy 0.0.325__py3-none-any.whl → 0.0.341__py3-none-any.whl

code_puppy/command_line/prompt_toolkit_completion.py

@@ -27,6 +27,10 @@ from code_puppy.command_line.attachments import (
     _detect_path_tokens,
     _tokenise,
 )
+from code_puppy.command_line.clipboard import (
+    capture_clipboard_image_to_pending,
+    has_image_in_clipboard,
+)
 from code_puppy.command_line.command_registry import get_unique_commands
 from code_puppy.command_line.file_path_completion import FilePathCompleter
 from code_puppy.command_line.load_context_completion import LoadContextCompleter
@@ -644,6 +648,120 @@ async def get_input_with_combined_completion(
         else:
             event.current_buffer.validate_and_handle()
 
+    # Handle bracketed paste (triggered by most terminal Cmd+V / Ctrl+V)
+    # This is the PRIMARY paste handler - works with Cmd+V on macOS terminals
+    @bindings.add(Keys.BracketedPaste)
+    def handle_bracketed_paste(event):
+        """Handle bracketed paste - works with Cmd+V on macOS terminals."""
+        # The pasted data is in event.data
+        pasted_data = event.data
+
+        # Check if clipboard has an image (the pasted text might just be empty or a file path)
+        try:
+            if has_image_in_clipboard():
+                placeholder = capture_clipboard_image_to_pending()
+                if placeholder:
+                    event.app.current_buffer.insert_text(placeholder + " ")
+                    # The placeholder itself is visible feedback - no need for extra output
+                    # Use bell for audible feedback (works in most terminals)
+                    event.app.output.bell()
+                    return  # Don't also paste the text data
+        except Exception:
+            pass
+
+        # No image - insert the pasted text as normal, sanitizing Windows newlines
+        if pasted_data:
+            # Normalize Windows line endings to Unix style
+            sanitized_data = pasted_data.replace("\r\n", "\n").replace("\r", "\n")
+            event.app.current_buffer.insert_text(sanitized_data)
+
+    # Fallback Ctrl+V for terminals without bracketed paste support
+    @bindings.add("c-v", eager=True)
+    def handle_smart_paste(event):
+        """Handle Ctrl+V - auto-detect image vs text in clipboard."""
+        try:
+            # Check for image first
+            if has_image_in_clipboard():
+                placeholder = capture_clipboard_image_to_pending()
+                if placeholder:
+                    event.app.current_buffer.insert_text(placeholder + " ")
+                    # The placeholder itself is visible feedback - no need for extra output
+                    # Use bell for audible feedback (works in most terminals)
+                    event.app.output.bell()
+                    return  # Don't also paste text
+        except Exception:
+            pass  # Fall through to text paste on any error
+
+        # No image (or error) - do normal text paste
+        # prompt_toolkit doesn't have built-in paste, so we handle it manually
+        try:
+            import platform
+            import subprocess
+
+            text = None
+            system = platform.system()
+
+            if system == "Darwin":  # macOS
+                result = subprocess.run(
+                    ["pbpaste"], capture_output=True, text=True, timeout=2
+                )
+                if result.returncode == 0:
+                    text = result.stdout
+            elif system == "Windows":
+                # Windows - use powershell
+                result = subprocess.run(
+                    ["powershell", "-command", "Get-Clipboard"],
+                    capture_output=True,
+                    text=True,
+                    timeout=2,
+                )
+                if result.returncode == 0:
+                    text = result.stdout
+            else:  # Linux
+                # Try xclip first, then xsel
+                for cmd in [
+                    ["xclip", "-selection", "clipboard", "-o"],
+                    ["xsel", "--clipboard", "--output"],
+                ]:
+                    try:
+                        result = subprocess.run(
+                            cmd, capture_output=True, text=True, timeout=2
+                        )
+                        if result.returncode == 0:
+                            text = result.stdout
+                            break
+                    except FileNotFoundError:
+                        continue
+
+            if text:
+                # Normalize Windows line endings to Unix style
+                text = text.replace("\r\n", "\n").replace("\r", "\n")
+                # Strip trailing newline that clipboard tools often add
+                text = text.rstrip("\n")
+                event.app.current_buffer.insert_text(text)
+        except Exception:
+            pass  # Silently fail if text paste doesn't work
+
+    # F3 - dedicated image paste (shows error if no image)
+    @bindings.add("f3")
+    def handle_image_paste_f3(event):
+        """Handle F3 - paste image from clipboard (image-only, shows error if none)."""
+        try:
+            if has_image_in_clipboard():
+                placeholder = capture_clipboard_image_to_pending()
+                if placeholder:
+                    event.app.current_buffer.insert_text(placeholder + " ")
+                    # The placeholder itself is visible feedback
+                    # Use bell for audible feedback (works in most terminals)
+                    event.app.output.bell()
+            else:
+                # Insert a transient message that user can delete
+                event.app.current_buffer.insert_text("[⚠️ no image in clipboard] ")
+                event.app.output.bell()
+        except Exception:
+            event.app.current_buffer.insert_text("[❌ clipboard error] ")
+            event.app.output.bell()
+
     session = PromptSession(
         completer=completer,
         history=history,

code_puppy/config.py

@@ -53,6 +53,7 @@ _DEFAULT_SQLITE_FILE = os.path.join(DATA_DIR, "dbos_store.sqlite")
 GEMINI_MODELS_FILE = os.path.join(DATA_DIR, "gemini_models.json")
 CHATGPT_MODELS_FILE = os.path.join(DATA_DIR, "chatgpt_models.json")
 CLAUDE_MODELS_FILE = os.path.join(DATA_DIR, "claude_models.json")
+ANTIGRAVITY_MODELS_FILE = os.path.join(DATA_DIR, "antigravity_models.json")
 
 # Cache files (XDG_CACHE_HOME)
 AUTOSAVE_DIR = os.path.join(CACHE_DIR, "autosaves")
@@ -1051,11 +1052,11 @@ def set_enable_dbos(enabled: bool) -> None:
     set_config_value("enable_dbos", "true" if enabled else "false")
 
 
-def get_message_limit(default: int = 100) -> int:
+def get_message_limit(default: int = 1000) -> int:
     """
     Returns the user-configured message/request limit for the agent.
     This controls how many steps/requests the agent can take.
-    Defaults to 100 if unset or misconfigured.
+    Defaults to 1000 if unset or misconfigured.
     Configurable by 'message_limit' key.
     """
     val = get_value("message_limit")

code_puppy/http_utils.py

@@ -4,29 +4,81 @@ HTTP utilities module for code-puppy.
 This module provides functions for creating properly configured HTTP clients.
 """
 
+import asyncio
 import os
 import socket
-from typing import Dict, Optional, Union
+import time
+from dataclasses import dataclass
+from typing import Any, Dict, Optional, Union
 
 import httpx
 import requests
-from tenacity import stop_after_attempt, wait_exponential
 
 from code_puppy.config import get_http2
 
-try:
-    from pydantic_ai.retries import (
-        AsyncTenacityTransport,
-        RetryConfig,
-        TenacityTransport,
-        wait_retry_after,
+
+@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")
     )
-except ImportError:
-    # Fallback if pydantic_ai.retries is not available
-    AsyncTenacityTransport = None
-    RetryConfig = None
-    TenacityTransport = None
-    wait_retry_after = None
+
+    # 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
@@ -34,14 +86,104 @@ except ImportError:
     ReopenableAsyncClient = None
 
 try:
-    from .messaging import emit_info
+    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
 
-def get_cert_bundle_path() -> str:
+
+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).
+    """
+
+    def __init__(
+        self,
+        retry_status_codes: tuple = (429, 502, 503, 504),
+        max_retries: int = 5,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        self.retry_status_codes = retry_status_codes
+        self.max_retries = max_retries
+
+    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
+                wait_time = 1.0 * (
+                    2**attempt
+                )  # Default exponential backoff: 1s, 2s, 4s...
+
+                # Check Retry-After header
+                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:
+                    emit_info(
+                        f"HTTP retry: {response.status_code} received. 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):
@@ -60,53 +202,15 @@ def create_client(
     # Check if HTTP/2 is enabled in config
     http2_enabled = get_http2()
 
-    # Check if custom retry transport should be disabled (e.g., for integration tests with proxies)
-    disable_retry_transport = os.environ.get(
-        "CODE_PUPPY_DISABLE_RETRY_TRANSPORT", ""
-    ).lower() in ("1", "true", "yes")
-
     # If retry components are available, create a client with retry transport
-    if (
-        TenacityTransport
-        and RetryConfig
-        and wait_retry_after
-        and not disable_retry_transport
-    ):
-
-        def should_retry_status(response):
-            """Raise exceptions for retryable HTTP status codes."""
-            if response.status_code in retry_status_codes:
-                emit_info(
-                    f"HTTP retry: Retrying request due to status code {response.status_code}"
-                )
-                return True
-
-        transport = TenacityTransport(
-            config=RetryConfig(
-                retry=lambda e: isinstance(e, httpx.HTTPStatusError)
-                and e.response.status_code in retry_status_codes,
-                wait=wait_retry_after(
-                    fallback_strategy=wait_exponential(multiplier=1, max=60),
-                    max_wait=300,
-                ),
-                stop=stop_after_attempt(10),
-                reraise=True,
-            ),
-            validate_response=should_retry_status,
-        )
-
-        return httpx.Client(
-            transport=transport,
-            verify=verify,
-            headers=headers or {},
-            timeout=timeout,
-            http2=http2_enabled,
-        )
-    else:
-        # Fallback to regular client if retry components are not available
-        return httpx.Client(
-            verify=verify, headers=headers or {}, timeout=timeout, http2=http2_enabled
-        )
+    # 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(
@@ -115,109 +219,26 @@ def create_async_client(
     headers: Optional[Dict[str, str]] = None,
     retry_status_codes: tuple = (429, 502, 503, 504),
 ) -> httpx.AsyncClient:
-    if verify is None:
-        verify = get_cert_bundle_path()
-
-    # Check if HTTP/2 is enabled in config
-    http2_enabled = get_http2()
+    config = _resolve_proxy_config(verify)
 
-    # Check if custom retry transport should be disabled (e.g., for integration tests with proxies)
-    disable_retry_transport = os.environ.get(
-        "CODE_PUPPY_DISABLE_RETRY_TRANSPORT", ""
-    ).lower() in ("1", "true", "yes")
-
-    # Check if proxy environment variables are set
-    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")
-    )
-
-    # When retry transport is disabled (test mode), disable SSL verification
-    # for proxy testing. For production proxies, SSL should still be verified!
-    if disable_retry_transport:
-        verify = False
-        trust_env = True
-    elif has_proxy:
-        # Production proxy detected - keep SSL verification enabled for security
-        trust_env = True
-    else:
-        trust_env = False
-
-    # If retry components are available, create a client with retry transport
-    # BUT: disable retry transport when proxies are detected because custom transports
-    # don't play nicely with proxy configuration
-    if (
-        AsyncTenacityTransport
-        and RetryConfig
-        and wait_retry_after
-        and not disable_retry_transport
-        and not has_proxy
-    ):
-
-        def should_retry_status(response):
-            """Raise exceptions for retryable HTTP status codes."""
-            if response.status_code in retry_status_codes:
-                emit_info(
-                    f"HTTP retry: Retrying request due to status code {response.status_code}"
-                )
-                return True
-
-        # Create transport (with or without proxy base)
-        if has_proxy:
-            # Extract proxy URL from environment
-            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")
-            )
-        else:
-            proxy_url = None
-
-        # Create retry transport wrapper
-        transport = AsyncTenacityTransport(
-            config=RetryConfig(
-                retry=lambda e: isinstance(e, httpx.HTTPStatusError)
-                and e.response.status_code in retry_status_codes,
-                wait=wait_retry_after(10),
-                stop=stop_after_attempt(10),
-                reraise=True,
-            ),
-            validate_response=should_retry_status,
-        )
-
-        return httpx.AsyncClient(
-            transport=transport,
-            proxy=proxy_url,  # Pass proxy to client, not transport
-            verify=verify,
+    if not config.disable_retry:
+        return RetryingAsyncClient(
+            retry_status_codes=retry_status_codes,
+            proxy=config.proxy_url,
+            verify=config.verify,
             headers=headers or {},
             timeout=timeout,
-            http2=http2_enabled,
-            trust_env=trust_env,
+            http2=config.http2_enabled,
+            trust_env=config.trust_env,
         )
     else:
-        # Fallback to regular client if retry components are not available,
-        # when retry transport is explicitly disabled, or when proxies are detected
-        # Extract proxy URL if needed
-        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")
-            )
-        else:
-            proxy_url = None
-
         return httpx.AsyncClient(
-            proxy=proxy_url,
-            verify=verify,
+            proxy=config.proxy_url,
+            verify=config.verify,
             headers=headers or {},
             timeout=timeout,
-            http2=http2_enabled,
-            trust_env=trust_env,
+            http2=config.http2_enabled,
+            trust_env=config.trust_env,
         )
 
 
@@ -267,132 +288,33 @@ def create_reopenable_async_client(
     headers: Optional[Dict[str, str]] = None,
     retry_status_codes: tuple = (429, 502, 503, 504),
 ) -> Union[ReopenableAsyncClient, httpx.AsyncClient]:
-    if verify is None:
-        verify = get_cert_bundle_path()
-
-    # Check if HTTP/2 is enabled in config
-    http2_enabled = get_http2()
-
-    # Check if custom retry transport should be disabled (e.g., for integration tests with proxies)
-    disable_retry_transport = os.environ.get(
-        "CODE_PUPPY_DISABLE_RETRY_TRANSPORT", ""
-    ).lower() in ("1", "true", "yes")
-
-    # Check if proxy environment variables are set
-    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")
-    )
-
-    # When retry transport is disabled (test mode), disable SSL verification
-    if disable_retry_transport:
-        verify = False
-        trust_env = True
-    elif has_proxy:
-        trust_env = True
-    else:
-        trust_env = False
-
-    # If retry components are available, create a client with retry transport
-    # BUT: disable retry transport when proxies are detected because custom transports
-    # don't play nicely with proxy configuration
-    if (
-        AsyncTenacityTransport
-        and RetryConfig
-        and wait_retry_after
-        and not disable_retry_transport
-        and not has_proxy
-    ):
-
-        def should_retry_status(response):
-            """Raise exceptions for retryable HTTP status codes."""
-            if response.status_code in retry_status_codes:
-                emit_info(
-                    f"HTTP retry: Retrying request due to status code {response.status_code}"
-                )
-                return True
-
-        transport = AsyncTenacityTransport(
-            config=RetryConfig(
-                retry=lambda e: isinstance(e, httpx.HTTPStatusError)
-                and e.response.status_code in retry_status_codes,
-                wait=wait_retry_after(
-                    fallback_strategy=wait_exponential(multiplier=1, max=60),
-                    max_wait=300,
-                ),
-                stop=stop_after_attempt(10),
-                reraise=True,
-            ),
-            validate_response=should_retry_status,
+    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
         )
-
-        # Extract proxy URL if needed
-        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")
-            )
-        else:
-            proxy_url = None
-
-        if ReopenableAsyncClient is not None:
-            return ReopenableAsyncClient(
-                transport=transport,
-                proxy=proxy_url,
-                verify=verify,
-                headers=headers or {},
-                timeout=timeout,
-                http2=http2_enabled,
-                trust_env=trust_env,
-            )
-        else:
-            # Fallback to regular AsyncClient if ReopenableAsyncClient is not available
-            return httpx.AsyncClient(
-                transport=transport,
-                proxy=proxy_url,
-                verify=verify,
-                headers=headers or {},
-                timeout=timeout,
-                http2=http2_enabled,
-                trust_env=trust_env,
-            )
+        kwargs = {**base_kwargs, "client_class": client_class}
+        if not config.disable_retry:
+            kwargs["retry_status_codes"] = retry_status_codes
+        return ReopenableAsyncClient(**kwargs)
     else:
-        # Fallback to regular clients if retry components are not available
-        # or when proxies are detected
-        # Extract proxy URL if needed
-        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")
+        # Fallback to RetryingAsyncClient or plain AsyncClient
+        if not config.disable_retry:
+            return RetryingAsyncClient(
+                retry_status_codes=retry_status_codes, **base_kwargs
             )
         else:
-            proxy_url = None
-
-        if ReopenableAsyncClient is not None:
-            return ReopenableAsyncClient(
-                proxy=proxy_url,
-                verify=verify,
-                headers=headers or {},
-                timeout=timeout,
-                http2=http2_enabled,
-                trust_env=trust_env,
-            )
-        else:
-            # Fallback to regular AsyncClient if ReopenableAsyncClient is not available
-            return httpx.AsyncClient(
-                proxy=proxy_url,
-                verify=verify,
-                headers=headers or {},
-                timeout=timeout,
-                http2=http2_enabled,
-                trust_env=trust_env,
-            )
+            return httpx.AsyncClient(**base_kwargs)
 
 
 def is_cert_bundle_available() -> bool: