code-puppy 0.0.135__py3-none-any.whl → 0.0.137__py3-none-any.whl

code_puppy/command_line/mcp/remove_command.py

@@ -0,0 +1,82 @@
+"""
+MCP Remove Command - Removes an MCP server.
+"""
+
+import json
+import logging
+import os
+from typing import List, Optional
+
+from code_puppy.messaging import emit_info
+
+from .base import MCPCommandBase
+from .utils import find_server_id_by_name, suggest_similar_servers
+
+# Configure logging
+logger = logging.getLogger(__name__)
+
+
+class RemoveCommand(MCPCommandBase):
+    """
+    Command handler for removing MCP servers.
+
+    Removes a specific MCP server from the manager and configuration.
+    """
+
+    def execute(self, args: List[str], group_id: Optional[str] = None) -> None:
+        """
+        Remove an MCP server.
+
+        Args:
+            args: Command arguments, expects [server_name]
+            group_id: Optional message group ID for grouping related messages
+        """
+        if group_id is None:
+            group_id = self.generate_group_id()
+
+        if not args:
+            emit_info("Usage: /mcp remove <server_name>", message_group=group_id)
+            return
+
+        server_name = args[0]
+
+        try:
+            # Find server by name
+            server_id = find_server_id_by_name(self.manager, server_name)
+            if not server_id:
+                emit_info(f"Server '{server_name}' not found", message_group=group_id)
+                suggest_similar_servers(self.manager, server_name, group_id=group_id)
+                return
+
+            # Actually remove the server
+            success = self.manager.remove_server(server_id)
+
+            if success:
+                emit_info(f"✓ Removed server: {server_name}", message_group=group_id)
+
+                # Also remove from mcp_servers.json
+                from code_puppy.config import MCP_SERVERS_FILE
+
+                if os.path.exists(MCP_SERVERS_FILE):
+                    try:
+                        with open(MCP_SERVERS_FILE, "r") as f:
+                            data = json.load(f)
+                            servers = data.get("mcp_servers", {})
+
+                        # Remove the server if it exists
+                        if server_name in servers:
+                            del servers[server_name]
+
+                            # Save back
+                            with open(MCP_SERVERS_FILE, "w") as f:
+                                json.dump(data, f, indent=2)
+                    except Exception as e:
+                        logger.warning(f"Could not update mcp_servers.json: {e}")
+            else:
+                emit_info(
+                    f"✗ Failed to remove server: {server_name}", message_group=group_id
+                )
+
+        except Exception as e:
+            logger.error(f"Error removing server '{server_name}': {e}")
+            emit_info(f"[red]Error removing server: {e}[/red]", message_group=group_id)

code_puppy/command_line/mcp/restart_command.py

