claude-smart 0.2.42 → 0.2.44

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

@@ -0,0 +1,176 @@
+from typing import Any
+
+from reflexio.lib._base import (
+    STORAGE_NOT_CONFIGURED_MSG,
+    ReflexioBase,
+    _require_storage,
+)
+from reflexio.models.api_schema.service_schemas import (
+    ManualPlaybookGenerationRequest,
+    ManualPlaybookGenerationResponse,
+    ManualProfileGenerationRequest,
+    ManualProfileGenerationResponse,
+    RerunPlaybookGenerationRequest,
+    RerunPlaybookGenerationResponse,
+    RerunProfileGenerationRequest,
+    RerunProfileGenerationResponse,
+)
+
+
+class GenerationMixin(ReflexioBase):
+    def run_playbook_aggregation(
+        self,
+        agent_version: str,
+        playbook_name: str | None = None,  # noqa: ARG002 — deprecated, accepted but ignored
+    ) -> dict:
+        """Run playbook aggregation for a given agent version.
+
+        Args:
+            agent_version (str): The agent version
+            playbook_name (str | None): Deprecated compatibility input. Aggregation is
+                singleton (one playbook kind per org), so name-based selection is ignored.
+
+        Returns:
+            dict: Aggregation stats (clusters_found, user_playbooks_processed, playbooks_generated)
+
+        Raises:
+            ValueError: If storage is not configured
+        """
+        if not self._is_storage_configured():
+            raise ValueError(STORAGE_NOT_CONFIGURED_MSG)
+        from reflexio.server.services.playbook.playbook_aggregator import (
+            PlaybookAggregator,
+        )
+        from reflexio.server.services.playbook.playbook_service_utils import (
+            PlaybookAggregatorRequest,
+        )
+
+        playbook_aggregator = PlaybookAggregator(
+            llm_client=self.llm_client,
+            request_context=self.request_context,
+            agent_version=agent_version,
+        )
+        aggregator_request = PlaybookAggregatorRequest(
+            agent_version=agent_version,
+            rerun=True,
+        )
+        return playbook_aggregator.run(aggregator_request)
+
+    def _run_generation_service(
+        self,
+        request: Any,
+        request_type: type,
+        service_cls: type,
+        output_pending: bool,
+        run_method: str,
+    ) -> Any:
+        """Shared logic for rerun and manual generation endpoints."""
+        if isinstance(request, dict):
+            request = request_type(**request)
+        service = service_cls(
+            llm_client=self.llm_client,
+            request_context=self.request_context,
+            allow_manual_trigger=True,
+            output_pending_status=output_pending,
+        )
+        return getattr(service, run_method)(request)
+
+    @_require_storage(RerunProfileGenerationResponse, msg_field="msg")
+    def rerun_profile_generation(
+        self,
+        request: RerunProfileGenerationRequest | dict,
+    ) -> RerunProfileGenerationResponse:
+        """Rerun profile generation for one or all users with filtered interactions.
+
+        Args:
+            request (Union[RerunProfileGenerationRequest, dict]): The rerun request
+
+        Returns:
+            RerunProfileGenerationResponse: Response containing success status, message, and count of profiles generated
+        """
+        from reflexio.server.services.profile.profile_generation_service import (
+            ProfileGenerationService,
+        )
+
+        return self._run_generation_service(
+            request,
+            RerunProfileGenerationRequest,
+            ProfileGenerationService,
+            output_pending=True,
+            run_method="run_rerun",
+        )
+
+    @_require_storage(ManualProfileGenerationResponse, msg_field="msg")
+    def manual_profile_generation(
+        self,
+        request: ManualProfileGenerationRequest | dict,
+    ) -> ManualProfileGenerationResponse:
+        """Manually trigger profile generation with window-sized interactions and CURRENT output.
+
+        Args:
+            request (Union[ManualProfileGenerationRequest, dict]): The request
+
+        Returns:
+            ManualProfileGenerationResponse: Response containing success status, message, and count of profiles generated
+        """
+        from reflexio.server.services.profile.profile_generation_service import (
+            ProfileGenerationService,
+        )
+
+        return self._run_generation_service(
+            request,
+            ManualProfileGenerationRequest,
+            ProfileGenerationService,
+            output_pending=False,
+            run_method="run_manual_regular",
+        )
+
+    @_require_storage(RerunPlaybookGenerationResponse, msg_field="msg")
+    def rerun_playbook_generation(
+        self,
+        request: RerunPlaybookGenerationRequest | dict,
+    ) -> RerunPlaybookGenerationResponse:
+        """Rerun playbook generation with filtered interactions.
+
+        Args:
+            request (Union[RerunPlaybookGenerationRequest, dict]): The rerun request
+
+        Returns:
+            RerunPlaybookGenerationResponse: Response containing success status, message, and count of playbooks generated
+        """
+        from reflexio.server.services.playbook.playbook_generation_service import (
+            PlaybookGenerationService,
+        )
+
+        return self._run_generation_service(
+            request,
+            RerunPlaybookGenerationRequest,
+            PlaybookGenerationService,
+            output_pending=True,
+            run_method="run_rerun",
+        )
+
+    @_require_storage(ManualPlaybookGenerationResponse, msg_field="msg")
+    def manual_playbook_generation(
+        self,
+        request: ManualPlaybookGenerationRequest | dict,
+    ) -> ManualPlaybookGenerationResponse:
+        """Manually trigger playbook generation with window-sized interactions and CURRENT output.
+
+        Args:
+            request (Union[ManualPlaybookGenerationRequest, dict]): The generation request
+
+        Returns:
+            ManualPlaybookGenerationResponse: Response containing success status, message, and count of playbooks generated
+        """
+        from reflexio.server.services.playbook.playbook_generation_service import (
+            PlaybookGenerationService,
+        )
+
+        return self._run_generation_service(
+            request,
+            ManualPlaybookGenerationRequest,
+            PlaybookGenerationService,
+            output_pending=False,
+            run_method="run_manual_regular",
+        )

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

