webbee 0.3.32__tar.gz → 0.3.33__tar.gz

{webbee-0.3.32 → webbee-0.3.33}/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## 0.3.33
+
+Performance.
+
+- When nothing is happening, the terminal now wakes about once a second
+  instead of four times a second — easier on the CPU and the battery — while
+  staying instant the moment a task runs or you're drag-scrolling.
+- The agent's file search and per-task project snapshot no longer crawl
+  `node_modules`, `vendor`, `dist`, `build`, and friends, so both stay fast on
+  large repositories.
+
 ## 0.3.32
 
 - Fixed the screen getting scrambled by stray output from background helper

{webbee-0.3.32 → webbee-0.3.33}/PKG-INFO

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

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

webbee-0.3.33/src/webbee/__init__.py

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

{webbee-0.3.32 → webbee-0.3.33}/src/webbee/coding_context.py

@@ -5,6 +5,17 @@ proof-of-done command a marathon carries in that context."""
 import os
 import subprocess
 
+# Heavy dependency/build dirs the file-tree walk and the agent `grep` tool
+# must NEVER descend: they blow up walk time on real repos and (with the tree's
+# 200-file cap) would otherwise fill the snapshot with dependency junk instead
+# of the user's own code. `.git` + all dotdirs are pruned separately by the
+# callers; these are the non-dot offenders. Shared with tools._t_grep.
+WALK_IGNORE_DIRS = frozenset({
+    "node_modules", "vendor", "dist", "build", "target", "__pycache__",
+    ".git", ".venv", "venv", ".next", ".cache", ".tox", ".mypy_cache",
+    ".pytest_cache",
+})
+
 
 def build_coding_context(workspace_root: str, intel=None) -> dict:
     """Snapshot handed to the cloud brain: cwd (realpath), `git status -sb`
@@ -23,7 +34,8 @@ def build_coding_context(workspace_root: str, intel=None) -> dict:
         git = ""
     paths = []
     for dirpath, dirnames, filenames in os.walk(cwd):
-        dirnames[:] = [d for d in dirnames if d != ".git" and not d.startswith(".")]
+        dirnames[:] = [d for d in dirnames
+                       if d not in WALK_IGNORE_DIRS and not d.startswith(".")]
         for fn in filenames:
             paths.append(os.path.relpath(os.path.join(dirpath, fn), cwd))
             if len(paths) >= 200:

{webbee-0.3.32 → webbee-0.3.33}/src/webbee/tools.py

@@ -327,12 +327,17 @@ class LocalToolExecutor:
         return {"ok": proc.returncode == 0, "content": out or f"(exit {proc.returncode})"}
 
     def _t_grep(self, a: dict) -> dict:
+        from webbee.coding_context import WALK_IGNORE_DIRS
         pat = re.compile(a["pattern"])
         base = self.resolve_in_workspace(a.get("path", "."))
         hits = []
-        for dp, _dn, fns in os.walk(base):
+        for dp, dns, fns in os.walk(base):
             if _is_git_dir(dp):
+                dns[:] = []
                 continue
+            # Prune heavy dependency/build dirs (node_modules, vendor, dist,
+            # …) so a grep on a real repo doesn't crawl megabytes of deps.
+            dns[:] = [d for d in dns if d not in WALK_IGNORE_DIRS]
             for fn in fns:
                 fp = os.path.join(dp, fn)
                 try:

{webbee-0.3.32 → webbee-0.3.33}/src/webbee/tui.py

@@ -211,6 +211,32 @@ def _width_watch(pane, app) -> None:
             pass
 
 
