claude-smart 0.2.42 → 0.2.44

package/plugin/vendor/reflexio/reflexio/server/services/configurator/local_file_config_storage.py

@@ -0,0 +1,187 @@
+import contextlib
+import json
+import logging
+import os
+import time
+from pathlib import Path
+from typing import Any
+
+from reflexio.cli.paths import reflexio_home
+from reflexio.models.config_schema import (
+    Config,
+    PlaybookConfig,
+    ProfileExtractorConfig,
+    StorageConfigSQLite,
+    normalize_legacy_config_shape,
+)
+from reflexio.server.services.configurator.config_storage import ConfigStorage
+
+logger = logging.getLogger(__name__)
+
+
+class LocalFileConfigStorage(ConfigStorage):
+    """
+    Local JSON file-based configuration storage implementation.
+    Saves/loads configuration to/from local JSON files.
+    """
+
+    def __init__(self, org_id: str, base_dir: str | None = None):
+        super().__init__(org_id=org_id)
+        if base_dir:
+            # Ensure base_dir is absolute
+            base_path = Path(base_dir)
+            abs_base_dir = (
+                str(base_path.resolve()) if not base_path.is_absolute() else base_dir
+            )
+            self.base_dir = str(Path(abs_base_dir) / "configs")
+            self.config_file = str(Path(self.base_dir) / f"config_{org_id}.json")
+            print(
+                f"LocalFileConfigStorage will save config for {org_id} to a local file at {self.config_file}"
+            )
+        else:
+            self.base_dir = str(reflexio_home() / "configs")
+            self.config_file = str(Path(self.base_dir) / f"config_{org_id}.json")
+
+    def _default_storage_config(self) -> StorageConfigSQLite:
+        """Return the default storage config (always SQLite for local file storage)."""
+        return StorageConfigSQLite()
+
+    def get_default_config(self) -> Config:
+        """
+        Returns a default configuration with SQLite storage.
+
+        Returns:
+            Config: Default configuration with SQLite storage
+        """
+        return Config(
+            storage_config=self._default_storage_config(),
+            profile_extractor_config=ProfileExtractorConfig(
+                extraction_definition_prompt="Extract key user information including name, role, preferences, and any other relevant profile details from the conversation.",
+            ),
+            user_playbook_extractor_config=PlaybookConfig(
+                extraction_definition_prompt="Extract playbook rules about agent performance, including areas where the agent was helpful, areas for improvement, and any issues encountered during the interaction.",
+            ),
+        )
+
+    def load_config(self) -> Config:
+        """
+        Loads the current configuration from local JSON file. If the file doesn't exist,
+        creates a default configuration and saves it.
+
+        Returns:
+            Config: Loaded configuration object
+        """
+        if not Path(self.config_file).exists():
+            config = self.get_default_config()
+            self._save_config_to_local_dir(config=config)
+            return config
+
+        try:
+            with Path(self.config_file).open(encoding="utf-8") as f:
+                config_content = f.read()
+                data = json.loads(str(config_content))
+                # Upgrade retired list-valued extractor fields (e.g.
+                # agent_success_configs) to their singular replacements before
+                # validation. Without this, Config would drop the unknown legacy
+                # keys and silently lose the user's customization.
+                if isinstance(data, dict):
+                    data = normalize_legacy_config_shape(data)
+                # Detect legacy on-disk configs that used the removed "disk"
+                # storage backend and rewrite only the storage_config field
+                # to default SQLite. Other persisted fields (extractors,
+                # prompts, etc.) are preserved so the migration doesn't
+                # silently lose user customizations. Without this guard,
+                # legacy configs would fail Pydantic validation and the
+                # broad-except path below would discard everything.
+                storage_cfg = (
+                    data.get("storage_config") if isinstance(data, dict) else None
+                )
+                if isinstance(storage_cfg, dict) and storage_cfg.get("type") == "disk":
+                    logger.warning(
+                        "Legacy storage_config.type='disk' detected in %s. "
+                        "The disk backend was removed; rewriting storage_config "
+                        "to default SQLite and preserving all other fields.",
+                        self.config_file,
+                    )
+                    data = dict(data)
+                    data["storage_config"] = self._default_storage_config().model_dump()
+                config: Config = Config(**data)
+                return config
+        except Exception:
+            logger.exception(
+                "Failed to load config from %s; falling back to default config.",
+                self.config_file,
+            )
+            # Create a default config if anything goes wrong.
+            return self.get_default_config()
+
+    def save_config(self, config: Config) -> None:
+        """
+        Saves the configuration to the local JSON file.
+
+        Args:
+            config (Config): Configuration object to save
+        """
+        if self.base_dir and self.config_file:
+            self._save_config_to_local_dir(config=config)
+        else:
+            print(
+                f"Cannot save config for org {self.org_id}: no local directory configured"
+            )
+
+    def get_version(self) -> tuple[str, Any] | None:
+        """Return the on-disk mtime of the org's config file, if it exists.
+
+        The Reflexio cache uses this to detect out-of-band edits to
+        ``~/.reflexio/configs/config_<org-id>.json`` (e.g. an operator
+        editing the file directly while the server is running). If the
+        file is missing — for example, before the first ``set_config``
+        write — return None so the cache leaves the entry alone rather
+        than thrashing every request.
+
+        Returns:
+            tuple[str, float] | None: ``("file", mtime_seconds)`` when
+            the config file exists, ``None`` otherwise (missing file or
+            stat failure).
+        """
+        try:
+            return ("file", Path(self.config_file).stat().st_mtime)
+        except OSError:
+            return None
+
+    def _save_config_to_local_dir(self, config: Config) -> None:
+        """
+        Saves configuration to the local JSON file atomically.
+
+        Writes to a per-write unique ``.tmp`` file first, then renames it
+        over the final path. ``Path.replace`` is atomic on POSIX (same
+        filesystem), so concurrent ``set_config`` calls across multiple
+        workers cannot observe a partially-written file, and a crash
+        mid-write leaves the previous good file intact. The tmp filename
+        embeds the pid and a nanosecond timestamp so concurrent writers
+        do not race on the same temp path.
+
+        Args:
+            config (Config): Configuration object to save
+
+        Raises:
+            OSError: If the write or atomic rename fails. The tmp file is
+                cleaned up on failure (best-effort), but the original
+                exception propagates so callers see the failure rather
+                than a false success.
+        """
+        if not (self.base_dir and self.config_file):
+            raise ValueError("base_dir and config_file must be set")
+
+        final_path = Path(self.config_file)
+        final_path.parent.mkdir(parents=True, exist_ok=True)
+        tmp_path = final_path.with_name(
+            f"{final_path.name}.{os.getpid()}.{time.time_ns()}.tmp"
+        )
+        try:
+            tmp_path.write_text(config.model_dump_json(), encoding="utf-8")
+            tmp_path.replace(final_path)
+        except OSError:
+            with contextlib.suppress(OSError):
+                tmp_path.unlink(missing_ok=True)
+            raise

