claude-smart 0.2.45 → 0.2.47

package/plugin/vendor/reflexio/reflexio/server/services/storage/sqlite_storage/_requests.py

@@ -1,12 +1,12 @@
 """Request CRUD methods for SQLite storage."""
 
-import json
 import sqlite3
 from typing import Any
 
 from reflexio.models.api_schema.internal_schema import (
     RequestInteractionDataModel,
     SessionDescriptor,
+    SessionFirstRequest,
 )
 from reflexio.models.api_schema.service_schemas import (
     Request,
@@ -15,6 +15,7 @@ from reflexio.models.api_schema.service_schemas import (
 from ._base import (
     SQLiteStorageBase,
     _epoch_to_iso,
+    _iso_to_epoch,
     _row_to_interaction,
     _row_to_request,
 )
@@ -29,6 +30,8 @@ class RequestMixin:
     _execute: Any
     _fetchone: Any
     _fetchall: Any
+    _subject_ref_for_user_id: Any
+    _assert_subject_writable_locked: Any
 
     # ------------------------------------------------------------------
     # Request methods
@@ -37,20 +40,31 @@ class RequestMixin:
     @SQLiteStorageBase.handle_exceptions
     def add_request(self, request: Request) -> None:
         created_at_iso = _epoch_to_iso(request.created_at)
-        self._execute(
-            """INSERT OR REPLACE INTO requests
-               (request_id, user_id, created_at, source, agent_version, session_id, metadata)
-               VALUES (?,?,?,?,?,?,?)""",
-            (
-                request.request_id,
-                request.user_id,
-                created_at_iso,
-                request.source,
-                request.agent_version,
-                request.session_id,
-                json.dumps(request.metadata, sort_keys=True),
-            ),
-        )
+        subject_ref = self._subject_ref_for_user_id(request.user_id)
+        with self._lock:
+            try:
+                self.conn.execute("BEGIN IMMEDIATE")
+                self._assert_subject_writable_locked(subject_ref)
+                self.conn.execute(
+                    """INSERT OR REPLACE INTO requests
+                       (request_id, user_id, created_at, source, agent_version, session_id,
+                        evaluation_only, governance_subject_ref)
+                       VALUES (?,?,?,?,?,?,?,?)""",
+                    (
+                        request.request_id,
+                        request.user_id,
+                        created_at_iso,
+                        request.source,
+                        request.agent_version,
+                        request.session_id,
+                        1 if request.evaluation_only else 0,
+                        subject_ref,
+                    ),
+                )
+                self.conn.commit()
+            except Exception:
+                self.conn.rollback()
+                raise
 
     @SQLiteStorageBase.handle_exceptions
     def get_request(self, request_id: str) -> Request | None:
@@ -154,35 +168,62 @@ class RequestMixin:
         end_time: int | None = None,
         top_k: int | None = 30,
         offset: int = 0,
+        source: str | None = None,
     ) -> dict[str, list[RequestInteractionDataModel]]:
-        sql = "SELECT * FROM requests WHERE 1=1"
-        params: list[Any] = []
-
+        # Request-level filters shared by both the session-page query and the
+        # request-fetch query. Pagination is applied at the SESSION level
+        # (top_k/offset count sessions, not request rows) so a session with many
+        # requests is never truncated to a subset of its rows.
+        filter_sql = ""
+        filter_params: list[Any] = []
         if user_id:
-            sql += " AND user_id = ?"
-            params.append(user_id)
+            filter_sql += " AND user_id = ?"
+            filter_params.append(user_id)
         if request_id:
-            sql += " AND request_id = ?"
-            params.append(request_id)
+            filter_sql += " AND request_id = ?"
+            filter_params.append(request_id)
         if session_id:
-            sql += " AND session_id = ?"
-            params.append(session_id)
-        if start_time:
-            sql += " AND created_at >= ?"
-            params.append(_epoch_to_iso(start_time))
-        if end_time:
-            sql += " AND created_at <= ?"
-            params.append(_epoch_to_iso(end_time))
+            filter_sql += " AND session_id = ?"
+            filter_params.append(session_id)
+        if source is not None:
+            filter_sql += " AND source = ?"
+            filter_params.append(source)
+        if start_time is not None:
+            filter_sql += " AND created_at >= ?"
+            filter_params.append(_epoch_to_iso(start_time))
+        if end_time is not None:
+            filter_sql += " AND created_at <= ?"
+            filter_params.append(_epoch_to_iso(end_time))
 
+        # Step 1: select the page of session_ids, ordered by each session's most
+        # recent matching request (latest-first), with session_id as a stable
+        # tiebreak so pages don't overlap or skip.
         effective_limit = top_k or 100
-        sql += " ORDER BY created_at DESC LIMIT ? OFFSET ?"
-        params.extend([effective_limit, offset])
+        page_rows = self._fetchall(
+            f"SELECT session_id, MAX(created_at) AS latest FROM requests "
+            f"WHERE 1=1{filter_sql} "
+            f"GROUP BY session_id ORDER BY latest DESC, session_id DESC "
+            f"LIMIT ? OFFSET ?",
+            [*filter_params, effective_limit, offset],
+        )
+        if not page_rows:
+            return {}
+        page_session_ids = [r["session_id"] for r in page_rows]
 
-        req_rows = self._fetchall(sql, params)
+        # Step 2: fetch ALL matching requests for the sessions in this page.
+        placeholders = ",".join("?" for _ in page_session_ids)
+        req_rows = self._fetchall(
+            f"SELECT * FROM requests WHERE 1=1{filter_sql} "
+            f"AND session_id IN ({placeholders}) ORDER BY created_at DESC",
+            [*filter_params, *page_session_ids],
+        )
         if not req_rows:
             return {}
 
-        grouped: dict[str, list[RequestInteractionDataModel]] = {}
+        # Preserve the latest-first session ordering from step 1.
+        grouped: dict[str, list[RequestInteractionDataModel]] = {
+            (sid or ""): [] for sid in page_session_ids
+        }
         for rr in req_rows:
             req = _row_to_request(rr)
             group_name = req.session_id or ""
@@ -261,3 +302,76 @@ class RequestMixin:
             )
             for r in rows
         ]
