webbee 0.3.27__tar.gz → 0.3.29__tar.gz

{webbee-0.3.27 → webbee-0.3.29}/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## 0.3.29
+
+- The Home screen scrolls for real now — mouse wheel and PageUp/PageDown move
+  through the whole page, however tall it gets.
+- The Webbee Code logo now opens every new tab you start, and Home itself is
+  kept clean (the logo is no longer on Home).
+
+## 0.3.28
+
+The Home screen scrolls now. When Home has more than fills the window — a tall
+stack of tabs, or command output — scroll it with the mouse wheel or
+PageUp/PageDown, like any other view. Output from a command run on Home (for
+example `/help`) shows inline at the bottom and the view jumps to it.
+
 ## 0.3.27
 
 Home dashboard polish.

{webbee-0.3.27 → webbee-0.3.29}/PKG-INFO

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

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

webbee-0.3.29/src/webbee/__init__.py

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

{webbee-0.3.27 → webbee-0.3.29}/src/webbee/home_view.py

@@ -259,6 +259,16 @@ def _line_len(frags) -> int:
     return sum(len(f[1]) for f in frags)
 
 
+def _flatten_lines(lines):
+    """Flatten a list of fragment-lines into one fragment list with a newline
+    fragment terminating each line (what a FormattedTextControl consumes)."""
+    out = []
+    for ln in lines:
+        out.extend(ln)
+        out.append(("", "\n"))
+    return out
+
+
 def _pad_line(frags, width: int):
     n = _line_len(frags)
     return list(frags) + ([("", " " * (width - n))] if n < width else [])
@@ -293,20 +303,25 @@ class HomeView:
 
     def __init__(self, *, slots, actions: "HomeActions",
                  data: "HomeData | None" = None, width: int = 100, out_pane=None):
-        from prompt_toolkit.layout.containers import HSplit, Window
+        from prompt_toolkit.layout.containers import Window
         from prompt_toolkit.layout.controls import FormattedTextControl
+        from prompt_toolkit.mouse_events import MouseEventType
         self.slots = slots
         self.actions = actions
         self.data = data if data is not None else HomeData()
-        # An OutputPane below the dashboard is Home's command/output region:
-        # `_say` and slash-command output (e.g. /help, gated-action notes)
-        # print into its captured console so a command run while Home is
-        # active still shows an honest answer, and the dock's OutputPane spy +
-        # ticker (dump/reflow/scroll/flash/edge_tick/forward_mouse) keep
-        # working. The dock builds it via `tui.OutputPane` and passes it
-        # (spy-visible, created first = Home); a bare fallback covers direct
-        # unit use. `self.console` IS that pane's console — it drives both the
-        # command output AND the dashboard's column-width math.
+        # Home is ONE ordinary scrollable Window (NOT dont_extend_height, NOT
+        # an HSplit): when its content is taller than the viewport, prompt_
+        # toolkit's own Window mouse handler scrolls it on the wheel (content
+        # fragment handlers return NotImplemented for SCROLL, so it falls
+        # through to Window._mouse_handler), and pageup/pagedown route here via
+        # `scroll()`. `_say`/slash-command output is rendered INLINE at the
+        # bottom of the SAME scrollable content (see `_fragments`), so it
+        # scrolls with everything and never gets squeezed off a short terminal.
+        # `out_pane` (built via `tui.OutputPane` by the dock, created first =
+        # Home for the spy) stays purely as the CAPTURE backend: `_say` prints
+        # into its console and `dump()` reads it back; its own window is NOT in
+        # the layout. `self.console` IS that pane's console — it drives both the
+        # captured command output AND the dashboard's column-width math.
         if out_pane is None:
             from webbee.output_pane import OutputPane
             out_pane = OutputPane(width=width)
@@ -315,38 +330,68 @@ class HomeView:
         self._focus_id: "str | None" = None
         self._hover_id: "str | None" = None
         self._model: "HomeModel | None" = None
-        self.control = FormattedTextControl(self._fragments, focusable=True, show_cursor=False)
-        self._dash = Window(content=self.control, wrap_lines=False,
-                            always_hide_cursor=True, dont_extend_height=True)
-        self.window = HSplit([self._dash, out_pane.window])
+        # Virtualized scroll (mirrors OutputPane): the control is fed ONLY the
+        # visible slice of lines, so it always fits the viewport and prompt_
+        # toolkit never fights an (absent) cursor to reset the scroll — the
+        # reason a plain FormattedTextControl window won't scroll. `_scroll` is
+        # the top visible line; `_view_h_val` is the last render's viewport
+        # height. Wheel adjusts `_scroll` here; PageUp/PageDown route via
+        # `scroll()`; `notify()` jumps to the bottom to reveal new output.
+        self._scroll = 0
+        self._view_h_val = 20
+        view = self
+
+        class _HomeControl(FormattedTextControl):
+            def mouse_handler(self, ev):
+                et = ev.event_type
+                if et == MouseEventType.SCROLL_DOWN:
+                    view.scroll(3)
+                    return None
+                if et == MouseEventType.SCROLL_UP:
+                    view.scroll(-3)
+                    return None
+                return super().mouse_handler(ev)
+
+        self.control = _HomeControl(self._visible_fragments, focusable=True, show_cursor=False)
+        self.window = Window(content=self.control, wrap_lines=False, always_hide_cursor=True)
 
     # ---- OutputPane-compatible surface (ticker/layout duck-type) ----------
