claude-smart 0.2.47 → 0.2.48

package/plugin/vendor/reflexio/reflexio/server/routes/system.py

@@ -0,0 +1,261 @@
+"""System/meta/stats/operations route handlers (extracted from api.py, Tier3 A2)."""
+
+import logging
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    pass
+
+from fastapi import (
+    APIRouter,
+    Depends,
+    HTTPException,
+    Request,
+    status,
+)
+
+from reflexio.models.api_schema.retriever_schema import (
+    GetDashboardStatsRequest,
+    GetDashboardStatsResponse,
+    StorageStatsRequest,
+    StorageStatsResponse,
+)
+from reflexio.models.api_schema.service_schemas import (
+    AdminInvalidateCacheRequest,
+    AdminInvalidateCacheResponse,
+    CancelOperationRequest,
+    CancelOperationResponse,
+    ClearUserDataRequest,
+    ClearUserDataResponse,
+    GetOperationStatusRequest,
+    GetOperationStatusResponse,
+    WhoamiResponse,
+)
+from reflexio.server.api_endpoints import (
+    account_api,
+    publisher_api,
+)
+from reflexio.server.auth import (
+    default_get_org_id,
+)
+from reflexio.server.cache import reflexio_cache
+from reflexio.server.rate_limit import limiter
+from reflexio.server.routes._common import _run_limited_api
+
+logger = logging.getLogger(__name__)
+router = APIRouter()
+
+
+@router.get("/")
+def root() -> dict[str, str]:
+    return {
+        "service": "Reflexio API",
+        "docs": "/docs",
+        "health": "/health",
+    }
+
+
+@router.get("/health")
+async def health_check() -> dict[str, str]:
+    """Health check endpoint for ECS/container orchestration."""
+    return {"status": "healthy"}
+
+
+@router.get(
+    "/api/whoami",
+    response_model=WhoamiResponse,
+    response_model_exclude_none=True,
+)
+def whoami_endpoint(
+    org_id: str = Depends(default_get_org_id),
+) -> WhoamiResponse:
+    """Return the caller's org and masked storage routing.
+
+    Powers ``reflexio status``. Safe to call unauthenticated in
+    self-host mode; the enterprise server wraps this in Bearer auth.
+    """
+    return account_api.whoami(org_id=org_id)
+
+
+@router.get(
+    "/api/storage_stats",
+    response_model=StorageStatsResponse,
+    response_model_exclude_none=True,
+)
+@limiter.limit("120/minute")  # Rate limit for read operations
+def storage_stats(
+    request: Request,
+    user_id: str,
+    org_id: str = Depends(default_get_org_id),
+) -> StorageStatsResponse:
+    """Return lightweight metadata about a user's profiles and playbooks.
+
+    Args:
+        request (Request): The HTTP request object (for rate limiting)
+        user_id (str): Target user id, passed as a query parameter so this is
+            a cacheable, idempotent GET.
+        org_id (str): Organization ID
+
+    Returns:
+        StorageStatsResponse: Counts and timestamp range for the user.
+    """
+    return _run_limited_api(
+        org_id,
+        "search",
+        lambda: reflexio_cache.get_reflexio(org_id=org_id).storage_stats(
+            StorageStatsRequest(user_id=user_id)
+        ),
+    )
+
+
+@router.post(
+    "/api/clear_user_data",
+    response_model=ClearUserDataResponse,
+    response_model_exclude_none=True,
+)
+@limiter.limit("10/minute")
+def clear_user_data(
+    request: Request,
+    payload: ClearUserDataRequest,
+    org_id: str = Depends(default_get_org_id),
+) -> ClearUserDataResponse:
+    """Delete all rows scoped to a single ``user_id``.
+
+    Removes the user's interactions, user playbooks, profiles, and
+    requests. Does NOT touch ``agent_playbooks`` — they are
+    intentionally shared cross-project. Used by paired-protocol
+    harnesses (e.g. SWE-bench) to isolate per-task data on a shared
+    backend without one task's clear-all nuking another in-flight
+    task's rows.
+
+    Args:
+        request (ClearUserDataRequest): Request containing the target user_id
+        org_id (str): Organization ID
+
+    Returns:
+        ClearUserDataResponse: Response with per-entity deletion counts
+    """
+    return publisher_api.clear_user_data(org_id=org_id, request=payload)
+
+
+@router.post("/api/admin/cache/invalidate")
+def admin_invalidate_cache(
+    payload: AdminInvalidateCacheRequest,
+    org_id: str = Depends(default_get_org_id),
+) -> AdminInvalidateCacheResponse:
+    """Explicitly evict the per-org Reflexio cache entry.
+
+    Necessary when the running config has been mutated through a
+    channel the server can't observe — e.g. another replica wrote to
+    the shared DB, or an operator hand-edited a self-host config file
+    on a backend that doesn't support cheap version probing. The
+    file-mtime check (Phase 1) and DB version check (Phase 3) cover
+    most cases automatically; this endpoint is the manual escape hatch.
+
+    Auth uses the same dependency as ``/api/set_config`` — callers
+    can only invalidate their own org's cache. If the request body
+    supplies ``org_id`` it must match the dep-resolved value;
+    cross-org invalidation is intentionally NOT exposed here.
+
+    Args:
+        payload: Optional ``org_id`` (verification only — must match
+            the caller's authenticated org if provided).
+        org_id: Organization ID resolved by the auth layer.
+
+    Returns:
+        AdminInvalidateCacheResponse: ``invalidated`` is True iff an
+        entry was evicted (False is a successful no-op when nothing
+        was cached).
+
+    Raises:
+        HTTPException: 403 when the body's ``org_id`` differs from the
+            caller's authenticated org.
+    """
+    if payload.org_id is not None and payload.org_id != org_id:
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail=(
+                "Cross-org cache invalidation is not supported; "
+                "omit org_id or pass your own."
+            ),
+        )
+    invalidated = reflexio_cache.invalidate_reflexio_cache(org_id=org_id)
+    return AdminInvalidateCacheResponse(invalidated=invalidated, org_id=org_id)
+
+
+@router.post(
+    "/api/get_dashboard_stats",
+    response_model=GetDashboardStatsResponse,
+    response_model_exclude_none=True,
+)
+@limiter.limit("30/minute")
+def get_dashboard_stats(
+    request: Request,
+    payload: GetDashboardStatsRequest,
+    org_id: str = Depends(default_get_org_id),
+) -> GetDashboardStatsResponse:
+    """Get comprehensive dashboard statistics including counts and time-series data.
+
+    Args:
+        request (GetDashboardStatsRequest): Request containing days_back and granularity
+        org_id (str): Organization ID
+
+    Returns:
+        GetDashboardStatsResponse: Response containing dashboard statistics
+    """
+    # Create Reflexio instance
+    reflexio = reflexio_cache.get_reflexio(org_id=org_id)
+
+    # Get dashboard stats using Reflexio's method
+    return reflexio.get_dashboard_stats(payload)
+
+
+@router.get(
+    "/api/get_operation_status",
+    response_model=GetOperationStatusResponse,
+    response_model_exclude_none=True,
+)
+def get_operation_status_endpoint(
+    service_name: str = "profile_generation",
+    org_id: str = Depends(default_get_org_id),
+) -> GetOperationStatusResponse:
+    """Get the status of an operation (e.g., profile generation rerun or manual).
+
+    Args:
+        service_name (str): The service name to query. Defaults to "profile_generation"
+        org_id (str): Organization ID
+
+    Returns:
+        GetOperationStatusResponse: Response containing operation status info
+    """
+    # Create Reflexio instance
+    reflexio = reflexio_cache.get_reflexio(org_id=org_id)
+
+    # Get operation status
+    request = GetOperationStatusRequest(service_name=service_name)
+    return reflexio.get_operation_status(request)
+
+
+@router.post(
+    "/api/cancel_operation",
+    response_model=CancelOperationResponse,
+    response_model_exclude_none=True,
+)
+@limiter.limit("10/minute")
+def cancel_operation_endpoint(
+    request: Request,
+    payload: CancelOperationRequest,
+    org_id: str = Depends(default_get_org_id),
+) -> CancelOperationResponse:
+    """Cancel an in-progress operation (rerun or manual generation).
+
+    Args:
+        request (Request): The HTTP request object (for rate limiting)
+        payload (CancelOperationRequest): Request containing optional service_name
+        org_id (str): Organization ID
+
+    Returns:
+        CancelOperationResponse: Response with list of services that were cancelled
+    """
+    reflexio = reflexio_cache.get_reflexio(org_id=org_id)
+    return reflexio.cancel_operation(payload)

