claude-smart 0.2.42 → 0.2.43

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

@@ -0,0 +1,263 @@
+"""Request CRUD methods for SQLite storage."""
+
+import json
+import sqlite3
+from typing import Any
+
+from reflexio.models.api_schema.internal_schema import (
+    RequestInteractionDataModel,
+    SessionDescriptor,
+)
+from reflexio.models.api_schema.service_schemas import (
+    Request,
+)
+
+from ._base import (
+    SQLiteStorageBase,
+    _epoch_to_iso,
+    _row_to_interaction,
+    _row_to_request,
+)
+
+
+class RequestMixin:
+    """Mixin providing request CRUD operations."""
+
+    # Type hints for instance attributes/methods provided by SQLiteStorageBase via MRO
+    _lock: Any
+    conn: sqlite3.Connection
+    _execute: Any
+    _fetchone: Any
+    _fetchall: Any
+
+    # ------------------------------------------------------------------
+    # Request methods
+    # ------------------------------------------------------------------
+
+    @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),
+            ),
+        )
+
+    @SQLiteStorageBase.handle_exceptions
+    def get_request(self, request_id: str) -> Request | None:
+        row = self._fetchone(
+            "SELECT * FROM requests WHERE request_id = ?", (request_id,)
+        )
+        return _row_to_request(row) if row else None
+
+    @SQLiteStorageBase.handle_exceptions
+    def delete_request(self, request_id: str) -> None:
+        # Delete FTS entries for interactions of this request
+        ids = [
+            r["interaction_id"]
+            for r in self._fetchall(
+                "SELECT interaction_id FROM interactions WHERE request_id = ?",
+                (request_id,),
+            )
+        ]
+        if ids:
+            placeholders = ",".join("?" for _ in ids)
+            with self._lock:
+                self.conn.execute(
+                    f"DELETE FROM interactions_fts WHERE rowid IN ({placeholders})", ids
+                )
+                self.conn.commit()
+        self._execute("DELETE FROM interactions WHERE request_id = ?", (request_id,))
+        self._execute("DELETE FROM requests WHERE request_id = ?", (request_id,))
+
+    @SQLiteStorageBase.handle_exceptions
+    def delete_session(self, session_id: str) -> int:
+        rows = self._fetchall(
+            "SELECT request_id FROM requests WHERE session_id = ?", (session_id,)
+        )
+        if not rows:
+            return 0
+        request_ids = [r["request_id"] for r in rows]
+        for rid in request_ids:
+            # Delete FTS for interactions
+            iids = [
+                r["interaction_id"]
+                for r in self._fetchall(
+                    "SELECT interaction_id FROM interactions WHERE request_id = ?",
+                    (rid,),
+                )
+            ]
+            if iids:
+                ph = ",".join("?" for _ in iids)
+                with self._lock:
+                    self.conn.execute(
+                        f"DELETE FROM interactions_fts WHERE rowid IN ({ph})", iids
+                    )
+                    self.conn.commit()
+            self._execute("DELETE FROM interactions WHERE request_id = ?", (rid,))
+        self._execute("DELETE FROM requests WHERE session_id = ?", (session_id,))
+        return len(request_ids)
+
+    @SQLiteStorageBase.handle_exceptions
+    def delete_all_requests(self) -> None:
+        with self._lock:
+            self.conn.execute("DELETE FROM interactions_fts")
+            self.conn.execute("DELETE FROM interactions")
+            self.conn.execute("DELETE FROM requests")
+            self.conn.commit()
+
+    @SQLiteStorageBase.handle_exceptions
+    def delete_requests_by_ids(self, request_ids: list[str]) -> int:
+        if not request_ids:
+            return 0
+        # Delete FTS entries for interactions of these requests
+        ph = ",".join("?" for _ in request_ids)
+        interaction_ids = [
+            r["interaction_id"]
+            for r in self._fetchall(
+                f"SELECT interaction_id FROM interactions WHERE request_id IN ({ph})",
+                request_ids,
+            )
+        ]
+        if interaction_ids:
+            iph = ",".join("?" for _ in interaction_ids)
+            with self._lock:
+                self.conn.execute(
+                    f"DELETE FROM interactions_fts WHERE rowid IN ({iph})",
+                    interaction_ids,
+                )
+                self.conn.commit()
+        self._execute(
+            f"DELETE FROM interactions WHERE request_id IN ({ph})", request_ids
+        )
+        cur = self._execute(
+            f"DELETE FROM requests WHERE request_id IN ({ph})", request_ids
+        )
+        return cur.rowcount
+
+    @SQLiteStorageBase.handle_exceptions
+    def get_sessions(
+        self,
+        user_id: str | None = None,
+        request_id: str | None = None,
+        session_id: str | None = None,
+        start_time: int | None = None,
+        end_time: int | None = None,
+        top_k: int | None = 30,
+        offset: int = 0,
+    ) -> dict[str, list[RequestInteractionDataModel]]:
+        sql = "SELECT * FROM requests WHERE 1=1"
+        params: list[Any] = []
+
+        if user_id:
+            sql += " AND user_id = ?"
+            params.append(user_id)
+        if request_id:
+            sql += " AND request_id = ?"
+            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))
+
+        effective_limit = top_k or 100
+        sql += " ORDER BY created_at DESC LIMIT ? OFFSET ?"
+        params.extend([effective_limit, offset])
+
+        req_rows = self._fetchall(sql, params)
+        if not req_rows:
+            return {}
+
+        grouped: dict[str, list[RequestInteractionDataModel]] = {}
+        for rr in req_rows:
+            req = _row_to_request(rr)
+            group_name = req.session_id or ""
+            int_rows = self._fetchall(
+                "SELECT * FROM interactions WHERE request_id = ? ORDER BY created_at ASC",
+                (req.request_id,),
+            )
+            interactions = [_row_to_interaction(ir) for ir in int_rows]
+            grouped.setdefault(group_name, []).append(
+                RequestInteractionDataModel(
+                    session_id=group_name,
+                    request=req,
+                    interactions=interactions,
+                )
+            )
+        return grouped
+
+    @SQLiteStorageBase.handle_exceptions
+    def get_rerun_user_ids(
+        self,
+        user_id: str | None = None,
+        start_time: int | None = None,
+        end_time: int | None = None,
+        source: str | None = None,
+        agent_version: str | None = None,
+    ) -> list[str]:
+        sql = "SELECT DISTINCT user_id FROM requests WHERE 1=1"
+        params: list[Any] = []
+        if user_id:
+            sql += " AND user_id = ?"
+            params.append(user_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))
+        if source:
+            sql += " AND source = ?"
+            params.append(source)
+        if agent_version:
+            sql += " AND agent_version = ?"
+            params.append(agent_version)
+
+        rows = self._fetchall(sql, params)
+        return sorted(r["user_id"] for r in rows)
+
+    @SQLiteStorageBase.handle_exceptions
+    def get_requests_by_session(self, user_id: str, session_id: str) -> list[Request]:
+        rows = self._fetchall(
+            "SELECT * FROM requests WHERE user_id = ? AND session_id = ?",
+            (user_id, session_id),
+        )
+        return [_row_to_request(r) for r in rows]
+
+    @SQLiteStorageBase.handle_exceptions
+    def get_session_ids_in_window(
+        self, from_ts: int, to_ts: int
+    ) -> list[SessionDescriptor]:
+        from_iso = _epoch_to_iso(from_ts)
+        to_iso = _epoch_to_iso(to_ts)
+        rows = self._fetchall(
+            """SELECT DISTINCT user_id, session_id, agent_version, source
+               FROM requests
+               WHERE session_id IS NOT NULL
+                 AND created_at BETWEEN ? AND ?
+               ORDER BY session_id, user_id, agent_version""",
+            (from_iso, to_iso),
+        )
+        return [
+            SessionDescriptor(
+                user_id=r["user_id"],
+                session_id=r["session_id"],
+                agent_version=r["agent_version"],
+                source=r["source"],
+            )
+            for r in rows
+        ]

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