package/plugin/vendor/reflexio/reflexio/server/services/configurator/test_config_storage.py

@@ -0,0 +1,162 @@
+# ruff: noqa: S101
+#!/usr/bin/env python3
+"""
+Simple test script to verify the new config storage classes work correctly.
+"""
+
+import json
+import tempfile
+from pathlib import Path
+
+from reflexio.models.config_schema import (
+    Config,
+    StorageConfigSQLite,
+)
+from reflexio.server.services.configurator.local_file_config_storage import (
+    LocalFileConfigStorage,
+)
+
+
+def test_local_file_config_storage():
+    """Test LocalFileConfigStorage functionality."""
+    print("Testing LocalFileConfigStorage...")
+
+    # Create a temporary directory for testing
+    with tempfile.TemporaryDirectory() as temp_dir:
+        org_id = "test_org_123"
+
+        # Create storage instance
+        storage = LocalFileConfigStorage(org_id=org_id, base_dir=temp_dir)
+
+        # Test get_default_config
+        default_config = storage.get_default_config()
+        print(
+            f"  Default config storage type: {type(default_config.storage_config).__name__}"
+        )
+        assert isinstance(default_config.storage_config, StorageConfigSQLite)
+
+        # Test load_config (should create default if file doesn't exist)
+        loaded_config = storage.load_config()
+        print(
+            f"  Loaded config storage type: {type(loaded_config.storage_config).__name__}"
+        )
+        assert isinstance(loaded_config.storage_config, StorageConfigSQLite)
+
+        # Test save_config
+        test_config = Config(
+            storage_config=StorageConfigSQLite(),
+            agent_context_prompt="Test context prompt",
+        )
+        storage.save_config(test_config)
+        print("  Config saved successfully")
+
+        # Test load_config again (should load the saved config)
+        reloaded_config = storage.load_config()
+        print(
+            f"  Reloaded config agent context: {reloaded_config.agent_context_prompt}"
+        )
+        assert reloaded_config.agent_context_prompt == "Test context prompt"
+
+    print("  LocalFileConfigStorage tests passed!")
+
+
+def test_configurator_integration():
+    """Test that the configurator works with the new storage classes."""
+    print("Testing configurator integration...")
+
+    # Test with local storage
+    with tempfile.TemporaryDirectory() as temp_dir:
+        from reflexio.server.services.configurator.configurator import (
+            DefaultConfigurator,
+        )
+
+        org_id = "test_org_789"
+        configurator = DefaultConfigurator(org_id=org_id, base_dir=temp_dir)
+
+        storage_config = configurator.get_current_storage_configuration()
+        print(f"  Configurator storage type: {type(storage_config).__name__}")
+        assert isinstance(storage_config, StorageConfigSQLite)
+
+        # Test setting and getting config
+        configurator.set_config_by_name(
+            "agent_context_prompt", "Integration test prompt"
+        )
+        context = configurator.get_agent_context()
+        print(f"  Agent context: {context}")
+        assert context == "Integration test prompt"
+
+    print("  Configurator integration tests passed!")
+
+
+def test_load_config_upgrades_legacy_list_shape():
+    """Legacy list-shaped extractor fields on disk are migrated to singular fields.
+
+    Configs persisted before the single-extractor refactor store
+    ``*_extractor_configs`` lists and ``agent_success_configs``. Without
+    migration at the load boundary, ``Config`` would drop these unknown keys and
+    silently lose the user's customization.
+    """
+    with tempfile.TemporaryDirectory() as temp_dir:
+        org_id = "legacy_org"
+        storage = LocalFileConfigStorage(org_id=org_id, base_dir=temp_dir)
+
+        legacy_payload = {
+            "storage_config": StorageConfigSQLite().model_dump(),
+            "profile_extractor_configs": [
+                {
+                    "extractor_name": "legacy_profile",
+                    "extraction_definition_prompt": "Extract legacy profile data.",
+                }
+            ],
+            "user_playbook_extractor_configs": [
+                {
+                    "extractor_name": "legacy_playbook",
+                    "extraction_definition_prompt": "Extract legacy playbook rules.",
+                }
+            ],
+            "agent_success_configs": [
+                {
+                    "evaluation_name": "legacy_success",
+                    "success_definition_prompt": "Evaluate legacy agent success.",
+                }
+            ],
+        }
+        Path(storage.config_file).parent.mkdir(parents=True, exist_ok=True)
+        Path(storage.config_file).write_text(
+            json.dumps(legacy_payload), encoding="utf-8"
+        )
+
+        loaded = storage.load_config()
+
+        assert loaded.profile_extractor_config is not None
+        assert loaded.profile_extractor_config.extractor_name == "legacy_profile"
+        assert loaded.user_playbook_extractor_config is not None
+        assert loaded.user_playbook_extractor_config.extractor_name == "legacy_playbook"
+        assert loaded.agent_success_config is not None
+        assert loaded.agent_success_config.evaluation_name == "legacy_success"
+
+
+def test_load_config():
+    """Test that the configurator loads the config correctly."""
+    print("Testing load_config...")
+
+    new_config = Config(
+        storage_config=StorageConfigSQLite(
+            db_path="/tmp/test.db",
+        ),
+        profile_extractor_config=None,
+    )
+
+    json_config = new_config.model_dump_json()
+    config = Config.model_validate_json(json_config)
+
+    assert isinstance(config.storage_config, StorageConfigSQLite)
+    assert config.storage_config.db_path == "/tmp/test.db"
+
+    print("  Load config tests passed!")
+
+
+if __name__ == "__main__":
+    import pytest
+
+    pytest.main([__file__])

