aether-robotics 5.2.1__tar.gz → 5.2.2__tar.gz

{aether_robotics-5.2.1/aether_robotics.egg-info → aether_robotics-5.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aether-robotics
-Version: 5.2.1
+Version: 5.2.2
 Summary: Autonomous multi-agent robotics system with DRL-First Hybrid FDIR
 Author: Chahel Paatur
 License: MIT
@@ -144,6 +144,24 @@ Full engineering detail, including the algorithms and where they came from: [doc
 
 ## What's New
 
+### v5.2.2 — Boot is the latency now, so boot got measured
+
+With planning cached at 0 ms and `get_distance` at 6 ms, the remaining ~5 s was boot — running before every objective, and entirely unmeasured. Instrumented first:
+
+| phase | ms (macOS dev machine) |
+|---|---|
+| hardware_probe | 1485 |
+| software_probe | 942 |
+| camera_probe (nested) | 828 |
+| i2c_scan | 0.1 |
+
+`[BOOT] hardware_probe 1485ms · software_probe 942ms · … · total 2449ms` prints under `AETHER_VERBOSE=1`, and `boot_latency {phase, ms}` is emitted always — the point is the distribution across real installs, not just machines being debugged.
+
+- **Cached hardware profile.** If the fingerprint is unchanged, the entire probe sweep is skipped: **3016 ms → 1 ms**. The fingerprint deliberately includes the I2C address scan (~340 ms on a Pi), not just device-node presence — swapping a PiCar-X HAT for a GoPiGo3 leaves `/dev/i2c-1` identical, and a fast boot onto the wrong adapter is not a win. Prints `[DISCOVERY] Using cached hardware profile (fingerprint match)`; invalidated by a hardware change or `aether doctor`.
+- **One-shot mode:** `aether --mode agent --objective "what's the distance in front of you"` runs one objective and exits, skipping readline and the feedback prompt.
+- **Input bar.** v5.2.1 printed a leading newline unconditionally, which put a blank row *inside* the panel after Enter — the reported symptom. It's now only printed when the cursor is genuinely mid-line (Ctrl-C, or teardown closing the box from a signal handler), plus a reserved row above and a blank line after the closing border so the panel renders fully on an 80×24.
+- **Subcommands look like the rest of the program.** `doctor` renders section panels with a coloured `13 passing · 4 warnings · 0 failures` summary; bare `aether kits` lists the kits instead of dumping argparse usage (`--help` still does). Four "KEY not set" provider warnings collapse into one line — they were never four problems. Non-TTY output stays byte-identical.
+
 ### v5.2.1 — Plan cache tuning, measured against the pairs that must not match
 
 A one-word difference (`"infront"` → `"in front"`) missed the cache and cost a fresh ~2.7 s planning call. Objectives are now **normalised before embedding** — lowercased, punctuation stripped, whitespace collapsed — so `"What's the distance?"` and `"whats the distance"` embed identically (measured 0.934 → 1.000).

{aether_robotics-5.2.1 → aether_robotics-5.2.2}/README.md

@@ -96,6 +96,24 @@ Full engineering detail, including the algorithms and where they came from: [doc
 
 ## What's New
 
+### v5.2.2 — Boot is the latency now, so boot got measured
+
+With planning cached at 0 ms and `get_distance` at 6 ms, the remaining ~5 s was boot — running before every objective, and entirely unmeasured. Instrumented first:
+
+| phase | ms (macOS dev machine) |
+|---|---|
+| hardware_probe | 1485 |
+| software_probe | 942 |
+| camera_probe (nested) | 828 |
+| i2c_scan | 0.1 |
+
+`[BOOT] hardware_probe 1485ms · software_probe 942ms · … · total 2449ms` prints under `AETHER_VERBOSE=1`, and `boot_latency {phase, ms}` is emitted always — the point is the distribution across real installs, not just machines being debugged.
+
+- **Cached hardware profile.** If the fingerprint is unchanged, the entire probe sweep is skipped: **3016 ms → 1 ms**. The fingerprint deliberately includes the I2C address scan (~340 ms on a Pi), not just device-node presence — swapping a PiCar-X HAT for a GoPiGo3 leaves `/dev/i2c-1` identical, and a fast boot onto the wrong adapter is not a win. Prints `[DISCOVERY] Using cached hardware profile (fingerprint match)`; invalidated by a hardware change or `aether doctor`.
+- **One-shot mode:** `aether --mode agent --objective "what's the distance in front of you"` runs one objective and exits, skipping readline and the feedback prompt.
+- **Input bar.** v5.2.1 printed a leading newline unconditionally, which put a blank row *inside* the panel after Enter — the reported symptom. It's now only printed when the cursor is genuinely mid-line (Ctrl-C, or teardown closing the box from a signal handler), plus a reserved row above and a blank line after the closing border so the panel renders fully on an 80×24.
+- **Subcommands look like the rest of the program.** `doctor` renders section panels with a coloured `13 passing · 4 warnings · 0 failures` summary; bare `aether kits` lists the kits instead of dumping argparse usage (`--help` still does). Four "KEY not set" provider warnings collapse into one line — they were never four problems. Non-TTY output stays byte-identical.
+
 ### v5.2.1 — Plan cache tuning, measured against the pairs that must not match
 
 A one-word difference (`"infront"` → `"in front"`) missed the cache and cost a fresh ~2.7 s planning call. Objectives are now **normalised before embedding** — lowercased, punctuation stripped, whitespace collapsed — so `"What's the distance?"` and `"whats the distance"` embed identically (measured 0.934 → 1.000).

aether_robotics-5.2.2/VERSION

@@ -0,0 +1 @@
+5.2.2

{aether_robotics-5.2.1 → aether_robotics-5.2.2}/aether/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "5.2.1"
+__version__ = "5.2.2"
 __author__ = "Chahel Paatur"
 
 #: Where users should actually be sent. v5.1.2: the GitHub repository is

{aether_robotics-5.2.1 → aether_robotics-5.2.2}/aether/app.py

@@ -947,6 +947,7 @@ def run_agent(args) -> None:
     updater.run(auto_update=auto_update, no_update=no_update)
 
     # ── Step 4: Capability Discovery ──────────────────────────────────
+    from aether.core import boot_timer
     discovery = ToolDiscovery()
     discovery.discover()
     # v5.1.1 UI 1: the ~70-line inventory is a debugging surface, not a boot
@@ -1309,9 +1310,23 @@ def run_agent(args) -> None:
     faults_detected = 0
     total_actions = 0
 
+    from aether.core import boot_timer as _boot_timer
     from aether.core import ui as _ui
-    _ui.enable_readline()     # v5.1.1 UI 2: history + line editing
     _mark_boot_finished()     # v5.1.2 FIX 5: [TOOLS]/[MEM] etc. are live now
+    _boot_timer.report()
+
+    # v5.2.2 (FIX 1 step 3): one-shot mode for scripted use. Deliberately
+    # BEFORE readline setup and before the feedback prompt — a scripted
+    # invocation must not touch shell history or block waiting on input.
+    _one_shot = (getattr(args, "objective", "") or "").strip()
+    if _one_shot:
+        _execute_objective(_one_shot, registry, llm_planner, corrector,
+                           parser, manifest, _load_agent_memory(5),
+                           available)
+        _feedback.session_ended()
+        return
+
+    _ui.enable_readline()     # v5.1.1 UI 2: history + line editing
 
     while True:
         try:
@@ -2948,6 +2963,10 @@ def main():
                              "autonomous = high-level goal decomposed into "
                              "self-directed sub-tasks (v4.0.0)")
     # ── v5.2.0 security: capabilities are OFF unless asked for ────────
+    parser.add_argument("--objective", type=str, default="",
+                        help="Run a single objective and exit (scripted use). "
+                             "With a warm boot and a cache hit this is "
+                             "sub-second end to end.")
     parser.add_argument("--allow-shell", action="store_true",
                         dest="allow_shell",
                         help="Allow the LLM to run shell commands "

{aether_robotics-5.2.1 → aether_robotics-5.2.2}/aether/cli/doctor.py

@@ -288,6 +288,14 @@ def check_api_key() -> Group:
     # persisted detection so this reflects reality, not a cached boot.
     if not os.environ.get("AETHER_DOCTOR_NO_PROBE"):
         forget_detection()
+        # v5.2.2: doctor is the explicit revalidation surface, so the cached
+        # hardware profile is dropped too — otherwise "run doctor" would
+        # report on a profile from a previous boot.
+        try:
+            from aether.core import discovery_cache
+            discovery_cache.invalidate()
+        except Exception:
+            pass
     probing = not os.environ.get("AETHER_DOCTOR_NO_PROBE")
     results: List[Result] = []
     verified_any = False
@@ -621,6 +629,28 @@ _CHECK_FNS = [
 ]
 
 
+#: Providers whose absence is a configuration choice, not a fault.
+_NOT_SET_MARKER = "not set ("
+
+
+def _collapse_provider_warnings(title, results):
+    """Fold N unconfigured-provider warnings into one actionable line."""
+    if title != "LLM Providers":
+        return results
+    kept, unset = [], []
+    for status, msg in results:
+        if status == WARN and _NOT_SET_MARKER in msg:
+            unset.append(msg.split()[0])
+            continue
+        kept.append((status, msg))
+    if len(unset) > 1:
+        kept.insert(0, (INFO, f"{len(unset)} providers not configured "
+                              f"({', '.join(unset)}) — any one is enough"))
+    elif unset:
+        kept.insert(0, (WARN, f"{unset[0]} not configured"))
+    return kept
+
+
 def run_doctor(argv=None) -> int:
     """Run every check group, print the report, and return an exit code
     (0 if no failures, 1 if any check FAILed)."""
@@ -634,21 +664,23 @@ def run_doctor(argv=None) -> int:
         except Exception as e:  # noqa: BLE001 — a check must never crash doctor
             groups.append((fn.__name__, [(FAIL, f"check crashed: {e}")]))
 
-    print("AETHER doctor — diagnostic report\n")
+    from aether.core import ui
+
+    # v5.2.2 (FIX 3): four "KEY not set" provider warnings are ONE decision,
+    # not four problems. Collapsing them stops the summary reading 4 warnings
+    # when the user simply has not configured three optional providers.
+    groups = [(title, _collapse_provider_warnings(title, results))
+              for title, results in groups]
+
     n_pass = n_warn = n_fail = 0
-    for title, results in groups:
-        print(f"  {title}")
-        for status, msg in results:
-            print(f"    {_SYMBOL.get(status, ' ')} {msg}")
-            if status == PASS:
-                n_pass += 1
-            elif status == WARN:
-                n_warn += 1
-            elif status == FAIL:
-                n_fail += 1
-        print()
-
-    print(f"  Summary: {n_pass} passing, {n_warn} warning(s), {n_fail} failure(s)")
+    for _title, results in groups:
+        for status, _msg in results:
+            n_pass += status == PASS
+            n_warn += status == WARN
+            n_fail += status == FAIL
     code = 1 if n_fail else 0
+
+    ui.print_check_report("AETHER doctor", groups, _SYMBOL,
+                          {"pass": n_pass, "warn": n_warn, "fail": n_fail})
     print(f"  Exit code: {code}")
     return code

{aether_robotics-5.2.1 → aether_robotics-5.2.2}/aether/cli/kits.py

@@ -320,5 +320,7 @@ def run_kits(argv=None) -> int:
         return info_kit(args.name)
     if args.action == "install":
         return install_kit(args.name)
-    parser.print_help()
-    return 1
+    # v5.2.2 (FIX 3): a bare `aether kits` lists the kits, which is what
+    # someone typing it wants. Raw argparse usage read as a different, older
+    # program than the rest of the CLI. `--help` still prints the usage.
+    return list_kits()

aether_robotics-5.2.2/aether/core/boot_timer.py

@@ -0,0 +1,98 @@
+"""Per-phase boot timing (v5.2.2 FIX 1, step 1).
+
+The plan cache made planning free (0 ms) and get_distance runs in 6 ms, yet
+perceived latency is ~5 s — because boot runs before every objective. Which
+phase costs what was a guess, and optimising a guess is how you spend a day
+speeding up something that was never the problem.
+
+This measures. It is deliberately the first thing built for v5.2.2, and the
+numbers it produced are what selected the optimisations that followed.
+
+Zero cost when idle: a monotonic subtraction and a dict append per phase.
+"""
+import os
+import time
+from contextlib import contextmanager
+from typing import Dict, List
+
+_phases: List[Dict] = []
+_enabled = True
+
+
+def reset() -> None:
+    _phases.clear()
+
+
+def disable() -> None:
+    """Used by tests and by paths where timing output would be noise."""
+    global _enabled
+    _enabled = False
+
+
+def enable() -> None:
+    global _enabled
+    _enabled = True
+
+
+@contextmanager
+def phase(name: str):
+    """Time a named boot phase. Never swallows the body's exception."""
+    if not _enabled:
+        yield
+        return
+    start = time.perf_counter()
+    try:
+        yield
+    finally:
+        elapsed = (time.perf_counter() - start) * 1000.0
+        _phases.append({"phase": name, "ms": round(elapsed, 1)})
+
+
+def record(name: str, ms: float) -> None:
+    """Record a phase measured by the caller (e.g. an async warm-up)."""
+    if _enabled:
+        _phases.append({"phase": name, "ms": round(float(ms), 1)})
+
+
+def phases() -> List[Dict]:
+    return list(_phases)
+
+
+def total_ms() -> float:
+    return round(sum(p["ms"] for p in _phases), 1)
+
+
+def summary_line(limit: int = 6) -> str:
+    """`i2c_scan 340ms · mavlink_probe 3100ms · ... · total 4810ms`.
+
+    Slowest first: the point of the line is to name the phase worth fixing,
+    and boot order is not interesting once you already have the total.
+    """
+    if not _phases:
+        return ""
+    ranked = sorted(_phases, key=lambda p: -p["ms"])[:limit]
+    parts = [f"{p['phase']} {p['ms']:.0f}ms" for p in ranked]
+    return " · ".join(parts) + f" · total {total_ms():.0f}ms"
+
+
+def report() -> None:
+    """Print the summary under AETHER_VERBOSE=1 and always emit analytics.
+
+    The line is verbose-only because it is diagnostic detail, but the events
+    are unconditional — the whole point is to learn the real distribution
+    across installs rather than only on machines being debugged.
+    """
+    if not _phases:
+        return
+    try:
+        if os.environ.get("AETHER_VERBOSE"):
+            print(f"  [BOOT] {summary_line()}")
+    except Exception:
+        pass
+    try:
+        from aether.core.analytics import track
+        for entry in _phases:
+            track("boot_latency", {"phase": entry["phase"], "ms": entry["ms"]})
+        track("boot_latency", {"phase": "total", "ms": total_ms()})
+    except Exception:
+        pass

aether_robotics-5.2.2/aether/core/discovery_cache.py

@@ -0,0 +1,148 @@
+"""Cached hardware profile keyed on a physical fingerprint (v5.2.2 FIX 1).
+
+Boot dominates perceived latency now that planning is cached. Measured phases:
+camera probe ~830 ms, software probe ~940 ms, and on a Pi the MAVLink scan
+costs ~3.1 s because `serial.Serial(port, 57600, timeout=2)` blocks for two
+seconds per candidate port and has never once succeeded on that hardware.
+
+None of it changes between boots unless the hardware changes. So: fingerprint
+the hardware cheaply, and if the fingerprint matches, reuse the whole manifest.
+
+WHY THE FINGERPRINT INCLUDES THE I2C ADDRESS SCAN
+--------------------------------------------------
+The tempting fingerprint is device-node presence alone — pure filesystem stat,
+microseconds. It is also wrong in a way that matters: swapping a PiCar-X HAT
+for a GoPiGo3 leaves /dev/i2c-1 exactly as it was, so a node-only fingerprint
+would match and AETHER would load the previous robot's adapter and send its
+motor commands to different hardware.
+
+The I2C ACK scan is ~340 ms on a Pi. Paying that to be certain which robot is
+attached, while skipping ~4.4 s of everything else, is the right trade — a fast
+boot that drives the wrong motors is not a win.
+"""
+import glob
+import hashlib
+import json
+import os
+import time
+from typing import Dict, Optional
+
+_PATH = os.path.join(os.path.expanduser("~"), ".aether", "hardware_profile.json")
+
+#: A profile older than this is re-probed regardless of fingerprint. Guards
+#: against drift we cannot see (firmware, permissions, a library upgrade).
+MAX_AGE_S = 7 * 24 * 3600
+
+#: Device-node globs that change when hardware is plugged or unplugged.
+_NODE_GLOBS = ("/dev/i2c-*", "/dev/spidev*", "/dev/ttyUSB*", "/dev/ttyACM*",
+               "/dev/video*", "/dev/serial0", "/dev/gpiomem")
+
+
+def disabled() -> bool:
+    return bool(os.environ.get("AETHER_NO_DISCOVERY_CACHE"))
+
+
+def _device_nodes() -> list:
+    nodes = []
+    for pattern in _NODE_GLOBS:
+        try:
+            nodes.extend(glob.glob(pattern))
+        except Exception:
+            continue
+    return sorted(set(nodes))
+
+
+def _i2c_addresses() -> list:
+    """ACK-scan bus 1. Identifies WHICH board is attached, not just that one is.
+
+    Returns [] when smbus2 is absent or the bus cannot be opened, which is the
+    same value a genuinely empty bus produces — acceptable, because in both
+    cases there is no I2C hardware to misidentify.
+    """
+    try:
+        import smbus2
+    except Exception:
+        return []
+    try:
+        bus = smbus2.SMBus(1)
+    except Exception:
+        return []
+    found = []
+    try:
+        for address in range(0x03, 0x78):
+            try:
+                bus.read_byte(address)
+                found.append(address)
+            except OSError:
+                pass
+    except Exception:
+        return []
+    finally:
+        try:
+            bus.close()
+        except Exception:
+            pass
+    return found
+
+
+def fingerprint() -> str:
+    """Stable hash of what is physically attached."""
+    import platform
+    import sys
+
+    try:
+        from aether import __version__ as version
+    except Exception:
+        version = "?"
+    parts = [
+        platform.system(), platform.machine(),
+        f"py{sys.version_info.major}.{sys.version_info.minor}",
+        f"aether{version}",              # a new release may probe differently
+        ",".join(_device_nodes()),
+        ",".join(hex(a) for a in _i2c_addresses()),
+    ]
+    return hashlib.sha256("\n".join(parts).encode()).hexdigest()[:32]
+
+
+def load(current: Optional[str] = None) -> Optional[Dict]:
+    """The cached manifest when the fingerprint still matches, else None."""
+    if disabled():
+        return None
+    try:
+        with open(_PATH) as handle:
+            payload = json.load(handle)
+    except Exception:
+        return None
+    if not isinstance(payload, dict):
+        return None
+    if time.time() - float(payload.get("ts", 0)) > MAX_AGE_S:
+        return None
+    expected = current if current is not None else fingerprint()
+    if payload.get("fingerprint") != expected:
+        return None
+    manifest = payload.get("manifest")
+    return manifest if isinstance(manifest, dict) else None
+
+
+def save(manifest: Dict, current: Optional[str] = None) -> None:
+    """Persist a freshly-probed manifest. Never raises."""
+    if disabled() or not isinstance(manifest, dict):
+        return
+    try:
+        os.makedirs(os.path.dirname(_PATH), exist_ok=True)
+        tmp = _PATH + ".tmp"
+        with open(tmp, "w") as handle:
+            json.dump({"fingerprint": current or fingerprint(),
+                       "ts": time.time(), "manifest": manifest}, handle)
+        os.replace(tmp, _PATH)
+        os.chmod(_PATH, 0o600)
+    except Exception:
+        pass
+
+
+def invalidate() -> None:
+    """Force a full re-probe. Called by `aether doctor`."""
+    try:
+        os.remove(_PATH)
+    except Exception:
+        pass

{aether_robotics-5.2.1 → aether_robotics-5.2.2}/aether/core/tool_discovery.py

@@ -37,6 +37,12 @@ def _probe_camera_cv2() -> Tuple[bool, Dict]:
     busy, which is the normal case while probing. Opening the capture is what
     talks, so the suppression wraps the probe rather than the import.
     """
+    from aether.core import boot_timer
+    with boot_timer.phase("camera_probe"):
+        return __probe_camera_cv2_impl()
+
+
+def __probe_camera_cv2_impl() -> Tuple[bool, Dict]:
     from aether.core.quiet import quiet_vendor_import
 
     try:
@@ -120,6 +126,12 @@ def _probe_i2c() -> Tuple[bool, Dict]:
     failure. The "devices" field is ALWAYS a list, never None. The whole
     body is wrapped so a bug here can never crash boot.
     """
+    from aether.core import boot_timer
+    with boot_timer.phase("i2c_scan"):
+        return __probe_i2c_impl()
+
+
+def __probe_i2c_impl() -> Tuple[bool, Dict]:
     try:
         try:
             import smbus2
@@ -152,6 +164,12 @@ def _probe_i2c() -> Tuple[bool, Dict]:
 
 def _probe_mavlink_serial() -> Tuple[bool, Dict]:
     """Scan serial ports for flight controller at 57600 baud."""
+    from aether.core import boot_timer
+    with boot_timer.phase("mavlink_probe"):
+        return __probe_mavlink_serial_impl()
+
+
+def __probe_mavlink_serial_impl() -> Tuple[bool, Dict]:
     candidates = []
     if sys.platform == "win32":
         candidates = [f"COM{i}" for i in range(1, 20)]
@@ -214,6 +232,12 @@ def _probe_oled() -> Tuple[bool, Dict]:
       - spi_ready=True but available=False: SPI ok, library missing
       - spi_ready=False: SPI interface not enabled
     """
+    from aether.core import boot_timer
+    with boot_timer.phase("oled_probe"):
+        return __probe_oled_impl()
+
+
+def __probe_oled_impl() -> Tuple[bool, Dict]:
     base_info = {
         "interface": "spi",
         "type": "SSD1306",
@@ -1030,17 +1054,42 @@ class ToolDiscovery:
         self._all_caps: Dict[str, Dict] = {}  # key → {available, detail, category, weight}
 
     def discover(self) -> Dict:
-        """Run all probes and build the full capability manifest."""
-        self._platform = _detect_platform()
-        self._serial_ports = _detect_serial_ports()
-
-        self._probe_hardware()
-        self._probe_software()
-        self._probe_network()
-        self._probe_environment()
+        """Run all probes and build the full capability manifest.
+
+        v5.2.2: each phase is timed. Boot dominates perceived latency now that
+        planning is cached, and the breakdown was previously unmeasured.
+        """
+        from aether.core import boot_timer, discovery_cache
+
+        # v5.2.2: if the hardware fingerprint is unchanged, the whole probe
+        # sweep is skipped. The fingerprint includes the I2C ACK scan, so a
+        # swapped HAT is a miss rather than a fast boot onto the wrong adapter.
+        with boot_timer.phase("fingerprint"):
+            current = discovery_cache.fingerprint()
+        cached = discovery_cache.load(current)
+        if cached is not None:
+            print("  [DISCOVERY] Using cached hardware profile "
+                  "(fingerprint match)")
+            self._manifest = cached
+            return self._manifest
+
+        with boot_timer.phase("platform"):
+            self._platform = _detect_platform()
+        with boot_timer.phase("serial_enum"):
+            self._serial_ports = _detect_serial_ports()
+
+        with boot_timer.phase("hardware_probe"):
+            self._probe_hardware()
+        with boot_timer.phase("software_probe"):
+            self._probe_software()
+        with boot_timer.phase("network_probe"):
+            self._probe_network()
+        with boot_timer.phase("environment_probe"):
+            self._probe_environment()
 
         self._compute_score()
         self._manifest = self._build_manifest()
+        discovery_cache.save(self._manifest, current)
         return self._manifest
 
     # ── Hardware ──────────────────────────────────────────────────