claude-smart 0.2.46 → 0.2.48

package/plugin/vendor/reflexio/reflexio/server/services/storage/storage_base/playbook/_source_linkage.py

@@ -0,0 +1,47 @@
+"""Abstract agent playbook source-linkage declarations."""
+
+from abc import abstractmethod
+from collections.abc import Sequence
+
+from reflexio.models.api_schema.domain import AgentPlaybookSourceWindow
+
+
+class PlaybookSourceLinkageMixin:
+    """Abstract agent playbook source-linkage methods."""
+
+    @abstractmethod
+    def set_source_user_playbook_ids_for_agent_playbook(
+        self, agent_playbook_id: int, user_playbook_ids: list[int]
+    ) -> None:
+        """Persist the source user playbook ids that produced an agent playbook."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def get_source_user_playbook_ids_for_agent_playbook(
+        self, agent_playbook_id: int
+    ) -> list[int]:
+        """Return source user playbook ids for an agent playbook."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def get_source_user_playbook_ids_for_agent_playbooks(
+        self, agent_playbook_ids: Sequence[int]
+    ) -> dict[int, list[int]]:
+        """Return source user playbook ids keyed by agent playbook id."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def set_source_windows_for_agent_playbook(
+        self,
+        agent_playbook_id: int,
+        source_windows: list[AgentPlaybookSourceWindow],
+    ) -> None:
+        """Persist replayable source windows that produced an agent playbook."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def get_source_windows_for_agent_playbook(
+        self, agent_playbook_id: int
+    ) -> list[AgentPlaybookSourceWindow]:
+        """Return replayable source windows for an agent playbook."""
+        raise NotImplementedError

package/plugin/vendor/reflexio/reflexio/server/services/storage/storage_base/playbook/_user.py