@@ -0,0 +1,92 @@
+"""
+MCP Restart Command - Restarts a specific MCP server.
+"""
+
+import logging
+from typing import List, Optional
+
+from code_puppy.messaging import emit_info
+
+from .base import MCPCommandBase
+from .utils import find_server_id_by_name, suggest_similar_servers
+
+# Configure logging
+logger = logging.getLogger(__name__)
+
+
+class RestartCommand(MCPCommandBase):
+    """
+    Command handler for restarting MCP servers.
+
+    Stops, reloads configuration, and starts a specific MCP server.
+    """
+
+    def execute(self, args: List[str], group_id: Optional[str] = None) -> None:
+        """
+        Restart a specific MCP server.
+
+        Args:
+            args: Command arguments, expects [server_name]
+            group_id: Optional message group ID for grouping related messages
+        """
+        if group_id is None:
+            group_id = self.generate_group_id()
+
+        if not args:
+            emit_info("Usage: /mcp restart <server_name>", message_group=group_id)
+            return
+
+        server_name = args[0]
+
+        try:
+            # Find server by name
+            server_id = find_server_id_by_name(self.manager, server_name)
+            if not server_id:
+                emit_info(f"Server '{server_name}' not found", message_group=group_id)
+                suggest_similar_servers(self.manager, server_name, group_id=group_id)
+                return
+
+            # Stop the server first
+            emit_info(f"Stopping server: {server_name}", message_group=group_id)
+            self.manager.stop_server_sync(server_id)
+
+            # Then reload and start it
+            emit_info("Reloading configuration...", message_group=group_id)
+            reload_success = self.manager.reload_server(server_id)
+
+            if reload_success:
+                emit_info(f"Starting server: {server_name}", message_group=group_id)
+                start_success = self.manager.start_server_sync(server_id)
+
+                if start_success:
+                    emit_info(
+                        f"✓ Restarted server: {server_name}", message_group=group_id
+                    )
+
+                    # Reload the agent to pick up the server changes
+                    try:
+                        from code_puppy.agent import get_code_generation_agent
+
+                        get_code_generation_agent(force_reload=True)
+                        emit_info(
+                            "[dim]Agent reloaded with updated servers[/dim]",
+                            message_group=group_id,
+                        )
+                    except Exception as e:
+                        logger.warning(f"Could not reload agent: {e}")
+                else:
+                    emit_info(
+                        f"✗ Failed to start server after reload: {server_name}",
+                        message_group=group_id,
+                    )
+            else:
+                emit_info(
+                    f"✗ Failed to reload server configuration: {server_name}",
+                    message_group=group_id,
+                )
+
+        except Exception as e:
+            logger.error(f"Error restarting server '{server_name}': {e}")
+            emit_info(
+                f"[red]Failed to restart server: {e}[/red]", message_group=group_id
+            )

code_puppy/command_line/mcp/search_command.py

@@ -0,0 +1,117 @@
+"""
+MCP Search Command - Searches for pre-configured MCP servers in the registry.
+"""
+
+import logging
+from typing import List, Optional
+
+from rich.table import Table
+
+from code_puppy.messaging import emit_info, emit_system_message
+
+from .base import MCPCommandBase
+
+# Configure logging
+logger = logging.getLogger(__name__)
+
+
+class SearchCommand(MCPCommandBase):
+    """
+    Command handler for searching MCP server registry.
+
+    Searches for pre-configured MCP servers with optional query terms.
+    """
+
+    def execute(self, args: List[str], group_id: Optional[str] = None) -> None:
+        """
+        Search for pre-configured MCP servers in the registry.
+
+        Args:
+            args: Search query terms
+            group_id: Optional message group ID for grouping related messages
+        """
+        if group_id is None:
+            group_id = self.generate_group_id()
+
+        try:
+            from code_puppy.mcp.server_registry_catalog import catalog
+
+            if not args:
+                # Show popular servers if no query
+                emit_info(
+                    "[bold cyan]Popular MCP Servers:[/bold cyan]\n",
+                    message_group=group_id,
+                )
+                servers = catalog.get_popular(15)
+            else:
+                query = " ".join(args)
+                emit_info(
+                    f"[bold cyan]Searching for: {query}[/bold cyan]\n",
+                    message_group=group_id,
+                )
+                servers = catalog.search(query)
+
+            if not servers:
+                emit_info(
+                    "[yellow]No servers found matching your search[/yellow]",
+                    message_group=group_id,
+                )
+                emit_info(
+                    "Try: /mcp search database, /mcp search file, /mcp search git",
+                    message_group=group_id,
+                )
+                return
+
+            # Create results table
+            table = Table(show_header=True, header_style="bold magenta")
+            table.add_column("ID", style="cyan", width=20)
+            table.add_column("Name", style="green")
+            table.add_column("Category", style="yellow")
+            table.add_column("Description", style="white")
+            table.add_column("Tags", style="dim")
+
+            for server in servers[:20]:  # Limit to 20 results
+                tags = ", ".join(server.tags[:3])  # Show first 3 tags
+                if len(server.tags) > 3:
+                    tags += "..."
+
+                # Add verified/popular indicators
+                indicators = []
+                if server.verified:
+                    indicators.append("✓")
+                if server.popular:
+                    indicators.append("⭐")
+                name_display = server.display_name
+                if indicators:
+                    name_display += f" {''.join(indicators)}"
+
+                table.add_row(
+                    server.id,
+                    name_display,
+                    server.category,
+                    server.description[:50] + "..."
+                    if len(server.description) > 50
+                    else server.description,
+                    tags,
+                )
+
+            # The first message established the group, subsequent messages will auto-group
+            emit_system_message(table, message_group=group_id)
+            emit_info("\n[dim]✓ = Verified  ⭐ = Popular[/dim]", message_group=group_id)
+            emit_info(
+                "[yellow]To install:[/yellow] /mcp install <id>", message_group=group_id
+            )
+            emit_info(
+                "[yellow]For details:[/yellow] /mcp search <specific-term>",
+                message_group=group_id,
+            )
+
+        except ImportError:
+            emit_info(
+                "[red]Server registry not available[/red]", message_group=group_id
+            )
+        except Exception as e:
+            logger.error(f"Error searching server registry: {e}")
+            emit_info(
+                f"[red]Error searching servers: {e}[/red]", message_group=group_id
+            )

