code-puppy 0.0.642__tar.gz → 0.0.643__tar.gz

{code_puppy-0.0.642 → code_puppy-0.0.643}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-puppy
-Version: 0.0.642
+Version: 0.0.643
 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.642 → code_puppy-0.0.643}/code_puppy/agents/_runtime.py

@@ -987,7 +987,14 @@ async def _run_with_mcp_impl(
     run_success = False
     run_error: Optional[BaseException] = None
     run_response_text = ""
-    run_usage_output_tokens: Optional[int] = None
+    run_usage_metadata: dict[str, int | None] = {
+        "usage_input_tokens": None,
+        "usage_output_tokens": None,
+        "usage_total_tokens": None,
+        "usage_cached_read_tokens": None,
+        "usage_cached_write_tokens": None,
+        "usage_thought_tokens": None,
+    }
 
     try:
         # Nested runs (e.g. shell_safety mid-run) leave the SIGINT handler
@@ -1044,13 +1051,37 @@ async def _run_with_mcp_impl(
         run_success = True
         run_response_text = _extract_response_text(result)
         try:
-            # Real billed output tokens -- calibrates the run-stats TG
-            # estimate (see run_stats.snapshot_cycle_into_aggregates).
-            run_usage_output_tokens = (
-                int(getattr(result.usage(), "output_tokens", 0) or 0) or None
-            )
+            usage = result.usage()
+
+            def _pick_usage_int(*names: str) -> int | None:
+                for name in names:
+                    value = getattr(usage, name, None)
+                    if value is not None:
+                        return int(value) or None
+                return None
+
+            run_usage_metadata = {
+                "usage_input_tokens": _pick_usage_int(
+                    "input_tokens", "request_tokens", "prompt_tokens"
+                ),
+                # Real billed output tokens -- calibrates the run-stats TG
+                # estimate (see run_stats.snapshot_cycle_into_aggregates).
+                "usage_output_tokens": _pick_usage_int(
+                    "output_tokens", "response_tokens", "completion_tokens"
+                ),
+                "usage_total_tokens": _pick_usage_int("total_tokens"),
+                "usage_cached_read_tokens": _pick_usage_int(
+                    "cache_read_tokens", "cached_read_tokens"
+                ),
+                "usage_cached_write_tokens": _pick_usage_int(
+                    "cache_write_tokens", "cached_write_tokens"
+                ),
+                "usage_thought_tokens": _pick_usage_int(
+                    "thinking_tokens", "thought_tokens", "reasoning_tokens"
+                ),
+            }
         except Exception:
-            run_usage_output_tokens = None
+            pass
         return result
     except asyncio.CancelledError:
         run_response_text = ""
@@ -1086,7 +1117,7 @@ async def _run_with_mcp_impl(
                 response_text=run_response_text,
                 metadata={
                     "model": agent.get_model_name(),
-                    "usage_output_tokens": run_usage_output_tokens,
+                    **run_usage_metadata,
                 },
             )
         except Exception:

{code_puppy-0.0.642 → code_puppy-0.0.643}/code_puppy/messaging/__init__.py

@@ -30,11 +30,11 @@ Example (new):
 """
 
 # =============================================================================
-# Apply Rich Markdown patches (left-justified headers)
+# Apply Rich Markdown patches (left-justified headers, unpadded code blocks)
 # =============================================================================
-from .markdown_patches import patch_markdown_headings
+from .markdown_patches import patch_markdown
 
-patch_markdown_headings()
+patch_markdown()
 
 # =============================================================================
 # Legacy API (backward compatible)
@@ -290,7 +290,7 @@ __all__ = [
     "DEFAULT_STYLES",
     "DIFF_STYLES",
     # Markdown patches
-    "patch_markdown_headings",
+    "patch_markdown",
     # Sub-agent console manager
     "AgentState",
     "SubAgentConsoleManager",

{code_puppy-0.0.642 → code_puppy-0.0.643}/code_puppy/messaging/bottom_bar.py

@@ -287,6 +287,12 @@ class BottomBar(TranscriptGuardMixin, BarPainterMixin):
             self._popup_slack = max(0, old_block - len(cleaned))
             self._sync_reserved(self._popup_seq)
 
+    @contextmanager
+    def output_transaction(self) -> Iterator[None]:
+        """Coordinate one transcript render with the live prompt surface."""
+        self.notify_transcript_output()
+        yield
+
     def notify_transcript_output(self) -> None:
         """Release ONE row of popup slack — called per rendered message.
 
@@ -698,12 +704,30 @@ _bottom_bar: Optional[BottomBar] = None
 _bottom_bar_lock = threading.Lock()
 
 
+def _use_inline_surface() -> bool:
+    """Use the DECSTBM-free surface for known-incompatible terminals."""
+    import os
+
+    mode = os.environ.get("CODE_PUPPY_PROMPT_MODE", "auto").strip().lower()
+    if mode in {"inline", "flow"}:
+        return True
+    if mode in {"pinned", "scroll-region"}:
+        return False
+    emulator = os.environ.get("TERMINAL_EMULATOR", "").strip().lower()
+    return emulator == "jetbrains-jediterm"
+
+
 def get_bottom_bar() -> BottomBar:
-    """Get or lazily create the global BottomBar singleton."""
+    """Get or lazily create the terminal-appropriate prompt surface."""
     global _bottom_bar
     with _bottom_bar_lock:
         if _bottom_bar is None:
-            _bottom_bar = BottomBar()
+            if _use_inline_surface():
+                from .inline_bar import InlineBottomBar
+
+                _bottom_bar = InlineBottomBar()
+            else:
+                _bottom_bar = BottomBar()
         return _bottom_bar
 
 

code_puppy-0.0.643/code_puppy/messaging/inline_bar.py

@@ -0,0 +1,190 @@
+"""Inline prompt surface for terminals that mishandle DECSTBM.
+
+Unlike :class:`bottom_bar.BottomBar`, this surface never establishes scroll
+margins or paints at absolute screen rows.  It keeps the live UI at the normal
+terminal cursor, erases it before transcript output, then redraws it below the
+new output.  The public API intentionally matches ``BottomBar`` so the editor
+and status/panel plugins do not need terminal-specific branches.
+"""
+
+from __future__ import annotations
+
+from contextlib import contextmanager
+from typing import Iterator
+
+from .bar_rendering import (
+    CLEAR_LINE,
+    CURSOR_HIDE,
+    CURSOR_SHOW,
+    WRAP_OFF,
+    WRAP_ON,
+    render_prompt_block,
+    sanitize,
+)
+from .bottom_bar import PANEL_MAX_ROWS, POPUP_MAX_ROWS, BottomBar
+
+
+class InlineBottomBar(BottomBar):
+    """A DECSTBM-free prompt surface for embedded terminal emulators."""
+
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self._displayed_rows = 0
+        self._output_depth = 0
+
+    def start(self) -> None:
+        if not self._is_tty():
+            return
+        with self._lock:
+            if self._active:
+                return
+            self._active = True
+            self._cols, self._rows = self._safe_size()
+            self._write(CURSOR_HIDE)
+            self._paint_inline()
+        self._install_sigwinch()
+        self._register_atexit()
+
+    def stop(self) -> None:
+        with self._lock:
+            if not self._active:
+                return
+            self._erase_inline()
+            self._write(CURSOR_SHOW)
+            self._active = False
+            self._displayed_rows = 0
+
+    def _sync_reserved(self, _painter) -> None:
+        """Repaint cached state without creating a terminal scroll region."""
+        if not self._active or self._suspend_depth > 0 or self._output_depth > 0:
+            return
+        self._ensure_inline_geometry()
+        self._erase_inline()
+        self._paint_inline()
+
+    def notify_transcript_output(self) -> None:
+        """Retain popup-slack semantics; erasing is owned by the transaction."""
+        with self._lock:
+            if self._popup_slack:
+                self._popup_slack -= 1
+
+    @contextmanager
+    def output_transaction(self) -> Iterator[None]:
+        """Atomically remove the live UI, allow output, then redraw it."""
+        with self._lock:
+            outermost = self._output_depth == 0
+            self._output_depth += 1
+            if outermost and self._active and self._suspend_depth == 0:
+                self.notify_transcript_output()
+                self._erase_inline()
+            try:
+                yield
+            finally:
+                self._output_depth -= 1
+                if outermost and self._active and self._suspend_depth == 0:
+                    self._ensure_inline_geometry()
+                    self._paint_inline()
+
+    @contextmanager
+    def suspended(self) -> Iterator[None]:
+        if not self._is_tty():
+            yield
+            return
+        with self._lock:
+            self._suspend_depth += 1
+            if self._suspend_depth == 1 and self._active:
+                self._erase_inline()
+        try:
+            yield
+        finally:
+            with self._lock:
+                self._suspend_depth -= 1
+                if self._suspend_depth == 0 and self._active:
+                    self._paint_inline()
+
+    def set_panel_lines(self, lines) -> None:
+        from rich.text import Text
+
+        cleaned = [
+            line.copy() if isinstance(line, Text) else sanitize(str(line))
+            for line in (lines or [])
+        ][:PANEL_MAX_ROWS]
+        with self._lock:
+            self._panel_lines = cleaned
+            self._sync_reserved(None)
+
+    def set_popup_lines(self, lines, selected: int = -1) -> None:
+        cleaned = [sanitize(str(line)) for line in (lines or [])][:POPUP_MAX_ROWS]
+        with self._lock:
+            self._popup_lines = cleaned
+            self._popup_selected = selected
+            self._popup_slack = 0
+            self._sync_reserved(None)
+
+    def _ensure_inline_geometry(self) -> None:
+        cols, rows = self._safe_size()
+        self._cols, self._rows = cols, rows
+
+    def _inline_lines(self) -> list[str]:
+        lines: list[str] = []
+        panel = [] if self._popup_lines else self._panel_lines
+        for line in panel:
+            lines.append(sanitize(line.plain if hasattr(line, "plain") else str(line)))
+
+        prompt_rows, _ = render_prompt_block(
+            self._prompt_prefix,
+            self._prompt_buffer,
+            self._prompt_cursor,
+            self._cols,
+            5,
+            prefix_sgrs=self._prompt_prefix_sgrs,
+        )
+        lines.extend(prompt_rows)
+
+        for index, line in enumerate(self._popup_lines):
+            marker = "› " if index == self._popup_selected else "  "
+            lines.append(f"{marker}{line}")
+
+        status = f"{self._status_prefix}{self._status}{self._status_suffix}"
+        if status:
+            lines.append(sanitize(status))
+        return lines or [""]
+
+    def _paint_inline(self) -> None:
+        if not self._active or self._suspend_depth > 0 or self._output_depth > 0:
+            return
+        lines = self._inline_lines()
+        parts = [WRAP_OFF]
+        for index, line in enumerate(lines):
+            if index:
+                parts.append("\r\n")
+            parts.append(f"{CLEAR_LINE}{line}")
+        if len(lines) > 1:
+            parts.append(f"\x1b[{len(lines) - 1}A")
+        parts.extend(["\r", WRAP_ON])
+        self._write("".join(parts))
+        self._displayed_rows = len(lines)
+
+    def _erase_inline(self) -> None:
+        if not self._displayed_rows:
+            return
+        parts = [WRAP_OFF, "\r"]
+        for index in range(self._displayed_rows):
+            if index:
+                parts.append("\x1b[1B\r")
+            parts.append(CLEAR_LINE)
+        if self._displayed_rows > 1:
+            parts.append(f"\x1b[{self._displayed_rows - 1}A")
+        parts.extend(["\r", WRAP_ON])
+        self._write("".join(parts))
+        self._displayed_rows = 0
+
+    def _emergency_restore(self) -> None:
+        try:
+            with self._lock:
+                if self._active:
+                    self._erase_inline()
+                self._write(CURSOR_SHOW)
+                self._active = False
+        except Exception:
+            pass

code_puppy-0.0.643/code_puppy/messaging/markdown_patches.py

@@ -0,0 +1,89 @@
+"""Patches for Rich's Markdown rendering.
+
+- Headings: Rich hardcodes them to center-justified; we want left.
+- Code blocks: Rich pads every line to fill a rectangular highlight
+  background, and that padding survives copy/paste (#505). See
+  ``NoPadCodeBlock``.
+"""
+
+from rich import box
+from rich.markdown import CodeBlock, Heading, Markdown
+from rich.panel import Panel
+from rich.rule import Rule
+from rich.syntax import Syntax
+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
+
+
+class NoPadCodeBlock(CodeBlock):
+    """Code block with per-character background but no padding (#505).
+
+    Rich's default ``CodeBlock`` pads every line to width so the theme
+    background fills a rectangle -- that padding survives copy/paste.
+    We bypass ``Syntax``'s line-filling and yield each highlighted line
+    directly: theme background stays on real characters, box is "ragged"
+    (hugs each line's own width) instead of a filled rectangle. Language
+    label + boundary drawn with ``Rule``.
+    """
+
+    def __rich_console__(self, console, options):
+        code = str(self.text).rstrip()
+        syntax = Syntax(
+            code,
+            self.lexer_name,
+            theme=self.theme,
+            word_wrap=True,
+            background_color=None,
+        )
+        yield Rule(title=self.lexer_name, align="left", style="dim")
+        for line in syntax.highlight(code).split("\n"):
+            # ``Text.highlight()`` sets ``justify="left"`` for opaque
+            # backgrounds, which re-pads to container width. Undo it;
+            # per-character bg from the base style is unaffected.
+            line.justify = None
+            yield line
+        yield Rule(style="dim")
+
+
+_patched = False
+
+
+def patch_markdown():
+    """Install left-justified headings + unpadded code blocks. Idempotent."""
+    global _patched
+    if _patched:
+        return
+
+    Markdown.elements["heading_open"] = LeftJustifiedHeading
+    Markdown.elements["fence"] = NoPadCodeBlock
+    Markdown.elements["code_block"] = NoPadCodeBlock
+    _patched = True
+
+
+__all__ = ["patch_markdown", "LeftJustifiedHeading", "NoPadCodeBlock"]

{code_puppy-0.0.642 → code_puppy-0.0.643}/code_puppy/messaging/renderers.py

@@ -275,18 +275,25 @@ def _classify_style(message: UIMessage) -> Optional[str]:
 
 
 def _print_message(console: Console, message: UIMessage) -> None:
-    """Print ``message`` to ``console`` using the standard styling rules."""
-    # New transcript output is about to scroll: the bottom bar walks
-    # its popup slack back one row per message so the prompt steps down
-    # with the flow (see BottomBar.notify_transcript_output). Guarded:
-    # bar geometry plumbing must NEVER break (or kill) a render thread.
+    """Print one message while coordinating with the live prompt surface."""
+    from contextlib import nullcontext
+
     try:
         from .bottom_bar import get_bottom_bar
 
-        get_bottom_bar().notify_transcript_output()
+        transaction = get_bottom_bar().output_transaction()
     except Exception:
-        pass
+        transaction = nullcontext()
+    with transaction:
+        _print_message_uncoordinated(console, message)
 
+
+def _print_message_uncoordinated(console: Console, message: UIMessage) -> None:
+    """Print ``message`` to ``console`` using the standard styling rules."""
+    # New transcript output is about to scroll: the bottom bar walks
+    # its popup slack back one row per message so the prompt steps down
+    # with the flow (see BottomBar.notify_transcript_output). Guarded:
+    # bar geometry plumbing must NEVER break (or kill) a render thread.
     style = _classify_style(message)
     content = message.content
     if message.type == MessageType.QUEUED:

{code_puppy-0.0.642 → code_puppy-0.0.643}/code_puppy/messaging/rich_renderer.py

@@ -433,6 +433,19 @@ class RichConsoleRenderer:
     # =========================================================================
 
     def _do_render(self, message: AnyMessage) -> None:
+        """Render one message while coordinating with the prompt surface."""
+        from contextlib import nullcontext
+
+        try:
+            from .bottom_bar import get_bottom_bar
+
+            transaction = get_bottom_bar().output_transaction()
+        except Exception:
+            transaction = nullcontext()
+        with transaction:
+            self._do_render_uncoordinated(message)
+
+    def _do_render_uncoordinated(self, message: AnyMessage) -> None:
         """Synchronously render a message by dispatching to the appropriate handler.
 
         Note: User input requests are skipped in sync mode as they require async.
@@ -463,17 +476,6 @@ class RichConsoleRenderer:
             if get_output_level() != "high" and get_suppress_thinking_messages():
                 return
 
-        # New transcript output is about to scroll (peek or full render):
-        # the bottom bar walks its completion-popup slack back one row
-        # per message so the prompt steps down with the flow. Guarded:
-        # bar geometry plumbing must NEVER break a render path.
-        try:
-            from .bottom_bar import get_bottom_bar
-
-            get_bottom_bar().notify_transcript_output()
-        except Exception:
-            pass
-
         # -- Output-level density gate --
         if self._should_collapse(message):
             self._render_peek(message)

{code_puppy-0.0.642 → code_puppy-0.0.643}/code_puppy/plugins/claude_code_hooks/register_callbacks.py

@@ -366,6 +366,8 @@ async def on_agent_run_end_hook(
             "session_id": session_id,
             "success": success,
             "error": str(error) if error else None,
+            "response_text": response_text,
+            "metadata": metadata,
         },
     )
 

{code_puppy-0.0.642 → code_puppy-0.0.643}/code_puppy/pydantic_patches.py

@@ -529,6 +529,33 @@ def patch_termflow_clipboard() -> None:
         pass  # never crash on patch failure
 
 
+def _no_pad_render_code_line(_line, highlighted, width, margin, style, pretty_pad=True):
+    """Drop-in for ``render_code_line`` minus the ``' ' * padding`` suffix."""
+    return f"{margin}{highlighted}"
+
+
+def patch_termflow_code_padding() -> None:
+    """Strip trailing-space padding from termflow code lines (#505).
+
+    termflow's ``render_code_line`` right-pads to render width, but
+    termflow doesn't color code backgrounds -- so the padding is pure
+    invisible filler that corrupts copy/paste. Must patch both
+    ``termflow.render.code`` (the definition) AND
+    ``termflow.render.renderer`` (did ``from … import render_code_line``,
+    so it holds a stale reference).
+    """
+    try:
+        import termflow.render.code as _termflow_code
+        import termflow.render.renderer as _termflow_renderer
+
+        _termflow_code.render_code_line = _no_pad_render_code_line
+        _termflow_renderer.render_code_line = _no_pad_render_code_line
+    except ImportError:
+        pass  # termflow not available
+    except Exception:
+        pass  # never crash on patch failure
+
+
 def apply_all_patches() -> None:
     """Apply all monkey patches.
 
@@ -541,3 +568,4 @@ def apply_all_patches() -> None:
     patch_tool_call_callbacks()
     patch_prompt_toolkit_emoji_width()
     patch_termflow_clipboard()
+    patch_termflow_code_padding()

{code_puppy-0.0.642 → code_puppy-0.0.643}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "code-puppy"
-version = "0.0.642"
+version = "0.0.643"
 description = "Code generation agent"
 readme = "README.md"
 requires-python = ">=3.11,<3.15"

code_puppy-0.0.642/code_puppy/messaging/markdown_patches.py

@@ -1,57 +0,0 @@
-"""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"]