code-puppy 0.0.96__py3-none-any.whl → 0.0.118__py3-none-any.whl

code_puppy/messaging/spinner/textual_spinner.py

@@ -0,0 +1,97 @@
+"""
+Textual spinner implementation for TUI mode.
+"""
+
+from textual.widgets import Static
+
+from .spinner_base import SpinnerBase
+
+
+class TextualSpinner(Static):
+    """A textual spinner widget based on the SimpleSpinnerWidget."""
+
+    # Use the frames from SpinnerBase
+    FRAMES = SpinnerBase.FRAMES
+
+    def __init__(self, **kwargs):
+        """Initialize the textual spinner."""
+        super().__init__("", **kwargs)
+        self._frame_index = 0
+        self._is_spinning = False
+        self._timer = None
+        self._paused = False
+        self._previous_state = ""
+
+        # Register this spinner for global management
+        from . import register_spinner
+
+        register_spinner(self)
+
+    def start_spinning(self):
+        """Start the spinner animation using Textual's timer system."""
+        if not self._is_spinning:
+            self._is_spinning = True
+            self._frame_index = 0
+            self.update_frame_display()
+            # Start the animation timer using Textual's timer system
+            self._timer = self.set_interval(0.10, self.update_frame_display)
+
+    def stop_spinning(self):
+        """Stop the spinner animation."""
+        self._is_spinning = False
+        if self._timer:
+            self._timer.stop()
+            self._timer = None
+        self.update("")
+
+        # Unregister this spinner from global management
+        from . import unregister_spinner
+
+        unregister_spinner(self)
+
+    def update_frame(self):
+        """Update to the next frame."""
+        if self._is_spinning:
+            self._frame_index = (self._frame_index + 1) % len(self.FRAMES)
+
+    def update_frame_display(self):
+        """Update the display with the current frame."""
+        if self._is_spinning:
+            self.update_frame()
+            current_frame = self.FRAMES[self._frame_index]
+
+            # Check if we're awaiting user input to determine which message to show
+            from code_puppy.tools.command_runner import is_awaiting_user_input
+
+            if is_awaiting_user_input():
+                # Show waiting message when waiting for user input
+                message = SpinnerBase.WAITING_MESSAGE
+            else:
+                # Show thinking message during normal processing
+                message = SpinnerBase.THINKING_MESSAGE
+
+            self.update(
+                f"[bold cyan]{message}[/bold cyan][bold cyan]{current_frame}[/bold cyan]"
+            )
+
+    def pause(self):
+        """Pause the spinner animation temporarily."""
+        if self._is_spinning and self._timer and not self._paused:
+            self._paused = True
+            self._timer.pause()
+            # Store current state but don't clear it completely
+            self._previous_state = self.text
+            self.update("")
+
+    def resume(self):
+        """Resume a paused spinner animation."""
+        # Check if we should show a spinner - don't resume if waiting for user input
+        from code_puppy.tools.command_runner import is_awaiting_user_input
+
+        if is_awaiting_user_input():
+            return  # Don't resume if waiting for user input
+
+        if self._is_spinning and self._timer and self._paused:
+            self._paused = False
+            self._timer.resume()
+            self.update_frame_display()

code_puppy/model_factory.py

@@ -1,6 +1,7 @@
 import json
+import logging
 import os
-import random
+import pathlib
 from typing import Any, Dict
 
 import httpx
@@ -12,9 +13,10 @@ from pydantic_ai.models.openai import OpenAIModel
 from pydantic_ai.providers.anthropic import AnthropicProvider
 from pydantic_ai.providers.google_gla import GoogleGLAProvider
 from pydantic_ai.providers.openai import OpenAIProvider
-from pydantic_ai.providers.openrouter import OpenRouterProvider
 
-from code_puppy.tools.common import console
+from . import callbacks
+from .config import EXTRA_MODELS_FILE
+from .http_utils import create_async_client
 
 # Environment variables used in this module:
 # - GEMINI_API_KEY: API key for Google's Gemini models. Required when using Gemini models.
