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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-puppy
-Version: 0.0.315
+Version: 0.0.317
 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.317}/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(
@@ -1291,7 +1279,14 @@ class BaseAgent(ABC):
 
         from code_puppy.messaging.spinner import pause_all_spinners
 
-        console = Console()
+        # 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()
 
         # Disable Live display in test mode or non-interactive environments
         # This fixes issues with pexpect PTY where Live() hangs

{code_puppy-0.0.315 → code_puppy-0.0.317}/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.315 → code_puppy-0.0.317}/code_puppy/mcp_/blocking_startup.py

@@ -201,15 +201,23 @@ class BlockingMCPServerStdio(SimpleCapturedMCPServerStdio):
 
             return result
 
-        except Exception as e:
+        except BaseException as e:
             # Store error and mark as initialized (with error)
-            self._init_error = e
+            # Unwrap ExceptionGroup if present (Python 3.11+)
+            if type(e).__name__ == "ExceptionGroup" and hasattr(e, "exceptions"):
+                # Use the first exception as the primary cause
+                self._init_error = e.exceptions[0]
+                error_details = f"{e.exceptions[0]}"
+            else:
+                self._init_error = e
+                error_details = str(e)
+
             self._initialized.set()
 
             # Emit error message
             server_name = getattr(self, "tool_prefix", self.command)
             emit_info(
-                f"❌ MCP Server '{server_name}' failed to initialize: {e}",
+                f"❌ MCP Server '{server_name}' failed to initialize: {error_details}",
                 style="red",
                 message_group=self.message_group,
             )

{code_puppy-0.0.315 → code_puppy-0.0.317}/code_puppy/mcp_/managed_server.py

@@ -6,6 +6,7 @@ that adds management capabilities while maintaining 100% compatibility.
 """
 
 import json
+import os
 import uuid
 from dataclasses import dataclass, field
 from datetime import datetime, timedelta
@@ -222,7 +223,16 @@ class ManagedMCPServer:
                 if "read_timeout" in config:
                     http_kwargs["read_timeout"] = config["read_timeout"]
                 if "headers" in config:
-                    http_kwargs["headers"] = config.get("headers")
+                    # Expand environment variables in headers
+                    headers = config.get("headers")
+                    resolved_headers = {}
+                    if isinstance(headers, dict):
+                        for k, v in headers.items():
+                            if isinstance(v, str):
+                                resolved_headers[k] = os.path.expandvars(v)
+                            else:
+                                resolved_headers[k] = v
+                    http_kwargs["headers"] = resolved_headers
                     # Create HTTP client if headers are provided but no client specified
 
                 self._pydantic_server = MCPServerStreamableHTTP(
@@ -243,8 +253,18 @@ class ManagedMCPServer:
             Configured async HTTP client with custom headers
         """
         headers = self.config.config.get("headers", {})
+
+        # Expand environment variables in headers
+        resolved_headers = {}
+        if isinstance(headers, dict):
+            for k, v in headers.items():
+                if isinstance(v, str):
+                    resolved_headers[k] = os.path.expandvars(v)
+                else:
+                    resolved_headers[k] = v
+
         timeout = self.config.config.get("timeout", 30)
-        client = create_async_client(headers=headers, timeout=timeout)
+        client = create_async_client(headers=resolved_headers, timeout=timeout)
         return client
 
     def enable(self) -> None:

{code_puppy-0.0.315 → code_puppy-0.0.317}/code_puppy/mcp_/manager.py

@@ -78,11 +78,76 @@ class MCPManager:
         # Active managed servers (server_id -> ManagedMCPServer)
         self._managed_servers: Dict[str, ManagedMCPServer] = {}
 
+        # Sync servers from mcp_servers.json into registry
+        self.sync_from_config()
+
         # Load existing servers from registry
         self._initialize_servers()
 
         logger.info("MCPManager initialized with core components")
 
+    def sync_from_config(self) -> None:
+        """Sync servers from mcp_servers.json into the registry.
+
+        This public method ensures that servers defined in the user's
+        configuration file are automatically registered with the manager.
+        It can be called during initialization or manually to reload
+        server configurations.
+
+        This is the single source of truth for syncing mcp_servers.json
+        into the registry, avoiding duplication with base_agent.py.
+        """
+        try:
+            from code_puppy.config import load_mcp_server_configs
+
+            configs = load_mcp_server_configs()
+            if not configs:
+                logger.debug("No servers found in mcp_servers.json")
+                return
+
+            synced_count = 0
+            updated_count = 0
+
+            for name, conf in configs.items():
+                try:
+                    # Create ServerConfig from the loaded configuration
+                    server_config = ServerConfig(
+                        id=conf.get("id", ""),  # Empty ID will be auto-generated
+                        name=name,
+                        type=conf.get("type", "sse"),
+                        enabled=conf.get("enabled", True),
+                        config=conf,
+                    )
+
+                    # Check if server already exists by name
+                    existing = self.registry.get_by_name(name)
+
+                    if not existing:
+                        # Register new server
+                        self.registry.register(server_config)
+                        synced_count += 1
+                        logger.debug(f"Synced new server from config: {name}")
+                    else:
+                        # Update existing server if config has changed
+                        if existing.config != server_config.config:
+                            server_config.id = existing.id  # Keep existing ID
+                            self.registry.update(existing.id, server_config)
+                            updated_count += 1
+                            logger.debug(f"Updated server from config: {name}")
+
+                except Exception as e:
+                    logger.warning(f"Failed to sync server '{name}' from config: {e}")
+                    continue
+
+            if synced_count > 0 or updated_count > 0:
+                logger.info(
+                    f"Synced {synced_count} new and updated {updated_count} servers from mcp_servers.json"
+                )
+
+        except Exception as e:
+            logger.error(f"Failed to sync from mcp_servers.json: {e}")
+            # Don't fail initialization if sync fails
+
     def _initialize_servers(self) -> None:
         """Initialize managed servers from registry configurations."""
         configs = self.registry.list_all()

