gothos 0.2.0__tar.gz → 0.2.2__tar.gz

{gothos-0.2.0 → gothos-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: gothos
-Version: 0.2.0
+Version: 0.2.2
 Summary: Provider-agnostic Android AI agent — automates any device using any LLM with safety gates, memory, planning and visual grounding
 Project-URL: Homepage, https://github.com/GouthamRajam/GothOS
 Project-URL: Repository, https://github.com/GouthamRajam/GothOS

{gothos-0.2.0 → gothos-0.2.2}/gothos/__init__.py

@@ -2,7 +2,7 @@
 
 """GothOS — Android AI agent with safety, memory, planning and provider-agnostic grounding."""
 
-__version__ = "0.2.0"
+__version__ = "0.2.2"
 
 from gothos import (
     benchmark,

{gothos-0.2.0 → gothos-0.2.2}/gothos/cli.py

@@ -179,7 +179,7 @@ async def _cmd_run(args: argparse.Namespace) -> int:
     print(f"Max steps: {args.max_steps}")
     print("-" * 50)
 
-    result = await agent.run(args.goal)  # type: ignore[call-arg]
+    result = await agent.run(args.goal, app_package="")
 
     print("-" * 50)
     print(f"Success: {result.success}")
@@ -192,25 +192,38 @@ async def _cmd_run(args: argparse.Namespace) -> int:
 
 
 async def _cmd_devices(_args: argparse.Namespace) -> int:
-    from gothos.device.adb import DeviceBridge
+    from gothos.device.adb import AdbError, DeviceBridge
 
     bridge = DeviceBridge()
+
+    # List all connected device serials via adb
     try:
-        await bridge.connect()
+        raw = await bridge.adb("devices")
+        assert isinstance(raw, str)
     except Exception as exc:
         print(f"ADB connection failed: {exc}", file=sys.stderr)
         return 1
 
-    devices = await bridge.list_devices()  # type: ignore[attr-defined]
-    if not devices:
+    serials: list[str] = []
+    for line in raw.strip().splitlines()[1:]:
+        parts = line.split()
+        if len(parts) >= 2 and parts[1] == "device":
+            serials.append(parts[0])
+
+    if not serials:
         print("No devices connected.")
         return 0
 
     print(f"{'Serial':<25} {'Model':<20} {'SDK':<6} {'Screen'}")
     print("-" * 70)
-    for d in devices:
-        screen = f"{d.screen_width}x{d.screen_height}" if d.screen_width else "unknown"
-        print(f"{d.serial:<25} {d.model or 'unknown':<20} {d.sdk_version or '?':<6} {screen}")
+    for serial in serials:
+        try:
+            b = DeviceBridge()
+            info = await b.connect(device_serial=serial)
+            screen = f"{info.screen_width}x{info.screen_height}" if info.screen_width else "unknown"
+            print(f"{info.serial:<25} {info.model:<20} {info.sdk_version or '?':<6} {screen}")
+        except AdbError:
+            print(f"{serial:<25} {'error':<20} {'?':<6} unknown")
 
     return 0
 
@@ -219,8 +232,8 @@ async def _cmd_screenshot(args: argparse.Namespace) -> int:
     from gothos.device.adb import DeviceBridge
     from gothos.device.screenshot import capture_screenshot
 
-    bridge = DeviceBridge(serial=args.device)  # type: ignore[call-arg]
-    await bridge.connect()
+    bridge = DeviceBridge()
+    await bridge.connect(device_serial=args.device)
 
     data = await capture_screenshot(bridge)
     output = Path(args.output)
@@ -233,8 +246,8 @@ async def _cmd_hierarchy(args: argparse.Namespace) -> int:
     from gothos.device.adb import DeviceBridge
     from gothos.device.screenshot import dump_ui_hierarchy
 
-    bridge = DeviceBridge(serial=args.device)  # type: ignore[call-arg]
-    await bridge.connect()
+    bridge = DeviceBridge()
+    await bridge.connect(device_serial=args.device)
 
     xml_str = await dump_ui_hierarchy(bridge)
 
@@ -259,11 +272,11 @@ async def _cmd_plan(args: argparse.Namespace) -> int:
     model = args.model or _DEFAULT_MODELS.get(args.provider, "")
     llm = build_llm(provider=args.provider, model=model)
 
-    bridge = DeviceBridge(serial=args.device)  # type: ignore[call-arg]
-    await bridge.connect()
+    bridge = DeviceBridge()
+    await bridge.connect(device_serial=args.device)
 
     xml_str = await dump_ui_hierarchy(bridge)
-    screen_state = get_screen_state(xml_str)  # type: ignore[arg-type]
+    screen_state = await get_screen_state(bridge)
     analyzer = ScreenAnalyzer()
     analysis = analyzer.analyze(xml_str)  # type: ignore[call-arg]
 
@@ -274,7 +287,7 @@ async def _cmd_plan(args: argparse.Namespace) -> int:
             {
                 "interactive_elements": len(analysis.interactive_elements),
                 "visible_text": analysis.visible_text[:500],  # type: ignore[attr-defined]
-                "current_package": screen_state.package if screen_state else "unknown",  # type: ignore[attr-defined]
+                "current_package": screen_state.app_package if screen_state else "unknown",
             }
         ),
     )