package/plugin/vendor/reflexio/reflexio/server/services/deduplication_utils.py

@@ -0,0 +1,112 @@
+"""
+Shared utilities for deduplication services.
+
+This module contains base classes and utility functions used by both
+ProfileDeduplicator and PlaybookConsolidator.
+"""
+
+import logging
+from abc import ABC
+from datetime import UTC, datetime
+
+from reflexio.server.api_endpoints.request_context import RequestContext
+from reflexio.server.llm.litellm_client import LiteLLMClient
+from reflexio.server.llm.model_defaults import ModelRole, resolve_model_name
+from reflexio.server.site_var.site_var_manager import SiteVarManager
+
+logger = logging.getLogger(__name__)
+
+# Format used for "Last Modified" timestamps shown to deduplication LLMs.
+# Includes hours and minutes so same-day contradictions (morning vs evening)
+# can be distinguished.
+DEDUP_TIMESTAMP_FORMAT = "%Y-%m-%d %H:%M UTC"
+DEDUP_TIMESTAMP_FALLBACK = "unknown"
+
+
+def format_dedup_timestamp(ts: int) -> str:
+    """Format a Unix timestamp as a UTC date string for deduplication prompts.
+
+    Wraps ``datetime.fromtimestamp`` in a try/except so a single malformed
+    timestamp (negative, zero, or out-of-range integer) cannot abort an entire
+    deduplication batch. Returns ``DEDUP_TIMESTAMP_FALLBACK`` on failure.
+
+    Args:
+        ts (int): Unix timestamp (seconds since epoch).
+
+    Returns:
+        str: Human-readable UTC timestamp like ``"2026-04-11 14:30 UTC"``,
+            or ``"unknown"`` if the value is unparseable.
+    """
+    try:
+        return datetime.fromtimestamp(ts, tz=UTC).strftime(DEDUP_TIMESTAMP_FORMAT)
+    except (OverflowError, ValueError, OSError, TypeError) as exc:
+        logger.warning("Failed to format dedup timestamp %r: %s", ts, exc)
+        return DEDUP_TIMESTAMP_FALLBACK
+
+
+def parse_item_id(item_id: str) -> tuple[str, int] | None:
+    """
+    Parse a prompt-format item ID like 'NEW-0' or 'EXISTING-1' into its prefix and index.
+
+    Args:
+        item_id (str): Item ID string in the format 'PREFIX-N' (e.g., 'NEW-0', 'EXISTING-1')
+
+    Returns:
+        Optional[tuple[str, int]]: A tuple of (prefix, index) where prefix is 'NEW' or 'EXISTING',
+            or None if the item ID is invalid
+    """
+    parts = item_id.rsplit("-", 1)
+    if len(parts) != 2:
+        logger.warning("Invalid item ID format: %s", item_id)
+        return None
+    prefix, idx_str = parts
+    prefix = prefix.upper()
+    if prefix not in ("NEW", "EXISTING"):
+        logger.warning("Invalid prefix in item ID: %s", item_id)
+        return None
+    try:
+        return prefix, int(idx_str)
+    except ValueError:
+        logger.warning("Invalid index in item ID: %s", item_id)
+        return None
+
+
+# ===============================
+# Base Deduplicator ABC
+# ===============================
+
+
+class BaseDeduplicator(ABC):  # noqa: B024
+    """
+    Abstract base class for deduplicators that use LLM-based semantic matching.
+
+    Provides shared initialization (LLM client, model name).
+    Subclasses implement their own deduplicate() method with domain-specific
+    prompt building, hybrid search, and result construction.
+    """
+
+    def __init__(
+        self,
+        request_context: RequestContext,
+        llm_client: LiteLLMClient,
+    ):
+        """
+        Initialize the deduplicator.
+
+        Args:
+            request_context: Request context with storage and prompt manager
+            llm_client: Unified LLM client for LLM calls
+        """
+        self.request_context = request_context
+        self.client = llm_client
+
+        # Resolve model name: site var → auto-detect
+        model_setting = SiteVarManager().get_site_var("llm_model_setting")
+        site_var = model_setting if isinstance(model_setting, dict) else {}
+        api_key_config = self.request_context.configurator.get_config().api_key_config
+
+        self.model_name = resolve_model_name(
+            ModelRole.GENERATION,
+            site_var_value=site_var.get("default_generation_model_name"),
+            api_key_config=api_key_config,
+        )

