alissa-tools-github-devloop 0.8.43__tar.gz → 0.8.44__tar.gz

{alissa_tools_github_devloop-0.8.43/src/main/alissa_tools_github_devloop.egg-info → alissa_tools_github_devloop-0.8.44}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alissa-tools-github-devloop
-Version: 0.8.43
+Version: 0.8.44
 Summary: ALISSA-TOOLS-GITHUB-DEVLOOP
 Home-page: https://alissa.app
 Author: Fahera

alissa_tools_github_devloop-0.8.44/src/main/alissa/tools/github/devloop/version

@@ -0,0 +1 @@
+0.8.44

{alissa_tools_github_devloop-0.8.43 → alissa_tools_github_devloop-0.8.44}/src/main/alissa/tools/github/devloop/webui/sources.py

@@ -31,6 +31,7 @@ logic lives here -- the console only moves a clock the daemon already reads.
 from __future__ import annotations
 
 import json
+import re
 import sqlite3
 import time
 import urllib.error
@@ -111,8 +112,20 @@ VERSION_CACHE_TTL = 600.0
 # non-terminal task corpus 1,440x/day.
 TASKS_CACHE_TTL = 300.0
 # The flag that narrows `alissa task list` to the calling actor's own rows
-# instead of the sponsor's corpus. Newer CLIs only -- see `_supports_self_scope`.
+# instead of the sponsor's corpus. Newer CLIs only -- see `_task_list_flags`.
 TASKS_SELF_FLAG = "--self"
+# The pane shows live work only, so the read asks for exactly those statuses
+# rather than every non-terminal row: the pending_validation backlog alone was
+# ~2,600 rows (~3.5 MB) per refresh on prod (issue #168).
+TASKS_STATUS_FLAG = "--status"
+TASKS_LIVE_STATUSES = ("draft", "committed", "in_progress", "blocked")
+# A row cap, a small multiple of what the pane displays, for a CLI that offers
+# one. Kept within the 1..100 the CLI's paged listings accept.
+TASKS_LIMIT_FLAG = "--limit"
+TASKS_LIMIT_FACTOR = 4
+TASKS_LIMIT_MAX = 100
+# The pane's displayed row count (`worker_tasks`' default limit).
+TASKS_DISPLAYED = 25
 # PyPI JSON endpoint for the running-vs-latest drift chip.
 PYPI_URL = "https://pypi.org/pypi/alissa-tools-github-devloop/json"
 # How many minutes past the stale window retry-now ages a row: the daemon
@@ -194,6 +207,12 @@ def edge_of(name: "str | None") -> "str | None":
     return None
 
 
+def _offers_flag(helptext: str, flag: str) -> bool:
+    """Whether a CLI `--help` text lists `flag` as an option of its own --
+    `--self` must not be read off a longer `--self-x` it happens to prefix."""
+    return re.search(re.escape(flag) + r"(?![\w-])", helptext) is not None
+
+
 def _default_http_get(url: str, timeout: float) -> "bytes | None":
     try:
         with urllib.request.urlopen(url, timeout=timeout) as resp:  # noqa: S310
@@ -250,8 +269,8 @@ class Sources:
         self._rate_cache = _Cache(RATE_CACHE_TTL, clock)
         self._version_cache = _Cache(VERSION_CACHE_TTL, clock)
         self._tasks_cache = _Cache(TASKS_CACHE_TTL, clock)
-        # Tri-state: None = not probed yet (see `_supports_self_scope`).
-        self._self_scope: "bool | None" = None
+        # None = not probed yet (see `_task_list_flags`).
+        self._list_flags: "frozenset[str] | None" = None
         self.boot_wall = int(wall_clock())
 
     # -- thin, failure-tolerant subprocess helpers -------------------------
@@ -460,40 +479,67 @@ class Sources:
             drain=self.drain(), now=self._wall(),
         )
 
-    def _supports_self_scope(self) -> bool:
-        """Whether the installed `alissa` CLI understands `task list --self`.
+    def _task_list_flags(self) -> "frozenset[str]":
+        """Which of the narrowing flags (`--self`, `--status`, `--limit`) the
+        installed `alissa` CLI offers on `task list`.
 
         Read off the CLI's own `--help`, which is local, tokenless and free.
-        The alternative -- send the flag and fall back when the call fails --
+        The alternative -- send a flag and fall back when the call fails --
         cannot tell an unknown flag from an auth hiccup, so it would spend a
-        second sponsor-scoped call on every unlucky refresh, which is the cost
-        this whole path exists to avoid.
+        second, wider call on every unlucky refresh, which is the cost this
+        whole path exists to avoid.
 
         A probe that *answers* is memoized for the process (the CLI cannot
         change under a running console). A probe that fails is deliberately
         NOT memoized: a transient `alissa` failure then degrades this refresh
