claude-smart 0.2.41 → 0.2.43

package/plugin/vendor/reflexio/reflexio/server/api_endpoints/publisher_api.py

@@ -0,0 +1,540 @@
+"""
+Create, edit, delete user interaction and user profile
+"""
+
+import logging
+
+from reflexio.models.api_schema.retriever_schema import (
+    UpdateAgentPlaybookRequest,
+    UpdateAgentPlaybookResponse,
+    UpdatePlaybookStatusRequest,
+    UpdatePlaybookStatusResponse,
+    UpdateUserPlaybookRequest,
+    UpdateUserPlaybookResponse,
+    UpdateUserProfileRequest,
+    UpdateUserProfileResponse,
+)
+from reflexio.models.api_schema.service_schemas import (
+    AddAgentPlaybookRequest,
+    AddAgentPlaybookResponse,
+    AddUserPlaybookRequest,
+    AddUserPlaybookResponse,
+    AddUserProfileRequest,
+    AddUserProfileResponse,
+    BulkDeleteResponse,
+    ClearUserDataRequest,
+    ClearUserDataResponse,
+    DeleteAgentPlaybookRequest,
+    DeleteAgentPlaybookResponse,
+    DeleteAgentPlaybooksByIdsRequest,
+    DeleteProfilesByIdsRequest,
+    DeleteRequestRequest,
+    DeleteRequestResponse,
+    DeleteRequestsByIdsRequest,
+    DeleteSessionRequest,
+    DeleteSessionResponse,
+    DeleteUserInteractionRequest,
+    DeleteUserInteractionResponse,
+    DeleteUserPlaybookRequest,
+    DeleteUserPlaybookResponse,
+    DeleteUserPlaybooksByIdsRequest,
+    DeleteUserProfileRequest,
+    DeleteUserProfileResponse,
+    PublishUserInteractionRequest,
+    PublishUserInteractionResponse,
+    RunPlaybookAggregationRequest,
+    RunPlaybookAggregationResponse,
+)
+from reflexio.server.api_endpoints.precondition_checks import (
+    validate_delete_user_profile_request,
+    validate_publish_user_interaction_request,
+)
+from reflexio.server.cache.reflexio_cache import get_reflexio
+from reflexio.server.tracing import sentry_tags
+
+logger = logging.getLogger(__name__)
+
+# ==============================
+# Create user interaction and profile
+# ==============================
+
+
+def add_user_interaction(
+    org_id: str,
+    request: PublishUserInteractionRequest,
+) -> PublishUserInteractionResponse:
+    """Add user interaction
+
+    Args:
+        org_id (str): Organization ID
+        request (PublishUserInteractionRequest): The request containing interaction data
+
+    Returns:
+        PublishUserInteractionResponse: Response containing success status and message
+    """
+    is_valid, message = validate_publish_user_interaction_request(request)
+    if not is_valid:
+        return PublishUserInteractionResponse(success=False, message=message)
+
+    reflexio = get_reflexio(org_id=org_id)
+    return reflexio.publish_interaction(request=request)
+
+
+def add_user_playbook(
+    org_id: str,
+    request: AddUserPlaybookRequest,
+) -> AddUserPlaybookResponse:
+    """Add user playbook directly to storage.
+
+    Args:
+        org_id (str): Organization ID
+        request (AddUserPlaybookRequest): The request containing user playbooks
+
+    Returns:
+        AddUserPlaybookResponse: Response containing success status, message, and added count
+    """
+    reflexio = get_reflexio(org_id=org_id)
+    return reflexio.add_user_playbook(request=request)
+
+
+def add_agent_playbook(
+    org_id: str,
+    request: AddAgentPlaybookRequest,
+) -> AddAgentPlaybookResponse:
+    """Add agent playbook directly to storage.
+
+    Args:
+        org_id (str): Organization ID
+        request (AddAgentPlaybookRequest): The request containing agent playbooks
+
+    Returns:
+        AddAgentPlaybookResponse: Response containing success status, message, and added count
+    """
+    reflexio = get_reflexio(org_id=org_id)
+    return reflexio.add_agent_playbook(request=request)
+
+
+def add_user_profile(
+    org_id: str,
+    request: AddUserProfileRequest,
+) -> AddUserProfileResponse:
+    """Add user profile directly to storage, bypassing inference.
+
+    Mirror of :func:`add_user_playbook` for the profile resource —
+    useful for seeding a known fact about the user (testing, migration,
+    manual fact injection) without producing an interaction first.
+
+    Args:
+        org_id (str): Organization ID
+        request (AddUserProfileRequest): The request containing user profiles
+
+    Returns:
+        AddUserProfileResponse: Response containing success status, message, and added count
+    """
+    reflexio = get_reflexio(org_id=org_id)
+    return reflexio.add_user_profile(request=request)
+
+
+def delete_user_profile(
+    org_id: str, request: DeleteUserProfileRequest
+) -> DeleteUserProfileResponse:
+    """Delete user profile
+
+    Args:
+        org_id (str): Organization ID
+        request (DeleteUserProfileRequest): The delete request
+
+    Returns:
+        DeleteUserProfileResponse: Response containing success status and message
+    """
+    is_valid, message = validate_delete_user_profile_request(request)
+    if not is_valid:
+        return DeleteUserProfileResponse(success=False, message=message)
+
+    reflexio = get_reflexio(org_id=org_id)
+    try:
+        return reflexio.delete_profile(request)
+    except Exception as e:
+        with sentry_tags(subsystem="publisher_api", action="delete_user_profile", org_id=org_id):
+            logger.exception("Failed to delete user profile")
+        return DeleteUserProfileResponse(success=False, message=str(e))
+
+
+def delete_user_interaction(
+    org_id: str, request: DeleteUserInteractionRequest
+) -> DeleteUserInteractionResponse:
+    """Delete user interaction
+
+    Args:
+        org_id (str): Organization ID
+        request (DeleteUserInteractionRequest): The delete request
+
+    Returns:
+        DeleteUserInteractionResponse: Response containing success status and message
+    """
+    reflexio = get_reflexio(org_id=org_id)
+    try:
+        return reflexio.delete_interaction(request)
+    except Exception as e:
+        with sentry_tags(subsystem="publisher_api", action="delete_user_interaction", org_id=org_id):
+            logger.exception("Failed to delete user interaction")
+        return DeleteUserInteractionResponse(success=False, message=str(e))
+
+
+def delete_request(org_id: str, request: DeleteRequestRequest) -> DeleteRequestResponse:
+    """Delete request and all its associated interactions
+
+    Args:
+        org_id (str): Organization ID
+        request (DeleteRequestRequest): The delete request
+
+    Returns:
+        DeleteRequestResponse: Response containing success status and message
+    """
+    reflexio = get_reflexio(org_id=org_id)
+    try:
+        return reflexio.delete_request(request)
+    except Exception as e:
+        with sentry_tags(subsystem="publisher_api", action="delete_request", org_id=org_id):
+            logger.exception("Failed to delete request")
+        return DeleteRequestResponse(success=False, message=str(e))
+
+
+def delete_session(org_id: str, request: DeleteSessionRequest) -> DeleteSessionResponse:
+    """Delete all requests and interactions in a session
+
+    Args:
+        org_id (str): Organization ID
+        request (DeleteSessionRequest): The delete request
+
+    Returns:
+        DeleteSessionResponse: Response containing success status, message, and deleted count
+    """
+    reflexio = get_reflexio(org_id=org_id)
+    try:
+        return reflexio.delete_session(request)
+    except Exception as e:
+        with sentry_tags(subsystem="publisher_api", action="delete_session", org_id=org_id):
+            logger.exception("Failed to delete session")
+        return DeleteSessionResponse(success=False, message=str(e))
+
+
+def delete_agent_playbook(
+    org_id: str, request: DeleteAgentPlaybookRequest
+) -> DeleteAgentPlaybookResponse:
+    """Delete agent playbook by ID.
+
+    Args:
+        org_id (str): Organization ID
+        request (DeleteAgentPlaybookRequest): The delete request
+
+    Returns:
+        DeleteAgentPlaybookResponse: Response containing success status and message
+    """
+    reflexio = get_reflexio(org_id=org_id)
+    try:
+        return reflexio.delete_agent_playbook(request)
+    except Exception as e:
+        with sentry_tags(subsystem="publisher_api", action="delete_agent_playbook", org_id=org_id):
+            logger.exception("Failed to delete agent playbook")
+        return DeleteAgentPlaybookResponse(success=False, message=str(e))
+
+
+def delete_user_playbook(
+    org_id: str, request: DeleteUserPlaybookRequest
+) -> DeleteUserPlaybookResponse:
+    """Delete user playbook by ID.
+
+    Args:
+        org_id (str): Organization ID
+        request (DeleteUserPlaybookRequest): The delete request
+
+    Returns:
+        DeleteUserPlaybookResponse: Response containing success status and message
+    """
+    reflexio = get_reflexio(org_id=org_id)
+    try:
+        return reflexio.delete_user_playbook(request)
+    except Exception as e:
+        with sentry_tags(subsystem="publisher_api", action="delete_user_playbook", org_id=org_id):
+            logger.exception("Failed to delete user playbook")
+        return DeleteUserPlaybookResponse(success=False, message=str(e))
+
+
+# ==============================
+# Bulk delete operations
+# ==============================
+
+
+def delete_all_interactions_bulk(org_id: str) -> BulkDeleteResponse:
+    """Delete all requests and their associated interactions.
+
+    Args:
+        org_id (str): Organization ID
+
+    Returns:
+        BulkDeleteResponse: Response containing success status and deleted count
+    """
+    reflexio = get_reflexio(org_id=org_id)
+    return reflexio.delete_all_interactions_bulk()
+
+
+def delete_all_profiles_bulk(org_id: str) -> BulkDeleteResponse:
+    """Delete all profiles.
+
+    Args:
+        org_id (str): Organization ID
+
+    Returns:
+        BulkDeleteResponse: Response containing success status and deleted count
+    """
+    reflexio = get_reflexio(org_id=org_id)
+    return reflexio.delete_all_profiles_bulk()
+
+
+def delete_all_playbooks_bulk(org_id: str) -> BulkDeleteResponse:
+    """Delete all playbooks (both user and agent).
+
+    Args:
+        org_id (str): Organization ID
+
+    Returns:
+        BulkDeleteResponse: Response containing success status and deleted count
+    """
+    reflexio = get_reflexio(org_id=org_id)
+    return reflexio.delete_all_playbooks_bulk()
+
+
+def delete_all_user_playbooks_bulk(org_id: str) -> BulkDeleteResponse:
+    """Delete all user playbooks (user only, not agent).
+
+    Args:
+        org_id (str): Organization ID
+
+    Returns:
+        BulkDeleteResponse: Response containing success status and deleted count
+    """
+    reflexio = get_reflexio(org_id=org_id)
+    return reflexio.delete_all_user_playbooks_bulk()
+
+
+def delete_all_agent_playbooks_bulk(org_id: str) -> BulkDeleteResponse:
+    """Delete all agent playbooks (agent only, not user).
+
+    Args:
+        org_id (str): Organization ID
+
+    Returns:
+        BulkDeleteResponse: Response containing success status and deleted count
+    """
+    reflexio = get_reflexio(org_id=org_id)
+    return reflexio.delete_all_agent_playbooks_bulk()
+
+
+def delete_requests_by_ids(
+    org_id: str, request: DeleteRequestsByIdsRequest
+) -> BulkDeleteResponse:
+    """Delete requests by their IDs.
+
+    Args:
+        org_id (str): Organization ID
+        request (DeleteRequestsByIdsRequest): The delete request
+
+    Returns:
+        BulkDeleteResponse: Response containing success status and deleted count
+    """
+    reflexio = get_reflexio(org_id=org_id)
+    return reflexio.delete_requests_by_ids(request)
+
+
+def delete_profiles_by_ids(
+    org_id: str, request: DeleteProfilesByIdsRequest
+) -> BulkDeleteResponse:
+    """Delete profiles by their IDs.
+
+    Args:
+        org_id (str): Organization ID
+        request (DeleteProfilesByIdsRequest): The delete request
+
+    Returns:
+        BulkDeleteResponse: Response containing success status and deleted count
+    """
+    reflexio = get_reflexio(org_id=org_id)
+    return reflexio.delete_profiles_by_ids(request)
+
+
+def delete_agent_playbooks_by_ids_bulk(
+    org_id: str, request: DeleteAgentPlaybooksByIdsRequest
+) -> BulkDeleteResponse:
+    """Delete agent playbooks by their IDs.
+
+    Args:
+        org_id (str): Organization ID
+        request (DeleteAgentPlaybooksByIdsRequest): The delete request
+
+    Returns:
+        BulkDeleteResponse: Response containing success status and deleted count
+    """
+    reflexio = get_reflexio(org_id=org_id)
+    return reflexio.delete_agent_playbooks_by_ids_bulk(request)
+
+
+def delete_user_playbooks_by_ids_bulk(
+    org_id: str, request: DeleteUserPlaybooksByIdsRequest
+) -> BulkDeleteResponse:
+    """Delete user playbooks by their IDs.
+
+    Args:
+        org_id (str): Organization ID
+        request (DeleteUserPlaybooksByIdsRequest): The delete request
+
+    Returns:
+        BulkDeleteResponse: Response containing success status and deleted count
+    """
+    reflexio = get_reflexio(org_id=org_id)
+    return reflexio.delete_user_playbooks_by_ids_bulk(request)
+
+
+def clear_user_data(
+    org_id: str, request: ClearUserDataRequest
+) -> ClearUserDataResponse:
+    """Delete all rows scoped to a single ``user_id``.
+
+    Args:
+        org_id (str): Organization ID
+        request (ClearUserDataRequest): Request containing the target user_id
+
+    Returns:
+        ClearUserDataResponse: Response with per-entity deletion counts
+    """
+    reflexio = get_reflexio(org_id=org_id)
+    return reflexio.clear_user_data(request)
+
+
+# ==============================
+# Run playbook aggregation
+# ==============================
+
+
+def run_playbook_aggregation(
+    org_id: str, request: RunPlaybookAggregationRequest
+) -> RunPlaybookAggregationResponse:
+    """Run playbook aggregation for a given agent version and playbook name.
+
+    Args:
+        org_id (str): Organization ID
+        request (RunPlaybookAggregationRequest): The run playbook aggregation request
+
+    Returns:
+        RunPlaybookAggregationResponse: Response containing success status and message
+    """
+    reflexio = get_reflexio(org_id=org_id)
+    try:
+        result = reflexio.run_playbook_aggregation(
+            request.agent_version, request.playbook_name
+        )
+    except Exception as e:
+        with sentry_tags(subsystem="publisher_api", action="run_playbook_aggregation", org_id=org_id):
+            logger.exception("Failed to run playbook aggregation")
+        return RunPlaybookAggregationResponse(success=False, message=str(e))
+
+    if result.get("skipped"):
+        return RunPlaybookAggregationResponse(
+            success=True, message=f"Skipped: {result['skipped']}"
+        )
+
+    message = (
+        f"Processed {result['user_playbooks_processed']} user playbooks, "
+        f"found {result['clusters_found']} clusters, "
+        f"generated {result['playbooks_generated']} agent playbooks"
+    )
+    return RunPlaybookAggregationResponse(success=True, message=message)
+
+
+# ==============================
+# Update playbook status
+# ==============================
+
+
+def update_agent_playbook_status(
+    org_id: str, request: UpdatePlaybookStatusRequest
+) -> UpdatePlaybookStatusResponse:
+    """Update the status of a specific playbook.
+
+    Args:
+        org_id (str): Organization ID
+        request (UpdatePlaybookStatusRequest): The update request
+
+    Returns:
+        UpdatePlaybookStatusResponse: Response containing success status and message
+    """
+    reflexio = get_reflexio(org_id=org_id)
+    try:
+        return reflexio.update_agent_playbook_status(request)
+    except Exception as e:
+        with sentry_tags(subsystem="publisher_api", action="update_playbook_status", org_id=org_id):
+            logger.exception("Failed to update playbook status")
+        return UpdatePlaybookStatusResponse(success=False, msg=str(e))
+
+
+def update_agent_playbook(
+    org_id: str, request: UpdateAgentPlaybookRequest
+) -> UpdateAgentPlaybookResponse:
+    """Update editable fields of an agent playbook.
+
+    Args:
+        org_id (str): Organization ID
+        request (UpdateAgentPlaybookRequest): The update request
+
+    Returns:
+        UpdateAgentPlaybookResponse: Response containing success status and message
+    """
+    reflexio = get_reflexio(org_id=org_id)
+    try:
+        return reflexio.update_agent_playbook(request)
+    except Exception as e:
+        with sentry_tags(subsystem="publisher_api", action="update_agent_playbook", org_id=org_id):
+            logger.exception("Failed to update agent playbook")
+        return UpdateAgentPlaybookResponse(success=False, msg=str(e))
+
+
+def update_user_playbook(
+    org_id: str, request: UpdateUserPlaybookRequest
+) -> UpdateUserPlaybookResponse:
+    """Update editable fields of a user playbook.
+
+    Args:
+        org_id (str): Organization ID
+        request (UpdateUserPlaybookRequest): The update request
+
+    Returns:
+        UpdateUserPlaybookResponse: Response containing success status and message
+    """
+    reflexio = get_reflexio(org_id=org_id)
+    try:
+        return reflexio.update_user_playbook(request)
+    except Exception as e:
+        with sentry_tags(subsystem="publisher_api", action="update_user_playbook", org_id=org_id):
+            logger.exception("Failed to update user playbook")
+        return UpdateUserPlaybookResponse(success=False, msg=str(e))
+
+
+def update_user_profile(
+    org_id: str, request: UpdateUserProfileRequest
+) -> UpdateUserProfileResponse:
+    """Apply a partial update to an existing user profile.
+
+    Args:
+        org_id (str): Organization ID
+        request (UpdateUserProfileRequest): The update request
+
+    Returns:
+        UpdateUserProfileResponse: Response containing success status and message
+    """
+    reflexio = get_reflexio(org_id=org_id)
+    try:
+        return reflexio.update_user_profile(request)
+    except Exception as e:
+        with sentry_tags(subsystem="publisher_api", action="update_user_profile", org_id=org_id):
+            logger.exception("Failed to update user profile")
+        return UpdateUserProfileResponse(success=False, msg=str(e))

