monkeybot-cli 0.11.1__tar.gz → 0.12.0__tar.gz

{monkeybot_cli-0.11.1 → monkeybot_cli-0.12.0}/.gitignore

@@ -11,6 +11,9 @@ internal/
 # Local scaffolded harness config (defaults ship in monkeybot-cli scaffold_defaults/)
 /monkeybot_config/
 
+# Local agent for manual CLI testing. Recreate with `monkeybot new --dest ./cli-agent`.
+/cli-agent/
+
 # Live eval run artifacts. Baselines under regression/t4/baselines/ stay versioned.
 /regression/t4/runs/
 # Live-eval agent project local state. Live secrets come from the repo-root .env; a stray key

{monkeybot_cli-0.11.1 → monkeybot_cli-0.12.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: monkeybot-cli
-Version: 0.11.1
+Version: 0.12.0
 Summary: CLI to create, configure, validate, and chat with monkeybot agents.
 Requires-Python: >=3.11
 Requires-Dist: httpx>=0.27.0

{monkeybot_cli-0.11.1 → monkeybot_cli-0.12.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "monkeybot-cli"
-version = "0.11.1"
+version = "0.12.0"
 description = "CLI to create, configure, validate, and chat with monkeybot agents."
 requires-python = ">=3.11"
 dependencies = [

{monkeybot_cli-0.11.1 → monkeybot_cli-0.12.0}/src/monkeybot_cli/chat_tui.py

@@ -57,6 +57,7 @@ from monkeybot_cli.chat_tui_widgets import (
     ToolCallBlock,
     TranscriptPane,
     UserTurn,
+    activity_label,
     write_osc52_clipboard,
 )
 from monkeybot_cli.config_resolve import load_config_doc, resolve_config
@@ -360,6 +361,7 @@ class ChatApp(App[int]):
         self._assistant: AssistantTurn | None = None
         self._thinking: ThinkingLine | None = None
         self._thinking_trace: ThinkingTrace | None = None
+        self._status_note = ""
         self._hitl_card: HitlCard | None = None
         self._hitl_status_flash: str | None = None
         self._ring_text = "[dim]○ 0%[/]"
@@ -433,7 +435,10 @@ class ChatApp(App[int]):
         if self._hitl_status_flash:
             parts.append(self._hitl_status_flash)
         if self._turn_active and not self._hitl_active:
-            parts.append("working · Esc interrupt")
+            if self._status_note:
+                parts.append(f"{self._status_note} · Esc interrupt")
+            else:
+                parts.append("working · Esc interrupt")
         elif self._hitl_active:
             if self._hitl_kind == "elicit":
                 parts.append("Enter submit · Ctrl-C cancel")
@@ -647,8 +652,24 @@ class ChatApp(App[int]):
                 transcript.mount(earlier, before=0)
             earlier.absorb(digest)
 
+    def _mark_activity_lead(self, widget: object) -> None:
+        """First row of a thought/tool/search stack gets the gap above it."""
+        if not isinstance(widget, (ThinkingTrace, ToolCallBlock, GroundingBlock)):
+            return
+        prev = None
+        for child in reversed(self._transcript().children):
+            if child is widget or getattr(child, "id", None) == "empty-hint":
+                continue
+            if isinstance(child, ThinkingTrace) and not child._raw.strip():
+                continue
+            prev = child
+            break
+        if not isinstance(prev, (ThinkingTrace, ToolCallBlock, GroundingBlock)):
+            widget.add_class("-lead")
+
     def _mount(self, widget: object) -> None:
         self._hide_empty_hint()
+        self._mark_activity_lead(widget)
         if self._is_counted_turn(widget):
             self._trim_old_turns()
             self._turn_count += 1
@@ -673,10 +694,33 @@ class ChatApp(App[int]):
             self._thinking.remove()
         self._thinking = None
 
+    def _drop_empty_thinking(self) -> None:
+        trace = self._thinking_trace
+        if trace is None or not trace.is_attached or trace._raw.strip():
+            return
+        already = bool(getattr(trace, "_trimmed", False))
+        trace._trimmed = True  # type: ignore[attr-defined]
+        trace.remove()
+        self._thinking_trace = None
+        if not already:
+            self._turn_count = max(0, self._turn_count - 1)
+
+    def _ensure_live_thinking(self) -> None:
+        trace = self._thinking_trace
+        if trace is not None and trace.is_attached and not trace.has_class("-done"):
+            return
+        self._clear_thinking()
+        block = ThinkingTrace()
+        self._thinking_trace = block
+        self._mount(block)
+
     def _finish_thinking_trace(self, *, clear: bool = False) -> None:
-        if self._thinking_trace is not None and self._thinking_trace.is_attached:
-            if not self._thinking_trace.has_class("-done"):
-                self._thinking_trace.finish()
+        trace = self._thinking_trace
+        if trace is not None and trace.is_attached:
+            if not trace._raw.strip():
+                self._drop_empty_thinking()
+            elif not trace.has_class("-done"):
+                trace.finish()
         if clear:
             self._thinking_trace = None
 
@@ -973,7 +1017,11 @@ class ChatApp(App[int]):
         self._follow_scroll()
 
     def _ev_thinking(self, p: dict) -> None:
-        self._show_thinking(str(p.get("text") or "thinking…"))
+        text = str(p.get("text") or "thinking…")
+        if text.strip().lower() in {"thinking…", "thinking...", "thinking"}:
+            self._ensure_live_thinking()
+            return
+        self._show_thinking(text)
 
     def _ev_thinking_clear(self, _p: dict) -> None:
         self._clear_thinking()
@@ -981,13 +1029,16 @@ class ChatApp(App[int]):
     def _ev_turn_started(self, _p: dict) -> None:
         self._turn_active = True
         self._assistant = None
+        self._status_note = ""
         self._seal_thinking_trace()
         self._clear_open_tools()
-        self._show_thinking("thinking…")
+        self._clear_thinking()
+        self._ensure_live_thinking()
         self._refresh_status()
 
     def _ev_assistant_start(self, _p: dict) -> None:
         self._clear_thinking()
+        self._drop_empty_thinking()
 
     def _ev_assistant_delta(self, p: dict) -> None:
         delta = str(p.get("delta", ""))
@@ -1027,30 +1078,49 @@ class ChatApp(App[int]):
 
     def _ev_summarizing(self, p: dict) -> None:
         tokens = int(p.get("tokens") or 0)
-        self._show_thinking(f"summarizing context ({tokens:,} tokens)")
+        self._drop_empty_thinking()
+        self._clear_thinking()
+        self._status_note = f"summarizing context ({tokens:,} tokens)"
+        self._refresh_status()
 
     def _ev_summarized(self, p: dict) -> None:
         turns = int(p.get("turns") or 0)
         noun = "turn" if turns == 1 else "turns"
-        self._show_thinking(f"summarized {turns} {noun}")
+        self._status_note = f"summarized {turns} {noun}"
+        self._refresh_status()
 
     def _ev_grounding(self, p: dict) -> None:
         self._clear_thinking()
+        self._drop_empty_thinking()
         queries = p.get("search_queries") or []
-        lines = ["**grounded search**"]
-        if queries:
-            q = ", ".join(f'"{q}"' for q in queries)
-            lines[0] += f" — {q}"
-        for source in (p.get("sources") or [])[:5]:
-            if not isinstance(source, dict):
-                continue
+        raw_sources = p.get("sources") or []
+        sources = [source for source in raw_sources if isinstance(source, dict)]
+        lines: list[str] = []
+        shown = 0
+        linked = 0
+        for source in sources:
             title = str(source.get("title") or "").strip()
             uri = str(source.get("uri") or "").strip()
             if not uri:
                 continue
+            linked += 1
+            if shown >= 5:
+                continue
+            shown += 1
             label = title or uri
             lines.append(f"- [{label}]({uri})")
-        self._mount(GroundingBlock("\n".join(lines)))
+        query_text = ", ".join(str(query).strip() for query in queries if str(query).strip())
+        if query_text and linked:
+            noun = "source" if linked == 1 else "sources"
+            hint = f"{query_text} · {linked} {noun}"
+        elif query_text:
+            hint = query_text
+        elif linked:
+            noun = "source" if linked == 1 else "sources"
+            hint = f"{linked} {noun}"
+        else:
+            hint = ""
+        self._mount(GroundingBlock("\n".join(lines), title=activity_label("Web", hint)))
 
     def _ev_turn_error(self, p: dict) -> None:
         self._close_assistant()
@@ -1157,9 +1227,10 @@ class ChatApp(App[int]):
     def _ev_stream_ended(self, _p: dict) -> None:
         self._exit_code = 1 if self._controller.stream_error else self._exit_code
 
-    def _ev_thinking_trace(self, p: dict) -> None:
-        # Legacy --show-thinking path; prefer thinking_block_* when present.
-        self._show_thinking(f"thinking  {p.get('text')}")
+    def _ev_thinking_trace(self, _p: dict) -> None:
+        # thinking_block_* owns the collapsed row. This legacy event would
+        # print the trace inline.
+        return
 
     def _ev_thinking_block_delta(self, p: dict) -> None:
         text = str(p.get("text") or "")
@@ -1230,6 +1301,7 @@ class ChatApp(App[int]):
     def _finish_turn_ui(self) -> None:
         self._turn_active = False
         self._assistant = None
+        self._status_note = ""
         self._clear_open_tools()
         self._refresh_status()
         self.query_one("#prompt", Composer).focus()

{monkeybot_cli-0.11.1 → monkeybot_cli-0.12.0}/src/monkeybot_cli/chat_tui_widgets.py

@@ -39,6 +39,38 @@ def _plain_title(text: str) -> Content:
     return Content.from_text(text, markup=False)
 
 
+_KIND_WIDTH = 7
+_HINT_MAX = 72
+
+
+def activity_label(kind: str, hint: str = "") -> str:
+    """One activity row: kind padded so hints share a column (``Thought  …``)."""
+    kind = " ".join(kind.split())
+    hint = " ".join(hint.split())
+    if len(hint) > _HINT_MAX:
+        hint = hint[:_HINT_MAX] + "…"
+    if not hint:
+        return kind
+    return f"{kind:<{_KIND_WIDTH}}  {hint}"
+
+
+def activity_label_from_title(title: str) -> str:
+    """Align a ``Kind  hint`` title that ``tool_collapsed_title`` already built."""
+    kind, sep, hint = title.partition("  ")
+    if not sep:
+        return activity_label(kind)
+    return activity_label(kind, hint)
+
+
+def _set_collapsed_mark(widget: Collapsible, mark: str) -> None:
+    """The disclosure symbol is the row's only glyph (spinner, ▸, ✓, ✗)."""
+    title = widget._title
+    if title.collapsed_symbol == mark:
+        return
+    title.collapsed_symbol = mark
+    title._update_label()
+
+
 def write_osc52_clipboard(app: App[object], text: str) -> bool:
     """Best-effort OSC 52 clipboard write via the Textual driver."""
     try:
@@ -110,59 +142,105 @@ class ThinkingLine(Static):
             self.update(Text(f"{self._label}  {elapsed}s", style="dim italic"))
 
 
-class ThinkingTrace(Vertical):
-    """OpenCode-style thinking block: ``Thinking...`` / body / ``...done thinking.``"""
+class ThinkingTrace(Collapsible):
+    """Collapsed thinking row. Click it (or focus it and press Enter) to read the trace."""
 
     DEFAULT_CSS = """
     ThinkingTrace {
         width: 1fr;
         height: auto;
-        margin-top: 1;
+        background: transparent;
+        border-top: none;
         padding: 0 1;
-    }
-    ThinkingTrace > .header {
-        height: 1;
+        margin-top: 0;
         color: $muted;
-        text-style: bold dim;
     }
-    ThinkingTrace > .body {
-        height: auto;
-        color: $muted;
-        text-style: dim;
+    ThinkingTrace.-lead {
+        margin-top: 1;
     }
-    ThinkingTrace > .footer {
-        height: 1;
-        color: $muted;
-        text-style: bold dim;
-        display: none;
+    ThinkingTrace > Contents {
+        width: 1fr;
+        height: auto;
+        padding: 0 1 1 3;
+        color: $disabled;
     }
-    ThinkingTrace.-done > .footer {
-        display: block;
+    ThinkingTrace .thinking-body {
+        width: 1fr;
+        height: auto;
+        margin: 0;
+        padding: 0;
+        background: transparent;
+        color: $disabled;
     }
     """
 
     def __init__(self, **kwargs: object) -> None:
-        super().__init__(**kwargs)  # type: ignore[arg-type]
         self._raw = ""
+        self._done = False
+        self._spin_i = 0
+        self._spin_timer: Timer | None = None
+        self._body = Static("", classes="thinking-body")
+        super().__init__(
+            self._body,
+            title=_plain_title("Thinking…"),  # type: ignore[arg-type]
+            collapsed=True,
+            collapsed_symbol="▸",
+            expanded_symbol="▾",
+            **kwargs,  # type: ignore[arg-type]
+        )
 
-    def compose(self) -> ComposeResult:
-        yield Static("Thinking...", classes="header")
-        yield Static("", classes="body")
-        yield Static("...done thinking.", classes="footer")
+    def on_mount(self) -> None:
+        self._start_spinner()
+
+    def on_unmount(self) -> None:
+        self._stop_spinner()
 
     def append_delta(self, chunk: str) -> None:
         if not chunk:
             return
         self._raw += chunk
-        with contextlib.suppress(NoMatches):
-            self.query_one(".body", Static).update(Text(self._raw, style="dim"))
+        self._body.update(Text(self._raw, style="dim"))
 
     def finish(self) -> None:
+        self._done = True
+        self._stop_spinner()
         self.add_class("-done")
+        _set_collapsed_mark(self, "▸")
+        self.title = _plain_title(activity_label("Thought", self._preview()))  # type: ignore[assignment]
 
     def reopen(self) -> None:
         """Allow late thinking deltas to continue this block after a premature close."""
+        self._done = False
         self.remove_class("-done")
+        self.title = _plain_title("Thinking…")  # type: ignore[assignment]
+        _set_collapsed_mark(self, "▸")
+        self._start_spinner()
+
+    def _preview(self) -> str:
+        return " ".join(self._raw.split())
+
+    def _start_spinner(self) -> None:
+        if self._done or not self.is_mounted:
+            return
+        self.title = _plain_title("Thinking…")  # type: ignore[assignment]
+        if not bool(getattr(self.app, "animations_enabled", True)):
+            _set_collapsed_mark(self, "▸")
+            return
+        if self._spin_timer is None:
+            self._spin_timer = self.set_interval(0.08, self._tick_spinner)
+        self._tick_spinner()
+
+    def _stop_spinner(self) -> None:
+        if self._spin_timer is not None:
+            self._spin_timer.stop()
+            self._spin_timer = None
+
+    def _tick_spinner(self) -> None:
+        if self._done:
+            return
+        glyph = _SPIN[self._spin_i % len(_SPIN)]
+        self._spin_i += 1
+        _set_collapsed_mark(self, glyph)
 
 
 class SystemLine(Static):
@@ -193,32 +271,50 @@ class SystemLine(Static):
         self.update(Text(self.body, style=style))
 
 
-class GroundingBlock(Vertical):
-    """Grounding sources with clickable markdown links."""
+class GroundingBlock(Collapsible):
+    """Collapsed web-search row. Open it to read the source links."""
 
     DEFAULT_CSS = """
     GroundingBlock {
         width: 1fr;
         height: auto;
-        margin-top: 1;
+        background: transparent;
+        border-top: none;
         padding: 0 1;
+        margin-top: 0;
+        color: $muted;
+    }
+    GroundingBlock.-lead {
+        margin-top: 1;
     }
-    GroundingBlock > Markdown {
+    GroundingBlock > Contents {
+        width: 1fr;
+        height: auto;
+        padding: 0 1 1 3;
+        color: $disabled;
+    }
+    GroundingBlock .grounding-body {
+        width: 1fr;
         height: auto;
         margin: 0;
         padding: 0;
         background: transparent;
-        color: $muted;
+        color: $disabled;
     }
     """
 
-    def __init__(self, markdown: str, **kwargs: object) -> None:
-        super().__init__(**kwargs)  # type: ignore[arg-type]
+    def __init__(self, markdown: str, *, title: str = "Web", **kwargs: object) -> None:
         self.markdown = markdown
         self.mounted_at = datetime.now()
-
-    def compose(self) -> ComposeResult:
-        yield Markdown(self.markdown, open_links=True)
+        body = Markdown(markdown, open_links=True, classes="grounding-body")
+        super().__init__(
+            body,
+            title=_plain_title(title),  # type: ignore[arg-type]
+            collapsed=True,
+            collapsed_symbol="▸",
+            expanded_symbol="▾",
+            **kwargs,  # type: ignore[arg-type]
+        )
 
 
 class EarlierTurns(Collapsible):
@@ -289,7 +385,7 @@ class UserTurn(Static):
         content = Text()
         if self.show_timestamp:
             content.append(self.mounted_at.strftime("%H:%M:%S "), style="dim")
-        content.append("you\n", style="bold")
+        content.append("you\n", style="dim")
         content.append(self.body)
         self.update(content)
 
@@ -304,7 +400,7 @@ class AssistantTurn(Vertical):
         margin-top: 1;
         padding: 0 1;
     }
-    AssistantTurn > .role {
+    AssistantTurn > .stamp {
         height: 1;
         color: $muted;
         text-style: dim;
@@ -335,22 +431,24 @@ class AssistantTurn(Vertical):
         self.show_timestamp = show_timestamp
 
     def compose(self) -> ComposeResult:
-        yield Static(self._role_label(), classes="role")
+        yield Static("", classes="stamp")
         yield Markdown("", open_links=False, classes="body")
         yield Static("▍", classes="cursor")
 
-    def _role_label(self) -> str:
+    def _stamp_text(self) -> str:
         if self.show_timestamp:
-            return f"{self.mounted_at.strftime('%H:%M:%S')}  assistant"
-        return "assistant"
+            return self.mounted_at.strftime("%H:%M:%S")
+        return ""
 
     def refresh_label(self) -> None:
         with contextlib.suppress(NoMatches):
-            self.query_one(".role", Static).update(self._role_label())
+            stamp = self.query_one(".stamp", Static)
+            text = self._stamp_text()
+            stamp.update(text)
+            stamp.display = bool(text)
 
     def on_mount(self) -> None:
-        # Flush timer is started lazily on first delta (and paused when drained).
-        return
+        self.refresh_label()
 
     def append_delta(self, chunk: str) -> None:
         if not chunk:
@@ -403,6 +501,9 @@ class ToolCallBlock(Collapsible):
         margin-top: 0;
         color: $muted;
     }
+    ToolCallBlock.-lead {
+        margin-top: 1;
+    }
     ToolCallBlock > Contents {
         width: 1fr;
         height: auto;
@@ -452,10 +553,10 @@ class ToolCallBlock(Collapsible):
         )
         super().__init__(
             self._detail,
-            title=_plain_title(f"  {title}"),  # type: ignore[arg-type]
+            title=_plain_title(activity_label_from_title(title)),  # type: ignore[arg-type]
             collapsed=True,
-            collapsed_symbol="▶",
-            expanded_symbol="▼",
+            collapsed_symbol="▸",
+            expanded_symbol="▾",
             classes="running",
             **kwargs,  # type: ignore[arg-type]
         )
@@ -466,14 +567,14 @@ class ToolCallBlock(Collapsible):
             self._spin_timer = self.set_interval(0.08, self._tick_spinner)
             self._tick_spinner()
         else:
-            self.title = _plain_title(f"  {self.display_label}")  # type: ignore[assignment]
+            _set_collapsed_mark(self, "▸")
 
     def _tick_spinner(self) -> None:
         if self.status != "running":
             return
         glyph = _SPIN[self._spin_i % len(_SPIN)]
         self._spin_i += 1
-        self.title = _plain_title(f"  {glyph} {self.display_label}")  # type: ignore[assignment]
+        _set_collapsed_mark(self, glyph)
 
     def mark_finished(self, *, error: object = None, result: str = "") -> None:
         self.status = "error" if error else "ok"
@@ -482,8 +583,8 @@ class ToolCallBlock(Collapsible):
         if self._spin_timer is not None:
             self._spin_timer.stop()
             self._spin_timer = None
-        mark = "✗" if error else "✓"
-        self.title = _plain_title(f"  {mark} {self.display_label}")  # type: ignore[assignment]
+        _set_collapsed_mark(self, "✗" if error else "✓")
+        self.title = _plain_title(activity_label_from_title(self.display_label))  # type: ignore[assignment]
         self._detail.update(
             format_tool_expand_body(
                 self.tool_name,

{monkeybot_cli-0.11.1 → monkeybot_cli-0.12.0}/tests/test_chat_tui.py

@@ -592,6 +592,10 @@ def test_grounding_mounts_markdown_links(tmp_path: Path) -> None:
             await pilot.pause()
             blocks = list(app.query(GroundingBlock))
             assert len(blocks) == 1
+            assert blocks[0].collapsed is True
+            assert "Web" in str(blocks[0].title)
+            assert "monkeys" in str(blocks[0].title)
+            assert "1 source" in str(blocks[0].title)
             assert "https://example.com" in blocks[0].markdown
             assert "[Docs]" in blocks[0].markdown
 
@@ -1212,24 +1216,36 @@ def test_thinking_trace_streams_and_finishes(tmp_path: Path) -> None:
             await pilot.pause()
             assert app._thinking_trace is not None
             assert "The user said hello" in app._thinking_trace._raw
-            header = app._thinking_trace.query_one(".header")
-            assert "Thinking" in str(header.render())
+            assert app._thinking_trace.collapsed is True
+            assert "Thinking" in str(app._thinking_trace.title)
             assert not app._thinking_trace.has_class("-done")
 
             app._ev_thinking_block_delta({"text": " — reply briefly."})
             await pilot.pause()
             assert "reply briefly" in app._thinking_trace._raw
+            assert app._thinking_trace.collapsed is True
 
             app._ev_thinking_block_complete({})
             await pilot.pause()
-            # Finished block stays mounted; pointer kept for late re-entry.
+            # Finished block stays mounted and collapsed; pointer kept for late re-entry.
             assert app._thinking_trace is not None
             assert app._thinking_trace.has_class("-done")
+            assert app._thinking_trace.collapsed is True
+            assert "Thought" in str(app._thinking_trace.title)
+            assert "hello" in str(app._thinking_trace.title)
+            assert app._thinking_trace._title.collapsed_symbol == "▸"
             traces = list(app.query(ThinkingTrace))
             assert len(traces) == 1
             assert traces[0].has_class("-done")
+            assert traces[0].collapsed is True
             assert "The user said hello — reply briefly." in traces[0]._raw
 
+            await pilot.click(traces[0].children[0])
+            await pilot.pause()
+            assert traces[0].collapsed is False
+            body = traces[0].query_one(".thinking-body")
+            assert "The user said hello — reply briefly." in str(body.render())
+
             app._ev_turn_complete({})
             await pilot.pause()
             assert app._thinking_trace is None
@@ -1272,6 +1288,7 @@ def test_late_thinking_delta_reopens_same_block(tmp_path: Path) -> None:
             assert len(traces) == 1
             assert "ask what they'd like me to build." in traces[0]._raw
             assert traces[0].has_class("-done")
+            assert traces[0].collapsed is True
 
             # Thinking block must still sit above the assistant turn.
             children = list(app._transcript().children)

{monkeybot_cli-0.11.1 → monkeybot_cli-0.12.0}/uv.lock

@@ -633,7 +633,7 @@ wheels = [
 
 [[package]]
 name = "monkeybot"
-version = "3.10.0"
+version = "3.11.0"
 source = { editable = "../" }
 dependencies = [
     { name = "aiosqlite" },
@@ -725,6 +725,7 @@ provides-extras = ["memory", "gemini", "vertex", "claude", "vertex-claude", "bed
 dev = [
     { name = "anthropic", extras = ["vertex", "bedrock"], specifier = ">=0.40.0" },
     { name = "asgi-lifespan", specifier = ">=2.1.0" },
+    { name = "jsonschema", specifier = ">=4.26.0" },
     { name = "monkeybot", extras = ["memory"] },
     { name = "monkeybot", extras = ["postgres"] },
     { name = "monkeybot-cli", editable = "." },
@@ -773,7 +774,7 @@ dev = [{ name = "pytest", specifier = ">=8.0.0" }]
 
 [[package]]
 name = "monkeybot-cli"
-version = "0.11.0"
+version = "0.11.1"
 source = { editable = "." }
 dependencies = [
     { name = "httpx" },