webbee 0.1.0__py3-none-any.whl

webbee/__init__.py

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

webbee/account.py

@@ -0,0 +1,78 @@
+import asyncio
+from dataclasses import dataclass
+from datetime import datetime
+
+
+@dataclass(frozen=True)
+class Account:
+    signed_in: bool = False
+    email: str = ""
+    nickname: str = ""
+    plan: str = ""
+    plan_status: str = ""
+    plan_renews: str = ""
+    dev_tier: str = ""
+    member_since: str = ""
+
+
+def _fmt_month(iso: str) -> str:
+    """'2026-04-27T10:00:00Z' -> 'Apr 2026'; '' on any failure."""
+    try:
+        return datetime.fromisoformat(iso.replace("Z", "+00:00")).strftime("%b %Y")
+    except Exception:
+        return ""
+
+
+def _fmt_day(iso: str) -> str:
+    """'2026-08-01T00:00:00Z' -> '2026-08-01'; '' on any failure."""
+    try:
+        return datetime.fromisoformat(iso.replace("Z", "+00:00")).strftime("%Y-%m-%d")
+    except Exception:
+        return ""
+
+
+async def _default_get(cfg, token: str, path: str) -> dict:
+    import httpx
+    async with httpx.AsyncClient(base_url=cfg.api_url, timeout=3.0) as c:
+        r = await c.get(path, headers={"Authorization": f"Bearer {token}"})
+        r.raise_for_status()
+        return r.json()
+
+
+async def fetch_account(cfg, token_provider, *, get=None) -> Account:
+    """Best-effort account summary for the welcome screen. NEVER raises: no
+    token or a failed /v1/auth/me -> Account(signed_in=False); a failed
+    billing/developer call just omits those fields."""
+    try:
+        token = await token_provider()
+    except Exception:
+        return Account(signed_in=False)
+
+    async def getter(path: str) -> dict:
+        if get is not None:
+            return await get(path)
+        return await _default_get(cfg, token, path)
+
+    async def _try(path):
+        try:
+            return await getter(path)
+        except Exception:
+            return None
+
+    me, sub, dev = await asyncio.gather(
+        _try("/v1/auth/me"), _try("/v1/billing/subscription"), _try("/v1/developer/profile"))
+    if not me:
+        return Account(signed_in=False)
+    attrs = me.get("attributes") or {}
+    sub = sub or {}
+    dev = dev or {}
+    return Account(
+        signed_in=True,
+        email=str(me.get("email", "") or ""),
+        nickname=str(dev.get("nickname", "") or ""),
+        plan=str(sub.get("plan", "") or ""),
+        plan_status=str(sub.get("status", "") or ""),
+        plan_renews=_fmt_day(str(sub.get("expires_at", "") or "")),
+        dev_tier=str(dev.get("tier", "") or attrs.get("developer_tier", "") or ""),
+        member_since=_fmt_month(str(me.get("created_at", "") or dev.get("registered_at", "") or "")),
+    )

webbee/banner_art.py

@@ -0,0 +1,9 @@
+# Webbee Code logo — pyfiglet "big" font (generated). Rendered bee-yellow + centered by render.py.
+WEBBEE_CODE = r"""__          __  _     _                  _____          _
+\ \        / / | |   | |                / ____|        | |
+ \ \  /\  / /__| |__ | |__   ___  ___  | |     ___   __| | ___
+  \ \/  \/ / _ \ '_ \| '_ \ / _ \/ _ \ | |    / _ \ / _` |/ _ \
+   \  /\  /  __/ |_) | |_) |  __/  __/ | |___| (_) | (_| |  __/
+    \/  \/ \___|_.__/|_.__/ \___|\___|  \_____\___/ \__,_|\___|
+
+"""

webbee/cli.py

