code-puppy 0.0.316__py3-none-any.whl → 0.0.325__py3-none-any.whl

code_puppy/mcp_/mcp_logs.py

@@ -0,0 +1,224 @@
+"""
+MCP Server Log Management.
+
+This module provides persistent log file management for MCP servers.
+Logs are stored in STATE_DIR/mcp_logs/<server_name>.log
+"""
+
+from datetime import datetime
+from pathlib import Path
+from typing import List, Optional
+
+from code_puppy.config import STATE_DIR
+
+# Maximum log file size in bytes (5MB)
+MAX_LOG_SIZE = 5 * 1024 * 1024
+
+# Number of rotated logs to keep
+MAX_ROTATED_LOGS = 3
+
+
+def get_mcp_logs_dir() -> Path:
+    """
+    Get the directory for MCP server logs.
+
+    Creates the directory if it doesn't exist.
+
+    Returns:
+        Path to the MCP logs directory
+    """
+    logs_dir = Path(STATE_DIR) / "mcp_logs"
+    logs_dir.mkdir(parents=True, exist_ok=True)
+    return logs_dir
+
+
+def get_log_file_path(server_name: str) -> Path:
+    """
+    Get the log file path for a specific server.
+
+    Args:
+        server_name: Name of the MCP server
+
+    Returns:
+        Path to the server's log file
+    """
+    # Sanitize server name for filesystem
+    safe_name = "".join(c if c.isalnum() or c in "-_" else "_" for c in server_name)
+    return get_mcp_logs_dir() / f"{safe_name}.log"
+
+
+def rotate_log_if_needed(server_name: str) -> None:
+    """
+    Rotate log file if it exceeds MAX_LOG_SIZE.
+
+    Args:
+        server_name: Name of the MCP server
+    """
+    log_path = get_log_file_path(server_name)
+
+    if not log_path.exists():
+        return
+
+    # Check if rotation is needed
+    if log_path.stat().st_size < MAX_LOG_SIZE:
+        return
+
+    logs_dir = get_mcp_logs_dir()
+    safe_name = "".join(c if c.isalnum() or c in "-_" else "_" for c in server_name)
+
+    # Remove oldest rotated log if we're at the limit
+    oldest = logs_dir / f"{safe_name}.log.{MAX_ROTATED_LOGS}"
+    if oldest.exists():
+        oldest.unlink()
+
+    # Shift existing rotated logs
+    for i in range(MAX_ROTATED_LOGS - 1, 0, -1):
+        old_path = logs_dir / f"{safe_name}.log.{i}"
+        new_path = logs_dir / f"{safe_name}.log.{i + 1}"
+        if old_path.exists():
+            old_path.rename(new_path)
+
+    # Rotate current log
+    rotated_path = logs_dir / f"{safe_name}.log.1"
+    log_path.rename(rotated_path)
+
+
+def write_log(server_name: str, message: str, level: str = "INFO") -> None:
+    """
+    Write a log message for a server.
+
+    Args:
+        server_name: Name of the MCP server
+        message: Log message to write
+        level: Log level (INFO, ERROR, WARN, DEBUG)
+    """
+    rotate_log_if_needed(server_name)
+
+    log_path = get_log_file_path(server_name)
+    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")[:-3]
+
+    with open(log_path, "a", encoding="utf-8") as f:
+        f.write(f"[{timestamp}] [{level}] {message}\n")
+
+
+def read_logs(
+    server_name: str, lines: Optional[int] = None, include_rotated: bool = False
+) -> List[str]:
+    """
+    Read log lines for a server.
+
+    Args:
+        server_name: Name of the MCP server
+        lines: Number of lines to return (from end). None means all lines.
+        include_rotated: Whether to include rotated log files
+
+    Returns:
+        List of log lines (most recent last)
+    """
+    all_lines = []
+
+    # Read rotated logs first (oldest to newest)
+    if include_rotated:
+        logs_dir = get_mcp_logs_dir()
+        safe_name = "".join(c if c.isalnum() or c in "-_" else "_" for c in server_name)
+
+        for i in range(MAX_ROTATED_LOGS, 0, -1):
+            rotated_path = logs_dir / f"{safe_name}.log.{i}"
+            if rotated_path.exists():
+                with open(rotated_path, "r", encoding="utf-8", errors="replace") as f:
+                    all_lines.extend(f.read().splitlines())
+
+    # Read current log
+    log_path = get_log_file_path(server_name)
+    if log_path.exists():
+        with open(log_path, "r", encoding="utf-8", errors="replace") as f:
+            all_lines.extend(f.read().splitlines())
+
+    # Return requested number of lines
+    if lines is not None and lines > 0:
+        return all_lines[-lines:]
+
+    return all_lines
+
+
+def clear_logs(server_name: str, include_rotated: bool = True) -> None:
+    """
+    Clear logs for a server.
+
+    Args:
+        server_name: Name of the MCP server
+        include_rotated: Whether to also clear rotated log files
+    """
+    log_path = get_log_file_path(server_name)
+
+    if log_path.exists():
+        log_path.unlink()
+
+    if include_rotated:
+        logs_dir = get_mcp_logs_dir()
+        safe_name = "".join(c if c.isalnum() or c in "-_" else "_" for c in server_name)
+
+        for i in range(1, MAX_ROTATED_LOGS + 1):
+            rotated_path = logs_dir / f"{safe_name}.log.{i}"
+            if rotated_path.exists():
+                rotated_path.unlink()
+
+
+def list_servers_with_logs() -> List[str]:
+    """
+    List all servers that have log files.
+
+    Returns:
+        List of server names with log files
+    """
+    logs_dir = get_mcp_logs_dir()
+    servers = set()
+
+    for path in logs_dir.glob("*.log*"):
+        # Extract server name from filename
+        name = path.stem
+        # Remove .log suffix and rotation numbers
+        name = name.replace(".log", "").rstrip(".0123456789")
+        if name:
+            servers.add(name)
+
+    return sorted(servers)
+
+
+def get_log_stats(server_name: str) -> dict:
+    """
+    Get statistics about a server's logs.
+
+    Args:
+        server_name: Name of the MCP server
+
+    Returns:
+        Dictionary with log statistics
+    """
+    log_path = get_log_file_path(server_name)
+
+    stats = {
+        "exists": log_path.exists(),
+        "size_bytes": 0,
+        "line_count": 0,
+        "rotated_count": 0,
+        "total_size_bytes": 0,
+    }
+
+    if log_path.exists():
+        stats["size_bytes"] = log_path.stat().st_size
+        stats["total_size_bytes"] = stats["size_bytes"]
+        with open(log_path, "r", encoding="utf-8", errors="replace") as f:
+            stats["line_count"] = sum(1 for _ in f)
+
+    # Count rotated logs
+    logs_dir = get_mcp_logs_dir()
+    safe_name = "".join(c if c.isalnum() or c in "-_" else "_" for c in server_name)
+
+    for i in range(1, MAX_ROTATED_LOGS + 1):
+        rotated_path = logs_dir / f"{safe_name}.log.{i}"
+        if rotated_path.exists():
+            stats["rotated_count"] += 1
+            stats["total_size_bytes"] += rotated_path.stat().st_size
+
+    return stats

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/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/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:
@@ -313,9 +319,21 @@ class ModelFactory:
                 http2=http2_enabled,
             )
 