package/plugin/vendor/reflexio/reflexio/server/scheduling.py

@@ -0,0 +1,132 @@
+"""Shared thread-lifecycle base for the process-local polling schedulers.
+
+Reflexio runs a family of background daemons — extraction resume, lineage GC,
+and (in the enterprise layer) billing ship / lease / period-close / integrity /
+audit / offline-tuner / governance-retention / invitation-reclamation. Every one
+of them hand-rolled the SAME thread mechanics: a :class:`threading.Event`
+stop-signal, a daemon :class:`threading.Thread` running a ``while not
+stop.is_set()`` loop, and a ``.join(timeout)`` graceful stop.
+
+:class:`ThreadedScheduler` captures ONLY those mechanics. Each scheduler keeps
+its own poll interval, work body, gating, and log lines — supplied via a small
+set of hooks so no observable behaviour changes:
+
+- :meth:`_run_once` performs one tick (catching its own errors) and returns the
+  number of seconds to wait before the next tick. A scheduler that reads its
+  interval from config each tick keeps doing exactly that by returning the fresh
+  value.
+- :meth:`_should_start` can veto startup (the enterprise schedulers whose
+  ``start`` is a logged no-op when a feature gate is off).
+- :meth:`_on_started` / :meth:`_on_stopped` emit each scheduler's own start/stop
+  log line (through its own module logger, so output is byte-identical).
+
+A scheduler whose loop is materially different (e.g. a bounded-attempt retrier
+that waits *before* each attempt and exits on first success) may override
+:meth:`_run_loop` wholesale and still reuse :meth:`start` / :meth:`stop` /
+:meth:`is_running`.
+
+This module is an OSS public seam: it imports only the standard library and
+nothing from ``reflexio_ext``.
+"""
+
+from __future__ import annotations
+
+import threading
+
+
+class ThreadedScheduler:
+    """Base for a process-local daemon that ticks on a background thread.
+
+    Owns the shared thread mechanics only: a stop :class:`threading.Event`, a
+    daemon thread, an idempotent :meth:`start`, and a join-with-timeout
+    :meth:`stop`. Subclasses supply the per-tick work + cadence via
+    :meth:`_run_once` (or override :meth:`_run_loop` for a bespoke loop shape).
+
+    Args:
+        thread_name (str): OS thread name for the daemon (aids debugging / logs).
+    """
+
+    def __init__(self, *, thread_name: str) -> None:
+        self._thread_name = thread_name
+        self._stop_event = threading.Event()
+        self._thread: threading.Thread | None = None
+
+    def start(self) -> None:
+        """Start the daemon thread, unless it is gated off or already running.
+
+        Calls :meth:`_should_start` first (a subclass gate that can log + veto),
+        then the idempotent alive-check, then spawns the thread and calls
+        :meth:`_on_started`.
+        """
+        if not self._should_start():
+            return
+        if self._thread is not None and self._thread.is_alive():
+            return
+        self._stop_event.clear()
+        self._thread = threading.Thread(
+            target=self._run_loop,
+            name=self._thread_name,
+            daemon=True,
+        )
+        self._thread.start()
+        self._on_started()
+
+    def stop(self, *, timeout_seconds: float = 5.0) -> None:
+        """Signal the loop to stop and join the thread.
+
+        Args:
+            timeout_seconds (float): Max seconds to wait for the thread to exit.
+        """
+        self._stop_event.set()
+        if self._thread is not None:
+            self._thread.join(timeout=timeout_seconds)
+            # Only drop the reference once the thread has actually exited. If the
+            # join timed out (a slow ``_run_once`` still running), keep it so
+            # ``is_running()`` stays true and a subsequent ``start()`` refuses to
+            # spawn a second loop while the first is alive.
+            if not self._thread.is_alive():
+                self._thread = None
+        self._on_stopped()
+
+    def is_running(self) -> bool:
+        """Return whether the background thread exists and is alive.
+
+        Returns:
+            bool: True when the loop thread is running.
+        """
+        return self._thread is not None and self._thread.is_alive()
+
+    # -- Overridable hooks ---------------------------------------------------
+
+    def _should_start(self) -> bool:
+        """Return whether :meth:`start` should spawn the thread (default True).
+
+        Override to gate startup behind a feature flag; the override owns any
+        "not starting" log line.
+        """
+        return True
+
+    def _on_started(self) -> None:
+        """Hook run after the thread starts (default no-op); override to log."""
+
+    def _on_stopped(self) -> None:
+        """Hook run after the thread joins (default no-op); override to log."""
+
+    def _run_once(self) -> float:
+        """Run one tick and return the seconds to wait before the next.
+
+        Implementations MUST catch their own per-tick errors — a raise here would
+        kill the daemon thread. The returned value is passed straight to
+        ``stop_event.wait`` as the inter-tick delay, so a subclass may compute a
+        fresh interval each tick (e.g. from config).
+
+        Returns:
+            float: Seconds to wait before the next tick.
+        """
+        raise NotImplementedError
+
+    def _run_loop(self) -> None:
+        """Drive :meth:`_run_once` until stopped, waiting its returned interval."""
+        while not self._stop_event.is_set():
+            interval = self._run_once()
+            self._stop_event.wait(interval)