code_puppy/command_line/mcp/start_all_command.py

@@ -0,0 +1,126 @@
+"""
+MCP Start All Command - Starts all registered MCP servers.
+"""
+
+import logging
+import time
+from typing import List, Optional
+
+from code_puppy.mcp.managed_server import ServerState
+from code_puppy.messaging import emit_info
+
+from .base import MCPCommandBase
+
+# Configure logging
+logger = logging.getLogger(__name__)
+
+
+class StartAllCommand(MCPCommandBase):
+    """
+    Command handler for starting all MCP servers.
+
+    Starts all registered MCP servers and provides a summary of results.
+    """
+
+    def execute(self, args: List[str], group_id: Optional[str] = None) -> None:
+        """
+        Start all registered MCP servers.
+
+        Args:
+            args: Command arguments (unused)
+            group_id: Optional message group ID for grouping related messages
+        """
+        if group_id is None:
+            group_id = self.generate_group_id()
+
+        try:
+            servers = self.manager.list_servers()
+
+            if not servers:
+                emit_info(
+                    "[yellow]No servers registered[/yellow]", message_group=group_id
+                )
+                return
+
+            started_count = 0
+            failed_count = 0
+            already_running = 0
+
+            emit_info(f"Starting {len(servers)} servers...", message_group=group_id)
+
+            for server_info in servers:
+                server_id = server_info.id
+                server_name = server_info.name
+
+                # Skip if already running
+                if server_info.state == ServerState.RUNNING:
+                    already_running += 1
+                    emit_info(
+                        f"  • {server_name}: already running", message_group=group_id
+                    )
+                    continue
+
+                # Try to start the server
+                success = self.manager.start_server_sync(server_id)
+
+                if success:
+                    started_count += 1
+                    emit_info(
+                        f"  [green]✓ Started: {server_name}[/green]",
+                        message_group=group_id,
+                    )
+                else:
+                    failed_count += 1
+                    emit_info(
+                        f"  [red]✗ Failed: {server_name}[/red]", message_group=group_id
+                    )
+
+            # Summary
+            emit_info("", message_group=group_id)
+            if started_count > 0:
+                emit_info(
+                    f"[green]Started {started_count} server(s)[/green]",
+                    message_group=group_id,
+                )
+            if already_running > 0:
+                emit_info(
+                    f"{already_running} server(s) already running",
+                    message_group=group_id,
+                )
+            if failed_count > 0:
+                emit_info(
+                    f"[yellow]Failed to start {failed_count} server(s)[/yellow]",
+                    message_group=group_id,
+                )
+
+            # Reload agent if any servers were started
+            if started_count > 0:
+                # Give async tasks a moment to complete before reloading agent
+                try:
+                    import asyncio
+
+                    asyncio.get_running_loop()  # Check if in async context
+                    # If we're in async context, wait a bit for servers to start
+                    time.sleep(0.5)  # Small delay to let async tasks progress
+                except RuntimeError:
+                    pass  # No async loop, servers will start when agent uses them
+
+                try:
+                    from code_puppy.agents.runtime_manager import (
+                        get_runtime_agent_manager,
+                    )
+
+                    manager = get_runtime_agent_manager()
+                    manager.reload_agent()
+                    emit_info(
+                        "[dim]Agent reloaded with updated servers[/dim]",
+                        message_group=group_id,
+                    )
+                except Exception as e:
+                    logger.warning(f"Could not reload agent: {e}")
+
+        except Exception as e:
+            logger.error(f"Error starting all servers: {e}")
+            emit_info(
+                f"[red]Failed to start servers: {e}[/red]", message_group=group_id
+            )