+            # Check if interleaved thinking is enabled for this model
+            # Only applies to Claude 4 models (Opus 4.5, Opus 4.1, Opus 4, Sonnet 4)
+            from code_puppy.config import get_effective_model_settings
+
+            effective_settings = get_effective_model_settings(model_name)
+            interleaved_thinking = effective_settings.get("interleaved_thinking", False)
+
+            default_headers = {}
+            if interleaved_thinking:
+                default_headers["anthropic-beta"] = "interleaved-thinking-2025-05-14"
+
             anthropic_client = AsyncAnthropic(
                 api_key=api_key,
                 http_client=client,
+                default_headers=default_headers if default_headers else None,
             )
 
             # Ensure cache_control is injected at the Anthropic SDK layer
@@ -345,10 +363,21 @@ class ModelFactory:
                 http2=http2_enabled,
             )
 
+            # Check if interleaved thinking is enabled for this model
+            from code_puppy.config import get_effective_model_settings
+
+            effective_settings = get_effective_model_settings(model_name)
+            interleaved_thinking = effective_settings.get("interleaved_thinking", False)
+
+            default_headers = {}
+            if interleaved_thinking:
+                default_headers["anthropic-beta"] = "interleaved-thinking-2025-05-14"
+
             anthropic_client = AsyncAnthropic(
                 base_url=url,
                 http_client=client,
                 api_key=api_key,
+                default_headers=default_headers if default_headers else None,
             )
 
             # Ensure cache_control is injected at the Anthropic SDK layer
