code-puppy 0.0.315__tar.gz → 0.0.320__tar.gz

{code_puppy-0.0.315 → code_puppy-0.0.320}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-puppy
-Version: 0.0.315
+Version: 0.0.320
 Summary: Code generation agent
 Project-URL: repository, https://github.com/mpfaffenberger/code_puppy
 Project-URL: HomePage, https://github.com/mpfaffenberger/code_puppy

{code_puppy-0.0.315 → code_puppy-0.0.320}/code_puppy/agents/base_agent.py

@@ -47,11 +47,10 @@ from code_puppy.config import (
     get_protected_token_count,
     get_use_dbos,
     get_value,
-    load_mcp_server_configs,
 )
 from code_puppy.error_logging import log_error
 from code_puppy.keymap import cancel_agent_uses_signal, get_cancel_agent_char_code
-from code_puppy.mcp_ import ServerConfig, get_mcp_manager
+from code_puppy.mcp_ import get_mcp_manager
 from code_puppy.messaging import (
     emit_error,
     emit_info,
@@ -90,6 +89,9 @@ class BaseAgent(ABC):
         # Cache for MCP tool definitions (for token estimation)
         # This is populated after the first successful run when MCP tools are retrieved
         self._mcp_tool_definitions_cache: List[Dict[str, Any]] = []
+        # Shared console for streaming output - should be set by cli_runner
+        # to avoid conflicts between spinner's Live display and response streaming
+        self._console: Optional[Any] = None
 
     @property
     @abstractmethod
@@ -989,45 +991,31 @@ class BaseAgent(ABC):
         return self._puppy_rules
 
     def load_mcp_servers(self, extra_headers: Optional[Dict[str, str]] = None):
-        """Load MCP servers through the manager and return pydantic-ai compatible servers."""
+        """Load MCP servers through the manager and return pydantic-ai compatible servers.
+
+        Note: The manager automatically syncs from mcp_servers.json during initialization,
+        so we don't need to sync here. Use reload_mcp_servers() to force a re-sync.
+        """
 
         mcp_disabled = get_value("disable_mcp_servers")
         if mcp_disabled and str(mcp_disabled).lower() in ("1", "true", "yes", "on"):
             return []
 
         manager = get_mcp_manager()
-        configs = load_mcp_server_configs()
-        if not configs:
-            existing_servers = manager.list_servers()
-            if not existing_servers:
-                return []
-        else:
-            for name, conf in configs.items():
-                try:
-                    server_config = ServerConfig(
-                        id=conf.get("id", f"{name}_{hash(name)}"),
-                        name=name,
-                        type=conf.get("type", "sse"),
-                        enabled=conf.get("enabled", True),
-                        config=conf,
-                    )
-                    existing = manager.get_server_by_name(name)
-                    if not existing:
-                        manager.register_server(server_config)
-                    else:
-                        if existing.config != server_config.config:
-                            manager.update_server(existing.id, server_config)
-                except Exception:
-                    continue
-
         return manager.get_servers_for_agent()
 
     def reload_mcp_servers(self):
-        """Reload MCP servers and return updated servers."""
+        """Reload MCP servers and return updated servers.
+
+        Forces a re-sync from mcp_servers.json to pick up any configuration changes.
+        """
         # Clear the MCP tool cache when servers are reloaded
         self._mcp_tool_definitions_cache = []
-        self.load_mcp_servers()
+
+        # Force re-sync from mcp_servers.json
         manager = get_mcp_manager()
+        manager.sync_from_config()
+
         return manager.get_servers_for_agent()
 
     def _load_model_with_fallback(
@@ -1279,27 +1267,22 @@ class BaseAgent(ABC):
             ctx: The run context.
             events: Async iterable of streaming events (PartStartEvent, PartDeltaEvent, etc.).
         """
-        import os
-        import time as time_module
-
         from pydantic_ai import PartDeltaEvent, PartStartEvent
         from pydantic_ai.messages import TextPartDelta, ThinkingPartDelta
         from rich.console import Console
-        from rich.live import Live
         from rich.markdown import Markdown
         from rich.markup import escape
 
         from code_puppy.messaging.spinner import pause_all_spinners
 
-        console = Console()
-
-        # Disable Live display in test mode or non-interactive environments
-        # This fixes issues with pexpect PTY where Live() hangs
-        use_live_display = (
-            console.is_terminal
-            and os.environ.get("CODE_PUPPY_TEST_FAST", "").lower() not in ("1", "true")
-            and os.environ.get("CI", "").lower() not in ("1", "true")
-        )
+        # IMPORTANT: Use the shared console (set by cli_runner) to avoid conflicts
+        # with the spinner's Live display. Multiple Console instances with separate
+        # Live displays cause cursor positioning chaos and line duplication.
+        if self._console is not None:
+            console = self._console
+        else:
+            # Fallback if console not set (shouldn't happen in normal use)
+            console = Console()
 
         # Track which part indices we're currently streaming (for Text/Thinking parts)
         streaming_parts: set[int] = set()
@@ -1308,11 +1291,9 @@ class BaseAgent(ABC):
         )  # Track which parts are thinking (for dim style)
         text_parts: set[int] = set()  # Track which parts are text
         banner_printed: set[int] = set()  # Track if banner was already printed
-        text_buffer: dict[int, list[str]] = {}  # Buffer text for markdown
-        live_displays: dict[int, Live] = {}  # Live displays for streaming markdown
+        text_buffer: dict[int, list[str]] = {}  # Buffer text for final markdown render
+        token_count: dict[int, int] = {}  # Track token count per text part
         did_stream_anything = False  # Track if we streamed any content
-        last_render_time: dict[int, float] = {}  # Track last render time per part
-        render_interval = 0.1  # Only re-render markdown every 100ms (throttle)
 
         def _print_thinking_banner() -> None:
             """Print the THINKING banner with spinner pause and line clear."""
@@ -1377,9 +1358,11 @@ class BaseAgent(ABC):
                     streaming_parts.add(event.index)
                     text_parts.add(event.index)
                     text_buffer[event.index] = []  # Initialize buffer
+                    token_count[event.index] = 0  # Initialize token counter
                     # Buffer initial content if present
                     if part.content and part.content.strip():
                         text_buffer[event.index].append(part.content)
+                        token_count[event.index] += 1
 
             # PartDeltaEvent - stream the content as it arrives
             elif isinstance(event, PartDeltaEvent):
@@ -1387,43 +1370,23 @@ class BaseAgent(ABC):
                     delta = event.delta
                     if isinstance(delta, (TextPartDelta, ThinkingPartDelta)):
                         if delta.content_delta:
-                            # For text parts, stream markdown with Live display
+                            # For text parts, show token counter then render at end
                             if event.index in text_parts:
-                                # Print banner and start Live on first content
+                                import sys
+
+                                # Print banner on first content
                                 if event.index not in banner_printed:
                                     _print_response_banner()
                                     banner_printed.add(event.index)
-                                    # Only use Live display if enabled (disabled in test/CI)
-                                    if use_live_display:
-                                        live = Live(
-                                            Markdown(""),
-                                            console=console,
-                                            refresh_per_second=10,
-                                            vertical_overflow="visible",  # Allow scrolling for long content
-                                        )
-                                        live.start()
-                                        live_displays[event.index] = live
-                                # Accumulate text and throttle markdown rendering
-                                # (Markdown parsing is O(n), doing it on every token = O(n²) death)
+                                # Accumulate text for final markdown render
                                 text_buffer[event.index].append(delta.content_delta)
-                                now = time_module.monotonic()
-                                last_render = last_render_time.get(event.index, 0)
-
-                                # Only re-render if enough time has passed (throttle)
-                                # Skip Live updates when not using live display
-                                if (
-                                    use_live_display
-                                    and now - last_render >= render_interval
-                                ):
-                                    content = "".join(text_buffer[event.index])
-                                    if event.index in live_displays:
-                                        try:
-                                            live_displays[event.index].update(
-                                                Markdown(content)
-                                            )
-                                            last_render_time[event.index] = now
-                                        except Exception:
-                                            pass
+                                token_count[event.index] += 1
+                                # Update token counter in place (single line)
+                                count = token_count[event.index]
+                                sys.stdout.write(
+                                    f"\r\x1b[K  ⏳ Receiving... {count} tokens"
+                                )
+                                sys.stdout.flush()
                             else:
                                 # For thinking parts, stream immediately (dim)
                                 if event.index not in banner_printed:
@@ -1435,36 +1398,24 @@ class BaseAgent(ABC):
             # PartEndEvent - finish the streaming with a newline
             elif isinstance(event, PartEndEvent):
                 if event.index in streaming_parts:
-                    # For text parts, do final render then stop the Live display
+                    # For text parts, clear counter line and render markdown
                     if event.index in text_parts:
-                        # Final render to ensure we show complete content
-                        # (throttling may have skipped the last few tokens)
-                        if event.index in live_displays and event.index in text_buffer:
-                            try:
-                                final_content = "".join(text_buffer[event.index])
-                                live_displays[event.index].update(
-                                    Markdown(final_content)
-                                )
-                            except Exception:
-                                pass
-                        if event.index in live_displays:
-                            try:
-                                live_displays[event.index].stop()
-                            except Exception:
-                                pass
-                            del live_displays[event.index]
-                        # When not using Live display, print the final content as markdown
-                        elif event.index in text_buffer:
+                        import sys
+
+                        # Clear the token counter line
+                        sys.stdout.write("\r\x1b[K")
+                        sys.stdout.flush()
+                        # Render the final markdown nicely
+                        if event.index in text_buffer:
                             try:
                                 final_content = "".join(text_buffer[event.index])
                                 if final_content.strip():
                                     console.print(Markdown(final_content))
                             except Exception:
                                 pass
-                        if event.index in text_buffer:
                             del text_buffer[event.index]
-                        # Clean up render time tracking
-                        last_render_time.pop(event.index, None)
+                        # Clean up token count
+                        token_count.pop(event.index, None)
                     # For thinking parts, just print newline
                     elif event.index in banner_printed:
                         console.print()  # Final newline after streaming

{code_puppy-0.0.315 → code_puppy-0.0.320}/code_puppy/cli_runner.py

@@ -706,6 +706,12 @@ async def run_prompt_with_attachments(
     attachments = [attachment.content for attachment in processed_prompt.attachments]
     link_attachments = [link.url_part for link in processed_prompt.link_attachments]
 
+    # IMPORTANT: Set the shared console on the agent so that streaming output
+    # uses the same console as the spinner. This prevents Live display conflicts
+    # that cause line duplication during markdown streaming.
+    if spinner_console is not None:
+        agent._console = spinner_console
+
     # Create the agent task first so we can track and cancel it
     agent_task = asyncio.create_task(
         agent.run_with_mcp(

code_puppy-0.0.320/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-0.0.315 → code_puppy-0.0.320}/code_puppy/command_line/model_settings_menu.py

@@ -84,6 +84,12 @@ SETTING_DEFINITIONS: Dict[str, Dict] = {
         "default": 10000,
         "format": "{:.0f}",
     },
+    "interleaved_thinking": {
+        "name": "Interleaved Thinking",
+        "description": "Enable thinking between tool calls (Claude 4 only: Opus 4.5, Opus 4.1, Opus 4, Sonnet 4). Adds beta header. WARNING: On Vertex/Bedrock, this FAILS for non-Claude 4 models!",
+        "type": "boolean",
+        "default": False,
+    },
 }
 
 

{code_puppy-0.0.315 → code_puppy-0.0.320}/code_puppy/mcp_/__init__.py

@@ -17,6 +17,15 @@ from .error_isolation import (
 )
 from .managed_server import ManagedMCPServer, ServerConfig, ServerState
 from .manager import MCPManager, ServerInfo, get_mcp_manager
+from .mcp_logs import (
+    clear_logs,
+    get_log_file_path,
+    get_log_stats,
+    get_mcp_logs_dir,
+    list_servers_with_logs,
+    read_logs,
+    write_log,
+)
 from .registry import ServerRegistry
 from .retry_manager import RetryManager, RetryStats, get_retry_manager, retry_mcp_call
 from .status_tracker import Event, ServerStatusTracker
@@ -46,4 +55,12 @@ __all__ = [
     "MCPDashboard",
     "MCPConfigWizard",
     "run_add_wizard",
+    # Log management
+    "get_mcp_logs_dir",
+    "get_log_file_path",
+    "read_logs",
+    "write_log",
+    "clear_logs",
+    "list_servers_with_logs",
+    "get_log_stats",
 ]