claude-smart 0.2.41 → 0.2.43

package/plugin/vendor/reflexio/reflexio/server/site_var/feature_flags.py

@@ -0,0 +1,116 @@
+"""
+Feature flags module for gating features per organization.
+
+Reads feature flag configuration from site_var and provides helpers
+to check whether a given feature is enabled for an organization.
+"""
+
+import logging
+
+from reflexio.server.site_var.site_var_manager import SiteVarManager
+
+logger = logging.getLogger(__name__)
+
+
+def _get_feature_flags_config() -> dict:
+    """
+    Load the feature_flags site var configuration.
+
+    Returns:
+        dict: The full feature flags config, or empty dict if not found.
+    """
+    config = SiteVarManager().get_site_var("feature_flags")
+    if config is None or not isinstance(config, dict):
+        logger.warning(
+            "feature_flags site var not found or invalid, defaulting to empty config"
+        )
+        return {}
+    return config
+
+
+def is_feature_enabled(org_id: str, feature_name: str) -> bool:
+    """
+    Check if a feature is enabled for a given organization.
+
+    A feature is enabled if:
+    - The feature's "enabled" field is True (globally enabled), OR
+    - The org_id is in the feature's "enabled_org_ids" list.
+
+    If the feature is not found in config, it defaults to enabled (fail-open).
+
+    Args:
+        org_id (str): The organization ID to check
+        feature_name (str): The feature flag name (e.g. "deduplicator")
+
+    Returns:
+        bool: True if the feature is enabled for this org
+    """
+    config = _get_feature_flags_config()
+    feature_config = config.get(feature_name)
+
+    if feature_config is None:
+        # Unknown feature — default to enabled (fail-open)
+        return True
+
+    if feature_config.get("enabled", False):
+        return True
+
+    enabled_org_ids = feature_config.get("enabled_org_ids", [])
+    return org_id in enabled_org_ids
+
+
+def get_all_feature_flags(org_id: str) -> dict[str, bool]:
+    """
+    Get the resolved enabled/disabled state of all feature flags for an organization.
+
+    Args:
+        org_id (str): The organization ID to check
+
+    Returns:
+        dict[str, bool]: Mapping of feature name to enabled status
+    """
+    config = _get_feature_flags_config()
+    result: dict[str, bool] = {}
+    for feature_name in config:
+        result[feature_name] = is_feature_enabled(org_id, feature_name)
+    return result
+
+
+def is_invitation_only_enabled() -> bool:
+    """
+    Check if invitation-only registration mode is enabled globally.
+
+    Returns:
+        bool: True if invitation-only mode is enabled
+    """
+    config = _get_feature_flags_config()
+    invitation_config = config.get("invitation_only")
+    if invitation_config is None:
+        return False
+    return invitation_config.get("enabled", False)
+
+
+def is_deduplicator_enabled(org_id: str) -> bool:
+    """
+    Convenience check for whether the deduplicator is enabled for an org.
+
+    Args:
+        org_id (str): The organization ID to check
+
+    Returns:
+        bool: True if deduplicator is enabled
+    """
+    return is_feature_enabled(org_id, "deduplicator")
+
+
+def is_resumable_extraction_agent_enabled(org_id: str) -> bool:
+    """
+    Convenience check for whether classic extraction should use the resumable agent.
+
+    Args:
+        org_id (str): The organization ID to check
+
+    Returns:
+        bool: True if the resumable extraction agent is enabled
+    """
+    return is_feature_enabled(org_id, "resumable_extraction_agent")

package/plugin/vendor/reflexio/reflexio/server/site_var/site_var_manager.py