package/plugin/vendor/reflexio/reflexio/server/api_endpoints/request_context.py

@@ -0,0 +1,50 @@
+from fastapi import Depends
+
+from reflexio.server._auth import default_get_org_id
+from reflexio.server.prompt.prompt_manager import PromptManager
+from reflexio.server.services.configurator.base_configurator import BaseConfigurator
+from reflexio.server.services.configurator.configurator import get_configurator_class
+
+
+class RequestContext:
+    def __init__(
+        self,
+        org_id: str,
+        storage_base_dir: str | None = None,
+        configurator: BaseConfigurator | None = None,
+    ):
+        self.org_id = str(org_id)
+        self.storage_base_dir = storage_base_dir
+        cls = get_configurator_class()
+        self.configurator = configurator or cls(org_id, base_dir=storage_base_dir)
+        self.prompt_manager = PromptManager()
+        self.storage = self.configurator.create_storage(
+            storage_config=self.configurator.get_current_storage_configuration(),
+        )
+
+    def is_storage_configured(self) -> bool:
+        """Check if storage is configured and available.
+
+        Returns:
+            bool: True if storage is configured, False otherwise
+        """
+        return self.storage is not None
+
+
+def get_request_context(
+    org_id: str = Depends(default_get_org_id),
+) -> RequestContext:
+    """FastAPI dependency that builds a RequestContext for the calling org.
+
+    The ``org_id`` parameter is resolved through :func:`default_get_org_id`,
+    which enterprise deployments override via ``app.dependency_overrides`` in
+    :func:`create_app` to plug in real auth (e.g. Bearer-token org resolution).
+    Tests that need a fixed context override this function directly.
+
+    Args:
+        org_id (str): Organisation identifier resolved by the auth layer.
+
+    Returns:
+        RequestContext: Fully initialised context with storage attached.
+    """
+    return RequestContext(org_id=org_id)