@@ -0,0 +1,56 @@
+import argparse
+import asyncio
+import os
+
+from webbee import __version__
+from webbee.config import Config
+
+
+def build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(prog="webbee", description="Webbee 🐝 — coding agent in your terminal")
+    p.add_argument("--version", action="version", version=f"webbee {__version__}")
+    p.add_argument("--mode", choices=["default", "plan", "autopilot"], default="default")
+    sub = p.add_subparsers(dest="cmd")
+    sub.add_parser("login", help="Log in to your Imperal account in the browser")
+    sub.add_parser("logout", help="Log out and remove local credentials")
+    return p
+
+
+def main(argv=None) -> None:
+    args = build_parser().parse_args(argv)
+    cfg = Config.from_env()
+
+    if args.cmd == "login":
+        from imperal_mcp import auth
+        print(f"Logged in as {auth.login(cfg)}.")
+        return
+    if args.cmd == "logout":
+        from imperal_mcp import auth
+        asyncio.run(auth.logout(cfg))
+        print("Logged out.")
+        return
+
+    # Default: the polished REPL. Fire a non-blocking update-check first.
+    from webbee.repl import run_repl
+    try:
+        _maybe_print_update_notice()
+        asyncio.run(run_repl(cfg, args.mode))
+    except KeyboardInterrupt:
+        # Ctrl-C during the update-check fetch, or at the read_line() prompt,
+        # unwinds here — exit clean, no traceback. (repl.py itself now cancels
+        # a Ctrl-C mid-turn internally and returns to the prompt instead of
+        # propagating — see run_repl.)
+        print("\nBye 🐝")
+
+
+def _maybe_print_update_notice() -> None:
+    try:
+        from pathlib import Path
+        import time
+        from webbee.update import check_for_update, default_fetch
+        cache = Path(os.path.expanduser("~/.cache/webbee/update.json"))
+        notice = check_for_update(__version__, cache_path=cache, now=time.time(), fetch=default_fetch)
+        if notice:
+            print(notice)
+    except Exception:
+        pass  # update-check must never block or crash startup

webbee/commands.py

@@ -0,0 +1,77 @@
+from dataclasses import dataclass
+
+_MODES = ("default", "plan", "autopilot")
+
+_HELP = """Commands:
+  /help              show this help
+  /login             sign in to your Imperal account (browser)
+  /logout            sign out and remove local credentials
+  /clear             clear the screen + reset session counters
+  /mode [default|plan|autopilot]   consent mode (no arg — show current)
+  /cost  (=/usage)   tokens + $ cost this session
+  /status            cwd · git · surface · tokens · version
+  /exit  (=/quit)    quit"""
+
+
+@dataclass(frozen=True)
+class CommandContext:
+    mode: str
+    workspace: str
+    version: str
+    surface: str
+    logged_in: bool
+    session_tokens: int
+    session_cost: float
+    git_branch: str
+
+
+@dataclass(frozen=True)
+class SlashResult:
+    handled: bool
+    exit: bool = False
+    message: str = ""
+    action: str = ""
+    new_mode: "str | None" = None
+
+
+def dispatch(line: str, ctx: CommandContext) -> SlashResult:
+    """Parse one input line. Non-slash lines return handled=False (the REPL
+    then sends them to the agent). Slash lines are fully handled here."""
+    text = line.strip()
+    if not text.startswith("/"):
+        return SlashResult(handled=False)
+
+    parts = text.split()
+    cmd, args = parts[0].lower(), parts[1:]
+
+    if cmd in ("/exit", "/quit"):
+        return SlashResult(handled=True, exit=True)
+    if cmd == "/help":
+        return SlashResult(handled=True, action="help", message=_HELP)
+    if cmd == "/login":
+        return SlashResult(handled=True, action="login")
+    if cmd == "/logout":
+        return SlashResult(handled=True, action="logout")
+    if cmd == "/clear":
+        return SlashResult(handled=True, action="clear", message="Screen cleared, counters reset.")
+    if cmd in ("/cost", "/usage"):
+        return SlashResult(handled=True, action="cost",
+                           message=f"This session: {ctx.session_tokens} tokens (~${ctx.session_cost:.4f}). "
+                                   f"LLM turns don't spend credits.")
+    if cmd == "/status":
+        auth = "signed in" if ctx.logged_in else "not signed in (/login)"
+        msg = (f"surface: {ctx.surface}   mode: {ctx.mode}   {auth}\n"
+               f"cwd: {ctx.workspace}   git: {ctx.git_branch}\n"
+               f"tokens: {ctx.session_tokens} (~${ctx.session_cost:.4f})   webbee v{ctx.version}")
+        return SlashResult(handled=True, action="status", message=msg)
+    if cmd == "/mode":
+        if not args:
+            return SlashResult(handled=True, action="mode", new_mode=None,
+                               message=f"Current mode: {ctx.mode}. Available: {', '.join(_MODES)}.")
+        want = args[0].lower()
+        if want not in _MODES:
+            return SlashResult(handled=True, action="mode", new_mode=None,
+                               message=f"Unknown mode '{want}'. Available: {', '.join(_MODES)}.")
+        return SlashResult(handled=True, action="mode", new_mode=want,
+                           message=f"Mode → {want}.")
+    return SlashResult(handled=True, message=f"Unknown command '{cmd}'. /help for the list.")