+
+    @SQLiteStorageBase.handle_exceptions
+    def get_first_requests_by_session_ids(
+        self, session_ids: list[str]
+    ) -> dict[str, SessionFirstRequest]:
+        if not session_ids:
+            return {}
+        out: dict[str, SessionFirstRequest] = {}
+        ids = sorted(set(session_ids))
+        chunk_size = 500
+        for i in range(0, len(ids), chunk_size):
+            chunk = ids[i : i + chunk_size]
+            ph = ",".join("?" for _ in chunk)
+            rows = self._fetchall(
+                f"""SELECT session_id, user_id, source, created_at
+                    FROM (
+                        SELECT session_id, user_id, source, created_at,
+                               ROW_NUMBER() OVER (
+                                   PARTITION BY session_id
+                                   ORDER BY created_at ASC, request_id ASC
+                               ) AS rn
+                        FROM requests
+                        WHERE session_id IN ({ph})
+                    )
+                    WHERE rn = 1""",  # noqa: S608
+                chunk,
+            )
+            for row in rows:
+                session_id = row["session_id"]
+                out[session_id] = SessionFirstRequest(
+                    session_id=session_id,
+                    user_id=row["user_id"],
+                    source=row["source"] or "",
+                    created_at=_iso_to_epoch(row["created_at"]),
+                )
+        return out
+
+    @SQLiteStorageBase.handle_exceptions
+    def get_first_requests_by_user_session_pairs(
+        self, pairs: list[tuple[str, str]]
+    ) -> dict[tuple[str, str], SessionFirstRequest]:
+        if not pairs:
+            return {}
+        out: dict[tuple[str, str], SessionFirstRequest] = {}
+        pair_list = sorted(set(pairs))
+        chunk_size = 300
+        for i in range(0, len(pair_list), chunk_size):
+            chunk = pair_list[i : i + chunk_size]
+            values = ",".join("(?, ?)" for _ in chunk)
+            params = [value for pair in chunk for value in pair]
+            rows = self._fetchall(
+                f"""SELECT session_id, user_id, source, created_at
+                    FROM (
+                        SELECT session_id, user_id, source, created_at,
+                               ROW_NUMBER() OVER (
+                                   PARTITION BY user_id, session_id
+                                   ORDER BY created_at ASC, request_id ASC
+                               ) AS rn
+                        FROM requests
+                        WHERE (user_id, session_id) IN ({values})
+                    )
+                    WHERE rn = 1""",  # noqa: S608
+                params,
+            )
+            for row in rows:
+                key = (row["user_id"], row["session_id"])
+                out[key] = SessionFirstRequest(
+                    session_id=row["session_id"],
+                    user_id=row["user_id"],
+                    source=row["source"] or "",
+                    created_at=_iso_to_epoch(row["created_at"]),
+                )
+        return out