package/plugin/vendor/reflexio/reflexio/server/services/embedding_text.py

@@ -0,0 +1,62 @@
+"""Canonical text and prefixes used for vector embeddings."""
+
+from __future__ import annotations
+
+from typing import Literal
+
+from reflexio.models.api_schema.service_schemas import (
+    AgentPlaybook,
+    AgentSuccessEvaluationResult,
+    Interaction,
+    UserPlaybook,
+    UserProfile,
+)
+
+SEARCH_DOCUMENT_PREFIX = "search_document: "
+SEARCH_QUERY_PREFIX = "search_query: "
+
+EmbeddingTextEntity = (
+    Interaction
+    | UserProfile
+    | UserPlaybook
+    | AgentPlaybook
+    | AgentSuccessEvaluationResult
+)
+
+
+def embedding_text(entity: EmbeddingTextEntity) -> str:
+    """Return the exact text used for an entity's stored embedding."""
+    if isinstance(entity, Interaction):
+        return f"{entity.content}\n{entity.user_action_description}"
+    if isinstance(entity, UserProfile):
+        parts = [entity.content]
+        if entity.custom_features:
+            parts.append(str(entity.custom_features))
+        return "\n".join(parts)
+    if isinstance(entity, (UserPlaybook, AgentPlaybook)):
+        return entity.trigger or entity.content
+    if isinstance(entity, AgentSuccessEvaluationResult):
+        return " ".join(
+            part
+            for part in (entity.failure_type, entity.failure_reason)
+            if part and part.strip()
+        )
+    raise TypeError(f"Unsupported embedding text entity: {type(entity).__name__}")
+
+
+def embedding_input(
+    text: str, *, purpose: Literal["document", "query"] = "document"
+) -> str:
+    """Apply the asymmetric search prefix used before embedding calls.
+
+    ``purpose`` must be ``"document"`` or ``"query"``; any other value raises so a
+    misspelled call site fails fast instead of silently writing or searching the
+    wrong vector space.
+    """
+    if purpose == "document":
+        return SEARCH_DOCUMENT_PREFIX + text
+    if purpose == "query":
+        return SEARCH_QUERY_PREFIX + text
+    raise ValueError(
+        f"Unknown embedding purpose {purpose!r}; expected 'document' or 'query'"
+    )

