claude-smart 0.2.42 → 0.2.43

package/plugin/vendor/reflexio/reflexio/lib/_search.py

@@ -0,0 +1,167 @@
+import logging
+
+from reflexio.lib._base import STORAGE_NOT_CONFIGURED_MSG, ReflexioBase
+from reflexio.models.api_schema.retriever_schema import (
+    GetAgentSuccessEvaluationResultsRequest,
+    GetAgentSuccessEvaluationResultsResponse,
+    GetRequestsRequest,
+    GetRequestsResponse,
+    RequestData,
+    Session,
+    UnifiedSearchRequest,
+    UnifiedSearchResponse,
+)
+from reflexio.server.llm.model_defaults import ModelRole, resolve_model_name
+from reflexio.server.site_var.site_var_manager import SiteVarManager
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class SearchMixin(ReflexioBase):
+    def get_agent_success_evaluation_results(
+        self,
+        request: GetAgentSuccessEvaluationResultsRequest | dict,
+    ) -> GetAgentSuccessEvaluationResultsResponse:
+        """Get agent success evaluation results.
+
+        Args:
+            request (Union[GetAgentSuccessEvaluationResultsRequest, dict]): The get request
+
+        Returns:
+            GetAgentSuccessEvaluationResultsResponse: Response containing agent success evaluation results
+        """
+        if not self._is_storage_configured():
+            return GetAgentSuccessEvaluationResultsResponse(
+                success=True,
+                agent_success_evaluation_results=[],
+                msg=STORAGE_NOT_CONFIGURED_MSG,
+            )
+        if isinstance(request, dict):
+            request = GetAgentSuccessEvaluationResultsRequest(**request)
+
+        try:
+            results = self._get_storage().get_agent_success_evaluation_results(
+                limit=request.limit or 100, agent_version=request.agent_version
+            )
+            return GetAgentSuccessEvaluationResultsResponse(
+                success=True,
+                agent_success_evaluation_results=results,
+                msg=f"Found {len(results)} evaluation result(s)",
+            )
+        except Exception as e:
+            return GetAgentSuccessEvaluationResultsResponse(
+                success=False, agent_success_evaluation_results=[], msg=str(e)
+            )
+
+    def get_requests(
+        self,
+        request: GetRequestsRequest | dict,
+    ) -> GetRequestsResponse:
+        """Get requests with their associated interactions, grouped by session.
+
+        Args:
+            request (Union[GetRequestsRequest, dict]): The get request
+
+        Returns:
+            GetRequestsResponse: Response containing requests grouped by session with their interactions
+        """
+        if not self._is_storage_configured():
+            return GetRequestsResponse(
+                success=True, sessions=[], msg=STORAGE_NOT_CONFIGURED_MSG
+            )
+        if isinstance(request, dict):
+            request = GetRequestsRequest(**request)
+
+        try:
+            # Get requests with interactions from storage (already grouped by session)
+            grouped_results = self._get_storage().get_sessions(
+                user_id=request.user_id,
+                request_id=request.request_id,
+                session_id=request.session_id,
+                start_time=(
+                    int(request.start_time.timestamp()) if request.start_time else None
+                ),
+                end_time=(
+                    int(request.end_time.timestamp()) if request.end_time else None
+                ),
+                top_k=request.top_k,
+                offset=request.offset or 0,
+            )
+
+            # Transform the dictionary into Session objects
+            sessions = []
+            for group_name, request_interaction_data_models in grouped_results.items():
+                # Convert each RequestInteractionDataModel to RequestData
+                request_data_list = [
+                    RequestData(
+                        request=request_interaction.request,
+                        interactions=request_interaction.interactions,
+                    )
+                    for request_interaction in request_interaction_data_models
+                ]
+                sessions.append(
+                    Session(session_id=group_name, requests=request_data_list)
+                )
+
+            # Determine has_more: count total requests returned across all groups
+            total_returned = sum(len(s.requests) for s in sessions)
+            effective_limit = request.top_k or 100
+            has_more = total_returned >= effective_limit
+
+            return GetRequestsResponse(
+                success=True,
+                sessions=sessions,
+                has_more=has_more,
+                msg=f"Found {total_returned} request(s) in {len(sessions)} session(s)",
+            )
+        except Exception as e:
+            return GetRequestsResponse(success=False, sessions=[], msg=str(e))
+
+    def unified_search(
+        self,
+        request: UnifiedSearchRequest | dict,
+        org_id: str,
+    ) -> UnifiedSearchResponse:
+        """Search across all entity types (profiles, feedbacks, raw_feedbacks) in parallel.
+
+        Args:
+            request (Union[UnifiedSearchRequest, dict]): The unified search request
+            org_id (str): Organization ID (used for feature flag checks)
+
+        Returns:
+            UnifiedSearchResponse: Combined results from all entity types
+        """
+        if not self._is_storage_configured():
+            return UnifiedSearchResponse(success=True, msg=STORAGE_NOT_CONFIGURED_MSG)
+        if isinstance(request, dict):
+            request = UnifiedSearchRequest(**request)
+
+        config = self.request_context.configurator.get_config()
+
+        from reflexio.server.services.unified_search_service import run_unified_search
+
+        config_llm_config = config.llm_config if config else None
+
+        # Resolve pre_retrieval_model_name: config override → site var → auto-detect
+        model_setting = SiteVarManager().get_site_var("llm_model_setting")
+        site_var = model_setting if isinstance(model_setting, dict) else {}
+        api_key_config = config.api_key_config if config else None
+
+        pre_retrieval_model_name = resolve_model_name(
+            ModelRole.PRE_RETRIEVAL,
+            site_var_value=site_var.get("pre_retrieval_model_name"),
+            config_override=config_llm_config.pre_retrieval_model_name
+            if config_llm_config
+            else None,
+            api_key_config=api_key_config,
+        )
+
+        return run_unified_search(
+            request=request,
+            org_id=org_id,
+            storage=self._get_storage(),
+            llm_client=self.llm_client,
+            prompt_manager=self.request_context.prompt_manager,
+            pre_retrieval_model_name=pre_retrieval_model_name,
+            retrieval_floor=config.retrieval_floor if config else None,
+        )

