claude-smart 0.2.41 → 0.2.43

package/plugin/vendor/reflexio/reflexio/server/services/playbook_optimizer/scenario_resolver.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+from reflexio.models.api_schema.domain import Status
+from reflexio.server.services.storage.storage_base import BaseStorage
+
+from .models import ScenarioWindow
+
+
+class ScenarioResolver:
+    """Builds the rollout test set from a playbook's lineage.
+
+    Each agent playbook is generated from a cluster of user playbooks,
+    which were themselves extracted from real interactions. To evaluate a
+    candidate change, the optimizer needs to replay those original
+    interactions — this class walks the lineage and materialises one
+    ``ScenarioWindow`` per source user playbook.
+
+    Empty windows (no source interactions, archived rows, etc.) are
+    skipped silently — the optimizer treats "no windows" as a reason to
+    skip the run.
+    """
+
+    def __init__(self, storage: BaseStorage) -> None:
+        self.storage = storage
+
+    def for_agent_playbook(self, agent_playbook_id: int) -> list[ScenarioWindow]:
+        source_windows = self.storage.get_source_windows_for_agent_playbook(
+            agent_playbook_id
+        )
+        windows: list[ScenarioWindow] = []
+        legacy_user_playbook_ids: list[int] = []
+        for source_window in source_windows:
+            if not source_window.source_interaction_ids:
+                legacy_user_playbook_ids.append(source_window.user_playbook_id)
+                continue
+            interactions = self.storage.get_interactions_by_ids(
+                source_window.source_interaction_ids
+            )
+            if interactions:
+                windows.append(
+                    ScenarioWindow(
+                        user_playbook_id=source_window.user_playbook_id,
+                        source_interaction_ids=source_window.source_interaction_ids,
+                        interactions=interactions,
+                    )
+                )
+
+        if not legacy_user_playbook_ids:
+            return windows
+
+        user_playbooks = self.storage.get_user_playbooks_by_ids_any_user(
+            legacy_user_playbook_ids, status_filter=None
+        )
+        for playbook in user_playbooks:
+            if not playbook.source_interaction_ids:
+                continue
+            interactions = self.storage.get_interactions_by_ids(
+                playbook.source_interaction_ids
+            )
+            if interactions:
+                windows.append(
+                    ScenarioWindow(
+                        user_playbook_id=playbook.user_playbook_id,
+                        source_interaction_ids=playbook.source_interaction_ids,
+                        interactions=interactions,
+                    )
+                )
+        return windows
+
+    def for_user_playbook(self, user_playbook_id: int) -> list[ScenarioWindow]:
+        playbook = self.storage.get_user_playbook_by_id(user_playbook_id)
+        if (
+            playbook is None
+            or playbook.status is not None
+            or not playbook.source_interaction_ids
+        ):
+            return []
+        interactions = self.storage.get_interactions_by_ids(
+            playbook.source_interaction_ids
+        )
+        if not interactions:
+            return []
+        return [
+            ScenarioWindow(
+                user_playbook_id=playbook.user_playbook_id,
+                source_interaction_ids=playbook.source_interaction_ids,
+                interactions=interactions,
+            )
+        ]
+
+
+def is_current_status(status: Status | None) -> bool:
+    return status is None

package/plugin/vendor/reflexio/reflexio/server/services/playbook_optimizer/scheduler.py