@@ -26,59 +28,6 @@ from code_puppy.tools.common import console
 #   Example: "X-Api-Key": "$OPENAI_API_KEY" will use the value from os.environ.get("OPENAI_API_KEY")
 
 
-def build_proxy_dict(proxy):
-    proxy_tokens = proxy.split(":")
-    structure = "{}:{}@{}:{}".format(
-        proxy_tokens[2], proxy_tokens[3], proxy_tokens[0], proxy_tokens[1]
-    )
-    proxies = {
-        "http": "http://{}/".format(structure),
-        "https": "http://{}".format(structure),
-    }
-    return proxies
-
-
-def build_httpx_proxy(proxy):
-    """Build an httpx.Proxy object from a proxy string in format ip:port:username:password"""
-    proxy_tokens = proxy.split(":")
-    if len(proxy_tokens) != 4:
-        raise ValueError(
-            f"Invalid proxy format: {proxy}. Expected format: ip:port:username:password"
-        )
-
-    ip, port, username, password = proxy_tokens
-    proxy_url = f"http://{ip}:{port}"
-    proxy_auth = (username, password)
-
-    # Log the proxy being used
-    console.log(f"Using proxy: {proxy_url} with username: {username}")
-
-    return httpx.Proxy(url=proxy_url, auth=proxy_auth)
-
-
-def get_random_proxy_from_file(file_path):
-    """Reads proxy file and returns a random proxy formatted for httpx.AsyncClient"""
-    if not os.path.exists(file_path):
-        raise ValueError(f"Proxy file '{file_path}' not found.")
-
-    with open(file_path, "r") as f:
-        proxies = [line.strip() for line in f.readlines() if line.strip()]
-
-    if not proxies:
-        raise ValueError(
-            f"Proxy file '{file_path}' is empty or contains only whitespace."
-        )
-
-    selected_proxy = random.choice(proxies)
-    try:
-        return build_httpx_proxy(selected_proxy)
-    except ValueError:
-        console.log(
-            f"Warning: Malformed proxy '{selected_proxy}' found in file '{file_path}', ignoring and continuing without proxy."
-        )
-        return None
-
-
 def get_custom_config(model_config):
     custom_config = model_config.get("custom_endpoint", {})
     if not custom_config:
@@ -91,32 +40,62 @@ def get_custom_config(model_config):
     headers = {}
     for key, value in custom_config.get("headers", {}).items():
         if value.startswith("$"):
-            value = os.environ.get(value[1:])
+            env_var_name = value[1:]
+            resolved_value = os.environ.get(env_var_name)
+            if resolved_value is None:
+                raise ValueError(
+                    f"Environment variable '{env_var_name}' is required for custom endpoint headers but is not set. "
+                    f"Please set the environment variable: export {env_var_name}=your_value"
+                )
+            value = resolved_value
         headers[key] = value
 
-    ca_certs_path = None
-    if "ca_certs_path" in custom_config:
-        ca_certs_path = custom_config.get("ca_certs_path")
-        if ca_certs_path.lower() == "false":
-            ca_certs_path = False
-
     api_key = None
     if "api_key" in custom_config:
         if custom_config["api_key"].startswith("$"):
-            api_key = os.environ.get(custom_config["api_key"][1:])
+            env_var_name = custom_config["api_key"][1:]
+            api_key = os.environ.get(env_var_name)
+            if api_key is None:
+                raise ValueError(
+                    f"Environment variable '{env_var_name}' is required for custom endpoint API key but is not set. "
+                    f"Please set the environment variable: export {env_var_name}=your_value"
+                )
         else:
             api_key = custom_config["api_key"]
-    return url, headers, ca_certs_path, api_key
+    if "ca_certs_path" in custom_config:
+        verify = custom_config["ca_certs_path"]
+    else:
+        verify = None
+    return url, headers, verify, api_key
 
 
 class ModelFactory:
     """A factory for creating and managing different AI models."""
 
     @staticmethod