code_puppy/command_line/mcp/start_command.py

@@ -0,0 +1,98 @@
+"""
+MCP Start Command - Starts a specific MCP server.
+"""
+
+import logging
+import time
+from typing import List, Optional
+
+from code_puppy.messaging import emit_info
+
+from .base import MCPCommandBase
+from .utils import find_server_id_by_name, suggest_similar_servers
+
+# Configure logging
+logger = logging.getLogger(__name__)
+
+
+class StartCommand(MCPCommandBase):
+    """
+    Command handler for starting MCP servers.
+
+    Starts a specific MCP server by name and reloads the agent.
+    """
+
+    def execute(self, args: List[str], group_id: Optional[str] = None) -> None:
+        """
+        Start a specific MCP server.
+
+        Args:
+            args: Command arguments, expects [server_name]
+            group_id: Optional message group ID for grouping related messages
+        """
+        if group_id is None:
+            group_id = self.generate_group_id()
+
+        if not args:
+            emit_info(
+                "[yellow]Usage: /mcp start <server_name>[/yellow]",
+                message_group=group_id,
+            )
+            return
+
+        server_name = args[0]
+
+        try:
+            # Find server by name
+            server_id = find_server_id_by_name(self.manager, server_name)
+            if not server_id:
+                emit_info(
+                    f"[red]Server '{server_name}' not found[/red]",
+                    message_group=group_id,
+                )
+                suggest_similar_servers(self.manager, server_name, group_id=group_id)
+                return
+
+            # Start the server (enable and start process)
+            success = self.manager.start_server_sync(server_id)
+
+            if success:
+                # This and subsequent messages will auto-group with the first message
+                emit_info(
+                    f"[green]✓ Started server: {server_name}[/green]",
+                    message_group=group_id,
+                )
+
+                # Give async tasks a moment to complete
+                try:
+                    import asyncio
+
+                    asyncio.get_running_loop()  # Check if in async context
+                    # If we're in async context, wait a bit for server to start
+                    time.sleep(0.5)  # Small delay to let async tasks progress
+                except RuntimeError:
+                    pass  # No async loop, server will start when agent uses it
+
+                # Reload the agent to pick up the newly enabled server
+                try:
+                    from code_puppy.agents.runtime_manager import (
+                        get_runtime_agent_manager,
+                    )
+
+                    manager = get_runtime_agent_manager()
+                    manager.reload_agent()
+                    emit_info(
+                        "[dim]Agent reloaded with updated servers[/dim]",
+                        message_group=group_id,
+                    )
+                except Exception as e:
+                    logger.warning(f"Could not reload agent: {e}")
+            else:
+                emit_info(
+                    f"[red]✗ Failed to start server: {server_name}[/red]",
+                    message_group=group_id,
+                )
+
+        except Exception as e:
+            logger.error(f"Error starting server '{server_name}': {e}")
+            emit_info(f"[red]Failed to start server: {e}[/red]", message_group=group_id)