-        only, instead of pinning the console to the expensive unscoped call
+        only, instead of pinning the console to the expensive unflagged call
         until someone restarts it."""
-        if self._self_scope is None:
+        if self._list_flags is None:
             helptext = self._safe_run(
                 ["alissa", "task", "list", "--help"], timeout=20
             )
             if helptext is None:
-                return False
-            self._self_scope = TASKS_SELF_FLAG in helptext
-        return self._self_scope
+                return frozenset()
+            self._list_flags = frozenset(
+                flag for flag in
+                (TASKS_SELF_FLAG, TASKS_STATUS_FLAG, TASKS_LIMIT_FLAG)
+                if _offers_flag(helptext, flag)
+            )
+        return self._list_flags
 
-    def worker_tasks(self, limit: int = 25) -> "list[dict]":
+    def _supports_self_scope(self) -> bool:
+        """Whether the installed `alissa` CLI understands `task list --self`."""
+        return TASKS_SELF_FLAG in self._task_list_flags()
+
+    def _task_list_argv(self) -> "list[str]":
+        """The `alissa task list` read the pane refreshes from: narrowed by
+        every flag the CLI offers -- the actor's own rows (`--self`), the live
+        statuses the pane shows (`--status`) and a row cap a small multiple
+        of the displayed count (`--limit`). A flag the CLI lacks is simply left
+        off; that per-flag degrade is the ONLY way the read widens."""
+        flags = self._task_list_flags()
+        argv = ["alissa", "task", "list", "--json"]
+        if TASKS_SELF_FLAG in flags:
+            argv.append(TASKS_SELF_FLAG)
+        if TASKS_STATUS_FLAG in flags:
+            argv += [TASKS_STATUS_FLAG, ",".join(TASKS_LIVE_STATUSES)]
+        if TASKS_LIMIT_FLAG in flags:
+            cap = min(TASKS_DISPLAYED * TASKS_LIMIT_FACTOR, TASKS_LIMIT_MAX)
+            argv += [TASKS_LIMIT_FLAG, str(cap)]
+        return argv
+
+    def worker_tasks(self, limit: int = TASKS_DISPLAYED) -> "list[dict]":
         """The worker actor's own tasks via `alissa task list` -- the
         actor-partition bridge (the console runs as the operator, whose actor
         owns the implementation tasks the dev sessions created). Best-effort:
         an old CLI or an auth hiccup just yields an empty list.
 
-        Self-scoped (`--self`) wherever the installed CLI offers it, so a poll
-        reads the console actor's own rows rather than the sponsor's whole
-        non-terminal corpus -- the pane only ever displays the former. An
-        older CLI, or a `--self` call that comes back empty-handed, degrades to
-        the unflagged call: a slower, larger read beats a blank pane.
+        Narrowed (`_task_list_argv`) to what the pane displays wherever the
+        installed CLI offers the flags, so a refresh reads the console actor's
+        live rows rather than the sponsor's whole non-terminal corpus. Only a
+        CLI that lacks a flag reads wider. A narrowed call that fails is never
+        retried unflagged (issue #168: that fallback re-read the sponsor's
+        whole corpus), and a valid but empty `[]` is a real answer.
 
         Cached (TASKS_CACHE_TTL) exactly like the two other remote checks: this
         call rides the shared ALISSA_API_TOKEN the daemon uses, so on the ~10s
@@ -501,16 +547,7 @@ class Sources:
         the API budget. A fetch that fails returns None and keeps the last good
         list (the _Cache contract), never overwriting it with junk."""
         def fetch() -> "list[dict] | None":
-            unscoped = ["alissa", "task", "list", "--json"]
-            self_scoped = self._supports_self_scope()
-            argv = (unscoped + [TASKS_SELF_FLAG]) if self_scoped else unscoped
-            raw = self._safe_json(argv, timeout=45)
-            if raw is None and self_scoped:
-                # The CLI advertised the flag but the call brought nothing
-                # back -- an API that does not serve the scope yet, say. One
-                # unflagged retry keeps the pane populated. A valid but empty
-                # `[]` is a real answer, not a failure, and is never retried.
-                raw = self._safe_json(unscoped, timeout=45)
+            raw = self._safe_json(self._task_list_argv(), timeout=45)
             if not isinstance(raw, list):
                 return None
             rows = [t for t in raw if isinstance(t, dict)]

{alissa_tools_github_devloop-0.8.43 → alissa_tools_github_devloop-0.8.44/src/main/alissa_tools_github_devloop.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alissa-tools-github-devloop
-Version: 0.8.43
+Version: 0.8.44
 Summary: ALISSA-TOOLS-GITHUB-DEVLOOP
 Home-page: https://alissa.app
 Author: Fahera

alissa_tools_github_devloop-0.8.43/src/main/alissa/tools/github/devloop/version

@@ -1 +0,0 @@
-0.8.43