+def _ticker_busy(slots, is_busy) -> bool:
+    """Whether the dock's animation loop must stay at the FAST (0.25s) cadence:
+    a turn is running, a copy-flash toast is live, OR an edge-drag auto-scroll
+    is in flight (`pane._edge_drag` — a drag-select past the viewport edge that
+    `pane.edge_tick()` keeps scrolling every tick). All three need smooth ~4x/s
+    updates; miss the edge-drag one and idle drag-scrolling crawls 4x slower.
+    Otherwise the loop is idle → the caller uses the slow 1.0s cadence."""
+    try:
+        pane = slots.active().pane
+        if bool(pane.flash()) or bool(getattr(pane, "_edge_drag", 0)):
+            return True
+    except Exception:
+        pass
+    return bool(is_busy())
+
+
+def _tick_interval(busy: bool) -> float:
+    """The dock's animation-loop sleep. 0.25s while a turn is running (or a
+    copy-flash is live) so the spinner/elapsed-clock animate smoothly; 1.0s
+    when fully idle, so the loop wakes 1×/s instead of 4×/s (less CPU/battery)
+    with no visible cost — an idle tick only resize-detects + re-syncs hover,
+    both of which tolerate a 1s lag (and a turn's first frame still shows
+    instantly via the submit's own invalidate)."""
+    return 0.25 if busy else 1.0
+
+
 def _tick_once(slots, app, is_busy) -> None:
     """One iteration of run_session's `_ticker` loop, extracted module-level
     so the wiring itself is directly unit-testable (an `async def` infinite
@@ -1272,7 +1298,7 @@ async def run_session(*, slots, on_line, on_cycle, steps_nav=None,
         # is_busy this ticker feeds it, since the old top-level is_busy
         # param died with the rest of the sink-shaped params.
         while True:
-            await asyncio.sleep(0.25)
+            await asyncio.sleep(_tick_interval(_ticker_busy(slots, _busy_live)))
             _sync_hover_mode()
             _tick_once(slots, app, _busy_live)
 

webbee-0.3.33/tests/test_coding_context.py

@@ -0,0 +1,31 @@
+from webbee.coding_context import WALK_IGNORE_DIRS, build_coding_context
+
+
+def test_walk_ignore_dirs_has_the_heavy_hitters():
+    for d in ("node_modules", "vendor", "dist", "build", "target", "__pycache__"):
+        assert d in WALK_IGNORE_DIRS
+
+
+def test_build_coding_context_prunes_heavy_dirs(tmp_path):
+    # W6: the per-turn file-tree walk must not descend node_modules/etc. — on a
+    # real repo it's slow and (with the 200-file cap) would fill the snapshot
+    # with dependency junk instead of the user's own code.
+    (tmp_path / "src").mkdir()
+    (tmp_path / "src" / "a.py").write_text("x\n")
+    nm = tmp_path / "node_modules" / "pkg"
+    nm.mkdir(parents=True)
+    (nm / "index.js").write_text("y\n")
+    tree = build_coding_context(str(tmp_path))["tree"]
+    assert "src/a.py" in tree
+    assert "node_modules" not in tree
+
+
+def test_build_coding_context_still_prunes_dotdirs(tmp_path):
+    (tmp_path / "src").mkdir()
+    (tmp_path / "src" / "a.py").write_text("x\n")
+    hidden = tmp_path / ".secret"
+    hidden.mkdir()
+    (hidden / "k.txt").write_text("y\n")
+    tree = build_coding_context(str(tmp_path))["tree"]
+    assert "src/a.py" in tree
+    assert ".secret" not in tree

{webbee-0.3.32 → webbee-0.3.33}/tests/test_tools.py

@@ -49,6 +49,22 @@ def test_grep_skips_git_dir(tmp_path):
     assert r["ok"] and "a.py" in r["content"] and ".git" not in r["content"]
 
 
+def test_grep_prunes_heavy_dirs(tmp_path):
+    # W6: a code grep must never crawl node_modules/vendor/dist/etc. — huge and
+    # never what the user meant. A match in src surfaces; one in node_modules
+    # does not (the walk is pruned, not just filtered).
+    ex = _ex(tmp_path)
+    (tmp_path / "src").mkdir()
+    (tmp_path / "src" / "a.py").write_text("needle\n")
+    nm = tmp_path / "node_modules" / "pkg"
+    nm.mkdir(parents=True)
+    (nm / "index.js").write_text("needle\n")
+    r = ex.run("grep", {"pattern": "needle"})
+    assert r["ok"]
+    assert "a.py" in r["content"]
+    assert "node_modules" not in r["content"]
+
+
 def test_grep_skips_git_dir_windows_style():
     # The os.walk-driven .git skip in _t_grep normalizes dp with os.sep so it
     # also matches on Windows, where os.walk yields backslash paths (an

{webbee-0.3.32 → webbee-0.3.33}/tests/test_tui.py

@@ -5206,3 +5206,41 @@ def test_hover_scoping_present_and_home_only():
     src = inspect.getsource(tui.run_session)
     assert "?1003h" in src and "?1003l" in src
     assert "_sync_hover_mode" in src
+
+
+def test_tick_interval_fast_when_busy_slow_when_idle():
+    # W6: the animation loop wakes 4x/s only while busy/flash; 1x/s when idle.
+    from webbee.tui import _tick_interval
+    assert _tick_interval(True) == 0.25
+    assert _tick_interval(False) == 1.0
+
+
+def test_ticker_busy_includes_turn_flash_and_edge_drag():
+    # W6 review fix: the fast-cadence predicate must fire for a running turn,
+    # a live copy-flash, AND an in-flight edge-drag auto-scroll (else idle
+    # drag-scrolling crawls 4x slower). A pane lacking _edge_drag (HomeView)
+    # must not crash.
+    from webbee.tui import _ticker_busy
+
+    class _Pane:
+        def __init__(self, flash="", edge=0):
+            self._flash, self._edge_drag = flash, edge
+        def flash(self):
+            return self._flash
+
+    class _Slots:
+        def __init__(self, pane):
+            self._p = pane
+        def active(self):
+            return type("S", (), {"pane": self._p})()
+
+    idle, running = (lambda: False), (lambda: True)
+    assert _ticker_busy(_Slots(_Pane()), idle) is False
+    assert _ticker_busy(_Slots(_Pane()), running) is True
+    assert _ticker_busy(_Slots(_Pane(flash="copied")), idle) is True
+    assert _ticker_busy(_Slots(_Pane(edge=1)), idle) is True
+
+    class _Bare:
+        def flash(self):
+            return ""
+    assert _ticker_busy(_Slots(_Bare()), idle) is False

webbee-0.3.32/src/webbee/__init__.py

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