claude-smart 0.2.41 → 0.2.43

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

@@ -0,0 +1,225 @@
+from __future__ import annotations
+
+import functools
+import logging
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any
+
+from pydantic import BaseModel
+
+if TYPE_CHECKING:
+    from reflexio.server.services.pre_retrieval import QueryReformulator
+
+
+from reflexio.models.config_schema import SearchMode
+from reflexio.server.api_endpoints.request_context import RequestContext
+from reflexio.server.llm.litellm_client import LiteLLMClient, LiteLLMConfig
+from reflexio.server.llm.model_defaults import (
+    ModelRole,
+    resolve_model_name,
+)
+from reflexio.server.services.configurator.base_configurator import BaseConfigurator
+from reflexio.server.services.storage.storage_base import BaseStorage
+from reflexio.server.site_var.site_var_manager import SiteVarManager
+from reflexio.server.tracing import profile_step
+
+logger = logging.getLogger(__name__)
+
+# Error message for when storage is not configured
+STORAGE_NOT_CONFIGURED_MSG = (
+    "Storage not configured. Please configure storage in settings first."
+)
+
+
+def _require_storage[T: BaseModel](
+    response_type: type[T], *, msg_field: str = "message"
+) -> Callable[..., Callable[..., T]]:
+    """Decorator that guards a Reflexio method with storage-configured check and error handling.
+
+    Args:
+        response_type: The Pydantic response model to return on failure
+        msg_field: Name of the message field on the response ('message' or 'msg')
+    """
+
+    def decorator(method: Callable[..., T]) -> Callable[..., T]:
+        @functools.wraps(method)
+        def wrapper(self: Reflexio, *args: Any, **kwargs: Any) -> T:
+            if not self._is_storage_configured():
+                return response_type.model_validate(
+                    {"success": False, msg_field: STORAGE_NOT_CONFIGURED_MSG}
+                )
+            try:
+                return method(self, *args, **kwargs)
+            except Exception as e:
+                return response_type.model_validate(
+                    {"success": False, msg_field: str(e)}
+                )
+
+        return wrapper
+
+    return decorator
+
+
+def _storage_backend_name(storage: BaseStorage) -> str:
+    class_name = storage.__class__.__name__.lower()
+    if "postgres" in class_name:
+        return "postgres"
+    if "supabase" in class_name:
+        return "supabase"
+    return class_name
+
+
+class ReflexioBase:
+    def __init__(
+        self,
+        org_id: str,
+        storage_base_dir: str | None = None,
+        configurator: BaseConfigurator | None = None,
+    ) -> None:
+        """Initialize Reflexio with organization ID and storage directory.
+
+        Args:
+            org_id (str): Organization ID
+            storage_base_dir (str, optional): Base directory for storing data
+        """
+        self.org_id = org_id
+        self.storage_base_dir = storage_base_dir
+        self.request_context = RequestContext(
+            org_id=org_id, storage_base_dir=storage_base_dir, configurator=configurator
+        )
+
+        # Create single LLM client for all services
+        model_setting = SiteVarManager().get_site_var("llm_model_setting")
+        site_var = model_setting if isinstance(model_setting, dict) else {}
+
+        # Get API key config and LLM config from configuration if available
+        config = self.request_context.configurator.get_config()
+        api_key_config = config.api_key_config if config else None
+        config_llm_config = config.llm_config if config else None
+
+        generation_model_name = resolve_model_name(
+            ModelRole.GENERATION,
+            site_var_value=site_var.get("default_generation_model_name"),
+            config_override=config_llm_config.generation_model_name
+            if config_llm_config
+            else None,
+            api_key_config=api_key_config,
+        )
+
+        llm_config = LiteLLMConfig(
+            model=generation_model_name,
+            api_key_config=api_key_config,
+        )
+        self.llm_client = LiteLLMClient(llm_config)
+
+    def _is_storage_configured(self) -> bool:
+        """Check if storage is configured and available.
+
+        Returns:
+            bool: True if storage is configured, False otherwise
+        """
+        return self.request_context.is_storage_configured()
+
+    def _get_storage(self) -> BaseStorage:
+        """Return storage, raising if not configured."""
+        storage = self.request_context.storage
+        if storage is None:
+            raise RuntimeError(STORAGE_NOT_CONFIGURED_MSG)
+        return storage
+
+    def _get_query_reformulator(self) -> QueryReformulator:
+        """Lazily create and cache a QueryReformulator instance.
+
+        Returns:
+            QueryReformulator: Cached reformulator instance
+        """
+        if not hasattr(self, "_query_reformulator"):
+            from reflexio.server.services.pre_retrieval import QueryReformulator
+
+            # 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 {}
+            config = self.request_context.configurator.get_config()
+            config_llm_config = config.llm_config if config else None
+            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,
+            )
+
+            self._query_reformulator = QueryReformulator(
+                llm_client=self.llm_client,
+                prompt_manager=self.request_context.prompt_manager,
+                model_name=pre_retrieval_model_name,
+            )
+        return self._query_reformulator
+
+    def _maybe_get_query_embedding(
+        self, query: str | None, search_mode: SearchMode
+    ) -> list[float] | None:
+        """Generate a query embedding if the search mode needs one and the storage supports it.
+
+        Args:
+            query (str, optional): The search query text
+            search_mode (SearchMode): Requested search mode
+
+        Returns:
+            list[float] or None: Query embedding vector, or None if not needed/available
+        """
+        if not query or search_mode == SearchMode.FTS:
+            return None
+        storage = self._get_storage()
+        if not storage.supports_embedding:
+            return None
+        with profile_step(
+            "search.embedding",
+            backend=_storage_backend_name(storage),
+            search_mode=search_mode,
+            purpose="query",
+        ) as span:
+            try:
+                embedding = storage._get_embedding(query, purpose="query")  # type: ignore[reportAttributeAccessIssue]
+                span.set_data("embedding_generated", embedding is not None)
+                return embedding
+            except Exception as e:
+                span.set_data("embedding_generated", False)
+                logger.warning(
+                    "Failed to generate query embedding due to %s — falling back to FTS",
+                    e,
+                )
+                return None
+
+    def _reformulate_query(
+        self, query: str | None, enabled: bool = False
+    ) -> str | None:
+        """Reformulate a search query using the query reformulator if enabled.
+
+        Returns the reformulated query, or None if reformulation is disabled,
+        the query is empty, or reformulation fails.
+
+        Args:
+            query (str, optional): The original search query
+            enabled (bool): Whether query reformulation is enabled for this request
+
+        Returns:
+            str or None: Reformulated query, or None to use original query
+        """
+        if not query or not enabled:
+            return None
+
+        with profile_step("search.reformulate", enabled=enabled):
+            reformulator = self._get_query_reformulator()
+            result = reformulator.rewrite(query)
+            # Only return if different from original
+            if result.standalone_query != query:
+                return result.standalone_query
+        return None
+
+
+if TYPE_CHECKING:
+    from reflexio.lib.reflexio_lib import Reflexio

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