@@ -0,0 +1,333 @@
+"""Abstract user playbook CRUD + search declarations."""
+
+from abc import abstractmethod
+
+from reflexio.models.api_schema.common import BlockingIssue
+from reflexio.models.api_schema.domain import Status, UserPlaybook
+from reflexio.models.api_schema.retriever_schema import SearchUserPlaybookRequest
+from reflexio.models.config_schema import SearchOptions
+
+
+class UserPlaybookStoreMixin:
+    """Abstract user playbook CRUD + search methods."""
+
+    @abstractmethod
+    def save_user_playbooks(self, user_playbooks: list[UserPlaybook]) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def get_user_playbooks(
+        self,
+        limit: int = 100,
+        user_id: str | None = None,
+        playbook_name: str | None = None,
+        agent_version: str | None = None,
+        status_filter: list[Status | None] | None = None,
+        start_time: int | None = None,
+        end_time: int | None = None,
+        include_embedding: bool = False,
+        tags: list[str] | None = None,
+        offset: int = 0,
+        user_playbook_id: int | None = None,
+        request_id: str | None = None,
+        query: str | None = None,
+    ) -> list[UserPlaybook]:
+        """Get user playbooks from storage.
+
+        Args:
+            limit (int): Maximum number of playbooks to return
+            user_playbook_id (int, optional): Exact user playbook ID to retrieve.
+            user_id (str, optional): The user ID to filter by. If None, returns playbooks for all users.
+            request_id (str, optional): Request ID that generated the playbook.
+            query (str, optional): Case-insensitive text filter across visible fields.
+            playbook_name (str, optional): The playbook name to filter by. If None, returns all user playbooks.
+            agent_version (str, optional): The agent version to filter by. If None, returns all agent versions.
+            status_filter (list[Optional[Status]], optional): List of status values to filter by.
+                Can include None (current), Status.PENDING (from rerun), Status.ARCHIVED (old).
+                If None, returns playbooks with all statuses.
+            start_time (int, optional): Unix timestamp. Only return playbooks created at or after this time.
+            end_time (int, optional): Unix timestamp. Only return playbooks created at or before this time.
+            include_embedding (bool): If True, fetch and parse embedding vectors. Defaults to False.
+            tags (list[str], optional): Match playbooks having any of these tags.
+            offset (int): Number of matching rows to skip. Defaults to 0.
+
+        Returns:
+            list[UserPlaybook]: List of user playbook objects
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def count_user_playbooks(
+        self,
+        user_id: str | None = None,
+        playbook_name: str | None = None,
+        min_user_playbook_id: int | None = None,
+        agent_version: str | None = None,
+        status_filter: list[Status | None] | None = None,
+    ) -> int:
+        """Count user playbooks in storage efficiently.
+
+        Args:
+            user_id (str, optional): The user ID to filter by. If None, counts playbooks for all users.
+            playbook_name (str, optional): The playbook name to filter by. If None, counts all user playbooks.
+            min_user_playbook_id (int, optional): Only count playbooks with user_playbook_id greater than this value.
+            agent_version (str, optional): The agent version to filter by. If None, counts all agent versions.
+            status_filter (list[Optional[Status]], optional): List of status values to filter by.
+                Can include None (current), Status.PENDING (from rerun), Status.ARCHIVED (old).
+                If None, returns playbooks with all statuses.
+
+        Returns:
+            int: Count of user playbooks matching the filters
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def count_user_playbooks_by_session(self, session_id: str) -> int:
+        """Count user playbooks linked to a session via request_id -> requests.session_id.
+
+        Args:
+            session_id (str): The session ID to count user playbooks for
+
+        Returns:
+            int: Count of user playbooks linked to the session
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def delete_all_user_playbooks(self) -> None:
+        """Delete all user playbooks from storage."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def delete_all_user_playbooks_by_playbook_name(
+        self, playbook_name: str, agent_version: str | None = None
+    ) -> None:
+        """Delete all user playbooks by playbook name from storage.
+
+        Args:
+            playbook_name (str): The playbook name to delete
+            agent_version (str, optional): The agent version to filter by. If None, deletes all agent versions.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def delete_user_playbook(self, user_playbook_id: int) -> None:
+        """Delete a user playbook by ID.
+
+        Args:
+            user_playbook_id (int): The ID of the user playbook to delete
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def update_all_user_playbooks_status(
+        self,
+        old_status: Status | None,
+        new_status: Status | None,
+        agent_version: str | None = None,
+        playbook_name: str | None = None,
+    ) -> int:
+        """Update all user playbooks 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)
+            agent_version: Optional filter by agent version
+            playbook_name: Optional filter by playbook name
+
+        Returns:
+            int: Number of user playbooks updated
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def delete_all_user_playbooks_by_status(
+        self,
+        status: Status,
+        agent_version: str | None = None,
+        playbook_name: str | None = None,
+    ) -> int:
+        """Delete all user playbooks with the given status atomically.
+
+        Args:
+            status: The status of user playbooks to delete
+            agent_version: Optional filter by agent version
+            playbook_name: Optional filter by playbook name
+
+        Returns:
+            int: Number of user playbooks deleted
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def delete_user_playbooks_by_ids(
+        self, user_playbook_ids: list[int], *, emit_hard_delete: bool = True
+    ) -> int:
+        """Delete user playbooks by their IDs.
+
+        Args:
+            user_playbook_ids: List of user_playbook_id values to delete
+            emit_hard_delete: When True (default), append a ``hard_delete``
+                lineage event per id (genuine erasure). Set False for rollback
+                cleanup of a never-live row (e.g. a lost supersede CAS), so no
+                spurious audit event is recorded.
+
+        Returns:
+            int: Number of user playbooks deleted
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def get_user_playbooks_by_ids(
+        self,
+        user_id: str,
+        user_playbook_ids: list[int],
+        status_filter: list[Status | None] | None = None,
+    ) -> list[UserPlaybook]:
+        """Fetch the subset of a user's playbooks whose ids are in the list.
+
+        Server-side filter on (``user_id``, ``user_playbook_id IN (...)``)
+        so callers (e.g. the reflection service resolving a small set of
+        cited playbook ids) avoid scanning every playbook for the user.
+
+        Args:
+            user_id (str): Owning user id.
+            user_playbook_ids (list[int]): Playbook 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_playbooks`` for consistency.
+
+        Returns:
+            list[UserPlaybook]: Matching playbooks. Order is unspecified.
+                Ids that do not exist (or do not match the user / status
+                filter) are silently omitted.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def get_user_playbook_by_id(
+        self, user_playbook_id: int, *, include_tombstones: bool = False
+    ) -> UserPlaybook | None:
+        """Fetch one user playbook by primary key.
+
+        Args:
+            user_playbook_id: The user_playbook_id to look up.
+            include_tombstones: When False (default), MERGED/SUPERSEDED rows
+                return None. Set to True for lineage resolution (resolve_current).
+
+        Returns:
+            The UserPlaybook if found and not filtered, otherwise None.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def get_user_playbooks_by_ids_any_user(
+        self,
+        user_playbook_ids: list[int],
+        status_filter: list[Status | None] | None = None,
+    ) -> list[UserPlaybook]:
+        """Fetch user playbooks by ids without requiring a single owner id."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def archive_user_playbook_by_id(self, user_id: str, user_playbook_id: int) -> bool:
+        """Atomically archive a single user playbook by id, only if CURRENT.
+
+        Flips the row's ``status`` from ``None`` (CURRENT) to
+        ``Status.ARCHIVED``. No-op when the playbook does not exist, has
+        a different ``user_id``, or is already non-current.
+
+        Args:
+            user_id (str): Owning user id; used as a guard so callers
+                cannot accidentally archive another user's playbook.
+            user_playbook_id (int): The user_playbook_id to archive.
+
+        Returns:
+            bool: True if a row was archived; False otherwise.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def has_user_playbooks_with_status(
+        self,
+        status: Status | None,
+        agent_version: str | None = None,
+        playbook_name: str | None = None,
+    ) -> bool:
+        """Check if any user playbooks exist with given status and filters.
+
+        Args:
+            status: The status to check for (None for CURRENT)
+            agent_version: Optional filter by agent version
+            playbook_name: Optional filter by playbook name
+
+        Returns:
+            bool: True if any matching user playbooks exist
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def update_user_playbook(
+        self,
+        user_playbook_id: int,
+        playbook_name: str | None = None,
+        content: str | None = None,
+        trigger: str | None = None,
+        rationale: str | None = None,
+        blocking_issue: BlockingIssue | None = None,
+        tags: list[str] | None = None,
+    ) -> None:
+        """Update editable fields of a user playbook. Only non-None fields are updated.
+
+        Args:
+            user_playbook_id (int): The ID of the user playbook to update
+            playbook_name (str, optional): New playbook name
+            content (str, optional): New content text
+            trigger (str, optional): New trigger text
+            rationale (str, optional): New rationale text
+            blocking_issue (BlockingIssue, optional): New blocking issue
+            tags (list[str], optional): Replacement tags
+
+        Raises:
+            ValueError: If user playbook with the given ID is not found
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def supersede_user_playbooks_by_ids(
+        self, user_playbook_ids: list[int], request_id: str
+    ) -> int:
+        """Soft-delete user playbooks by setting status to SUPERSEDED.
+
+        Eligible rows (CURRENT, PENDING, or ARCHIVED; not already MERGED /
+        SUPERSEDED) are transitioned to SUPERSEDED and emit one status_change
+        lineage event under the shared request id. This is the user-playbook
+        analogue of the existing agent/profile soft-supersede helpers and
+        preserves dead-source content for point-in-time attribution reads.
+
+        Args:
+            user_playbook_ids (list[int]): User playbook ids to supersede.
+            request_id (str): Shared request id for all emitted lineage events.
+
+        Returns:
+            int: Number of user playbooks actually updated.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def search_user_playbooks(
+        self,
+        request: SearchUserPlaybookRequest,
+        options: SearchOptions | None = None,
+    ) -> list[UserPlaybook]:
+        """Search user playbooks with advanced filtering including semantic search.
+
+        Args:
+            request (SearchUserPlaybookRequest): Search request with query, filters, and pagination
+            options (SearchOptions, optional): Engine-level search parameters (e.g. pre-computed embedding)
+
+        Returns:
+            list[UserPlaybook]: List of matching user playbook objects
+        """
+        raise NotImplementedError

