code-puppy 0.0.169__py3-none-any.whl → 0.0.366__py3-none-any.whl

code_puppy/command_line/mcp/logs_command.py

@@ -1,15 +1,22 @@
 """
-MCP Logs Command - Shows recent events/logs for a server.
+MCP Logs Command - Shows server logs from persistent log files.
 """
 
 import logging
-from datetime import datetime
 from typing import List, Optional
 
-from rich.table import Table
+from rich.panel import Panel
+from rich.syntax import Syntax
 from rich.text import Text
 
-from code_puppy.messaging import emit_info
+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
@@ -22,105 +29,207 @@ class LogsCommand(MCPCommandBase):
     """
     Command handler for showing MCP server logs.
 
-    Shows recent events/logs for a specific MCP server with configurable limit.
+    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 recent events/logs for a server.
+        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, expects [server_name] and optional [limit]
+            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:
-            emit_info("Usage: /mcp logs <server_name> [limit]", message_group=group_id)
+            self._list_servers_with_logs(group_id)
             return
 
         server_name = args[0]
-        limit = 10  # Default limit
+
+        # 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:
-            try:
-                limit = int(args[1])
-                if limit <= 0 or limit > 100:
+            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(
-                        "Limit must be between 1 and 100, using default: 10",
+                        f"Invalid number '{args[1]}', using default: 50",
                         message_group=group_id,
                     )
-                    limit = 10
-            except ValueError:
-                emit_info(
-                    f"Invalid limit '{args[1]}', using default: 10",
-                    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:
-            # Find server by name
+            # Verify server exists in manager
             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
+                # 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
 
-            # Get server status which includes recent events
-            status = self.manager.get_server_status(server_id)
+            # Read logs
+            log_lines = read_logs(server_name, lines=lines)
 
-            if not status.get("exists", True):
+            if not log_lines:
                 emit_info(
-                    f"Server '{server_name}' status not available",
+                    f"📋 No logs found for server: **{server_name}**\n"
+                    f"Log file: `{get_log_file_path(server_name)}`",
                     message_group=group_id,
                 )
                 return
 
-            recent_events = status.get("recent_events", [])
+            # 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)
 
-            if not recent_events:
+            # 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(
-                    f"No recent events for server: {server_name}",
+                    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,
                 )
-                return
 
-            # Show events in a table
-            table = Table(title=f"📋 Recent Events for {server_name} (last {limit})")
-            table.add_column("Time", style="dim", no_wrap=True)
-            table.add_column("Event", style="cyan")
-            table.add_column("Details", style="dim")
+        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)
 
-            # Take only the requested number of events
-            events_to_show = (
-                recent_events[-limit:] if len(recent_events) > limit else recent_events
-            )
+    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)
 
-            for event in reversed(events_to_show):  # Show newest first
-                timestamp = datetime.fromisoformat(event["timestamp"])
-                time_str = timestamp.strftime("%H:%M:%S")
-                event_type = event["event_type"]
-
-                # Format details
-                details = event.get("details", {})
-                details_str = details.get("message", "")
-                if not details_str and "error" in details:
-                    details_str = str(details["error"])
-
-                # Color code event types
-                event_style = "cyan"
-                if "error" in event_type.lower():
-                    event_style = "red"
-                elif event_type in ["started", "enabled", "registered"]:
-                    event_style = "green"
-                elif event_type in ["stopped", "disabled"]:
-                    event_style = "yellow"
-
-                table.add_row(
-                    time_str, Text(event_type, style=event_style), details_str or "-"
+            if not stats["exists"] and stats["rotated_count"] == 0:
+                emit_info(
+                    f"No logs to clear for server: {server_name}",
+                    message_group=group_id,
                 )
-            emit_info(table, 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 getting logs for server '{server_name}': {e}")
-            emit_info(f"[red]Error getting logs: {e}[/red]", message_group=group_id)
+            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

@@ -7,7 +7,7 @@ import logging
 import os
 from typing import List, Optional
 
-from code_puppy.messaging import emit_info
+from code_puppy.messaging import emit_error, emit_info
 
 from .base import MCPCommandBase
 from .utils import find_server_id_by_name, suggest_similar_servers
@@ -79,4 +79,4 @@ class RemoveCommand(MCPCommandBase):
 
         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)
+            emit_error(f"Error removing server: {e}", message_group=group_id)

code_puppy/command_line/mcp/restart_command.py

@@ -5,6 +5,8 @@ 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
@@ -65,11 +67,16 @@ class RestartCommand(MCPCommandBase):
 
                     # Reload the agent to pick up the server changes
                     try:
-                        from code_puppy.agent import get_code_generation_agent
+                        from code_puppy.agents import get_current_agent
 
-                        get_code_generation_agent(force_reload=True)
+                        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(
-                            "[dim]Agent reloaded with updated servers[/dim]",
+                            Text.from_markup(
+                                "[dim]Agent reloaded with updated servers[/dim]"
+                            ),
                             message_group=group_id,
                         )
                     except Exception as e:
@@ -88,5 +95,6 @@ class RestartCommand(MCPCommandBase):
         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
+                Text.from_markup(f"[red]Failed to restart server: {e}[/red]"),
+                message_group=group_id,
             )

code_puppy/command_line/mcp/search_command.py

@@ -6,8 +6,9 @@ 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
+from code_puppy.messaging import emit_info, emit_system_message, emit_warning
 
 from .base import MCPCommandBase
 
@@ -34,26 +35,26 @@ class SearchCommand(MCPCommandBase):
             group_id = self.generate_group_id()
 
         try:
-            from code_puppy.mcp.server_registry_catalog import catalog
+            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",
+                    "Popular MCP Servers:\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",
+                    f"Searching for: {query}\n",
                     message_group=group_id,
                 )
                 servers = catalog.search(query)
 
             if not servers:
-                emit_info(
-                    "[yellow]No servers found matching your search[/yellow]",
+                emit_warning(
+                    "No servers found matching your search",
                     message_group=group_id,
                 )
                 emit_info(
@@ -97,21 +98,26 @@ class SearchCommand(MCPCommandBase):
 
             # 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("\n✓ = Verified  ⭐ = Popular", message_group=group_id)
             emit_info(
-                "[yellow]To install:[/yellow] /mcp install <id>", message_group=group_id
+                Text.from_markup("[yellow]To install:[/yellow] /mcp install <id>"),
+                message_group=group_id,
             )
             emit_info(
-                "[yellow]For details:[/yellow] /mcp search <specific-term>",
+                Text.from_markup(
+                    "[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
+                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(
-                f"[red]Error searching servers: {e}[/red]", message_group=group_id
+                Text.from_markup(f"[red]Error searching servers: {e}[/red]"),
+                message_group=group_id,
             )

code_puppy/command_line/mcp/start_all_command.py

@@ -6,9 +6,12 @@ import logging
 import time
 from typing import List, Optional
 
-from code_puppy.mcp.managed_server import ServerState
+from rich.text import Text
+
+from code_puppy.mcp_.managed_server import ServerState
 from code_puppy.messaging import emit_info
 
+from ...agents import get_current_agent
 from .base import MCPCommandBase
 
 # Configure logging
@@ -66,20 +69,23 @@ class StartAllCommand(MCPCommandBase):
                 if success:
                     started_count += 1
                     emit_info(
-                        f"  [green]✓ Started: {server_name}[/green]",
+                        Text.from_markup(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
+                        Text.from_markup(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]",
+                    Text.from_markup(
+                        f"[green]Started {started_count} server(s)[/green]"
+                    ),
                     message_group=group_id,
                 )
             if already_running > 0:
@@ -89,7 +95,9 @@ class StartAllCommand(MCPCommandBase):
                 )
             if failed_count > 0:
                 emit_info(
-                    f"[yellow]Failed to start {failed_count} server(s)[/yellow]",
+                    Text.from_markup(
+                        f"[yellow]Failed to start {failed_count} server(s)[/yellow]"
+                    ),
                     message_group=group_id,
                 )
 
@@ -106,14 +114,14 @@ class StartAllCommand(MCPCommandBase):
                     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()
+                    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(
-                        "[dim]Agent reloaded with updated servers[/dim]",
+                        Text.from_markup(
+                            "[dim]Agent reloaded with updated servers[/dim]"
+                        ),
                         message_group=group_id,
                     )
                 except Exception as e:
@@ -122,5 +130,6 @@ class StartAllCommand(MCPCommandBase):
         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
+                Text.from_markup(f"[red]Failed to start servers: {e}[/red]"),
+                message_group=group_id,
             )

code_puppy/command_line/mcp/start_command.py

@@ -3,11 +3,13 @@ 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 rich.text import Text
 
+from code_puppy.messaging import emit_error, emit_info, emit_success
+
+from ...agents import get_current_agent
 from .base import MCPCommandBase
 from .utils import find_server_id_by_name, suggest_similar_servers
 
@@ -20,6 +22,7 @@ class StartCommand(MCPCommandBase):
     Command handler for starting MCP servers.
 
     Starts a specific MCP server by name and reloads the agent.
+    The server subprocess starts asynchronously in the background.
     """
 
     def execute(self, args: List[str], group_id: Optional[str] = None) -> None:
@@ -35,7 +38,7 @@ class StartCommand(MCPCommandBase):
 
         if not args:
             emit_info(
-                "[yellow]Usage: /mcp start <server_name>[/yellow]",
+                Text.from_markup("[yellow]Usage: /mcp start <server_name>[/yellow]"),
                 message_group=group_id,
             )
             return
@@ -46,53 +49,69 @@ class StartCommand(MCPCommandBase):
             # 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]",
+                emit_error(
+                    f"Server '{server_name}' not found",
                     message_group=group_id,
                 )
                 suggest_similar_servers(self.manager, server_name, group_id=group_id)
                 return
 
-            # Start the server (enable and start process)
+            # Get server info for better messaging (safely handle missing method)
+            server_type = "unknown"
+            try:
+                if hasattr(self.manager, "get_server_by_name"):
+                    server_config = self.manager.get_server_by_name(server_name)
+                    server_type = (
+                        getattr(server_config, "type", "unknown")
+                        if server_config
+                        else "unknown"
+                    )
+            except Exception:
+                pass  # Default to unknown type if we can't determine it
+
+            # Start the server (schedules async start in background)
             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
+                if server_type == "stdio":
+                    # Stdio servers start subprocess asynchronously
+                    emit_success(
+                        f"🚀 Starting server: {server_name} (subprocess starting in background)",
+                        message_group=group_id,
+                    )
+                    emit_info(
+                        Text.from_markup(
+                            "[dim]Tip: Use /mcp status to check if the server is fully initialized[/dim]"
+                        ),
+                        message_group=group_id,
+                    )
+                else:
+                    # SSE/HTTP servers connect on first use
+                    emit_success(
+                        f"✅ Enabled server: {server_name}",
+                        message_group=group_id,
+                    )
 
                 # Reload the agent to pick up the newly enabled server
+                # NOTE: We don't block or wait - the server will be ready
+                # when the next prompt runs (pydantic-ai handles connection)
                 try:
-                    from code_puppy.agents.runtime_manager import (
-                        get_runtime_agent_manager,
-                    )
-
-                    manager = get_runtime_agent_manager()
-                    manager.reload_agent()
+                    agent = get_current_agent()
+                    agent.reload_code_generation_agent()
+                    # Clear MCP tool cache - it will be repopulated on next run
+                    agent.update_mcp_tool_cache_sync()
                     emit_info(
-                        "[dim]Agent reloaded with updated servers[/dim]",
+                        "Agent reloaded with updated servers",
                         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]",
+                emit_error(
+                    f"Failed to start server: {server_name}",
                     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)
+            emit_error(f"Failed to start server: {e}", message_group=group_id)