@@ -0,0 +1,263 @@
+import json
+import logging
+from pathlib import Path
+
+import redis
+
+logger = logging.getLogger(__name__)
+
+
+class SiteVarManager:
+    """
+    Manages site variables by loading JSON or text files from a source directory and caching them in Redis.
+    Each file in the source directory represents a site variable with the filename as the key.
+    Supports both .json and .txt files.
+    """
+
+    def __init__(self, source_dir: str | None = None, enable_redis: bool = False):
+        """
+        Initialize the SiteVarManager with a source directory for site variable files.
+
+        Args:
+            source_dir (Optional[str]): Directory containing JSON or text files for site variables
+            enable_redis (bool): Whether to enable Redis caching (default: False)
+        """
+        self.source_dir = source_dir or str(Path(__file__).parent / "site_var_sources")
+        self.enable_redis = enable_redis
+        self.redis = (
+            redis.Redis(host="localhost", port=6379, db=0) if enable_redis else None
+        )
+
+        # In-memory cache to avoid repeated file/Redis access
+        self._cache: dict[str, str | dict] = {}
+
+        # Ensure source directory exists
+        if not Path(self.source_dir).exists():
+            logger.warning(
+                "Source directory %s does not exist, creating it", self.source_dir
+            )
+            Path(self.source_dir).mkdir(parents=True, exist_ok=True)
+
+    def get_site_var(self, name: str) -> str | dict | None:
+        """
+        Get a site variable by name. Checks in-memory cache first, then Redis cache (if enabled), then loads from file.
+        Supports both JSON and text files.
+
+        Args:
+            name (str): Name of the site variable to retrieve
+
+        Returns:
+            Optional[str | dict]: The site variable value as JSON dict (for JSON files) or plain text (for text files), or None if not found
+        """
+        try:
+            # First check in-memory cache
+            if name in self._cache:
+                logger.debug("Retrieved site var %s from in-memory cache", name)
+                return self._cache[name]
+
+            # Then try to get from Redis cache if enabled
+            if self.enable_redis and self.redis is not None:
+                cached_value = self.redis.get(name)
+                if cached_value is not None:
+                    logger.debug("Retrieved site var %s from Redis cache", name)
+                    decoded_value = cached_value.decode("utf-8")  # type: ignore[reportAttributeAccessIssue]
+                    # Try to parse as JSON for dict values
+                    try:
+                        parsed_value = json.loads(decoded_value)
+                        self._cache[name] = parsed_value
+                        return parsed_value
+                    except json.JSONDecodeError:
+                        # It's a plain text value
+                        self._cache[name] = decoded_value
+                        return decoded_value
+
+            # If not in cache or Redis disabled, try to load from file
+            content = self._load_from_file(name)
+            if content is not None:
+                # Cache in memory
+                self._cache[name] = content
+
+                # Cache in Redis for future use if enabled
+                if self.enable_redis and self.redis is not None:
+                    # Convert dict to JSON string for Redis storage
+                    redis_value = (
+                        json.dumps(content) if isinstance(content, dict) else content
+                    )
+                    self.redis.set(name, redis_value)
+                    logger.debug("Cached site var %s in Redis", name)
+                return content
+            logger.warning("Site var %s not found in Redis or files", name)
+            return None
+
+        except redis.RedisError as e:
+            logger.error("Redis error while getting site var %s: %s", name, str(e))
+            # Fallback to file-based loading
+            content = self._load_from_file(name)
+            if content is not None:
+                self._cache[name] = content
+            return content
+        except Exception as e:
+            logger.error("Error loading site var %s: %s", name, str(e))
+            return None
+
+    def evict_cache(self) -> None:
+        """
+        Evict (clear) all cached site variables from in-memory cache.
+        This forces fresh loading from Redis or files on next access.
+        """
+        cache_size = len(self._cache)
+        self._cache.clear()
+        logger.info("Evicted %d site variables from in-memory cache", cache_size)
+
+    def get_cache_stats(self) -> dict[str, int]:
+        """
+        Get statistics about the in-memory cache.
+
+        Returns:
+            dict[str, int]: Cache statistics including size and key count
+        """
+        return {
+            "cache_size": len(self._cache),
+            "cached_keys": len(list(self._cache.keys())),
+        }
+
+    def load_all_site_vars(self) -> dict[str, str | dict]:
+        """
+        Load all site variables from files in the source directory and cache them in memory and Redis (if enabled).
+        Supports both JSON and text files.
+
+        Returns:
+            dict[str, str | dict]: Dictionary mapping site var names to their values
+        """
+        site_vars = {}
+
+        try:
+            if not Path(self.source_dir).exists():
+                logger.warning("Source directory %s does not exist", self.source_dir)
+                return site_vars
+
+            for filename in [p.name for p in Path(self.source_dir).iterdir()]:
+                if filename.endswith((".json", ".txt")):
+                    name = self._get_name_from_filename(filename)
+                    value = self.get_site_var(name)  # This will use cache automatically
+                    if value is not None:
+                        site_vars[name] = value
+
+            logger.info(
+                "Loaded %d site variables, %d now in cache",
+                len(site_vars),
+                len(self._cache),
+            )
+            return site_vars
+
+        except Exception as e:
+            logger.error("Error loading site variables from directory: %s", str(e))
+            return site_vars
+
+    def list_site_vars(self) -> list[str]:
+        """
+        List all available site variable names from the source directory.
+        Supports both .json and .txt files.
+
+        Returns:
+            list[str]: List of site variable names
+        """
+        try:
+            if not Path(self.source_dir).exists():
+                return []
+
+            return [
+                entry.stem
+                for entry in Path(self.source_dir).iterdir()
+                if entry.name.endswith((".json", ".txt"))
+            ]
+
+        except Exception as e:
+            logger.error("Error listing site variables: %s", str(e))
+            return []
+
+    def _find_file_path(self, name: str) -> str | None:
+        """
+        Find the file path for a site variable, checking both .json and .txt extensions.
+
+        Args:
+            name (str): Name of the site variable
+
+        Returns:
+            Optional[str]: Path to the file if found, None otherwise
+        """
+        json_path = Path(self.source_dir) / f"{name}.json"
+        txt_path = Path(self.source_dir) / f"{name}.txt"
+
+        if json_path.exists():
+            return str(json_path)
+        if txt_path.exists():
+            return str(txt_path)
+        return None
+
+    def _load_file_content(self, file_path: str) -> str | dict | None:
+        """
+        Load content from a file, handling both JSON and text files.
+
+        Args:
+            file_path (str): Path to the file to load
+
+        Returns:
+            Optional[str]: File content as string, or None if error
+        """
+        try:
+            if not Path(file_path).exists():
+                logger.error("File %s does not exist", file_path)
+                return None
+
+            if file_path.endswith(".txt"):
+                with Path(file_path).open(encoding="utf-8") as f:
+                    return f.read().strip()
+            if file_path.endswith(".json"):
+                try:
+                    # Parse to validate JSON, then return as string
+                    with Path(file_path).open(encoding="utf-8") as f:
+                        return json.load(f)
+                except json.JSONDecodeError as e:
+                    logger.error("Invalid JSON in file %s: %s", file_path, str(e))
+                    return None
+            else:
+                logger.error(
+                    "Unsupported file type: %s. Use 'json' or 'txt'", file_path
+                )
+                return None
+
+        except OSError as e:
+            logger.error("Error reading file %s: %s", file_path, str(e))
+            return None
+
+    def _load_from_file(self, name: str) -> str | dict | None:
+        """
+        Load a site variable directly from file (fallback method).
+
+        Args:
+            name (str): Name of the site variable
+
+        Returns:
+            Optional[str]: The site variable value, or None if not found
+        """
+        file_path = self._find_file_path(name)
+        if file_path:
+            return self._load_file_content(file_path)
+        return None
+
+    def _get_name_from_filename(self, filename: str) -> str:
+        """
+        Extract the site variable name from a filename by removing the extension.
+
+        Args:
+            filename (str): Filename with extension
+
+        Returns:
+            str: Site variable name without extension
+        """
+        if filename.endswith(".json"):
+            return filename[:-5]
+        if filename.endswith(".txt"):
+            return filename[:-4]
+        return filename

