hubble-cli 4.1.0__tar.gz → 4.1.2__tar.gz

{hubble_cli-4.1.0 → hubble_cli-4.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hubble-cli
-Version: 4.1.0
+Version: 4.1.2
 Summary: Hubble: agentic coding CLI for AIHub and other OpenAI-compatible APIs
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/Hamdayrabby/hubble-cli

{hubble_cli-4.1.0 → hubble_cli-4.1.2}/hubble/__init__.py

@@ -1,3 +1,3 @@
 """Hubble: an agentic coding CLI for OpenAI-compatible gateways such as AIHub."""
 
-__version__ = "4.1.0"
+__version__ = "4.1.2"

{hubble_cli-4.1.0 → hubble_cli-4.1.2}/hubble/banner.py

@@ -444,17 +444,17 @@ def compose_grid(width: int, height: int, t: float, status: List[Text], tips: Li
     logo_h = {2: 9, 1: 7, 0: 1}  # letter rows + shadow row + tagline
     top = 2 if width >= BIG_LOGO_WIDTH + 4 else (1 if width >= 58 else 0)
     mid = min(top, 1)
-    # Richest to poorest. Below a plain small-logo layout, keep shrinking the status block itself
-    # (never just tips) so something animated always fits, all the way down to the logo line alone.
+    # Richest to poorest. The name is the last thing to shrink: first drop the scene, then the
+    # tips, then status lines, and only then fall back to a smaller logo.
     n_status = len(status)
-    layouts = [
-        (top, FULL, True, n_status), (top, COMPACT, True, n_status),
-        (mid, FULL, True, n_status), (mid, COMPACT, True, n_status),
-        (top, COMPACT, False, n_status), (mid, COMPACT, False, n_status), (0, COMPACT, False, n_status),
-        (top, None, True, n_status), (0, None, True, n_status), (0, None, False, n_status),
-        (0, None, False, min(2, n_status)), (0, None, False, min(1, n_status)),
-        (0, None, False, 0),
-    ]
+    layouts = []
+    for cand_size in dict.fromkeys([top, mid, 0]):
+        for cand_art in (FULL, COMPACT, None):
+            layouts.append((cand_size, cand_art, True, n_status))
+        for cand_art in (COMPACT, None):
+            layouts.append((cand_size, cand_art, False, n_status))
+        for n in (min(2, n_status), min(1, n_status), 0):
+            layouts.append((cand_size, None, False, n))
     size, art, with_tips, n_status = layouts[-1]
     for cand_size, cand_art, cand_tips, cand_n in layouts:
         if cand_art is not None and width < cand_art.width + 24:

{hubble_cli-4.1.0 → hubble_cli-4.1.2}/hubble/repl.py

@@ -98,6 +98,7 @@ class Repl:
         self._main_root: Optional[Path] = None  # set once /worktree moves the tools elsewhere
         from hubble.update import UpdateChecker
         self.updates = UpdateChecker(enabled=bool(agent.settings.get("update_check", True)))
+        self._update_scheduled = False
         self.turn_stats = None
         self.agent = agent
         agent.fallback_resolver = self.fallback_for
@@ -263,12 +264,15 @@ class Repl:
         """Called on every prompt redraw (at least once a second): keep the home screen's model
         line in step with the running scan, and report a finished scan right away instead of
         waiting for the next Enter."""
-        if self.updates.latest and not self.updates.announced:
+        # Only when there really is something to print, and only schedule it once: run_in_terminal
+        # redraws the prompt, which calls this again -- anything looser here loops forever (flicker).
+        if self.updates.has_notice() and not self._update_scheduled:
+            self._update_scheduled = True
             try:
                 from prompt_toolkit.application import get_app, run_in_terminal
                 get_app().loop.call_soon(lambda: run_in_terminal(self._announce_update))
             except Exception:
-                pass  # not inside a prompt; the main loop shows it before the next one
+                self._update_scheduled = False  # not inside a prompt; the main loop shows it
         key = tuple((n, s.status, s.done, s.retry_done) for n, s in self.scanners.items())
         if key == self._scan_key:
             return

{hubble_cli-4.1.0 → hubble_cli-4.1.2}/hubble/update.py

@@ -89,9 +89,13 @@ class UpdateChecker:
         except OSError:
             pass
 
+    def has_notice(self) -> bool:
+        """Cheap, side-effect-free: is there a notice waiting to be shown? (Called on every redraw.)"""
+        return bool(self.latest) and not self.announced and is_newer(self.latest)
+
     def pending_notice(self) -> Optional[str]:
         """The notice text once, when a newer version is known and not yet shown."""
-        if self.announced or not self.latest or not is_newer(self.latest):
+        if not self.has_notice():
             return None
         self.announced = True
         return (f"Update available: hubble {__version__} → {self.latest}. "

{hubble_cli-4.1.0 → hubble_cli-4.1.2}/hubble_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hubble-cli
-Version: 4.1.0
+Version: 4.1.2
 Summary: Hubble: agentic coding CLI for AIHub and other OpenAI-compatible APIs
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/Hamdayrabby/hubble-cli

{hubble_cli-4.1.0 → hubble_cli-4.1.2}/tests/test_update.py

@@ -63,6 +63,54 @@ def test_disabled_by_setting_or_env(monkeypatch, tmp_path):
     assert c.pending_notice() is None
 
 
+def _idle_redraws(tmp_path, latest, seconds=2.0):
+    """Sit at a real prompt for `seconds` with `latest` known; return how many times it redrew."""
+    import threading
+
+    from prompt_toolkit.application import create_app_session, get_app
+    from prompt_toolkit.input import create_pipe_input
+    from prompt_toolkit.output import DummyOutput
+
+    from hubble.agent import Agent
+    from hubble.permissions import Permissions
+    from hubble.repl import Repl
+    from hubble.session import SessionStore
+    from hubble.tools import ToolContext
+    from hubble.ui import ReplEvents
+
+    ctx = ToolContext(root=tmp_path)
+    agent = Agent(None, {"model": "m", "max_turns": 2, "max_tokens": 10, "context_window": 1000,
+                         "auto_compact_ratio": 0, "persona": "code"}, ctx, Permissions(), ReplEvents(ctx))
+    repl = Repl(agent, SessionStore(tmp_path), {"hubble": object()})
+    repl.updates.latest = latest
+    counts = {}
+    with create_pipe_input() as inp:
+        with create_app_session(input=inp, output=DummyOutput()):
+            session = repl._prompt_session()
+
+            def driver():
+                time.sleep(seconds)
+                counts["renders"] = session.app.render_counter
+                inp.send_text("\r")
+            threading.Thread(target=driver, daemon=True).start()
+            session.prompt("> ")
+    return counts["renders"], repl
+
+
+def test_no_redraw_loop_when_pypi_is_not_newer(tmp_path, monkeypatch):
+    """Regression: a known-but-not-newer version made every redraw schedule another redraw
+    (run_in_terminal), so the terminal flickered nonstop."""
+    renders, repl = _idle_redraws(tmp_path, latest="0.0.1")
+    assert renders < 15, f"{renders} redraws in 2s while idle: redraw loop"
+    assert repl.updates.pending_notice() is None
+
+
+def test_newer_version_announced_once_without_redraw_loop(tmp_path):
+    renders, repl = _idle_redraws(tmp_path, latest="999.0.0")
+    assert renders < 15, f"{renders} redraws in 2s while idle: redraw loop"
+    assert repl.updates.announced
+
+
 def test_network_failure_is_silent(monkeypatch, tmp_path):
     monkeypatch.setattr(update, "CACHE_FILE", tmp_path / "c.json")
     monkeypatch.setattr(update, "_fetch_latest", lambda timeout=4.0: None)