package/plugin/vendor/reflexio/reflexio/server/services/storage/sqlite_storage/_shadow_verdicts.py

@@ -13,13 +13,6 @@ from reflexio.models.api_schema.eval_overview_schema import (
 
 from ._base import SQLiteStorageBase, _epoch_to_iso
 
-# Maximum epoch seconds that ``datetime.fromtimestamp`` can represent (year
-# 9999-12-31). Callers passing sentinel "open" upper bounds like
-# ``sys.maxsize`` or ``10**12`` would otherwise overflow ``_epoch_to_iso``;
-# clamping to this value yields the same query semantics (≥ everything) with
-# a valid ISO string.
-_MAX_SAFE_EPOCH_TS = 253_402_300_799  # 9999-12-31T23:59:59Z
-
 
 def _parse_dt(value: str) -> datetime:
     """
@@ -164,8 +157,8 @@ class ShadowVerdictsMixin:
             list[ShadowComparisonVerdict]: Verdicts in chronological order
                 (ascending ``created_at``).
         """
-        from_iso = _epoch_to_iso(max(0, min(from_ts, _MAX_SAFE_EPOCH_TS)))
-        to_iso = _epoch_to_iso(max(0, min(to_ts, _MAX_SAFE_EPOCH_TS)))
+        from_iso = _epoch_to_iso(from_ts)
+        to_iso = _epoch_to_iso(to_ts)
         rows = self._fetchall(
             """SELECT * FROM shadow_comparison_verdicts
                WHERE created_at >= ? AND created_at <= ?
@@ -175,6 +168,27 @@ class ShadowVerdictsMixin:
         )
         return [_row_to_verdict(r) for r in rows]
 
+    @SQLiteStorageBase.handle_exceptions
+    def get_recent_shadow_comparison_verdicts(
+        self,
+        from_ts: int,
+        to_ts: int,
+        judge_prompt_version: str,
+        limit: int,
+    ) -> list[ShadowComparisonVerdict]:
+        from_iso = _epoch_to_iso(from_ts)
+        to_iso = _epoch_to_iso(to_ts)
+        safe_limit = max(0, limit)
+        rows = self._fetchall(
+            """SELECT * FROM shadow_comparison_verdicts
+               WHERE created_at >= ? AND created_at <= ?
+                 AND judge_prompt_version = ?
+               ORDER BY created_at DESC
+               LIMIT ?""",
+            (from_iso, to_iso, judge_prompt_version, safe_limit),
+        )
+        return [_row_to_verdict(r) for r in rows]
+
     @SQLiteStorageBase.handle_exceptions
     def delete_shadow_comparison_verdicts_by_session(self, session_id: str) -> int:
         """

package/plugin/vendor/reflexio/reflexio/server/services/storage/sqlite_storage/_stall_state.py

@@ -11,7 +11,7 @@ from __future__ import annotations
 import logging
 import sqlite3
 from dataclasses import dataclass
-from datetime import datetime
+from datetime import UTC, datetime
 from typing import Any
 
 from reflexio.models.api_schema.stall_state_schema import StallReason
@@ -163,10 +163,13 @@ def _parse_ts(raw: str | None) -> datetime | None:
     if raw is None:
         return None
     try:
-        return datetime.fromisoformat(raw)
+        parsed = datetime.fromisoformat(raw)
     except ValueError:
         _LOGGER.warning("Malformed timestamp in stall_state: %r", raw)
         return None
+    if parsed.tzinfo is None:
+        parsed = parsed.replace(tzinfo=UTC)
+    return parsed
 
 
 class SQLiteStallStateMixin:

package/plugin/vendor/reflexio/reflexio/server/services/storage/sqlite_storage/playbook/__init__.py

@@ -0,0 +1,13 @@
+from ._agent import AgentPlaybookStoreMixin
+from ._eval_results import AgentEvaluationResultStoreMixin
+from ._optimization import OptimizationJobStoreMixin
+from ._source_linkage import PlaybookSourceLinkageMixin
+from ._user import UserPlaybookStoreMixin
+
+__all__ = [
+    "AgentEvaluationResultStoreMixin",
+    "AgentPlaybookStoreMixin",
+    "OptimizationJobStoreMixin",
+    "PlaybookSourceLinkageMixin",
+    "UserPlaybookStoreMixin",
+]