code-puppy 0.0.339__tar.gz → 0.0.341__tar.gz

{code_puppy-0.0.339 → code_puppy-0.0.341}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-puppy
-Version: 0.0.339
+Version: 0.0.341
 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.339 → code_puppy-0.0.341}/code_puppy/agents/base_agent.py

@@ -913,6 +913,11 @@ class BaseAgent(ABC):
         """
         Truncate message history to manage token usage.
 
+        Protects:
+        - The first message (system prompt) - always kept
+        - The second message if it contains a ThinkingPart (extended thinking context)
+        - The most recent messages up to protected_tokens
+
         Args:
             messages: List of messages to truncate
             protected_tokens: Number of tokens to protect
@@ -924,12 +929,30 @@ class BaseAgent(ABC):
 
         emit_info("Truncating message history to manage token usage")
         result = [messages[0]]  # Always keep the first message (system prompt)
+
+        # Check if second message exists and contains a ThinkingPart
+        # If so, protect it (extended thinking context shouldn't be lost)
+        skip_second = False
+        if len(messages) > 1:
+            second_msg = messages[1]
+            has_thinking = any(
+                isinstance(part, ThinkingPart) for part in second_msg.parts
+            )
+            if has_thinking:
+                result.append(second_msg)
+                skip_second = True
+
         num_tokens = 0
         stack = queue.LifoQueue()
 
+        # Determine which messages to consider for the recent-tokens window
+        # Skip first message (already added), and skip second if it has thinking
+        start_idx = 2 if skip_second else 1
+        messages_to_scan = messages[start_idx:]
+
         # Put messages in reverse order (most recent first) into the stack
         # but break when we exceed protected_tokens
-        for idx, msg in enumerate(reversed(messages[1:])):  # Skip the first message
+        for msg in reversed(messages_to_scan):
             num_tokens += self.estimate_tokens_for_message(msg)
             if num_tokens > protected_tokens:
                 break

code_puppy-0.0.341/code_puppy/claude_cache_client.py

@@ -0,0 +1,371 @@
+"""Cache helpers for Claude Code / Anthropic.
+
+ClaudeCacheAsyncClient: httpx client that tries to patch /v1/messages bodies.
+
+We now also expose `patch_anthropic_client_messages` which monkey-patches
+AsyncAnthropic.messages.create() so we can inject cache_control BEFORE
+serialization, avoiding httpx/Pydantic internals.
+"""
+
+from __future__ import annotations
+
+import base64
+import json
+import logging
+import time
+from typing import Any, Callable, MutableMapping
+
+import httpx
+
+logger = logging.getLogger(__name__)
+
+# Refresh token if it's older than 1 hour (3600 seconds)
+TOKEN_MAX_AGE_SECONDS = 3600
+
+try:
+    from anthropic import AsyncAnthropic
+except ImportError:  # pragma: no cover - optional dep
+    AsyncAnthropic = None  # type: ignore
+
+
+class ClaudeCacheAsyncClient(httpx.AsyncClient):
+    def _get_jwt_age_seconds(self, token: str | None) -> float | None:
+        """Decode a JWT and return its age in seconds.
+
+        Returns None if the token can't be decoded or has no timestamp claims.
+        Uses 'iat' (issued at) if available, otherwise calculates from 'exp'.
+        """
+        if not token:
+            return None
+
+        try:
+            # JWT format: header.payload.signature
+            # We only need the payload (second part)
+            parts = token.split(".")
+            if len(parts) != 3:
+                return None
+
+            # Decode the payload (base64url encoded)
+            payload_b64 = parts[1]
+            # Add padding if needed (base64url doesn't require padding)
+            padding = 4 - len(payload_b64) % 4
+            if padding != 4:
+                payload_b64 += "=" * padding
+
+            payload_bytes = base64.urlsafe_b64decode(payload_b64)
+            payload = json.loads(payload_bytes.decode("utf-8"))
+
+            now = time.time()
+
+            # Prefer 'iat' (issued at) claim if available
+            if "iat" in payload:
+                iat = float(payload["iat"])
+                age = now - iat
+                return age
+
+            # Fall back to calculating from 'exp' claim
+            # Assume tokens are typically valid for 1 hour
+            if "exp" in payload:
+                exp = float(payload["exp"])
+                # If exp is in the future, calculate how long until expiry
+                # and assume the token was issued 1 hour before expiry
+                time_until_exp = exp - now
+                # If token has less than 1 hour left, it's "old"
+                age = TOKEN_MAX_AGE_SECONDS - time_until_exp
+                return max(0, age)
+
+            return None
+        except Exception as exc:
+            logger.debug("Failed to decode JWT age: %s", exc)
+            return None
+
+    def _extract_bearer_token(self, request: httpx.Request) -> str | None:
+        """Extract the bearer token from request headers."""
+        auth_header = request.headers.get("Authorization") or request.headers.get(
+            "authorization"
+        )
+        if auth_header and auth_header.lower().startswith("bearer "):
+            return auth_header[7:]  # Strip "Bearer " prefix
+        return None
+
+    def _should_refresh_token(self, request: httpx.Request) -> bool:
+        """Check if the token in the request is older than 1 hour."""
+        token = self._extract_bearer_token(request)
+        if not token:
+            return False
+
+        age = self._get_jwt_age_seconds(token)
+        if age is None:
+            return False
+
+        should_refresh = age >= TOKEN_MAX_AGE_SECONDS
+        if should_refresh:
+            logger.info(
+                "JWT token is %.1f seconds old (>= %d), will refresh proactively",
+                age,
+                TOKEN_MAX_AGE_SECONDS,
+            )
+        return should_refresh
+
+    async def send(
+        self, request: httpx.Request, *args: Any, **kwargs: Any
+    ) -> httpx.Response:  # type: ignore[override]
+        # Proactive token refresh: check JWT age before every request
+        if not request.extensions.get("claude_oauth_refresh_attempted"):
+            try:
+                if self._should_refresh_token(request):
+                    refreshed_token = self._refresh_claude_oauth_token()
+                    if refreshed_token:
+                        logger.info("Proactively refreshed token before request")
+                        # Rebuild request with new token
+                        headers = dict(request.headers)
+                        self._update_auth_headers(headers, refreshed_token)
+                        body_bytes = self._extract_body_bytes(request)
+                        request = self.build_request(
+                            method=request.method,
+                            url=request.url,
+                            headers=headers,
+                            content=body_bytes,
+                        )
+                        request.extensions["claude_oauth_refresh_attempted"] = True
+            except Exception as exc:
+                logger.debug("Error during proactive token refresh check: %s", exc)
+
+        try:
+            if request.url.path.endswith("/v1/messages"):
+                body_bytes = self._extract_body_bytes(request)
+                if body_bytes:
+                    updated = self._inject_cache_control(body_bytes)
+                    if updated is not None:
+                        # Rebuild a request with the updated body and transplant internals
+                        try:
+                            rebuilt = self.build_request(
+                                method=request.method,
+                                url=request.url,
+                                headers=request.headers,
+                                content=updated,
+                            )
+
+                            # Copy core internals so httpx uses the modified body/stream
+                            if hasattr(rebuilt, "_content"):
+                                setattr(request, "_content", rebuilt._content)  # type: ignore[attr-defined]
+                            if hasattr(rebuilt, "stream"):
+                                request.stream = rebuilt.stream
+                            if hasattr(rebuilt, "extensions"):
+                                request.extensions = rebuilt.extensions
+
+                            # Ensure Content-Length matches the new body
+                            request.headers["Content-Length"] = str(len(updated))
+
+                        except Exception:
+                            # Swallow instrumentation errors; do not break real calls.
+                            pass
+        except Exception:
+            # Swallow wrapper errors; do not break real calls.
+            pass
+        response = await super().send(request, *args, **kwargs)
+        try:
+            # Check for both 401 and 400 - Anthropic/Cloudflare may return 400 for auth errors
+            # Also check if it's a Cloudflare HTML error response
+            if response.status_code in (400, 401) and not request.extensions.get(
+                "claude_oauth_refresh_attempted"
+            ):
+                # Determine if this is an auth error (including Cloudflare HTML errors)
+                is_auth_error = response.status_code == 401
+
+                if response.status_code == 400:
+                    # Check if this is a Cloudflare HTML error
+                    is_auth_error = self._is_cloudflare_html_error(response)
+                    if is_auth_error:
+                        logger.info(
+                            "Detected Cloudflare 400 error (likely auth-related), attempting token refresh"
+                        )
+
+                if is_auth_error:
+                    refreshed_token = self._refresh_claude_oauth_token()
+                    if refreshed_token:
+                        logger.info("Token refreshed successfully, retrying request")
+                        await response.aclose()
+                        body_bytes = self._extract_body_bytes(request)
+                        headers = dict(request.headers)
+                        self._update_auth_headers(headers, refreshed_token)
+                        retry_request = self.build_request(
+                            method=request.method,
+                            url=request.url,
+                            headers=headers,
+                            content=body_bytes,
+                        )
+                        retry_request.extensions["claude_oauth_refresh_attempted"] = (
+                            True
+                        )
+                        return await super().send(retry_request, *args, **kwargs)
+                    else:
+                        logger.warning("Token refresh failed, returning original error")
+        except Exception as exc:
+            logger.debug("Error during token refresh attempt: %s", exc)
+        return response
+
+    @staticmethod
+    def _extract_body_bytes(request: httpx.Request) -> bytes | None:
+        # Try public content first
+        try:
+            content = request.content
+            if content:
+                return content
+        except Exception:
+            pass
+
+        # Fallback to private attr if necessary
+        try:
+            content = getattr(request, "_content", None)
+            if content:
+                return content
+        except Exception:
+            pass
+
+        return None
+
+    @staticmethod
+    def _update_auth_headers(
+        headers: MutableMapping[str, str], access_token: str
+    ) -> None:
+        bearer_value = f"Bearer {access_token}"
+        if "Authorization" in headers or "authorization" in headers:
+            headers["Authorization"] = bearer_value
+        elif "x-api-key" in headers or "X-API-Key" in headers:
+            headers["x-api-key"] = access_token
+        else:
+            headers["Authorization"] = bearer_value
+
+    @staticmethod
+    def _is_cloudflare_html_error(response: httpx.Response) -> bool:
+        """Check if this is a Cloudflare HTML error response.
+
+        Cloudflare often returns HTML error pages with status 400 when
+        there are authentication issues.
+        """
+        # Check content type
+        content_type = response.headers.get("content-type", "")
+        if "text/html" not in content_type.lower():
+            return False
+
+        # Check if body contains Cloudflare markers
+        try:
+            # Read response body if not already consumed
+            if hasattr(response, "_content") and response._content:
+                body = response._content.decode("utf-8", errors="ignore")
+            else:
+                # Try to read the text (this might be already consumed)
+                try:
+                    body = response.text
+                except Exception:
+                    return False
+
+            # Look for Cloudflare and 400 Bad Request markers
+            body_lower = body.lower()
+            return "cloudflare" in body_lower and "400 bad request" in body_lower
+        except Exception as exc:
+            logger.debug("Error checking for Cloudflare error: %s", exc)
+            return False
+
+    def _refresh_claude_oauth_token(self) -> str | None:
+        try:
+            from code_puppy.plugins.claude_code_oauth.utils import refresh_access_token
+
+            logger.info("Attempting to refresh Claude Code OAuth token...")
+            refreshed_token = refresh_access_token(force=True)
+            if refreshed_token:
+                self._update_auth_headers(self.headers, refreshed_token)
+                logger.info("Successfully refreshed Claude Code OAuth token")
+            else:
+                logger.warning("Token refresh returned None")
+            return refreshed_token
+        except Exception as exc:
+            logger.error("Exception during token refresh: %s", exc)
+            return None
+
+    @staticmethod
+    def _inject_cache_control(body: bytes) -> bytes | None:
+        try:
+            data = json.loads(body.decode("utf-8"))
+        except Exception:
+            return None
+
+        if not isinstance(data, dict):
+            return None
+
+        modified = False
+
+        # Minimal, deterministic strategy:
+        # Add cache_control only on the single most recent block:
+        # the last dict content block of the last message (if any).
+        messages = data.get("messages")
+        if isinstance(messages, list) and messages:
+            last = messages[-1]
+            if isinstance(last, dict):
+                content = last.get("content")
+                if isinstance(content, list) and content:
+                    last_block = content[-1]
+                    if (
+                        isinstance(last_block, dict)
+                        and "cache_control" not in last_block
+                    ):
+                        last_block["cache_control"] = {"type": "ephemeral"}
+                        modified = True
+
+        if not modified:
+            return None
+
+        return json.dumps(data).encode("utf-8")
+
+
+def _inject_cache_control_in_payload(payload: dict[str, Any]) -> None:
+    """In-place cache_control injection on Anthropic messages.create payload."""
+
+    messages = payload.get("messages")
+    if isinstance(messages, list) and messages:
+        last = messages[-1]
+        if isinstance(last, dict):
+            content = last.get("content")
+            if isinstance(content, list) and content:
+                last_block = content[-1]
+                if isinstance(last_block, dict) and "cache_control" not in last_block:
+                    last_block["cache_control"] = {"type": "ephemeral"}
+
+    # No extra markers in production mode; keep payload clean.
+    # (Function kept for potential future use.)
+    return
+
+
+def patch_anthropic_client_messages(client: Any) -> None:
+    """Monkey-patch AsyncAnthropic.messages.create to inject cache_control.
+
+    This operates at the highest level: just before Anthropic SDK serializes
+    the request into HTTP. That means no httpx / Pydantic shenanigans can
+    undo it.
+    """
+
+    if AsyncAnthropic is None or not isinstance(client, AsyncAnthropic):  # type: ignore[arg-type]
+        return
+
+    try:
+        messages_obj = getattr(client, "messages", None)
+        if messages_obj is None:
+            return
+        original_create: Callable[..., Any] = messages_obj.create
+    except Exception:  # pragma: no cover - defensive
+        return
+
+    async def wrapped_create(*args: Any, **kwargs: Any):
+        # Anthropic messages.create takes a mix of positional/kw args.
+        # The payload is usually in kwargs for the Python SDK.
+        if kwargs:
+            _inject_cache_control_in_payload(kwargs)
+        elif args:
+            maybe_payload = args[-1]
+            if isinstance(maybe_payload, dict):
+                _inject_cache_control_in_payload(maybe_payload)
+
+        return await original_create(*args, **kwargs)
+
+    messages_obj.create = wrapped_create  # type: ignore[assignment]

{code_puppy-0.0.339 → code_puppy-0.0.341}/code_puppy/cli_runner.py

@@ -144,8 +144,8 @@ async def main():
         except ImportError:
             emit_system_message("🐶 Code Puppy is Loading...")
 
-        # Check for truecolor support and warn if not available
-        print_truecolor_warning(display_console)
+        # Truecolor warning moved to interactive_mode() so it prints LAST
+        # after all the help stuff - max visibility for the ugly red box!
 
     available_port = find_available_port()
     if available_port is None:
@@ -382,6 +382,10 @@ async def interactive_mode(message_renderer, initial_command: str = None) -> Non
 
         emit_warning(f"MOTD error: {e}")
 
+    # Print truecolor warning LAST so it's the most visible thing on startup
+    # Big ugly red box should be impossible to miss! 🔴
+    print_truecolor_warning(display_console)
+
     # Initialize the runtime agent manager
     if initial_command:
         from code_puppy.agents import get_current_agent

{code_puppy-0.0.339 → code_puppy-0.0.341}/code_puppy/command_line/autosave_menu.py

@@ -69,12 +69,21 @@ def _get_session_entries(base_dir: Path) -> List[Tuple[str, dict]]:
 
 
 def _extract_last_user_message(history: list) -> str:
-    """Extract the most recent user message from history."""
+    """Extract the most recent user message from history.
+
+    Joins all content parts from the message since messages can have
+    multiple parts (e.g., text + attachments, multi-part prompts).
+    """
     # Walk backwards through history to find last user message
     for msg in reversed(history):
+        content_parts = []
         for part in msg.parts:
             if hasattr(part, "content"):
-                return part.content
+                content = part.content
+                if isinstance(content, str) and content.strip():
+                    content_parts.append(content)
+        if content_parts:
+            return "\n\n".join(content_parts)
     return "[No messages found]"
 
 
@@ -298,19 +307,13 @@ def _render_message_browser_panel(
             # Don't override Rich's ANSI styling - use empty style
             text_color = ""
 
-        # Truncate if too long (max 35 lines)
-        message_lines = rendered.split("\n")[:35]
-        is_truncated = len(rendered.split("\n")) > 35
+        # Show full message without truncation
+        message_lines = rendered.split("\n")
 
         for line in message_lines:
             lines.append((text_color, f"  {line}"))
             lines.append(("", "\n"))
 
-        if is_truncated:
-            lines.append(("", "\n"))
-            lines.append(("fg:yellow", "  ... truncated (message too long)"))
-            lines.append(("", "\n"))
-
     except Exception as e:
         lines.append(("fg:red", f"  Error rendering message: {e}"))
         lines.append(("", "\n"))
@@ -359,7 +362,7 @@ def _render_preview_panel(base_dir: Path, entry: Optional[Tuple[str, dict]]) ->
     lines.append(("", "\n\n"))
 
     lines.append(("bold", "  Last Message:"))
-    lines.append(("fg:ansibrightblack", "  (press 'e' to browse all)"))
+    lines.append(("fg:ansibrightblack", "  (press 'e' to browse full history)"))
     lines.append(("", "\n"))
 
     # Try to load and preview the last message
@@ -367,15 +370,11 @@ def _render_preview_panel(base_dir: Path, entry: Optional[Tuple[str, dict]]) ->
         history = load_session(session_name, base_dir)
         last_message = _extract_last_user_message(history)
 
-        # Check if original message is long (before Rich processing)
-        original_lines = last_message.split("\n") if last_message else []
-        is_long = len(original_lines) > 30
-
-        # Render markdown with rich but strip ANSI codes
+        # Render markdown with rich
         console = Console(
             file=StringIO(),
             legacy_windows=False,
-            no_color=False,  # Disable ANSI color codes
+            no_color=False,
             force_terminal=False,
             width=76,
         )
@@ -383,19 +382,14 @@ def _render_preview_panel(base_dir: Path, entry: Optional[Tuple[str, dict]]) ->
         console.print(md)
         rendered = console.file.getvalue()
 
-        # Truncate if too long (max 30 lines for bigger preview)
-        message_lines = rendered.split("\n")[:30]
+        # Show full message without truncation
+        message_lines = rendered.split("\n")
 
         for line in message_lines:
             # Rich already rendered the markdown, just display it dimmed
             lines.append(("fg:ansibrightblack", f"  {line}"))
             lines.append(("", "\n"))
 
-        if is_long:
-            lines.append(("", "\n"))
-            lines.append(("fg:yellow", "  ... truncated"))
-            lines.append(("", "\n"))
-
     except Exception as e:
         lines.append(("fg:red", f"  Error loading preview: {e}"))
         lines.append(("", "\n"))

{code_puppy-0.0.339 → code_puppy-0.0.341}/code_puppy/command_line/prompt_toolkit_completion.py

@@ -29,7 +29,6 @@ from code_puppy.command_line.attachments import (
 )
 from code_puppy.command_line.clipboard import (
     capture_clipboard_image_to_pending,
-    get_clipboard_manager,
     has_image_in_clipboard,
 )
 from code_puppy.command_line.command_registry import get_unique_commands
@@ -663,16 +662,18 @@ async def get_input_with_combined_completion(
                 placeholder = capture_clipboard_image_to_pending()
                 if placeholder:
                     event.app.current_buffer.insert_text(placeholder + " ")
-                    count = get_clipboard_manager().get_pending_count()
-                    sys.stdout.write(f"\033[36m📋 +image ({count})\033[0m ")
-                    sys.stdout.flush()
+                    # The placeholder itself is visible feedback - no need for extra output
+                    # Use bell for audible feedback (works in most terminals)
+                    event.app.output.bell()
                     return  # Don't also paste the text data
         except Exception:
             pass
 
-        # No image - insert the pasted text as normal
+        # No image - insert the pasted text as normal, sanitizing Windows newlines
         if pasted_data:
-            event.app.current_buffer.insert_text(pasted_data)
+            # Normalize Windows line endings to Unix style
+            sanitized_data = pasted_data.replace("\r\n", "\n").replace("\r", "\n")
+            event.app.current_buffer.insert_text(sanitized_data)
 
     # Fallback Ctrl+V for terminals without bracketed paste support
     @bindings.add("c-v", eager=True)
@@ -684,9 +685,9 @@ async def get_input_with_combined_completion(
                 placeholder = capture_clipboard_image_to_pending()
                 if placeholder:
                     event.app.current_buffer.insert_text(placeholder + " ")
-                    count = get_clipboard_manager().get_pending_count()
-                    sys.stdout.write(f"\033[36m📋 +image ({count})\033[0m ")
-                    sys.stdout.flush()
+                    # The placeholder itself is visible feedback - no need for extra output
+                    # Use bell for audible feedback (works in most terminals)
+                    event.app.output.bell()
                     return  # Don't also paste text
         except Exception:
             pass  # Fall through to text paste on any error
@@ -715,7 +716,7 @@ async def get_input_with_combined_completion(
                     timeout=2,
                 )
                 if result.returncode == 0:
-                    text = result.stdout.rstrip("\r\n")
+                    text = result.stdout
             else:  # Linux
                 # Try xclip first, then xsel
                 for cmd in [
@@ -733,6 +734,10 @@ async def get_input_with_combined_completion(
                         continue
 
             if text:
+                # Normalize Windows line endings to Unix style
+                text = text.replace("\r\n", "\n").replace("\r", "\n")
+                # Strip trailing newline that clipboard tools often add
+                text = text.rstrip("\n")
                 event.app.current_buffer.insert_text(text)
         except Exception:
             pass  # Silently fail if text paste doesn't work
@@ -746,15 +751,16 @@ async def get_input_with_combined_completion(
                 placeholder = capture_clipboard_image_to_pending()
                 if placeholder:
                     event.app.current_buffer.insert_text(placeholder + " ")
-                    count = get_clipboard_manager().get_pending_count()
-                    sys.stdout.write(f"\033[36m📋 +image ({count})\033[0m ")
-                    sys.stdout.flush()
+                    # The placeholder itself is visible feedback
+                    # Use bell for audible feedback (works in most terminals)
+                    event.app.output.bell()
             else:
-                sys.stdout.write("\033[33m⚠️ no image\033[0m ")
-                sys.stdout.flush()
+                # Insert a transient message that user can delete
+                event.app.current_buffer.insert_text("[⚠️ no image in clipboard] ")
+                event.app.output.bell()
         except Exception:
-            sys.stdout.write("\033[31m❌ clipboard error\033[0m ")
-            sys.stdout.flush()
+            event.app.current_buffer.insert_text("[❌ clipboard error] ")
+            event.app.output.bell()
 
     session = PromptSession(
         completer=completer,

{code_puppy-0.0.339 → code_puppy-0.0.341}/code_puppy/mcp_/managed_server.py

@@ -222,18 +222,14 @@ class ManagedMCPServer:
                     http_kwargs["timeout"] = config["timeout"]
                 if "read_timeout" in config:
                     http_kwargs["read_timeout"] = config["read_timeout"]
-                if "headers" in config:
-                    # 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
+
+                # Handle http_client vs headers (mutually exclusive)
+                if "http_client" in config:
+                    # Use provided http_client
+                    http_kwargs["http_client"] = config["http_client"]
+                elif config.get("headers"):
                     # Create HTTP client if headers are provided but no client specified
+                    http_kwargs["http_client"] = self._get_http_client()
 
                 self._pydantic_server = MCPServerStreamableHTTP(
                     **http_kwargs, process_tool_call=process_tool_call

{code_puppy-0.0.339 → code_puppy-0.0.341}/code_puppy/tools/common.py

@@ -727,15 +727,9 @@ def _format_diff_with_syntax_highlighting(
                 result.append("\n")
             continue
 
-        # Handle diff headers specially
-        if line.startswith("---"):
-            result.append(line, style="yellow")
-        elif line.startswith("+++"):
-            result.append(line, style="yellow")
-        elif line.startswith("@@"):
-            result.append(line, style="cyan")
-        elif line.startswith(("diff ", "index ")):
-            result.append(line, style="dim")
+        # Skip diff headers - they're redundant noise since we show the filename in the banner
+        if line.startswith(("---", "+++", "@@", "diff ", "index ")):
+            continue
         else:
             # Determine line type and extract code content
             if line.startswith("-"):