package/plugin/vendor/reflexio/reflexio/lib/_storage_labels.py

@@ -0,0 +1,103 @@
+"""Shared helpers for describing + masking storage configurations.
+
+Used by the publish diagnostics, the whoami endpoint, and the config
+show/pull commands so every surface labels storage the same way and
+masks credentials with the same rules.
+"""
+
+from __future__ import annotations
+
+from reflexio.models.config_schema import (
+    StorageConfig,
+    StorageConfigSQLite,
+)
+
+
+def describe_storage(
+    storage_config: StorageConfig | None,
+) -> tuple[str | None, str | None]:
+    """Map a ``StorageConfig`` to a ``(storage_type, masked_label)`` pair.
+
+    The type is a short slug ("sqlite", "supabase", "postgres",
+    "local_dir") suitable for grouping; the label is a short,
+    human-readable string with any secret material masked so it's safe
+    to print anywhere.
+
+    Enterprise-only storage types (Supabase, Postgres, local directory)
+    are matched by class name so we don't take a hard import dependency
+    on ``reflexio_ext`` from the open-source package.
+
+    Args:
+        storage_config: The storage configuration to describe.
+
+    Returns:
+        tuple[str | None, str | None]: ``(storage_type, storage_label)``,
+        or ``(None, None)`` when no storage is configured.
+    """
+    if storage_config is None:
+        return None, None
+
+    cls_name = type(storage_config).__name__
+
+    if isinstance(storage_config, StorageConfigSQLite):
+        return "sqlite", storage_config.db_path or "<default sqlite>"
+
+    if cls_name == "StorageConfigSupabase":
+        url = getattr(storage_config, "url", None)
+        return "supabase", mask_url(url) if url else "<supabase>"
+    if cls_name == "StorageConfigPostgres":
+        db_url = getattr(storage_config, "db_url", None)
+        return "postgres", mask_url(db_url) if db_url else "<postgres>"
+    if cls_name == "StorageConfigLocal":
+        return "local_dir", getattr(storage_config, "dir_path", None) or "<local>"
+
+    return cls_name.removeprefix("StorageConfig").lower() or None, cls_name
+
+
+def mask_url(value: str) -> str:
+    """Mask the middle of a URL/host while keeping scheme + domain tail.
+
+    Examples:
+        ``https://jpkjckbyxrdefzomiyse.supabase.co`` →
+        ``https://jpkj...supabase.co``
+
+        ``postgresql://user:pass@host.supabase.com:6543/postgres`` →
+        ``postgresql://***@host.supabase.com:6543/postgres``
+    """
+    if not value:
+        return ""
+
+    # Postgres / user-info URLs: hide the credentials segment entirely.
+    if "@" in value and "://" in value:
+        scheme, rest = value.split("://", 1)
+        _, host_part = rest.split("@", 1)
+        return f"{scheme}://***@{host_part}"
+
+    # HTTP(S) URLs: keep scheme, show first 4 chars of host, then tail domain.
+    if "://" in value:
+        scheme, rest = value.split("://", 1)
+        host = rest.split("/", 1)[0]
+        if "." not in host:
+            return f"{scheme}://{_short_head(host)}..."
+        head, tail = host.split(".", 1)
+        return f"{scheme}://{_short_head(head)}...{tail}"
+
+    # Plain strings (keys, paths): keep the first 4 chars.
+    return _short_head(value) + "..."
+
+
+def mask_secret(value: str) -> str:
+    """Mask a secret string, keeping only the first 4 and last 2 characters.
+
+    Returns ``"<empty>"`` for empty inputs so the output is always printable.
+    """
+    if not value:
+        return "<empty>"
+    if len(value) <= 8:
+        return "*" * len(value)
+    return f"{value[:4]}...{value[-2:]}"
+
+
+def _short_head(value: str) -> str:
+    """Return the first 4 characters of ``value`` (or the full string if shorter)."""
+    return value[:4] if len(value) > 4 else value