-    def load_config(config_path: str) -> Dict[str, Any]:
-        """Loads model configurations from a JSON file."""
-        with open(config_path, "r") as f:
-            return json.load(f)
+    def load_config() -> Dict[str, Any]:
+        load_model_config_callbacks = callbacks.get_callbacks("load_model_config")
+        if len(load_model_config_callbacks) > 0:
+            if len(load_model_config_callbacks) > 1:
+                logging.getLogger(__name__).warning(
+                    "Multiple load_model_config callbacks registered, using the first"
+                )
+            config = callbacks.on_load_model_config()[0]
+        else:
+            from code_puppy.config import MODELS_FILE
+
+            if not pathlib.Path(MODELS_FILE).exists():
+                with open(pathlib.Path(__file__).parent / "models.json", "r") as src:
+                    with open(pathlib.Path(MODELS_FILE), "w") as target:
+                        target.write(src.read())
+
+            with open(MODELS_FILE, "r") as f:
+                config = json.load(f)
+        if pathlib.Path(EXTRA_MODELS_FILE).exists():
+            with open(EXTRA_MODELS_FILE, "r") as f:
+                extra_config = json.load(f)
+                config.update(extra_config)
+        return config
 
     @staticmethod
     def get_model(model_name: str, config: Dict[str, Any]) -> Any:
@@ -152,19 +131,8 @@ class ModelFactory:
             return AnthropicModel(model_name=model_config["name"], provider=provider)
 
         elif model_type == "custom_anthropic":