@@ -0,0 +1,83 @@
+from typing import Any
+
+from reflexio.lib._base import ReflexioBase
+from reflexio.models.api_schema.retriever_schema import SetConfigResponse
+from reflexio.models.config_schema import Config
+
+
+class ConfigMixin(ReflexioBase):
+    def set_config(self, config: Config | dict) -> SetConfigResponse:
+        """Set configuration for the organization.
+
+        Args:
+            config (Union[Config, dict]): The configuration to set
+
+        Returns:
+            dict: Response containing success status and message
+        """
+        try:
+            configurator = self.request_context.configurator
+            if isinstance(config, dict):
+                config = configurator.normalize_config_payload(config)
+                config = Config(**config)
+
+            # Validate storage connection before setting config.
+            # If no storage_config provided, preserve the existing one (callers
+            # like get_config() don't expose storage_config for security).
+            storage_config = config.storage_config
+            if storage_config is None:
+                storage_config = configurator.get_current_storage_configuration()
+                config.storage_config = storage_config
+
+            # Check if storage config is ready to test
+            if not configurator.is_storage_config_ready_to_test(
+                storage_config=storage_config
+            ):
+                return SetConfigResponse(
+                    success=False, msg="Storage configuration is incomplete"
+                )
+
+            # Test and initialize storage connection
+            (
+                success,
+                error_msg,
+            ) = configurator.test_and_init_storage_config(storage_config=storage_config)
+
+            if not success:
+                return SetConfigResponse(
+                    success=False,
+                    msg=f"Failed to validate storage connection: {error_msg}",
+                )
+
+            # Only set config if validation passed
+            configurator.set_config(config)
+
+            return SetConfigResponse(success=True, msg="Configuration set successfully")
+        except Exception as e:
+            return SetConfigResponse(
+                success=False, msg=f"Failed to set configuration: {str(e)}"
+            )
+
+    def get_config(self) -> Config:
+        """Get configuration for the organization.
+
+        Returns:
+            Config: The current configuration
+        """
+        return self.request_context.configurator.get_config()
+
+    def current_config_version(self) -> tuple[str, Any] | None:
+        """Cheap probe of the persisted config version.
+
+        Delegates to the underlying ``ConfigStorage.get_version()``.
+        Used by the per-org Reflexio cache to detect out-of-band
+        configuration changes (file edits, replica writes, direct DB
+        updates) without doing a full reload on every request.
+
+        Returns:
+            tuple[str, Any] | None: ``("file", mtime)`` for file-backed
+            storage, ``("db", version)`` for DB-backed storage, or
+            ``None`` when probing is unsupported / fails (the cache
+            treats ``None`` as "still fresh").
+        """
+        return self.request_context.configurator.config_storage.get_version()

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

