codepp 0.0.437__py3-none-any.whl

code_puppy/command_line/mcp/list_command.py

@@ -0,0 +1,94 @@
+"""
+MCP List Command - Lists all registered MCP servers in a formatted table.
+"""
+
+import logging
+from typing import List, Optional
+
+from rich.table import Table
+from rich.text import Text
+
+from code_puppy.mcp_.managed_server import ServerState
+from code_puppy.messaging import emit_error, emit_info
+
+from .base import MCPCommandBase
+from .utils import format_state_indicator, format_uptime
+
+# Configure logging
+logger = logging.getLogger(__name__)
+
+
+class ListCommand(MCPCommandBase):
+    """
+    Command handler for listing MCP servers.
+
+    Displays all registered MCP servers in a formatted table with status information.
+    """
+
+    def execute(self, args: List[str], group_id: Optional[str] = None) -> None:
+        """
+        List all registered MCP servers in a formatted table.
+
+        Args:
+            args: Command arguments (unused for list command)
+            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("No MCP servers registered", message_group=group_id)
+                return
+
+            # Create table for server list
+            table = Table(title="🔌 MCP Server Status Dashboard")
+            table.add_column("Name", style="cyan", no_wrap=True)
+            table.add_column("Type", style="dim", no_wrap=True)
+            table.add_column("State", justify="center")
+            table.add_column("Enabled", justify="center")
+            table.add_column("Uptime", style="dim")
+            table.add_column("Status", style="dim")
+
+            for server in servers:
+                # Format state with appropriate color and icon
+                state_display = format_state_indicator(server.state)
+
+                # Format enabled status
+                enabled_display = "✓" if server.enabled else "✗"
+                enabled_style = "green" if server.enabled else "red"
+
+                # Format uptime
+                uptime_display = format_uptime(server.uptime_seconds)
+
+                # Format status message
+                status_display = server.error_message or "OK"
+                if server.quarantined:
+                    status_display = "Quarantined"
+
+                table.add_row(
+                    server.name,
+                    server.type.upper(),
+                    state_display,
+                    Text(enabled_display, style=enabled_style),
+                    uptime_display,
+                    status_display,
+                )
+
+            emit_info(table, message_group=group_id)
+
+            # Show summary
+            total = len(servers)
+            running = sum(
+                1 for s in servers if s.state == ServerState.RUNNING and s.enabled
+            )
+            emit_info(
+                f"\n📊 Summary: {running}/{total} servers running",
+                message_group=group_id,
+            )
+
+        except Exception as e:
+            logger.error(f"Error listing MCP servers: {e}")
+            emit_error(f"Error listing servers: {e}", message_group=group_id)

code_puppy/command_line/mcp/logs_command.py

@@ -0,0 +1,235 @@
+"""
+MCP Logs Command - Shows server logs from persistent log files.
+"""
+
+import logging
+from typing import List, Optional
+
+from rich.panel import Panel
+from rich.syntax import Syntax
+from rich.text import Text
+
+from code_puppy.mcp_.mcp_logs import (
+    clear_logs,
+    get_log_file_path,
+    get_log_stats,
+    list_servers_with_logs,
+    read_logs,
+)
+from code_puppy.messaging import emit_error, emit_info
+
+from .base import MCPCommandBase
+from .utils import find_server_id_by_name, suggest_similar_servers
+
+# Configure logging
+logger = logging.getLogger(__name__)
+
+
+class LogsCommand(MCPCommandBase):
+    """
+    Command handler for showing MCP server logs.
+
+    Shows logs from persistent log files stored in ~/.code_puppy/mcp_logs/.
+    """
+
+    def execute(self, args: List[str], group_id: Optional[str] = None) -> None:
+        """
+        Show logs for a server.
+
+        Usage:
+            /mcp logs                    - List servers with logs
+            /mcp logs <server_name>      - Show last 50 lines
+            /mcp logs <server_name> 100  - Show last 100 lines
+            /mcp logs <server_name> all  - Show all logs
+            /mcp logs <server_name> --clear - Clear logs for server
+
+        Args:
+            args: Command arguments
+            group_id: Optional message group ID for grouping related messages
+        """
+        if group_id is None:
+            group_id = self.generate_group_id()
+
+        # No args - list servers with logs
+        if not args:
+            self._list_servers_with_logs(group_id)
+            return
+
+        server_name = args[0]
+
+        # Check for --clear flag
+        if len(args) > 1 and args[1] == "--clear":
+            self._clear_logs(server_name, group_id)
+            return
+
+        # Determine number of lines
+        lines = 50  # Default
+        show_all = False
+
+        if len(args) > 1:
+            if args[1].lower() == "all":
+                show_all = True
+            else:
+                try:
+                    lines = int(args[1])
+                    if lines <= 0:
+                        emit_info(
+                            "Lines must be positive, using default: 50",
+                            message_group=group_id,
+                        )
+                        lines = 50
+                except ValueError:
+                    emit_info(
+                        f"Invalid number '{args[1]}', using default: 50",
+                        message_group=group_id,
+                    )
+
+        self._show_logs(server_name, lines if not show_all else None, group_id)
+
+    def _list_servers_with_logs(self, group_id: str) -> None:
+        """List all servers that have log files."""
+        servers = list_servers_with_logs()
+
+        if not servers:
+            emit_info(
+                "📋 No MCP server logs found.\n"
+                "Logs are created when servers are started.",
+                message_group=group_id,
+            )
+            return
+
+        lines = ["📋 **Servers with logs:**\n"]
+
+        for server in servers:
+            stats = get_log_stats(server)
+            size_kb = stats["total_size_bytes"] / 1024
+            size_str = (
+                f"{size_kb:.1f} KB" if size_kb < 1024 else f"{size_kb / 1024:.1f} MB"
+            )
+            rotated = (
+                f" (+{stats['rotated_count']} rotated)"
+                if stats["rotated_count"]
+                else ""
+            )
+            lines.append(
+                f"  • **{server}** - {stats['line_count']} lines, {size_str}{rotated}"
+            )
+
+        lines.append("\n**Usage:** `/mcp logs <server_name> [lines|all]`")
+
+        emit_info("\n".join(lines), message_group=group_id)
+
+    def _show_logs(self, server_name: str, lines: Optional[int], group_id: str) -> None:
+        """
+        Show logs for a specific server.
+
+        Args:
+            server_name: Name of the server
+            lines: Number of lines to show, or None for all
+            group_id: Message group ID
+        """
+        try:
+            # Verify server exists in manager
+            server_id = find_server_id_by_name(self.manager, server_name)
+            if not server_id:
+                # Server not configured, but might have logs from before
+                stats = get_log_stats(server_name)
+                if not stats["exists"]:
+                    emit_info(
+                        f"Server '{server_name}' not found and has no logs.",
+                        message_group=group_id,
+                    )
+                    suggest_similar_servers(
+                        self.manager, server_name, group_id=group_id
+                    )
+                    return
+
+            # Read logs
+            log_lines = read_logs(server_name, lines=lines)
+
+            if not log_lines:
+                emit_info(
+                    f"📋 No logs found for server: **{server_name}**\n"
+                    f"Log file: `{get_log_file_path(server_name)}`",
+                    message_group=group_id,
+                )
+                return
+
+            # Get stats for header
+            stats = get_log_stats(server_name)
+            total_lines = stats["line_count"]
+            showing = len(log_lines)
+
+            # Format header
+            if lines is None:
+                header = f"📋 Logs for {server_name} (all {total_lines} lines)"
+            else:
+                header = (
+                    f"📋 Logs for {server_name} (last {showing} of {total_lines} lines)"
+                )
+
+            # Format log content with syntax highlighting
+            log_content = "\n".join(log_lines)
+
+            # Create a panel with the logs
+            syntax = Syntax(
+                log_content,
+                "log",
+                theme="monokai",
+                word_wrap=True,
+                line_numbers=False,
+            )
+
+            panel = Panel(
+                syntax,
+                title=header,
+                subtitle=f"Log file: {get_log_file_path(server_name)}",
+                border_style="dim",
+            )
+
+            emit_info(panel, message_group=group_id)
+
+            # Show hint for more options
+            if lines is not None and showing < total_lines:
+                emit_info(
+                    Text.from_markup(
+                        f"[dim]💡 Use `/mcp logs {server_name} all` to see all logs, "
+                        f"or `/mcp logs {server_name} <number>` for specific count[/dim]"
+                    ),
+                    message_group=group_id,
+                )
+
+        except Exception as e:
+            logger.error(f"Error getting logs for server '{server_name}': {e}")
+            emit_error(f"Error getting logs: {e}", message_group=group_id)
+
+    def _clear_logs(self, server_name: str, group_id: str) -> None:
+        """
+        Clear logs for a specific server.
+
+        Args:
+            server_name: Name of the server
+            group_id: Message group ID
+        """
+        try:
+            stats = get_log_stats(server_name)
+
+            if not stats["exists"] and stats["rotated_count"] == 0:
+                emit_info(
+                    f"No logs to clear for server: {server_name}",
+                    message_group=group_id,
+                )
+                return
+
+            # Clear the logs
+            clear_logs(server_name, include_rotated=True)
+
+            cleared_count = 1 + stats["rotated_count"]
+            emit_info(
+                f"🗑️  Cleared {cleared_count} log file(s) for **{server_name}**",
+                message_group=group_id,
+            )
+
+        except Exception as e:
+            logger.error(f"Error clearing logs for server '{server_name}': {e}")
+            emit_error(f"Error clearing logs: {e}", message_group=group_id)

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_error, 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_error(f"Error removing server: {e}", message_group=group_id)

code_puppy/command_line/mcp/restart_command.py

@@ -0,0 +1,100 @@
+"""
+MCP Restart Command - Restarts a specific MCP server.
+"""
+
+import logging
+from typing import List, Optional
+
+from rich.text import Text
+
+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.agents import get_current_agent
+
+                        agent = get_current_agent()
+                        agent.reload_code_generation_agent()
+                        # Update MCP tool cache immediately so token counts reflect the change
+                        agent.update_mcp_tool_cache_sync()
+                        emit_info(
+                            Text.from_markup(
+                                "[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(
+                Text.from_markup(f"[red]Failed to restart server: {e}[/red]"),
+                message_group=group_id,
+            )

code_puppy/command_line/mcp/search_command.py

@@ -0,0 +1,123 @@
+"""
+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 rich.text import Text
+
+from code_puppy.messaging import emit_info, emit_system_message, emit_warning
+
+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(
+                    "Popular MCP Servers:\n",
+                    message_group=group_id,
+                )
+                servers = catalog.get_popular(15)
+            else:
+                query = " ".join(args)
+                emit_info(
+                    f"Searching for: {query}\n",
+                    message_group=group_id,
+                )
+                servers = catalog.search(query)
+
+            if not servers:
+                emit_warning(
+                    "No servers found matching your search",
+                    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✓ = Verified  ⭐ = Popular", message_group=group_id)
+            emit_info(
+                Text.from_markup("[yellow]To install:[/yellow] /mcp install <id>"),
+                message_group=group_id,
+            )
+            emit_info(
+                Text.from_markup(
+                    "[yellow]For details:[/yellow] /mcp search <specific-term>"
+                ),
+                message_group=group_id,
+            )
+
+        except ImportError:
+            emit_info(
+                Text.from_markup("[red]Server registry not available[/red]"),
+                message_group=group_id,
+            )
+        except Exception as e:
+            logger.error(f"Error searching server registry: {e}")
+            emit_info(
+                Text.from_markup(f"[red]Error searching servers: {e}[/red]"),
+                message_group=group_id,
+            )