-            url, headers, ca_certs_path, api_key = get_custom_config(model_config)
-
-            # Check for proxy configuration
-            proxy_file_path = os.environ.get("CODE_PUPPY_PROXIES")
-            proxy = None
-            if proxy_file_path:
-                proxy = get_random_proxy_from_file(proxy_file_path)
-
-            # Only pass proxy to client if it's valid
-            client_args = {"headers": headers, "verify": ca_certs_path}
-            if proxy is not None:
-                client_args["proxy"] = proxy
-            client = httpx.AsyncClient(**client_args)
+            url, headers, verify, api_key = get_custom_config(model_config)
+            client = create_async_client(headers=headers, verify=verify)
             anthropic_client = AsyncAnthropic(
                 base_url=url,
                 http_client=client,
@@ -228,19 +196,8 @@ class ModelFactory:
             return model
 
         elif model_type == "custom_openai":
-            url, headers, ca_certs_path, api_key = get_custom_config(model_config)
-
-            # Check for proxy configuration
-            proxy_file_path = os.environ.get("CODE_PUPPY_PROXIES")
-            proxy = None
-            if proxy_file_path:
-                proxy = get_random_proxy_from_file(proxy_file_path)
-
-            # Only pass proxy to client if it's valid
-            client_args = {"headers": headers, "verify": ca_certs_path}
-            if proxy is not None:
-                client_args["proxy"] = proxy
-            client = httpx.AsyncClient(**client_args)
+            url, headers, verify, api_key = get_custom_config(model_config)
+            client = create_async_client(headers=headers, verify=verify)
             provider_args = dict(
                 base_url=url,
                 http_client=client,
@@ -252,16 +209,27 @@ class ModelFactory:
             model = OpenAIModel(model_name=model_config["name"], provider=provider)
             setattr(model, "provider", provider)
             return model
-        elif model_type == "openrouter":
-            api_key = None
-            if "api_key" in model_config:
-                if model_config["api_key"].startswith("$"):
-                    api_key = os.environ.get(model_config["api_key"][1:])
-                else:
-                    api_key = model_config["api_key"]
-            provider = OpenRouterProvider(api_key=api_key)
-            model_name = model_config.get("name")
-            model = OpenAIModel(model_name, provider=provider)
+
+        elif model_type == "custom_gemini":
+            url, headers, verify, api_key = get_custom_config(model_config)
+            os.environ["GEMINI_API_KEY"] = api_key
+
+            class CustomGoogleGLAProvider(GoogleGLAProvider):
+                def __init__(self, *args, **kwargs):
+                    super().__init__(*args, **kwargs)
+
+                @property
+                def base_url(self):
+                    return url
+
+                @property
+                def client(self) -> httpx.AsyncClient:
+                    _client = create_async_client(headers=headers, verify=verify)
+                    _client.base_url = self.base_url
+                    return _client
+
+            google_gla = CustomGoogleGLAProvider(api_key=api_key)
+            model = GeminiModel(model_name=model_config["name"], provider=google_gla)
             return model
         else:
             raise ValueError(f"Unsupported model type: {model_type}")

code_puppy/plugins/__init__.py

@@ -0,0 +1,32 @@
+import importlib
+import logging
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+
+def load_plugin_callbacks():
+    """Dynamically load register_callbacks.py from all plugin submodules."""
+    plugins_dir = Path(__file__).parent
+
+    # Iterate through all subdirectories in the plugins folder
+    for item in plugins_dir.iterdir():
+        if item.is_dir() and not item.name.startswith("_"):
+            plugin_name = item.name
+            callbacks_file = item / "register_callbacks.py"
+
+            if callbacks_file.exists():
+                try:
+                    # Import the register_callbacks module dynamically
+                    module_name = f"code_puppy.plugins.{plugin_name}.register_callbacks"
+                    logger.debug(f"Loading plugin callbacks from {module_name}")
+                    importlib.import_module(module_name)
+                    logger.info(
+                        f"Successfully loaded callbacks from plugin: {plugin_name}"
+                    )
+                except ImportError as e:
+                    logger.warning(
+                        f"Failed to import callbacks from plugin {plugin_name}: {e}"
+                    )
+                except Exception as e:
+                    logger.error(f"Unexpected error loading plugin {plugin_name}: {e}")

code_puppy/reopenable_async_client.py

@@ -0,0 +1,225 @@
+"""
+ReopenableAsyncClient - A reopenable httpx.AsyncClient wrapper.
+
+This module provides a ReopenableAsyncClient class that extends httpx.AsyncClient
+to support reopening after being closed, which the standard httpx.AsyncClient
+doesn't support.
+"""
+
+from typing import Optional, Union
+
+import httpx
+
+
+class ReopenableAsyncClient:
+    """
+    A wrapper around httpx.AsyncClient that can be reopened after being closed.
+
+    Standard httpx.AsyncClient becomes unusable after calling aclose().
+    This class allows you to reopen the client and continue using it.
+
+    Example:
+        >>> client = ReopenableAsyncClient(timeout=30.0)
+        >>> await client.get("https://httpbin.org/get")
+        >>> await client.aclose()
+        >>> # Client is now closed, but can be reopened
+        >>> await client.reopen()
+        >>> await client.get("https://httpbin.org/get")  # Works!
+
+    The client preserves all original configuration when reopening.
+    """
+
+    class _StreamWrapper:
+        """Async context manager wrapper for streaming responses."""
+
+        def __init__(
+            self,
+            parent_client: "ReopenableAsyncClient",
+            method: str,
+            url: Union[str, httpx.URL],
+            **kwargs,
+        ):
+            self.parent_client = parent_client
+            self.method = method
+            self.url = url
+            self.kwargs = kwargs
+            self._stream_context = None
+
+        async def __aenter__(self):
+            client = await self.parent_client._ensure_client_open()
+            self._stream_context = client.stream(self.method, self.url, **self.kwargs)
+            return await self._stream_context.__aenter__()
+
+        async def __aexit__(self, exc_type, exc_val, exc_tb):
+            if self._stream_context:
+                return await self._stream_context.__aexit__(exc_type, exc_val, exc_tb)
+
+    def __init__(self, **kwargs):
+        """
+        Initialize the ReopenableAsyncClient.
+
+        Args:
+            **kwargs: All arguments that would be passed to httpx.AsyncClient()
+        """
+        self._client_kwargs = kwargs.copy()
+        self._client: Optional[httpx.AsyncClient] = None
+        self._is_closed = True
+
+    async def _ensure_client_open(self) -> httpx.AsyncClient:
+        """
+        Ensure the underlying client is open and ready to use.
+
+        Returns:
+            The active httpx.AsyncClient instance
+
+        Raises:
+            RuntimeError: If client cannot be opened
+        """
+        if self._is_closed or self._client is None:
+            await self._create_client()
+        return self._client
+
+    async def _create_client(self) -> None:
+        """Create a new httpx.AsyncClient with the stored configuration."""
+        if self._client is not None and not self._is_closed:
+            # Close existing client first
+            await self._client.aclose()
+
+        self._client = httpx.AsyncClient(**self._client_kwargs)
+        self._is_closed = False
+
+    async def reopen(self) -> None:
+        """
+        Explicitly reopen the client after it has been closed.
+
+        This is useful when you want to reuse a client that was previously closed.
+        """
+        await self._create_client()
+
+    async def aclose(self) -> None:
+        """
+        Close the underlying httpx.AsyncClient.
+
+        After calling this, the client can be reopened using reopen() or
+        automatically when making the next request.
+        """
+        if self._client is not None and not self._is_closed:
+            await self._client.aclose()
+            self._is_closed = True
+
+    @property
+    def is_closed(self) -> bool:
+        """Check if the client is currently closed."""
+        return self._is_closed or self._client is None
+
+    # Delegate all httpx.AsyncClient methods to the underlying client
+
+    async def get(self, url: Union[str, httpx.URL], **kwargs) -> httpx.Response:
+        """Make a GET request."""
+        client = await self._ensure_client_open()
+        return await client.get(url, **kwargs)
+
+    async def post(self, url: Union[str, httpx.URL], **kwargs) -> httpx.Response:
+        """Make a POST request."""
+        client = await self._ensure_client_open()
+        return await client.post(url, **kwargs)
+
+    async def put(self, url: Union[str, httpx.URL], **kwargs) -> httpx.Response:
+        """Make a PUT request."""
+        client = await self._ensure_client_open()
+        return await client.put(url, **kwargs)
+
+    async def patch(self, url: Union[str, httpx.URL], **kwargs) -> httpx.Response:
+        """Make a PATCH request."""
+        client = await self._ensure_client_open()
+        return await client.patch(url, **kwargs)
+
+    async def delete(self, url: Union[str, httpx.URL], **kwargs) -> httpx.Response:
+        """Make a DELETE request."""
+        client = await self._ensure_client_open()
+        return await client.delete(url, **kwargs)
+
+    async def head(self, url: Union[str, httpx.URL], **kwargs) -> httpx.Response:
+        """Make a HEAD request."""
+        client = await self._ensure_client_open()
+        return await client.head(url, **kwargs)
+
+    async def options(self, url: Union[str, httpx.URL], **kwargs) -> httpx.Response:
+        """Make an OPTIONS request."""
+        client = await self._ensure_client_open()
+        return await client.options(url, **kwargs)
+
+    async def request(
+        self, method: str, url: Union[str, httpx.URL], **kwargs
+    ) -> httpx.Response:
+        """Make a request with the specified HTTP method."""
+        client = await self._ensure_client_open()
+        return await client.request(method, url, **kwargs)
+
+    async def send(self, request: httpx.Request, **kwargs) -> httpx.Response:
+        """Send a pre-built request."""
+        client = await self._ensure_client_open()
+        return await client.send(request, **kwargs)
+
+    def build_request(
+        self, method: str, url: Union[str, httpx.URL], **kwargs
+    ) -> httpx.Request:
+        """
+        Build a request without sending it.
+
+        Note: This creates a temporary client if none exists, but doesn't keep it open.
+        """
+        if self._client is None or self._is_closed:
+            # Create a temporary client just for building the request
+            temp_client = httpx.AsyncClient(**self._client_kwargs)
+            try:
+                request = temp_client.build_request(method, url, **kwargs)
+                return request
+            finally:
+                # Clean up the temporary client synchronously if possible
+                # Note: This might leave a connection open, but it's better than
+                # making this method async just for building requests
+                pass
+        return self._client.build_request(method, url, **kwargs)
+
+    def stream(self, method: str, url: Union[str, httpx.URL], **kwargs):
+        """Stream a request. Returns an async context manager."""
+        return self._StreamWrapper(self, method, url, **kwargs)
+
+    # Context manager support
+    async def __aenter__(self):
+        """Async context manager entry."""
+        await self._ensure_client_open()
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Async context manager exit."""
+        await self.aclose()
+
+    # Properties that don't require an active client
+    @property
+    def timeout(self) -> Optional[httpx.Timeout]:
+        """Get the configured timeout."""
+        return self._client_kwargs.get("timeout")
+
+    @property
+    def headers(self) -> httpx.Headers:
+        """Get the configured headers."""
+        if self._client is not None:
+            return self._client.headers
+        # Return headers from kwargs if client doesn't exist
+        headers = self._client_kwargs.get("headers", {})
+        return httpx.Headers(headers)
+
+    @property
+    def cookies(self) -> httpx.Cookies:
+        """Get the current cookies."""
+        if self._client is not None and not self._is_closed:
+            return self._client.cookies
+        # Return empty cookies if client doesn't exist or is closed
+        return httpx.Cookies()
+
+    def __repr__(self) -> str:
+        """String representation of the client."""
+        status = "closed" if self.is_closed else "open"
+        return f"<ReopenableAsyncClient [{status}]>"

code_puppy/state_management.py

@@ -1,8 +1,66 @@
 from typing import Any, List
 
-from code_puppy.message_history_processor import message_history_processor
-
 _message_history: List[Any] = []
+_compacted_message_hashes = set()
+_tui_mode: bool = False
+_tui_app_instance: Any = None
+
+
+def add_compacted_message_hash(message_hash: str) -> None:
+    """Add a message hash to the set of compacted message hashes."""
+    _compacted_message_hashes.add(message_hash)
+
+
+def get_compacted_message_hashes():
+    """Get the set of compacted message hashes."""
+    return _compacted_message_hashes
+
+
+def set_tui_mode(enabled: bool) -> None:
+    """Set the global TUI mode state.
+
+    Args:
+        enabled: True if running in TUI mode, False otherwise
+    """
+    global _tui_mode
+    _tui_mode = enabled
+
+
+def is_tui_mode() -> bool:
+    """Check if the application is running in TUI mode.
+
+    Returns:
+        True if running in TUI mode, False otherwise
+    """
+    return _tui_mode
+
+
+def set_tui_app_instance(app_instance: Any) -> None:
+    """Set the global TUI app instance reference.
+
+    Args:
+        app_instance: The TUI app instance
+    """
+    global _tui_app_instance
+    _tui_app_instance = app_instance
+
+
+def get_tui_app_instance() -> Any:
+    """Get the current TUI app instance.
+
+    Returns:
+        The TUI app instance if available, None otherwise
+    """
+    return _tui_app_instance
+
+
+def get_tui_mode() -> bool:
+    """Get the current TUI mode state.
+
+    Returns:
+        True if running in TUI mode, False otherwise
+    """
+    return _tui_mode
 
 
 def get_message_history() -> List[Any]:
@@ -37,22 +95,3 @@ def hash_message(message):
         else:
             hashable_entities.append(part.content)
     return hash(",".join(hashable_entities))
-
-
-def message_history_accumulator(messages: List[Any]):
-    global _message_history
-
-    message_history_hashes = set([hash_message(m) for m in _message_history])
-    for msg in messages:
-        if hash_message(msg) not in message_history_hashes:
-            _message_history.append(msg)
-
-    # Apply message history trimming using the main processor
-    # This ensures we maintain global state while still managing context limits
-    trimmed_messages = message_history_processor(_message_history)
-
-    # Update our global state with the trimmed version
-    # This preserves the state but keeps us within token limits
-    _message_history = trimmed_messages
-
-    return _message_history