webbee 0.2.1__tar.gz → 0.2.3__tar.gz

{webbee-0.2.1 → webbee-0.2.3}/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## 0.2.3
+
+- **Readable big numbers.** Token and credit counts in the toolbar now scale
+  (`1.5M tok`, `2M credits`) instead of an awkward `1500.0k`.
+- **Esc really stops a turn now.** Previously only Ctrl-C worked; Esc now cancels
+  the running turn too, matching the "Esc/Ctrl-C to stop" hint.
+- **The `❯` prompt takes your mode's colour** — cyan (default), purple (plan),
+  yellow (autopilot) — so the current mode is obvious from the input line.
+
+## 0.2.2
+
+- **See Webbee's reasoning as a distinct 💭 block.** Before each step, Webbee now
+  shows a genuine line of thinking — what it's weighing and why — rendered as its
+  own 💭 block, separate from status lines. Works on every model.
+- **SSH steps are visible.** When Webbee runs a command on one of your connected
+  servers, the terminal now shows that step (command + result), like any other.
+
 ## 0.2.1
 
 - **Fixes a marathon that could hang on "working" and quietly burn credits.** A

{webbee-0.2.1 → webbee-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: webbee
-Version: 0.2.1
+Version: 0.2.3
 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.2.1 → webbee-0.2.3}/pyproject.toml

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

webbee-0.2.3/src/webbee/__init__.py

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

{webbee-0.2.1 → webbee-0.2.3}/src/webbee/render.py

@@ -27,8 +27,20 @@ _ACCENT = "cyan"      # interactive chrome ONLY — live caret / mode / panel ur
 
 
 def _fmt_tokens(n: int) -> str:
-    """Compact token count: 2100 -> '2.1k', 900 -> '900'."""
-    return f"{n / 1000:.1f}k" if n >= 1000 else str(int(n))
+    """Compact count for the live toolbar: 900 -> '900', 2_100 -> '2.1k',
+    1_500_000 -> '1.5M', 2_000_000 -> '2M', 3_200_000_000 -> '3.2B'. Used for
+    both token counts and (integer) credits so big numbers stay readable."""
+    try:
+        n = int(n or 0)
+    except (TypeError, ValueError):
+        return "0"
+    a = abs(n)
+    if a < 1000:
+        return str(n)
+    for div, suf in ((1_000_000_000, "B"), (1_000_000, "M"), (1000, "k")):
+        if a >= div:
+            return f"{n / div:.1f}".rstrip("0").rstrip(".") + suf
+    return str(n)
 
 
 def _salient_arg(args: dict) -> str:
@@ -325,6 +337,13 @@ class RichSink:
             self.console.print(Text("  " + text, style="dim italic"))
             self._nudge()
 
+    def thinking(self, text: str) -> None:
+        # System-driven reasoning as a distinct 💭 block — visually apart from the
+        # dim `progress` line (which stays reserved for status like low-balance).
+        if text:
+            self.console.print(Text("  💭 " + text, style="italic medium_purple3"))
+            self._nudge()
+
     def plan_blocked(self, tool: str) -> None:
         """Plan mode auto-declines writes/destructive. Tell the user WHY and how
         to allow it (Shift+Tab). Autopilot and default never reach this."""

{webbee-0.2.1 → webbee-0.2.3}/src/webbee/session.py

@@ -272,6 +272,9 @@ class AgentSession:
                 elif ftype == "step_finished":  # v2 (Slice-5 T8 dual-emit)
                     handle_step_finished(frame, sink, finished, step_labels, self.steps, local_ids)
 
+                elif ftype == "thinking":  # system-driven reasoning -> the 💭 block
+                    (getattr(sink, "thinking", None) or sink.progress)(_progress_text(frame))
+
                 elif ftype == "progress":  # P2 — dual-reads llm_text (v2) / text (legacy)
                     sink.progress(_progress_text(frame))
 

{webbee-0.2.1 → webbee-0.2.3}/src/webbee/tui.py