package/plugin/vendor/reflexio/reflexio/server/services/README.md

@@ -23,7 +23,8 @@ strings before deleting old import paths in the same PR.
 | File | Purpose |
 |------|---------|
 | `generation_service.py` | `GenerationService` — saves interactions, runs profile + playbook generation in parallel (ThreadPoolExecutor), schedules deferred evaluation when `session_id` is present. |
-| `base_generation_service.py` | `BaseGenerationService` — abstract base; the **Service Pattern** (load configs → create actors → run in parallel → save results). Per-extractor timeout `EXTRACTOR_TIMEOUT_SECONDS = 300`. |
+| `publish_learning_worker.py` | Deferred post-persist publish learning worker — queues async publish learning after durable interaction writes and requeues under publish limiter pressure. |
+| `base_generation_service.py` + `base_generation/` | `BaseGenerationService` stable import surface plus mixins for batch progress, config filtering, extraction lifecycle, should-run prechecks, status transitions, and usage billing. Per-extractor timeout `EXTRACTOR_TIMEOUT_SECONDS = 300`. |
 | `operation_state_utils.py` | `OperationStateManager` — all `_operation_state` access (progress, concurrency locks, extractor/aggregator bookmarks, cluster fingerprints, cancellation). |
 | `extractor_config_utils.py`, `extractor_interaction_utils.py` | Filter extractors by source / `allow_manual_trigger` / names; per-extractor stride + window + bookmark handling. |
 | `deduplication_utils.py`, `service_utils.py`, `embedding_text.py` | LLM dedup helpers (used by `ProfileConsolidator` + `PlaybookConsolidator`), message construction / JSON extraction / response logging, embedding text builders. |