@@ -0,0 +1,174 @@
+from __future__ import annotations
+
+import heapq
+import logging
+import threading
+import time
+from collections.abc import Callable
+
+from .optimizer import PlaybookOptimizationRunStatus, PlaybookOptimizationTarget
+
+logger = logging.getLogger(__name__)
+
+ScheduleKey = tuple[str, str, int]
+ScheduledCallback = Callable[[], PlaybookOptimizationRunStatus | None]
+
+
+class PlaybookOptimizationScheduler:
+    """Process-local scheduler that debounces optimization runs.
+
+    Behaviour:
+
+    - **Debounce** by ``(org_id, target.kind, target.target_id)`` — repeated
+      enqueues for the same playbook collapse into one fire.
+    - **Jitter** the fire time by up to ``jitter_seconds`` to spread load
+      across simultaneous saves.
+    - **Cooldown** when a callback returns ``"aborted"`` (the assistant
+      backend repeatedly failed). After ``abort_cooldown_threshold``
+      consecutive aborts, further enqueues for the same key are silently
+      dropped for ``cooldown_after_aborts_seconds``. A ``completed`` or
+      ``skipped`` outcome resets the counter.
+
+    The scheduler is a singleton with a daemon thread; multiple processes
+    schedule independently, so debounce is per-process.
+    """
+
+    _instance = None
+    _lock = threading.Lock()
+
+    @classmethod
+    def get_instance(cls) -> PlaybookOptimizationScheduler:
+        if cls._instance is None:
+            with cls._lock:
+                if cls._instance is None:
+                    cls._instance = cls()
+        return cls._instance
+
+    def __init__(self) -> None:
+        self._scheduled: dict[
+            ScheduleKey, tuple[float, ScheduledCallback, int, int]
+        ] = {}
+        self._heap: list[tuple[float, ScheduleKey]] = []
+        self._mutex = threading.Lock()
+        self._wake_event = threading.Event()
+        self._abort_counts: dict[ScheduleKey, tuple[int, float]] = {}
+        self._thread = threading.Thread(
+            target=self._scheduler_loop,
+            daemon=True,
+            name="playbook-optimizer-scheduler",
+        )
+        self._thread.start()
+
+    def enqueue(
+        self,
+        *,
+        org_id: str,
+        target: PlaybookOptimizationTarget,
+        callback: ScheduledCallback,
+        jitter_seconds: float = 1.0,
+        abort_cooldown_threshold: int = 2,
+        cooldown_after_aborts_seconds: int = 3600,
+    ) -> None:
+        key: ScheduleKey = (org_id, target.kind, target.target_id)
+        now = time.monotonic()
+        jitter = (time.monotonic() % 1.0) * jitter_seconds
+        fire_time = now + jitter
+        with self._mutex:
+            if self._cooldown_remaining_locked(key, now) > 0:
+                logger.info(
+                    "Skipping playbook optimization enqueue during cooldown: %s", key
+                )
+                return
+            self._scheduled[key] = (
+                fire_time,
+                callback,
+                abort_cooldown_threshold,
+                cooldown_after_aborts_seconds,
+            )
+            heapq.heappush(self._heap, (fire_time, key))
+        self._wake_event.set()
+
+    def _scheduler_loop(self) -> None:
+        while True:
+            try:
+                with self._mutex:
+                    next_fire_time = self._heap[0][0] if self._heap else None
+                if next_fire_time is None:
+                    self._wake_event.wait()
+                    self._wake_event.clear()
+                    continue
+                wait_seconds = next_fire_time - time.monotonic()
+                if wait_seconds > 0:
+                    self._wake_event.wait(timeout=wait_seconds)
+                    self._wake_event.clear()
+                    continue
+                with self._mutex:
+                    while self._heap and self._heap[0][0] <= time.monotonic():
+                        fire_time, key = heapq.heappop(self._heap)
+                        current = self._scheduled.get(key)
+                        if current is None or abs(current[0] - fire_time) > 0.001:
+                            continue
+                        _, callback, abort_threshold, cooldown_seconds = current
+                        del self._scheduled[key]
+                        threading.Thread(
+                            target=self._run_callback,
+                            args=(key, callback, abort_threshold, cooldown_seconds),
+                            daemon=True,
+                            name=f"playbook-opt-{key[1]}-{key[2]}",
+                        ).start()
+            except Exception:
+                logger.exception("Playbook optimization scheduler loop failed")
+                time.sleep(1)
+
+    def _run_callback(
+        self,
+        key: ScheduleKey,
+        callback: ScheduledCallback,
+        abort_threshold: int,
+        cooldown_seconds: int,
+    ) -> None:
+        try:
+            status = callback()
+            if status == "aborted":
+                self._record_abort(key, abort_threshold, cooldown_seconds)
+            elif status in {"completed", "skipped"}:
+                self._clear_abort_state(key)
+        except Exception:
+            logger.exception("Playbook optimization callback failed for key=%s", key)
+            self._record_abort(key, abort_threshold, cooldown_seconds)
+
+    def _cooldown_remaining_locked(self, key: ScheduleKey, now: float) -> float:
+        state = self._abort_counts.get(key)
+        if state is None:
+            return 0.0
+        count, cooldown_until = state
+        if cooldown_until <= 0:
+            return 0.0
+        remaining = cooldown_until - now
+        if remaining > 0:
+            return remaining
+        del self._abort_counts[key]
+        return 0.0
+
+    def _record_abort(
+        self, key: ScheduleKey, abort_threshold: int, cooldown_seconds: int
+    ) -> None:
+        now = time.monotonic()
+        with self._mutex:
+            self._cooldown_remaining_locked(key, now)
+            count, _ = self._abort_counts.get(key, (0, 0.0))
+            count += 1
+            if count >= abort_threshold:
+                cooldown_until = now + cooldown_seconds
+                self._abort_counts[key] = (0, cooldown_until)
+                logger.warning(
+                    "Playbook optimization entered abort cooldown for key=%s seconds=%s",
+                    key,
+                    cooldown_seconds,
+                )
+            else:
+                self._abort_counts[key] = (count, 0.0)
+
+    def _clear_abort_state(self, key: ScheduleKey) -> None:
+        with self._mutex:
+            self._abort_counts.pop(key, None)

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

