code-puppy 0.0.379__tar.gz → 0.0.381__tar.gz

{code_puppy-0.0.379 → code_puppy-0.0.381}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-puppy
-Version: 0.0.379
+Version: 0.0.381
 Summary: Code generation agent
 Project-URL: repository, https://github.com/mpfaffenberger/code_puppy
 Project-URL: HomePage, https://github.com/mpfaffenberger/code_puppy

{code_puppy-0.0.379 → code_puppy-0.0.381}/code_puppy/agents/base_agent.py

@@ -3,8 +3,11 @@
 import asyncio
 import json
 import math
+import pathlib
 import signal
 import threading
+import time
+import traceback
 import uuid
 from abc import ABC, abstractmethod
 from typing import (
@@ -37,6 +40,7 @@ from pydantic_ai.durable_exec.dbos import DBOSAgent
 from pydantic_ai.messages import (
     ModelMessage,
     ModelRequest,
+    ModelResponse,
     TextPart,
     ThinkingPart,
     ToolCallPart,
@@ -88,6 +92,49 @@ _delayed_compaction_requested = False
 _reload_count = 0
 
 
+def _log_error_to_file(exc: Exception) -> Optional[str]:
+    """Log detailed error information to ~/.code_puppy/error_logs/log_{timestamp}.txt.
+
+    Args:
+        exc: The exception to log.
+
+    Returns:
+        The path to the log file if successful, None otherwise.
+    """
+    try:
+        error_logs_dir = pathlib.Path.home() / ".code_puppy" / "error_logs"
+        error_logs_dir.mkdir(parents=True, exist_ok=True)
+
+        timestamp = time.strftime("%Y%m%d_%H%M%S")
+        log_file = error_logs_dir / f"log_{timestamp}.txt"
+
+        with open(log_file, "w", encoding="utf-8") as f:
+            f.write(f"Timestamp: {time.strftime('%Y-%m-%d %H:%M:%S')}\n")
+            f.write(f"Exception Type: {type(exc).__name__}\n")
+            f.write(f"Exception Message: {str(exc)}\n")
+            f.write(f"Exception Args: {exc.args}\n")
+            f.write("\n--- Full Traceback ---\n")
+            f.write(traceback.format_exc())
+            f.write("\n--- Exception Chain ---\n")
+            # Walk the exception chain for chained exceptions
+            current = exc
+            chain_depth = 0
+            while current is not None and chain_depth < 10:
+                f.write(
+                    f"\n[Cause {chain_depth}] {type(current).__name__}: {current}\n"
+                )
+                f.write("".join(traceback.format_tb(current.__traceback__)))
+                current = (
+                    current.__cause__ if current.__cause__ else current.__context__
+                )
+                chain_depth += 1
+
+        return str(log_file)
+    except Exception:
+        # Don't let logging errors break the main flow
+        return None
+
+
 class BaseAgent(ABC):
     """Base class for all agent configurations."""
 
@@ -264,6 +311,33 @@ class BaseAgent(ABC):
             cleaned.append(message)
         return cleaned
 
+    def ensure_history_ends_with_request(
+        self, messages: List[ModelMessage]
+    ) -> List[ModelMessage]:
+        """Ensure message history ends with a ModelRequest.
+
+        pydantic_ai requires that processed message history ends with a ModelRequest.
+        This can fail when swapping models mid-conversation if the history ends with
+        a ModelResponse from the previous model.
+
+        This method trims trailing ModelResponse messages to ensure compatibility.
+
+        Args:
+            messages: List of messages to validate/fix.
+
+        Returns:
+            List of messages guaranteed to end with ModelRequest, or empty list
+            if no ModelRequest is found.
+        """
+        if not messages:
+            return messages
+
+        # Trim trailing ModelResponse messages
+        while messages and isinstance(messages[-1], ModelResponse):
+            messages = messages[:-1]
+
+        return messages
+
     # Message history processing methods (moved from state_management.py and message_history_processor.py)
     def _stringify_part(self, part: Any) -> str:
         """Create a stable string representation for a message part.
@@ -372,10 +446,10 @@ class BaseAgent(ABC):
 
     def estimate_token_count(self, text: str) -> int:
         """
-        Simple token estimation using len(message) / 3.
+        Simple token estimation using len(message) / 2.5.
         This replaces tiktoken with a much simpler approach.
         """
-        return max(1, math.floor((len(text) / 3)))
+        return max(1, math.floor((len(text) / 2.5)))
 
     def estimate_tokens_for_message(self, message: ModelMessage) -> int:
         """

{code_puppy-0.0.379 → code_puppy-0.0.381}/code_puppy/callbacks.py

@@ -13,6 +13,7 @@ PhaseType = Literal[
     "delete_file",
     "run_shell_command",
     "load_model_config",
+    "load_models_config",
     "load_prompt",
     "agent_reload",
     "custom_command",
@@ -27,6 +28,10 @@ PhaseType = Literal[
     "get_model_system_prompt",
     "agent_run_start",
     "agent_run_end",
+    "register_mcp_catalog_servers",
+    "register_browser_types",
+    "get_motd",
+    "register_model_providers",
 ]
 CallbackFunc = Callable[..., Any]
 
@@ -40,6 +45,7 @@ _callbacks: Dict[PhaseType, List[CallbackFunc]] = {
     "delete_file": [],
     "run_shell_command": [],
     "load_model_config": [],
+    "load_models_config": [],
     "load_prompt": [],
     "agent_reload": [],
     "custom_command": [],
@@ -54,6 +60,10 @@ _callbacks: Dict[PhaseType, List[CallbackFunc]] = {
     "get_model_system_prompt": [],
     "agent_run_start": [],
     "agent_run_end": [],
+    "register_mcp_catalog_servers": [],
+    "register_browser_types": [],
+    "get_motd": [],
+    "register_model_providers": [],
 }
 
 logger = logging.getLogger(__name__)
@@ -204,6 +214,19 @@ def on_load_model_config(*args, **kwargs) -> List[Any]:
     return _trigger_callbacks_sync("load_model_config", *args, **kwargs)
 
 
+def on_load_models_config() -> List[Any]:
+    """Trigger callbacks to load additional model configurations.
+
+    Plugins can register callbacks that return a dict of model configurations
+    to be merged with the built-in models.json. Plugin models override built-in
+    models with the same name.
+
+    Returns:
+        List of model config dicts from all registered callbacks.
+    """
+    return _trigger_callbacks_sync("load_models_config")
+
+
 def on_edit_file(*args, **kwargs) -> Any:
     return _trigger_callbacks_sync("edit_file", *args, **kwargs)
 
@@ -517,3 +540,64 @@ async def on_agent_run_end(
         response_text,
         metadata,
     )
+
+
+def on_register_mcp_catalog_servers() -> List[Any]:
+    """Trigger callbacks to register additional MCP catalog servers.
+
+    Plugins can register callbacks that return List[MCPServerTemplate] to add
+    servers to the MCP catalog/marketplace.
+
+    Returns:
+        List of results from all registered callbacks (each should be a list of MCPServerTemplate).
+    """
+    return _trigger_callbacks_sync("register_mcp_catalog_servers")
+
+
+def on_register_browser_types() -> List[Any]:
+    """Trigger callbacks to register custom browser types/providers.
+
+    Plugins can register callbacks that return a dict mapping browser type names
+    to initialization functions. This allows plugins to provide custom browser
+    implementations (like Camoufox for stealth browsing).
+
+    Each callback should return a dict with:
+    - key: str - the browser type name (e.g., "camoufox", "firefox-stealth")
+    - value: callable - async initialization function that takes (manager, **kwargs)
+                        and sets up the browser on the manager instance
+
+    Example callback:
+        def register_my_browser_types():
+            return {
+                "camoufox": initialize_camoufox,
+                "my-stealth-browser": initialize_my_stealth,
+            }
+
+    Returns:
+        List of dicts from all registered callbacks.
+    """
+    return _trigger_callbacks_sync("register_browser_types")
+
+
+def on_get_motd() -> List[Any]:
+    """Trigger callbacks to get custom MOTD content.
+
+    Plugins can register callbacks that return a tuple of (message, version).
+    The last non-None result will be used as the MOTD.
+
+    Returns:
+        List of (message, version) tuples from registered callbacks.
+    """
+    return _trigger_callbacks_sync("get_motd")
+
+
+def on_register_model_providers() -> List[Any]:
+    """Trigger callbacks to register custom model provider classes.
+
+    Plugins can register callbacks that return a dict mapping provider names
+    to model classes. Example: {"walmart_gemini": WalmartGeminiModel}
+
+    Returns:
+        List of dicts from all registered callbacks.
+    """
+    return _trigger_callbacks_sync("register_model_providers")

{code_puppy-0.0.379 → code_puppy-0.0.381}/code_puppy/cli_runner.py

@@ -551,7 +551,13 @@ async def interactive_mode(message_renderer, initial_command: str = None) -> Non
             reset_windows_terminal_full()
             from code_puppy.messaging import emit_warning
 
-            emit_warning("\nInput cancelled")
+            # Stop wiggum mode on Ctrl+C
+            from code_puppy.command_line.wiggum_state import is_wiggum_active, stop_wiggum
+            if is_wiggum_active():
+                stop_wiggum()
+                emit_warning("\n🍩 Wiggum loop stopped!")
+            else:
+                emit_warning("\nInput cancelled")
             continue
 
         # Check for exit commands (plain text or command form)
@@ -718,6 +724,12 @@ async def interactive_mode(message_renderer, initial_command: str = None) -> Non
                         ensure_ctrl_c_disabled()
                     except ImportError:
                         pass
+                    # Stop wiggum mode on cancellation
+                    from code_puppy.command_line.wiggum_state import is_wiggum_active, stop_wiggum
+                    if is_wiggum_active():
+                        stop_wiggum()
+                        from code_puppy.messaging import emit_warning
+                        emit_warning("🍩 Wiggum loop stopped due to cancellation")
                     continue
                 # Get the structured response
                 agent_response = result.output
@@ -758,6 +770,86 @@ async def interactive_mode(message_renderer, initial_command: str = None) -> Non
 
             auto_save_session_if_enabled()
 
+            # ================================================================
+            # WIGGUM LOOP: Re-run prompt if wiggum mode is active
+            # ================================================================
+            from code_puppy.command_line.wiggum_state import (
+                get_wiggum_prompt,
+                get_wiggum_count,
+                increment_wiggum_count,
+                is_wiggum_active,
+                stop_wiggum,
+            )
+
+            while is_wiggum_active():
+                wiggum_prompt = get_wiggum_prompt()
+                if not wiggum_prompt:
+                    stop_wiggum()
+                    break
+
+                # Increment and show debug message
+                loop_num = increment_wiggum_count()
+                from code_puppy.messaging import emit_warning, emit_system_message
+
+                emit_warning(f"\n🍩 WIGGUM RELOOPING! (Loop #{loop_num})")
+                emit_system_message(f"Re-running prompt: {wiggum_prompt}")
+
+                # Reset context/history for fresh start
+                new_session_id = finalize_autosave_session()
+                current_agent.clear_message_history()
+                emit_system_message(f"Context cleared. Session rotated to: {new_session_id}")
+
+                # Small delay to let user see the debug message
+                import time
+                time.sleep(0.5)
+
+                try:
+                    # Re-run the wiggum prompt
+                    result, current_agent_task = await run_prompt_with_attachments(
+                        current_agent,
+                        wiggum_prompt,
+                        spinner_console=message_renderer.console,
+                    )
+
+                    if result is None:
+                        # Cancelled - stop wiggum mode
+                        emit_warning("Wiggum loop cancelled by user")
+                        stop_wiggum()
+                        break
+
+                    # Get the structured response
+                    agent_response = result.output
+
+                    # Emit structured message for proper markdown rendering
+                    response_msg = AgentResponseMessage(
+                        content=agent_response,
+                        is_markdown=True,
+                    )
+                    get_message_bus().emit(response_msg)
+
+                    # Update message history
+                    if hasattr(result, "all_messages"):
+                        current_agent.set_message_history(list(result.all_messages()))
+
+                    # Flush console
+                    display_console.file.flush() if hasattr(
+                        display_console.file, "flush"
+                    ) else None
+                    time.sleep(0.1)
+
+                    # Auto-save
+                    auto_save_session_if_enabled()
+
+                except KeyboardInterrupt:
+                    emit_warning("\n🍩 Wiggum loop interrupted by Ctrl+C")
+                    stop_wiggum()
+                    break
+                except Exception as e:
+                    from code_puppy.messaging import emit_error
+                    emit_error(f"Wiggum loop error: {e}")
+                    stop_wiggum()
+                    break
+
             # Re-disable Ctrl+C if needed (uvx mode) - must be done after
             # each iteration as various operations may restore console mode
             try:

{code_puppy-0.0.379 → code_puppy-0.0.381}/code_puppy/command_line/core_commands.py

@@ -790,3 +790,64 @@ def handle_generate_pr_description_command(command: str) -> str:
 
     # Return the prompt to be processed by the main chat system
     return pr_prompt
+
+
+@register_command(
+    name="wiggum",
+    description="Loop mode: re-run the same prompt when agent finishes (like Wiggum chasing donuts 🍩)",
+    usage="/wiggum <prompt>",
+    category="core",
+)
+def handle_wiggum_command(command: str) -> str | bool:
+    """Start wiggum loop mode.
+
+    When active, the agent will automatically re-run the same prompt
+    after completing, resetting context each time. Use Ctrl+C to stop.
+
+    Example:
+        /wiggum say hello world
+    """
+    from code_puppy.command_line.wiggum_state import start_wiggum, stop_wiggum
+    from code_puppy.messaging import emit_info, emit_success, emit_warning
+
+    # Extract the prompt after /wiggum
+    parts = command.split(maxsplit=1)
+    if len(parts) < 2 or not parts[1].strip():
+        emit_warning("Usage: /wiggum <prompt>")
+        emit_info("Example: /wiggum say hello world")
+        emit_info("This will repeatedly run 'say hello world' after each completion.")
+        emit_info("Press Ctrl+C to stop the loop.")
+        return True
+
+    prompt = parts[1].strip()
+
+    # Start wiggum mode
+    start_wiggum(prompt)
+    emit_success(f"🍩 WIGGUM MODE ACTIVATED!")
+    emit_info(f"Prompt: {prompt}")
+    emit_info("The agent will re-loop this prompt after each completion.")
+    emit_info("Press Ctrl+C to stop the wiggum loop.")
+
+    # Return the prompt to execute immediately
+    return prompt
+
+
+@register_command(
+    name="wiggum_stop",
+    description="Stop wiggum loop mode",
+    usage="/wiggum_stop",
+    aliases=["stopwiggum", "ws"],
+    category="core",
+)
+def handle_wiggum_stop_command(command: str) -> bool:
+    """Stop wiggum loop mode."""
+    from code_puppy.command_line.wiggum_state import is_wiggum_active, stop_wiggum
+    from code_puppy.messaging import emit_info, emit_success
+
+    if is_wiggum_active():
+        stop_wiggum()
+        emit_success("🍩 Wiggum mode stopped!")
+    else:
+        emit_info("Wiggum mode is not active.")
+
+    return True

{code_puppy-0.0.379 → code_puppy-0.0.381}/code_puppy/command_line/motd.py

@@ -25,6 +25,28 @@ Reminder that Code Puppy supports three different OAuth subscriptions:
 MOTD_TRACK_FILE = os.path.join(CONFIG_DIR, "motd.txt")
 
 
+def get_motd_content() -> tuple[str, str]:
+    """Get MOTD content, checking plugins first.
+
+    Returns:
+        Tuple of (message, version) - either from plugin or built-in.
+    """
+    # Check if plugins want to override MOTD
+    try:
+        from code_puppy.callbacks import on_get_motd
+
+        results = on_get_motd()
+        # Use the last non-None result
+        for result in reversed(results):
+            if result is not None and isinstance(result, tuple) and len(result) == 2:
+                return result
+    except Exception:
+        pass
+
+    # Fall back to built-in MOTD
+    return (MOTD_MESSAGE, MOTD_VERSION)
+
+
 def has_seen_motd(version: str) -> bool:  # 🐕 Check if puppy has seen this MOTD!
     if not os.path.exists(MOTD_TRACK_FILE):
         return False
@@ -62,12 +84,13 @@ def print_motd(
     Returns:
         True if the MOTD was printed, False otherwise 🐾
     """
-    if force or not has_seen_motd(MOTD_VERSION):
+    message, version = get_motd_content()
+    if force or not has_seen_motd(version):
         # Create a Rich Markdown object for proper rendering 🎨🐶
         from rich.markdown import Markdown
 
-        markdown_content = Markdown(MOTD_MESSAGE)
+        markdown_content = Markdown(message)
         emit_info(markdown_content)
-        mark_motd_seen(MOTD_VERSION)
+        mark_motd_seen(version)
         return True
     return False

code_puppy-0.0.381/code_puppy/command_line/wiggum_state.py

@@ -0,0 +1,78 @@
+"""Wiggum loop state management.
+
+This module tracks the state for the /wiggum command, which causes
+the agent to automatically re-run the same prompt after completing,
+like Chief Wiggum chasing donuts in circles. 🍩
+
+Usage:
+    /wiggum <prompt>  - Start looping with the given prompt
+    Ctrl+C            - Stop the wiggum loop
+"""
+
+from dataclasses import dataclass, field
+from typing import Optional
+
+
+@dataclass
+class WiggumState:
+    """State container for wiggum loop mode."""
+
+    active: bool = False
+    prompt: Optional[str] = None
+    loop_count: int = 0
+
+    def start(self, prompt: str) -> None:
+        """Start wiggum mode with the given prompt."""
+        self.active = True
+        self.prompt = prompt
+        self.loop_count = 0
+
+    def stop(self) -> None:
+        """Stop wiggum mode."""
+        self.active = False
+        self.prompt = None
+        self.loop_count = 0
+
+    def increment(self) -> int:
+        """Increment and return the loop count."""
+        self.loop_count += 1
+        return self.loop_count
+
+
+# Global singleton for wiggum state
+_wiggum_state = WiggumState()
+
+
+def get_wiggum_state() -> WiggumState:
+    """Get the global wiggum state."""
+    return _wiggum_state
+
+
+def is_wiggum_active() -> bool:
+    """Check if wiggum mode is currently active."""
+    return _wiggum_state.active
+
+
+def get_wiggum_prompt() -> Optional[str]:
+    """Get the current wiggum prompt, if active."""
+    return _wiggum_state.prompt if _wiggum_state.active else None
+
+
+def start_wiggum(prompt: str) -> None:
+    """Start wiggum mode with the given prompt."""
+    _wiggum_state.start(prompt)
+
+
+def stop_wiggum() -> None:
+    """Stop wiggum mode."""
+    _wiggum_state.stop()
+
+
+def increment_wiggum_count() -> int:
+    """Increment wiggum loop count and return the new value."""
+    return _wiggum_state.increment()
+
+
+def get_wiggum_count() -> int:
+    """Get the current wiggum loop count."""
+    return _wiggum_state.loop_count

{code_puppy-0.0.379 → code_puppy-0.0.381}/code_puppy/config.py

@@ -144,6 +144,19 @@ def set_universal_constructor_enabled(enabled: bool) -> None:
     set_value("enable_universal_constructor", "true" if enabled else "false")
 
 
+def get_enable_streaming() -> bool:
+    """
+    Get the enable_streaming configuration value.
+    Controls whether streaming (SSE) is used for model responses.
+    Returns True if streaming is enabled, False otherwise.
+    Defaults to True.
+    """
+    val = get_value("enable_streaming")
+    if val is None:
+        return True  # Default to True for better UX
+    return str(val).lower() in ("1", "true", "yes", "on")
+
+
 DEFAULT_SECTION = "puppy"
 REQUIRED_KEYS = ["puppy_name", "owner_name"]
 
@@ -289,6 +302,8 @@ def get_config_keys():
     default_keys.append("enable_pack_agents")
     # Add universal constructor control key
     default_keys.append("enable_universal_constructor")
+    # Add streaming control key
+    default_keys.append("enable_streaming")
     # Add cancel agent key configuration
     default_keys.append("cancel_agent_key")
     # Add banner color keys

{code_puppy-0.0.379 → code_puppy-0.0.381}/code_puppy/mcp_/server_registry_catalog.py

@@ -1025,7 +1025,20 @@ class MCPServerCatalog:
     """Catalog for searching and managing pre-configured MCP servers."""
 
     def __init__(self):
-        self.servers = MCP_SERVER_REGISTRY
+        # Start with built-in servers
+        self.servers = list(MCP_SERVER_REGISTRY)
+
+        # Let plugins add their own catalog entries
+        try:
+            from code_puppy.callbacks import on_register_mcp_catalog_servers
+
+            plugin_results = on_register_mcp_catalog_servers()
+            for result in plugin_results:
+                if isinstance(result, list):
+                    self.servers.extend(result)
+        except Exception:
+            pass  # Don't break catalog if plugins fail
+
         self._build_index()
 
     def _build_index(self):

{code_puppy-0.0.379 → code_puppy-0.0.381}/code_puppy/model_factory.py

@@ -30,6 +30,26 @@ from .round_robin_model import RoundRobinModel
 
 logger = logging.getLogger(__name__)
 
+# Registry for custom model provider classes from plugins
+_CUSTOM_MODEL_PROVIDERS: Dict[str, type] = {}
+
+
+def _load_plugin_model_providers():
+    """Load custom model providers from plugins."""
+    global _CUSTOM_MODEL_PROVIDERS
+    try:
+        from code_puppy.callbacks import on_register_model_providers
+        results = on_register_model_providers()
+        for result in results:
+            if isinstance(result, dict):
+                _CUSTOM_MODEL_PROVIDERS.update(result)
+    except Exception:
+        pass  # Don't break if plugins fail
+
+
+# Load plugin model providers at module initialization
+_load_plugin_model_providers()
+
 
 def get_api_key(env_var_name: str) -> str | None:
     """Get an API key from config first, then fall back to environment variable.
@@ -279,6 +299,20 @@ class ModelFactory:
                 logging.getLogger(__name__).warning(
                     f"Failed to load {label} config from {source_path}: {exc}"
                 )
+
+        # Let plugins add/override models via load_models_config hook
+        try:
+            from code_puppy.callbacks import on_load_models_config
+
+            results = on_load_models_config()
+            for result in results:
+                if isinstance(result, dict):
+                    config.update(result)  # Plugin models override built-in
+        except Exception as exc:
+            logging.getLogger(__name__).debug(
+                f"Failed to load plugin models config: {exc}"
+            )
+
         return config
 
     @staticmethod
@@ -294,6 +328,15 @@ class ModelFactory:
 
         model_type = model_config.get("type")
 
+        # Check for plugin-registered model provider classes first
+        if model_type in _CUSTOM_MODEL_PROVIDERS:
+            provider_class = _CUSTOM_MODEL_PROVIDERS[model_type]
+            try:
+                return provider_class(model_name=model_name, model_config=model_config, config=config)
+            except Exception as e:
+                logger.error(f"Custom model provider '{model_type}' failed: {e}")
+                return None
+
         if model_type == "gemini":
             api_key = get_api_key("GEMINI_API_KEY")
             if not api_key: