webbee 0.3.32__tar.gz → 0.3.34__tar.gz

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

@@ -1,5 +1,24 @@
 # Changelog
 
+## 0.3.34
+
+Paste images with Ctrl+V. Copy a screenshot (or any image) and press Ctrl+V in
+a session tab — Webbee Code uploads it and drops a reference into your prompt,
+so the next thing you ask can be about that image. Text on the clipboard
+pastes inline. Nothing is sent until you send your message; if image upload
+isn't available the image is saved locally and referenced by path.
+
+## 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.34}/PKG-INFO

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

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

webbee-0.3.34/src/webbee/__init__.py

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

webbee-0.3.34/src/webbee/clipboard_read.py

@@ -0,0 +1,154 @@
+"""Read the OS clipboard OUT-OF-BAND for Ctrl+V paste (W3 Wave A).
+
+A terminal's bracketed paste is text-only — a clipboard IMAGE never reaches the
+app that way — so an image must be pulled from the OS clipboard via the
+platform tool. Same discipline as `clipboard.py` (copy-out): `shutil.which`-
+gated, bounded timeout, output CAPTURED so it never inherits the dock's tty
+(the 0.3.32 lesson: a chatty child scrambles the full-screen renderer), and it
+NEVER raises. macOS + Linux are the verified paths; Windows is best-effort and
+UNVERIFIED (no Windows host to test on) — it fails soft to None."""
+from __future__ import annotations
+
+import shutil
+import subprocess
+import sys
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class ClipboardItem:
+    kind: str          # "image" | "text"
+    data: object       # bytes (PNG) for image, str for text
+    name: str = ""     # suggested filename for an image
+    mime: str = ""
+
+
+def _run(cmd):
+    """Captured, bounded, never-raises subprocess. `capture_output=True` keeps
+    stdout/stderr OFF the dock's tty. Returns CompletedProcess or None."""
+    try:
+        return subprocess.run(cmd, capture_output=True, timeout=2)
+    except Exception:
+        return None
+
+
+def _read_via_tempfile(argv_for_path) -> "bytes | None":
+    """Run a tool that WRITES a PNG to a temp path (osascript / PowerShell),
+    then read+delete it. `argv_for_path(path)` returns the argv. Never raises."""
+    import os
+    import tempfile
+    fd, path = tempfile.mkstemp(suffix=".png")
+    os.close(fd)
+    try:
+        p = _run(argv_for_path(path))
+        if p is not None and p.returncode == 0 and os.path.getsize(path) > 0:
+            with open(path, "rb") as f:
+                return f.read() or None
+        return None
+    except Exception:
+        return None
+    finally:
+        try:
+            os.remove(path)
+        except OSError:
+            pass
+
+
+def _mac_image() -> "bytes | None":
+    if shutil.which("pngpaste"):
+        p = _run(["pngpaste", "-"])
+        if p is not None and p.returncode == 0 and p.stdout:
+            return p.stdout
+    if not shutil.which("osascript"):
+        return None
+    # osascript returns non-zero when the clipboard holds no «class PNGf» image.
+    def _argv(path):
+        script = ('set p to (POSIX file "%s")\n'
+                  'set d to (the clipboard as «class PNGf»)\n'
+                  'set fh to open for access p with write permission\n'
+                  'write d to fh\nclose access fh' % path)
+        return ["osascript", "-e", script]
+    return _read_via_tempfile(_argv)
+
+
+def _linux_image() -> "bytes | None":
+    if shutil.which("wl-paste"):
+        types = _run(["wl-paste", "--list-types"])
+        if types is not None and types.returncode == 0 and b"image/png" in (types.stdout or b""):
+            p = _run(["wl-paste", "--type", "image/png"])
+            if p is not None and p.returncode == 0 and p.stdout:
+                return p.stdout
+    if shutil.which("xclip"):
+        tgt = _run(["xclip", "-selection", "clipboard", "-t", "TARGETS", "-o"])
+        if tgt is not None and tgt.returncode == 0 and b"image/png" in (tgt.stdout or b""):
+            p = _run(["xclip", "-selection", "clipboard", "-t", "image/png", "-o"])
+            if p is not None and p.returncode == 0 and p.stdout:
+                return p.stdout
+    return None
+
+
+def _windows_image() -> "bytes | None":
+    # UNVERIFIED (no Windows host). Best-effort; fail-soft to None.
+    if not shutil.which("powershell"):
+        return None
+
+    def _argv(path):
+        ps = ("Add-Type -AssemblyName System.Windows.Forms;"
+              "$i=[System.Windows.Forms.Clipboard]::GetImage();"
+              "if($i){$i.Save('%s')}" % path.replace("\\", "\\\\"))
+        return ["powershell", "-NoProfile", "-Command", ps]
+    return _read_via_tempfile(_argv)
+
+
+def read_clipboard_image() -> "bytes | None":
+    """Raw PNG bytes on the clipboard, or None. Platform-dispatched, captured
+    (tty-safe), never raises."""
+    try:
+        if sys.platform == "darwin":
+            return _mac_image()
+        if sys.platform == "win32":
+            return _windows_image()
+        return _linux_image()
+    except Exception:
+        return None
+
+
+def _text_cmd() -> "list[str] | None":
+    if sys.platform == "darwin":
+        return ["pbpaste"] if shutil.which("pbpaste") else None
+    if shutil.which("wl-paste"):
+        return ["wl-paste", "--no-newline"]
+    if shutil.which("xclip"):
+        return ["xclip", "-selection", "clipboard", "-o"]
+    if sys.platform == "win32" and shutil.which("powershell"):
+        return ["powershell", "-NoProfile", "-Command", "Get-Clipboard"]
+    return None
+
+
+def read_clipboard_text() -> "str | None":
+    """The clipboard's text, or None. Captured (tty-safe), never raises."""
+    cmd = _text_cmd()
+    if cmd is None:
+        return None
+    p = _run(cmd)
+    if p is not None and p.returncode == 0 and p.stdout:
+        try:
+            return p.stdout.decode("utf-8", "replace")
+        except Exception:
+            return None
+    return None
+
+
+def read_clipboard(ts: str) -> "ClipboardItem | None":
+    """One paste's worth of clipboard content: an IMAGE if present (PNG bytes,
+    named `pasted-<ts>.png`), else TEXT, else None. `ts` is a caller-supplied
+    timestamp string for the image name (the dock has no wall-clock in a pure
+    function, so it's passed in)."""
+    img = read_clipboard_image()
+    if img:
+        return ClipboardItem(kind="image", data=img, name=f"pasted-{ts}.png",
+                             mime="image/png")
+    txt = read_clipboard_text()
+    if txt:
+        return ClipboardItem(kind="text", data=txt)
+    return None