package/plugin/vendor/reflexio/reflexio/lib/_user_playbook.py

@@ -0,0 +1,288 @@
+from reflexio.lib._base import (
+    STORAGE_NOT_CONFIGURED_MSG,
+    ReflexioBase,
+    _require_storage,
+)
+from reflexio.models.api_schema.retriever_schema import (
+    GetUserPlaybooksRequest,
+    GetUserPlaybooksResponse,
+    SearchUserPlaybookRequest,
+    SearchUserPlaybookResponse,
+    UpdateUserPlaybookRequest,
+    UpdateUserPlaybookResponse,
+)
+from reflexio.models.api_schema.service_schemas import (
+    AddUserPlaybookRequest,
+    AddUserPlaybookResponse,
+    BulkDeleteResponse,
+    DeleteUserPlaybookRequest,
+    DeleteUserPlaybookResponse,
+    DeleteUserPlaybooksByIdsRequest,
+    DowngradeUserPlaybooksRequest,
+    DowngradeUserPlaybooksResponse,
+    UpgradeUserPlaybooksRequest,
+    UpgradeUserPlaybooksResponse,
+)
+from reflexio.models.config_schema import SearchOptions
+from reflexio.server.services.playbook.playbook_generation_service import (
+    PlaybookGenerationService,
+)
+from reflexio.server.tracing import profile_step
+
+
+class UserPlaybookMixin(ReflexioBase):
+    def get_user_playbooks(
+        self,
+        request: GetUserPlaybooksRequest | dict,
+    ) -> GetUserPlaybooksResponse:
+        """Get user playbooks.
+
+        Args:
+            request (Union[GetUserPlaybooksRequest, dict]): The get request
+
+        Returns:
+            GetUserPlaybooksResponse: Response containing user playbooks
+        """
+        if not self._is_storage_configured():
+            return GetUserPlaybooksResponse(
+                success=True, user_playbooks=[], msg=STORAGE_NOT_CONFIGURED_MSG
+            )
+        if isinstance(request, dict):
+            request = GetUserPlaybooksRequest(**request)
+
+        try:
+            user_playbooks = self._get_storage().get_user_playbooks(
+                limit=request.limit or 100,
+                user_id=request.user_id,
+                playbook_name=request.playbook_name,
+                agent_version=request.agent_version,
+                status_filter=request.status_filter,
+            )
+            return GetUserPlaybooksResponse(
+                success=True,
+                user_playbooks=user_playbooks,
+                msg=f"Found {len(user_playbooks)} user playbook(s)",
+            )
+        except Exception as e:
+            return GetUserPlaybooksResponse(
+                success=False, user_playbooks=[], msg=str(e)
+            )
+
+    def add_user_playbook(
+        self,
+        request: AddUserPlaybookRequest | dict,
+    ) -> AddUserPlaybookResponse:
+        """Add user playbooks directly to storage.
+
+        Args:
+            request (Union[AddUserPlaybookRequest, dict]): The add request containing user playbooks
+
+        Returns:
+            AddUserPlaybookResponse: Response containing success status, message, and count of added playbooks
+        """
+        if not self._is_storage_configured():
+            return AddUserPlaybookResponse(
+                success=False, message=STORAGE_NOT_CONFIGURED_MSG
+            )
+        if isinstance(request, dict):
+            request = AddUserPlaybookRequest(**request)
+
+        try:
+            self._get_storage().save_user_playbooks(list(request.user_playbooks))
+            return AddUserPlaybookResponse(
+                success=True,
+                added_count=len(request.user_playbooks),
+                message=f"Added {len(request.user_playbooks)} item(s)",
+            )
+        except Exception as e:
+            return AddUserPlaybookResponse(success=False, message=str(e))
+
+    def search_user_playbooks(
+        self,
+        request: SearchUserPlaybookRequest | dict,
+    ) -> SearchUserPlaybookResponse:
+        """Search user playbooks with advanced filtering and semantic search.
+
+        Args:
+            request (Union[SearchUserPlaybookRequest, dict]): The search request
+
+        Returns:
+            SearchUserPlaybookResponse: Response containing matching user playbooks
+        """
+        if not self._is_storage_configured():
+            return SearchUserPlaybookResponse(
+                success=True, user_playbooks=[], msg=STORAGE_NOT_CONFIGURED_MSG
+            )
+        if isinstance(request, dict):
+            request = SearchUserPlaybookRequest(**request)
+
+        try:
+            query = (
+                self._reformulate_query(
+                    request.query, enabled=bool(request.enable_reformulation)
+                )
+                or request.query
+            )
+            search_request = request.model_copy(update={"query": query})
+            query_embedding = self._maybe_get_query_embedding(
+                search_request.query, search_request.search_mode
+            )
+            options = (
+                SearchOptions(query_embedding=query_embedding)
+                if query_embedding
+                else None
+            )
+            with profile_step(
+                "search.storage",
+                entity_type="user_playbooks",
+                search_mode=search_request.search_mode,
+                top_k=search_request.top_k,
+            ) as span:
+                user_playbooks = self._get_storage().search_user_playbooks(
+                    search_request, options
+                )
+                span.set_data("result_count", len(user_playbooks))
+            return SearchUserPlaybookResponse(
+                success=True,
+                user_playbooks=user_playbooks,
+                msg=f"Found {len(user_playbooks)} matching user playbook(s)",
+            )
+        except Exception as e:
+            return SearchUserPlaybookResponse(
+                success=False, user_playbooks=[], msg=str(e)
+            )
+
+    @_require_storage(DeleteUserPlaybookResponse)
+    def delete_user_playbook(
+        self,
+        request: DeleteUserPlaybookRequest | dict,
+    ) -> DeleteUserPlaybookResponse:
+        """Delete a user playbook by ID.
+
+        Args:
+            request (DeleteUserPlaybookRequest): The delete request containing user_playbook_id
+
+        Returns:
+            DeleteUserPlaybookResponse: Response containing success status and message
+        """
+        if isinstance(request, dict):
+            request = DeleteUserPlaybookRequest(**request)
+        self._get_storage().delete_user_playbook(request.user_playbook_id)
+        return DeleteUserPlaybookResponse(success=True, message="Deleted successfully")
+
+    @_require_storage(BulkDeleteResponse)
+    def delete_user_playbooks_by_ids_bulk(
+        self,
+        request: DeleteUserPlaybooksByIdsRequest | dict,
+    ) -> BulkDeleteResponse:
+        """Delete user playbooks by their IDs.
+
+        Args:
+            request (DeleteUserPlaybooksByIdsRequest): The delete request containing user_playbook_ids
+
+        Returns:
+            BulkDeleteResponse: Response containing success status and deleted count
+        """
+        if isinstance(request, dict):
+            request = DeleteUserPlaybooksByIdsRequest(**request)
+        deleted = self._get_storage().delete_user_playbooks_by_ids(
+            request.user_playbook_ids
+        )
+        return BulkDeleteResponse(
+            success=True, deleted_count=deleted, message=f"Deleted {deleted} item(s)"
+        )
+
+    @_require_storage(BulkDeleteResponse)
+    def delete_all_user_playbooks_bulk(self) -> BulkDeleteResponse:
+        """Delete all user playbooks (only user playbooks, not agent playbooks).
+
+        Unlike :meth:`delete_all_playbooks_bulk` on ``AgentPlaybookMixin``
+        (which cascades to both user and agent playbooks), this method
+        scopes the deletion strictly to user playbooks. Use this from
+        CLI or API callers that want per-entity semantics.
+
+        Returns:
+            BulkDeleteResponse: Response containing success status and message.
+        """
+        self._get_storage().delete_all_user_playbooks()
+        return BulkDeleteResponse(success=True, message="Deleted successfully")
+
+    @_require_storage(UpdateUserPlaybookResponse, msg_field="msg")
+    def update_user_playbook(
+        self,
+        request: UpdateUserPlaybookRequest | dict,
+    ) -> UpdateUserPlaybookResponse:
+        """Update editable fields of a user playbook.
+
+        Args:
+            request (Union[UpdateUserPlaybookRequest, dict]): The update request
+
+        Returns:
+            UpdateUserPlaybookResponse: Response containing success status and message
+        """
+        if isinstance(request, dict):
+            request = UpdateUserPlaybookRequest(**request)
+        self._get_storage().update_user_playbook(
+            user_playbook_id=request.user_playbook_id,
+            playbook_name=request.playbook_name,
+            content=request.content,
+            trigger=request.trigger,
+            rationale=request.rationale,
+        )
+        return UpdateUserPlaybookResponse(
+            success=True, msg="User playbook updated successfully"
+        )
+
+    def upgrade_all_user_playbooks(
+        self,
+        request: UpgradeUserPlaybooksRequest | dict | None = None,
+    ) -> UpgradeUserPlaybooksResponse:
+        """Upgrade all user playbooks by deleting old ARCHIVED, archiving CURRENT, and promoting PENDING.
+
+        Args:
+            request (Union[UpgradeUserPlaybooksRequest, dict], optional): The upgrade request
+
+        Returns:
+            UpgradeUserPlaybooksResponse: Response containing success status and counts
+        """
+        if not self._is_storage_configured():
+            return UpgradeUserPlaybooksResponse(
+                success=False, message=STORAGE_NOT_CONFIGURED_MSG
+            )
+        if isinstance(request, dict):
+            request = UpgradeUserPlaybooksRequest(**request)
+        elif request is None:
+            request = UpgradeUserPlaybooksRequest()
+
+        service = PlaybookGenerationService(
+            llm_client=self.llm_client,
+            request_context=self.request_context,
+        )
+        return service.run_upgrade(request)  # type: ignore[reportArgumentType]
+
+    def downgrade_all_user_playbooks(
+        self,
+        request: DowngradeUserPlaybooksRequest | dict | None = None,
+    ) -> DowngradeUserPlaybooksResponse:
+        """Downgrade all user playbooks by archiving CURRENT and restoring ARCHIVED.
+
+        Args:
+            request (Union[DowngradeUserPlaybooksRequest, dict], optional): The downgrade request
+
+        Returns:
+            DowngradeUserPlaybooksResponse: Response containing success status and counts
+        """
+        if not self._is_storage_configured():
+            return DowngradeUserPlaybooksResponse(
+                success=False, message=STORAGE_NOT_CONFIGURED_MSG
+            )
+        if isinstance(request, dict):
+            request = DowngradeUserPlaybooksRequest(**request)
+        elif request is None:
+            request = DowngradeUserPlaybooksRequest()
+
+        service = PlaybookGenerationService(
+            llm_client=self.llm_client,
+            request_context=self.request_context,
+        )
+        return service.run_downgrade(request)  # type: ignore[reportArgumentType]

package/plugin/vendor/reflexio/reflexio/lib/reflexio_lib.py

@@ -0,0 +1,27 @@
+"""Reflexio facade — assembled from domain mixins."""
+
+from reflexio.lib._agent_playbook import AgentPlaybookMixin
+from reflexio.lib._config import ConfigMixin
+from reflexio.lib._dashboard import DashboardMixin
+from reflexio.lib._generation import GenerationMixin
+from reflexio.lib._interactions import InteractionsMixin
+from reflexio.lib._operations import OperationsMixin
+from reflexio.lib._profiles import ProfilesMixin
+from reflexio.lib._reflection import ReflectionMixin
+from reflexio.lib._search import SearchMixin
+from reflexio.lib._user_playbook import UserPlaybookMixin
+
+
+class Reflexio(
+    InteractionsMixin,
+    ProfilesMixin,
+    AgentPlaybookMixin,
+    UserPlaybookMixin,
+    ConfigMixin,
+    GenerationMixin,
+    ReflectionMixin,
+    OperationsMixin,
+    DashboardMixin,
+    SearchMixin,
+):
+    """Synchronous facade providing a unified API for all Reflexio operations."""