hx-cli 0.2.0__tar.gz → 0.2.1__tar.gz

{hx_cli-0.2.0 → hx_cli-0.2.1}/CHANGELOG.md

@@ -28,6 +28,24 @@ the project follows [semantic versioning](https://semver.org/).
 
 ---
 
+## [0.2.1] - 2026-09-14
+
+### Changed
+
+- Code blocks in a reply are drawn as a block - the code on a band of its own
+  colour, syntax highlighted, with the language named at the top - instead of
+  printing the ``` fences back out as text. Themes set the band with the new
+  `mdCodeBlockBg` role, and a theme that leaves colour to the terminal, as
+  `ansi` does, gets a rule above and below instead.
+
+### Fixed
+
+- The model's reasoning is shown again. It was collapsed to a bare `Thinking…`
+  with no key wired to open it, so the text never reached the screen. `ctrl+o`
+  now folds and unfolds it, the same key that expands a tool call.
+
+---
+
 ## [0.2.0] - 2026-09-14
 
 ### Changed
@@ -390,7 +408,8 @@ First release, published to PyPI as [`hx-cli`](https://pypi.org/project/hx-cli/)
 - `/configure` and `hx auth` for the OpenRouter key, `hx upgrade` for
   self-update, and `install.sh` bootstrapping uv with a pinned Python.
 
-[Unreleased]: https://github.com/aletisunil/hx/compare/v0.2.0...HEAD
+[Unreleased]: https://github.com/aletisunil/hx/compare/v0.2.1...HEAD
+[0.2.1]: https://github.com/aletisunil/hx/compare/v0.2.0...v0.2.1
 [0.2.0]: https://github.com/aletisunil/hx/compare/v0.1.9...v0.2.0
 [0.1.9]: https://github.com/aletisunil/hx/compare/v0.1.8...v0.1.9
 [0.1.8]: https://github.com/aletisunil/hx/compare/v0.1.7...v0.1.8

{hx_cli-0.2.0 → hx_cli-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hx-cli
-Version: 0.2.0
+Version: 0.2.1
 Summary: HX - a terminal coding agent
 Project-URL: Homepage, https://github.com/aletisunil/hx
 Project-URL: Issues, https://github.com/aletisunil/hx/issues

{hx_cli-0.2.0 → hx_cli-0.2.1}/src/hx/__init__.py

@@ -1,5 +1,5 @@
 """HX - a terminal coding agent."""
 
-__version__ = "0.2.0"
+__version__ = "0.2.1"
 
 __all__ = ["__version__"]

{hx_cli-0.2.0 → hx_cli-0.2.1}/src/hx/term/markdown.py

@@ -13,6 +13,11 @@ Two conventions worth naming, both taken from pi:
   hashes are syntax, and leaving them in makes prose look like a source file.
   H3 and below keep theirs, because by then the level is worth stating and
   bold-on-bold no longer distinguishes them.
+* **Code blocks lose their fences.** ``` is syntax too, and printing it back
+  out tells the reader only that the renderer gave up. The block is a band of
+  its own colour instead, with the language named at the top of it - and a rule
+  above and below for a theme that has no colour to tint with, which is what
+  the ``ansi`` one deliberately is.
 * **Tables are the one place box-drawing is allowed.** A table without rules is
   not a table. Everywhere else, a rule above and below - never a rectangle.
 """
@@ -27,6 +32,7 @@ LIST_INDENT = 4
 """Columns per nesting level, wide enough that a marker and its text both fit."""
 
 CODE_INDENT = "  "
+CODE_RULE = "─"
 QUOTE_RAIL = "│ "
 HR_MAX = 80
 """A rule spanning a very wide terminal reads as a divider in a book, not a
@@ -43,6 +49,17 @@ class Painter:
     def paint(self, role: str, text: str, **kwargs: bool) -> str:
         return text
 
+    def fill(self, role: str, text: str) -> str | None:
+        """``text`` on a background, or ``None`` if this role has none.
+
+        A theme is allowed to have no opinion about colour - the ``ansi`` one
+        deliberately has none, deferring to the terminal's own palette - and a
+        band tinted in a colour that resolves to nothing is not a band. So the
+        renderer asks rather than assumes, and rules the block instead when the
+        answer is no.
+        """
+        return None
+
     def code(self, source: str, language: str | None) -> list[str]:
         return source.split("\n")
 
@@ -126,15 +143,77 @@ class _Renderer:
 
     def _fence(self, node: object, indent: int) -> None:
         language = (node.info or "").strip().split(" ")[0] or None  # type: ignore[attr-defined]
-        fence = self.painter.paint("md_code_block_border", "```" + (language or ""))
+        available = max(1, self.width - indent)
+        room = max(1, available - 2 * len(CODE_INDENT))
+        body = [
+            truncate_to_width(line, room)
+            for line in self.painter.code(node.content.rstrip("\n"), language)  # type: ignore[attr-defined]
+        ]
+
         self.blank()
-        self.emit(fence, indent)
-        room = max(1, self.width - indent - len(CODE_INDENT))
-        for line in self.painter.code(node.content.rstrip("\n"), language):  # type: ignore[attr-defined]
-            self.emit(CODE_INDENT + truncate_to_width(line, room), indent)
-        self.emit(self.painter.paint("md_code_block_border", "```"), indent)
+        if self.painter.fill("md_code_block_bg", "") is None:
+            self._ruled_block(body, language, available, indent)
+        else:
+            self._tinted_block(body, language, available, indent)
         self.blank()
 
+    def _tinted_block(
+        self, body: list[str], language: str | None, available: int, indent: int
+    ) -> None:
+        """Code on a band of its own colour, the language named at the top.
+
+        The band spans the column rather than the longest line, for the same
+        reason a tinted message does: a block whose right edge follows the code
+        is a ragged column, not a block. The language label and a blank row
+        below the code are the padding - inside the tint, so the band is a
+        rectangle rather than a highlighted run of text.
+        """
+        span = available
+        label = truncate_to_width(language or "", max(0, span - 2 * len(CODE_INDENT)))
+        head = self.painter.paint("md_code_block", label) if label else ""
+        rows = [head, *body, ""]
+        for row in rows:
+            padding = " " * max(0, span - len(CODE_INDENT) - cell_width(row))
+            filled = self.painter.fill("md_code_block_bg", CODE_INDENT + row + padding)
+            self.emit(filled if filled is not None else CODE_INDENT + row, indent)
+
+    def _ruled_block(
+        self, body: list[str], language: str | None, available: int, indent: int
+    ) -> None:
+        """The same block for a theme with no colour of its own to tint with.
+
+        Capped like a thematic break, but never shorter than the code it
+        encloses: a rule the content overhangs reads as a broken block.
+        """
+        widest = max((cell_width(line) for line in body), default=0) + len(CODE_INDENT)
+        span = min(available, max(HR_MAX, widest))
+        self.emit(self._code_rule(span, language), indent)
+        for line in body:
+            self.emit(CODE_INDENT + line, indent)
+        self.emit(self.painter.paint("md_code_block_border", CODE_RULE * span), indent)
+
+    def _code_rule(self, span: int, language: str | None) -> str:
+        """The rule opening a code block, carrying the language if there is one.
+
+        The fence markers themselves are syntax, the same way a heading's
+        hashes are: the reader is looking at source either way, and ``` in the
+        middle of rendered prose only tells them the renderer gave up. A rule
+        says the same thing in the vocabulary the rest of the UI uses, and the
+        language sits in it rather than on a line of its own.
+        """
+        paint = self.painter.paint
+        label = truncate_to_width(language or "", max(0, span - 4))
+        if not label:
+            return paint("md_code_block_border", CODE_RULE * span)
+        trail = CODE_RULE * (span - 4 - cell_width(label))
+        return (
+            paint("md_code_block_border", CODE_RULE * 2)
+            + " "
+            + paint("md_code_block", label)
+            + " "
+            + paint("md_code_block_border", trail)
+        )
+
     _code_block = _fence
 
     def _hr(self, _node: object, indent: int) -> None:

{hx_cli-0.2.0 → hx_cli-0.2.1}/src/hx/term/primitives.py

@@ -139,8 +139,9 @@ class Box(Widget):
 
     The tint is the only thing marking the block, and it reaches the full width
     of the terminal so the block reads as a band rather than a ragged column.
-    Backgrounds mean one of two things in this UI - whose turn this is, or how
-    a tool call ended - and are never used for emphasis.
+    Backgrounds mean one of three things in this UI - whose turn this is, how a
+    tool call ended, or that a run of text is code - and are never used for
+    emphasis.
     """
 
     __slots__ = ("_padding_x", "_padding_y", "_tint", "children")

{hx_cli-0.2.0 → hx_cli-0.2.1}/src/hx/tui/paint.py

@@ -66,9 +66,9 @@ def bg(role: str, text: str) -> str:
 def tint(role: str) -> Callable[[str], str]:
     """A background filler, for :class:`~hx.term.primitives.Box`.
 
-    Backgrounds mean exactly two things in this UI - whose turn this is, and
-    how a tool call ended - so there are few of these and they are never used
-    for emphasis.
+    Backgrounds mean exactly three things in this UI - whose turn this is, how
+    a tool call ended, and that a run of text is code - so there are few of
+    these and they are never used for emphasis.
     """
 
     def paint(line: str) -> str:
@@ -103,6 +103,17 @@ class ThemePainter(Painter):
     def paint(self, role: str, text: str, **kwargs: bool) -> str:
         return fg(role, text, **kwargs)
 
+    def fill(self, role: str, text: str) -> str | None:
+        """The role as a background, unless the theme leaves it to the terminal.
+
+        ``ansi_default`` and an empty value both mean "whatever the terminal is
+        already using", which as a background is nothing at all.
+        """
+        value = color(role)
+        if not value or value == "ansi_default":
+            return None
+        return bg(role, text)
+
     def code(self, source: str, language: str | None) -> list[str]:
         from hx.term.syntax import highlight
 

{hx_cli-0.2.0 → hx_cli-0.2.1}/src/hx/tui/roles.py

@@ -66,6 +66,7 @@ class Palette:
     md_link_url: str
     md_code: str
     md_code_block: str
+    md_code_block_bg: str
     md_code_block_border: str
     md_quote: str
     md_quote_border: str

{hx_cli-0.2.0 → hx_cli-0.2.1}/src/hx/tui/runtime.py

@@ -951,13 +951,18 @@ class HXSession:
         self._notice(f"Copied to the clipboard ({used}).", "success")
 
     def expand_cursored(self) -> None:
-        """Expand the cursored block, or every tool block when none is."""
+        """Expand the cursored block, or every foldable one when none is.
+
+        Reasoning folds with the tool calls rather than on a key of its own:
+        both are the detail under an answer, and one key for "show me the
+        detail" is the whole point of having a key for it.
+        """
         cursor = self.view.transcript.cursor
         if cursor is not None and hasattr(cursor, "toggle"):
             cursor.toggle()
         else:
             for block in self.view.transcript.blocks:
-                if isinstance(block, ToolBlock):
+                if isinstance(block, ToolBlock | ThinkingMessage):
                     block.toggle()
         self.runner.request_immediate_render()
 

{hx_cli-0.2.0 → hx_cli-0.2.1}/src/hx/tui/theme_json.py

@@ -40,7 +40,12 @@ _EXPORT_FALLBACKS = {"background": "pageBg", "surface": "cardBg"}
 
 #: Roles that borrow another role when absent. Only for roles pi has no concept
 #: of; a role pi does define must be present or the file is rejected.
-_DERIVED = {"panel": "surface", "diff_hunk": "md_link", "user_text": "text"}
+_DERIVED = {
+    "panel": "surface",
+    "diff_hunk": "md_link",
+    "user_text": "text",
+    "md_code_block_bg": "surface",
+}
 
 _FIELDS = frozenset(f.name for f in fields(Palette)) - {"name", "dark"}
 

{hx_cli-0.2.0 → hx_cli-0.2.1}/src/hx/tui/themes/ansi.json

@@ -42,6 +42,7 @@
 		"mdLink": "ansi_blue",
 		"mdLinkUrl": "faint",
 		"mdCode": "ansi_cyan",
+		"mdCodeBlockBg": "default",
 		"mdCodeBlock": "ansi_green",
 		"mdCodeBlockBorder": "faint",
 		"mdQuote": "faint",

{hx_cli-0.2.0 → hx_cli-0.2.1}/src/hx/tui/themes/dark.json

@@ -20,7 +20,8 @@
 		"toolPendingBg": "#282832",
 		"toolSuccessBg": "#283228",
 		"toolErrorBg": "#3c2828",
-		"customMsgBg": "#2d2838"
+		"customMsgBg": "#2d2838",
+		"codeBg": "#22222a"
 	},
 	"colors": {
 		"background": "pageBg",
@@ -59,6 +60,7 @@
 		"mdLink": "#81a2be",
 		"mdLinkUrl": "dimGray",
 		"mdCode": "accent",
+		"mdCodeBlockBg": "codeBg",
 		"mdCodeBlock": "green",
 		"mdCodeBlockBorder": "gray",
 		"mdQuote": "gray",

{hx_cli-0.2.0 → hx_cli-0.2.1}/src/hx/tui/themes/light.json

@@ -19,7 +19,8 @@
 		"toolPendingBg": "#e8e8f0",
 		"toolSuccessBg": "#e8f0e8",
 		"toolErrorBg": "#f0e8e8",
-		"customMsgBg": "#ede7f6"
+		"customMsgBg": "#ede7f6",
+		"codeBg": "#eceef0"
 	},
 	"colors": {
 		"background": "pageBg",
@@ -58,6 +59,7 @@
 		"mdLink": "blue",
 		"mdLinkUrl": "dimGray",
 		"mdCode": "teal",
+		"mdCodeBlockBg": "codeBg",
 		"mdCodeBlock": "green",
 		"mdCodeBlockBorder": "mediumGray",
 		"mdQuote": "mediumGray",

{hx_cli-0.2.0 → hx_cli-0.2.1}/src/hx/tui/views/blocks.py

@@ -17,7 +17,7 @@ from typing import Any
 
 from hx.term.component import Widget
 from hx.term.markdown import render_markdown
-from hx.term.primitives import Box, HangingText, Lines, Text
+from hx.term.primitives import Box, HangingText, Lines
 from hx.term.sanitize import plain_text
 from hx.tui.glyphs import NOTICE, SPINNER, TOOL_DONE, TOOL_FAILED
 from hx.tui.limits import PREVIEW_LINES
@@ -89,11 +89,18 @@ class AssistantMessage(Widget):
 
 
 class ThinkingMessage(Widget):
-    """The model's reasoning, in its own muted colour."""
+    """The model's reasoning, in its own muted colour.
+
+    Shown rather than hidden. Reasoning is the part of a turn that explains the
+    part you can see, and a reader who does not want it has a key for that -
+    ``ctrl+o``, the same one that expands a tool call. A one-line ``Thinking…``
+    with no way to open it, which is what this was, is the reasoning simply
+    not arriving.
+    """
 
     __slots__ = ("_collapsed", "_text")
 
-    def __init__(self, text: str = "", collapsed: bool = True) -> None:
+    def __init__(self, text: str = "", collapsed: bool = False) -> None:
         super().__init__()
         self._text = plain_text(text)
         self._collapsed = collapsed
@@ -107,13 +114,23 @@ class ThinkingMessage(Widget):
             self._collapsed = collapsed
             self.invalidate()
 
+    def toggle(self) -> None:
+        self.set_collapsed(not self._collapsed)
+
+    @property
+    def text(self) -> str:
+        return self._text
+
     def draw(self, width: int) -> list[str]:
         if not self._text.strip():
             return []
-        if self._collapsed:
-            return Text(fg("thinking", "Thinking…", italic=True)).render(width)
         lines = [fg("thinking", line, italic=True) for line in self._text.strip().split("\n")]
-        return Lines(lines).render(width)
+        if not self._collapsed:
+            return Lines(lines).render(width)
+        # Folded by the reader, with the key they just pressed - so the count
+        # is what is worth saying here, not the key again.
+        note = fg("dim", f" ({len(lines)} lines)") if len(lines) > 1 else ""
+        return Lines([fg("thinking", "Thinking…", italic=True) + note]).render(width)
 
 
 class ToolBlock(Widget):

{hx_cli-0.2.0 → hx_cli-0.2.1}/tests/term/test_markdown.py

@@ -31,6 +31,14 @@ class Recording(Painter):
         return source.split("\n")
 
 
+class Tinting(Recording):
+    """A painter that has a background to offer, as a real theme does."""
+
+    def fill(self, role: str, text: str) -> str | None:
+        self.roles.append(f"fill:{role}")
+        return f"<{role}>{text}</{role}>"
+
+
 def plain(text: str, width: int = 60) -> list[str]:
     return [strip_ansi(line) for line in render_markdown(text, width)]
 
@@ -146,6 +154,60 @@ def test_a_fenced_block_is_highlighted_and_indented() -> None:
     assert body and strip_ansi(body[0]).startswith("  ")
 
 
+def test_a_fenced_block_is_ruled_rather_than_fenced() -> None:
+    """``` is syntax, like a heading's hashes: printing it back out tells the
+    reader only that the renderer gave up."""
+    lines = plain("```json\n{}\n```")
+    assert not any("```" in line for line in lines)
+    assert lines[0].startswith("──") and lines[-1] == "─" * cell_width(lines[0])
+
+
+def test_the_language_sits_in_the_opening_rule() -> None:
+    painter = Recording()
+    out = render_markdown("```json\n{}\n```", 40, painter)
+    assert "md_code_block" in painter.roles, "the role finally does something"
+    assert "json" in strip_ansi(out[0])
+    assert "json" not in strip_ansi(out[-1]), "only the opening rule carries it"
+
+
+def test_a_block_without_a_language_gets_a_plain_rule() -> None:
+    lines = plain("```\nx\n```")
+    assert lines[0] == lines[-1] == "─" * cell_width(lines[0])
+
+
+def test_a_theme_with_a_colour_tints_the_block_instead_of_ruling_it() -> None:
+    painter = Tinting()
+    out = render_markdown("```json\n{}\n```", 40, painter)
+    assert "fill:md_code_block_bg" in painter.roles
+    assert not any("─" in line for line in out), "tinted, so no rules"
+    assert "json" in out[0], "the language is named at the top of the band"
+
+
+def test_the_band_spans_the_column_rather_than_the_longest_line() -> None:
+    """A block whose right edge follows the code is a ragged column."""
+    painter = Tinting()
+    out = render_markdown("```\nx\n```", 40, painter)
+    inner = [line.split(">", 1)[1].rsplit("</", 1)[0] for line in out]
+    assert {cell_width(line) for line in inner} == {40}
+
+
+def test_a_theme_with_no_colour_of_its_own_falls_back_to_rules() -> None:
+    """The ansi theme defers to the terminal's palette, so it has no surface
+    colour to tint with - and a band tinted in nothing is not a band."""
+    painter = Recording()
+    out = render_markdown("```json\n{}\n```", 40, painter)
+    assert any("─" in line for line in out)
+
+
+def test_the_rule_is_never_shorter_than_the_code_it_encloses() -> None:
+    """A rule the content overhangs reads as a broken block."""
+    code = "x = " + "y" * 90
+    lines = plain(f"```python\n{code}\n```", width=120)
+    span = cell_width(lines[0])
+    assert all(cell_width(line) <= span for line in lines)
+    assert span >= cell_width(lines[1])
+
+
 def test_a_table_is_the_one_place_box_drawing_is_allowed() -> None:
     lines = plain("| a | b |\n| - | - |\n| 1 | 2 |")
     assert any("┼" in line for line in lines)

{hx_cli-0.2.0 → hx_cli-0.2.1}/tests/tui/views/test_blocks.py

@@ -80,6 +80,23 @@ def test_thinking_collapses_to_one_line() -> None:
     assert "reasoning" in " ".join(plain(block.render(40)))
 
 
+def test_thinking_is_shown_rather_than_hidden() -> None:
+    """The port collapsed it by default and wired no way to open it, so the
+    reasoning was simply not arriving."""
+    block = ThinkingMessage("first thought\nsecond thought")
+    shown = " ".join(plain(block.render(40)))
+    assert "first thought" in shown and "second thought" in shown
+
+
+def test_thinking_folds_with_the_same_key_as_a_tool_call() -> None:
+    block = ThinkingMessage("first thought\nsecond thought")
+    block.toggle()
+    folded = plain(block.render(40))
+    assert folded == [" Thinking… (2 lines)"], "folded, and says how much is folded"
+    block.toggle()
+    assert "second thought" in " ".join(plain(block.render(40)))
+
+
 # -- tool calls -------------------------------------------------------------