@@ -44,15 +44,19 @@ def build_toolbar(mode: str, tokens: int, credits: int, *, busy: bool = False,
     return [("class:tb.dim", "  mode: "),
             (f"class:tb.mode.{mode}", mode),
             ("class:tb.dim",
-             f"   ·   {_fmt_tokens(tokens)} tok · {credits} credits   ·   Shift + TAB: switch mode")]
-
-
-def _escape_action(sel: dict, is_busy, stop_turn, event) -> None:
-    """Esc key binding (P5g). While a turn is running, ask the server to stop
-    it (`stop_turn` posts the cancel; fail-soft, best-effort) and leave the
-    step-selection untouched — while idle (unchanged), clear the selection."""
-    if is_busy() and stop_turn is not None:
-        event.app.create_background_task(stop_turn())
+             f"   ·   {_fmt_tokens(tokens)} tok · {_fmt_tokens(credits)} credits   ·   Shift + TAB: switch mode")]
+
+
+def _escape_action(sel: dict, turn: dict, is_busy, stop_turn, event) -> None:
+    """Esc key binding (P5g). While a turn is running, STOP it — cancel the LOCAL
+    turn task (what actually tears the turn down, same as Ctrl-C) AND ask the
+    server to stop (so it stops spending). While idle, clear the step-selection."""
+    if is_busy():
+        t = turn.get("task")
+        if t is not None and not t.done():
+            if stop_turn is not None:
+                event.app.create_background_task(stop_turn())
+            t.cancel()                       # cancel the running turn; dock survives
         return
     sel["i"] = None
     event.app.invalidate()
