code-puppy 0.0.337__py3-none-any.whl → 0.0.339__py3-none-any.whl

code_puppy/agents/base_agent.py

@@ -1353,7 +1353,6 @@ class BaseAgent(ABC):
             ToolCallPartDelta,
         )
         from rich.console import Console
-        from rich.markdown import Markdown
         from rich.markup import escape
 
         from code_puppy.messaging.spinner import pause_all_spinners
@@ -1375,10 +1374,17 @@ class BaseAgent(ABC):
         text_parts: set[int] = set()  # Track which parts are text
         tool_parts: set[int] = set()  # Track which parts are tool calls
         banner_printed: set[int] = set()  # Track if banner was already printed
-        text_buffer: dict[int, list[str]] = {}  # Buffer text for final markdown render
         token_count: dict[int, int] = {}  # Track token count per text/tool part
         did_stream_anything = False  # Track if we streamed any content
 
+        # Termflow streaming state for text parts
+        from termflow import Parser as TermflowParser
+        from termflow import Renderer as TermflowRenderer
+
+        termflow_parsers: dict[int, TermflowParser] = {}
+        termflow_renderers: dict[int, TermflowRenderer] = {}
+        termflow_line_buffers: dict[int, str] = {}  # Buffer incomplete lines
+
         def _print_thinking_banner() -> None:
             """Print the THINKING banner with spinner pause and line clear."""
             nonlocal did_stream_anything
@@ -1437,13 +1443,17 @@ class BaseAgent(ABC):
                 elif isinstance(part, TextPart):
                     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
+                    # Initialize termflow streaming for this text part
+                    termflow_parsers[event.index] = TermflowParser()
+                    termflow_renderers[event.index] = TermflowRenderer(
+                        output=console.file, width=console.width
+                    )
+                    termflow_line_buffers[event.index] = ""
+                    # Handle initial content if present
                     if part.content and part.content.strip():
-                        text_buffer[event.index].append(part.content)
-                        # Count chunks (each part counts as 1)
-                        token_count[event.index] += 1
+                        _print_response_banner()
+                        banner_printed.add(event.index)
+                        termflow_line_buffers[event.index] = part.content
                 elif isinstance(part, ToolCallPart):
                     streaming_parts.add(event.index)
                     tool_parts.add(event.index)
@@ -1459,22 +1469,29 @@ class BaseAgent(ABC):
                     delta = event.delta
                     if isinstance(delta, (TextPartDelta, ThinkingPartDelta)):
                         if delta.content_delta:
-                            # For text parts, show token counter then render at end
+                            # For text parts, stream markdown with termflow
                             if event.index in text_parts:
                                 # Print banner on first content
                                 if event.index not in banner_printed:
                                     _print_response_banner()
                                     banner_printed.add(event.index)
-                                # Accumulate text for final markdown render
-                                text_buffer[event.index].append(delta.content_delta)
-                                # Count chunks received
-                                token_count[event.index] += 1
-                                # Update chunk counter in place (single line)
-                                count = token_count[event.index]
-                                console.print(
-                                    f"  ⏳ Receiving... {count} chunks   ",
-                                    end="\r",
+
+                                # Add content to line buffer
+                                termflow_line_buffers[event.index] += (
+                                    delta.content_delta
                                 )
+
+                                # Process complete lines
+                                parser = termflow_parsers[event.index]
+                                renderer = termflow_renderers[event.index]
+                                buffer = termflow_line_buffers[event.index]
+
+                                while "\n" in buffer:
+                                    line, buffer = buffer.split("\n", 1)
+                                    events_to_render = parser.parse_line(line)
+                                    renderer.render_all(events_to_render)
+
+                                termflow_line_buffers[event.index] = buffer
                             else:
                                 # For thinking parts, stream immediately (dim)
                                 if event.index not in banner_printed:
@@ -1503,19 +1520,27 @@ class BaseAgent(ABC):
             # PartEndEvent - finish the streaming with a newline
             elif isinstance(event, PartEndEvent):
                 if event.index in streaming_parts:
-                    # For text parts, clear counter line and render markdown
+                    # For text parts, finalize termflow rendering
                     if event.index in text_parts:
-                        # Clear the chunk counter line by printing spaces and returning
-                        console.print(" " * 50, end="\r")
-                        # 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
-                            del text_buffer[event.index]
+                        # Render any remaining buffered content
+                        if event.index in termflow_parsers:
+                            parser = termflow_parsers[event.index]
+                            renderer = termflow_renderers[event.index]
+                            remaining = termflow_line_buffers.get(event.index, "")
+
+                            # Parse and render any remaining partial line
+                            if remaining.strip():
+                                events_to_render = parser.parse_line(remaining)
+                                renderer.render_all(events_to_render)
+
+                            # Finalize the parser to close any open blocks
+                            final_events = parser.finalize()
+                            renderer.render_all(final_events)
+
+                            # Clean up termflow state
+                            del termflow_parsers[event.index]
+                            del termflow_renderers[event.index]
+                            del termflow_line_buffers[event.index]
                     # For tool parts, clear the chunk counter line
                     elif event.index in tool_parts:
                         # Clear the chunk counter line by printing spaces and returning

code_puppy/claude_cache_client.py

@@ -10,7 +10,7 @@ serialization, avoiding httpx/Pydantic internals.
 from __future__ import annotations
 
 import json
-from typing import Any, Callable
+from typing import Any, Callable, MutableMapping
 
 import httpx
 
@@ -56,7 +56,28 @@ class ClaudeCacheAsyncClient(httpx.AsyncClient):
         except Exception:
             # Swallow wrapper errors; do not break real calls.
             pass
-        return await super().send(request, *args, **kwargs)
+        response = await super().send(request, *args, **kwargs)
+        try:
+            if response.status_code == 401 and not request.extensions.get(
+                "claude_oauth_refresh_attempted"
+            ):
+                refreshed_token = self._refresh_claude_oauth_token()
+                if refreshed_token:
+                    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)
+        except Exception:
+            pass
+        return response
 
     @staticmethod
     def _extract_body_bytes(request: httpx.Request) -> bytes | None:
