aether-robotics 4.2.0a2__tar.gz → 4.2.0a3__tar.gz

{aether_robotics-4.2.0a2/aether_robotics.egg-info → aether_robotics-4.2.0a3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aether-robotics
-Version: 4.2.0a2
+Version: 4.2.0a3
 Summary: Autonomous multi-agent robotics system with DRL-First Hybrid FDIR
 Author: Chahel Paatur
 License: MIT

aether_robotics-4.2.0a3/VERSION

@@ -0,0 +1 @@
+4.2.0a3

{aether_robotics-4.2.0a2 → aether_robotics-4.2.0a3}/aether/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "4.2.0a2"
+__version__ = "4.2.0a3"
 __author__ = "Chahel Paatur"
 
 # v3.9.6: one-time scrub of any secrets that leaked into experience memory in

{aether_robotics-4.2.0a2 → aether_robotics-4.2.0a3}/aether/app.py

@@ -1719,7 +1719,8 @@ def _summarize_output(output) -> str:
 
 def _execute_objective(objective: str, registry, llm_planner, corrector,
                        parser_obj, manifest, recent_memory,
-                       available, fix_mode: bool = False) -> Dict:
+                       available, fix_mode: bool = False,
+                       on_step=None) -> Dict:
     """Execute a single objective and return structured result.
 
     Used by agent mode (interactive), server mode (HTTP), and `aether --fix`
@@ -1755,6 +1756,20 @@ def _execute_objective(objective: str, registry, llm_planner, corrector,
     if fix_mode:
         print(f"  [agent] planning: {objective}")
 
+    # v4.2.0a3: optional live-progress hook (TUI). Phases: "plan" (full plan
+    # list, once), "start" (before each step), "done" (after each step).
+    # Presentation-only — a hook failure must never affect execution.
+    def _report(phase: str, data: Dict) -> None:
+        if on_step is None:
+            return
+        try:
+            on_step(phase, data)
+        except Exception:
+            pass
+
+    _report("plan", {"plan": plan, "source": plan_source,
+                     "objective": objective})
+
     # Execute plan steps
     step_faults = 0
     prev_output = None
@@ -1767,6 +1782,8 @@ def _execute_objective(objective: str, registry, llm_planner, corrector,
     for i, action in enumerate(plan, 1):
         tool_name = action["tool"]
         params = dict(action.get("params", {}))
+        _report("start", {"index": i, "total": len(plan),
+                          "tool": tool_name, "params": dict(params)})
 
         # Pipe previous output
         pipe_key = action.get("pipe_input")
@@ -1854,6 +1871,7 @@ def _execute_objective(objective: str, registry, llm_planner, corrector,
 
         action_log.append(entry)
         step_outputs.append(str(prev_output) if prev_output else None)
+        _report("done", {"index": i, "total": len(plan), "entry": dict(entry)})
 
         if fix_mode:
             from aether.core import ui
@@ -1976,6 +1994,8 @@ def bootstrap_agent_state_for_fix() -> dict:
         "parser": parser,
         "manifest": manifest,
         "available": registry.available_tools(),
+        # v4.2.0a3: adapter identity for the TUI status bar / boot detail.
+        "adapter_id": _adapter_id,
     }
 
 

{aether_robotics-4.2.0a2 → aether_robotics-4.2.0a3}/aether/tui/app.py

@@ -60,8 +60,8 @@ AETHER_THEME = Theme(
 )
 
 from aether import __version__
-from aether.tui.widgets import (AgentWidget, DoctorWidget, PlaceholderWidget,
-                                WelcomeWidget)
+from aether.tui.widgets import (AgentWidget, DoctorWidget, MascotWidget,
+                                PlaceholderWidget, WelcomeWidget)
 
 # (mode id, sidebar label, phase-1 availability)
 MODES = [
@@ -140,9 +140,11 @@ class AetherApp(App):
     #header-bar { dock: top; height: 1; background: ansi_default;
                   padding: 0 1; }
     #body { height: 1fr; background: ansi_default; }
-    #sidebar { width: 14; background: ansi_default; border: none;
-               padding: 0 1; }
+    #sidebar-col { width: 17; background: ansi_default; }
+    #sidebar { width: 100%; height: 1fr; background: ansi_default;
+               border: none; padding: 0 1; }
     #sidebar ListItem { background: ansi_default; padding: 0 1; }
+    #mascot { dock: bottom; }
     #main-switcher { width: 1fr; border: none; background: ansi_default;
                      padding: 0 1; }
     #status-bar { height: 1; background: ansi_default;
@@ -170,10 +172,12 @@ class AetherApp(App):
     def compose(self) -> ComposeResult:
         yield Static(id="header-bar")
         with Horizontal(id="body"):
-            yield ListView(
-                *[ListItem(Label(label), id=f"nav-{mode_id}")
-                  for mode_id, label, _ in MODES],
-                id="sidebar")
+            with Vertical(id="sidebar-col"):
+                yield ListView(
+                    *[ListItem(Label(label), id=f"nav-{mode_id}")
+                      for mode_id, label, _ in MODES],
+                    id="sidebar")
+                yield MascotWidget(id="mascot")
             with ContentSwitcher(initial="welcome", id="main-switcher"):
                 yield WelcomeWidget(id="welcome")
                 yield AgentWidget(id="agent")
@@ -266,8 +270,14 @@ class AetherApp(App):
                 return
         except Exception:
             pass
+        # Single-adapter path (load_tier1 doesn't fill the active list).
+        adapter_id = state.get("adapter_id")
         n = len(state.get("available", []))
-        self.adapters_line = f"registry ready ({n} tools)"
+        if adapter_id:
+            self.adapters_line = f"{adapter_id} (primary) · {n} tools"
+            self.adapter_count = 1
+        else:
+            self.adapters_line = f"registry ready ({n} tools)"
 
     # ── mode switching ─────────────────────────────────────────────────
     def activate_mode(self, mode_id: str) -> None:

{aether_robotics-4.2.0a2 → aether_robotics-4.2.0a3}/aether/tui/widgets/__init__.py

@@ -5,7 +5,8 @@ render a PlaceholderWidget until phase 2/3.
 """
 from aether.tui.widgets.agent import AgentWidget
 from aether.tui.widgets.doctor import DoctorWidget
