alissa-tools-github-revloop 0.12.0__tar.gz → 0.13.0__tar.gz

{alissa_tools_github_revloop-0.12.0/src/main/alissa_tools_github_revloop.egg-info → alissa_tools_github_revloop-0.13.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alissa-tools-github-revloop
-Version: 0.12.0
+Version: 0.13.0
 Summary: ALISSA-TOOLS-GITHUB-REVLOOP
 Home-page: https://alissa.app
 Author: Fahera

{alissa_tools_github_revloop-0.12.0 → alissa_tools_github_revloop-0.13.0}/src/main/alissa/tools/github/revloop/loop.py

@@ -14,6 +14,7 @@ import logging
 import re
 import secrets
 import time
+from collections import Counter
 from dataclasses import dataclass
 from enum import Enum
 from pathlib import Path
@@ -185,6 +186,19 @@ class Decision:
     action: Action
     reason: str = ""
     round: int | None = None
+    # Descriptive metadata for the poll-snapshot exhaust (see
+    # ReviewWatcher._stage_record). Populated where a decision names a concrete
+    # reviewer -- the SPAWNED path and the liveness-deferral IN_FLIGHT paths --
+    # and left at its default elsewhere. Purely observational: nothing in the
+    # decision logic reads these, so they never change which branch is taken.
+    # `deferred` marks an IN_FLIGHT that is a liveness deferral (a live session
+    # holding the respawn back) rather than a freshly-enqueued round;
+    # `reenqueued` marks a SPAWNED that respawned a round whose prior session
+    # was presumed dead (the "stale-re-enqueued" summary bucket).
+    session: str | None = None
+    task_ref: str | None = None
+    deferred: bool = False
+    reenqueued: bool = False
 
 
 def session_name(pr: PullRequest, round_: int) -> str:
@@ -323,6 +337,8 @@ class ReviewWatcher:
                 Action.IN_FLIGHT,
                 f"round {round_} is stale but liveness is unprobeable — deferring",
                 round_,
+                session=session,
+                deferred=True,
             )
 
         ses = live.get(session)
@@ -356,6 +372,8 @@ class ReviewWatcher:
             f"{session} is still {life} — not "
             f"respawning over a live reviewer",
             round_,
+            session=session,
+            deferred=True,
         )
 
     def _convergence_reason(
@@ -405,9 +423,14 @@ class ReviewWatcher:
 
     # -- reap sweep --------------------------------------------------------
 
-    def sweep_sessions(self) -> None:
+    def sweep_sessions(self) -> int:
         """Kill the managed session of every finished round. Runs every poll.
 
+        Returns the number of sessions actually reaped this pass (0 in
+        `--dry-run`, where the sweep only logs) -- the poll-snapshot exhaust
+        records it, and it is the one count the snapshot cannot derive from
+        the per-PR Decision list.
+
         The predecessor of this sweep ran inside evaluate(), which is fed by
         the review-requested:@me search -- and submitting a review CLEARS the
         request, so a finished round's PR vanished from the search at exactly
@@ -435,7 +458,7 @@ class ReviewWatcher:
             sessions = self.alissa.list_review_sessions()
         except CommandError as exc:
             log.warning("reap sweep skipped: could not list sessions: %s", exc)
-            return
+            return 0
 
         # Per-sweep memos. The PR fetch is keyed per distinct PR; the round
         # count additionally keys on the task ref, because two spawns of one
@@ -443,6 +466,7 @@ class ReviewWatcher:
         # task existed carries None). None = undecidable this pass.
         prs: dict[tuple[str, int], PullRequest | None] = {}
         completed_cache: dict[tuple[str, int, str | None], float | None] = {}
+        reaped = 0
 
         for ses in sessions:
             if not ses.is_idle:
@@ -486,10 +510,12 @@ class ReviewWatcher:
             # The live list is the authority; gating on the reaps table would
             # spare any session killed behind the ledger's back.
             self.state.record_reap(ses.name)
+            reaped += 1
             log.info(
                 "reaped finished reviewer session %s (round %d done)",
                 ses.name, row["round"],
             )
+        return reaped
 
     def _sweep_pr(self, repo_slug: str, number: int) -> PullRequest | None:
         """One PR fetch for the sweep; the caller memoizes per distinct PR.
@@ -596,6 +622,9 @@ class ReviewWatcher:
             Action.SPAWNED,
             f"session {name} → {task.ref if task else 'no task'}",
             round_,
+            session=name,
+            task_ref=task.ref if task else None,
+            reenqueued=reenqueued,
         )
 
     def _ensure_hub(self, pr: PullRequest) -> tuple[Path, str | None]:
@@ -778,7 +807,8 @@ class ReviewWatcher:
         # needs the slot a finished session is squatting on. Deliberately not
         # inside the per-request loop below — the sweep must reach sessions
         # whose PR no longer appears in the search at all.
-        self.sweep_sessions()
+        started = time.monotonic()
+        reaped = self.sweep_sessions()
 
         requests = self.github.review_requests(self.config.repos)
         log.info("%d PR(s) with a review pending from %s", len(requests), self.github.login)