@@ -0,0 +1,266 @@
+from typing import TYPE_CHECKING
+
+from reflexio.lib._base import STORAGE_NOT_CONFIGURED_MSG, ReflexioBase
+from reflexio.models.api_schema.braintrust_schema import (
+    BraintrustStatusResponse,
+    ConnectBraintrustRequest,
+    ConnectBraintrustResponse,
+    SelectProjectsRequest,
+    SelectProjectsResponse,
+    SyncBraintrustResponse,
+)
+from reflexio.models.api_schema.eval_overview_schema import (
+    ContextTile,
+    GetEvaluationOverviewRequest,
+    GetEvaluationOverviewResponse,
+    HeroBlock,
+    NumberWithDelta,
+    PercentWithDelta,
+    ScoreDistribution,
+)
+from reflexio.models.api_schema.retriever_schema import (
+    DashboardStats,
+    GetDashboardStatsRequest,
+    GetDashboardStatsResponse,
+    GetPlaybookApplicationStatsRequest,
+    GetPlaybookApplicationStatsResponse,
+    PeriodStats,
+    TimeSeriesDataPoint,
+)
+
+if TYPE_CHECKING:
+    from reflexio.server.services.braintrust.service import (
+        BraintrustConnectorService,
+    )
+
+
+class DashboardMixin(ReflexioBase):
+    def get_dashboard_stats(
+        self, request: GetDashboardStatsRequest | dict
+    ) -> GetDashboardStatsResponse:
+        """Get dashboard statistics including counts and time-series data.
+
+        Args:
+            request (Union[GetDashboardStatsRequest, dict]): Request containing days_back and granularity
+
+        Returns:
+            GetDashboardStatsResponse: Response containing dashboard statistics
+        """
+        if not self._is_storage_configured():
+            # Return empty stats when storage is not configured
+            empty_period = PeriodStats(
+                total_profiles=0,
+                total_interactions=0,
+                total_playbooks=0,
+                success_rate=0.0,
+            )
+            empty_stats = DashboardStats(
+                current_period=empty_period,
+                previous_period=empty_period,
+                interactions_time_series=[],
+                profiles_time_series=[],
+                playbooks_time_series=[],
+                evaluations_time_series=[],
+            )
+            return GetDashboardStatsResponse(
+                success=True, stats=empty_stats, msg=STORAGE_NOT_CONFIGURED_MSG
+            )
+        try:
+            # Convert dict to request object if needed
+            if isinstance(request, dict):
+                request = GetDashboardStatsRequest(**request)
+
+            # Get stats from storage layer
+            stats_dict = self._get_storage().get_dashboard_stats(
+                days_back=request.days_back or 30
+            )
+
+            # Convert dict to Pydantic models
+            current_period = PeriodStats(**stats_dict["current_period"])
+            previous_period = PeriodStats(**stats_dict["previous_period"])
+
+            interactions_time_series = [
+                TimeSeriesDataPoint(**ts)
+                for ts in stats_dict["interactions_time_series"]
+            ]
+            profiles_time_series = [
+                TimeSeriesDataPoint(**ts) for ts in stats_dict["profiles_time_series"]
+            ]
+            playbooks_time_series = [
+                TimeSeriesDataPoint(**ts) for ts in stats_dict["playbooks_time_series"]
+            ]
+            evaluations_time_series = [
+                TimeSeriesDataPoint(**ts)
+                for ts in stats_dict["evaluations_time_series"]
+            ]
+
+            # Build dashboard stats object
+            dashboard_stats = DashboardStats(
+                current_period=current_period,
+                previous_period=previous_period,
+                interactions_time_series=interactions_time_series,
+                profiles_time_series=profiles_time_series,
+                playbooks_time_series=playbooks_time_series,
+                evaluations_time_series=evaluations_time_series,
+            )
+
+            return GetDashboardStatsResponse(
+                success=True,
+                stats=dashboard_stats,
+                msg="Retrieved dashboard stats successfully",
+            )
+
+        except Exception as e:
+            return GetDashboardStatsResponse(
+                success=False, msg=f"Failed to get dashboard stats: {str(e)}"
+            )
+
+    def get_playbook_application_stats(
+        self, request: GetPlaybookApplicationStatsRequest | dict
+    ) -> GetPlaybookApplicationStatsResponse:
+        """Get per-rule citation counts from the interactions table.
+
+        Aggregates the JSON citations column on interactions in the look-back
+        window and groups by (kind, real_id) so the dashboard can show how
+        often each individual playbook or profile has been applied.
+
+        Args:
+            request (Union[GetPlaybookApplicationStatsRequest, dict]): Request
+                containing days_back.
+
+        Returns:
+            GetPlaybookApplicationStatsResponse: Response containing the
+                aggregated stats sorted by applied_count descending.
+        """
+        if not self._is_storage_configured():
+            return GetPlaybookApplicationStatsResponse(
+                success=True, stats=[], msg=STORAGE_NOT_CONFIGURED_MSG
+            )
+        try:
+            if isinstance(request, dict):
+                request = GetPlaybookApplicationStatsRequest(**request)
+            stats = self._get_storage().get_playbook_application_stats(
+                days_back=request.days_back
+            )
+            return GetPlaybookApplicationStatsResponse(
+                success=True,
+                stats=stats,
+                msg="Retrieved playbook application stats successfully",
+            )
+        except Exception as e:
+            return GetPlaybookApplicationStatsResponse(
+                success=False,
+                stats=[],
+                msg=f"Failed to get playbook application stats: {str(e)}",
+            )
+
+    # ==============================
+    # Braintrust connector (Plan C-backend)
+    # ==============================
+
+    def braintrust_connect(
+        self, request: ConnectBraintrustRequest | dict
+    ) -> ConnectBraintrustResponse:
+        """Step 1 of the Braintrust connect flow — validate key, list workspaces."""
+        if isinstance(request, dict):
+            request = ConnectBraintrustRequest(**request)
+        if not self._is_storage_configured():
+            return ConnectBraintrustResponse(
+                success=False, msg=STORAGE_NOT_CONFIGURED_MSG
+            )
+        return self._braintrust_service().connect(request)
+
+    def braintrust_select_projects(
+        self, request: SelectProjectsRequest | dict
+    ) -> SelectProjectsResponse:
+        """Step 2 — persist the connection with selected projects (key encrypted)."""
+        if isinstance(request, dict):
+            request = SelectProjectsRequest(**request)
+        if not self._is_storage_configured():
+            return SelectProjectsResponse(success=False, msg=STORAGE_NOT_CONFIGURED_MSG)
+        return self._braintrust_service().select_projects(request)
+
+    def braintrust_status(self) -> BraintrustStatusResponse:
+        """Return whether this org is connected to Braintrust + sync state."""
+        if not self._is_storage_configured():
+            return BraintrustStatusResponse(connected=False)
+        return self._braintrust_service().status()
+
+    def braintrust_disconnect(self) -> None:
+        """Delete the persisted Braintrust connection."""
+        if not self._is_storage_configured():
+            return
+        self._braintrust_service().disconnect()
+
+    def braintrust_sync(self) -> SyncBraintrustResponse:
+        """Manual one-shot sync (cron-driven sync is a follow-up)."""
+        if not self._is_storage_configured():
+            return SyncBraintrustResponse(success=False, msg=STORAGE_NOT_CONFIGURED_MSG)
+        return self._braintrust_service().sync_once()
+
+    def _braintrust_service(self) -> "BraintrustConnectorService":
+        from reflexio.server.services.braintrust.service import (
+            BraintrustConnectorService,
+        )
+
+        return BraintrustConnectorService(
+            storage=self._get_storage(),
+            org_id=self.request_context.org_id,
+        )
+
+    def get_evaluation_overview(
+        self, request: GetEvaluationOverviewRequest | dict
+    ) -> GetEvaluationOverviewResponse:
+        """Build the /evaluations overview payload (hero + tiles + attribution + distribution).
+
+        Args:
+            request (GetEvaluationOverviewRequest | dict): Window, bucket
+                granularity, and shadow-inclusion flag.
+
+        Returns:
+            GetEvaluationOverviewResponse: Full payload — the redesigned
+                /evaluations page is expected to render directly from this.
+        """
+        if isinstance(request, dict):
+            request = GetEvaluationOverviewRequest(**request)
+        if not self._is_storage_configured():
+            return _empty_overview_response()
+        from reflexio.server.services.evaluation_overview.service import (
+            EvaluationOverviewService,
+        )
+
+        service = EvaluationOverviewService(
+            storage=self._get_storage(),
+            config=self.request_context.configurator.get_config(),
+        )
+        return service.run(request)
+
+
+def _empty_overview_response() -> GetEvaluationOverviewResponse:
+    """Return a default response when storage is not configured.
+
+    Used by lib wrappers to keep the endpoint stable even before storage is
+    wired up (matches the defensive pattern used by other dashboard methods).
+    """
+    return GetEvaluationOverviewResponse(
+        hero=HeroBlock(
+            state="empty",
+            regular_success_rate_pp=0.0,
+            shadow_success_rate_pp=None,
+            delta_pp=None,
+            buckets=[],
+        ),
+        context_tiles=ContextTile(
+            success=PercentWithDelta(current=0.0, delta_pp=0.0),
+            corrections=NumberWithDelta(current=0.0, delta=0.0),
+            turns=NumberWithDelta(current=0.0, delta=0.0),
+            escalation=PercentWithDelta(current=0.0, delta_pp=0.0),
+        ),
+        rule_attribution=[],
+        score_distribution=ScoreDistribution(
+            current_bins=[0, 0, 0, 0, 0, 0],
+            baseline_bins=[0, 0, 0, 0, 0, 0],
+            labels=["0", "1", "2", "3", "4", "5+"],
+        ),
+        braintrust_tiles=[],
+    )