-    # All delegate to the composed output pane so the dock's ticker/layout
-    # drive Home's command-output region exactly as they do a session pane.
     def reflow(self, new_width: int) -> None:
+        # Keep the capture console's width in sync (drives the dashboard's
+        # column math) and repaint; the Window re-lays-out at the new size.
         self._out.reflow(new_width)
+        self._invalidate()
 
     def edge_tick(self) -> None:
-        self._out.edge_tick()
+        return None
 
     def flash(self) -> str:
         return self._out.flash()
 
     def scroll(self, delta: int) -> None:
-        self._out.scroll(delta)
+        # Wheel (via the control) and PageUp/PageDown (tui routes here) move the
+        # top visible line; clamped so you can't scroll past the ends.
+        lines = self._all_lines()
+        max_off = max(0, len(lines) - max(1, self._view_h_val))
+        self._scroll = max(0, min(self._scroll + delta, max_off))
+        self._invalidate()
 
     @property
     def _view_h(self) -> int:
-        return self._out._view_h
+        return self._view_h_val
 
     def forward_mouse(self, ev, clamp: str = "bottom") -> bool:
-        return self._out.forward_mouse(ev, clamp)
+        return False
 
     def dump(self) -> str:
         return self._out.dump()
 
     def notify(self) -> None:
-        self._out.notify()
+        # New captured output landed (a `_say` note / command reply). Reveal
+        # it: jump to the bottom (clamped on the next render) so the answer is
+        # visible, then repaint.
+        self._scroll = 10 ** 7
+        self._invalidate()
 
     def _invalidate(self) -> None:
         try:
@@ -414,7 +459,7 @@ class HomeView:
         return _h
 
     # ---- render -----------------------------------------------------------
-    def _fragments(self):
+    def _all_lines(self):
         from webbee.home import _mask_email
         from webbee.render import _fmt_tokens
         m = self._build_model()
@@ -551,21 +596,10 @@ class HomeView:
                        "· Ctrl+T new tab · Alt+N switch")])
             return L
 