package/plugin/vendor/reflexio/reflexio/server/site_var/site_var_sources/feature_flags.json

@@ -0,0 +1,13 @@
+{
+    "invitation_only": {
+        "enabled": true
+    },
+    "deduplicator": {
+        "enabled": true,
+        "enabled_org_ids": []
+    },
+    "resumable_extraction_agent": {
+        "enabled": true,
+        "enabled_org_ids": []
+    }
+}

package/plugin/vendor/reflexio/reflexio/server/site_var/site_var_sources/llm_model_setting.json

@@ -0,0 +1,7 @@
+{
+    "should_run_model_name": "",
+    "default_generation_model_name": "",
+    "default_evaluate_model_name": "",
+    "embedding_model_name": "",
+    "pre_retrieval_model_name": ""
+}

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

@@ -0,0 +1,158 @@
+"""Optional tracing hook for request-path profiling.
+
+This module intentionally has no observability-vendor dependency. Deployments
+that want tracing can register a tracer; deployments that do not register one
+pay only a cheap context-manager/no-op cost.
+"""
+
+from __future__ import annotations
+
+import logging
+from collections.abc import Iterator, Mapping
+from contextlib import AbstractContextManager, contextmanager
+from typing import Any, Protocol
+
+logger = logging.getLogger(__name__)
+
+
+class TraceSpan(Protocol):
+    """Minimal span handle exposed to shared Reflexio code."""
+
+    def set_data(self, key: str, value: Any) -> None:
+        """Attach low-cardinality metadata to the active span."""
+        ...
+
+
+class Tracer(Protocol):
+    """Process-global tracer interface configured by enterprise startup."""
+
+    def span(self, name: str, **data: Any) -> AbstractContextManager[TraceSpan]:
+        """Create a span context manager."""
+        ...
+
+
+class _NoopTraceSpan:
+    def set_data(self, key: str, value: Any) -> None:
+        del key, value
+
+
+_NOOP_SPAN = _NoopTraceSpan()
+_tracer: Tracer | None = None
+
+
+def configure_tracer(tracer: Tracer | None) -> None:
+    """Set the process-global tracer.
+
+    Args:
+        tracer: Tracer implementation, or None to disable tracing.
+    """
+    global _tracer
+    _tracer = tracer
+
+
+@contextmanager
+def profile_step(name: str, **data: Any) -> Iterator[TraceSpan]:
+    """Profile a named step if tracing is configured.
+
+    Tracing must never make product requests fail. Errors from creating,
+    entering, or exiting the tracing span are logged and swallowed. Exceptions
+    raised by the profiled product code are still propagated unchanged.
+    """
+    tracer = _tracer
+    if tracer is None:
+        yield _NOOP_SPAN
+        return
+
+    try:
+        span_cm = tracer.span(name, **data)
+        span = span_cm.__enter__()
+    except Exception as exc:  # noqa: BLE001
+        logger.warning("Tracer failed to start span %s: %s", name, exc)
+        yield _NOOP_SPAN
+        return
+
+    try:
+        yield span
+    except BaseException as exc:
+        try:
+            span_cm.__exit__(type(exc), exc, exc.__traceback__)
+        except Exception as tracer_exc:  # noqa: BLE001
+            logger.warning("Tracer failed to finish span %s: %s", name, tracer_exc)
+        raise
+    else:
+        try:
+            span_cm.__exit__(None, None, None)
+        except Exception as exc:  # noqa: BLE001
+            logger.warning("Tracer failed to finish span %s: %s", name, exc)
+
+
+def set_span_data(span: TraceSpan, values: Mapping[str, Any]) -> None:
+    """Best-effort helper for attaching multiple span fields."""
+    for key, value in values.items():
+        try:
+            span.set_data(key, value)
+        except Exception as exc:  # noqa: BLE001
+            logger.warning("Tracer failed to set span data %s: %s", key, exc)
+
+
+@contextmanager
+def sentry_tags(**tags: Any) -> Iterator[None]:
+    """Attach tags to any Sentry events produced inside the block.
+
+    Used inside ``except`` handlers, immediately wrapping a
+    ``logger.exception(...)`` call, so the event auto-captured by
+    Sentry's ``LoggingIntegration`` is filterable by org / subsystem.
+
+    No-op when ``sentry-sdk`` is not installed (the OS package does not
+    declare it as a dependency; enterprise deployments pull it in).
+    Tag values that are ``None`` are skipped to avoid noisy "None" tags.
+
+    Args:
+        **tags: arbitrary tag name → value pairs. Values are stringified.
+
+    Yields:
+        None. Re-enters the active Sentry scope for the duration of the
+        ``with`` block.
+    """
+    try:
+        import sentry_sdk  # type: ignore[import-not-found]
+    except ImportError:
+        yield
+        return
+
+    # Mirrors `profile_step` above: instrumentation must never make a product
+    # request fail. If the Sentry SDK throws while opening or closing the
+    # scope, log and continue rather than letting the exception escape the
+    # caller's `with sentry_tags(...)` block and mask the original failure.
+    # `new_scope()` is the sentry-sdk >=2.0 replacement for the deprecated
+    # `push_scope()`; the AttributeError on the older 1.x SDK is caught by
+    # the broad `except` below so the helper still degrades cleanly.
+    try:
+        scope_cm = sentry_sdk.new_scope()
+        scope = scope_cm.__enter__()
+    except Exception as exc:  # noqa: BLE001
+        logger.warning("Failed to open Sentry scope for tags: %s", exc)
+        yield
+        return
+
+    for key, value in tags.items():
+        if value is None:
+            continue
+        try:
+            scope.set_tag(key, str(value))
+        except Exception as exc:  # noqa: BLE001
+            logger.warning("Failed to set Sentry tag %s: %s", key, exc)
+
+    try:
+        yield
+    except BaseException as exc:
+        try:
+            scope_cm.__exit__(type(exc), exc, exc.__traceback__)
+        except Exception as cleanup_exc:  # noqa: BLE001
+            logger.warning("Failed to close Sentry scope: %s", cleanup_exc)
+        raise
+    else:
+        try:
+            scope_cm.__exit__(None, None, None)
+        except Exception as exc:  # noqa: BLE001
+            logger.warning("Failed to close Sentry scope: %s", exc)

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