-from aether.tui.widgets.common import PlaceholderWidget, WelcomeWidget
+from aether.tui.widgets.common import (MascotWidget, PlaceholderWidget,
+                                       WelcomeWidget)
 
-__all__ = ["AgentWidget", "DoctorWidget", "PlaceholderWidget",
-           "WelcomeWidget"]
+__all__ = ["AgentWidget", "DoctorWidget", "MascotWidget",
+           "PlaceholderWidget", "WelcomeWidget"]

aether_robotics-4.2.0a3/aether/tui/widgets/agent.py

@@ -0,0 +1,297 @@
+"""Agent mode widget: objective input + live plan progress (v4.2.0a3).
+
+Dispatches through the exact same pipeline as the classic REPL:
+bootstrap_agent_state_for_fix() builds the registry/planner once (in a
+thread worker, since it touches hardware), then each objective runs through
+aether.app._execute_objective — the function agent/server/--fix already
+share. The optional on_step hook it now exposes drives a Claude Code-style
+live step list: ○ pending, spinner while running, ● green/red with the
+step's wall-clock seconds when finished. Only presentation; execution is
+untouched (DO NOT CHANGE contract).
+"""
+from typing import Callable, List, Optional
+
+from aether.tui import AETHER_ORANGE
+
+from textual import work
+from textual.app import ComposeResult
+from textual.containers import Vertical
+from textual.widgets import Input, RichLog, Static
+
+_SLASH_PREFIX = "/"
+_SPINNER = "⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏"
+
+
+def _params_str(params: dict) -> str:
+    return ", ".join(f"{k}={v!r}" for k, v in (params or {}).items())
+
+
+class AgentWidget(Vertical):
+    """Objective REPL rendered as a TUI pane."""
+
+    DEFAULT_CSS = """
+    AgentWidget { background: ansi_default; }
+    AgentWidget #agent-log { height: 1fr; border: none;
+                             background: ansi_default; padding: 0 1; }
+    AgentWidget #agent-live { height: auto; background: ansi_default;
+                              padding: 0 2; display: none; }
+    AgentWidget #agent-input { border: round $primary 50%;
+                               background: ansi_default; padding: 0 1; }
+    AgentWidget #agent-input:focus { border: round $primary; }
+    """
+
+    def __init__(self, bootstrap_fn: Optional[Callable] = None,
+                 execute_fn: Optional[Callable] = None, **kwargs) -> None:
+        """bootstrap_fn/execute_fn are injectable for tests; the defaults are
+        the production agent pipeline. An injected execute_fn may accept
+        (objective, state) or (objective, state, on_step)."""
+        super().__init__(**kwargs)
+        self._bootstrap_fn = bootstrap_fn
+        self._execute_fn = execute_fn
+        self._agent_state: Optional[dict] = None
+        # Live-run state (UI thread only)
+        self._steps: List[dict] = []
+        self._plan_source = ""
+        self._spin = 0
+
+    # -- layout --
+    def compose(self) -> ComposeResult:
+        yield RichLog(id="agent-log", markup=True, wrap=True)
+        yield Static(id="agent-live")
+        yield Input(placeholder="objective>  (or / for commands)",
+                    id="agent-input")
+
+    def on_mount(self) -> None:
+        log = self.query_one("#agent-log", RichLog)
+        log.write("[bold]AETHER Agent[/bold]")
+        log.write("[dim]Type an objective in plain English. "
+                  "First objective boots the hardware registry.[/dim]")
+        self.set_interval(0.12, self._animate)
+
+    def focus_input(self) -> None:
+        self.query_one("#agent-input", Input).focus()
+
+    # -- input handling --
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        text = event.value.strip()
+        event.input.value = ""
+        if not text:
+            return
+        if text.startswith(_SLASH_PREFIX):
+            self.app.run_slash_command(text)
+            return
+        self._log(f"\n[bold {AETHER_ORANGE}]objective>"
+                  f"[/bold {AETHER_ORANGE}] {text}")
+        self.run_objective(text)
+
+    # -- objective pipeline (thread worker: hardware + LLM latency) --
+    @work(thread=True, exclusive=True, group="agent-objective")
+    def run_objective(self, objective: str) -> None:
+        app = self.app
+        try:
+            state = self._ensure_agent_state()
+            app.call_from_thread(app.set_busy,
+                                 "planning objective with Claude...")
+            app.call_from_thread(self._live_planning)
+
+            def on_step(phase: str, data: dict) -> None:
+                app.call_from_thread(self._on_step_ui, phase, data)
+
+            execute = self._execute_fn or self._default_execute
+            try:
+                result = execute(objective, state, on_step)
+            except TypeError:
+                result = execute(objective, state)  # legacy 2-arg fake
+            app.call_from_thread(self._render_result, result)
+            app.call_from_thread(app.count_action)
+        except Exception as e:  # noqa: BLE001 — surface, never crash the TUI
+            app.call_from_thread(
+                self._log, f"  [red]\\[FAIL][/red] {type(e).__name__}: {e}")
+            app.call_from_thread(self._live_clear)
+        finally:
+            app.call_from_thread(app.set_busy, "")
+
+    def _ensure_agent_state(self) -> dict:
+        if self._agent_state is None:
+            app = self.app
+            app.call_from_thread(app.set_busy, "booting hardware registry...")
+            app.call_from_thread(
+                self._log, "[dim]Discovering hardware + adapters...[/dim]")
+            bootstrap = self._bootstrap_fn or self._default_bootstrap
+            self._agent_state = bootstrap()
+            app.call_from_thread(app.on_agent_state_ready, self._agent_state)
+            for line in _adapter_detail_lines(self._agent_state):
+                app.call_from_thread(self._log, line)
+        return self._agent_state
+
+    @staticmethod
+    def _default_bootstrap() -> dict:
+        from aether.app import bootstrap_agent_state_for_fix
+        return bootstrap_agent_state_for_fix()
+
+    @staticmethod
+    def _default_execute(objective: str, state: dict, on_step=None) -> dict:
+        from aether.app import _execute_objective
+        return _execute_objective(
+            objective, state["registry"], state["planner"],
+            state["corrector"], state["parser"], state["manifest"],
+            recent_memory=[], available=state["available"], on_step=on_step)
+
+    # -- live plan panel (all methods below run on the UI thread) --
+    def _live(self) -> Static:
+        return self.query_one("#agent-live", Static)
+
+    def _live_planning(self) -> None:
+        self._steps = []
+        self._plan_source = ""
+        live = self._live()
+        live.styles.display = "block"
+        self._render_live()
+
+    def _live_clear(self) -> None:
+        self._steps = []
+        live = self._live()
+        live.update("")
+        live.styles.display = "none"
+
+    def _on_step_ui(self, phase: str, data: dict) -> None:
+        if phase == "plan":
+            self._plan_source = data.get("source", "?")
+            self._steps = [
+                {"tool": a.get("tool", "?"),
+                 "params": dict(a.get("params", {})),
+                 "status": "pending", "secs": None, "error": ""}
+                for a in data.get("plan", [])]
+        elif phase == "start" and self._steps:
+            i = data.get("index", 1) - 1
+            if 0 <= i < len(self._steps):
+                self._steps[i]["status"] = "running"
+        elif phase == "done" and self._steps:
+            i = data.get("index", 1) - 1
+            entry = data.get("entry", {})
+            if 0 <= i < len(self._steps):
+                step = self._steps[i]
+                step["status"] = "done" if entry.get("success") else "failed"
+                step["secs"] = entry.get("duration_ms", 0) / 1000.0
+                step["error"] = entry.get("error", "")
+        self._render_live()
+
+    def _animate(self) -> None:
+        if any(s["status"] == "running" for s in self._steps) or (
+                self._live().styles.display == "block" and not self._steps):
+            self._spin = (self._spin + 1) % len(_SPINNER)
+            self._render_live()
+
+    def _step_line(self, step: dict) -> str:
+        call = f"{step['tool']}({_params_str(step['params'])})"
+        status = step["status"]
+        if status == "pending":
+            return f"  [dim]○ {call}[/dim]"
+        if status == "running":
+            frame = _SPINNER[self._spin]
+            return (f"  [{AETHER_ORANGE}]{frame}[/{AETHER_ORANGE}] {call} "
+                    f"[dim]running...[/dim]")
+        secs = f" [dim]({step['secs']:.1f}s)[/dim]" if step["secs"] is not None \
+            else ""
+        if status == "done":
+            return f"  [green]●[/green] {call}{secs}"
+        return (f"  [red]●[/red] {call}{secs} "
+                f"[red]{step.get('error', '')}[/red]")
+
+    def _render_live(self) -> None:
+        if not self._steps:
+            frame = _SPINNER[self._spin]
+            self._live().update(
+                f"[{AETHER_ORANGE}]{frame}[/{AETHER_ORANGE}] "
+                f"[dim]planning objective with Claude...[/dim]")
+            return
+        done = sum(1 for s in self._steps if s["status"] in ("done", "failed"))
+        header = (f"[{AETHER_ORANGE}]\\[PLAN][/{AETHER_ORANGE}] "
+                  f"{self._plan_source} · {len(self._steps)} step(s) · "
+                  f"[dim]{done}/{len(self._steps)} complete[/dim]")
+        self._live().update(
+            "\n".join([header] + [self._step_line(s) for s in self._steps]))
+
+    # -- final render into scrollback --
+    def _log(self, line: str) -> None:
+        self.query_one("#agent-log", RichLog).write(line)
+
+    def _render_result(self, result: dict) -> None:
+        if self._steps:
+            # Rich path: persist the live step list (with dots + seconds).
+            done = sum(1 for s in self._steps if s["status"] == "done")
+            self._log(f"  [{AETHER_ORANGE}]\\[PLAN][/{AETHER_ORANGE}] "
+                      f"{self._plan_source} · {len(self._steps)} step(s)")
+            total_s = 0.0
+            for step in self._steps:
+                self._log(self._step_line(step))
+                total_s += step["secs"] or 0.0
+            summary = f"{done}/{len(self._steps)} steps · {total_s:.1f}s total"
+        else:
+            # Legacy path (no on_step data): render from the result dict.
+            actions = result.get("actions", [])
+            self._log(f"  [{AETHER_ORANGE}]\\[PLAN][/{AETHER_ORANGE}] "
+                      f"{result.get('plan_source', '?')} plan · "
+                      f"{len(actions)} step(s)")
+            for entry in actions:
+                self._log(f"  [{AETHER_ORANGE}]\\[EXEC][/{AETHER_ORANGE}] "
+                          f"{entry.get('tool', '?')}")
+                if entry.get("success"):
+                    self._log(f"  [green]\\[OK][/green] success "
+                              f"({entry.get('duration_ms', 0):.0f}ms)")
+                else:
+                    self._log(f"  [red]\\[FAIL][/red] {entry.get('error', '')}")
+            summary = f"{len(actions)} step(s)"
+        status = result.get("status", "?")
+        color = "green" if status in ("ok", "success", "SUCCESS",
+                                      "completed") else "yellow"
+        self._log(f"  [{color}]status: {status}[/{color}] [dim]· {summary}[/dim]")
+        self._live_clear()
+
+    def clear_log(self) -> None:
+        self.query_one("#agent-log", RichLog).clear()
+
+
+def _adapter_detail_lines(state: dict) -> List[str]:
+    """Boot-time adapter detail for the log: name, role, tool count,
+    address, GPIO pins. Best effort — never raises."""
+    lines: List[str] = []
+    try:
+        from aether.adapters import (get_active_adapters, get_adapter_gpio_pins,
+                                     get_last_detected, get_primary_adapter,
+                                     get_tool_origin)
+        active = get_active_adapters()
+        addr_of = {d["adapter"]: d.get("address") for d in get_last_detected()}
+        if active:
+            primary = get_primary_adapter()
+            counts: dict = {}
+            for _tool, adp in get_tool_origin().items():
+                counts[adp] = counts.get(adp, 0) + 1
+            for name in active:
+                lines.append(_adapter_line(
+                    name, name == primary, counts.get(name, 0),
+                    addr_of.get(name), get_adapter_gpio_pins(name)))
+            return lines
+        adapter_id = state.get("adapter_id")
+        if adapter_id:
+            tools = len(state.get("manifest", {}).get("adapter_tools", []))
+            lines.append(_adapter_line(
+                adapter_id, True, tools, addr_of.get(adapter_id),
+                get_adapter_gpio_pins(adapter_id)))
+            return lines
+    except Exception:
+        pass
+    if not lines:
+        lines.append(f"[dim]● registry ready "
+                     f"({len(state.get('available', []))} tools)[/dim]")
+    return lines
+
+
+def _adapter_line(name: str, primary: bool, tools: int, address,
+                  gpio_pins) -> str:
+    role = ("[green]primary[/green]" if primary
+            else f"[{AETHER_ORANGE}]namespaced[/{AETHER_ORANGE}]")
+    gpio = ", ".join(str(p) for p in (gpio_pins or [])) or "none (I2C only)"
+    addr = address or "vendor lib"
+    return (f"[green]●[/green] [bold]{name}[/bold] — {role} · "
+            f"{tools} tools · addr {addr} · [dim]GPIO {gpio}[/dim]")

