symphony-code 0.0.1__py3-none-any.whl

coding_agent/tui/transcript/surface.py

@@ -0,0 +1,345 @@
+"""Transcript mounting mixed into CodingAgentApp.
+
+Every transcript entry is mounted once and then updated in place. Groupable
+tool calls become rows of one ``ToolCallSummary`` per consecutive stretch (the
+render-time grouping fx does in ``tool_group_projection.zig``), so a status
+change only re-renders that group's text. Following the newest output is
+Textual's scroll anchor on ``#transcript``.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Mapping, Optional
+
+from textual import events
+from textual.containers import VerticalScroll
+from textual.geometry import Offset
+from textual.widget import Widget
+
+from coding_agent.tui.transcript.messages import (
+    AssistantMessage,
+    Notice,
+    RunSummary,
+    SelectableStatic,
+    Welcome,
+)
+from coding_agent.tui.transcript.process import (
+    ReasoningWidget,
+    RunProcess,
+    ThinkingStatus,
+)
+
+if TYPE_CHECKING:
+    # tools.* imports transcript.messages, so the runtime imports stay local.
+    from coding_agent.tui.tools.calls import ToolCallWidget
+    from coding_agent.tui.tools.snapshots import ToolCallSnapshot, ToolCallSummary
+
+
+class TranscriptScroll(VerticalScroll):
+    """The transcript viewport: anchored to its newest content.
+
+    Textual keeps an anchored widget at the bottom through every layout,
+    releases the anchor when the reader scrolls up, and restores it when they
+    scroll back to the end.
+    """
+
+    def on_mount(self) -> None:
+        self.anchor()
+
+    def _wheel_leaves_tail(self, event: events.MouseScrollUp | events.MouseScrollDown) -> bool:
+        """A plain wheel tick is the reader leaving the tail, not the stream.
+
+        Pointer scrolling does not release Textual's anchor (keyboard does).
+        Worse, a follow animation sets ``scroll_target_y`` at the end before
+        ``scroll_y`` arrives. A wheel tick then computes its next target from
+        that end, so the page never moves and the next layout snaps back.
+        Stop the animation and release before the tick is applied.
+        """
+        if event.ctrl or event.shift:
+            return False
+        self.app.animator.force_stop_animation(self, "scroll_y")
+        self.app.animator.force_stop_animation(self, "scroll_x")
+        if self.is_anchored:
+            self.release_anchor()
+        return True
+
+    # Textual dispatches a handler from every class in the MRO, so Widget's own
+    # wheel handler applies the tick after these. Calling super() scrolled twice.
+    def _on_mouse_scroll_down(self, event: events.MouseScrollDown) -> None:
+        self._wheel_leaves_tail(event)
+
+    def _on_mouse_scroll_up(self, event: events.MouseScrollUp) -> None:
+        self._wheel_leaves_tail(event)
+
+    def anchor(self, anchor: bool = True) -> None:
+        """Follow new content with a short scroll instead of an instant jump.
+
+        A reader who already scrolled away owns the viewport. Re-anchoring
+        them (a stream paint, a composer layout) is what makes the wheel
+        look dead.
+        """
+        if anchor and self._anchored and self._anchor_released:
+            return
+        self._anchored = anchor
+        if anchor:
+            self.scroll_end(animate=True, duration=0.35, easing="out_cubic")
+
+    @property
+    def scroll_offset(self) -> Offset:
+        """Keep short transcripts top-aligned while anchored.
+
+        While anchored, Textual parks ``scroll_y`` at ``content - viewport``,
+        which is negative until the transcript fills the screen and would push
+        the first rows down to the composer.
+        """
+        offset = super().scroll_offset
+        return Offset(offset.x, max(0, offset.y))
+
+
+class TranscriptSurface:
+    """TranscriptView implementation mixed into CodingAgentApp."""
+
+    def _mount_transcript(self, widget: Widget) -> None:
+        transcript = self.query_one("#transcript", VerticalScroll)
+        welcome = self.query(".welcome")
+        if welcome:
+            welcome.first().remove()
+        transcript.mount(widget)
+
+    def finalize_transcript_history(self) -> None:
+        """Freeze completed message renders after restoring history."""
+        for message in self.query(".message"):
+            if isinstance(message, SelectableStatic):
+                message.freeze_render()
+
+    def set_assistant(self, text: str, *, new: bool = False) -> None:
+        if new or self._assistant is None:
+            if self._thinking is not None:
+                self._thinking.set_visible(False)
+            self._assistant = AssistantMessage(text, streaming=True)
+            # Keep assistant text in the run timeline so tools and text stay in
+            # stream order: a later non-tool widget can close the open stretch.
+            if self._process is not None and not self._process.completed:
+                self._mount_process_item(self._assistant)
+            else:
+                self._mount_transcript(self._assistant)
+        else:
+            self._assistant.set_content(text, streaming=True)
+
+    def finish_assistant(self) -> None:
+        if self._assistant is not None:
+            self._assistant.finish_stream()
+
+    def invalidate_workspace_caches(self) -> None:
+        index = getattr(self, "_file_index", None)
+        if index is not None:
+            index.invalidate()
+
+    def set_thinking(self, text: str) -> None:
+        if self._thinking is None:
+            self._thinking = ThinkingStatus(text)
+            self._process = RunProcess(self._thinking)
+            self._mount_transcript(self._process)
+        else:
+            self._thinking.set_text(text)
+
+    def set_working(self, detail: str = "") -> None:
+        if self._thinking is None:
+            self.set_thinking("Working")
+        assert self._thinking is not None
+        self._thinking.set_visible(True)
+        self._thinking.set_working(detail)
+
+    def set_churning(self, turn: int = 0) -> None:
+        if self._thinking is None:
+            self.set_thinking("Churning")
+        assert self._thinking is not None
+        self._thinking.set_visible(True)
+        self._thinking.set_churning()
+        if self._process is not None:
+            self._process.place_thinking_last()
+
+    def _mount_process_item(self, widget: Widget) -> None:
+        """Append a run timeline entry; anything but a tool row ends the open group."""
+        if self._process is None:
+            self.set_thinking("Thinking…")
+        assert self._process is not None
+        self._close_tool_group()
+        self._process.add_item(widget)
+
+    def _close_tool_group(self) -> None:
+        if self._open_tool_group is not None:
+            self._open_tool_group.close()
+            self._open_tool_group = None
+
+    def set_reasoning(self, text: str, *, new: bool = False) -> None:
+        if new or self._reasoning is None:
+            if self._thinking is not None:
+                self._thinking.set_visible(False)
+            self._reasoning = ReasoningWidget(text)
+            self._mount_process_item(self._reasoning)
+        else:
+            self._reasoning.set_content(text)
+
+    def finish_reasoning(self) -> None:
+        if self._reasoning is None:
+            return
+        self._reasoning.complete()
+        self._reasoning = None
+
+    def add_tool(self, call_id: str, name: str) -> None:
+        self._show_tool(self._new_tool(call_id, name))
+
+    def _new_tool(self, call_id: str, name: str) -> ToolCallWidget:
+        from coding_agent.tui.tools.calls import make_tool_widget
+
+        if self._thinking is not None:
+            self._thinking.set_visible(False)
+        tool = make_tool_widget(call_id, name, workspace=self.workspace)
+        self._tools[call_id] = tool
+        return tool
+
+    def _show_tool(self, tool: ToolCallWidget) -> None:
+        """Mount an interactive card once, or place/update a row in its group."""
+        if tool.keep_in_transcript and not (
+            self._process is not None and self._process.completed and tool.status in {"done", "failed"}
+        ):
+            if not tool.is_attached:
+                self._mount_process_item(tool)
+            return
+        snapshot = tool.snapshot()
+        if self._process is not None and self._process.completed:
+            self._process.absorb_late_call(snapshot)
+            self._tool_groups[tool.call_id] = self._process.completed_summary or self._tool_groups.get(tool.call_id)
+            return
+        group = self._tool_groups.get(tool.call_id)
+        if group is not None and not (
+            group is self._open_tool_group and group.rejects_last(snapshot)
+        ):
+            group.update_call(snapshot)
+            return
+        if group is not None:
+            # Activity arrived with the arguments and no longer matches the
+            # stretch this call joined while it was still preparing.
+            group.remove_call(tool.call_id)
+        group = self._tool_group_for(snapshot)
+        group.add_call(snapshot)
+        self._tool_groups[tool.call_id] = group
+
+    def _tool_group_for(self, snapshot: ToolCallSnapshot) -> ToolCallSummary:
+        from coding_agent.tui.tools.snapshots import ToolCallSummary
+
+        group = self._open_tool_group
+        if group is not None and group.accepts(snapshot):
+            return group
+        group = ToolCallSummary(expanded=True)
+        self._mount_process_item(group)
+        self._open_tool_group = group
+        return group
+
+    def update_tool(
+        self,
+        call_id: str,
+        *,
+        tool_name: str = "tool",
+        arguments: Optional[Mapping[str, Any]] = None,
+        raw_arguments: str = "",
+        status: str = "preparing",
+        result: Any = None,
+    ) -> None:
+        tool = self._tools.get(call_id)
+        if tool is None:
+            if call_id in self._tool_groups:
+                return  # a finished group row is final; its model is released
+            tool = self._new_tool(call_id, tool_name)
+        if status == "running":
+            tool.set_running(arguments)
+        elif status in {"done", "failed"}:
+            tool.set_result(result)
+            if status == "failed":
+                tool.status = "failed"
+                tool.refresh_content()
+            if tool.tool_name in {"write_file", "patch", "bash"}:
+                self.invalidate_workspace_caches()
+        else:
+            tool.set_arguments(arguments, raw_arguments)
+        self._show_tool(tool)
+        if not tool.keep_in_transcript and status in {"done", "failed"}:
+            # The group row holds the finished call's snapshot. Dropping the
+            # unmounted model keeps a session from retaining a widget tree
+            # per finished call (and the GC work that comes with it).
+            del self._tools[call_id]
+
+    def append_tool_output(self, call_id: str, chunk: str) -> None:
+        """Feed a streamed output chunk to its Bash card, in place."""
+        from coding_agent.tui.tools.calls import BashToolWidget
+
+        tool = self._tools.get(call_id)
+        if isinstance(tool, BashToolWidget):
+            tool.append_output(chunk)
+
+    def add_notice(self, text: str, tone: str = "info") -> None:
+        notice = Notice(text, tone)
+        if self._busy and self._process is not None:
+            self._mount_process_item(notice)
+        else:
+            self._mount_transcript(notice)
+
+    def add_run_summary(
+        self,
+        summary: str,
+        *,
+        label: str = "summary so far",
+        event_type: str = "run_summary",
+    ) -> None:
+        widget = RunSummary(summary, label=label, event_type=event_type)
+        if self._busy and self._process is not None:
+            self._mount_process_item(widget)
+        else:
+            self._mount_transcript(widget)
+
+    def finish_process(
+        self, title: str, *, collapse: bool = True, verb: str = "", duration: str = ""
+    ) -> None:
+        """Collect successful run work and retain the final reply and metrics."""
+        self._close_tool_group()
+        if self._process is not None:
+            self._process.complete(title, collapse=collapse, verb=verb, duration=duration)
+
+    def mount_transcript(self, widget: Widget) -> None:
+        """Public adapter used by the persisted-history loader."""
+        self._mount_transcript(widget)
+
+    def mount_transcript_batch(self, widgets: list[Widget]) -> None:
+        """Mount restored history in one layout pass instead of one per row."""
+        if not widgets:
+            return
+        transcript = self.query_one("#transcript", VerticalScroll)
+        for welcome in self.query(".welcome"):
+            welcome.remove()
+        transcript.mount(*widgets)
+
+    def action_copy_selection(self) -> None:
+        """Copy the currently selected rendered transcript text to the clipboard."""
+        selected = self.screen.get_selected_text()
+        if selected:
+            self.copy_to_clipboard(selected)
+
+    def on_mouse_up(self, event: events.MouseUp) -> None:
+        """Copy the drag selection, then clear its highlight."""
+        if self.screen.get_selected_text():
+            self.action_copy_selection()
+            self.notify("Copied to clipboard!")
+            self.screen.clear_selection()
+
+    def action_clear_transcript(self) -> None:
+        transcript = self.query_one("#transcript", VerticalScroll)
+        transcript.remove_children()
+        transcript.mount(Welcome(self.workspace))
+        self._assistant = None
+        self._thinking = None
+        self._reasoning = None
+        self._process = None
+        self._tools.clear()
+        self._tool_groups.clear()
+        self._open_tool_group = None

coding_agent/tui/transcript/thinking_markdown.py

@@ -0,0 +1,314 @@
+"""Markdown for thinking text: muted block rendering and one-line previews.
+
+Thinking is rendered into plain Rich ``Text`` (wrapped in a ``Group`` and
+grids for lists) rather than Rich's ``Markdown`` renderable or Textual's
+``Markdown`` widget. ``Text`` carries only emphasis (bold, italic, strike,
+underline) and inherits the widget's CSS colour, so the muted thinking tone
+comes from theme.toml instead of Rich's ``markdown.*`` palette. It also costs
+one markdown-it parse per paint, with no child widgets to mount.
+
+Thinking streams token by token, so ``render_thinking(..., streaming=True)``
+first closes a dangling ``**``/``*``/backtick in the last paragraph: a
+half-written ``**Tracing the`` renders bold instead of showing raw asterisks,
+and the real closing marker replaces the synthetic one on the next chunk.
+
+Streaming renders freeze every top-level block except the unfinished tail.
+Later chunks reuse that frozen renderable and parse only the tail, matching
+the stable-checkpoint approach used by Grok's streaming Markdown renderer.
+"""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Iterator
+
+from markdown_it import MarkdownIt
+from markdown_it.tree import SyntaxTreeNode
+from rich.console import Group, RenderableType
+from rich.padding import Padding
+from rich.style import Style
+from rich.table import Table
+from rich.text import Text
+
+PARSER = MarkdownIt("commonmark").enable("strikethrough")
+FENCE_LINE = re.compile(r"^[ \t]{0,3}(?:```|~~~)", re.MULTILINE)
+BULLETS = ("•", "◦", "▪")
+QUOTE_BAR = "│"
+RULE = "───"
+CODE_BLOCK_INDENT = 2
+PLAIN = Style()
+BOLD = Style(bold=True)
+ITALIC = Style(italic=True)
+STRIKE = Style(strike=True)
+LINK = Style(underline=True)
+HEADING = Style(bold=True)
+TOP_HEADING = Style(bold=True, underline=True)
+BLOCK_SEPARATOR = " · "
+
+
+def close_dangling_markers(source: str) -> str:
+    """Close or drop emphasis/code markers left open by a partial stream.
+
+    Only the last paragraph is scanned: earlier paragraphs are complete, and
+    an open code fence is left alone because markdown-it already renders an
+    unclosed fence up to the end of the text.
+    """
+    if len(FENCE_LINE.findall(source)) % 2:
+        return source
+    length = len(source)
+    index = source.rfind("\n\n") + 1
+    opened: list[tuple[str, int]] = []
+    code_marker = ""
+    code_at = -1
+    while index < length:
+        character = source[index]
+        if character == "\\":
+            index += 2
+            continue
+        if character in "`*":
+            run = len(source[index:]) - len(source[index:].lstrip(character))
+            if character == "`":
+                if code_at < 0:
+                    code_marker, code_at = source[index : index + run], index
+                elif run == len(code_marker):
+                    code_marker, code_at = "", -1
+            elif code_at < 0:
+                before = source[index - 1] if index else " "
+                # A run at the very end is a marker still being typed: treat
+                # it as an opener so the empty emphasis is dropped below.
+                after = source[index + run] if index + run < length else character
+                for marker in ("**",) * (run // 2) + ("*",) * (run % 2):
+                    if opened and opened[-1][0] == marker and not before.isspace():
+                        opened.pop()
+                    elif not after.isspace():
+                        opened.append((marker, index))
+            index += run
+            continue
+        index += 1
+    if code_at >= 0:
+        opened.append((code_marker, code_at))
+    closed = source
+    for marker, position in reversed(opened):
+        if closed[position + len(marker) :].strip():
+            closed = closed.rstrip() + marker
+        else:
+            closed = closed[:position].rstrip()
+    return closed
+
+
+class StreamingThinkingRenderer:
+    """Freeze stable top-level blocks and reparse only the unfinished tail."""
+
+    def __init__(self) -> None:
+        self._source = ""
+        self._style: Style | None = None
+        self._frozen = Group()
+        self._frozen_end = 0
+        self._scan_start = 0
+        self._group: Group | None = None
+        self._group_tail = ""
+
+    def render(self, source: str, *, code_style: Style) -> RenderableType:
+        if not source.startswith(self._source[: self._frozen_end]) or code_style != self._style:
+            self._source = ""
+            self._style = code_style
+            self._frozen = Group()
+            self._frozen_end = 0
+            self._scan_start = 0
+            self._group = None
+            self._group_tail = ""
+        self._source = source
+        text = close_dangling_markers(source)
+        frozen_end, self._scan_start = _stable_prefix_end(source, text, self._scan_start)
+        if frozen_end < self._frozen_end:
+            self._frozen = Group()
+            self._frozen_end = 0
+        if frozen_end > self._frozen_end:
+            added = SyntaxTreeNode(PARSER.parse(source[self._frozen_end:frozen_end])).children
+            rendered = render_blocks(added, code_style, depth=0, loose=True)
+            if self._frozen.renderables and rendered:
+                self._frozen.renderables.append(Text())
+            self._frozen.renderables.extend(rendered)
+            self._frozen_end = frozen_end
+        tail = text[self._frozen_end :]
+        if self._group is not None and tail == self._group_tail:
+            return self._group
+        tail_blocks = SyntaxTreeNode(PARSER.parse(tail)).children if tail.strip() else []
+        rendered_tail = render_blocks(tail_blocks, code_style, depth=0, loose=True)
+        blocks = list(self._frozen.renderables)
+        if blocks and rendered_tail:
+            blocks.append(Text())
+        self._group_tail = tail
+        self._group = Group(*blocks, *rendered_tail) if blocks or rendered_tail else Group(Text(" "))
+        return self._group
+
+
+def render_thinking(source: str, *, code_style: Style, streaming: bool) -> RenderableType:
+    """Render thinking markdown as emphasis-only Text blocks in the widget's colour."""
+    text = close_dangling_markers(source) if streaming else source
+    root = SyntaxTreeNode(PARSER.parse(text))
+    rendered = render_blocks(root.children, code_style, depth=0, loose=True)
+    return Group(*rendered) if rendered else Text(" ")
+
+
+def _stable_prefix_end(source: str, display_text: str, scan_start: int) -> tuple[int, int]:
+    """Return the frozen byte end and where the next tail scan can resume.
+
+    Nested blocks are not checkpoints because their container can continue.
+    A display-only closing marker means the final paragraph is unfinished.
+    ``scan_start`` advances with the stream, so each update scans only the
+    newly closed tail rather than the whole thought.
+    """
+    if display_text != source or len(FENCE_LINE.findall(source)) % 2:
+        return 0, 0
+    start = _checkpoint_scan_start(source, scan_start)
+    if start == 0:
+        return 0, 0
+    tokens = PARSER.parse(source[start:])
+    closed = [token for token in tokens if token.level == 0 and token.map and token.nesting == 0]
+    if len(closed) < 2:
+        return start, start
+    keep = len(closed) - 1 if _tail_can_extend(closed[-1]) else len(closed)
+    if keep < 1:
+        return start, start
+    lines = source[start:].splitlines(keepends=True)
+    frozen = start + sum(len(line) for line in lines[: closed[keep - 1].map[1]])
+    # An open container must stay inside the next scan. Advancing past it made
+    # every following block unfreezable.
+    return frozen, start if keep < len(closed) else frozen
+
+
+def _tail_can_extend(token: object) -> bool:
+    """A following paragraph can continue these top-level containers."""
+    return getattr(token, "type", "") in {
+        "bullet_list_close",
+        "ordered_list_close",
+        "blockquote_close",
+    }
+
+
+def _checkpoint_scan_start(source: str, scan_start: int) -> int:
+    """Return the newest paragraph boundary followed by another closed block."""
+    cursor = scan_start
+    start = scan_start
+    while True:
+        found = source.find("\n\n", cursor)
+        if found < 0:
+            return start
+        nxt = found + 2
+        if "\n\n" in source[nxt:]:
+            start = nxt
+        cursor = nxt
+
+
+def render_blocks(
+    nodes: list[SyntaxTreeNode], code_style: Style, *, depth: int, loose: bool
+) -> list[RenderableType]:
+    """Render sibling blocks, with a blank row between them when ``loose``."""
+    rendered: list[RenderableType] = []
+    for node in nodes:
+        if rendered and loose:
+            rendered.append(Text())
+        rendered.append(render_block(node, code_style, depth=depth))
+    return rendered
+
+
+def render_block(node: SyntaxTreeNode, code_style: Style, *, depth: int) -> RenderableType:
+    match node.type:
+        case "paragraph":
+            return render_inline(node.children, code_style, PLAIN)
+        case "heading":
+            style = TOP_HEADING if node.tag == "h1" else HEADING
+            return render_inline(node.children, code_style, style)
+        case "bullet_list" | "ordered_list":
+            return render_list(node, code_style, depth=depth)
+        case "blockquote":
+            grid = Table.grid(expand=True, padding=0)
+            grid.add_column(width=2, no_wrap=True)
+            grid.add_column(ratio=1)
+            body = render_blocks(node.children, code_style, depth=depth, loose=True)
+            grid.add_row(Text(QUOTE_BAR), Group(*body))
+            return grid
+        case "fence" | "code_block":
+            code = Text(node.content.rstrip("\n"), style=code_style)
+            return Padding(code, (0, 0, 0, CODE_BLOCK_INDENT))
+        case "hr":
+            return Text(RULE)
+        case _:
+            return Text(node.content.rstrip("\n"))
+
+
+def render_list(node: SyntaxTreeNode, code_style: Style, *, depth: int) -> Table:
+    """A list as a grid so wrapped item text hangs under the item, not the marker."""
+    if node.type == "ordered_list":
+        start = int(node.attrs.get("start", 1))
+        markers = [f"{start + offset}." for offset in range(len(node.children))]
+    else:
+        markers = [BULLETS[depth % len(BULLETS)]] * len(node.children)
+    grid = Table.grid(expand=True, padding=0)
+    grid.add_column(width=max(len(marker) for marker in markers) + 1, no_wrap=True)
+    grid.add_column(ratio=1)
+    for marker, item in zip(markers, node.children):
+        loose = any(not child.hidden for child in item.children if child.type == "paragraph")
+        body = render_blocks(item.children, code_style, depth=depth + 1, loose=loose)
+        grid.add_row(Text(marker), Group(*body))
+    return grid
+
+
+def render_inline(nodes: list[SyntaxTreeNode], code_style: Style, style: Style) -> Text:
+    """Render a block's inline children (markdown-it wraps them in one ``inline`` node)."""
+    text = Text(style=style)
+    for node in nodes:
+        append_inline(text, node, code_style, PLAIN)
+    return text
+
+
+def append_inline(text: Text, node: SyntaxTreeNode, code_style: Style, style: Style) -> None:
+    match node.type:
+        case "inline":
+            for child in node.children:
+                append_inline(text, child, code_style, style)
+        case "strong" | "em" | "s" | "link" | "image":
+            emphasis = {"strong": BOLD, "em": ITALIC, "s": STRIKE}.get(node.type, LINK)
+            href = str((node.attrs or {}).get("href") or "")
+            # Rich only opens a link when the span carries one. Styling the
+            # text as a link without the target is why clicks did nothing.
+            if node.type == "link" and href.startswith(("http://", "https://")):
+                emphasis = emphasis + Style(link=href)
+            for child in node.children:
+                append_inline(text, child, code_style, style + emphasis)
+        case "code_inline":
+            text.append(node.content, style=style + code_style)
+        case "softbreak" | "hardbreak":
+            text.append("\n")
+        case _:
+            text.append(node.content, style=style)
+
+
+def thinking_plain_text(source: str) -> str:
+    """Thinking markdown as one line of plain text, every marker stripped.
+
+    Blocks (headings, paragraphs, list items, code) are joined with `` · `` so
+    a bold lead-in such as ``**Checking the caller**`` stays apart from the
+    prose after it.
+    """
+    blocks = (" ".join(block.split()) for block in plain_blocks(SyntaxTreeNode(PARSER.parse(source))))
+    return BLOCK_SEPARATOR.join(block for block in blocks if block)
+
+
+def plain_blocks(node: SyntaxTreeNode) -> Iterator[str]:
+    if node.type == "inline":
+        yield "".join(plain_inline(child) for child in node.children)
+    elif node.children:
+        for child in node.children:
+            yield from plain_blocks(child)
+    else:
+        yield node.content
+
+
+def plain_inline(node: SyntaxTreeNode) -> str:
+    if node.type in {"softbreak", "hardbreak"}:
+        return " "
+    if node.children:
+        return "".join(plain_inline(child) for child in node.children)
+    return node.content