package/plugin/vendor/reflexio/reflexio/server/api_endpoints/stall_state_api.py

@@ -0,0 +1,100 @@
+"""HTTP endpoints exposing the stall_state row."""
+
+from __future__ import annotations
+
+from fastapi import APIRouter, Depends, HTTPException
+
+from reflexio.models.api_schema.stall_state_schema import (
+    MarkNotifiedResponse,
+    StallStateResponse,
+)
+from reflexio.server.api_endpoints.request_context import (
+    RequestContext,
+    get_request_context,
+)
+from reflexio.server.services.storage.storage_base import BaseStorage
+
+router = APIRouter(tags=["stall_state"])
+
+_UNSUPPORTED_DETAIL = "Stall state is not supported by the configured storage backend"
+
+
+def _require_storage(ctx: RequestContext) -> BaseStorage:
+    """Return ``ctx.storage`` or raise 503 when storage isn't configured.
+
+    Cloud-mode deployments may run with ``ctx.storage is None`` until the
+    caller provisions a backend; stall_state has no meaningful response in
+    that state, so we surface 503 instead of an ``AttributeError``.
+
+    Args:
+        ctx (RequestContext): The injected request context.
+
+    Returns:
+        BaseStorage: The configured storage backend.
+
+    Raises:
+        HTTPException: 503 when storage is not configured.
+    """
+    if not ctx.is_storage_configured() or ctx.storage is None:
+        raise HTTPException(status_code=503, detail="Storage not configured")
+    return ctx.storage
+
+
+@router.get("/stall_state", response_model=StallStateResponse)
+def read_stall_state(
+    ctx: RequestContext = Depends(get_request_context),
+) -> StallStateResponse:
+    """Return the current singleton stall_state row.
+
+    Args:
+        ctx (RequestContext): Injected request context with storage attached.
+
+    Returns:
+        StallStateResponse: ``stalled=False`` with null fields when clean.
+
+    Raises:
+        HTTPException: 503 when storage is not configured, or when the
+            backend does not implement stall_state (backends without stall_state support).
+    """
+    storage = _require_storage(ctx)
+    try:
+        state = storage.get_stall_state()
+    except NotImplementedError as exc:
+        raise HTTPException(status_code=503, detail=_UNSUPPORTED_DETAIL) from exc
+    return StallStateResponse(
+        stalled=state.stalled,
+        reason=state.reason,
+        stalled_at=state.stalled_at,
+        reset_estimate=state.reset_estimate,
+        notified_in_cc=state.notified_in_cc,
+        error_message=state.error_message,
+    )
+
+
+@router.post("/stall_state/notified", response_model=MarkNotifiedResponse)
+def post_notified(
+    ctx: RequestContext = Depends(get_request_context),
+) -> MarkNotifiedResponse:
+    """Idempotently flip ``notified_in_cc=1`` for the current stall.
+
+    No-op (and still returns 200) when there's no active stall — the SessionStart
+    hook may race with auto-clear.
+
+    Args:
+        ctx (RequestContext): Injected request context with storage attached.
+
+    Returns:
+        MarkNotifiedResponse: ``notified_in_cc=True`` after the call (when stalled),
+            ``False`` when no stall is active.
+
+    Raises:
+        HTTPException: 503 when storage is not configured, or when the
+            backend does not implement stall_state (backends without stall_state support).
+    """
+    storage = _require_storage(ctx)
+    try:
+        storage.mark_stall_notified()
+        state = storage.get_stall_state()
+    except NotImplementedError as exc:
+        raise HTTPException(status_code=503, detail=_UNSUPPORTED_DETAIL) from exc
+    return MarkNotifiedResponse(notified_in_cc=state.notified_in_cc)

package/plugin/vendor/reflexio/reflexio/server/cache/__init__.py

@@ -0,0 +1,15 @@
+"""Reflexio caching module."""
+
+from reflexio.server.cache.reflexio_cache import (
+    clear_reflexio_cache,
+    get_cache_stats,
+    get_reflexio,
+    invalidate_reflexio_cache,
+)
+
+__all__ = [
+    "get_reflexio",
+    "invalidate_reflexio_cache",
+    "clear_reflexio_cache",
+    "get_cache_stats",
+]