@@ -799,8 +829,89 @@ class ReviewWatcher:
             level = logging.INFO if decision.action != Action.SKIPPED else logging.DEBUG
             log.log(level, "%s → %s (%s)", slug, decision.action.value, decision.reason)
             results.append((slug, decision))
+
+        # Persist one poll_snapshots row per pass, built entirely from the
+        # Decision list already in hand plus the reap count -- no new GitHub
+        # calls. Written in dry-run too: a snapshot OBSERVES the pass, it is
+        # not a side effect the daemon takes, so a future console sees dry-run
+        # passes as well as live ones.
+        self._write_snapshot(
+            results, reaped, duration_ms=int((time.monotonic() - started) * 1000)
+        )
         return results
 
+    def _stage_record(self, slug: str, decision: Decision) -> dict:
+        """One per-item entry of a poll snapshot's compact JSON: the PR
+        reference (the slug and the number parsed from it), the current stage
+        (the decision's action, refined to name the stale-re-enqueue and
+        liveness-deferral buckets the bare action folds together), and the
+        round, session name, and origin task ref carried on the Decision.
+        `attempt` is carried as a fixed None for schema parity with the
+        devloop's per-item record -- the reviewloop is round-based and has no
+        attempt dimension -- so one console can read both loops' snapshots."""
+        _, _, tail = slug.partition("#")
+        stage = decision.action.value
+        if decision.reenqueued:
+            stage = "stale-re-enqueued"
+        elif decision.deferred:
+            stage = "deferred"
+        return {
+            "slug": slug,
+            "number": int(tail),
+            "round": decision.round,
+            "attempt": None,
+            "session": decision.session,
+            "stage": stage,
+            "reason": decision.reason,
+            "task_ref": decision.task_ref,
+        }
+
+    def _write_snapshot(
+        self,
+        results: list[tuple[str, Decision]],
+        reaped: int,
+        *,
+        duration_ms: int,
+    ) -> None:
+        """Persist one poll_snapshots row from the pass's Decision list and the
+        reaper count -- no new GitHub calls. The SPAWNED and IN_FLIGHT buckets
+        each split in two off observational Decision flags: a SPAWNED that
+        respawned a presumed-dead round is `stale_reenqueued`, and an
+        IN_FLIGHT that is a liveness deferral (not a freshly-enqueued round) is
+        `deferred`."""
+        stages = [self._stage_record(slug, d) for slug, d in results]
+        counts = Counter(d.action for _, d in results)
+        spawned = sum(
+            1 for _, d in results
+            if d.action is Action.SPAWNED and not d.reenqueued
+        )
+        stale_reenqueued = sum(
+            1 for _, d in results
+            if d.action is Action.SPAWNED and d.reenqueued
+        )
+        in_flight = sum(
+            1 for _, d in results
+            if d.action is Action.IN_FLIGHT and not d.deferred
+        )
+        deferred = sum(
+            1 for _, d in results
+            if d.action is Action.IN_FLIGHT and d.deferred
+        )
+        self.state.record_snapshot(
+            duration_ms=duration_ms,
+            candidates=len(results),
+            spawned=spawned,
+            stale_reenqueued=stale_reenqueued,
+            in_flight=in_flight,
+            deferred=deferred,
+            converged=counts[Action.CONVERGED],
+            capped=counts[Action.CAPPED],
+            escalated=counts[Action.ESCALATED],
+            skipped=counts[Action.SKIPPED],
+            reaped=reaped,
+            stages=stages,
+        )
+
     def run_forever(self) -> None:
         # preflight() is the caller's responsibility -- the CLI runs it once for
         # every mode, so calling it here too would double every check.

{alissa_tools_github_revloop-0.12.0 → alissa_tools_github_revloop-0.13.0}/src/main/alissa/tools/github/revloop/state.py