webbee/config.py

@@ -0,0 +1,14 @@
+import os
+from dataclasses import dataclass
+
+@dataclass(frozen=True)
+class Config:
+    api_url: str
+    panel_url: str
+
+    @classmethod
+    def from_env(cls) -> "Config":
+        return cls(
+            api_url=os.environ.get("IMPERAL_API_URL", "https://auth.imperal.io").rstrip("/"),
+            panel_url=os.environ.get("IMPERAL_PANEL_URL", "https://panel.imperal.io").rstrip("/"),
+        )

webbee/events.py

@@ -0,0 +1,17 @@
+from typing import Protocol, runtime_checkable
+
+
+@runtime_checkable
+class TurnSink(Protocol):
+    """Everything a running coding turn tells the UI. The renderer (render.py)
+    implements this with Rich; tests implement it with a recording fake.
+    session.py imports ONLY this — never Rich — so the SSE loop stays testable."""
+
+    def tool_start(self, tool: str, args: dict) -> None: ...
+    def tool_result(self, tool: str, ok: bool, summary: str) -> None: ...
+    async def ask_consent(self, app_id: str, tool: str, args: dict) -> str: ...
+    def panel_release(self, panel_url: str, summary: str) -> None: ...
+    def progress(self, text: str) -> None: ...
+    def usage(self, tokens: int, cost_usd: float) -> None: ...
+    def plan_blocked(self, tool: str) -> None: ...
+    def user_echo(self, text: str) -> None: ...

webbee/render.py

