claude-smart 0.2.41 → 0.2.43

package/plugin/vendor/reflexio/reflexio/server/services/storage/storage_base/_profiles.py

@@ -0,0 +1,250 @@
+from abc import abstractmethod
+
+from reflexio.models.api_schema.domain import (
+    DeleteUserInteractionRequest,
+    DeleteUserProfileRequest,
+    Interaction,
+    Status,
+    UserProfile,
+)
+from reflexio.models.api_schema.retriever_schema import (
+    SearchInteractionRequest,
+    SearchUserProfileRequest,
+)
+
+
+class ProfileMixin:
+    """Mixin for profile and interaction CRUD methods."""
+
+    # read methods
+    @abstractmethod
+    def get_all_profiles(
+        self,
+        limit: int = 100,
+        status_filter: list[Status | None] | None = None,
+    ) -> list[UserProfile]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def get_all_interactions(self, limit: int = 100) -> list[Interaction]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def get_user_profile(
+        self,
+        user_id: str,
+        status_filter: list[Status | None] | None = None,
+    ) -> list[UserProfile]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def get_user_interaction(self, user_id: str) -> list[Interaction]:
+        raise NotImplementedError
+
+    # create or update methods
+    @abstractmethod
+    def add_user_profile(self, user_id: str, user_profiles: list[UserProfile]) -> None:
+        """Add the user profile for a given user id."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def add_user_interaction(self, user_id: str, interaction: Interaction) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def add_user_interactions_bulk(
+        self, user_id: str, interactions: list[Interaction]
+    ) -> None:
+        """Add multiple user interactions with batched embedding generation.
+
+        Args:
+            user_id: The user ID
+            interactions: List of interactions to add
+        """
+        raise NotImplementedError
+
+    # delete methods
+    @abstractmethod
+    def delete_user_interaction(self, request: DeleteUserInteractionRequest) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def delete_user_profile(self, request: DeleteUserProfileRequest) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def update_user_profile_by_id(
+        self, user_id: str, profile_id: str, new_profile: UserProfile
+    ) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def delete_all_interactions_for_user(self, user_id: str) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def delete_all_profiles_for_user(self, user_id: str) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def delete_all_profiles(self) -> None:
+        """Delete all profiles across all users."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def delete_all_interactions(self) -> None:
+        """Delete all interactions across all users."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def count_all_interactions(self) -> int:
+        """Count total interactions across all users.
+
+        Returns:
+            int: Total number of interactions
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def count_all_profiles(self) -> int:
+        """Count total profiles across all users without hydrating rows.
+
+        Cheap alternative to ``len(get_all_profiles(...))`` — avoids
+        loading every profile row (including embedding BLOBs) just to
+        take a count. Used by publish-path diagnostics that snapshot
+        totals before and after a run.
+
+        Returns:
+            int: Total number of profiles across all users
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def delete_oldest_interactions(self, count: int) -> int:
+        """Delete the oldest N interactions based on created_at timestamp.
+
+        Args:
+            count (int): Number of oldest interactions to delete
+
+        Returns:
+            int: Number of interactions actually deleted
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def update_all_profiles_status(
+        self,
+        old_status: Status | None,
+        new_status: Status | None,
+        user_ids: list[str] | None = None,
+    ) -> int:
+        """Update all profiles with old_status to new_status atomically.
+
+        Args:
+            old_status: The current status to match (None for CURRENT)
+            new_status: The new status to set (None for CURRENT)
+            user_ids: Optional list of user_ids to filter updates. If None, updates all users.
+
+        Returns:
+            int: Number of profiles updated
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def get_profiles_by_ids(
+        self,
+        user_id: str,
+        profile_ids: list[str],
+        status_filter: list[Status | None] | None = None,
+    ) -> list[UserProfile]:
+        """Fetch the subset of a user's profiles whose ids are in the list.
+
+        Server-side filter on (``user_id``, ``profile_id IN (...)``) so
+        callers (e.g. the reflection service resolving a small set of
+        cited profile ids) avoid scanning every profile for the user.
+
+        Args:
+            user_id (str): Owning user id.
+            profile_ids (list[str]): Profile ids to fetch. Empty list
+                returns ``[]`` without hitting storage.
+            status_filter (list[Status | None] | None): Statuses to
+                include. ``None`` (default) means CURRENT only — same
+                default as ``get_user_profile`` for consistency.
+
+        Returns:
+            list[UserProfile]: Matching profiles. Order is unspecified.
+                Ids that do not exist (or do not match the user / status
+                filter) are silently omitted.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def archive_profile_by_id(self, user_id: str, profile_id: str) -> bool:
+        """Atomically archive a single profile by id, only if currently CURRENT.
+
+        Flips the row's ``status`` from ``None`` (CURRENT) to
+        ``Status.ARCHIVED``. No-op when the profile does not exist or is
+        already non-current.
+
+        Args:
+            user_id (str): Owning user id.
+            profile_id (str): The profile id to archive.
+
+        Returns:
+            bool: True if a row was archived; False otherwise.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def delete_all_profiles_by_status(self, status: Status) -> int:
+        """Delete all profiles with the given status atomically.
+
+        Args:
+            status: The status of profiles to delete
+
+        Returns:
+            int: Number of profiles deleted
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def get_user_ids_with_status(self, status: Status | None) -> list[str]:
+        """Get list of unique user_ids that have profiles with the given status.
+
+        Args:
+            status: The status to filter by (None for CURRENT)
+
+        Returns:
+            list[str]: List of unique user_ids
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def delete_profiles_by_ids(self, profile_ids: list[str]) -> int:
+        """Delete profiles by their IDs.
+
+        Args:
+            profile_ids (list[str]): List of profile IDs to delete
+
+        Returns:
+            int: Number of profiles deleted
+        """
+        raise NotImplementedError
+
+    # Search methods
+    @abstractmethod
+    def search_interaction(
+        self,
+        search_interaction_request: SearchInteractionRequest,
+        query_embedding: list[float] | None = None,
+    ) -> list[Interaction]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def search_user_profile(
+        self,
+        search_user_profile_request: SearchUserProfileRequest,
+        status_filter: list[Status | None] | None = None,
+        query_embedding: list[float] | None = None,
+    ) -> list[UserProfile]:
+        raise NotImplementedError

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

@@ -0,0 +1,154 @@
+from abc import abstractmethod
+
+from reflexio.models.api_schema.domain import Request
+from reflexio.models.api_schema.internal_schema import (
+    RequestInteractionDataModel,
+    SessionDescriptor,
+)
+
+
+class RequestMixin:
+    """Mixin for request CRUD methods."""
+
+    @abstractmethod
+    def add_request(self, request: Request) -> None:
+        """Add a request to storage.
+
+        Args:
+            request: Request object to store
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def get_request(self, request_id: str) -> Request | None:
+        """Get a request by its ID.
+
+        Args:
+            request_id: The request ID to retrieve
+
+        Returns:
+            Request object if found, None otherwise
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def delete_request(self, request_id: str) -> None:
+        """Delete a request by its ID.
+
+        Args:
+            request_id: The request ID to delete
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def delete_session(self, session_id: str) -> int:
+        """Delete all requests and interactions in a session.
+
+        Args:
+            session_id: The session ID to delete
+
+        Returns:
+            int: Number of requests deleted
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def delete_all_requests(self) -> None:
+        """Delete all requests and their associated interactions."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def delete_requests_by_ids(self, request_ids: list[str]) -> int:
+        """Delete requests and their associated interactions by request IDs.
+
+        Args:
+            request_ids (list[str]): List of request IDs to delete
+
+        Returns:
+            int: Number of requests deleted
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    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]]:
+        """Get requests with their associated interactions, grouped by session_id.
+
+        Args:
+            user_id (str, optional): User ID to filter requests.
+            request_id (str, optional): Specific request ID to retrieve
+            session_id (str, optional): Specific session ID to retrieve
+            start_time (int, optional): Start timestamp for filtering
+            end_time (int, optional): End timestamp for filtering
+            top_k (int, optional): Maximum number of requests to return
+            offset (int): Number of requests to skip for pagination. Defaults to 0.
+
+        Returns:
+            dict[str, list[RequestInteractionDataModel]]: Dictionary mapping session_id to list of RequestInteractionDataModel objects
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    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]:
+        """Get distinct user IDs that have matching requests for rerun workflows.
+
+        Args:
+            user_id (str, optional): Restrict to a specific user ID.
+            start_time (int, optional): Start timestamp for request filtering.
+            end_time (int, optional): End timestamp for request filtering.
+            source (str, optional): Restrict to requests from a source.
+            agent_version (str, optional): Restrict to requests with an agent version.
+
+        Returns:
+            list[str]: Distinct user IDs matching the filters.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def get_requests_by_session(self, user_id: str, session_id: str) -> list[Request]:
+        """Get all requests for a specific session.
+
+        Args:
+            user_id (str): User ID to filter requests
+            session_id (str): Session ID to filter by
+
+        Returns:
+            list[Request]: List of Request objects in the session
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def get_session_ids_in_window(
+        self, from_ts: int, to_ts: int
+    ) -> list[SessionDescriptor]:
+        """Return one descriptor per distinct (user_id, session_id, agent_version, source) tuple with at least one request whose ``created_at`` falls inside ``[from_ts, to_ts]``.
+
+        A session that records requests under multiple ``agent_version`` or
+        ``source`` values within the window yields one descriptor per distinct
+        combination, so regen workers can invoke ``run_group_evaluation`` once
+        per (user, session, agent_version, source) tuple without conflating
+        runs from different agent versions.
+
+        Args:
+            from_ts (int): Inclusive lower bound (Unix seconds).
+            to_ts (int): Inclusive upper bound (Unix seconds).
+
+        Returns:
+            list[SessionDescriptor]: Deduped descriptors ordered by session_id.
+        """
+        raise NotImplementedError

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