@@ -0,0 +1,26 @@
+"""Pre-retrieval optimization package for search.
+
+Provides independent, reusable modules for search pre-processing:
+  - QueryReformulator: Search-time query normalization (resolves context,
+    expands abbreviations, fixes grammar)
+  - DocumentExpander: Storage-time document enrichment (synonym expansion,
+    keyword extraction)
+"""
+
+from reflexio.models.api_schema.retriever_schema import ReformulationResult
+from reflexio.server.services.pre_retrieval._document_expander import (
+    DocumentExpander,
+    ExpansionResult,
+)
+from reflexio.server.services.pre_retrieval._query_reformulator import (
+    QueryReformulator,
+    ReformulationSearchResult,
+)
+
+__all__ = [
+    "DocumentExpander",
+    "ExpansionResult",
+    "QueryReformulator",
+    "ReformulationResult",
+    "ReformulationSearchResult",
+]

package/plugin/vendor/reflexio/reflexio/server/services/pre_retrieval/_document_expander.py

@@ -0,0 +1,179 @@
+"""Independent document expansion module for storage-time enrichment.
+
+Expands document content with synonyms and related terms to improve FTS recall.
+Called during the storage pipeline, before document indexing.
+
+The expanded terms are stored in a structured plain text format:
+  "backup, sync, replica; deploy, release, ship"
+Each semicolon-separated group contains a key term followed by its synonyms.
+"""
+
+import json
+import logging
+import re
+
+from pydantic import BaseModel
+
+from reflexio.server.llm.litellm_client import LiteLLMClient
+from reflexio.server.prompt.prompt_manager import PromptManager
+from reflexio.server.services.service_utils import log_model_response
+
+logger = logging.getLogger(__name__)
+
+
+class ExpansionResult(BaseModel):
+    """Output of document expansion.
+
+    Args:
+        expansions (dict[str, list[str]]): Mapping of key terms to synonym lists.
+        expanded_text (str): Punctuated plain text of all expansions.
+    """
+
+    expansions: dict[str, list[str]] = {}
+    expanded_text: str = ""
+
+
+class DocumentExpander:
+    """Independent, reusable document expansion module.
+
+    Expands document content with synonyms and related terms via LLM
+    for improved full-text search recall at storage time.
+    """
+
+    MAX_CONTENT_LENGTH = 4000
+    LLM_TIMEOUT = 25
+    LLM_MAX_RETRIES = 1
+
+    def __init__(
+        self,
+        llm_client: LiteLLMClient,
+        prompt_manager: PromptManager,
+        model_name: str | None = None,
+    ):
+        """Initialize the DocumentExpander.
+
+        Args:
+            llm_client (LiteLLMClient): Shared LLM client instance
+            prompt_manager (PromptManager): Prompt manager for rendering prompts
+            model_name (str, optional): Model name override for expansion.
+                When set, passed as model= kwarg to generate_response().
+        """
+        self.llm_client = llm_client
+        self.prompt_manager = prompt_manager
+        self.model_name = model_name
+
+    def expand(self, content: str) -> ExpansionResult:
+        """Expand document content with synonyms and related terms.
+
+        Uses LLM to extract key concepts and generate synonyms.
+        Returns structured result with both the expansion mapping
+        and a punctuated plain text representation.
+
+        Args:
+            content (str): Document text to expand
+
+        Returns:
+            ExpansionResult: Expansion mapping and formatted text
+        """
+        if len(content) > self.MAX_CONTENT_LENGTH:
+            content = content[: self.MAX_CONTENT_LENGTH]
+        try:
+            expansions = self._extract_expansions(content)
+            expanded_text = self._format_expanded_terms(expansions)
+            return ExpansionResult(
+                expansions=expansions,
+                expanded_text=expanded_text,
+            )
+        except Exception as e:
+            logger.warning("Document expansion failed, returning empty: %s", e)
+            return ExpansionResult()
+
+    def _extract_expansions(self, content: str) -> dict[str, list[str]]:
+        """Use LLM to extract key terms and their synonyms from document content.
+
+        Args:
+            content (str): Document text
+
+        Returns:
+            dict[str, list[str]]: Mapping of key terms to synonym lists
+
+        Raises:
+            Exception: If LLM call or parsing fails
+        """
+        prompt = self.prompt_manager.render_prompt(
+            "document_expansion",
+            {"content": content},
+        )
+        logger.debug("Document expansion prompt: %s", prompt)
+        model_kwargs = {}
+        if self.model_name:
+            model_kwargs["model"] = self.model_name
+        result = self.llm_client.generate_response(
+            prompt,
+            timeout=self.LLM_TIMEOUT,
+            max_retries=self.LLM_MAX_RETRIES,
+            **model_kwargs,
+        )
+        log_model_response(logger, "Document expansion model response", result)
+
+        if isinstance(result, str):
+            return self._parse_expansion_json(result)
+        return {}
+
+    @staticmethod
+    def _parse_expansion_json(output: str) -> dict[str, list[str]]:
+        """Parse LLM output as JSON expansion mapping.
+
+        Handles code-fenced JSON and bare JSON. Validates structure.
+
+        Args:
+            output (str): Raw LLM output
+
+        Returns:
+            dict[str, list[str]]: Parsed expansion mapping
+        """
+        text = output.strip()
+
+        # Handle code-fenced JSON
+        if "```" in text:
+            match = re.search(r"```(?:\w+)?\s*([\s\S]*?)```", text)
+            if match:
+                text = match.group(1).strip()
+
+        try:
+            parsed = json.loads(text)
+            if isinstance(parsed, dict):
+                expansions: dict[str, list[str]] = {}
+                for key, value in parsed.items():
+                    if isinstance(key, str) and isinstance(value, list):
+                        synonyms = [
+                            s for s in value if isinstance(s, str) and s.strip()
+                        ]
+                        if synonyms:
+                            expansions[key.strip()] = synonyms
+                return expansions
+        except json.JSONDecodeError:
+            logger.warning("Failed to parse expansion JSON: %s", text[:200])
+
+        return {}
+
+    @staticmethod
+    def _format_expanded_terms(expansions: dict[str, list[str]]) -> str:
+        """Format expansions as punctuated plain text.
+
+        Output format: "term, syn1, syn2; term2, syn3, syn4"
+        - Semicolons separate synonym groups
+        - Commas separate terms within a group
+        - First term in each group is the original key term
+
+        Args:
+            expansions (dict[str, list[str]]): Term-to-synonyms mapping
+
+        Returns:
+            str: Formatted expansion text
+        """
+        groups = []
+        for term, synonyms in expansions.items():
+            parts = [term, *synonyms]
+            groups.append(", ".join(parts))
+        return "; ".join(groups)