@@ -0,0 +1,334 @@
+from collections.abc import Callable
+
+from reflexio.lib._base import (
+    STORAGE_NOT_CONFIGURED_MSG,
+    ReflexioBase,
+    _require_storage,
+)
+from reflexio.lib._storage_labels import describe_storage
+from reflexio.models.api_schema.retriever_schema import (
+    GetInteractionsRequest,
+    GetInteractionsResponse,
+    SearchInteractionRequest,
+    SearchInteractionResponse,
+)
+from reflexio.models.api_schema.service_schemas import (
+    BulkDeleteResponse,
+    ClearUserDataRequest,
+    ClearUserDataResponse,
+    DeleteRequestRequest,
+    DeleteRequestResponse,
+    DeleteRequestsByIdsRequest,
+    DeleteSessionRequest,
+    DeleteSessionResponse,
+    DeleteUserInteractionRequest,
+    DeleteUserInteractionResponse,
+    PublishUserInteractionRequest,
+    PublishUserInteractionResponse,
+)
+from reflexio.server.services.generation_service import GenerationService
+
+
+def _safe_count(counter: Callable[[], int]) -> int:
+    """Return a storage count, or 0 on failure.
+
+    Used to snapshot profile/playbook counts around a publish so the CLI
+    can report deltas. Never raises — a storage hiccup during counting
+    shouldn't block the publish itself from returning a useful response.
+
+    Args:
+        counter (Callable[[], int]): Zero-arg thunk returning an integer
+            count (e.g. ``storage.count_all_profiles``).
+
+    Returns:
+        int: The count, or 0 if the thunk raised.
+    """
+    try:
+        return counter()
+    except Exception:  # noqa: BLE001
+        return 0
+
+
+class InteractionsMixin(ReflexioBase):
+    def publish_interaction(
+        self,
+        request: PublishUserInteractionRequest | dict,
+    ) -> PublishUserInteractionResponse:
+        """Publish user interactions.
+
+        Args:
+            request (Union[PublishUserInteractionRequest, dict]): The publish user interaction request
+
+        Returns:
+            PublishUserInteractionResponse: Response containing success status and message
+        """
+        if not self._is_storage_configured():
+            return PublishUserInteractionResponse(
+                success=False, message=STORAGE_NOT_CONFIGURED_MSG
+            )
+        # Snapshot profile + playbook totals before the run so we can report
+        # how many rows the extraction actually produced. These are best-effort
+        # counts — we don't distinguish added vs. updated, only net deltas.
+        storage = self._get_storage()
+        before_profiles = _safe_count(storage.count_all_profiles)
+        before_playbooks = _safe_count(storage.count_user_playbooks)
+
+        generation_service = GenerationService(
+            llm_client=self.llm_client,
+            request_context=self.request_context,
+        )
+        # Describe the storage the server is actually writing to so the CLI
+        # can surface it. Computed once, up-front, so the response reflects
+        # the resolved config at the moment of the call.
+        storage_type, storage_label = describe_storage(
+            self.request_context.configurator.get_current_storage_configuration()
+        )
+        try:
+            # Convert dict to PublishUserInteractionRequest if needed
+            if isinstance(request, dict):
+                request = PublishUserInteractionRequest(**request)
+            result = generation_service.run(request)
+            after_profiles = _safe_count(storage.count_all_profiles)
+            after_playbooks = _safe_count(storage.count_user_playbooks)
+            # Don't concatenate warnings into the message field — they
+            # already travel through ``result.warnings`` and the CLI
+            # renders them separately. Embedding multi-line error
+            # strings (e.g. server-side Supabase stack traces) into
+            # ``message`` turns the CLI's one-line header into a
+            # terminal dump.
+            if result.warnings:
+                message = (
+                    f"Interaction published successfully with "
+                    f"{len(result.warnings)} warning(s)"
+                )
+            else:
+                message = "Interaction published successfully"
+            return PublishUserInteractionResponse(
+                success=True,
+                message=message,
+                warnings=result.warnings,
+                request_id=result.request_id,
+                storage_type=storage_type,
+                storage_label=storage_label,
+                profiles_added=max(0, after_profiles - before_profiles),
+                playbooks_added=max(0, after_playbooks - before_playbooks),
+            )
+        except Exception as e:
+            return PublishUserInteractionResponse(success=False, message=str(e))
+
+    def search_interactions(
+        self,
+        request: SearchInteractionRequest | dict,
+    ) -> SearchInteractionResponse:
+        """Search for user interactions.
+
+        Args:
+            request (SearchInteractionRequest): The search request
+
+        Returns:
+            SearchInteractionResponse: Response containing matching interactions
+        """
+        if not self._is_storage_configured():
+            return SearchInteractionResponse(
+                success=True, interactions=[], msg=STORAGE_NOT_CONFIGURED_MSG
+            )
+        if isinstance(request, dict):
+            request = SearchInteractionRequest(**request)
+        query_embedding = self._maybe_get_query_embedding(
+            request.query, request.search_mode
+        )
+        interactions = self._get_storage().search_interaction(
+            request, query_embedding=query_embedding
+        )
+        return SearchInteractionResponse(
+            success=True,
+            interactions=interactions,
+            msg=f"Found {len(interactions)} matching interaction(s)",
+        )
+
+    @_require_storage(DeleteUserInteractionResponse)
+    def delete_interaction(
+        self,
+        request: DeleteUserInteractionRequest | dict,
+    ) -> DeleteUserInteractionResponse:
+        """Delete user interactions.
+
+        Args:
+            request (DeleteUserInteractionRequest): The delete request
+
+        Returns:
+            DeleteUserInteractionResponse: Response containing success status and message
+        """
+        if isinstance(request, dict):
+            request = DeleteUserInteractionRequest(**request)
+        self._get_storage().delete_user_interaction(request)
+        return DeleteUserInteractionResponse(
+            success=True, message="Deleted successfully"
+        )
+
+    @_require_storage(DeleteRequestResponse)
+    def delete_request(
+        self,
+        request: DeleteRequestRequest | dict,
+    ) -> DeleteRequestResponse:
+        """Delete a request and all its associated interactions.
+
+        Args:
+            request (DeleteRequestRequest): The delete request containing request_id
+
+        Returns:
+            DeleteRequestResponse: Response containing success status and message
+        """
+        if isinstance(request, dict):
+            request = DeleteRequestRequest(**request)
+        self._get_storage().delete_request(request.request_id)
+        return DeleteRequestResponse(success=True, message="Deleted successfully")
+
+    @_require_storage(DeleteSessionResponse)
+    def delete_session(
+        self,
+        request: DeleteSessionRequest | dict,
+    ) -> DeleteSessionResponse:
+        """Delete all requests and interactions in a session.
+
+        Args:
+            request (DeleteSessionRequest): The delete request containing session_id
+
+        Returns:
+            DeleteSessionResponse: Response containing success status, message, and deleted count
+        """
+        if isinstance(request, dict):
+            request = DeleteSessionRequest(**request)
+        deleted_count = self._get_storage().delete_session(request.session_id)
+        return DeleteSessionResponse(
+            success=True,
+            deleted_requests_count=deleted_count,
+            message=f"Deleted {deleted_count} item(s)",
+        )
+
+    @_require_storage(BulkDeleteResponse)
+    def delete_all_interactions_bulk(self) -> BulkDeleteResponse:
+        """Delete all requests and their associated interactions.
+
+        Returns:
+            BulkDeleteResponse: Response containing success status and deleted count
+        """
+        self._get_storage().delete_all_requests()
+        return BulkDeleteResponse(success=True, message="Deleted successfully")
+
+    @_require_storage(BulkDeleteResponse)
+    def delete_requests_by_ids(
+        self,
+        request: DeleteRequestsByIdsRequest | dict,
+    ) -> BulkDeleteResponse:
+        """Delete requests by their IDs.
+
+        Args:
+            request (DeleteRequestsByIdsRequest): The delete request containing request_ids
+
+        Returns:
+            BulkDeleteResponse: Response containing success status and deleted count
+        """
+        if isinstance(request, dict):
+            request = DeleteRequestsByIdsRequest(**request)
+        deleted = self._get_storage().delete_requests_by_ids(request.request_ids)
+        return BulkDeleteResponse(
+            success=True, deleted_count=deleted, message=f"Deleted {deleted} item(s)"
+        )
+
+    @_require_storage(ClearUserDataResponse)
+    def clear_user_data(
+        self,
+        request: ClearUserDataRequest | dict,
+    ) -> ClearUserDataResponse:
+        """Delete all rows scoped to a single ``user_id``.
+
+        Wipes the user's interactions, user playbooks, profiles, and
+        requests. Intentionally does NOT touch ``agent_playbooks`` —
+        those are the cross-project rollup of skills and have no
+        ``user_id`` column. Used by paired-protocol harnesses (e.g.
+        SWE-bench) to isolate per-task data on a shared backend without
+        nuking sibling tasks' rows.
+
+        Args:
+            request (ClearUserDataRequest | dict): Request containing
+                the ``user_id`` whose data should be cleared.
+
+        Returns:
+            ClearUserDataResponse: Per-entity deletion counts.
+        """
+        if isinstance(request, dict):
+            request = ClearUserDataRequest(**request)
+        deleted_counts = self._get_storage().clear_user_data(request.user_id)
+        total = sum(deleted_counts.values())
+        return ClearUserDataResponse(
+            success=True,
+            deleted_counts=deleted_counts,
+            message=f"Cleared {total} row(s) for user {request.user_id!r}",
+        )
+
+    def get_interactions(
+        self,
+        request: GetInteractionsRequest | dict,
+    ) -> GetInteractionsResponse:
+        """Get user interactions.
+
+        Args:
+            request (GetInteractionsRequest): The get request
+
+        Returns:
+            GetInteractionsResponse: Response containing user interactions
+        """
+        if not self._is_storage_configured():
+            return GetInteractionsResponse(
+                success=True, interactions=[], msg=STORAGE_NOT_CONFIGURED_MSG
+            )
+        if isinstance(request, dict):
+            request = GetInteractionsRequest(**request)
+        interactions = self._get_storage().get_user_interaction(request.user_id)
+        interactions = sorted(interactions, key=lambda x: x.created_at, reverse=True)
+
+        # Apply time filters
+        if request.start_time:
+            interactions = [
+                i
+                for i in interactions
+                if i.created_at >= int(request.start_time.timestamp())
+            ]
+        if request.end_time:
+            interactions = [
+                i
+                for i in interactions
+                if i.created_at <= int(request.end_time.timestamp())
+            ]
+
+        # Apply top_k limit
+        if request.top_k:
+            interactions = interactions[: request.top_k]
+
+        return GetInteractionsResponse(
+            success=True,
+            interactions=interactions,
+            msg=f"Found {len(interactions)} interaction(s)",
+        )
+
+    def get_all_interactions(self, limit: int = 100) -> GetInteractionsResponse:
+        """Get all user interactions across all users.
+
+        Args:
+            limit (int, optional): Maximum number of interactions to return. Defaults to 100.
+
+        Returns:
+            GetInteractionsResponse: Response containing all user interactions
+        """
+        if not self._is_storage_configured():
+            return GetInteractionsResponse(
+                success=True, interactions=[], msg=STORAGE_NOT_CONFIGURED_MSG
+            )
+        interactions = self._get_storage().get_all_interactions(limit=limit)
+        interactions = sorted(interactions, key=lambda x: x.created_at, reverse=True)
+        return GetInteractionsResponse(
+            success=True,
+            interactions=interactions,
+            msg=f"Found {len(interactions)} interaction(s)",
+        )

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