@@ -0,0 +1,130 @@
+"""Storage interface for per-turn shadow comparison verdicts (F1).
+
+Declares the methods every storage implementation MAY implement to expose the
+``shadow_comparison_verdicts`` table used by the per-turn Reflexio-vs-Shadow
+comparison feature.
+
+The default implementations raise :class:`NotImplementedError`. Concrete
+backends that support the feature (currently :class:`SQLiteStorage`) override
+these methods via their own mixin. Backends that don't (currently
+:class:`DiskStorage`, :class:`SupabaseStorage` — added in later tasks) will
+surface a clear ``NotImplementedError`` at call time rather than
+``AttributeError``.
+
+This intentionally follows the :class:`StallStateMixin` precedent so adding
+a new backend-optional feature does not break the instantiation contract of
+existing backends.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from reflexio.models.api_schema.eval_overview_schema import (
+        ShadowComparisonVerdict,
+    )
+
+
+class ShadowVerdictsMixin:
+    """Default no-op shadow_comparison_verdicts interface for storage backends.
+
+    Subclasses that support the feature must override every method. The
+    methods below raise :class:`NotImplementedError` so callers see a
+    clear error message naming the backend rather than ``AttributeError``.
+    """
+
+    def save_shadow_comparison_verdict(
+        self, verdict: ShadowComparisonVerdict
+    ) -> ShadowComparisonVerdict:
+        """Persist a verdict and return the row with the assigned ``verdict_id``.
+
+        Args:
+            verdict (ShadowComparisonVerdict): The verdict to persist. The
+                ``verdict_id`` field is ignored on save — storage assigns
+                the autoincrement key.
+
+        Returns:
+            ShadowComparisonVerdict: The same verdict with ``verdict_id``
+                replaced by the storage-assigned primary key.
+
+        Raises:
+            NotImplementedError: When the backend does not support shadow
+                comparison verdicts.
+        """
+        raise NotImplementedError(
+            f"{type(self).__name__} does not support shadow_comparison_verdicts"
+        )
+
+    def get_shadow_comparison_verdict(
+        self, verdict_id: int
+    ) -> ShadowComparisonVerdict | None:
+        """Fetch one verdict by its autoincrement primary key.
+
+        Args:
+            verdict_id (int): The storage-assigned key returned by
+                :meth:`save_shadow_comparison_verdict`.
+
+        Returns:
+            ShadowComparisonVerdict | None: The verdict if present, else
+                ``None``.
+
+        Raises:
+            NotImplementedError: When the backend does not support shadow
+                comparison verdicts.
+        """
+        raise NotImplementedError(
+            f"{type(self).__name__} does not support shadow_comparison_verdicts"
+        )
+
+    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.
+
+        Args:
+            from_ts (int): Inclusive lower bound of ``created_at``, in Unix
+                epoch seconds (UTC).
+            to_ts (int): Inclusive upper bound of ``created_at``, in Unix
+                epoch seconds (UTC).
+            judge_prompt_version (str): The pinned ``shadow_comparison``
+                prompt version. Filtering by this prevents rubric-mixing in
+                the dashboard headline metric — verdicts produced under an
+                older rubric stay in storage but do not contaminate the
+                current trend.
+
+        Returns:
+            list[ShadowComparisonVerdict]: Matching verdicts in chronological
+                order (ascending ``created_at``).
+
+        Raises:
+            NotImplementedError: When the backend does not support shadow
+                comparison verdicts.
+        """
+        raise NotImplementedError(
+            f"{type(self).__name__} does not support shadow_comparison_verdicts"
+        )
+
+    def delete_shadow_comparison_verdicts_by_session(self, session_id: str) -> int:
+        """Remove all verdicts for one session.
+
+        Used by the regen worker's delete-after-save pattern: a re-eval
+        run computes fresh verdicts, persists them, then clears the prior
+        ones to avoid double-counting.
+
+        Args:
+            session_id (str): The session whose verdicts should be removed.
+
+        Returns:
+            int: Number of rows deleted.
+
+        Raises:
+            NotImplementedError: When the backend does not support shadow
+                comparison verdicts.
+        """
+        raise NotImplementedError(
+            f"{type(self).__name__} does not support shadow_comparison_verdicts"
+        )

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

