asher-cli 0.0.1__py3-none-any.whl

asher/connection/__init__.py

@@ -0,0 +1,120 @@
+"""Whisker cloud API connection and authentication."""
+
+from __future__ import annotations
+
+import contextlib
+import os
+from typing import Any
+
+import keyring
+import keyring.errors
+from dotenv import load_dotenv
+from textual import work
+from textual.widgets import RichLog
+
+from ..helpers import ts
+
+load_dotenv()
+
+_SERVICE = "asher-cli"
+
+
+def _keyring_load() -> tuple[str, str]:
+    try:
+        email = keyring.get_password(_SERVICE, "email") or ""
+        password = keyring.get_password(_SERVICE, "password") or ""
+        return email, password
+    except Exception:
+        return "", ""
+
+
+def _keyring_save(email: str, password: str) -> bool:
+    try:
+        keyring.set_password(_SERVICE, "email", email)
+        keyring.set_password(_SERVICE, "password", password)
+        return True
+    except Exception:
+        return False
+
+
+def _keyring_delete() -> None:
+    for key in ("email", "password"):
+        with contextlib.suppress(Exception):
+            keyring.delete_password(_SERVICE, key)
+
+
+class ConnectionMixin:
+    # declared for type checkers; assigned in AsherApp.__init__
+    _account: Any
+    _robot: Any
+    _pets: list
+
+    @work(exclusive=True)
+    async def _connect_worker(self) -> None:
+        log = self.query_one("#log", RichLog)  # type: ignore[attr-defined]
+
+        email, password = _keyring_load()
+
+        if not email or not password:
+            env_email = os.getenv("LITTER_ROBOT_USER") or os.getenv("LR4_EMAIL") or ""
+            env_pass = os.getenv("LITTER_ROBOT_PASSWORD") or os.getenv("LR4_PASSWORD") or ""
+            email = email or env_email
+            password = password or env_pass
+
+        if not email or not password:
+            from textual.widgets import Static  # noqa: PLC0415
+
+            self._is_loading = False  # type: ignore[attr-defined]
+            self._log_info("No saved credentials found.")  # type: ignore[attr-defined]
+            self._log_info("Type /login to sign in.")  # type: ignore[attr-defined]
+            self._set_cat("idle", "not signed in")  # type: ignore[attr-defined]
+            self.query_one("#hint-bar", Static).update("/login to sign in")  # type: ignore[attr-defined]
+            return
+
+        try:
+            from pylitterbot import Account  # noqa: PLC0415
+
+            self._account = Account()
+            await self._account.connect(
+                username=email, password=password, load_robots=True, load_pets=True
+            )
+            self._pets = list(self._account.pets)
+            robots = list(self._account.robots)
+
+            if not robots:
+                self._log_err("No Litter Robots found on this account.")  # type: ignore[attr-defined]
+                self._set_cat("error", "no robots")  # type: ignore[attr-defined]
+                return
+
+            self._robot = robots[0]
+            if len(robots) > 1:
+                self._log_info(  # type: ignore[attr-defined]
+                    f"{len(robots)} robots found — using '{getattr(robots[0], 'name', 'robot #1')}'"
+                )
+                for i, rb in enumerate(robots):
+                    model = type(rb).__name__
+                    self._log_info(  # type: ignore[attr-defined]
+                        f"  [{i}] {getattr(rb, 'name', '?')} ({model}  serial={getattr(rb, 'serial', '?')})"
+                    )
+
+            await self._update_last_cat_seen()  # type: ignore[attr-defined]
+            await self._refresh_status()  # type: ignore[attr-defined]
+
+            t = ts()
+            t.append("✓ Connected to ", style="#3fb950")
+            name = getattr(self._robot, "name", "robot")
+            model = type(self._robot).__name__
+            t.append(name, style="bold #e6edf3")
+            t.append(f" ({model})", style="#484f58")
+            log.write(t)
+            self._set_cat("happy", "connected!")  # type: ignore[attr-defined]
+
+        except ImportError:
+            self._is_loading = False  # type: ignore[attr-defined]
+            self._log_err("pylitterbot not installed. Run: pip install pylitterbot")  # type: ignore[attr-defined]
+            self._set_cat("error", "missing dep")  # type: ignore[attr-defined]
+        except Exception as exc:
+            self._is_loading = False  # type: ignore[attr-defined]
+            self._log_err(f"Connection failed: {exc}")  # type: ignore[attr-defined]
+            self._log_warn("Type '/logout' to clear saved credentials and try again.")  # type: ignore[attr-defined]
+            self._set_cat("error", "auth error")  # type: ignore[attr-defined]

