claude-smart 0.2.41 → 0.2.43

package/plugin/vendor/reflexio/reflexio/server/cache/reflexio_cache.py

@@ -0,0 +1,208 @@
+"""Reflexio instance cache with explicit invalidation and version-based auto-eviction."""
+
+import logging
+import threading
+from dataclasses import dataclass
+from typing import Any, Final
+
+from cachetools import TTLCache
+
+from reflexio.lib.reflexio_lib import Reflexio
+
+logger = logging.getLogger(__name__)
+
+# Cache configuration
+REFLEXIO_CACHE_MAX_SIZE = 100
+REFLEXIO_CACHE_TTL_SECONDS = 3600  # 1 hour safety net
+
+# Type alias for cache key: (org_id, storage_base_dir)
+CacheKey = tuple[str, str | None]
+
+
+# Sentinel returned by ``_probe_version_safe`` when the underlying probe
+# raised an exception. Distinguishing "probe failed transiently" from
+# "backend can't probe" matters: the former should NOT promote the entry
+# to permanent unprobeable state, otherwise a single transient error
+# (e.g. brief Postgres reconnect, file lock contention) would silently
+# disable version-based auto-eviction for the lifetime of the entry.
+_PROBE_FAILED: Final = object()
+
+# Type alias for ``current_config_version()`` return values plus our
+# private sentinel. ``None`` means "backend doesn't support probing"
+# (permanent), the sentinel means "probe raised this time" (transient).
+_ProbeResult = tuple[str, Any] | None | object
+
+
+@dataclass
+class _CacheEntry:
+    """Per-org cache entry pairing a Reflexio instance with the config version stamped at load time.
+
+    The ``cached_version`` is whatever ``Reflexio.current_config_version()``
+    returned when the instance was constructed. On each cache hit we
+    re-probe and evict the entry if the value changed — this catches
+    out-of-band config mutations (file edits, sibling-replica writes,
+    direct DB updates) that don't go through ``invalidate_reflexio_cache``.
+
+    Attributes:
+        reflexio (Reflexio): The cached Reflexio instance.
+        cached_version (tuple[str, Any] | None): The version stamp
+            captured at load time. ``None`` means "no probe available";
+            entries with ``None`` are never auto-evicted (they fall
+            through to the TTL safety net). Probe failures during
+            construction never produce ``None`` here — they're recorded
+            as the same value the next probe attempt would compare
+            against, so a later successful probe can still evict the
+            stale entry.
+    """
+
+    reflexio: Reflexio
+    cached_version: tuple[str, Any] | None
+
+
+# Module-level cache and lock
+_reflexio_cache: TTLCache = TTLCache(
+    maxsize=REFLEXIO_CACHE_MAX_SIZE, ttl=REFLEXIO_CACHE_TTL_SECONDS
+)
+_reflexio_cache_lock = threading.Lock()
+
+
+def _probe_version_safe(reflexio: Reflexio) -> _ProbeResult:
+    """Probe the current config version, distinguishing failure from "no probe".
+
+    A failing probe must never break a cache hit, but it also must not
+    be conflated with a backend that legitimately can't probe (which
+    returns ``None``). Conflating the two would let a single transient
+    failure permanently disable auto-eviction for the entry.
+
+    Args:
+        reflexio (Reflexio): The cached Reflexio instance to probe.
+
+    Returns:
+        ``tuple[str, Any]`` on success, ``None`` when the backend
+        intentionally doesn't expose a version (permanent), or the
+        ``_PROBE_FAILED`` sentinel when the call raised (transient).
+    """
+    try:
+        return reflexio.current_config_version()
+    except Exception as exc:  # noqa: BLE001 - intentional broad catch
+        logger.warning(
+            "Failed to probe config version for org %s: %s — keeping entry warm",
+            reflexio.org_id,
+            exc,
+        )
+        return _PROBE_FAILED
+
+
+def get_reflexio(org_id: str, storage_base_dir: str | None = None) -> Reflexio:
+    """Get or create a cached Reflexio instance.
+
+    On cache hit, the entry's stamped config version is re-probed. If
+    the persisted version has changed (e.g. config file mtime bumped,
+    sibling replica wrote new DB version), the entry is evicted and a
+    fresh instance is constructed.
+
+    Args:
+        org_id (str): Organization ID
+        storage_base_dir (Optional[str]): Base directory for storage (self-host mode)
+
+    Returns:
+        Reflexio: Cached or newly created instance
+    """
+    cache_key: CacheKey = (org_id, storage_base_dir)
+
+    # Cache lookup — held briefly to extract the entry, then released
+    # before doing any I/O (file stat, DB query) for the version probe.
+    with _reflexio_cache_lock:
+        entry: _CacheEntry | None = _reflexio_cache.get(cache_key)
+
+    if entry is not None:
+        cached_version = entry.cached_version
+        # Skip probing when we have nothing to compare against — a
+        # ``None`` stamp means the backend can't probe cheaply, so we
+        # rely on TTL + explicit invalidation instead.
+        if cached_version is None:
+            return entry.reflexio
+        current_version = _probe_version_safe(entry.reflexio)
+        # Transient probe failure: keep the cached instance for this
+        # request but DON'T mutate the stamp — the next request will
+        # try again, so a brief outage doesn't permanently disable
+        # eviction the way collapsing failures into ``None`` would.
+        if current_version is _PROBE_FAILED:
+            return entry.reflexio
+        if current_version == cached_version:
+            return entry.reflexio
+        # Stale entry. Evict only if the cached version still matches
+        # the one we just compared against — another thread may have
+        # already replaced the entry while we were probing.
+        with _reflexio_cache_lock:
+            existing = _reflexio_cache.get(cache_key)
+            if existing is not None and existing.cached_version == cached_version:
+                del _reflexio_cache[cache_key]
+
+    # Cache miss (or just-evicted stale entry) - create a new instance
+    # outside the lock to avoid blocking concurrent requests for other orgs.
+    reflexio = Reflexio(org_id=org_id, storage_base_dir=storage_base_dir)
+    new_version = _probe_version_safe(reflexio)
+
+    # Construction-time probe failure: serve this request from the
+    # newly-built instance but DON'T cache it. Caching with
+    # ``cached_version=None`` would conflate the entry with a
+    # legitimately-unprobeable backend and permanently disable
+    # auto-eviction. Skipping the cache means the next request pays a
+    # construction cost, but version-based eviction is preserved as
+    # soon as the backend recovers.
+    if new_version is _PROBE_FAILED:
+        return reflexio
+
+    new_entry = _CacheEntry(
+        reflexio=reflexio,
+        cached_version=new_version,  # type: ignore[arg-type]
+    )
+
+    with _reflexio_cache_lock:
+        # Double-check in case another thread populated while we were constructing.
+        existing = _reflexio_cache.get(cache_key)
+        if existing is None:
+            _reflexio_cache[cache_key] = new_entry
+            return reflexio
+        return existing.reflexio
+
+
+def invalidate_reflexio_cache(org_id: str, storage_base_dir: str | None = None) -> bool:
+    """Invalidate cached Reflexio for specific org.
+
+    Call this after set_config to ensure next request gets fresh instance.
+
+    Args:
+        org_id (str): Organization ID to invalidate
+        storage_base_dir (Optional[str]): Base directory for storage
+
+    Returns:
+        bool: True if entry was removed, False if not found
+    """
+    cache_key: CacheKey = (org_id, storage_base_dir)
+    with _reflexio_cache_lock:
+        if cache_key in _reflexio_cache:
+            del _reflexio_cache[cache_key]
+            return True
+        return False
+
+
+def clear_reflexio_cache() -> None:
+    """Clear entire cache (for testing/admin)."""
+    with _reflexio_cache_lock:
+        _reflexio_cache.clear()
+
+
+def get_cache_stats() -> dict:
+    """Get cache statistics for monitoring.
+
+    Returns:
+        dict: Cache statistics including current size, max size, and TTL
+    """
+    with _reflexio_cache_lock:
+        return {
+            "current_size": len(_reflexio_cache),
+            "max_size": REFLEXIO_CACHE_MAX_SIZE,
+            "ttl_seconds": REFLEXIO_CACHE_TTL_SECONDS,
+        }

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