@@ -78,6 +99,29 @@ class ClaudeCacheAsyncClient(httpx.AsyncClient):
 
         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
+
+    def _refresh_claude_oauth_token(self) -> str | None:
+        try:
+            from code_puppy.plugins.claude_code_oauth.utils import refresh_access_token
+
+            refreshed_token = refresh_access_token(force=True)
+            if refreshed_token:
+                self._update_auth_headers(self.headers, refreshed_token)
+            return refreshed_token
+        except Exception:
+            return None
+
     @staticmethod
     def _inject_cache_control(body: bytes) -> bytes | None:
         try:

code_puppy/cli_runner.py

@@ -17,14 +17,12 @@ import traceback
 from pathlib import Path
 
 from dbos import DBOS, DBOSConfig
-from rich.console import Console, ConsoleOptions, RenderResult
-from rich.markdown import CodeBlock, Markdown
-from rich.syntax import Syntax
-from rich.text import Text
+from rich.console import Console
 
 from code_puppy import __version__, callbacks, plugins
 from code_puppy.agents import get_current_agent
 from code_puppy.command_line.attachments import parse_prompt_attachments
+from code_puppy.command_line.clipboard import get_clipboard_manager
 from code_puppy.config import (
     AUTOSAVE_DIR,
     COMMAND_HISTORY_FILE,
@@ -43,6 +41,7 @@ from code_puppy.keymap import (
 )
 from code_puppy.messaging import emit_info
 from code_puppy.terminal_utils import (
+    print_truecolor_warning,
     reset_unix_terminal,
     reset_windows_terminal_ansi,
     reset_windows_terminal_full,
@@ -91,7 +90,6 @@ async def main():
         "command", nargs="*", help="Run a single command (deprecated, use -p instead)"
     )
     args = parser.parse_args()
-    from rich.console import Console
 
     from code_puppy.messaging import (
         RichConsoleRenderer,
@@ -146,6 +144,9 @@ 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)
+
     available_port = find_available_port()
     if available_port is None:
         emit_error("No available ports in range 8090-9010!")
@@ -354,6 +355,13 @@ async def interactive_mode(message_renderer, initial_command: str = None) -> Non
     emit_system_message(
         "Type @ for path completion, or /model to pick a model. Toggle multiline with Alt+M or F2; newline: Ctrl+J."
     )
+    emit_system_message("Paste images: Ctrl+V (even on Mac!), F3, or /paste command.")
+    import platform
+
+    if platform.system() == "Darwin":
+        emit_system_message(
+            "💡 macOS tip: Use Ctrl+V (not Cmd+V) to paste images in terminal."
+        )
     cancel_key = get_cancel_agent_display_name()
     emit_system_message(
         f"Press {cancel_key} during processing to cancel the current task or inference. Use Ctrl+X to interrupt running shell commands."
@@ -567,6 +575,7 @@ async def interactive_mode(message_renderer, initial_command: str = None) -> Non
 
         # Check for clear command (supports both `clear` and `/clear`)
         if task.strip().lower() in ("clear", "/clear"):
+            from code_puppy.command_line.clipboard import get_clipboard_manager
             from code_puppy.messaging import (
                 emit_info,
                 emit_system_message,
@@ -579,6 +588,13 @@ async def interactive_mode(message_renderer, initial_command: str = None) -> Non
             emit_warning("Conversation history cleared!")
             emit_system_message("The agent will not remember previous interactions.")
             emit_info(f"Auto-save session rotated to: {new_session_id}")
+
+            # Also clear pending clipboard images
+            clipboard_manager = get_clipboard_manager()
+            clipboard_count = clipboard_manager.get_pending_count()
+            clipboard_manager.clear_pending()
+            if clipboard_count > 0:
+                emit_info(f"Cleared {clipboard_count} pending clipboard image(s)")
             continue
 
         # Parse attachments first so leading paths aren't misread as commands
@@ -679,8 +695,6 @@ async def interactive_mode(message_renderer, initial_command: str = None) -> Non
             save_command_to_history(task)
 
             try:
-                prettier_code_blocks()
-
                 # No need to get agent directly - use manager's run methods
 
                 # Use our custom helper to enable attachment handling with spinner support
@@ -750,28 +764,6 @@ async def interactive_mode(message_renderer, initial_command: str = None) -> Non
                 pass
 
 
-def prettier_code_blocks():
-    """Configure Rich to use prettier code block rendering."""
-
-    class SimpleCodeBlock(CodeBlock):
-        def __rich_console__(
-            self, console: Console, options: ConsoleOptions
-        ) -> RenderResult:
-            code = str(self.text).rstrip()
-            yield Text(self.lexer_name, style="dim")
-            syntax = Syntax(
-                code,
-                self.lexer_name,
-                theme=self.theme,
-                background_color="default",
-                line_numbers=True,
-            )
-            yield syntax
-            yield Text(f"/{self.lexer_name}", style="dim")
-
-    Markdown.elements["fence"] = SimpleCodeBlock
-
-
 async def run_prompt_with_attachments(
     agent,
     raw_prompt: str,
@@ -785,6 +777,7 @@ async def run_prompt_with_attachments(
         tuple: (result, task) where result is the agent response and task is the asyncio task
     """
     import asyncio
+    import re
 
     from code_puppy.messaging import emit_system_message, emit_warning
 
@@ -793,21 +786,41 @@ async def run_prompt_with_attachments(
     for warning in processed_prompt.warnings:
         emit_warning(warning)
 
+    # Get clipboard images and merge with file attachments
+    clipboard_manager = get_clipboard_manager()
+    clipboard_images = clipboard_manager.get_pending_images()
+
+    # Clear pending clipboard images after retrieval
+    clipboard_manager.clear_pending()
+
+    # Build summary of all attachments
     summary_parts = []
     if processed_prompt.attachments:
-        summary_parts.append(f"binary files: {len(processed_prompt.attachments)}")
+        summary_parts.append(f"files: {len(processed_prompt.attachments)}")
+    if clipboard_images:
+        summary_parts.append(f"clipboard images: {len(clipboard_images)}")
     if processed_prompt.link_attachments:
         summary_parts.append(f"urls: {len(processed_prompt.link_attachments)}")
     if summary_parts:
         emit_system_message("Attachments detected -> " + ", ".join(summary_parts))
 
-    if not processed_prompt.prompt:
+    # Clean up clipboard placeholders from the prompt text
+    cleaned_prompt = processed_prompt.prompt
+    if clipboard_images and cleaned_prompt:
+        cleaned_prompt = re.sub(
+            r"\[📋 clipboard image \d+\]\s*", "", cleaned_prompt
+        ).strip()
+
+    if not cleaned_prompt:
         emit_warning(
             "Prompt is empty after removing attachments; add instructions and retry."
         )
         return None, None
 
+    # Combine file attachments with clipboard images
     attachments = [attachment.content for attachment in processed_prompt.attachments]
+    attachments.extend(clipboard_images)  # Add clipboard images
+
     link_attachments = [link.url_part for link in processed_prompt.link_attachments]
 
     # IMPORTANT: Set the shared console on the agent so that streaming output
@@ -819,7 +832,7 @@ async def run_prompt_with_attachments(
     # Create the agent task first so we can track and cancel it
     agent_task = asyncio.create_task(
         agent.run_with_mcp(
-            processed_prompt.prompt,
+            cleaned_prompt,  # Use cleaned prompt (clipboard placeholders removed)
             attachments=attachments,
             link_attachments=link_attachments,
         )