@@ -0,0 +1,153 @@
+import logging
+
+from reflexio.lib._base import STORAGE_NOT_CONFIGURED_MSG, ReflexioBase
+from reflexio.models.api_schema.service_schemas import (
+    CancelOperationRequest,
+    CancelOperationResponse,
+    GetOperationStatusRequest,
+    GetOperationStatusResponse,
+    OperationStatus,
+    OperationStatusInfo,
+)
+from reflexio.server.services.operation_state_utils import OperationStateManager
+
+logger = logging.getLogger(__name__)
+
+
+class OperationsMixin(ReflexioBase):
+    def get_operation_status(
+        self, request: GetOperationStatusRequest | dict
+    ) -> GetOperationStatusResponse:
+        """Get the status of an operation.
+
+        Args:
+            request (Union[GetOperationStatusRequest, dict]): Request containing service_name
+
+        Returns:
+            GetOperationStatusResponse: Response containing operation status info
+        """
+        if not self._is_storage_configured():
+            return GetOperationStatusResponse(
+                success=True, operation_status=None, msg=STORAGE_NOT_CONFIGURED_MSG
+            )
+        try:
+            # Convert dict to request object if needed
+            if isinstance(request, dict):
+                request = GetOperationStatusRequest(**request)
+
+            # Build the progress key: {service_name}::{org_id}::progress
+            org_id = self.request_context.org_id
+            progress_key = f"{request.service_name}::{org_id}::progress"
+
+            # Get operation state from storage
+            state_entry = self._get_storage().get_operation_state(progress_key)
+
+            if not state_entry:
+                return GetOperationStatusResponse(
+                    success=False,
+                    msg=f"No operation found for service: {request.service_name}",
+                )
+
+            # Extract the actual operation_state from the storage wrapper
+            # Storage returns: {"service_name": "...", "operation_state": {...}, "updated_at": "..."}
+            operation_state = state_entry.get("operation_state", state_entry)
+
+            # Auto-recover stale IN_PROGRESS operations so the frontend
+            # doesn't show "in progress" forever after a crash/restart
+            if operation_state.get("status") == OperationStatus.IN_PROGRESS.value:
+                from datetime import UTC, datetime
+
+                from reflexio.server.services.operation_state_utils import (
+                    BATCH_STALE_PROGRESS_SECONDS,
+                )
+
+                started_at = operation_state.get("started_at")
+                if started_at is not None:
+                    current_time = int(datetime.now(UTC).timestamp())
+                    elapsed = current_time - started_at
+                    if elapsed > BATCH_STALE_PROGRESS_SECONDS:
+                        logger.warning(
+                            "Stale %s operation detected during status poll "
+                            "(started %d seconds ago), auto-marking as FAILED",
+                            request.service_name,
+                            elapsed,
+                        )
+                        operation_state["status"] = OperationStatus.FAILED.value
+                        operation_state["completed_at"] = current_time
+                        operation_state["error_message"] = (
+                            f"Auto-recovered: operation was stuck for {elapsed}s "
+                            f"(threshold: {BATCH_STALE_PROGRESS_SECONDS}s)"
+                        )
+                        self._get_storage().update_operation_state(
+                            progress_key, operation_state
+                        )
+
+            # Convert to OperationStatusInfo
+            operation_status_info = OperationStatusInfo(**operation_state)
+
+            return GetOperationStatusResponse(
+                success=True,
+                operation_status=operation_status_info,
+                msg="Retrieved operation status successfully",
+            )
+
+        except Exception as e:
+            return GetOperationStatusResponse(
+                success=False, msg=f"Failed to get operation status: {str(e)}"
+            )
+
+    def cancel_operation(
+        self, request: CancelOperationRequest | dict
+    ) -> CancelOperationResponse:
+        """Cancel an in-progress operation (rerun or manual generation).
+
+        Sets a cancellation flag so the batch loop stops before the next user.
+        The current LLM call finishes, but no new users are started.
+
+        Args:
+            request (Union[CancelOperationRequest, dict]): Request containing optional service_name.
+                If service_name is None, cancels both profile_generation and playbook_generation.
+
+        Returns:
+            CancelOperationResponse: Response with list of services that were cancelled
+        """
+        if not self._is_storage_configured():
+            return CancelOperationResponse(
+                success=False, msg=STORAGE_NOT_CONFIGURED_MSG
+            )
+        try:
+            if isinstance(request, dict):
+                request = CancelOperationRequest(**request)
+
+            # Determine which services to cancel
+            if request.service_name:
+                service_names = [request.service_name]
+            else:
+                service_names = ["profile_generation", "playbook_generation"]
+
+            cancelled_services = []
+            for svc in service_names:
+                mgr = OperationStateManager(
+                    storage=self._get_storage(),
+                    org_id=self.request_context.org_id,
+                    service_name=svc,
+                )
+                if mgr.request_cancellation():
+                    cancelled_services.append(svc)
+
+            if cancelled_services:
+                return CancelOperationResponse(
+                    success=True,
+                    cancelled_services=cancelled_services,
+                    msg=f"Cancellation requested for: {', '.join(cancelled_services)}",
+                )
+            return CancelOperationResponse(
+                success=True,
+                cancelled_services=[],
+                msg="No in-progress operations found to cancel",
+            )
+
+        except Exception as e:
+            return CancelOperationResponse(
+                success=False, msg=f"Failed to cancel operation: {str(e)}"
+            )