@@ -0,0 +1,46 @@
+"""Request correlation ID for tracing concurrent operations.
+
+Stores a short hex ID in a ContextVar so every log line emitted during a
+single HTTP request (including ThreadPoolExecutor worker threads) can be
+correlated back to the originating request.
+
+Usage in worker threads::
+
+    ctx = contextvars.copy_context()
+    executor.submit(ctx.run, fn, *args)
+"""
+
+from __future__ import annotations
+
+import contextvars
+import logging
+import uuid
+
+# ContextVar holds the correlation ID for the current request.
+# Default is empty string (non-request contexts like startup, CLI).
+correlation_id_var: contextvars.ContextVar[str] = contextvars.ContextVar(
+    "correlation_id", default=""
+)
+
+
+def generate_correlation_id() -> str:
+    """Generate a short 8-character hex correlation ID."""
+    return uuid.uuid4().hex[:8]
+
+
+class CorrelationIdFilter(logging.Filter):
+    """Logging filter that injects correlation fields into every log record.
+
+    Attach this filter to handlers so formatters can use:
+
+    - ``%(correlation_id)s`` — the raw ID (empty string outside request context).
+    - ``%(correlation_tag)s`` — a ready-to-embed ``"[<cid>] "`` string that
+      collapses to ``""`` when there is no correlation ID. Use this in format
+      strings to avoid rendering an empty ``[]`` at startup / CLI time.
+    """
+
+    def filter(self, record: logging.LogRecord) -> bool:
+        cid = correlation_id_var.get("")
+        record.correlation_id = cid  # type: ignore[attr-defined]
+        record.correlation_tag = f"[{cid}] " if cid else ""  # type: ignore[attr-defined]
+        return True