@@ -364,6 +393,31 @@ class ModelFactory:
                 )
                 return None
 
+            # Check if interleaved thinking is enabled (defaults to True for OAuth models)
+            from code_puppy.config import get_effective_model_settings
+
+            effective_settings = get_effective_model_settings(model_name)
+            interleaved_thinking = effective_settings.get("interleaved_thinking", True)
+
+            # Handle anthropic-beta header based on interleaved_thinking setting
+            if "anthropic-beta" in headers:
+                beta_parts = [p.strip() for p in headers["anthropic-beta"].split(",")]
+                if interleaved_thinking:
+                    # Ensure interleaved-thinking is in the header
+                    if "interleaved-thinking-2025-05-14" not in beta_parts:
+                        beta_parts.append("interleaved-thinking-2025-05-14")
+                else:
+                    # Remove interleaved-thinking from the header
+                    beta_parts = [
+                        p for p in beta_parts if "interleaved-thinking" not in p
+                    ]
+                headers["anthropic-beta"] = ",".join(beta_parts) if beta_parts else None
+                if headers.get("anthropic-beta") is None:
+                    del headers["anthropic-beta"]
+            elif interleaved_thinking:
+                # No existing beta header, add one for interleaved thinking
+                headers["anthropic-beta"] = "interleaved-thinking-2025-05-14"
+
             # Use a dedicated client wrapper that injects cache_control on /v1/messages
             if verify is None:
                 verify = get_cert_bundle_path()

code_puppy/models.json

@@ -9,9 +9,9 @@
     "context_length": 200000,
     "supported_settings": ["temperature", "seed"]
   },