@@ -62,7 +63,7 @@ strings before deleting old import paths in the same PR.
 
 | Path | Purpose |
 |------|---------|
-| `storage/` | `storage_base/` (`BaseStorage` split by domain, including `_governance.py` and `_lineage.py`) + `sqlite_storage/` (governance validation, retention barriers, lineage/tombstones) + `governance_validation.py` + `retention*.py`. Access via `request_context.storage` only. |
+| `storage/` | `storage_base/` and `sqlite_storage/` keep legacy domain facades while focused subpackages own `profiles/`, `playbook/`, `agent_run/`, `governance/`, and SQLite `base/` helpers; plus `governance_validation.py` and `retention*.py`. Access via `request_context.storage` only. |
 | `configurator/` | `DefaultConfigurator` — loads YAML config and creates the storage backend. |
 
 ## Key Rules

package/plugin/vendor/reflexio/reflexio/server/services/base_generation/__init__.py

@@ -0,0 +1,38 @@
+"""Sub-mixins composed into ``BaseGenerationService`` (Tier-1b decomposition).
+
+Each mixin holds a cohesive bucket of the ``BaseGenerationService`` behaviour and
+is composed into the base via MRO in
+``reflexio.server.services.base_generation_service``. The residual base keeps the
+ABC skeleton (all abstract methods), ``__init__`` (per-run field inits), the ``run``
+FIFO drain, ``_run_generation`` billing emit-ordering, and the lock/queue helpers.
+"""
+
+from reflexio.server.services.base_generation._batch_progress import (
+    BatchProgressMixin,
+)
+from reflexio.server.services.base_generation._config_filter import (
+    ConfigFilterMixin,
+)
+from reflexio.server.services.base_generation._extraction_lifecycle import (
+    ExtractionRunLifecycleMixin,
+)
+from reflexio.server.services.base_generation._should_run import (
+    ShouldRunPrecheckMixin,
+)
+from reflexio.server.services.base_generation._status_change import (
+    StatusChangeMixin,
+    StatusChangeOperation,
+)
+from reflexio.server.services.base_generation._usage_billing import (
+    UsageBillingMixin,
+)
+
+__all__ = [
+    "BatchProgressMixin",
+    "ConfigFilterMixin",
+    "ExtractionRunLifecycleMixin",
+    "ShouldRunPrecheckMixin",
+    "StatusChangeMixin",
+    "StatusChangeOperation",
+    "UsageBillingMixin",
+]