asher/helpers.py

@@ -0,0 +1,48 @@
+"""Pure helper functions — no Textual or pylitterbot imports."""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+
+from rich.text import Text
+
+STATUS_COLORS: dict[str, str] = {
+    "Ready": "#3fb950",  # green
+    "Cycling": "#58a6ff",  # blue
+    "Cat Detected": "#d29922",  # amber
+    "Drawer Full": "#f85149",  # red
+    "Offline": "#f85149",  # red
+    "Sleeping": "#484f58",  # muted
+}
+
+
+def fmt_ago(dt: datetime | None) -> str:
+    if dt is None:
+        return "never"
+    if dt.tzinfo is None:
+        dt = dt.replace(tzinfo=timezone.utc)
+    s = int((datetime.now(timezone.utc) - dt).total_seconds())
+    if s < 60:
+        return f"{s}s ago"
+    if s < 3600:
+        return f"{s // 60}m ago"
+    if s < 86400:
+        return f"{s // 3600}h ago"
+    return f"{s // 86400}d ago"
+
+
+def drawer_bar(pct: float, width: int = 14) -> Text:
+    filled = max(0, min(width, int(width * pct / 100)))
+    bar = "█" * filled + "░" * (width - filled)
+    color = "#f85149" if pct >= 85 else "#d29922" if pct >= 60 else "#3fb950"
+    t = Text()
+    t.append("[", style="#484f58")
+    t.append(bar, style=color)
+    t.append("]", style="#484f58")
+    return t
+
+
+def ts() -> Text:
+    t = Text()
+    t.append(f"[{datetime.now().strftime('%H:%M:%S')}] ", style="#484f58")
+    return t

asher/monitoring/__init__.py

