code-puppy 0.0.380__tar.gz → 0.0.382__tar.gz

{code_puppy-0.0.380 → code_puppy-0.0.382}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-puppy
-Version: 0.0.380
+Version: 0.0.382
 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.380 → code_puppy-0.0.382}/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",
@@ -28,6 +29,9 @@ PhaseType = Literal[
     "agent_run_start",
     "agent_run_end",
     "register_mcp_catalog_servers",
+    "register_browser_types",
+    "get_motd",
+    "register_model_providers",
 ]
 CallbackFunc = Callable[..., Any]
 
@@ -41,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": [],
@@ -56,6 +61,9 @@ _callbacks: Dict[PhaseType, List[CallbackFunc]] = {
     "agent_run_start": [],
     "agent_run_end": [],
     "register_mcp_catalog_servers": [],
+    "register_browser_types": [],
+    "get_motd": [],
+    "register_model_providers": [],
 }
 
 logger = logging.getLogger(__name__)
@@ -206,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)
 
@@ -531,3 +552,52 @@ def on_register_mcp_catalog_servers() -> List[Any]:
         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.380 → code_puppy-0.0.382}/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.380 → code_puppy-0.0.382}/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.380 → code_puppy-0.0.382}/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.382/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.380 → code_puppy-0.0.382}/code_puppy/config.py

@@ -715,8 +715,9 @@ def set_model_setting(model_name: str, setting: str, value: Optional[float]) ->
     if value is None:
         set_config_value(key, "")
     elif isinstance(value, float):
-        # Round floats to nearest tenth to avoid floating point weirdness
-        set_config_value(key, str(round(value, 1)))
+        # Round floats to nearest hundredth to avoid floating point weirdness
+        # (allows 0.05 step increments for temperature/top_p)
+        set_config_value(key, str(round(value, 2)))
     else:
         set_config_value(key, str(value))
 

{code_puppy-0.0.380 → code_puppy-0.0.382}/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:

{code_puppy-0.0.380 → code_puppy-0.0.382}/code_puppy/tools/browser/browser_manager.py

@@ -8,13 +8,41 @@ import atexit
 import contextvars
 import os
 from pathlib import Path
-from typing import Optional
+from typing import Callable, Dict, Optional
 
 from playwright.async_api import Browser, BrowserContext, Page
 
 from code_puppy import config
 from code_puppy.messaging import emit_info, emit_success, emit_warning
 
+# Registry for custom browser types from plugins (e.g., Camoufox for stealth browsing)
+_CUSTOM_BROWSER_TYPES: Dict[str, Callable] = {}
+_BROWSER_TYPES_LOADED: bool = False
+
+
+def _load_plugin_browser_types() -> None:
+    """Load custom browser types from plugins.
+
+    This is called lazily on first browser initialization to allow plugins
+    to register custom browser providers (like Camoufox for stealth browsing).
+    """
+    global _CUSTOM_BROWSER_TYPES, _BROWSER_TYPES_LOADED
+
+    if _BROWSER_TYPES_LOADED:
+        return
+
+    _BROWSER_TYPES_LOADED = True
+
+    try:
+        from code_puppy.callbacks import on_register_browser_types
+
+        results = on_register_browser_types()
+        for result in results:
+            if isinstance(result, dict):
+                _CUSTOM_BROWSER_TYPES.update(result)
+    except Exception:
+        pass  # Don't break if plugins fail to load
+
 # Store active manager instances by session ID
 _active_managers: dict[str, "BrowserManager"] = {}
 
@@ -78,14 +106,19 @@ class BrowserManager:
     _context: Optional[BrowserContext] = None
     _initialized: bool = False
 
-    def __init__(self, session_id: Optional[str] = None):
+    def __init__(
+        self, session_id: Optional[str] = None, browser_type: Optional[str] = None
+    ):
         """Initialize manager settings.
 
         Args:
             session_id: Optional session ID for this instance.
                 If None, uses 'default' as the session ID.
+            browser_type: Optional browser type to use. If None, uses Chromium.
+                Custom types can be registered via the register_browser_types hook.
         """
         self.session_id = session_id or "default"
+        self.browser_type = browser_type  # None means default Chromium
 
         # Default to headless=True (no browser spam during tests)
         # Override with BROWSER_HEADLESS=false to see the browser
@@ -124,7 +157,27 @@ class BrowserManager:
             raise
 
     async def _initialize_browser(self) -> None:
-        """Initialize Playwright Chromium browser with persistent context."""
+        """Initialize browser with persistent context.
+
+        Checks for custom browser types registered via plugins first,
+        then falls back to default Playwright Chromium.
+        """
+        # Load plugin browser types on first initialization
+        _load_plugin_browser_types()
+
+        # Check if a custom browser type was requested and is available
+        if self.browser_type and self.browser_type in _CUSTOM_BROWSER_TYPES:
+            emit_info(
+                f"Using custom browser type '{self.browser_type}' "
+                f"(session: {self.session_id})"
+            )
+            init_func = _CUSTOM_BROWSER_TYPES[self.browser_type]
+            # Custom init functions should set self._context and self._browser
+            await init_func(self)
+            self._initialized = True
+            return
+
+        # Default: use Playwright Chromium
         from playwright.async_api import async_playwright
 
         emit_info(f"Using persistent profile: {self.profile_dir}")
@@ -220,13 +273,18 @@ class BrowserManager:
         emit_info(f"Browser closed (session: {self.session_id})")
 
 
-def get_browser_manager(session_id: Optional[str] = None) -> BrowserManager:
+def get_browser_manager(
+    session_id: Optional[str] = None, browser_type: Optional[str] = None
+) -> BrowserManager:
     """Get or create a BrowserManager instance.
 
     Args:
         session_id: Optional session ID. If provided and a manager with this
             session exists, returns that manager. Otherwise creates a new one.
             If None, uses 'default' as the session ID.
+        browser_type: Optional browser type to use for new managers.
+            Ignored if a manager for this session already exists.
+            Custom types can be registered via the register_browser_types hook.
 
     Returns:
         A BrowserManager instance.
@@ -237,11 +295,14 @@ def get_browser_manager(session_id: Optional[str] = None) -> BrowserManager:
 
         # Named session (for multi-agent use)
         manager = get_browser_manager("qa-agent-1")
+
+        # Custom browser type (e.g., stealth browser from plugin)
+        manager = get_browser_manager("stealth-session", browser_type="camoufox")
     """
     session_id = session_id or "default"
 
     if session_id not in _active_managers:
-        _active_managers[session_id] = BrowserManager(session_id)
+        _active_managers[session_id] = BrowserManager(session_id, browser_type)
 
     return _active_managers[session_id]
 

{code_puppy-0.0.380 → code_puppy-0.0.382}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "code-puppy"
-version = "0.0.380"
+version = "0.0.382"
 description = "Code generation agent"
 readme = "README.md"
 requires-python = ">=3.11,<3.14"

code_puppy-0.0.380/code_puppy/plugins/ralph/__init__.py

@@ -1,13 +0,0 @@
-"""Ralph Plugin - Autonomous AI agent loop for completing PRDs.
-
-Based on Geoffrey Huntley's Ralph pattern: https://ghuntley.com/ralph/
-
-This plugin provides:
-- PRD Generator agent for creating detailed requirements
-- Ralph Converter agent for converting PRDs to JSON format
-- Ralph Orchestrator agent for autonomous execution
-- Tools for managing prd.json and progress.txt
-- /ralph commands for controlling the workflow
-"""
-
-__version__ = "0.1.0"