@@ -0,0 +1,313 @@
+import asyncio
+import time
+
+from rich.console import Console
+from rich.markdown import Markdown
+from rich.panel import Panel
+from rich.text import Text
+
+from webbee.banner_art import WEBBEE_CODE
+
+_ICON = {"read_file": "📖", "grep": "🔎", "glob": "🗂️", "write_file": "✎",
+         "edit_file": "🔧", "bash": "⚡"}
+_BEE = "yellow"       # bee-yellow brand accent — logo / 🐝 / notes / busy dot ONLY
+_ACCENT = "cyan"      # interactive chrome ONLY — live caret / mode / panel url
+
+
+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))
+
+
+def _salient_arg(args: dict) -> str:
+    """The one human-readable arg to show for a tool/consent call (PURE) — a
+    title/path/command/name over an opaque id; falls back to the first id-ish
+    value. Keeps the feed readable instead of dumping a raw args dict."""
+    if not isinstance(args, dict):
+        return ""
+    for k in ("title", "name", "path", "pattern", "command", "query", "q"):
+        v = args.get(k)
+        if v:
+            return str(v)
+    for k in ("id", "note_id", "folder_id", "task_id"):
+        v = args.get(k)
+        if v:
+            return str(v)
+    return ""
+
+
+def _invalidate() -> None:
+    """Redraw the running prompt_toolkit app if any. No-op when none is active
+    (tests / non-tty fallback) — the fallback when no output pane is wired."""
+    try:
+        from prompt_toolkit.application import get_app_or_none
+        app = get_app_or_none()
+        if app is not None:
+            app.invalidate()
+    except Exception:
+        pass
+
+
+class RichSink:
+    """Rich implementation of TurnSink. Turn output (action feed, 🐝 answer,
+    footer) is rendered by the Rich Console. In the full-screen dock the Console
+    writes ANSI into the OutputPane's buffer (repl passes console=pane.console +
+    on_output=pane.notify) and the pane shows it in a scrollable region above
+    the fixed input; after each render this sink calls on_output() so the pane
+    follows the tail. The live status (busy/elapsed/tokens) is the dock toolbar,
+    fed by status(). Consent runs through the dock via an asyncio.Future
+    (resolve_consent), with a sync input fallback for non-tty.
+
+    Tests pass live_enabled=False + inject input_fn/clock and no on_output; then
+    _nudge() is a harmless no-op and consent uses the injected input_fn."""
+
+    def __init__(self, console=None, *, live_enabled=True, input_fn=input,
+                 clock=time.monotonic, on_output=None):
+        self.console = console or Console()
+        self._live_enabled = live_enabled
+        self._input = input_fn
+        self._clock = clock
+        self._on_output = on_output      # pane.notify (scroll+redraw) in the dock
+        self.tokens = 0
+        self.cost_usd = 0.0
+        self.session_tokens = 0
+        self.session_cost = 0.0
+        self._tools = 0
+        self._started = None
+        self._busy = False
+        self._current = ""
+        self._pending = ("", "")
+        self._consent = None            # asyncio.Future while awaiting a reply
+        self._consent_summary = ""
+
+    def _nudge(self) -> None:
+        """After output/state changes: let the pane follow the tail + redraw."""
+        if self._on_output is not None:
+            self._on_output()
+        else:
+            _invalidate()
+
+    # ---- welcome ------------------------------------------------------------
+    def welcome(self, account, cwd: str, surface: str) -> None:
+        """One-time launch splash: a centered WEBBEE CODE logo + imperal.io + an
+        honest account panel (who/plan/tier/member-since). Runs BEFORE the dock
+        starts. Clears the screen ONLY in the non-pane path (the full-screen
+        dock owns its own alternate screen — clearing there would corrupt it)."""
+        if self._on_output is None:
+            self.console.clear()
+        w = self.console.width
+
+        def _center_block(text: str) -> str:
+            lines = text.splitlines()
+            bw = max((len(line) for line in lines), default=0)
+            pad = " " * max(0, (w - bw) // 2)
+            return "\n".join(pad + line for line in lines)
+
+        self.console.print()
+        self.console.print(Text(_center_block(WEBBEE_CODE), style=f"bold {_BEE}"))
+        self.console.print(Text("🐝".center(w), style=f"bold {_BEE}"))
+        self.console.print(Text("ICNLI AI Cloud OS · Agent".center(w), style=f"bold {_ACCENT}"))
+        self.console.print(Text("·  i m p e r a l . i o  ·".center(w), style="dim"))
+        self.console.print()
+        rows = []
+        if account.signed_in:
+            who = account.email + (f"   ·   @{account.nickname}" if account.nickname else "")
+            rows.append(("Signed in as", who))
+            if account.plan:
+                plan = account.plan + (f" · {account.plan_status}" if account.plan_status else "")
+                plan += (f" · renews {account.plan_renews}" if account.plan_renews else "")
+                rows.append(("Plan", plan))
+            if account.dev_tier:
+                rows.append(("Developer", f"{account.dev_tier} tier"))
+            if account.member_since:
+                rows.append(("Member since", account.member_since))
+        else:
+            rows.append(("", "not signed in — /login"))
+        bw = max((len(label.ljust(14) + value) for label, value in rows), default=0)
+        pad = " " * max(0, (w - bw) // 2)
+        for label, value in rows:
+            self.console.print(Text.assemble((pad + label.ljust(14), "dim"), (value, "white")))
+        self.console.print()
+        self.console.print(Text("/help · Ctrl-D to exit".center(w), style="dim"))
+        self.console.print()
+        self._nudge()
+
+    # ---- turn lifecycle -------------------------------------------------
+    def begin_turn(self) -> None:
+        self._tools = 0
+        self._started = self._clock()
+        self._current = ""
+        self._pending = ("", "")
+        self.tokens = 0        # per-turn live counters (usage frames are per-turn cumulative)
+        self.cost_usd = 0.0
+        self._busy = True
+        self.console.print()   # breathing room between the user's message and the response
+        self._nudge()
+
+    def end_turn(self, final_text: str) -> None:
+        self._busy = False
+        if final_text:
+            self.console.print()   # separation before the focus block
+            self.console.print(Text("  🐝 Webbee", style=f"bold {_BEE}"))
+            self.console.print(Markdown(final_text))
+        elapsed = self._elapsed()
+        self.session_tokens += self.tokens
+        self.session_cost += self.cost_usd
+        noun = "action" if self._tools == 1 else "actions"
+        self.console.print(Text(
+            f"  {elapsed:.1f}s · {self._tools} {noun} · {_fmt_tokens(self.tokens)} tok"
+            f" · session {_fmt_tokens(self.session_tokens)} tok",
+            style="dim"))
+        self.console.print()   # breathing room before the next prompt
+        self._nudge()
+
+    def note(self, message: str) -> None:
+        self.console.print(Text("  " + message, style=_BEE))
+        self._nudge()
+
+    def user_echo(self, text: str) -> None:
+        """Commit the just-sent user message as its own clearly-readable line
+        with a background bar (NOT boxed like the live input) so it stands out
+        as 'what I sent' in the scrollback."""
+        self.console.print(Text.assemble(
+            ("  ", ""), (" ❯ " + text + " ", "bold white on grey30")))
+        self._nudge()
+
+    def clear(self) -> None:
+        """/clear: wipe the pane/screen + reset the session counters."""
+        self.console.clear()
+        self.tokens = 0
+        self.cost_usd = 0.0
+        self.session_tokens = 0
+        self.session_cost = 0.0
+        self._tools = 0
+        self._current = ""
+        self._nudge()
+
+    def abort(self) -> None:
+        """Ctrl-C mid-turn: clear busy so the toolbar drops back to idle. No
+        printing — the caller (repl.py) prints the note."""
+        self._busy = False
+        self._nudge()
+
+    # ---- TurnSink -------------------------------------------------------
+    def tool_start(self, tool: str, args: dict) -> None:
+        self._tools += 1
+        arg = args.get("path") or args.get("pattern") or args.get("command") or ""
+        self._pending = (tool, str(arg))
+        self._current = f"{tool} {str(arg)[:40]}".strip()
+        self._nudge()  # the completed line is printed in tool_result
+
+    def tool_result(self, tool: str, ok: bool, summary: str) -> None:
+        # One calm dim line: icon + tool (+arg), then the ✓/✗ RIGHT NEXT TO the
+        # action (not pinned to the far right), then a dim summary. Only the
+        # ✓/✗ carries colour — the rest recedes (dim).
+        _tool, arg = self._pending if self._pending[0] else (tool, "")
+        icon = _ICON.get(_tool, "⚡")
+        mark = "✓" if ok else "✗"
+        self.console.print(Text.assemble(
+            ("  " + icon + " ", "dim"),
+            (_tool, "dim"),
+            (("  " + arg[:40]) if arg else "", "dim"),
+            ("   ", ""),
+            (mark + " ", "green" if ok else "red"),
+            (str(summary)[:50], "dim"),
+        ))
+        self._pending = ("", "")
+        self._nudge()
+
+    async def ask_consent(self, app_id: str, tool: str, args: dict) -> str:
+        """Ask for consent and return the user's RAW reply (trimmed only) —
+        NEVER interpret (the kernel decides, ICNLI). When the dock is running
+        the reply comes through the pinned box via an asyncio.Future (no
+        blocking input on the event loop); otherwise fall back to the injected
+        sync reader (tests / non-tty)."""
+        label = f"{app_id}·{tool}" if app_id else tool
+        sal = _salient_arg(args)
+        self.console.print(Text.assemble(("  ? approve ", "yellow"), (label, "dim"),
+                                          (("  " + sal[:60]) if sal else "", "dim")))
+        fut = self._arm_consent(label, sal)
+        if fut is None:                       # non-tty / no running app
+            raw = self._input("     ")
+        else:
+            self._nudge()
+            raw = await fut
+        self._consent = None
+        self._consent_summary = ""
+        raw = (raw or "").strip()
+        self.console.print(Text("  ↳ " + raw, style="dim"))   # quiet echo of the reply
+        self._nudge()
+        return raw
+
+    def panel_release(self, panel_url: str, summary: str) -> None:
+        body = Text.assemble(
+            (summary + "\n\n" if summary else "", "white"),
+            ("Approve it in your browser:\n", "white"),
+            (f"  {panel_url}\n", f"bold {_ACCENT}"),
+            ("Then ask again — you weren't charged.", "dim"),
+        )
+        self.console.print(Panel(body, title="💳 This costs money", border_style="magenta"))
+        self._nudge()
+
+    def progress(self, text: str) -> None:
+        if text:
+            self.console.print(Text("  " + text, style="dim italic"))
+            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."""
+        self.console.print(Text.assemble(
+            ("  ⛔ plan mode", _BEE),
+            (f" — {tool} blocked. " if tool else " — action blocked. ", "dim"),
+            ("Press Shift+Tab to switch to default or autopilot to allow it.", "dim")))
+        self._nudge()
+
+    def usage(self, tokens: int, cost_usd: float) -> None:
+        # Cumulative frame — trust the server's running totals verbatim.
+        self.tokens = tokens
+        self.cost_usd = cost_usd
+        self._nudge()
+
+    # ---- dock bridge (read by tui.run_session's toolbar + Enter binding) ---
+    def status(self) -> dict:
+        """Live state for the dock toolbar. The bottom counter shows the SESSION
+        TOTAL (not per-turn): the running session total, plus the in-flight
+        turn's spend while busy (so it grows live), with no double-count at idle
+        (end_turn has already folded the finished turn into the session)."""
+        return {"busy": self._busy, "current": self._current,
+                "elapsed": self._elapsed(), "tools": self._tools,
+                "tokens": self.session_tokens + (self.tokens if self._busy else 0),
+                "cost": self.session_cost + (self.cost_usd if self._busy else 0.0),
+                "consent": self.consent_pending()}
+
+    def is_busy(self) -> bool:
+        return self._busy
+
+    def consent_pending(self) -> bool:
+        return self._consent is not None and not self._consent.done()
+
+    def resolve_consent(self, raw: str) -> None:
+        """Called by the dock's Enter binding when a consent reply is awaited —
+        hands the RAW reply verbatim to the awaiting ask_consent (ICNLI)."""
+        if self.consent_pending():
+            self._consent.set_result(raw)
+
+    # ---- internals ------------------------------------------------------
+    def _arm_consent(self, label: str, summary: str):
+        """Create the consent Future iff a dock is running; else None (caller
+        falls back to sync input)."""
+        try:
+            from prompt_toolkit.application import get_app_or_none
+            if get_app_or_none() is None:
+                return None
+            self._consent = asyncio.get_running_loop().create_future()
+            self._consent_summary = summary or label
+            return self._consent
+        except Exception:
+            return None
+
+    def _elapsed(self) -> float:
+        if self._started is None:
+            return 0.0
+        return self._clock() - self._started