code-puppy 0.0.134__py3-none-any.whl → 0.0.136__py3-none-any.whl

code_puppy/agents/runtime_manager.py

@@ -7,8 +7,20 @@ all references to the agent are properly updated when it's reloaded.
 
 import asyncio
 import signal
+import sys
 import uuid
-from typing import Optional, Any
+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
@@ -20,71 +32,79 @@ from code_puppy.messaging.message_queue import emit_info, emit_warning
 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)
+        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)
+        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:
+
+    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:
@@ -93,12 +113,15 @@ class RuntimeAgentManager:
             except* mcp.shared.exceptions.McpError as mcp_error:
                 emit_warning(f"MCP server error: {str(mcp_error)}", group_id=group_id)
                 emit_warning(f"{str(mcp_error)}", group_id=group_id)
-                emit_warning(f"Try disabling any malfunctioning MCP servers", group_id=group_id)
+                emit_warning(
+                    "Try disabling any malfunctioning MCP servers", group_id=group_id
+                )
             except* InterruptedError as ie:
                 emit_warning(f"Interrupted: {str(ie)}")
             except* Exception as other_error:
                 # Filter out CancelledError 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:
@@ -107,40 +130,41 @@ class RuntimeAgentManager:
                         remaining_exceptions.append(exc)
                         emit_warning(f"Unexpected error: {str(exc)}", group_id=group_id)
                         emit_warning(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
         handled = False
-        
+
         def keyboard_interrupt_handler(sig, frame):
             """Signal handler for Ctrl+C - replicating exact original logic"""
             nonlocal handled
             if handled:
                 return
             handled = True
-            
+
             # First, nuke any running shell processes triggered by tools
             try:
                 killed = kill_all_running_shell_processes()
@@ -157,11 +181,11 @@ class RuntimeAgentManager:
                     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
@@ -181,32 +205,34 @@ class RuntimeAgentManager:
             # 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:
+
+    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()
         return await agent.run(prompt, usage_limits=usage_limits, **kwargs)
-    
+
     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
         """
@@ -221,11 +247,11 @@ _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
+    return _runtime_manager

code_puppy/command_line/command_handler.py

@@ -9,41 +9,85 @@ from code_puppy.command_line.utils import make_directory_table
 from code_puppy.config import get_config_keys
 from code_puppy.tools.tools_content import tools_content
 
+
 def get_commands_help():
     """Generate commands help using Rich Text objects to avoid markup conflicts."""
     from rich.text import Text
-    
+
     # Build help text programmatically
     help_lines = []
-    
+
     # Title
     help_lines.append(Text("Commands Help", style="bold magenta"))
-    
-    # Commands - build each line programmatically  
-    help_lines.append(Text("/help, /h", style="cyan") + Text("             Show this help message"))
-    help_lines.append(Text("/cd", style="cyan") + Text(" <dir>             Change directory or show directories"))
-    help_lines.append(Text("/agent", style="cyan") + Text(" <name>         Switch to a different agent or show available agents"))
-    help_lines.append(Text("/exit, /quit", style="cyan") + Text("          Exit interactive mode"))
-    help_lines.append(Text("/generate-pr-description", style="cyan") + Text(" [@dir]  Generate comprehensive PR description"))
-    help_lines.append(Text("/model", style="cyan") + Text(" <model>        Set active model"))
-    help_lines.append(Text("/mcp", style="cyan") + Text("                  Manage MCP servers (list, start, stop, status, etc.)"))
-    help_lines.append(Text("/motd", style="cyan") + Text("                 Show the latest message of the day (MOTD)"))
-    help_lines.append(Text("/show", style="cyan") + Text("                 Show puppy config key-values"))
-    help_lines.append(Text("/compact", style="cyan") + Text("              Summarize and compact current chat history"))
-    help_lines.append(Text("/dump_context", style="cyan") + Text(" <name>  Save current message history to file"))
-    help_lines.append(Text("/load_context", style="cyan") + Text(" <name>  Load message history from file"))
-    help_lines.append(Text("/set", style="cyan") + Text("                  Set puppy config key-values (e.g., /set yolo_mode true, /set compaction_strategy truncation)"))
-    help_lines.append(Text("/tools", style="cyan") + Text("                Show available tools and capabilities"))
-    help_lines.append(Text("/<unknown>", style="cyan") + Text("            Show unknown command warning"))
-    
-    
+
+    # Commands - build each line programmatically
+    help_lines.append(
+        Text("/help, /h", style="cyan") + Text("             Show this help message")
+    )
+    help_lines.append(
+        Text("/cd", style="cyan")
+        + Text(" <dir>             Change directory or show directories")
+    )
+    help_lines.append(
+        Text("/agent", style="cyan")
+        + Text(" <name>         Switch to a different agent or show available agents")
+    )
+    help_lines.append(
+        Text("/exit, /quit", style="cyan") + Text("          Exit interactive mode")
+    )
+    help_lines.append(
+        Text("/generate-pr-description", style="cyan")
+        + Text(" [@dir]  Generate comprehensive PR description")
+    )
+    help_lines.append(
+        Text("/model, /m", style="cyan") + Text(" <model>   Set active model")
+    )
+    help_lines.append(
+        Text("/mcp", style="cyan")
+        + Text("                  Manage MCP servers (list, start, stop, status, etc.)")
+    )
+    help_lines.append(
+        Text("/motd", style="cyan")
+        + Text("                 Show the latest message of the day (MOTD)")
+    )
+    help_lines.append(
+        Text("/show", style="cyan")
+        + Text("                 Show puppy config key-values")
+    )
+    help_lines.append(
+        Text("/compact", style="cyan")
+        + Text("              Summarize and compact current chat history")
+    )
+    help_lines.append(
+        Text("/dump_context", style="cyan")
+        + Text(" <name>  Save current message history to file")
+    )
+    help_lines.append(
+        Text("/load_context", style="cyan")
+        + Text(" <name>  Load message history from file")
+    )
+    help_lines.append(
+        Text("/set", style="cyan")
+        + Text(
+            "                  Set puppy config key-values (e.g., /set yolo_mode true, /set compaction_strategy truncation)"
+        )
+    )
+    help_lines.append(
+        Text("/tools", style="cyan")
+        + Text("                Show available tools and capabilities")
+    )
+    help_lines.append(
+        Text("/<unknown>", style="cyan")
+        + Text("            Show unknown command warning")
+    )
+
     # Combine all lines
     final_text = Text()
     for i, line in enumerate(help_lines):
         if i > 0:
             final_text.append("\n")
         final_text.append_text(line)
-    
+
     return final_text
 
 
@@ -69,9 +113,9 @@ def handle_command(command: str):
         from code_puppy.config import get_compaction_strategy
         from code_puppy.message_history_processor import (
             estimate_tokens_for_message,
+            get_protected_token_count,
             summarize_messages,
             truncation,
-            get_protected_token_count,
         )
         from code_puppy.messaging import (
             emit_error,
@@ -152,17 +196,16 @@ def handle_command(command: str):
             return True
 
     if command.strip().startswith("/show"):
+        from code_puppy.agents import get_current_agent_config
         from code_puppy.command_line.model_picker_completion import get_active_model
         from code_puppy.config import (
+            get_compaction_strategy,
+            get_compaction_threshold,
             get_owner_name,
             get_protected_token_count,
             get_puppy_name,
-            get_compaction_threshold,
             get_yolo_mode,
         )
-        from code_puppy.agents import get_current_agent_config
-
-        from code_puppy.config import get_compaction_strategy
 
         puppy_name = get_puppy_name()
         owner_name = get_owner_name()
@@ -234,10 +277,10 @@ def handle_command(command: str):
     if command.startswith("/agent"):
         # Handle agent switching
         from code_puppy.agents import (
+            get_agent_descriptions,
             get_available_agents,
             get_current_agent_config,
             set_current_agent,
-            get_agent_descriptions,
         )
         from code_puppy.agents.runtime_manager import get_runtime_agent_manager
 
@@ -317,10 +360,14 @@ def handle_command(command: str):
             emit_warning("Usage: /agent [agent-name]")
             return True
 
-    if command.startswith("/model"):
+    if command.startswith("/model") or command.startswith("/m "):
         # Try setting model and show confirmation
         # Handle both /model and /m for backward compatibility
-        model_command = command.replace("/model", "/m") if command.startswith("/model") else command
+        model_command = command
+        if command.startswith("/model"):
+            # Convert /model to /m for internal processing
+            model_command = command.replace("/model", "/m", 1)
+
         new_input = update_model_in_input(model_command)
         if new_input is not None:
             from code_puppy.agents.runtime_manager import get_runtime_agent_manager
@@ -334,16 +381,18 @@ def handle_command(command: str):
             return True
         # If no model matched, show available models
         model_names = load_model_names()
-        emit_warning("Usage: /model <model-name>")
+        emit_warning("Usage: /model <model-name> or /m <model-name>")
         emit_warning(f"Available models: {', '.join(model_names)}")
         return True
-    
+
     if command.startswith("/mcp"):
-        from code_puppy.command_line.mcp_commands import MCPCommandHandler
+        from code_puppy.command_line.mcp import MCPCommandHandler
+
         handler = MCPCommandHandler()
         return handler.handle_mcp_command(command)
     if command in ("/help", "/h"):
         import uuid
+
         group_id = str(uuid.uuid4())
         help_text = get_commands_help()
         emit_info(help_text, message_group_id=group_id)

code_puppy/command_line/mcp/__init__.py

@@ -0,0 +1,10 @@
+"""
+MCP Command Line Interface - Namespace package for MCP server management commands.
+
+This package provides a modular command interface for managing MCP servers.
+Each command is implemented in its own module for better maintainability.
+"""
+
+from .handler import MCPCommandHandler
+
+__all__ = ["MCPCommandHandler"]

code_puppy/command_line/mcp/add_command.py

@@ -0,0 +1,183 @@
+"""
+MCP Add Command - Adds new MCP servers from JSON configuration or wizard.
+"""
+
+import json
+import logging
+import os
+from typing import List, Optional
+
+from code_puppy.messaging import emit_info
+from code_puppy.state_management import is_tui_mode
+
+from .base import MCPCommandBase
+from .wizard_utils import run_interactive_install_wizard
+
+# Configure logging
+logger = logging.getLogger(__name__)
+
+
+class AddCommand(MCPCommandBase):
+    """
+    Command handler for adding MCP servers.
+
+    Adds new MCP servers from JSON configuration or interactive wizard.
+    """
+
+    def execute(self, args: List[str], group_id: Optional[str] = None) -> None:
+        """
+        Add a new MCP server from JSON configuration or launch wizard.
+
+        Usage:
+            /mcp add                    - Launch interactive wizard
+            /mcp add <json>             - Add server from JSON config
+
+        Example JSON:
+            /mcp add {"name": "test", "type": "stdio", "command": "echo", "args": ["hello"]}
+
+        Args:
+            args: Command arguments - JSON config or empty for wizard
+            group_id: Optional message group ID for grouping related messages
+        """
+        if group_id is None:
+            group_id = self.generate_group_id()
+
+        # Check if in TUI mode and guide user to use Ctrl+T instead
+        if is_tui_mode() and not args:
+            emit_info(
+                "💡 In TUI mode, press Ctrl+T to open the MCP Install Wizard",
+                message_group=group_id,
+            )
+            emit_info(
+                "   The wizard provides a better interface for browsing and installing MCP servers.",
+                message_group=group_id,
+            )
+            return
+
+        try:
+            if args:
+                # Parse JSON from arguments
+                json_str = " ".join(args)
+
+                try:
+                    config_dict = json.loads(json_str)
+                except json.JSONDecodeError as e:
+                    emit_info(f"Invalid JSON: {e}", message_group=group_id)
+                    emit_info(
+                        "Usage: /mcp add <json> or /mcp add (for wizard)",
+                        message_group=group_id,
+                    )
+                    emit_info(
+                        'Example: /mcp add {"name": "test", "type": "stdio", "command": "echo"}',
+                        message_group=group_id,
+                    )
+                    return
+
+                # Validate required fields
+                if "name" not in config_dict:
+                    emit_info("Missing required field: 'name'", message_group=group_id)
+                    return
+                if "type" not in config_dict:
+                    emit_info("Missing required field: 'type'", message_group=group_id)
+                    return
+
+                # Add the server
+                success = self._add_server_from_json(config_dict, group_id)
+
+                if success:
+                    # Reload MCP servers
+                    try:
+                        from code_puppy.agent import reload_mcp_servers
+
+                        reload_mcp_servers()
+                    except ImportError:
+                        pass
+
+                    emit_info(
+                        "Use '/mcp list' to see all servers", message_group=group_id
+                    )
+
+            else:
+                # No arguments - launch interactive wizard with server templates
+                success = run_interactive_install_wizard(self.manager, group_id)
+
+                if success:
+                    # Reload the agent to pick up new server
+                    try:
+                        from code_puppy.agent import reload_mcp_servers
+
+                        reload_mcp_servers()
+                    except ImportError:
+                        pass
+
+        except ImportError as e:
+            logger.error(f"Failed to import: {e}")
+            emit_info("Required module not available", message_group=group_id)
+        except Exception as e:
+            logger.error(f"Error in add command: {e}")
+            emit_info(f"[red]Error adding server: {e}[/red]", message_group=group_id)
+
+    def _add_server_from_json(self, config_dict: dict, group_id: str) -> bool:
+        """
+        Add a server from JSON configuration.
+
+        Args:
+            config_dict: Server configuration dictionary
+            group_id: Message group ID
+
+        Returns:
+            True if successful, False otherwise
+        """
+        try:
+            from code_puppy.config import MCP_SERVERS_FILE
+            from code_puppy.mcp.managed_server import ServerConfig
+
+            # Extract required fields
+            name = config_dict.pop("name")
+            server_type = config_dict.pop("type")
+            enabled = config_dict.pop("enabled", True)
+
+            # Everything else goes into config
+            server_config = ServerConfig(
+                id=f"{name}_{hash(name)}",
+                name=name,
+                type=server_type,
+                enabled=enabled,
+                config=config_dict,  # Remaining fields are server-specific config
+            )
+
+            # Register the server
+            server_id = self.manager.register_server(server_config)
+
+            if not server_id:
+                emit_info(f"Failed to add server '{name}'", message_group=group_id)
+                return False
+
+            emit_info(
+                f"✅ Added server '{name}' (ID: {server_id})", message_group=group_id
+            )
+
+            # Save to mcp_servers.json for persistence
+            if os.path.exists(MCP_SERVERS_FILE):
+                with open(MCP_SERVERS_FILE, "r") as f:
+                    data = json.load(f)
+                    servers = data.get("mcp_servers", {})
+            else:
+                servers = {}
+                data = {"mcp_servers": servers}
+
+            # Add new server
+            servers[name] = config_dict.copy()
+            servers[name]["type"] = server_type
+
+            # Save back
+            os.makedirs(os.path.dirname(MCP_SERVERS_FILE), exist_ok=True)
+            with open(MCP_SERVERS_FILE, "w") as f:
+                json.dump(data, f, indent=2)
+
+            return True
+
+        except Exception as e:
+            logger.error(f"Error adding server from JSON: {e}")
+            emit_info(f"[red]Failed to add server: {e}[/red]", message_group=group_id)
+            return False

code_puppy/command_line/mcp/base.py

@@ -0,0 +1,35 @@
+"""
+MCP Command Base Classes - Shared functionality for MCP command handlers.
+
+Provides base classes and common utilities used across all MCP command modules.
+"""
+
+import logging
+
+from rich.console import Console
+
+from code_puppy.mcp.manager import get_mcp_manager
+
+# Configure logging
+logger = logging.getLogger(__name__)
+
+
+class MCPCommandBase:
+    """
+    Base class for MCP command handlers.
+
+    Provides common functionality like console access and MCP manager access
+    that all command handlers need.
+    """
+
+    def __init__(self):
+        """Initialize the base command handler."""
+        self.console = Console()
+        self.manager = get_mcp_manager()
+        logger.debug(f"Initialized {self.__class__.__name__}")
+
+    def generate_group_id(self) -> str:
+        """Generate a unique group ID for message grouping."""
+        import uuid
+
+        return str(uuid.uuid4())