@@ -0,0 +1,111 @@
+"""Robot status polling and refresh."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from rich.text import Text
+from textual import work
+from textual.widgets import Static
+
+from ..helpers import drawer_bar, fmt_ago
+
+
+class MonitoringMixin:
+    # declared for type checkers; assigned in AsherApp.__init__
+    _robot: Any
+    _pets: list
+    _cat_mode: str
+    _last_cat_seen: Any
+
+    async def _update_last_cat_seen(self) -> None:
+        """Cache the timestamp of the most recent cat-detection event from activity history."""
+        if self._robot is None:
+            return
+        try:
+            acts = await self._robot.get_activity_history(limit=10)
+            for act in acts:
+                w = getattr(act, "weight", None)
+                action: Any = getattr(act, "action", None)
+                action_text = (
+                    action.text if hasattr(action, "text") else str(action or "")
+                ).lower()
+                if (w is not None and float(w) > 0) or "cat" in action_text:
+                    ts_dt = getattr(act, "timestamp", None)
+                    if ts_dt is not None:
+                        self._last_cat_seen = ts_dt
+                        return
+        except Exception:
+            pass
+
+    async def _refresh_status(self) -> None:
+        r = self._robot
+        if r is None:
+            return
+        self._is_loading = False
+
+        name = getattr(r, "name", "—")
+        online = getattr(r, "is_online", False)
+        drawer = float(getattr(r, "waste_drawer_level", 0) or 0)
+        status = getattr(r, "status", None)
+        sleeping = getattr(r, "sleeping", False)
+        last_seen = self._last_cat_seen or getattr(r, "last_seen", None)
+
+        status_str = status.value if status else ("Sleeping" if sleeping else "Ready")
+
+        weight_val = "—"
+        try:
+            w = getattr(r, "pet_weight", None)
+            if w is not None and float(w) > 0:
+                weight_val = f"{float(w):.1f} lb"
+        except Exception:
+            pass
+
+        pet_name = self._pets[0].name if self._pets else None
+
+        self.query_one("#robot-lbl", Static).update(Text(name, style="bold #e6edf3"))  # type: ignore[attr-defined]
+
+        online_lbl = self.query_one("#online-lbl", Static)  # type: ignore[attr-defined]
+        if online:
+            online_lbl.update(Text("● ONLINE", style="bold #3fb950"))
+        else:
+            online_lbl.update(Text("○ OFFLINE", style="bold #f85149"))
+
+        self.query_one("#status-lbl", Static).update(  # type: ignore[attr-defined]
+            Text(f"[{status_str}]", style="#8b949e")
+        )
+
+        bar = drawer_bar(drawer)
+        dt = Text()
+        dt.append("Drawer ", style="#484f58")
+        dt.append_text(bar)
+        dt.append(f" {drawer:.0f}%", style="#8b949e")
+        self.query_one("#drawer-lbl", Static).update(dt)  # type: ignore[attr-defined]
+
+        visit_label = "Last visit" if self._last_cat_seen else "Last seen"
+        self.query_one("#clean-lbl", Static).update(  # type: ignore[attr-defined]
+            Text(f"{visit_label} {fmt_ago(last_seen)}", style="#484f58")
+        )
+
+        wt_text = Text()
+        if pet_name:
+            wt_text.append(pet_name, style="#8b949e")
+            wt_text.append(" 🐱 ", style="#484f58")
+        else:
+            wt_text.append("cat ", style="#484f58")
+        wt_text.append(weight_val, style="#8b949e")
+        self.query_one("#weight-lbl", Static).update(wt_text)  # type: ignore[attr-defined]
+
+        if drawer >= 85 and self._cat_mode not in ("cleaning", "error"):
+            self._set_cat("full", "drawer full!")  # type: ignore[attr-defined]
+
+    @work(exclusive=True)
+    async def _poll_status_interval(self) -> None:
+        if self._robot is None:
+            return
+        try:
+            await self._robot.refresh()
+            await self._update_last_cat_seen()
+            await self._refresh_status()
+        except Exception:
+            pass

asher/slash-commands/__init__.py

@@ -0,0 +1,26 @@
+"""Slash-command registry — app management commands (prefixed with /).
+
+Convention
+----------
+- Normal commands (no prefix): robot actions — clean, status, lock, etc.
+- Slash commands (/prefix):    app management — /login, /logout, /exit, /reload, …
+- Special cases (no prefix OK): exit, quit — accepted both ways.
+
+Dispatch flow
+-------------
+on_input_submitted  →  raw.startswith("/")  →  _run_slash_cmd()  (CommandsMixin)
+                    →  otherwise            →  _run_cmd()         (CommandsMixin)
+
+Current slash commands (implemented in asher/commands/__init__.py)
+------------------------------------------------------------------
+/login    — show login screen; save credentials to keyring; reconnect
+/logout   — delete credentials from keyring; exit
+/exit     — exit the app
+/help     — show help (also available without slash)
+
+To add a new slash command
+--------------------------
+1. Add a branch in _run_slash_cmd() in asher/commands/__init__.py.
+2. Implement _cmd_<name>() on CommandsMixin.
+3. Add an entry to the slash_cmds list in _show_help().
+"""

asher/ui/__init__.py

@@ -0,0 +1,279 @@
+"""UI layout, CSS, cat panel, and log helpers."""
+
+from __future__ import annotations
+
+from importlib.metadata import PackageNotFoundError
+from importlib.metadata import version as pkg_version
+
+from rich.text import Text
+from textual.app import ComposeResult
+from textual.containers import Container
+from textual.widgets import Input, RichLog, Static
+
+from ..cats import CATS
+from ..helpers import ts
+
+try:
+    VERSION = pkg_version("asher-cli")
+except PackageNotFoundError:
+    VERSION = "dev"
+
+_CSS = """
+Screen {
+    background: #0d1117;
+    color: #c9d1d9;
+}
+
+/* ── Status bar ── */
+#status-bar {
+    background: #161b22;
+    height: 4;
+    border-bottom: solid #30363d;
+    dock: top;
+    padding: 0;
+    layout: vertical;
+}
+
+.srow {
+    height: 2;
+    layout: horizontal;
+    align: left middle;
+    padding: 0 2;
+}
+
+.srow:first-child {
+    border-bottom: solid #30363d;
+}
+
+.sep {
+    color: #30363d;
+    width: auto;
+    height: 1;
+    padding: 0 1;
+}
+
+.chunk {
+    width: auto;
+    padding: 0 2 0 0;
+    height: 1;
+}
+
+/* ── Main ── */
+#main-area {
+    layout: horizontal;
+    height: 1fr;
+}
+
+#log {
+    width: 1fr;
+    height: 1fr;
+    background: #0d1117;
+    padding: 1 2;
+    overflow-x: hidden;
+    scrollbar-background: #161b22;
+    scrollbar-color: #30363d;
+    scrollbar-color-hover: #58a6ff;
+}
+
+/* ── Cat panel ── */
+#cat-panel {
+    width: 30;
+    background: #0d1117;
+    border-left: solid #21262d;
+    align: center middle;
+    padding: 1 2;
+    height: 1fr;
+    layout: vertical;
+}
+
+#cat-art {
+    color: #58a6ff;
+    text-align: left;
+    width: 26;
+    content-align: left middle;
+}
+
+#cat-label {
+    color: #484f58;
+    text-style: italic;
+    text-align: left;
+    width: 26;
+    padding-top: 1;
+    height: 3;
+}
+
+/* ── Input area (outer dock + hint below the box) ── */
+#bottom-dock {
+    dock: bottom;
+    height: 4;
+    background: #161b22;
+    layout: vertical;
+    padding: 0 0 0 0;
+}
+
+#input-bar {
+    background: #161b22;
+    height: 3;
+    border-top: solid #30363d;
+    border-bottom: solid #30363d;
+    layout: vertical;
+    padding: 0 2;
+}
+
+#input-row {
+    layout: horizontal;
+    height: 1;
+    align: left middle;
+}
+
+#prompt {
+    color: #3fb950;
+    width: auto;
+    text-style: bold;
+    padding: 0 1 0 0;
+    height: 1;
+}
+
+#hint-bar {
+    color: #484f58;
+    height: 1;
+    padding: 0 2;
+}
+
+#cmd-input {
+    width: 1fr;
+    background: #161b22;
+    color: #e6edf3;
+    border: none;
+    height: 1;
+    padding: 0;
+}
+
+Input {
+    border: none;
+    background: #161b22;
+    padding: 0;
+}
+"""
+
+
+_SPINNER = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
+
+
+class UIMixin:
+    CSS: str = _CSS
+
+    # declared for type checkers; assigned in AsherApp.__init__
+    _cat_mode: str
+    _cat_frame: int
+    _is_loading: bool
+    _spinner_idx: int
+
+    def compose(self) -> ComposeResult:
+        with Container(id="status-bar"):
+            with Container(classes="srow"):
+                yield Static("", id="title-lbl", classes="chunk")
+                yield Static("", id="robot-lbl", classes="chunk")
+                yield Static("", id="online-lbl", classes="chunk")
+                yield Static("", id="status-lbl", classes="chunk")
+            with Container(classes="srow"):
+                yield Static("", id="drawer-lbl", classes="chunk")
+                yield Static("│", classes="sep")
+                yield Static("", id="weight-lbl", classes="chunk")
+                yield Static("│", classes="sep")
+                yield Static("", id="clean-lbl", classes="chunk")
+
+        with Container(id="main-area"):
+            yield RichLog(id="log", highlight=True, markup=True, wrap=True, min_width=0)
+            with Container(id="cat-panel"):
+                yield Static(CATS["idle"], id="cat-art")  # type: ignore[arg-type]
+                yield Static("idle", id="cat-label")
+
+        with Container(id="bottom-dock"):
+            with Container(id="input-bar"), Container(id="input-row"):
+                yield Static(">", id="prompt")
+                yield Input(placeholder="type a command  (help for list)…", id="cmd-input")
+            yield Static(
+                "help · clean · status · history · /login · /logout · quit",
+                id="hint-bar",
+            )
+
+    def _refresh_title(self) -> None:
+        t = Text()
+        t.append("◆ ", style="bold #58a6ff")
+        t.append("Asher CLI", style="bold #e6edf3")
+        t.append(f" v{VERSION}", style="#484f58")
+        self.query_one("#title-lbl", Static).update(t)  # type: ignore[attr-defined]
+
+    def _show_loading_state(self) -> None:
+        self.query_one("#online-lbl", Static).update(  # type: ignore[attr-defined]
+            Text(f"{_SPINNER[0]} connecting…", style="#484f58")
+        )
+        dash = Text("—", style="#30363d")
+        for wid in ("#robot-lbl", "#status-lbl", "#drawer-lbl", "#weight-lbl", "#clean-lbl"):
+            self.query_one(wid, Static).update(dash)  # type: ignore[attr-defined]
+
+    def _show_welcome(self) -> None:
+        log = self.query_one("#log", RichLog)  # type: ignore[attr-defined]
+        log.write("")
+        log.write(
+            Text.from_markup(" [bold #58a6ff]◆ Asher CLI[/] [#484f58]— Litter Robot Dashboard[/]")
+        )
+        log.write(Text.from_markup(" [#484f58]Connecting to Whisker cloud API…[/]"))
+        log.write(
+            Text.from_markup(
+                " [#484f58]Type [/][#3fb950]help[/][#484f58] to see available commands.[/]"
+            )
+        )
+        log.write(Text.from_markup(" [#21262d]" + "─" * 52 + "[/]"))
+        log.write("")
+
+    def _set_cat(self, mode: str, label: str = "") -> None:
+        self._cat_mode = mode
+        self._cat_frame = 0
+        cats = CATS.get(mode, CATS["idle"])
+        frame = cats[0] if isinstance(cats, list) else cats
+        color = "#f85149" if mode == "error" else "#d29922" if mode == "full" else "#58a6ff"
+        self.query_one("#cat-art", Static).update(Text(frame, style=color))  # type: ignore[attr-defined]
+        self.query_one("#cat-label", Static).update(  # type: ignore[attr-defined]
+            Text(label or mode, style="italic #484f58")
+        )
+
+    def _tick_cat(self) -> None:
+        if self._is_loading:
+            self._spinner_idx = (self._spinner_idx + 1) % len(_SPINNER)
+            self.query_one("#online-lbl", Static).update(  # type: ignore[attr-defined]
+                Text(f"{_SPINNER[self._spinner_idx]} connecting…", style="#484f58")
+            )
+        cats = CATS.get(self._cat_mode, CATS["idle"])
+        if not isinstance(cats, list):
+            return
+        self._cat_frame = (self._cat_frame + 1) % len(cats)
+        frame = cats[self._cat_frame]
+        self.query_one("#cat-art", Static).update(Text(frame, style="#58a6ff"))  # type: ignore[attr-defined]
+
+    def _log_ok(self, msg: str) -> None:
+        t = ts()
+        t.append(f"✓ {msg}", style="#3fb950")
+        self.query_one("#log", RichLog).write(t)  # type: ignore[attr-defined]
+
+    def _log_err(self, msg: str) -> None:
+        t = ts()
+        t.append(f"✖ {msg}", style="#f85149")
+        self.query_one("#log", RichLog).write(t)  # type: ignore[attr-defined]
+
+    def _log_warn(self, msg: str) -> None:
+        t = ts()
+        t.append(f"⚠ {msg}", style="#d29922")
+        self.query_one("#log", RichLog).write(t)  # type: ignore[attr-defined]
+
+    def _log_info(self, msg: str) -> None:
+        t = ts()
+        t.append(f"  {msg}", style="#8b949e")
+        self.query_one("#log", RichLog).write(t)  # type: ignore[attr-defined]
+
+    def action_clear_log(self) -> None:
+        self.query_one("#log", RichLog).clear()  # type: ignore[attr-defined]
+
+    def action_blur_input(self) -> None:
+        self.query_one("#cmd-input", Input).blur()  # type: ignore[attr-defined]