@@ -157,7 +161,7 @@ async def run_session(*, pane, on_line, mode_getter, on_cycle, status,
 
     @kb.add("escape")
     def _step_clear(event):
-        _escape_action(sel, is_busy, stop_turn, event)
+        _escape_action(sel, turn, is_busy, stop_turn, event)
 
     @kb.add("pageup")
     def _pgup(event):
@@ -190,8 +194,13 @@ async def run_session(*, pane, on_line, mode_getter, on_cycle, status,
         rows = sum(max(1, -(-len(ln) // cols)) for ln in text.split("\n"))
         return min(10, max(1, rows))
 
+    def _prompt_fragments():
+        # The ❯ takes the CURRENT mode's colour (same classes the toolbar uses)
+        # so the mode is obvious from the input line itself, not just the toolbar.
+        return [(f"class:tb.mode.{mode_getter()}", "❯ ")]
+
     input_win = Window(
-        BufferControl(buffer=buf, input_processors=[BeforeInput("❯ ", style="class:prompt")]),
+        BufferControl(buffer=buf, input_processors=[BeforeInput(_prompt_fragments)]),
         height=_input_height, wrap_lines=True)
     toolbar = Window(FormattedTextControl(_toolbar), height=1, always_hide_cursor=True)
     root = HSplit([pane.window, Frame(input_win), toolbar])

{webbee-0.2.1 → webbee-0.2.3}/tests/test_marathon.py

@@ -154,6 +154,7 @@ def _run_marathon_capture_post(monkeypatch, tmp_path, goal="build X", frames=Non
     class NoteSink:
         def __init__(self): self.notes = []
         def note(self, msg): self.notes.append(msg)
+        def thinking(self, msg): self.thinks = getattr(self, "thinks", []) + [msg]
         def tool_start(self, *a): ...
         def tool_result(self, *a): ...
         def ask_consent(self, *a): return "y"
@@ -202,6 +203,16 @@ def test_marathon_complete_is_terminal(monkeypatch, tmp_path):
     assert result == "goal done"
 
 
+def test_thinking_frame_renders_as_distinct_channel(monkeypatch, tmp_path):
+    # A `thinking` frame routes to the distinct 💭 reasoning channel
+    # (sink.thinking), NOT the plain progress/note lines.
+    _, _, sink = _run_marathon_capture_post(monkeypatch, tmp_path, frames=[
+        {"type": "thinking", "task_id": "OURS", "text": "assessing the repo before editing"},
+        {"type": "marathon_complete", "task_id": "OURS", "text": "done"},
+    ])
+    assert getattr(sink, "thinks", []) == ["assessing the repo before editing"]
+
+
 def test_marathon_paused_is_terminal_and_noted(monkeypatch, tmp_path):
     _, result, sink = _run_marathon_capture_post(monkeypatch, tmp_path, frames=[
         {"type": "marathon_paused", "task_id": "OURS", "reason": "out of credits"},

{webbee-0.2.1 → webbee-0.2.3}/tests/test_tui.py

@@ -22,13 +22,30 @@ def test_next_mode_unknown_resets():
 def test_toolbar_idle_has_mode_tokens_cost_and_hint():
     t = _txt(build_toolbar("plan", 51000, 66))
     assert "plan" in t
-    assert "51.0k" in t
+    assert "51k" in t
     assert "66 credits" in t
     assert "Shift + TAB" in t          # spelled in words, no glyph
     assert "⇧⇥" not in t     # the ⇧⇥ glyph must NOT appear
     assert not NO_CYRILLIC.search(t)
 
 
+def test_toolbar_humanizes_millions_and_credits():
+    # Big numbers stay readable: tokens + credits both scale to k/M/B.
+    t = _txt(build_toolbar("default", 1_500_000, 2_000_000))
+    assert "1.5M tok" in t
+    assert "2M credits" in t
+
+
+def test_fmt_tokens_scales_k_m_b():
+    from webbee.render import _fmt_tokens
+    assert _fmt_tokens(900) == "900"
+    assert _fmt_tokens(2100) == "2.1k"
+    assert _fmt_tokens(51000) == "51k"
+    assert _fmt_tokens(1_500_000) == "1.5M"
+    assert _fmt_tokens(2_000_000) == "2M"
+    assert _fmt_tokens(3_200_000_000) == "3.2B"
+
+
 def test_toolbar_busy_state_shows_working_dot_and_stop_hint():
     t = _txt(build_toolbar("default", 1200, 0.0143, busy=True,
                            current="notes·delete_note", elapsed=4, tools=3))
@@ -203,7 +220,15 @@ def _run_and_drain(coro):
     asyncio.run(coro)
 
 
-def test_escape_while_busy_schedules_server_stop_and_leaves_selection():
+class _FakeTask:
+    def __init__(self): self.cancelled = []
+    def done(self): return False
+    def cancel(self): self.cancelled.append(1)
+
+
+def test_escape_while_busy_cancels_turn_and_schedules_server_stop():
+    # Esc now REALLY stops a running turn: cancel the local turn task (what tears
+    # it down) AND ask the server to stop — matching the "Esc/Ctrl-C" hint.
     from webbee.tui import _escape_action
 
     stop_calls = []
@@ -213,13 +238,15 @@ def test_escape_while_busy_schedules_server_stop_and_leaves_selection():
 
     event = _FakeEvent()
     sel = {"i": 2}
-    _escape_action(sel, lambda: True, stop_turn, event)
+    task = _FakeTask()
+    turn = {"task": task}
+    _escape_action(sel, turn, lambda: True, stop_turn, event)
 
+    assert task.cancelled == [1]                  # the local turn is actually cancelled
     assert len(event.app.background_tasks) == 1
     _run_and_drain(event.app.background_tasks[0])
-    assert stop_calls == [1]
-    # Esc-while-busy interrupts — it does NOT also clear the step-selection
-    # or invalidate the toolbar (that's the idle-path job, tested below).
+    assert stop_calls == [1]                       # AND the server is asked to stop
+    # Busy-path stops the turn — it does NOT also clear the step-selection.
     assert sel["i"] == 2
     assert event.app.invalidated is False
 
@@ -234,7 +261,8 @@ def test_escape_while_idle_clears_step_selection_unchanged():
 
     event = _FakeEvent()
     sel = {"i": 2}
-    _escape_action(sel, lambda: False, stop_turn, event)
+    turn = {"task": None}
+    _escape_action(sel, turn, lambda: False, stop_turn, event)
 
     assert sel["i"] is None
     assert event.app.invalidated is True
@@ -242,18 +270,20 @@ def test_escape_while_idle_clears_step_selection_unchanged():
     assert stop_calls == []
 
 
-def test_escape_while_busy_with_no_stop_turn_falls_back_to_clearing():
-    # stop_turn=None (e.g. no repl wiring) must never crash Esc — it just
-    # keeps the pre-P5g behavior of clearing the step-selection.
+def test_escape_while_busy_with_no_stop_turn_still_cancels_locally():
+    # stop_turn=None (e.g. no repl wiring) must never crash Esc — it still cancels
+    # the local turn task, so Esc reliably stops even without the server hook.
     from webbee.tui import _escape_action
 
     event = _FakeEvent()
     sel = {"i": 1}
-    _escape_action(sel, lambda: True, None, event)
+    task = _FakeTask()
+    turn = {"task": task}
+    _escape_action(sel, turn, lambda: True, None, event)
 
-    assert sel["i"] is None
-    assert event.app.invalidated is True
-    assert event.app.background_tasks == []
+    assert task.cancelled == [1]                  # local teardown happens regardless
+    assert event.app.background_tasks == []        # no stop_turn -> nothing scheduled
+    assert sel["i"] == 1                            # busy-path leaves the selection
 
 
 def test_interrupt_while_busy_cancels_local_task_and_schedules_server_stop():

webbee-0.2.1/src/webbee/__init__.py

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