-  "synthetic-MiniMax-M2": {
+  "synthetic-MiniMax-M2.1": {
     "type": "custom_openai",
-    "name": "hf:MiniMaxAI/MiniMax-M2",
+    "name": "hf:MiniMaxAI/MiniMax-M2.1",
     "custom_endpoint": {
       "url": "https://api.synthetic.new/openai/v1/",
       "api_key": "$SYN_API_KEY"
@@ -81,7 +81,7 @@
     "type": "anthropic",
     "name": "claude-opus-4-5",
     "context_length": 200000,
-    "supported_settings": ["temperature", "extended_thinking", "budget_tokens"]
+    "supported_settings": ["temperature", "extended_thinking", "budget_tokens", "interleaved_thinking"]
   },
   "zai-glm-4.6-coding": {
     "type": "zai_coding",

code_puppy/plugins/__init__.py

@@ -18,6 +18,9 @@ def _load_builtin_plugins(plugins_dir: Path) -> list[str]:
 
     Returns list of successfully loaded plugin names.
     """
+    # Import safety permission check for shell_safety plugin
+    from code_puppy.config import get_safety_permission_level
+
     loaded = []
 
     for item in plugins_dir.iterdir():
@@ -26,6 +29,15 @@ def _load_builtin_plugins(plugins_dir: Path) -> list[str]:
             callbacks_file = item / "register_callbacks.py"
 
             if callbacks_file.exists():
+                # Skip shell_safety plugin unless safety_permission_level is "low" or "none"
+                if plugin_name == "shell_safety":
+                    safety_level = get_safety_permission_level()
+                    if safety_level not in ("none", "low"):
+                        logger.debug(
+                            f"Skipping shell_safety plugin - safety_permission_level is '{safety_level}' (needs 'low' or 'none')"
+                        )
+                        continue
+
                 try:
                     module_name = f"code_puppy.plugins.{plugin_name}.register_callbacks"
                     importlib.import_module(module_name)

code_puppy/plugins/claude_code_oauth/utils.py

@@ -368,6 +368,7 @@ def add_models_to_extra_config(models: List[str]) -> bool:
                     "temperature",
                     "extended_thinking",
                     "budget_tokens",
+                    "interleaved_thinking",
                 ],
             }
             added += 1

code_puppy/plugins/shell_safety/agent_shell_safety.py

@@ -5,13 +5,12 @@ It's designed to be ultra-lightweight with a concise prompt (<200 tokens) and
 uses structured output for reliable parsing.
 """
 
-import asyncio
 from typing import TYPE_CHECKING, List
 
 from code_puppy.agents.base_agent import BaseAgent
 
 if TYPE_CHECKING:
-    from code_puppy.tools.command_runner import ShellSafetyAssessment
+    pass
 
 
 class ShellSafetyAgent(BaseAgent):
@@ -68,119 +67,3 @@ class ShellSafetyAgent(BaseAgent):
     def get_available_tools(self) -> List[str]:
         """This agent uses no tools - pure reasoning only."""
         return []
-
-    async def assess_command(
-        self, command: str, cwd: str | None = None
-    ) -> "ShellSafetyAssessment":
-        """Assess the safety risk of a shell command.
-
-        Args:
-            command: The shell command to assess
-            cwd: Optional working directory context
-
-        Returns:
-            ShellSafetyAssessment with risk level and reasoning
-
-        Note:
-            On timeout or error, defaults to 'high' risk with error reasoning
-            to fail safe. Optionally uses DBOS for durable execution tracking.
-        """
-        import uuid
-
-        from pydantic_ai import Agent, UsageLimits
-
-        from code_puppy.config import get_use_dbos
-        from code_puppy.model_factory import ModelFactory
-        from code_puppy.tools.command_runner import ShellSafetyAssessment
-
-        try:
-            # Build the assessment prompt
-            prompt = f"Assess this shell command:\n\nCommand: {command}"
-            if cwd:
-                prompt += f"\nWorking directory: {cwd}"
-
-            # Get the current model
-            model_name = self.get_model_name()
-            models_config = ModelFactory.load_config()
-
-            if model_name not in models_config:
-                # Fall back to high risk if model config fails
-                return ShellSafetyAssessment(
-                    risk="high",
-                    reasoning="Model configuration unavailable - failing safe",
-                    is_fallback=True,
-                )
-
-            model = ModelFactory.get_model(model_name, models_config)
-
-            # Handle claude-code models: swap instructions and prepend system prompt
-            from code_puppy.model_utils import prepare_prompt_for_model
-
-            instructions = self.get_system_prompt()
-            prepared = prepare_prompt_for_model(model_name, instructions, prompt)
-            instructions = prepared.instructions
-            prompt = prepared.user_prompt
-
-            from code_puppy.model_factory import make_model_settings
-
-            model_settings = make_model_settings(model_name)
-
-            temp_agent = Agent(
-                model=model,
-                system_prompt=instructions,
-                retries=2,  # Increase from 1 to 2 for better reliability
-                output_type=ShellSafetyAssessment,
-                model_settings=model_settings,
-            )
-
-            # Generate unique agent name and workflow ID for DBOS (if enabled)
-            agent_name = f"shell-safety-{uuid.uuid4().hex[:8]}"
-            workflow_id = f"shell-safety-{uuid.uuid4().hex[:8]}"
-
-            # Wrap with DBOS if enabled (same pattern as agent_tools.py)
-            if get_use_dbos():
-                from pydantic_ai.durable_exec.dbos import DBOSAgent
-
-                dbos_agent = DBOSAgent(temp_agent, name=agent_name)
-                temp_agent = dbos_agent
-
-            # Run the agent as a cancellable task
-            # Import the shared task registry for cancellation support
-            from code_puppy.tools.agent_tools import _active_subagent_tasks
-
-            if get_use_dbos():
-                from dbos import DBOS, SetWorkflowID
-
-                with SetWorkflowID(workflow_id):
-                    task = asyncio.create_task(
-                        temp_agent.run(
-                            prompt,
-                            usage_limits=UsageLimits(request_limit=3),
-                        )
-                    )
-                    _active_subagent_tasks.add(task)
-            else:
-                task = asyncio.create_task(
-                    temp_agent.run(
-                        prompt,
-                        usage_limits=UsageLimits(request_limit=3),
-                    )
-                )
-                _active_subagent_tasks.add(task)
-
-            try:
-                result = await task
-            finally:
-                _active_subagent_tasks.discard(task)
-                if task.cancelled():
-                    if get_use_dbos():
-                        DBOS.cancel_workflow(workflow_id)
-
-            return result.output
-
-        except Exception as e:
-            return ShellSafetyAssessment(
-                risk="high",
-                reasoning=f"Safety assessment failed: {str(e)[:200]} - failing safe",
-                is_fallback=True,
-            )

code_puppy/plugins/shell_safety/register_callbacks.py

@@ -7,12 +7,42 @@ and assesses their safety risk before execution.
 from typing import Any, Dict, Optional
 
 from code_puppy.callbacks import register_callback
-from code_puppy.config import get_safety_permission_level, get_yolo_mode
+from code_puppy.config import (
+    get_global_model_name,
+    get_safety_permission_level,
+    get_yolo_mode,
+)
 from code_puppy.messaging import emit_info
 from code_puppy.plugins.shell_safety.command_cache import (
     cache_assessment,
     get_cached_assessment,
 )
+from code_puppy.tools.command_runner import ShellSafetyAssessment
+
+# OAuth model prefixes - these models have their own safety mechanisms
+OAUTH_MODEL_PREFIXES = (
+    "claude-code-",  # Anthropic OAuth
+    "chatgpt-",  # OpenAI OAuth
+    "gemini-oauth",  # Google OAuth
+)
+
+
+def is_oauth_model(model_name: str | None) -> bool:
+    """Check if the model is an OAuth model that should skip safety checks.
+
+    OAuth models have their own built-in safety mechanisms, so we skip
+    the shell safety callback to avoid redundant checks and potential bugs.
+
+    Args:
+        model_name: The name of the current model
+
+    Returns:
+        True if the model is an OAuth model, False otherwise
+    """
+    if not model_name:
+        return False
+    return model_name.startswith(OAUTH_MODEL_PREFIXES)
+
 
 # Risk level hierarchy for numeric comparison
 # Lower numbers = safer commands, higher numbers = more dangerous
@@ -68,6 +98,11 @@ async def shell_safety_callback(
         None if command is safe to proceed
         Dict with rejection info if command should be blocked
     """
+    # Skip safety checks for OAuth models - they have their own safety mechanisms
+    current_model = get_global_model_name()
+    if is_oauth_model(current_model):
+        return None
+
     # Only check safety in yolo_mode - otherwise user is reviewing manually
     yolo_mode = get_yolo_mode()
     if not yolo_mode:
@@ -108,8 +143,14 @@ async def shell_safety_callback(
         # Create agent and assess command
         agent = ShellSafetyAgent()
 
-        # Run async assessment (we're in an async callback now!)
-        assessment = await agent.assess_command(command, cwd)
+        # Build the assessment prompt with optional cwd context
+        prompt = f"Assess this shell command:\n\nCommand: {command}"
+        if cwd:
+            prompt += f"\nWorking directory: {cwd}"
+
+        # Run async assessment with structured output type
+        result = await agent.run_with_mcp(prompt, output_type=ShellSafetyAssessment)
+        assessment = result.output
 
         # Cache the result for future use, but only if it's not a fallback assessment
         if not getattr(assessment, "is_fallback", False):