{aether_robotics-4.2.0a2 → aether_robotics-4.2.0a3}/aether/tui/widgets/common.py

@@ -1,9 +1,32 @@
-"""Shared TUI widgets: first-run welcome screen and phase-2 placeholders."""
+"""Shared TUI widgets: mascot mark, first-run welcome, phase-2 placeholders."""
 from textual.app import ComposeResult
 from textual.containers import Horizontal, Vertical
 from textual.widgets import Button, Static
 
 from aether import __version__
+from aether.tui import AETHER_ORANGE
+
+# Compact rendition of the AETHER banner mascot (the robot face) for the
+# bottom-left corner of the TUI.
+_MASCOT_ART = (
+    f"[{AETHER_ORANGE}]▄████▄ ▄████▄[/{AETHER_ORANGE}]\n"
+    f"[{AETHER_ORANGE}]█████████████[/{AETHER_ORANGE}]\n"
+    f"[dim]█▀▀[/dim][{AETHER_ORANGE}]███████[/{AETHER_ORANGE}][dim]▀▀█[/dim]\n"
+    f"[{AETHER_ORANGE}]▀████▀ ▀████▀[/{AETHER_ORANGE}]\n"
+    f"[dim] ━━ AETHER ━━[/dim]"
+)
+
+
+class MascotWidget(Static):
+    """The AETHER robot face, parked bottom-left under the sidebar."""
+
+    DEFAULT_CSS = """
+    MascotWidget { height: 5; background: ansi_default; padding: 0 1;
+                   color: $primary; }
+    """
+
+    def __init__(self, **kwargs) -> None:
+        super().__init__(_MASCOT_ART, **kwargs)
 
 
 class WelcomeWidget(Vertical):

{aether_robotics-4.2.0a2 → aether_robotics-4.2.0a3/aether_robotics.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aether-robotics
-Version: 4.2.0a2
+Version: 4.2.0a3
 Summary: Autonomous multi-agent robotics system with DRL-First Hybrid FDIR
 Author: Chahel Paatur
 License: MIT

{aether_robotics-4.2.0a2 → aether_robotics-4.2.0a3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "aether-robotics"
-version = "4.2.0a2"
+version = "4.2.0a3"
 description = "Autonomous multi-agent robotics system with DRL-First Hybrid FDIR"
 readme = "README.md"
 license = {text = "MIT"}