package/plugin/vendor/reflexio/reflexio/server/llm/__init__.py

@@ -0,0 +1,30 @@
+"""
+LLM client package providing unified access to multiple LLM providers.
+
+This package uses LiteLLM as the backend to provide a consistent interface
+for OpenAI, Claude, Azure OpenAI, and other LLM providers.
+"""
+
+from .litellm_client import (
+    LiteLLMClient,
+    LiteLLMClientError,
+    LiteLLMConfig,
+    ToolCallingChatResponse,
+    create_litellm_client,
+)
+from .model_defaults import (
+    ModelRole,
+    resolve_model_name,
+    validate_llm_availability,
+)
+
+__all__ = [
+    "LiteLLMClient",
+    "LiteLLMConfig",
+    "LiteLLMClientError",
+    "ModelRole",
+    "ToolCallingChatResponse",
+    "create_litellm_client",
+    "resolve_model_name",
+    "validate_llm_availability",
+]

package/plugin/vendor/reflexio/reflexio/server/llm/embedding_service.py

@@ -0,0 +1,110 @@
+"""OpenAI-compatible local embedding service."""
+
+from __future__ import annotations
+
+import math
+import threading
+from typing import Any
+
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel, Field
+
+from reflexio.server.llm.providers.local_embedding_provider import LocalEmbedder
+from reflexio.server.llm.providers.nomic_embedding_provider import (
+    NomicEmbedder,
+    is_nomic_model,
+)
+
+_MINILM_MODEL = "local/minilm-l6-v2"
+_SUPPORTED_MODELS = {
+    _MINILM_MODEL,
+    "local/nomic-embed-v1.5",
+    "local/nomic-embed-text-v1.5",
+}
+_ACTIVE_MODEL: str | None = None
+_ACTIVE_MODEL_LOCK = threading.Lock()
+
+app = FastAPI(title="Reflexio Embedding Service")
+
+
+class EmbeddingRequest(BaseModel):
+    model: str
+    input: str | list[str]
+    dimensions: int | None = Field(default=None, gt=0)
+
+
+class EmbeddingData(BaseModel):
+    object: str = "embedding"
+    embedding: list[float]
+    index: int
+
+
+class EmbeddingResponse(BaseModel):
+    object: str = "list"
+    data: list[EmbeddingData]
+    model: str
+
+
+@app.get("/health")
+def health() -> dict[str, Any]:
+    """Health check endpoint."""
+    return {"status": "ok", "active_model": _ACTIVE_MODEL}
+
+
+@app.post("/v1/embeddings")
+def create_embeddings(request: EmbeddingRequest) -> EmbeddingResponse:
+    """Create embeddings using the daemon's single active local model."""
+    _activate_model(request.model)
+    texts = [request.input] if isinstance(request.input, str) else list(request.input)
+    if is_nomic_model(request.model):
+        embeddings = NomicEmbedder.get().embed(texts)
+    elif request.model == _MINILM_MODEL:
+        embeddings = LocalEmbedder.get().embed(texts)
+    else:
+        raise HTTPException(
+            status_code=400, detail=f"Unsupported model: {request.model}"
+        )
+
+    if request.dimensions:
+        embeddings = [_resize_embedding(vec, request.dimensions) for vec in embeddings]
+
+    return EmbeddingResponse(
+        data=[
+            EmbeddingData(embedding=embedding, index=index)
+            for index, embedding in enumerate(embeddings)
+        ],
+        model=request.model,
+    )
+
+
+def _activate_model(model: str) -> None:
+    if model not in _SUPPORTED_MODELS:
+        raise HTTPException(status_code=400, detail=f"Unsupported model: {model}")
+    global _ACTIVE_MODEL
+    with _ACTIVE_MODEL_LOCK:
+        if _ACTIVE_MODEL is None:
+            _ACTIVE_MODEL = model
+            return
+        if model != _ACTIVE_MODEL:
+            raise HTTPException(
+                status_code=409,
+                detail=(
+                    "Embedding daemon already owns model "
+                    f"{_ACTIVE_MODEL}; start a separate daemon for {model}"
+                ),
+            )
+
+
+def _resize_embedding(vec: list[float], dimensions: int) -> list[float]:
+    if dimensions == len(vec):
+        return vec
+    if dimensions > len(vec):
+        raise HTTPException(
+            status_code=400,
+            detail=f"dimensions={dimensions} exceeds model output length {len(vec)}",
+        )
+    sliced = vec[:dimensions]
+    norm = math.sqrt(sum(value * value for value in sliced))
+    if norm <= 0:
+        return sliced
+    return [value / norm for value in sliced]