{webbee-0.3.32 → webbee-0.3.34}/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.34}/src/webbee/home_view.py

@@ -368,6 +368,9 @@ class HomeView:
     def flash(self) -> str:
         return self._out.flash()
 
+    def flash_note(self, msg: str, secs: float = 4.0) -> None:
+        self._out.flash_note(msg, secs)
+
     def scroll(self, delta: int) -> None:
         # Wheel (via the control) and PageUp/PageDown (tui routes here) move the
         # top visible line; clamped so you can't scroll past the ends.

{webbee-0.3.32 → webbee-0.3.34}/src/webbee/intel/watch.py

@@ -11,7 +11,9 @@ def _ignored(path: str) -> bool:
     filter works on Windows too (watchfiles yields backslash paths there --
     unfiltered .git churn re-indexed the repo on every checkpoint)."""
     p = path.replace(os.sep, "/").replace("\\", "/")
-    return "/.git/" in p or "/node_modules/" in p
+    # `.webbee/` = our own per-workspace scratch (pasted images, gitignore) —
+    # never re-index/checkpoint on a paste (W3).
+    return "/.git/" in p or "/node_modules/" in p or "/.webbee/" in p
 
 
 async def watch_workspace(root: str, on_change) -> None:

{webbee-0.3.32 → webbee-0.3.34}/src/webbee/output_pane.py

@@ -335,6 +335,13 @@ class OutputPane:
         import time as _t
         return self.copy_flash if _t.monotonic() < self._flash_until else ""
 
+    def flash_note(self, msg: str, secs: float = 4.0) -> None:
+        """Show a transient toolbar note (paste progress, hints) — same channel
+        as the copy toast, reused so there's one flash mechanism."""
+        import time as _t
+        self.copy_flash = msg
+        self._flash_until = _t.monotonic() + secs
+
     # ---- W2 Task 8: selection capture past the pane's own Window --------
     def forward_mouse(self, ev, clamp: str = "bottom") -> bool:
         """Public seam neighbor windows call FIRST (via `tui._forwarding` /

{webbee-0.3.32 → webbee-0.3.34}/src/webbee/repl.py

@@ -676,6 +676,43 @@ def _schedule_home_refill(slots: SlotManager, idx: int, fill_kwargs: dict, *,
     return True
 
 
+def _save_pasted(workspace: str, name: str, data: bytes) -> str:
+    """Save a pasted image into `<workspace>/.webbee/pasted/<name>` (that dir
+    ships a `.gitignore` of `*` so pasted files never pollute the repo or its
+    shadow-git). Returns the saved path, or "" on any failure. Never raises."""
+    try:
+        base = os.path.join(workspace, ".webbee")
+        pdir = os.path.join(base, "pasted")
+        os.makedirs(pdir, exist_ok=True)
+        gi = os.path.join(base, ".gitignore")
+        if not os.path.exists(gi):
+            with open(gi, "w", encoding="utf-8") as f:
+                f.write("*\n")
+        path = os.path.join(pdir, name)
+        with open(path, "wb") as f:
+            f.write(data)
+        return path
+    except Exception:
+        return ""
+
+
+def _extract_file_id(resp) -> str:
+    """Pull `file_id` from a file-reader `receive_files` response. Canon: it
+    lives at `data.items[].file_id` (== `.id`), NOT `data.received` (the panel's
+    Round-3 lesson). Handles dict + object shapes; "" if absent."""
+    try:
+        data = resp.get("data") if isinstance(resp, dict) else getattr(resp, "data", None)
+        items = data.get("items") if isinstance(data, dict) else getattr(data, "items", None)
+        if items:
+            it = items[0]
+            if isinstance(it, dict):
+                return str(it.get("file_id") or it.get("id") or "")
+            return str(getattr(it, "file_id", "") or getattr(it, "id", "") or "")
+    except Exception:
+        pass
+    return ""
+
+
 async def run_repl(cfg, mode: str = "default", *, once: bool = False, sink=None, read_line=input,
                    agent_factory=None, auth=None, account_fetcher=None,
                    sessions_client=None, intel_factory=None, shadow_factory=None) -> None:
@@ -1337,6 +1374,32 @@ async def run_repl(cfg, mode: str = "default", *, once: bool = False, sink=None,
                         from prompt_toolkit.application import get_app
                         get_app().exit()
 
+                async def _on_paste(ws: str, name: str, data: bytes) -> str:
+                    # W3 Wave A: save the pasted image into the tab's workspace
+                    # then upload it through the SAME file-reader door the panel
+                    # and Telegram use; return the reference to drop into the
+                    # task. Degrades honestly on 402 / no cloud (local path +
+                    # note). Never raises.
+                    import base64
+                    saved = _save_pasted(ws, name, data)
+                    try:
+                        from imperal_mcp.client import ImperalClient
+                        client = ImperalClient(cfg, token_provider)
+                        b64 = base64.b64encode(data).decode("ascii")
+                        resp = await client.run_tool(
+                            "file-reader", "receive_files",
+                            {"files": [{"name": name, "mime_type": "image/png",
+                                        "data_base64": b64}]})
+                        fid = _extract_file_id(resp)
+                        if fid:
+                            return f"📎 {name} (file_id={fid})"
+                    except Exception:
+                        pass
+                    if saved:
+                        return (f"📎 {name} — saved to {saved}; a file-reader "
+                                "plan is needed to send it to the model")
+                    return f"📎 {name} — could not upload"
+
                 try:
                     ok = await tui.run_session(
                         slots=slots, on_line=_on_line, on_cycle=_cycle,
@@ -1359,6 +1422,7 @@ async def run_repl(cfg, mode: str = "default", *, once: bool = False, sink=None,
                             spawn_poller=_spawn_slot_poller),
                         on_switch=lambda idx: _schedule_home_refill(slots, idx, home_fill_kwargs),
                         on_new=lambda: _open_new_tab(),
+                        on_paste=_on_paste,
                     )
                 finally:
                     _cancel_background()

{webbee-0.3.32 → webbee-0.3.34}/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.34}/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
@@ -508,7 +534,7 @@ def _restore_draft(buf, slot) -> None:
 async def run_session(*, slots, on_line, on_cycle, steps_nav=None,
                       stop_turn=None, queued_run=None, inject=None,
                       home_input=None, cancel_slot=None, ui_hooks=None,
-                      on_switch=None, on_new=None) -> bool:
+                      on_switch=None, on_new=None, on_paste=None) -> bool:
     """The full-screen dock: EVERYTHING visible resolves `slots.active()` AT
     CALL TIME (W4a Task 3 — the single most structural change of the
     multisession-tabs wave: no more one session's objects captured once at
@@ -823,6 +849,49 @@ async def run_session(*, slots, on_line, on_cycle, steps_nav=None,
         # Alt+1-style switch (footer legend reminds muscle-memory users).
         _new_tab_click()
 
+    @kb.add("c-v")
+    def _paste_key(event):
+        # 0.3.34 (W3 Wave A): Ctrl-V pastes the OS clipboard. An IMAGE is read
+        # OUT-OF-BAND (a terminal's bracketed paste is text-only), then saved +
+        # uploaded via the file-reader door (repl's on_paste) and its reference
+        # dropped into the input; a text clipboard is inserted inline. Normal
+        # text paste (Cmd-V / Ctrl-Shift-V → bracketed paste) is a DIFFERENT
+        # key and is unaffected. Home has no workspace/agent → guide, not crash.
+        import time as _t
+        from webbee.clipboard_read import read_clipboard
+        slot = _a()
+        pane = _pane()
+        if on_paste is None or slot.kind == "home" or not getattr(slot, "workspace", ""):
+            pane.flash_note("📎 open a session tab to paste a file")
+            event.app.invalidate()
+            return
+        item = read_clipboard(_t.strftime("%Y%m%d-%H%M%S", _t.gmtime()))
+        if item is None:
+            pane.flash_note("clipboard is empty")
+            event.app.invalidate()
+            return
+        if item.kind == "text":
+            buf.insert_text(item.data)
+            return
+        pane.flash_note(f"📎 uploading {item.name}…", secs=30.0)
+        event.app.invalidate()
+
+        async def _do_paste():
+            ref = ""
+            try:
+                ref = await on_paste(slot.workspace, item.name, item.data)
+            except Exception:
+                ref = ""
+            if ref:
+                sep = "" if (not buf.text or buf.text.endswith(" ")) else " "
+                buf.insert_text(sep + ref + " ")
+                pane.flash_note(f"📎 {item.name}")
+            else:
+                pane.flash_note("📎 paste failed")
+            event.app.invalidate()
+
+        event.app.create_background_task(_do_paste())
+
     def _alt_digit_handler(d: int):
         def _h(event):
             _switch_to(d)
@@ -1272,7 +1341,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.34/tests/test_clipboard_read.py

@@ -0,0 +1,84 @@
+import subprocess
+import sys
+
+import webbee.clipboard_read as cr
+
+
+class _CP:
+    def __init__(self, rc=0, out=b""):
+        self.returncode = rc
+        self.stdout = out
+
+
+def test_run_captures_output_tty_safe(monkeypatch):
+    # The 0.3.32 lesson: clipboard subprocesses must NOT inherit the dock tty.
+    seen = {}
+
+    def fake(cmd, **kw):
+        seen.update(kw)
+        return _CP(0, b"x")
+
+    monkeypatch.setattr(subprocess, "run", fake)
+    cr._run(["echo"])
+    assert seen.get("capture_output") is True
+    assert seen.get("timeout") == 2
+
+
+def test_run_never_raises(monkeypatch):
+    monkeypatch.setattr(subprocess, "run", lambda *a, **k: (_ for _ in ()).throw(RuntimeError()))
+    assert cr._run(["x"]) is None
+
+
+def test_mac_image_via_pngpaste(monkeypatch):
+    monkeypatch.setattr(sys, "platform", "darwin")
+    monkeypatch.setattr(cr.shutil, "which", lambda n: "/p" if n == "pngpaste" else None)
+    monkeypatch.setattr(subprocess, "run", lambda cmd, **k: _CP(0, b"\x89PNGdata"))
+    assert cr.read_clipboard_image() == b"\x89PNGdata"
+
+
+def test_image_none_when_no_tool(monkeypatch):
+    monkeypatch.setattr(sys, "platform", "darwin")
+    monkeypatch.setattr(cr.shutil, "which", lambda n: None)
+    assert cr.read_clipboard_image() is None
+
+
+def test_linux_image_requires_png_in_targets(monkeypatch):
+    monkeypatch.setattr(sys, "platform", "linux")
+    monkeypatch.setattr(cr.shutil, "which", lambda n: "/x" if n == "xclip" else None)
+
+    def fake(cmd, **k):
+        if "TARGETS" in cmd:
+            return _CP(0, b"TARGETS\nimage/png\nUTF8_STRING")
+        return _CP(0, b"PNGDATA")
+
+    monkeypatch.setattr(subprocess, "run", fake)
+    assert cr.read_clipboard_image() == b"PNGDATA"
+
+
+def test_linux_image_none_when_no_png_target(monkeypatch):
+    monkeypatch.setattr(sys, "platform", "linux")
+    monkeypatch.setattr(cr.shutil, "which", lambda n: "/x" if n == "xclip" else None)
+    monkeypatch.setattr(subprocess, "run", lambda cmd, **k: _CP(0, b"TARGETS\nUTF8_STRING"))
+    assert cr.read_clipboard_image() is None
+
+
+def test_read_clipboard_text(monkeypatch):
+    monkeypatch.setattr(sys, "platform", "darwin")
+    monkeypatch.setattr(cr.shutil, "which", lambda n: "/p" if n == "pbpaste" else None)
+    monkeypatch.setattr(subprocess, "run", lambda cmd, **k: _CP(0, b"hello text"))
+    assert cr.read_clipboard_text() == "hello text"
+
+
+def test_read_clipboard_prefers_image_then_text_then_none(monkeypatch):
+    monkeypatch.setattr(cr, "read_clipboard_image", lambda: b"IMG")
+    monkeypatch.setattr(cr, "read_clipboard_text", lambda: "txt")
+    item = cr.read_clipboard("20260721")
+    assert item.kind == "image" and item.data == b"IMG"
+    assert item.name == "pasted-20260721.png" and item.mime == "image/png"
+
+    monkeypatch.setattr(cr, "read_clipboard_image", lambda: None)
+    item = cr.read_clipboard("x")
+    assert item.kind == "text" and item.data == "txt"
+
+    monkeypatch.setattr(cr, "read_clipboard_text", lambda: None)
+    assert cr.read_clipboard("x") is None

webbee-0.3.34/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.34}/tests/test_repl.py

@@ -2815,3 +2815,29 @@ def test_remote_mode_flip_targets_polled_slot_not_active(monkeypatch):
     confirm_src = inspect.getsource(repl_mod._confirm_autopilot)
     assert "slots.active()" not in confirm_src
     assert "def _confirm_autopilot(slot" in confirm_src
+
+
+def test_extract_file_id_reads_items_path():
+    # Canon: data.items[].file_id (== .id), NOT data.received.
+    from webbee.repl import _extract_file_id
+    assert _extract_file_id({"data": {"items": [{"file_id": "abc", "id": "xyz"}]}}) == "abc"
+    assert _extract_file_id({"data": {"items": [{"id": "xyz"}]}}) == "xyz"
+    assert _extract_file_id({"data": {"items": []}}) == ""
+    assert _extract_file_id({"data": {}}) == ""
+    assert _extract_file_id({}) == ""
+    assert _extract_file_id(None) == ""
+
+
+def test_save_pasted_writes_file_and_gitignore(tmp_path):
+    import os as _os
+    from webbee.repl import _save_pasted
+    p = _save_pasted(str(tmp_path), "pasted-x.png", b"\x89PNG")
+    assert p and _os.path.isfile(p)
+    with open(p, "rb") as f:
+        assert f.read() == b"\x89PNG"
+    assert (tmp_path / ".webbee" / ".gitignore").read_text().strip() == "*"
+
+
+def test_save_pasted_never_raises_on_bad_dir():
+    from webbee.repl import _save_pasted
+    assert _save_pasted("/dev/null/nope", "x.png", b"x") == ""

{webbee-0.3.32 → webbee-0.3.34}/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.34}/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"