webbee 0.2.2__tar.gz → 0.2.3__tar.gz

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

@@ -1,5 +1,14 @@
 # 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

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "webbee"
-version = "0.2.2"
+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.2 → 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:

{webbee-0.2.2 → 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.2 → 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.2/src/webbee/__init__.py

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