@@ -0,0 +1,113 @@
+"""Optional usage metrics hook.
+
+This module intentionally has no storage or vendor dependency. Deployments that
+want usage metrics can register a recorder; deployments that do not register one
+pay only a cheap function-call/no-op cost.
+"""
+
+from __future__ import annotations
+
+import logging
+import time
+from collections.abc import Callable, Mapping
+from dataclasses import dataclass, field
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass(slots=True, frozen=True)
+class UsageEvent:
+    org_id: str
+    event_name: str
+    event_category: str
+    user_id: str | None = None
+    request_id: str | None = None
+    session_id: str | None = None
+    pipeline: str | None = None
+    entity_type: str | None = None
+    entity_id: str | None = None
+    extractor_name: str | None = None
+    playbook_name: str | None = None
+    source: str | None = None
+    agent_version: str | None = None
+    backend: str | None = None
+    outcome: str | None = None
+    count_value: int = 1
+    duration_ms: int | None = None
+    error_kind: str | None = None
+    metadata: Mapping[str, Any] = field(default_factory=dict)
+    created_at: float = field(default_factory=time.time)
+
+
+UsageEventRecorder = Callable[[UsageEvent], None]
+
+_recorder: UsageEventRecorder | None = None
+
+
+def configure_usage_event_recorder(recorder: UsageEventRecorder | None) -> None:
+    """Set the process-global usage metrics recorder.
+
+    Args:
+        recorder: Callable that accepts UsageEvent, or None to disable metrics.
+    """
+    global _recorder
+    _recorder = recorder
+
+
+def record_usage_event(
+    *,
+    org_id: str,
+    event_name: str,
+    event_category: str,
+    user_id: str | None = None,
+    request_id: str | None = None,
+    session_id: str | None = None,
+    pipeline: str | None = None,
+    entity_type: str | None = None,
+    entity_id: str | None = None,
+    extractor_name: str | None = None,
+    playbook_name: str | None = None,
+    source: str | None = None,
+    agent_version: str | None = None,
+    backend: str | None = None,
+    outcome: str | None = None,
+    count_value: int = 1,
+    duration_ms: int | None = None,
+    error_kind: str | None = None,
+    metadata: Mapping[str, Any] | None = None,
+) -> None:
+    """Record one usage event if a recorder is configured.
+
+    The product path must never fail because metrics failed, so this function
+    catches and logs all recorder errors.
+    """
+    recorder = _recorder
+    if recorder is None:
+        return
+    try:
+        recorder(
+            UsageEvent(
+                org_id=str(org_id),
+                event_name=event_name,
+                event_category=event_category,
+                user_id=user_id,
+                request_id=request_id,
+                session_id=session_id,
+                pipeline=pipeline,
+                entity_type=entity_type,
+                entity_id=entity_id,
+                extractor_name=extractor_name,
+                playbook_name=playbook_name,
+                source=source,
+                agent_version=agent_version,
+                backend=backend,
+                outcome=outcome,
+                count_value=count_value,
+                duration_ms=duration_ms,
+                error_kind=error_kind,
+                metadata=metadata or {},
+            )
+        )
+    except Exception as exc:  # noqa: BLE001
+        logger.warning("Usage metrics recorder failed: %s", exc)