orbi-cli 0.6.2__tar.gz → 0.6.4__tar.gz

{orbi_cli-0.6.2 → orbi_cli-0.6.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: orbi-cli
-Version: 0.6.2
+Version: 0.6.4
 Summary: Orbi — local AI development worker: claims GitHub Issues, runs Pi in isolated worktrees, and delivers PRs (GitHub Issues + labels are the only state store).
 Author: xqliu
 License-Expression: AGPL-3.0-only OR LicenseRef-Sustainable-Use-1.0

{orbi_cli-0.6.2 → orbi_cli-0.6.4}/pyproject.toml

@@ -44,7 +44,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "orbi-cli"
-version = "0.6.2"
+version = "0.6.4"
 description = "Orbi — local AI development worker: claims GitHub Issues, runs Pi in isolated worktrees, and delivers PRs (GitHub Issues + labels are the only state store)."
 readme = "README.md"
 requires-python = ">=3.14"

{orbi_cli-0.6.2 → orbi_cli-0.6.4}/src/orbi/__init__.py

@@ -18,4 +18,4 @@ the package would shadow the installed package for every process with
 the checkout root on sys.path. The direct-execution compatibility entry
 is `python3 -m orbi.cli` (development path only).
 """
-__version__ = "0.6.2"
+__version__ = "0.6.4"

{orbi_cli-0.6.2 → orbi_cli-0.6.4}/src/orbi/pi_process.py

@@ -1258,6 +1258,10 @@ def _stream_pi_once(
     # inherits the Runner's environment unchanged (pre-#157 shape).
     process = subprocess.Popen(
         command, cwd=cwd, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+        # Pi's print mode reads piped stdin until it closes and prepends
+        # it to the prompt (Issue #1562): the child must get /dev/null,
+        # never the Runner's possibly-open stdin pipe.
+        stdin=subprocess.DEVNULL,
         env=None if pi_env is None else {**os.environ, **pi_env},
     )
     # Track the live Pi child for the stop handler: a

{orbi_cli-0.6.2 → orbi_cli-0.6.4}/src/orbi/progress.py

@@ -913,3 +913,73 @@ def _finish_progress_body(*, number: int, title: str, run_id: str,
         number=number, source_repo=source_repo, action=action,
         reason=reason, diagnosis=diagnosis,
     ))
+
+# Automatic observability: the GitHub progress comment is
+# PATCHed on every activity change and at most every 30 seconds while a
+# Pi session runs, so a mobile user sees live progress without any
+# command. The journal cadence is the poll interval above.
+PI_HEARTBEAT_SECONDS = 30.0
+
+def _live_progress(ctx: RunContext, publisher: ProgressPublisher, *,
+                   title: str, role: str, started: float,
+                   pr_url: str | None, review_round: int, priority: str,
+                   activity: dict | None = None) -> None:
+    """One live GitHub progress update while a Pi session is running.
+
+    Called from the `stream_pi` poll loop (every activity change or
+    heartbeat): the same run-marker comment is PATCHed in
+    place at most every `PI_HEARTBEAT_SECONDS` or when the visible
+    activity changed. `activity` is the watcher state of that poll, so
+    the live comment shows the session exactly as the journal reports
+    it. The publisher already knows the comment id after `ensure`, so a
+    callback before it would fail fast here — and the wiring always
+    ensures first.
+    """
+    state = _progress_state(
+        ctx, title=title, role=role, started=started,
+        pr_url=pr_url, review_round=review_round, priority=priority,
+        activity=activity,
+    )
+    publisher.patch(_progress_body(state))
+
+class LiveProgressThrottle:
+    """Throttle live GitHub PATCHes to change-driven or <=30-second cadence.
+
+    The `stream_pi` poll loop fires on every poll (15 s default); PATCHing
+    GitHub on every poll would double the traffic for no visible gain.
+    The throttle passes an update through when the visible activity
+    (phase, action, result, model_wait) changed since the last PATCH or
+    when at least `PI_HEARTBEAT_SECONDS` passed since it.
+    """
+
+    def __init__(self, ctx: RunContext, publisher: ProgressPublisher, *,
+                 title: str, role: str, started: float,
+                 pr_url: str | None, review_round: int,
+                 priority: str) -> None:
+        def publish(activity: dict) -> None:
+            _live_progress(
+                ctx, publisher, title=title, role=role,
+                started=started, pr_url=pr_url,
+                review_round=review_round, priority=priority,
+                activity=activity,
+            )
+
+        self._publish = publish
+        self._last_visible: tuple | None = None
+        self._last_patch = 0.0
+
+    def __call__(self, activity: dict) -> None:
+        visible = (
+            activity["phase"], activity["action"], activity["result"],
+            activity["model_wait"],
+            # The idle-recovery state is visible progress:
+            # entering/leaving it PATCHes the live comment immediately.
+            activity.get("recovery"),
+        )
+        now = time.monotonic()
+        if visible == self._last_visible and \
+                now - self._last_patch < PI_HEARTBEAT_SECONDS:
+            return
+        self._last_visible = visible
+        self._last_patch = now
+        self._publish(activity)