webbee 0.3.40__tar.gz → 0.3.41__tar.gz

{webbee-0.3.40 → webbee-0.3.41}/CHANGELOG.md

@@ -1,5 +1,30 @@
 # Changelog
 
+## 0.3.41
+
+The model tier is always visible now (not just via `/model`), and clicking a
+tool line in the transcript expands it right there -- no keyboard needed.
+
+- **The active model tier is now shown right in the toolbar**, next to
+  `mode:`, both idle and mid-turn -- it used to be visible only by running
+  `/model` with no argument or catching the flash right after a Ctrl+B
+  cycle. Silent (nothing shown) when no tier has been chosen, so it never
+  claims a value you didn't pick.
+- **Click any finished tool line (bash, write_file, read_file, ...) in the
+  transcript to expand it** -- the exact same compact, bordered detail card
+  `/steps N` (or Up/Down + Enter) already gave you, one gesture shorter.
+  Clicking a banner, a progress line, or blank space is a harmless no-op --
+  nothing to expand there. Busy mid-turn is also a no-op (there's no
+  finished-turn detail to show yet). This reuses the existing `/steps`
+  machinery end to end -- it is not a new UI surface, never covers the
+  screen, and nothing needed to be kept in sync twice.
+- Right-click paste (from 0.3.39) is confirmed working end-to-end on the
+  underlying mouse-report protocol; if it doesn't react in your terminal,
+  check that terminal's own mouse-reporting setting -- some terminal
+  emulators (notably macOS Terminal.app) never forward a right-click to the
+  program running inside them at all, by design, regardless of what an app
+  requests.
+
 ## 0.3.40
 
 The bottom-right version badge is now real everywhere, and Home stopped

{webbee-0.3.40 → webbee-0.3.41}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: webbee
-Version: 0.3.40
+Version: 0.3.41
 Summary: Webbee 🐝 — the Imperal Cloud coding agent in your terminal
 Project-URL: Homepage, https://imperal.io
 Project-URL: Documentation, https://docs.imperal.io

{webbee-0.3.40 → webbee-0.3.41}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "webbee"
-version = "0.3.40"
+version = "0.3.41"
 description = "Webbee 🐝 — the Imperal Cloud coding agent in your terminal"
 readme = "README.md"
 license = "MIT"

webbee-0.3.41/src/webbee/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.3.41"

{webbee-0.3.40 → webbee-0.3.41}/src/webbee/output_pane.py

@@ -49,6 +49,14 @@ class OutputPane:
                 pane_records.clear()
                 pane._reset_buffer()                # StringIO + caches reset (Task 3 builds on it)
 
+            def record_count(self) -> int:
+                """webbee-code-click-to-expand-v1: how many print records exist so
+                far -- RichSink.tool_result reads this RIGHT AFTER printing a step's
+                line to tag that exact record as \"step N\", so a later mouse click
+                on that line can look the step back up (see render.py's
+                `_STEP_RECORDS` / tui.py's click handler)."""
+                return len(pane_records)
+
         self._records = pane_records
         self._record_lines: list = []      # per-record NEW-line count, prefix-summable (reflow.py)
         self._ring_base_lines = 0          # buffer content lines BEFORE ring record 0 (deque

{webbee-0.3.40 → webbee-0.3.41}/src/webbee/render.py

@@ -167,6 +167,13 @@ class RichSink:
         self._pending = ("", "")
         self._consent = None            # asyncio.Future while awaiting a reply
         self._consent_summary = ""
+        # webbee-code-click-to-expand-v1: maps a printed record index (pane's
+        # RecordingConsole ring position, 0-based) -> 1-based step number for
+        # THIS turn, so a mouse click on a tool_result line can look its own
+        # step back up without any new wire protocol -- begin_turn resets both
+        # every turn, exactly like self.steps itself resets in session.py.
+        self._step_index = 0
+        self._step_records: dict = {}
         # Cross-surface items already queued in the RUNNING kernel session
         # (full-queue-layer K1: task_queued/task_dequeued frames). The dock's
         # queue panel reads THIS list object every redraw — mutate in place
