code-puppy 0.0.173__py3-none-any.whl → 0.0.175__py3-none-any.whl

code_puppy/agents/runtime_manager.py

@@ -1,272 +0,0 @@
-"""
-Runtime agent manager that ensures proper agent instance updates.
-
-This module provides a wrapper around the agent singleton that ensures
-all references to the agent are properly updated when it's reloaded.
-"""
-
-import asyncio
-import signal
-import sys
-import uuid
-from typing import Any, Optional
-
-# ExceptionGroup is available in Python 3.11+
-if sys.version_info >= (3, 11):
-    from builtins import ExceptionGroup
-else:
-    # For Python 3.10 and below, we can define a simple fallback
-    class ExceptionGroup(Exception):
-        def __init__(self, message, exceptions):
-            super().__init__(message)
-            self.exceptions = exceptions
-
-
-import mcp
-from pydantic_ai import Agent
-from pydantic_ai.exceptions import UsageLimitExceeded
-from pydantic_ai.usage import UsageLimits
-
-from code_puppy.messaging.message_queue import emit_info
-
-
-class RuntimeAgentManager:
-    """
-    Manages the runtime agent instance and ensures proper updates.
-
-    This class acts as a proxy that always returns the current agent instance,
-    ensuring that when the agent is reloaded, all code using this manager
-    automatically gets the updated instance.
-    """
-
-    def __init__(self):
-        """Initialize the runtime agent manager."""
-        self._agent: Optional[Agent] = None
-        self._last_model_name: Optional[str] = None
-
-    def get_agent(self, force_reload: bool = False, message_group: str = "") -> Agent:
-        """
-        Get the current agent instance.
-
-        This method always returns the most recent agent instance,
-        automatically handling reloads when the model changes.
-
-        Args:
-            force_reload: If True, force a reload of the agent
-
-        Returns:
-            The current agent instance
-        """
-        from code_puppy.agent import get_code_generation_agent
-
-        # Always get the current singleton - this ensures we have the latest
-        current_agent = get_code_generation_agent(
-            force_reload=force_reload, message_group=message_group
-        )
-        self._agent = current_agent
-
-        return self._agent
-
-    def reload_agent(self) -> Agent:
-        """
-        Force reload the agent.
-
-        This is typically called after MCP servers are started/stopped.
-
-        Returns:
-            The newly loaded agent instance
-        """
-        message_group = uuid.uuid4()
-        emit_info(
-            "[bold cyan]Reloading agent with updated configuration...[/bold cyan]",
-            message_group=message_group,
-        )
-        return self.get_agent(force_reload=True, message_group=message_group)
-
-    async def run_with_mcp(
-        self, prompt: str, usage_limits: Optional[UsageLimits] = None, **kwargs
-    ) -> Any:
-        """
-        Run the agent with MCP servers and full cancellation support.
-
-        This method ensures we're always using the current agent instance
-        and handles Ctrl+C interruption properly by creating a cancellable task.
-
-        Args:
-            prompt: The user prompt to process
-            usage_limits: Optional usage limits for the agent
-            **kwargs: Additional arguments to pass to agent.run (e.g., message_history)
-
-        Returns:
-            The agent's response
-
-        Raises:
-            asyncio.CancelledError: When execution is cancelled by user
-        """
-        agent = self.get_agent()
-        group_id = str(uuid.uuid4())
-
-        # Function to run agent with MCP
-        async def run_agent_task():
-            try:
-                async with agent:
-                    return await agent.run(prompt, usage_limits=usage_limits, **kwargs)
-            except* UsageLimitExceeded as ule:
-                emit_info(f"Usage limit exceeded: {str(ule)}", group_id=group_id)
-                emit_info(
-                    "The agent has reached its usage limit. You can ask it to continue by saying 'please continue' or similar.",
-                    group_id=group_id,
-                )
-            except* mcp.shared.exceptions.McpError as mcp_error:
-                emit_info(f"MCP server error: {str(mcp_error)}", group_id=group_id)
-                emit_info(f"{str(mcp_error)}", group_id=group_id)
-                emit_info(
-                    "Try disabling any malfunctioning MCP servers", group_id=group_id
-                )
-            except* asyncio.exceptions.CancelledError:
-                emit_info("Cancelled")
-            except* InterruptedError as ie:
-                emit_info(f"Interrupted: {str(ie)}")
-            except* Exception as other_error:
-                # Filter out CancelledError and UsageLimitExceeded from the exception group - let it propagate
-                remaining_exceptions = []
-
-                def collect_non_cancelled_exceptions(exc):
-                    if isinstance(exc, ExceptionGroup):
-                        for sub_exc in exc.exceptions:
-                            collect_non_cancelled_exceptions(sub_exc)
-                    elif not isinstance(
-                        exc, (asyncio.CancelledError, UsageLimitExceeded)
-                    ):
-                        remaining_exceptions.append(exc)
-                        emit_info(f"Unexpected error: {str(exc)}", group_id=group_id)
-                        emit_info(f"{str(exc.args)}", group_id=group_id)
-
-                collect_non_cancelled_exceptions(other_error)
-
-                # If there are CancelledError exceptions in the group, re-raise them
-                cancelled_exceptions = []
-
-                def collect_cancelled_exceptions(exc):
-                    if isinstance(exc, ExceptionGroup):
-                        for sub_exc in exc.exceptions:
-                            collect_cancelled_exceptions(sub_exc)
-                    elif isinstance(exc, asyncio.CancelledError):
-                        cancelled_exceptions.append(exc)
-
-                collect_cancelled_exceptions(other_error)
-
-                if cancelled_exceptions:
-                    # Re-raise the first CancelledError to propagate cancellation
-                    raise cancelled_exceptions[0]
-
-        # Create the task FIRST
-        agent_task = asyncio.create_task(run_agent_task())
-
-        # Import shell process killer
-        from code_puppy.tools.command_runner import kill_all_running_shell_processes
-
-        # Ensure the interrupt handler only acts once per task
-        def keyboard_interrupt_handler(sig, frame):
-            """Signal handler for Ctrl+C - replicating exact original logic"""
-
-            # First, nuke any running shell processes triggered by tools
-            try:
-                killed = kill_all_running_shell_processes()
-                if killed:
-                    emit_info(f"Cancelled {killed} running shell process(es).")
-                else:
-                    # Only cancel the agent task if no shell processes were killed
-                    if not agent_task.done():
-                        agent_task.cancel()
-            except Exception as e:
-                emit_info(f"Shell kill error: {e}")
-                # If shell kill failed, still try to cancel the agent task
-                if not agent_task.done():
-                    agent_task.cancel()
-            # Don't call the original handler
-            # This prevents the application from exiting
-
-        try:
-            # Save original handler and set our custom one AFTER task is created
-            original_handler = signal.signal(signal.SIGINT, keyboard_interrupt_handler)
-
-            # Wait for the task to complete or be cancelled
-            result = await agent_task
-            return result
-        except asyncio.CancelledError:
-            # Task was cancelled by our handler
-            raise
-        except KeyboardInterrupt:
-            # Handle direct keyboard interrupt during await
-            if not agent_task.done():
-                agent_task.cancel()
-            try:
-                await agent_task
-            except asyncio.CancelledError:
-                pass
-            raise asyncio.CancelledError()
-        finally:
-            # Restore original signal handler
-            if original_handler:
-                signal.signal(signal.SIGINT, original_handler)
-
-    async def run(
-        self, prompt: str, usage_limits: Optional[UsageLimits] = None, **kwargs
-    ) -> Any:
-        """
-        Run the agent without explicitly managing MCP servers.
-
-        Args:
-            prompt: The user prompt to process
-            usage_limits: Optional usage limits for the agent
-            **kwargs: Additional arguments to pass to agent.run (e.g., message_history)
-
-        Returns:
-            The agent's response
-        """
-        agent = self.get_agent()
-        try:
-            return await agent.run(prompt, usage_limits=usage_limits, **kwargs)
-        except UsageLimitExceeded as ule:
-            group_id = str(uuid.uuid4())
-            emit_info(f"Usage limit exceeded: {str(ule)}", group_id=group_id)
-            emit_info(
-                "The agent has reached its usage limit. You can ask it to continue by saying 'please continue' or similar.",
-                group_id=group_id,
-            )
-            # Return None or some default value to indicate the limit was reached
-            return None
-
-    def __getattr__(self, name: str) -> Any:
-        """
-        Proxy all other attribute access to the current agent.
-
-        This allows the manager to be used as a drop-in replacement
-        for direct agent access.
-
-        Args:
-            name: The attribute name to access
-
-        Returns:
-            The attribute from the current agent
-        """
-        agent = self.get_agent()
-        return getattr(agent, name)
-
-
-# Global singleton instance
-_runtime_manager: Optional[RuntimeAgentManager] = None
-
-
-def get_runtime_agent_manager() -> RuntimeAgentManager:
-    """
-    Get the global runtime agent manager instance.
-
-    Returns:
-        The singleton RuntimeAgentManager instance
-    """
-    global _runtime_manager
-    if _runtime_manager is None:
-        _runtime_manager = RuntimeAgentManager()
-    return _runtime_manager