@@ -0,0 +1,193 @@
+"""SQLite CRUD for ``shadow_comparison_verdicts`` (F1)."""
+
+from __future__ import annotations
+
+import sqlite3
+from datetime import UTC, datetime
+from typing import Any
+
+from reflexio.models.api_schema.eval_overview_schema import (
+    ShadowComparisonOutput,
+    ShadowComparisonVerdict,
+)
+
+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:
+    """
+    Parse a stored ISO timestamp into a tz-aware ``datetime``.
+
+    Rows inserted with a model-provided ``created_at`` carry an explicit
+    offset (``...+00:00``). Rows that fell back to the ``CURRENT_TIMESTAMP``
+    default are tz-naive (SQLite stores ``YYYY-MM-DD HH:MM:SS``); tag those
+    as UTC to keep the dashboard math correct.
+
+    Args:
+        value (str): Stored timestamp text.
+
+    Returns:
+        datetime: A tz-aware ``datetime`` in UTC.
+    """
+    if value.endswith("Z") or "+" in value or "-" in value[10:]:
+        return datetime.fromisoformat(value)
+    # CURRENT_TIMESTAMP default — "YYYY-MM-DD HH:MM:SS" with a space, not "T".
+    iso = value.replace(" ", "T")
+    return datetime.fromisoformat(iso).replace(tzinfo=UTC)
+
+
+def _row_to_verdict(row: sqlite3.Row) -> ShadowComparisonVerdict:
+    """
+    Hydrate a ``ShadowComparisonVerdict`` from a SQLite row.
+
+    Args:
+        row (sqlite3.Row): Row from ``shadow_comparison_verdicts``.
+
+    Returns:
+        ShadowComparisonVerdict: Reconstructed verdict including the nested
+            :class:`ShadowComparisonOutput`.
+    """
+    d = dict(row)
+    return ShadowComparisonVerdict(
+        verdict_id=d["verdict_id"],
+        interaction_id=d["interaction_id"],
+        session_id=d["session_id"],
+        agent_version=d["agent_version"],
+        reflexio_is_request_1=bool(d["reflexio_is_request_1"]),
+        output=ShadowComparisonOutput(
+            better_request=d["better_request"],
+            is_significantly_better=bool(d["is_significantly_better"]),
+            comparison_reason=d.get("comparison_reason"),
+        ),
+        judge_prompt_version=d["judge_prompt_version"],
+        created_at=_parse_dt(d["created_at"]),
+    )
+
+
+class ShadowVerdictsMixin:
+    """SQLite implementation of the shadow_comparison_verdicts contract."""
+
+    # Attributes provided by SQLiteStorageBase via MRO; declared here for
+    # pyright so the @handle_exceptions decorator sees correct types.
+    conn: sqlite3.Connection
+    _execute: Any
+    _fetchone: Any
+    _fetchall: Any
+
+    @SQLiteStorageBase.handle_exceptions
+    def save_shadow_comparison_verdict(
+        self, verdict: ShadowComparisonVerdict
+    ) -> ShadowComparisonVerdict:
+        """
+        Insert a verdict and return the persisted row.
+
+        Args:
+            verdict (ShadowComparisonVerdict): Verdict to persist. The
+                ``verdict_id`` field is ignored; storage assigns the
+                autoincrement primary key.
+
+        Returns:
+            ShadowComparisonVerdict: The verdict with ``verdict_id``
+                populated from the autoincrement.
+        """
+        cur = self._execute(
+            """INSERT INTO shadow_comparison_verdicts
+               (interaction_id, session_id, agent_version,
+                reflexio_is_request_1, better_request,
+                is_significantly_better, comparison_reason,
+                judge_prompt_version, created_at)
+               VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)""",
+            (
+                verdict.interaction_id,
+                verdict.session_id,
+                verdict.agent_version,
+                1 if verdict.reflexio_is_request_1 else 0,
+                verdict.output.better_request,
+                1 if verdict.output.is_significantly_better else 0,
+                verdict.output.comparison_reason,
+                verdict.judge_prompt_version,
+                verdict.created_at.isoformat(),
+            ),
+        )
+        verdict_id = cur.lastrowid
+        return verdict.model_copy(update={"verdict_id": verdict_id})
+
+    @SQLiteStorageBase.handle_exceptions
+    def get_shadow_comparison_verdict(
+        self, verdict_id: int
+    ) -> ShadowComparisonVerdict | None:
+        """
+        Fetch a verdict by its autoincrement primary key.
+
+        Args:
+            verdict_id (int): The verdict's storage-assigned key.
+
+        Returns:
+            ShadowComparisonVerdict | None: The verdict if found, else
+                ``None``.
+        """
+        row = self._fetchone(
+            "SELECT * FROM shadow_comparison_verdicts WHERE verdict_id = ?",
+            (verdict_id,),
+        )
+        return _row_to_verdict(row) if row else None
+
+    @SQLiteStorageBase.handle_exceptions
+    def get_shadow_comparison_verdicts(
+        self,
+        from_ts: int,
+        to_ts: int,
+        judge_prompt_version: str,
+    ) -> list[ShadowComparisonVerdict]:
+        """
+        Fetch verdicts in ``[from_ts, to_ts]`` for one pinned prompt version.
+
+        Comparisons happen against stored ISO timestamps, which are
+        lexicographically orderable when expressed in UTC — see
+        :func:`_epoch_to_iso`.
+
+        Args:
+            from_ts (int): Inclusive lower bound, Unix epoch seconds (UTC).
+            to_ts (int): Inclusive upper bound, Unix epoch seconds (UTC).
+            judge_prompt_version (str): Pinned ``shadow_comparison`` prompt
+                version. Filtering by this prevents rubric-mixing in the
+                dashboard headline.
+
+        Returns:
+            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)))
+        rows = self._fetchall(
+            """SELECT * FROM shadow_comparison_verdicts
+               WHERE created_at >= ? AND created_at <= ?
+                 AND judge_prompt_version = ?
+               ORDER BY created_at ASC""",
+            (from_iso, to_iso, judge_prompt_version),
+        )
+        return [_row_to_verdict(r) for r in rows]
+
+    @SQLiteStorageBase.handle_exceptions
+    def delete_shadow_comparison_verdicts_by_session(self, session_id: str) -> int:
+        """
+        Delete all verdicts for one session.
+
+        Args:
+            session_id (str): The session whose verdicts should be removed.
+
+        Returns:
+            int: Number of rows deleted.
+        """
+        cur = self._execute(
+            "DELETE FROM shadow_comparison_verdicts WHERE session_id = ?",
+            (session_id,),
+        )
+        return cur.rowcount

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

@@ -0,0 +1,166 @@
+"""SQLite implementation of ShareLinkMixin."""
+
+from typing import Any
+
+from reflexio.models.api_schema.domain import ShareLink
+
+from ._base import (
+    SQLiteStorageBase,
+    _epoch_now,
+)
+
+
+def _row_to_share_link(row: Any) -> ShareLink:
+    """Convert a sqlite3.Row to a ShareLink model.
+
+    Args:
+        row: A sqlite3.Row from the share_links table.
+
+    Returns:
+        ShareLink: The populated model.
+    """
+    d = dict(row)
+    return ShareLink(
+        id=d["id"],
+        org_id=d["org_id"],
+        token=d["token"],
+        resource_type=d["resource_type"],
+        resource_id=d["resource_id"],
+        created_at=d["created_at"],
+        expires_at=d["expires_at"],
+        created_by_email=d["created_by_email"],
+    )
+
+
+class SQLiteShareLinkMixin:
+    """SQLite-backed share link operations."""
+
+    # Type hints for instance attributes/methods provided by SQLiteStorageBase via MRO
+    org_id: str
+    _execute: Any
+    _fetchone: Any
+    _fetchall: Any
+
+    @SQLiteStorageBase.handle_exceptions
+    def create_share_link(
+        self,
+        token: str,
+        resource_type: str,
+        resource_id: str,
+        expires_at: int | None,
+        created_by_email: str | None,
+    ) -> ShareLink:
+        """Create a new share link.
+
+        Args:
+            token (str): The share token (unique).
+            resource_type (str): Type of resource (e.g., "profile", "user_playbook").
+            resource_id (str): ID of the resource being shared.
+            expires_at (int | None): Optional Unix timestamp of expiration.
+            created_by_email (str | None): Optional email of creator.
+
+        Returns:
+            ShareLink: The created share link with id and created_at populated.
+        """
+        now = _epoch_now()
+        cur = self._execute(
+            """INSERT INTO share_links
+               (org_id, token, resource_type, resource_id, created_at, expires_at, created_by_email)
+               VALUES (?, ?, ?, ?, ?, ?, ?)""",
+            (
+                self.org_id,
+                token,
+                resource_type,
+                resource_id,
+                now,
+                expires_at,
+                created_by_email,
+            ),
+        )
+        return ShareLink(
+            id=cur.lastrowid,
+            org_id=self.org_id,
+            token=token,
+            resource_type=resource_type,
+            resource_id=resource_id,
+            created_at=now,
+            expires_at=expires_at,
+            created_by_email=created_by_email,
+        )
+
+    @SQLiteStorageBase.handle_exceptions
+    def get_share_link_by_token(self, token: str) -> ShareLink | None:
+        """Look up a share link by its token.
+
+        Args:
+            token (str): The share token.
+
+        Returns:
+            ShareLink | None: The share link if found, else None.
+        """
+        row = self._fetchone(
+            "SELECT * FROM share_links WHERE org_id = ? AND token = ?",
+            (self.org_id, token),
+        )
+        return _row_to_share_link(row) if row else None
+
+    @SQLiteStorageBase.handle_exceptions
+    def get_share_link_by_resource(
+        self, resource_type: str, resource_id: str
+    ) -> ShareLink | None:
+        """Look up an existing share link for a specific resource.
+
+        Args:
+            resource_type (str): Type of resource.
+            resource_id (str): ID of the resource.
+
+        Returns:
+            ShareLink | None: The existing share link if any, else None.
+        """
+        row = self._fetchone(
+            "SELECT * FROM share_links WHERE org_id = ? AND resource_type = ? AND resource_id = ?",
+            (self.org_id, resource_type, resource_id),
+        )
+        return _row_to_share_link(row) if row else None
+
+    @SQLiteStorageBase.handle_exceptions
+    def get_share_links(self) -> list[ShareLink]:
+        """Return all share links for this org.
+
+        Returns:
+            list[ShareLink]: All share links, ordered by created_at ascending.
+        """
+        rows = self._fetchall(
+            "SELECT * FROM share_links WHERE org_id = ? ORDER BY created_at ASC",
+            (self.org_id,),
+        )
+        return [_row_to_share_link(row) for row in rows]
+
+    @SQLiteStorageBase.handle_exceptions
+    def delete_share_link(self, link_id: int) -> bool:
+        """Delete a share link by ID.
+
+        Args:
+            link_id (int): The share link ID.
+
+        Returns:
+            bool: True if deleted, False if not found.
+        """
+        cur = self._execute(
+            "DELETE FROM share_links WHERE org_id = ? AND id = ?",
+            (self.org_id, link_id),
+        )
+        return cur.rowcount > 0
+
+    @SQLiteStorageBase.handle_exceptions
+    def delete_all_share_links(self) -> int:
+        """Delete all share links for this org.
+
+        Returns:
+            int: Number of links deleted.
+        """
+        cur = self._execute(
+            "DELETE FROM share_links WHERE org_id = ?",
+            (self.org_id,),
+        )
+        return cur.rowcount