package/plugin/vendor/reflexio/reflexio/server/services/evaluation_overview/distribution.py

@@ -0,0 +1,33 @@
+"""Bucket per-session correction counts into a fixed 6-bin histogram.
+
+The spec §4.5 called for a continuous 0.0-1.0 score distribution; the actual
+schema only has `is_success` and `number_of_correction_per_session`, so we
+distribute by correction count instead. Six bins keep the visualization
+readable while preserving the shape of session quality.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+
+BUCKET_LABELS: tuple[str, ...] = ("0", "1", "2", "3", "4", "5+")
+_BUCKET_COUNT = len(BUCKET_LABELS)
+
+
+def bucket_corrections(
+    corrections: Iterable[int],
+) -> tuple[int, int, int, int, int, int]:
+    """Return per-bin counts for the corrections histogram.
+
+    Args:
+        corrections (Iterable[int]): One non-negative integer per session in
+            the window. Values >= 5 fall into the final "5+" bin.
+
+    Returns:
+        tuple[int, ...]: Six non-negative counts in BUCKET_LABELS order.
+    """
+    bins = [0] * _BUCKET_COUNT
+    for c in corrections:
+        idx = min(_BUCKET_COUNT - 1, max(0, c))
+        bins[idx] += 1
+    return tuple(bins)  # type: ignore[return-value]

package/plugin/vendor/reflexio/reflexio/server/services/evaluation_overview/eval_sampler.py

@@ -0,0 +1,126 @@
+"""Pure stratified sampler for the F3 eval-regen pipeline.
+
+DB-free and LLM-free. Operates on SampleCandidate tuples emitted by the
+regen worker's candidate-discovery step; returns the sampled subset.
+
+Stratification key: (day_bucket, F2 group). Day buckets are aligned to
+86400-second boundaries. F2 group is derived via the existing
+`assign_group_from_metadata` so the per-day cap is honored separately
+for treatment / control / untagged.
+"""
+
+from __future__ import annotations
+
+import random
+from collections import defaultdict
+from collections.abc import Iterable
+from dataclasses import dataclass
+from typing import Any
+
+from reflexio.server.services.evaluation_overview.group_aggregation import (
+    GroupAssignment,
+    assign_group_from_metadata,
+)
+
+# Day bucket width in seconds. Strata are aligned to (ts // _DAY) * _DAY.
+_DAY = 86_400
+
+
+@dataclass(frozen=True)
+class SampleCandidate:
+    """One candidate for the regen pipeline's sampling step.
+
+    Carries everything the regen worker needs to dispatch a per-session
+    evaluation, plus the first-request metadata used to assign the F2
+    group for stratification.
+
+    Attributes:
+        session_id: The session to evaluate.
+        user_id: Owner of the session's requests.
+        agent_version: Agent version to filter on.
+        source: Optional source tag (passed through to run_group_evaluation).
+        created_at: Unix epoch seconds of the session's most relevant
+            timestamp; used for day-bucket alignment.
+        first_request_metadata: The metadata dict on the session's first
+            request, read once during candidate discovery.
+    """
+
+    session_id: str
+    user_id: str
+    agent_version: str
+    source: str | None
+    created_at: int
+    first_request_metadata: dict[str, Any]
+
+
+def stratify_by_day_and_group(
+    candidates: Iterable[SampleCandidate],
+) -> dict[tuple[int, GroupAssignment], list[SampleCandidate]]:
+    """Bucket candidates by (day_bucket, F2 group).
+
+    Args:
+        candidates: Candidate tuples emitted by the regen candidate-discovery
+            step.
+
+    Returns:
+        Dict from (day_bucket_start, group) to the candidate list for that
+        stratum. Empty strata are absent; the dict has only populated keys.
+    """
+    strata: dict[tuple[int, GroupAssignment], list[SampleCandidate]] = defaultdict(list)
+    for c in candidates:
+        day_bucket = (c.created_at // _DAY) * _DAY
+        group = assign_group_from_metadata(c.first_request_metadata)
+        strata[(day_bucket, group)].append(c)
+    return dict(strata)
+
+
+def sample_per_stratum(
+    candidates: list[SampleCandidate],
+    n: int,
+    rng: random.Random,
+) -> list[SampleCandidate]:
+    """Sample up to ``n`` candidates from a single stratum.
+
+    Args:
+        candidates: All candidates in one stratum.
+        n: Cap. Strata with fewer than ``n`` items are returned whole.
+        rng: Seeded random for reproducibility.
+
+    Returns:
+        Sampled subset. Order is ``random.Random.sample``'s implementation
+        detail — callers should not depend on it.
+
+    Raises:
+        ValueError: When ``n`` is not positive.
+    """
+    if n <= 0:
+        raise ValueError(f"n must be positive, got {n}")
+    if len(candidates) <= n:
+        return list(candidates)
+    return rng.sample(candidates, n)
+
+
+def sample_candidates(
+    candidates: Iterable[SampleCandidate],
+    n_per_stratum: int,
+    rng: random.Random,
+) -> list[SampleCandidate]:
+    """Stratify by (day x group), then sample per stratum, then flatten.
+
+    Predictable cost across runs: at most ``n_per_stratum * num_strata``
+    items returned, regardless of traffic volume.
+
+    Args:
+        candidates: All candidates in the regen window.
+        n_per_stratum: Per-stratum cap (typically
+            ``Config.eval_sample_n_per_stratum``).
+        rng: Seeded random for reproducibility.
+
+    Returns:
+        Flattened sampled list.
+    """
+    strata = stratify_by_day_and_group(candidates)
+    sampled: list[SampleCandidate] = []
+    for stratum_candidates in strata.values():
+        sampled.extend(sample_per_stratum(stratum_candidates, n_per_stratum, rng))
+    return sampled