@@ -271,6 +278,11 @@ class RichSink:
         self._reconnect_since = None
         self._turn_failed = False
         self._parked = False
+        # webbee-code-click-to-expand-v1: fresh per-turn -- step numbering
+        # (and thus which printed record maps to which step) restarts with
+        # every turn, exactly like self.steps itself does in session.py.
+        self._step_index = 0
+        self._step_records = {}
         self.console.print()   # breathing room between the user's message and the response
         self._nudge()
 
@@ -580,8 +592,23 @@ class RichSink:
             (_clean(summary)[:trunc(w, 0.35, 50)], "dim"),
         ))
         self._pending = ("", "")
+        # webbee-code-click-to-expand-v1: tag the record JUST printed as
+        # "step N" (1-based, matching /steps' own numbering) -- record_count()
+        # already reflects this print (Rich prints synchronously), so the
+        # index this line landed at is exactly len(pane_records) - 1.
+        self._step_index += 1
+        rc = getattr(self.console, "record_count", None)
+        if callable(rc):
+            self._step_records[rc() - 1] = self._step_index
         self._nudge()
 
+    def step_for_record(self, record_idx: int) -> "int | None":
+        """webbee-code-click-to-expand-v1: 1-based step number that produced
+        `record_idx` (a pane RecordingConsole ring position), or None if that
+        record isn't a tool_result line (e.g. a progress/thinking/banner
+        line -- nothing to expand there, same as clicking blank space)."""
+        return self._step_records.get(record_idx)
+
     async def ask_consent(self, app_id: str, tool: str, args: dict) -> str:
         """Ask for consent and return the user's RAW reply (trimmed only) —
         NEVER interpret (the kernel decides, ICNLI). When the dock is running

{webbee-0.3.40 → webbee-0.3.41}/src/webbee/selection.py

@@ -111,6 +111,16 @@ def make_select_control(pane, FormattedTextControl, MouseEventType, MouseButton)
                 up_abs = (ev.position.y + pane._offset, ev.position.x)
                 if down_abs is not None and down_abs != up_abs:
                     pane._copy_selection(down_abs, up_abs)
+                elif down_abs is not None:
+                    # webbee-code-click-to-expand-v1: a PLAIN click (press and
+                    # release at the SAME absolute cell -- no drag, nothing to
+                    # copy) on a transcript line asks "what happened here?" --
+                    # same one-hook/getattr-guarded shape as on_middle_paste/
+                    # on_right_paste above, so a pane with no hook wired
+                    # (tests, no dock) stays a harmless no-op.
+                    hook = getattr(pane, "on_line_click", None)
+                    if hook is not None:
+                        hook(down_abs[0])
                 pane._sel = None
                 pane._invalidate()                 # clear the highlight (colours restored)
                 return None

{webbee-0.3.40 → webbee-0.3.41}/src/webbee/tui.py

@@ -223,7 +223,8 @@ def next_tier(tier: str) -> str:
 def build_toolbar(mode: str, tokens: int, credits: int, *, busy: bool = False,
                   current: str = "", elapsed: float = 0.0, tools: int = 0,
                   consent: bool = False, queued: int = 0,
-                  reconnecting: int = 0, width: int = 0, live: str = "") -> list:
+                  reconnecting: int = 0, width: int = 0, live: str = "",
+                  tier: str = "") -> list:
     """The status line under the pinned input box, as prompt_toolkit formatted
     text (per-segment styled). Four states: consent (awaiting a reply),
     reconnecting (the stream transport is down mid-turn — honest, not a fake
@@ -249,14 +250,27 @@ def build_toolbar(mode: str, tokens: int, credits: int, *, busy: bool = False,
         frags = [("class:tb.spin", f"  {spin} "), ("class:tb.working", "working")]
         if current:
             frags += [("class:tb.dim", " · "), ("class:tb.action", current)]
+        # webbee-code-model-tier-toolbar-v1: keep the tier visible mid-turn too
+        # (a short "· smart" tag, NOT the full "model: " label used at idle --
+        # busy is already the densest row, this is the cheapest legible form).
+        if tier:
+            frags += [("class:tb.dim", " · "), ("class:tb.mode.default", tier)]
         frags.append(("class:tb.dim",
                       f" · {elapsed:.0f}s · {tools} · {_fmt_tokens(tokens)} tok"))
         frags += q
         frags.append(("class:tb.dim", "   ·   Esc/Ctrl-C to stop"))
         return frags
     frags = [("class:tb.dim", "  mode: "),
-             (f"class:tb.mode.{mode}", mode),
-             ("class:tb.dim", f"   ·   {_fmt_tokens(tokens)} tok · {_fmt_tokens(credits)} credits this session"),
+             (f"class:tb.mode.{mode}", mode)]
+    # webbee-code-model-tier-toolbar-v1: the tier was only ever visible via
+    # `/model` (no arg) or right after a Ctrl+B cycle flash -- ask once, then
+    # forget, exactly the visibility gap the mode segment right next to it
+    # never had. "" (unset -> server admin default) stays silent rather than
+    # claim a tier name nobody chose (I-DIAGNOSIS-GROUNDED spirit: never
+    # invent a value the user didn't pick and the server didn't confirm).
+    if tier:
+        frags += [("class:tb.dim", " · model: "), ("class:tb.mode.default", tier)]
+    frags += [("class:tb.dim", f"   ·   {_fmt_tokens(tokens)} tok · {_fmt_tokens(credits)} credits this session"),
              *q]
     # 0.3.37: the PERSISTENT live-session indicator (active_sessions.
     # session_indicator). Empty string = nothing running = say nothing, so an
@@ -846,6 +860,8 @@ async def run_session(*, slots, on_line, on_cycle, on_tier_cycle=None, steps_nav
             p.on_middle_paste = _middle_paste
         if getattr(p, "on_right_paste", None) is None:
             p.on_right_paste = _right_paste
+        if getattr(p, "on_line_click", None) is None:
+            p.on_line_click = _line_click
         return p
 
     def _sink_attr(name, default=None):
@@ -1174,6 +1190,40 @@ async def run_session(*, slots, on_line, on_cycle, on_tier_cycle=None, steps_nav
 
         get_app().create_background_task(_do_right_paste())
 
+    def _line_click(abs_line: int) -> None:
+        """webbee-code-click-to-expand-v1: a PLAIN click on a transcript line
+        (see selection.py's `on_line_click` hook) asks \"what happened here?\"
+        without touching the keyboard at all -- the exact same reveal /steps
+        N (and Up/Down + Enter) already show, just one gesture shorter. A
+        click resolves to a RECORD via the pane's own reflow-anchoring math
+        (`_record_at_line`, already used for reflow + scroll-anchoring), then
+        to a step number via the sink's `step_for_record` (set right after
+        each tool_result print, see render.py) -- so a click on a banner,
+        a progress line, or blank space (no step there) is a harmless no-op,
+        never an error. Busy mid-turn is ALSO a no-op (steps_nav reflects the
+        LAST finished turn only -- clicking during a live one would expand
+        stale data), same gate Enter's own steps_nav path already uses.
+        Compact by construction: dispatches through steps_nav[\"expand\"],
+        the SAME `/steps N` -> step_detail bordered panel Enter already
+        shows -- never a new UI surface, never full-screen, nothing to
+        keep in sync twice."""
+        if not steps_nav or _busy_live():
+            return
+        slot = _a()
+        sink = slot.sink
+        step_fn = getattr(sink, "step_for_record", None) if sink is not None else None
+        if step_fn is None:
+            return
+        pane = _pane()
+        record_idx = pane._record_at_line(abs_line)
+        step_no = step_fn(record_idx)
+        if not step_no:
+            return
+        event = get_app_or_none()
+        if event is None:
+            return
+        event.create_background_task(steps_nav["expand"](step_no - 1, slot))
+
     @kb.add("c-v")
     def _paste_key(event):
         # 0.3.34 (W3 Wave A): Ctrl-V pastes the OS clipboard. An IMAGE is read
@@ -1367,7 +1417,8 @@ async def run_session(*, slots, on_line, on_cycle, on_tier_cycle=None, steps_nav
                                       queued=len(slot.pending) + len(_sink_attr("remote_pending", [])),
                                       reconnecting=st.get("reconnecting", 0),
                                       width=_toolbar_fit_width(),
-                                      live=str((live or {}).get("text") or ""))
+                                      live=str((live or {}).get("text") or ""),
+                                      tier=getattr(slot, "model_tier", "") or "")
             else:
                 # Home has no sink of its OWN, but it is the dock's summary
                 # page: show the SESSION TOTAL across every open tab (0.3.36)

{webbee-0.3.40 → webbee-0.3.41}/tests/test_render.py

@@ -960,3 +960,55 @@ def test_tool_diff_caps_very_long_diffs_without_crashing():
     out = s.console.export_text()
     assert "line 0" in out
     assert "truncated" in out.lower()
+
+
+# --------------------------------------------------------------------------
+# webbee-code-click-to-expand-v1: `/steps N` (and Up/Down + Enter) already
+# let you expand any step of the last turn -- a mouse click on the printed
+# tool_result line itself is the natural next step. RichSink tags the exact
+# printed RECORD as "step N" the instant it prints the line, so a later
+# click can resolve record -> step with no new wire protocol at all.
+# --------------------------------------------------------------------------
+def test_step_for_record_maps_the_printed_line_to_its_step_number():
+    from webbee.output_pane import OutputPane
+    pane = OutputPane(width=80)
+    s = RichSink(console=pane.console, live_enabled=False,
+                input_fn=lambda p: "", clock=lambda: 0.0, on_output=pane.notify)
+    s.begin_turn()
+    s.tool_start("bash", {"command": "ls"})
+    s.tool_result("bash", True, "done")           # step 1 -> some record index
+    s.tool_start("read_file", {"path": "a.py"})
+    s.tool_result("read_file", True, "42 lines")  # step 2 -> a later record index
+
+    # Whatever record each line landed at, step_for_record must resolve it
+    # back to the RIGHT step -- never the other one, never None.
+    recs = s._step_records
+    assert len(recs) == 2
+    ordered = sorted(recs.items())                # [(rec_idx, step_no), ...]
+    assert ordered[0][1] == 1
+    assert ordered[1][1] == 2
+    for rec_idx, step_no in recs.items():
+        assert s.step_for_record(rec_idx) == step_no
+
+
+def test_step_for_record_is_none_for_a_non_step_line():
+    s = _sink()
+    s.begin_turn()
+    s.tool_start("bash", {"command": "ls"})
+    s.tool_result("bash", True, "done")
+    assert s.step_for_record(999) is None          # nothing ever printed there
+
+
+def test_step_records_reset_on_a_new_turn():
+    from webbee.output_pane import OutputPane
+    pane = OutputPane(width=80)
+    s = RichSink(console=pane.console, live_enabled=False,
+                input_fn=lambda p: "", clock=lambda: 0.0, on_output=pane.notify)
+    s.begin_turn()
+    s.tool_start("bash", {"command": "ls"})
+    s.tool_result("bash", True, "done")
+    assert len(s._step_records) == 1
+    s.end_turn("ok")
+    s.begin_turn()                                 # a fresh turn, fresh numbering
+    assert s._step_records == {}
+    assert s._step_index == 0

{webbee-0.3.40 → webbee-0.3.41}/tests/test_tui.py

@@ -5273,3 +5273,113 @@ def test_ticker_busy_includes_turn_flash_and_edge_drag():
         def flash(self):
             return ""
     assert _ticker_busy(_Slots(_Bare()), idle) is False
+
+
+# --------------------------------------------------------------------------
+# webbee-code-model-tier-toolbar-v1: the chosen model tier was only ever
+# visible via `/model` (no arg) or a Ctrl+B cycle flash -- now it sits right
+# next to `mode:` in the idle toolbar (always visible, not on-demand), and as
+# a short tag mid-turn too.
+# --------------------------------------------------------------------------
+def test_idle_toolbar_shows_the_model_tier_when_set():
+    t = _txt(build_toolbar("default", 0, 0.0, tier="supersmart"))
+    assert "model: supersmart" in t
+
+
+def test_idle_toolbar_says_nothing_about_tier_when_unset():
+    t = _txt(build_toolbar("default", 0, 0.0, tier=""))
+    assert "model:" not in t
+
+
+def test_busy_toolbar_shows_a_short_tier_tag():
+    t = _txt(build_toolbar("default", 0, 0.0, busy=True, elapsed=1.0, tier="ultrasmart"))
+    assert "ultrasmart" in t
+
+
+def test_busy_toolbar_says_nothing_about_tier_when_unset():
+    t = _txt(build_toolbar("default", 0, 0.0, busy=True, elapsed=1.0, tier=""))
+    assert "ultrasmart" not in t and "supersmart" not in t and "smart" not in t
+
+
+# --------------------------------------------------------------------------
+# webbee-code-click-to-expand-v1: a plain mouse click on a printed tool_result
+# line expands that step's detail card -- the SAME reveal /steps N (and
+# Up/Down + Enter) already give, one gesture shorter, never a new surface.
+# --------------------------------------------------------------------------
+def test_clicking_a_tool_result_line_expands_its_step():
+    from prompt_toolkit.application import create_app_session, get_app
+    from prompt_toolkit.data_structures import Point
+    from prompt_toolkit.input import create_pipe_input
+    from prompt_toolkit.mouse_events import MouseButton, MouseEvent, MouseEventType
+    from prompt_toolkit.output import DummyOutput
+
+    from webbee import tui
+    from webbee.render import RichSink
+
+    async def scenario():
+        pane = tui.OutputPane(width=80)
+        sink = RichSink(console=pane.console, live_enabled=False,
+                       input_fn=lambda p: "", clock=lambda: 0.0, on_output=pane.notify)
+        sink.begin_turn()
+        sink.tool_start("bash", {"command": "ls"})
+        sink.tool_result("bash", True, "done")     # this is step 1
+        sink.end_turn("ok")
+
+        slots = mk_slots(pane=pane, sink=sink)
+        expanded = []
+
+        async def _expand(idx, slot):
+            expanded.append(idx)
+
+        async def on_line(text, slot=None): ...
+
+        with create_pipe_input() as pipe:
+            with create_app_session(input=pipe, output=DummyOutput()):
+                task = asyncio.create_task(tui.run_session(
+                    slots=slots, on_line=on_line, on_cycle=lambda: None,
+                    steps_nav={"expand": _expand, "count": lambda: 1}))
+                await asyncio.sleep(0.05)
+                # begin_turn prints a leading blank line (breathing room)
+                # before the tool_result line itself -- so the step's line is
+                # absolute line 1, not 0, in a freshly-booted pane at offset 0.
+                pane.on_line_click(1)
+                await asyncio.sleep(0.02)
+                assert expanded == [0]              # step 1 -> steps_nav index 0
+                pipe.send_text("\x04")
+                ok = await asyncio.wait_for(task, 5)
+        assert ok is True
+
+    asyncio.run(scenario())
+
+
+def test_clicking_a_non_step_line_is_a_harmless_noop():
+    from prompt_toolkit.application import create_app_session, get_app
+    from prompt_toolkit.input import create_pipe_input
+    from prompt_toolkit.output import DummyOutput
+
+    from webbee import tui
+
+    async def scenario():
+        pane = tui.OutputPane(width=80)
+        slots = mk_slots(pane=pane, sink=_idle_sink())
+        expanded = []
+
+        async def _expand(idx, slot):
+            expanded.append(idx)
+
+        async def on_line(text, slot=None): ...
+
+        with create_pipe_input() as pipe:
+            with create_app_session(input=pipe, output=DummyOutput()):
+                task = asyncio.create_task(tui.run_session(
+                    slots=slots, on_line=on_line, on_cycle=lambda: None,
+                    steps_nav={"expand": _expand, "count": lambda: 0}))
+                await asyncio.sleep(0.05)
+                pane.on_line_click(0)                # nothing was ever printed/tagged here
+                await asyncio.sleep(0.02)
+                assert expanded == []
+                pipe.send_text("\x04")
+                ok = await asyncio.wait_for(task, 5)
+        assert ok is True
+
+    asyncio.run(scenario())

webbee-0.3.40/src/webbee/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.3.40"