package/plugin/vendor/reflexio/reflexio/server/llm/image_utils.py

@@ -0,0 +1,55 @@
+"""Shared image encoding utilities for LLM clients."""
+
+import base64
+from pathlib import Path
+
+# Mapping from file extension to MIME type for supported image formats.
+SUPPORTED_IMAGE_MIME_TYPES: dict[str, str] = {
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".png": "image/png",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+}
+
+
+class ImageEncodingError(Exception):
+    """Raised when an image file cannot be encoded to base64."""
+
+
+def encode_image_to_base64(image_path: str | Path) -> tuple[str, str]:
+    """
+    Encode an image file to a base64 string with MIME type detection.
+
+    Reads the file at *image_path*, validates that the format is supported,
+    and returns the base64-encoded contents together with the corresponding
+    MIME type string.
+
+    Args:
+        image_path (str | Path): Filesystem path to the image file.
+
+    Returns:
+        tuple[str, str]: A ``(base64_data, media_type)`` pair.
+
+    Raises:
+        ImageEncodingError: If the file does not exist or has an unsupported
+            extension.
+    """
+    path = Path(image_path)
+
+    if not path.exists():
+        raise ImageEncodingError(f"Image file not found: {image_path}")
+
+    suffix = path.suffix.lower()
+    if suffix not in SUPPORTED_IMAGE_MIME_TYPES:
+        raise ImageEncodingError(
+            f"Unsupported image format: {suffix}. "
+            f"Supported formats: {', '.join(sorted(SUPPORTED_IMAGE_MIME_TYPES))}"
+        )
+
+    media_type = SUPPORTED_IMAGE_MIME_TYPES[suffix]
+
+    with path.open("rb") as f:
+        base64_data = base64.b64encode(f.read()).decode("utf-8")
+
+    return base64_data, media_type