package/plugin/vendor/reflexio/reflexio/server/services/storage/storage_base/profiles/__init__.py

@@ -0,0 +1,9 @@
+from ._interaction_store import InteractionStoreMixin
+from ._profile_store import ProfileStoreMixin
+from ._search import ProfileSearchMixin
+
+__all__ = [
+    "InteractionStoreMixin",
+    "ProfileSearchMixin",
+    "ProfileStoreMixin",
+]

package/plugin/vendor/reflexio/reflexio/server/services/storage/storage_base/profiles/_interaction_store.py

@@ -0,0 +1,73 @@
+from abc import abstractmethod
+
+from reflexio.models.api_schema.domain import (
+    DeleteUserInteractionRequest,
+    Interaction,
+)
+
+
+class InteractionStoreMixin:
+    """Mixin for interaction-store CRUD methods."""
+
+    @abstractmethod
+    def get_all_interactions(self, limit: int = 100) -> list[Interaction]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def get_user_interaction(self, user_id: str) -> list[Interaction]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def get_all_user_ids(self) -> list[str]:
+        """Return distinct user IDs that have stored interactions."""
+        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
+
+    @abstractmethod
+    def delete_user_interaction(self, request: DeleteUserInteractionRequest) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def delete_all_interactions_for_user(self, user_id: str) -> None:
+        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 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