@@ -0,0 +1,93 @@
+"""Abstract ShareLink storage operations.
+
+Each BaseStorage subclass (SQLite, Supabase, Postgres) must implement these methods.
+Storage instances are org-scoped, so org_id is not a method parameter.
+"""
+
+from abc import abstractmethod
+
+from reflexio.models.api_schema.domain import ShareLink
+
+
+class ShareLinkMixin:
+    """Mixin defining share link CRUD operations on a per-org data storage."""
+
+    @abstractmethod
+    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.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    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.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    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 (for dedup).
+
+        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.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    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.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    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.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def delete_all_share_links(self) -> int:
+        """Delete all share links for this org.
+
+        Returns:
+            int: Number of links deleted.
+        """
+        raise NotImplementedError

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

@@ -0,0 +1,76 @@
+"""Stall state interface for storage backends.
+
+Declares the methods every storage implementation MUST implement to expose
+the singleton stall_state row used by the credit-stall notification flow.
+
+The default implementations raise :class:`NotImplementedError`. Concrete
+backends that support the stall_state feature override these methods via
+their own mixin. Backends without stall_state support will surface a clear
+``NotImplementedError`` at call time rather than ``AttributeError``.
+"""
+
+from __future__ import annotations
+
+from datetime import datetime
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from reflexio.server.services.storage.sqlite_storage._stall_state import (
+        StallReason,
+        StallState,
+    )
+
+
+class StallStateMixin:
+    """Default no-op stall_state interface for storage backends.
+
+    Subclasses that support the stall_state feature must override every method.
+    """
+
+    def get_stall_state(self) -> StallState:
+        """Return the current stall row.
+
+        Returns:
+            StallState: Current snapshot of the singleton stall row.
+
+        Raises:
+            NotImplementedError: When the backend does not support stall_state.
+        """
+        raise NotImplementedError(f"{type(self).__name__} does not support stall_state")
+
+    def upsert_stall_state(
+        self,
+        *,
+        reason: StallReason,
+        stalled_at: datetime,
+        reset_estimate: datetime | None,
+        error_message: str,
+    ) -> None:
+        """Mark the singleton as stalled with the given reason.
+
+        Args:
+            reason (StallReason): The stall reason discriminator.
+            stalled_at (datetime): When the stall was first detected.
+            reset_estimate (datetime | None): Estimated reset time, if known.
+            error_message (str): Raw error text for debugging.
+
+        Raises:
+            NotImplementedError: When the backend does not support stall_state.
+        """
+        raise NotImplementedError(f"{type(self).__name__} does not support stall_state")
+
+    def mark_stall_notified(self) -> None:
+        """Set ``notified_in_cc=1`` for the current stall.
+
+        Raises:
+            NotImplementedError: When the backend does not support stall_state.
+        """
+        raise NotImplementedError(f"{type(self).__name__} does not support stall_state")
+
+    def clear_stall_state(self) -> None:
+        """Mark the singleton clean — clears all stall fields atomically.
+
+        Raises:
+            NotImplementedError: When the backend does not support stall_state.
+        """
+        raise NotImplementedError(f"{type(self).__name__} does not support stall_state")