{code_puppy-0.0.315 → code_puppy-0.0.317}/code_puppy/messaging/__init__.py

@@ -29,6 +29,13 @@ Example (new):
     >>> bus.emit(TextMessage(level=MessageLevel.INFO, text="Hello"))
 """
 
+# =============================================================================
+# Apply Rich Markdown patches (left-justified headers)
+# =============================================================================
+from .markdown_patches import patch_markdown_headings
+
+patch_markdown_headings()
+
 # =============================================================================
 # Legacy API (backward compatible)
 # =============================================================================
@@ -220,4 +227,6 @@ __all__ = [
     "RichConsoleRenderer",
     "DEFAULT_STYLES",
     "DIFF_STYLES",
+    # Markdown patches
+    "patch_markdown_headings",
 ]

code_puppy-0.0.317/code_puppy/messaging/markdown_patches.py

@@ -0,0 +1,57 @@
+"""Patches for Rich's Markdown rendering.
+
+This module provides customizations to Rich's default Markdown rendering,
+particularly for header justification which is hardcoded to center in Rich.
+"""
+
+from rich import box
+from rich.markdown import Heading, Markdown
+from rich.panel import Panel
+from rich.text import Text
+
+
+class LeftJustifiedHeading(Heading):
+    """A heading that left-justifies text instead of centering.
+
+    Rich's default Heading class hardcodes `text.justify = 'center'`,
+    which can look odd in a CLI context. This subclass overrides that
+    to use left justification instead.
+    """
+
+    def __rich_console__(self, console, options):
+        """Render the heading with left justification."""
+        text = self.text
+        text.justify = "left"  # Override Rich's default 'center'
+
+        if self.tag == "h1":
+            # Draw a border around h1s (same as Rich default)
+            yield Panel(
+                text,
+                box=box.HEAVY,
+                style="markdown.h1.border",
+            )
+        else:
+            # Styled text for h2 and beyond (same as Rich default)
+            if self.tag == "h2":
+                yield Text("")
+            yield text
+
+
+_patched = False
+
+
+def patch_markdown_headings():
+    """Patch Rich's Markdown to use left-justified headings.
+
+    This function is idempotent - calling it multiple times has no effect
+    after the first call.
+    """
+    global _patched
+    if _patched:
+        return
+
+    Markdown.elements["heading_open"] = LeftJustifiedHeading
+    _patched = True
+
+
+__all__ = ["patch_markdown_headings", "LeftJustifiedHeading"]

{code_puppy-0.0.315 → code_puppy-0.0.317}/code_puppy/model_factory.py

@@ -108,6 +108,12 @@ def make_model_settings(
         # Handle Anthropic extended thinking settings
         # Remove top_p as Anthropic doesn't support it with extended thinking
         model_settings_dict.pop("top_p", None)
+
+        # Claude extended thinking requires temperature=1.0 (API restriction)
+        # Default to 1.0 if not explicitly set by user
+        if model_settings_dict.get("temperature") is None:
+            model_settings_dict["temperature"] = 1.0
+
         extended_thinking = effective_settings.get("extended_thinking", True)
         budget_tokens = effective_settings.get("budget_tokens", 10000)
         if extended_thinking and budget_tokens:

{code_puppy-0.0.315 → code_puppy-0.0.317}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "code-puppy"
-version = "0.0.315"
+version = "0.0.317"
 description = "Code generation agent"
 readme = "README.md"
 requires-python = ">=3.11,<3.14"
@@ -79,6 +79,7 @@ path = "code_puppy/models_dev_api.json"
 [tool.ruff.lint.per-file-ignores]
 "code_puppy/main.py" = ["E402"]
 "code_puppy/cli_runner.py" = ["E402"]
+"code_puppy/messaging/__init__.py" = ["E402"]
 
 [tool.pytest.ini_options]
 addopts = "--cov=code_puppy --cov-report=term-missing"