package/plugin/vendor/reflexio/reflexio/server/services/storage/storage_base/{_profiles.py → profiles/_profile_store.py}

@@ -1,72 +1,73 @@
 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."""
+class ProfileStoreMixin:
+    """Mixin for profile-store CRUD methods."""
 
-    # read methods
     @abstractmethod
     def get_all_profiles(
         self,
         limit: int = 100,
         status_filter: list[Status | None] | None = None,
+        user_id: str | None = None,
+        profile_id: str | None = None,
+        query: str | None = None,
+        source: str | None = None,
+        profile_time_to_live: str | None = None,
+        start_time: int | None = None,
+        end_time: int | 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,
         tags: list[str] | None = None,
+        profile_id: str | None = None,
+        query: str | None = None,
+        source: str | None = None,
+        profile_time_to_live: str | None = None,
+        start_time: int | None = None,
+        end_time: int | None = None,
+        include_expired: bool = False,
     ) -> 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.
+        """Return profiles for a user, optionally including expired rows.
 
         Args:
-            user_id: The user ID
-            interactions: List of interactions to add
+            user_id: The user whose profiles to return.
+            status_filter: Statuses to include (``None`` element = CURRENT).
+                Defaults to ``[None]`` (CURRENT only) when not supplied.
+            tags: If provided, only return profiles whose ``tags`` overlap.
+            profile_id: If provided, filter to this exact profile id.
+            query: Free-text substring match across content, profile_id, user_id.
+            source: If provided, filter to this exact source value.
+            profile_time_to_live: If provided, filter to this TTL value.
+            start_time: If provided, lower bound on last_modified_timestamp.
+            end_time: If provided, upper bound on last_modified_timestamp.
+            include_expired: When ``False`` (default), rows whose
+                ``expiration_timestamp`` is in the past are excluded
+                (byte-for-byte prior behaviour — every existing caller is
+                unaffected).  Pass ``True`` to omit the expiry filter so
+                EXPIRED tombstones (``expiration_timestamp < now``) are
+                returned.  Required by ``clear_user_data`` to reach every
+                profile a user owns regardless of TTL state.
+
+        Returns:
+            list[UserProfile]: Matching profiles in unspecified order.
         """
         raise NotImplementedError
 
-    # delete methods
     @abstractmethod
-    def delete_user_interaction(self, request: DeleteUserInteractionRequest) -> None:
+    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
@@ -86,10 +87,6 @@ class ProfileMixin:
         """Replace only the tags of a profile, leaving content and embedding untouched."""
         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
@@ -99,20 +96,6 @@ class ProfileMixin:
         """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.
@@ -127,18 +110,6 @@ class ProfileMixin:
         """
         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,
@@ -158,6 +129,24 @@ class ProfileMixin:
         """
         raise NotImplementedError
 
+    @abstractmethod
+    def expire_active_profiles(self, *, now: int, limit: int = 1000) -> int:
+        """Tombstone active profiles whose TTL has elapsed.
+
+        Selects ``status IS NULL AND expiration_timestamp < now`` and transitions
+        each to ``status=EXPIRED, retired_at=now``, emitting a ``status_change``
+        lineage event (reason ``ttl-expired``). Returns the number tombstoned.
+
+        Args:
+            now: Current epoch timestamp (seconds). Profiles with
+                ``expiration_timestamp < now`` are tombstoned.
+            limit: Maximum number of profiles to tombstone in one call (default 1000).
+
+        Returns:
+            int: Number of profiles tombstoned.
+        """
+        raise NotImplementedError
+
     @abstractmethod
     def get_profiles_by_ids(
         self,
@@ -350,21 +339,3 @@ class ProfileMixin:
                 commit-atomic legacy change-log "removed" entry.
         """
         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