@@ -7,14 +7,35 @@ session name back to the round it was spawned for (so the reap sweep can tell
 a finished round's session from an in-flight one), and to remember that a
 cap-out was already escalated. The ledger tolerates sessions dying or being
 killed behind its back: a reap record is bookkeeping, never a precondition.
+
+The `poll_snapshots` table is a different animal from the ledger above: it
+records what each poll pass OBSERVED, not what the daemon must remember to
+avoid double-work. One row per pass carries the timing, the candidate count,
+the decision-summary counts, and a compact JSON column of the pass's per-item
+stages -- everything a future console sidecar (the UI-1 pattern ported from
+the devloop) needs to render live daemon state without spending a single
+GitHub API call of its own. It is self-bounding: the newest SNAPSHOT_RETENTION
+rows are kept and older ones pruned on every write. `read_snapshots` is the
+reader that sidecar will consume (newest first, `stages` decoded back from
+JSON). Adding the table is itself the migration for an existing database --
+`CREATE TABLE IF NOT EXISTS` creates it on the next open of a DB that predates
+it, alongside the untouched legacy ledgers.
 """
 
 from __future__ import annotations
 
+import json
 import sqlite3
 import time
 from pathlib import Path
 
+# Poll-snapshot retention: the newest N rows are kept, older ones pruned on
+# every write. Fixed, not a config key -- `poll_snapshots` is an observation
+# buffer for a future console sidecar, and a bounded ring is all it needs (it
+# reads the recent tail). A change to this constant is a change to the
+# observable buffer size, so it is pinned by a test.
+SNAPSHOT_RETENTION = 1000
+
 # Shared between SCHEMA and the migration so the two can never drift.
 _SPAWNS_TABLE = """
 CREATE TABLE IF NOT EXISTS spawns (
@@ -52,6 +73,23 @@ CREATE TABLE IF NOT EXISTS pings (
     pinged_at INTEGER NOT NULL,
     PRIMARY KEY (repo, number, kind)
 );
+
+CREATE TABLE IF NOT EXISTS poll_snapshots (
+    id                INTEGER PRIMARY KEY AUTOINCREMENT,
+    ts                INTEGER NOT NULL,
+    duration_ms       INTEGER NOT NULL,
+    candidates        INTEGER NOT NULL,
+    spawned           INTEGER NOT NULL,
+    stale_reenqueued  INTEGER NOT NULL,
+    in_flight         INTEGER NOT NULL,
+    deferred          INTEGER NOT NULL,
+    converged         INTEGER NOT NULL,
+    capped            INTEGER NOT NULL,
+    escalated         INTEGER NOT NULL,
+    skipped           INTEGER NOT NULL,
+    reaped            INTEGER NOT NULL,
+    stages_json       TEXT    NOT NULL
+);
 """
 
 
@@ -216,3 +254,81 @@ class State:
             (repo, number, head_sha, int(time.time())),
         )
         self._db.commit()
+
+    # -- poll snapshots (the console sidecar's exhaust buffer) -------------
+
+    def record_snapshot(
+        self,
+        *,
+        duration_ms: int,
+        candidates: int,
+        spawned: int = 0,
+        stale_reenqueued: int = 0,
+        in_flight: int = 0,
+        deferred: int = 0,
+        converged: int = 0,
+        capped: int = 0,
+        escalated: int = 0,
+        skipped: int = 0,
+        reaped: int = 0,
+        stages: list[dict],
+    ) -> None:
+        """Append one poll-pass observation, then prune to the newest
+        SNAPSHOT_RETENTION rows. `ts` is stamped here (wall-clock seconds,
+        like every other row in this ledger); `stages` is the compact
+        per-item list a future console reads back through read_snapshots,
+        serialized to JSON. Purely observational -- written on every pass,
+        dry-run included -- and pruned on write, so the table is
+        self-bounding. The count kwargs default to 0 so a caller need only
+        pass the ones a given pass produced.
+        """
+        self._db.execute(
+            "INSERT INTO poll_snapshots "
+            "(ts, duration_ms, candidates, spawned, stale_reenqueued, "
+            "in_flight, deferred, converged, capped, escalated, skipped, "
+            "reaped, stages_json) "
+            "VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?)",
+            (
+                int(time.time()),
+                duration_ms,
+                candidates,
+                spawned,
+                stale_reenqueued,
+                in_flight,
+                deferred,
+                converged,
+                capped,
+                escalated,
+                skipped,
+                reaped,
+                json.dumps(stages, separators=(",", ":")),
+            ),
+        )
+        # Prune on write: keep the newest SNAPSHOT_RETENTION rows by id. The
+        # autoincrement id is monotonic across prunes, so "newest" is well
+        # defined even when a wall-clock step would leave `ts` unordered.
+        self._db.execute(
+            "DELETE FROM poll_snapshots WHERE id NOT IN "
+            "(SELECT id FROM poll_snapshots ORDER BY id DESC LIMIT ?)",
+            (SNAPSHOT_RETENTION,),
+        )
+        self._db.commit()
+
+    def read_snapshots(self, limit: int | None = None) -> list[dict]:
+        """Poll snapshots newest-first, each with its per-item `stages` list
+        decoded back from JSON (the round-trip counterpart of
+        record_snapshot). `limit` caps the rows returned; None returns every
+        retained row. This is the whole contract the future console depends
+        on -- everything it needs is already here, so it makes no GitHub
+        calls."""
+        sql = "SELECT * FROM poll_snapshots ORDER BY id DESC"
+        params: tuple = ()
+        if limit is not None:
+            sql += " LIMIT ?"
+            params = (limit,)
+        out = []
+        for row in self._db.execute(sql, params).fetchall():
+            record = dict(row)
+            record["stages"] = json.loads(record.pop("stages_json"))
+            out.append(record)
+        return out

alissa_tools_github_revloop-0.13.0/src/main/alissa/tools/github/revloop/version

@@ -0,0 +1 @@
+0.13.0

{alissa_tools_github_revloop-0.12.0 → alissa_tools_github_revloop-0.13.0/src/main/alissa_tools_github_revloop.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alissa-tools-github-revloop
-Version: 0.12.0
+Version: 0.13.0
 Summary: ALISSA-TOOLS-GITHUB-REVLOOP
 Home-page: https://alissa.app
 Author: Fahera

alissa_tools_github_revloop-0.12.0/src/main/alissa/tools/github/revloop/version

@@ -1 +0,0 @@
-0.12.0