{gothos-0.2.0 → gothos-0.2.2}/gothos/core/agent.py

@@ -156,7 +156,7 @@ class GothOSAgent:
     # Public API
     # ------------------------------------------------------------------
 
-    async def run(self, goal: str, app_package: str) -> RunResult:
+    async def run(self, goal: str, app_package: str = "") -> RunResult:
         """Execute *goal* on *app_package* and return the outcome."""
         if self._graph is None:
             raise RuntimeError("Agent not initialised — call initialize() first")

{gothos-0.2.0 → gothos-0.2.2}/gothos/mcp/tools.py

@@ -181,8 +181,8 @@ async def capture_state(inp: CaptureStateInput) -> DeviceSnapshot:
     )
     from gothos.screen.analyzer import ScreenAnalyzer
 
-    bridge = DeviceBridge(serial=inp.device_serial)  # type: ignore[call-arg]
-    await bridge.connect()
+    bridge = DeviceBridge()
+    await bridge.connect(device_serial=inp.device_serial)
     device_info = await bridge.get_device_info()
 
     snapshot = DeviceSnapshot(
@@ -215,9 +215,9 @@ async def capture_state(inp: CaptureStateInput) -> DeviceSnapshot:
         snapshot.interactive_count = len(analysis.interactive_elements)
         snapshot.has_keyboard = analysis.has_keyboard
 
-        screen_state = get_screen_state(xml_str)  # type: ignore[arg-type]
+        screen_state = await get_screen_state(bridge)
         if screen_state:
-            snapshot.current_package = screen_state.package or ""  # type: ignore[attr-defined]
+            snapshot.current_package = screen_state.app_package or ""
 
     if inp.include_device_info:
         current_pkg = await bridge.shell("dumpsys window | grep mCurrentFocus")
@@ -279,8 +279,8 @@ async def health_check(inp: HealthCheckInput) -> HealthReport:
     try:
         from gothos.device.adb import DeviceBridge
 
-        bridge = DeviceBridge(serial=inp.device_serial)  # type: ignore[call-arg]
-        await bridge.connect()
+        bridge = DeviceBridge()
+        await bridge.connect(device_serial=inp.device_serial)
         report.adb_connected = True
 
         device_info = await bridge.get_device_info()

{gothos-0.2.0 → gothos-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "gothos"
-version = "0.2.0"
+version = "0.2.2"
 description = "Provider-agnostic Android AI agent — automates any device using any LLM with safety gates, memory, planning and visual grounding"
 readme = "README.md"
 license = "MIT"

{gothos-0.2.0 → gothos-0.2.2}/tests/test_mcp.py

@@ -8,6 +8,8 @@ from unittest.mock import patch
 
 import pytest
 
+import gothos
+
 from gothos.mcp.models import (
     ActionEntry,
     CaptureStateInput,
@@ -431,7 +433,7 @@ class TestHealthCheck:
         ):
             result = await health_check(HealthCheckInput(check_llm=False))
 
-        assert result.gothos_version == "0.2.0"
+        assert result.gothos_version == gothos.__version__
 
 
 # ---------------------------------------------------------------------------