code_puppy/command_line/meta_command_handler.py

@@ -1,153 +0,0 @@
-import os
-
-from rich.console import Console
-
-from code_puppy.command_line.model_picker_completion import (
-    load_model_names,
-    update_model_in_input,
-)
-from code_puppy.config import get_config_keys
-from code_puppy.command_line.utils import make_directory_table
-from code_puppy.command_line.motd import print_motd
-
-META_COMMANDS_HELP = """
-[bold magenta]Meta Commands Help[/bold magenta]
-~help, ~h             Show this help message
-~cd <dir>             Change directory or show directories
-~m <model>            Set active model
-~motd                 Show the latest message of the day (MOTD)
-~show                 Show puppy config key-values
-~set                  Set puppy config key-values (message_limit, protected_token_count, compaction_threshold, allow_recursion, etc.)
-~<unknown>            Show unknown meta command warning
-"""
-
-
-def handle_meta_command(command: str, console: Console) -> bool:
-    """
-    Handle meta/config commands prefixed with '~'.
-    Returns True if the command was handled (even if just an error/help), False if not.
-    """
-    command = command.strip()
-
-    if command.strip().startswith("~motd"):
-        print_motd(console, force=True)
-        return True
-
-    if command.startswith("~cd"):
-        tokens = command.split()
-        if len(tokens) == 1:
-            try:
-                table = make_directory_table()
-                console.print(table)
-            except Exception as e:
-                console.print(f"[red]Error listing directory:[/red] {e}")
-            return True
-        elif len(tokens) == 2:
-            dirname = tokens[1]
-            target = os.path.expanduser(dirname)
-            if not os.path.isabs(target):
-                target = os.path.join(os.getcwd(), target)
-            if os.path.isdir(target):
-                os.chdir(target)
-                console.print(
-                    f"[bold green]Changed directory to:[/bold green] [cyan]{target}[/cyan]"
-                )
-            else:
-                console.print(f"[red]Not a directory:[/red] [bold]{dirname}[/bold]")
-            return True
-
-    if command.strip().startswith("~show"):
-        from code_puppy.command_line.model_picker_completion import get_active_model
-        from code_puppy.config import (
-            get_owner_name,
-            get_puppy_name,
-            get_yolo_mode,
-            get_message_limit,
-        )
-
-        puppy_name = get_puppy_name()
-        owner_name = get_owner_name()
-        model = get_active_model()
-        yolo_mode = get_yolo_mode()
-        msg_limit = get_message_limit()
-        console.print(f"""[bold magenta]🐶 Puppy Status[/bold magenta]
-
-[bold]puppy_name:[/bold]     [cyan]{puppy_name}[/cyan]
-[bold]owner_name:[/bold]     [cyan]{owner_name}[/cyan]
-[bold]model:[/bold]          [green]{model}[/green]
-[bold]YOLO_MODE:[/bold]      {"[red]ON[/red]" if yolo_mode else "[yellow]off[/yellow]"}
-[bold]message_limit:[/bold]   [cyan]{msg_limit}[/cyan] requests per minute
-""")
-        return True
-
-    if command.startswith("~set"):
-        # Syntax: ~set KEY=VALUE or ~set KEY VALUE
-        from code_puppy.config import set_config_value
-
-        tokens = command.split(None, 2)
-        argstr = command[len("~set") :].strip()
-        key = None
-        value = None
-        if "=" in argstr:
-            key, value = argstr.split("=", 1)
-            key = key.strip()
-            value = value.strip()
-        elif len(tokens) >= 3:
-            key = tokens[1]
-            value = tokens[2]
-        elif len(tokens) == 2:
-            key = tokens[1]
-            value = ""
-        else:
-            console.print(
-                f"[yellow]Usage:[/yellow] ~set KEY=VALUE or ~set KEY VALUE\nConfig keys: {', '.join(get_config_keys())}"
-            )
-            return True
-        if key:
-            set_config_value(key, value)
-            console.print(
-                f'[green]🌶 Set[/green] [cyan]{key}[/cyan] = "{value}" in puppy.cfg!'
-            )
-        else:
-            console.print("[red]You must supply a key.[/red]")
-        return True
-
-    if command.startswith("~m"):
-        # Try setting model and show confirmation
-        new_input = update_model_in_input(command)
-        if new_input is not None:
-            from code_puppy.command_line.model_picker_completion import get_active_model
-            from code_puppy.agents.runtime_manager import get_runtime_agent_manager
-
-            model = get_active_model()
-            # Make sure this is called for the test
-            manager = get_runtime_agent_manager()
-            manager.reload_agent()
-            console.print(
-                f"[bold green]Active model set and loaded:[/bold green] [cyan]{model}[/cyan]"
-            )
-            return True
-        # If no model matched, show available models
-        model_names = load_model_names()
-        console.print("[yellow]Usage:[/yellow] ~m <model-name>")
-        console.print(f"[yellow]Available models:[/yellow] {', '.join(model_names)}")
-        return True
-    if command in ("~help", "~h"):
-        console.print(META_COMMANDS_HELP)
-        return True
-    if command.startswith("~"):
-        name = command[1:].split()[0] if len(command) > 1 else ""
-        if name:
-            console.print(
-                f"[yellow]Unknown meta command:[/yellow] {command}\n[dim]Type ~help for options.[/dim]"
-            )
-        else:
-            # Show current model ONLY here
-            from code_puppy.command_line.model_picker_completion import get_active_model
-
-            current_model = get_active_model()
-            console.print(
-                f"[bold green]Current Model:[/bold green] [cyan]{current_model}[/cyan]"
-            )
-        return True
-    return False