-        # Header: the Webbee Code ASCII logo (bee-yellow), then a centered
-        # "◆ Home" — restored (it was on the pre-dashboard Home and Valentin
-        # wants it kept). The whole art block is centered by ONE offset (max
-        # line width) so its shape is preserved; degrades to left-aligned when
-        # the terminal is narrower than the art.
-        from webbee.banner_art import WEBBEE_CODE
-        art = WEBBEE_CODE.rstrip("\n").split("\n")
-        art_w = max((len(ln) for ln in art), default=0)
-        art_pad = max(0, (width - art_w) // 2)
-        lines = [[("", "")]]
-        for ln in art:
-            lines.append([("", " " * art_pad), ("class:home.header", ln)] if ln else [("", "")])
+        # A small centered "◆ Home" title. The Webbee Code logo now opens each
+        # NEW session tab instead (RichSink.banner), so Home itself stays clean.
         title_pad = max(0, (width - len("◆ Home")) // 2)
-        lines.append([("", " " * title_pad), ("class:home.header", "◆ Home")])
-        lines.append([("", "")])
+        lines = [[("", "")], [("", " " * title_pad), ("class:home.header", "◆ Home")], [("", "")]]
         if two_column(width):
             colw = max(20, (width // 2) - 3)
             lines += _side_by_side(you_lines(), wallet_lines(), colw)
@@ -579,8 +613,34 @@ class HomeView:
         lines += [[("", "")]] + security_lines()
         lines += footer_lines()
 
-        out = []
-        for ln in lines:
-            out.extend(ln)
-            out.append(("", "\n"))
-        return out
+        # `_say` / slash-command output, captured in the backend pane, rendered
+        # INLINE at the very bottom of the same scrollable content (ANSI →
+        # fragments, styling preserved). `notify()` jumps the scroll here so a
+        # command's answer is visible; it scrolls with the rest of Home.
+        dump = self._out.dump()
+        if dump.strip():
+            from prompt_toolkit.formatted_text import ANSI, to_formatted_text
+            lines.append([("", "")])
+            lines.append([("class:home.header", " Output ")])
+            lines.append(list(to_formatted_text(ANSI(dump.rstrip("\n")))))
+        return lines
+
+    def _fragments(self):
+        """The FULL dashboard flattened (every line). The build helpers and
+        tests use this; the on-screen control uses `_visible_fragments`."""
+        return _flatten_lines(self._all_lines())
+
+    def _visible_fragments(self):
+        """Only the visible slice `[_scroll : _scroll+view_h]`, flattened — what
+        the control renders. Captures the live viewport height from the last
+        render (`render_info.window_height`) and clamps `_scroll` into range, so
+        the slice always fits and the window never needs (and never fights) a
+        cursor to scroll."""
+        ri = getattr(self.window, "render_info", None)
+        if ri is not None and getattr(ri, "window_height", 0):
+            self._view_h_val = ri.window_height
+        lines = self._all_lines()
+        h = max(1, self._view_h_val)
+        off = max(0, min(self._scroll, max(0, len(lines) - h)))
+        self._scroll = off
+        return _flatten_lines(lines[off:off + h])

{webbee-0.3.27 → webbee-0.3.29}/src/webbee/render.py

@@ -214,6 +214,19 @@ class RichSink:
         self.console.print()
         self._nudge()
 
+    def banner(self) -> None:
+        """The Webbee Code brand logo, printed at the top of every NEW session
+        tab (0.3.29) so each tab opens with the logo the launch splash has
+        always carried — just the brand block, no identity/privacy (those stay
+        on the one-time boot `welcome`). Align.center = reflow-safe."""
+        self.console.print()
+        self.console.print(Align.center(Text(WEBBEE_CODE, style=f"bold {_BEE}")))
+        self.console.print(Align.center(Text("🐝", style=f"bold {_BEE}")))
+        self.console.print(Align.center(Text("ICNLI AI Cloud OS · Agent", style=f"bold {_ACCENT}")))
+        self.console.print(Align.center(Text("·  i m p e r a l . i o  ·", style="dim")))
+        self.console.print()
+        self._nudge()
+
     # ---- turn lifecycle -------------------------------------------------
     def begin_turn(self) -> None:
         self._tools = 0

{webbee-0.3.27 → webbee-0.3.29}/src/webbee/repl.py

@@ -419,6 +419,11 @@ async def _finish_slot(cfg, token_provider, workspace, mode, *, resources: Works
     # one kernel-owned row. Reference share — never a copy.
     sink.local_pending = slot.pending
     replayed = 0
+    if not first:
+        # Every NEW tab opens with the Webbee Code logo (0.3.29) — the brand
+        # block the launch splash carries — since the boot `welcome` (below)
+        # only runs for the first tab.
+        sink.banner()
     if first:
         if account is not None:
             sink.welcome(account, workspace, "terminal")

{webbee-0.3.27 → webbee-0.3.29}/tests/test_home_view.py

@@ -297,8 +297,42 @@ def test_you_tile_shows_expires_when_not_active():
     assert "expires Aug 3" in text
 
 
-def test_home_renders_webbee_code_logo_and_title():
+def test_home_has_title_but_no_logo():
+    # 0.3.29: the Webbee Code logo moved to each NEW session tab; Home keeps
+    # only a small "◆ Home" title.
     hv, _ = _view()
     text = "".join(f[1] for f in hv._fragments())
-    assert "_____" in text        # a slice of the WEBBEE_CODE ascii banner
     assert "◆ Home" in text
+    assert "_____" not in text     # the ascii logo is no longer on Home
+
+
+def test_home_virtualized_scroll_slices_and_clamps():
+    # Home virtualizes like OutputPane: the control renders only a slice ≤ the
+    # viewport height, and scroll() moves/clamps the top line.
+    hv, _ = _view()
+    hv._view_h_val = 5
+    total = len(hv._all_lines())
+    assert total > 5                                   # taller than a 5-row viewport
+    visible_newlines = sum(1 for f in hv._visible_fragments() if f[1] == "\n")
+    assert visible_newlines <= 5
+    hv.scroll(3)
+    assert hv._scroll == 3
+    hv.scroll(10 ** 6)
+    assert hv._scroll == total - 5                     # clamped to the bottom
+    hv.scroll(-10 ** 6)
+    assert hv._scroll == 0                             # clamped to the top
+
+
+def test_captured_output_renders_inline_and_notify_reveals_it():
+    # Home is one scrollable window; _say/command output is captured in the
+    # backend pane and rendered INLINE at the bottom, and notify() jumps the
+    # scroll to reveal it.
+    hv, _ = _view()
+    hv.console.print("hello-inline-output")
+    text = "".join(f[1] for f in hv._fragments())
+    assert "hello-inline-output" in text
+    assert "Output" in text
+    hv.notify()
+    hv._visible_fragments()                         # clamps _scroll into range
+    total = len(hv._all_lines())
+    assert hv._scroll == max(0, total - hv._view_h_val)   # notify jumped to the bottom

webbee-0.3.27/src/webbee/__init__.py

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