claude-smart 0.2.41 → 0.2.43

package/plugin/vendor/reflexio/reflexio/server/llm/providers/claude_code_stream_parser.py

@@ -0,0 +1,197 @@
+"""Parse the NDJSON stream from ``claude -p --output-format stream-json``
+and classify whether the call ended in a credit/auth stall.
+
+Public surface:
+    - parse_stream_json(stdout, exit_code, stderr_text) -> ParseResult
+    - classify_stall(result) -> "billing_error" | "auth_error" | None
+    - parse_reset_estimate(text) -> datetime | None
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import re
+from dataclasses import dataclass, field
+from datetime import UTC, datetime, time, timedelta
+
+from reflexio.models.api_schema.stall_state_schema import StallReason
+
+_LOGGER = logging.getLogger(__name__)
+
+_BILLING_CATEGORIES = {"billing_error"}
+_AUTH_CATEGORIES = {"authentication_failed", "oauth_org_not_allowed"}
+
+_TEXT_PATTERNS_BILLING = (
+    "hit your weekly limit",
+    "hit your session limit",
+    "credit balance is too low",
+    "billing_error",
+)
+_TEXT_PATTERNS_AUTH = (
+    "please run /login",
+    "oauth token revoked",
+    "oauth token has expired",
+    "not logged in",
+)
+
+_RESET_RE = re.compile(
+    r"resets\s+(?:(?P<weekday>mon|tue|wed|thu|fri|sat|sun)\w*\s+)?"
+    r"(?P<hour>\d{1,2}):(?P<minute>\d{2})\s*(?P<ampm>am|pm)",
+    re.IGNORECASE,
+)
+
+
+@dataclass
+class ParseResult:
+    """Aggregated state of one ``claude -p`` invocation.
+
+    Attributes:
+        success (bool): True iff exit_code==0 AND a terminal result event
+            with non-empty text appeared.
+        terminal_text (str): The ``result`` field from the terminal event.
+        retry_errors (list[str]): All ``error`` strings observed in
+            ``api_retry`` events, in order.
+        stderr_text (str): Raw stderr text from the subprocess.
+        raw_lines_parsed (int): NDJSON lines parsed successfully.
+        raw_lines_failed (int): NDJSON lines that failed to parse.
+    """
+
+    success: bool
+    terminal_text: str
+    retry_errors: list[str] = field(default_factory=list)
+    stderr_text: str = ""
+    raw_lines_parsed: int = 0
+    raw_lines_failed: int = 0
+
+    @property
+    def stall_candidate(self) -> str | None:
+        """The last retry error string in a stall category, or None."""
+        for err in reversed(self.retry_errors):
+            if err in _BILLING_CATEGORIES or err in _AUTH_CATEGORIES:
+                return err
+        return None
+
+
+def parse_stream_json(
+    stdout: str,
+    *,
+    exit_code: int,
+    stderr_text: str = "",
+) -> ParseResult:
+    """Parse the full NDJSON stream from claude -p.
+
+    Args:
+        stdout (str): Raw subprocess stdout — newline-delimited JSON events.
+        exit_code (int): Subprocess exit code.
+        stderr_text (str): Raw stderr — used by the text-fallback path.
+
+    Returns:
+        ParseResult: Aggregated state. ``success`` requires both a clean
+            exit and a parseable terminal ``result`` event.
+    """
+    retry_errors: list[str] = []
+    terminal_text = ""
+    parsed = 0
+    failed = 0
+    saw_terminal = False
+    for line in stdout.splitlines():
+        if not line.strip():
+            continue
+        try:
+            event = json.loads(line)
+        except json.JSONDecodeError:
+            failed += 1
+            continue
+        parsed += 1
+        if not isinstance(event, dict):
+            continue
+        match event.get("type"), event.get("subtype"):
+            case ("system", "api_retry"):
+                err = event.get("error")
+                if isinstance(err, str):
+                    retry_errors.append(err)
+            case ("result", _) | (_, "result"):
+                text = event.get("result")
+                if isinstance(text, str):
+                    terminal_text = text
+                    saw_terminal = True
+    return ParseResult(
+        success=(exit_code == 0 and saw_terminal and bool(terminal_text)),
+        terminal_text=terminal_text,
+        retry_errors=retry_errors,
+        stderr_text=stderr_text,
+        raw_lines_parsed=parsed,
+        raw_lines_failed=failed,
+    )
+
+
+def classify_stall(result: ParseResult) -> StallReason | None:
+    """Decide whether a finished ParseResult represents a stall.
+
+    Args:
+        result (ParseResult): Output of :func:`parse_stream_json`.
+
+    Returns:
+        StallReason | None: ``"billing_error"`` or ``"auth_error"`` only
+            when the call terminated unsuccessfully AND a stall-class
+            signal was observed (event or text fallback).
+    """
+    if result.success:
+        return None
+    candidate = result.stall_candidate
+    if candidate in _BILLING_CATEGORIES:
+        return "billing_error"
+    if candidate in _AUTH_CATEGORIES:
+        return "auth_error"
+    return _classify_from_text(result.stderr_text + " " + result.terminal_text)
+
+
+def _classify_from_text(text: str) -> StallReason | None:
+    """Belt-and-suspenders: regex the raw error text after NDJSON has been parsed."""
+    lower = text.lower()
+    if any(p in lower for p in _TEXT_PATTERNS_BILLING):
+        _LOGGER.warning("Stall classified via text fallback (billing): %r", text[:200])
+        return "billing_error"
+    if any(p in lower for p in _TEXT_PATTERNS_AUTH):
+        _LOGGER.warning("Stall classified via text fallback (auth): %r", text[:200])
+        return "auth_error"
+    return None
+
+
+def parse_reset_estimate(text: str) -> datetime | None:
+    """Best-effort parse of a reset time from Claude Code error text.
+
+    The hour/minute extracted from the message text is treated as UTC, then
+    advanced one day if it has already passed. Claude Code's error messages
+    typically express reset times in the user's local timezone, so the
+    returned datetime may be off by the user's UTC offset (up to ±24h).
+    Callers should treat this as an approximation, not an authoritative
+    reset moment.
+
+    Args:
+        text (str): Error text — typically the terminal event message or stderr.
+
+    Returns:
+        datetime | None: A UTC-naive-in-spirit but tz-aware datetime that
+            best approximates the next reset, or None when no recognizable
+            pattern is found.
+    """
+    match = _RESET_RE.search(text or "")
+    if not match:
+        return None
+    hour_raw = int(match.group("hour"))
+    minute = int(match.group("minute"))
+    # The regex permits 1–2 digit hours and minutes; reject out-of-range
+    # values so "13:00pm" or "10:75am" parse as None instead of producing
+    # silently-wrong times via modulo arithmetic.
+    if not 1 <= hour_raw <= 12 or not 0 <= minute <= 59:
+        return None
+    hour = hour_raw % 12
+    if match.group("ampm").lower() == "pm":
+        hour += 12
+    today = datetime.now(UTC).date()
+    candidate = datetime.combine(today, time(hour, minute), tzinfo=UTC)
+    if candidate <= datetime.now(UTC):
+        candidate += timedelta(days=1)
+    return candidate

package/plugin/vendor/reflexio/reflexio/server/llm/providers/embedding_service_provider.py

@@ -0,0 +1,210 @@
+"""HTTP embedding service provider.
+
+This module is the routing boundary between Reflexio's LLM client and an
+OpenAI-compatible embedding service. It lets local Claude Smart installs keep
+one model process alive across backend workers, Claude Code, and Codex, while
+also supporting a horizontally-scaled internal service in cloud deployments.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import time
+from typing import Any, Literal
+
+import httpx
+
+_LOGGER = logging.getLogger(__name__)
+
+EmbeddingProviderMode = Literal[
+    "cloud", "local_service", "internal_service", "inprocess", "off"
+]
+
+_ENV_PROVIDER = "REFLEXIO_EMBEDDING_PROVIDER"
+_ENV_SERVICE_URL = "REFLEXIO_EMBEDDING_SERVICE_URL"
+_ENV_TIMEOUT_MS = "REFLEXIO_EMBEDDING_SERVICE_TIMEOUT_MS"
+_ENV_EMBEDDING_PORT = "EMBEDDING_PORT"
+_ENV_CLAUDE_SMART_LOCAL = "CLAUDE_SMART_USE_LOCAL_EMBEDDING"
+_DEFAULT_LOCAL_PORT = 8072
+_DEFAULT_INTERNAL_SERVICE_TIMEOUT_MS = 2_000
+_DEFAULT_LOCAL_SERVICE_TIMEOUT_MS = 30_000
+_SERVICE_MODES = {"local_service", "internal_service"}
+_VALID_MODES = {"cloud", *_SERVICE_MODES, "inprocess", "off"}
+
+
+class EmbeddingUnavailableError(RuntimeError):
+    """Raised when the configured embedding provider is unavailable."""
+
+
+def _local_service_url() -> str:
+    port = os.environ.get(_ENV_EMBEDDING_PORT, str(_DEFAULT_LOCAL_PORT))
+    return f"http://127.0.0.1:{port}"
+
+
+def embedding_service_url(mode: EmbeddingProviderMode | None = None) -> str:
+    """Return the configured embedding service URL.
+
+    ``local_service`` defaults to ``127.0.0.1:$EMBEDDING_PORT`` so local
+    Claude Smart hosts can share a single machine daemon. ``internal_service``
+    requires an explicit URL because it is deployment-specific.
+    """
+    resolved = mode or embedding_provider_mode()
+    configured = os.environ.get(_ENV_SERVICE_URL)
+    if configured:
+        return configured.rstrip("/")
+    if resolved == "local_service":
+        return _local_service_url()
+    raise EmbeddingUnavailableError(
+        f"{_ENV_SERVICE_URL} is required when {_ENV_PROVIDER}={resolved}"
+    )
+
+
+def embedding_service_timeout_seconds(
+    mode: EmbeddingProviderMode | None = None,
+) -> float:
+    raw = os.environ.get(_ENV_TIMEOUT_MS)
+    if raw is None:
+        resolved = mode or embedding_provider_mode()
+        if resolved == "local_service":
+            return _DEFAULT_LOCAL_SERVICE_TIMEOUT_MS / 1000
+        return _DEFAULT_INTERNAL_SERVICE_TIMEOUT_MS / 1000
+    try:
+        timeout_ms = int(raw)
+    except ValueError as exc:
+        raise EmbeddingUnavailableError(
+            f"{_ENV_TIMEOUT_MS} must be an integer number of milliseconds"
+        ) from exc
+    return max(timeout_ms, 1) / 1000
+
+
+def _ordered_embeddings_from_response(
+    data: Any, expected_count: int
+) -> list[list[float]]:
+    if not isinstance(data, list):
+        raise ValueError("embedding service response is missing data[]")
+    if len(data) != expected_count:
+        raise ValueError(
+            "embedding service response cardinality mismatch: "
+            f"expected {expected_count}, got {len(data)}"
+        )
+
+    seen: set[int] = set()
+    indexed_embeddings: list[tuple[int, list[Any]]] = []
+    for item in data:
+        if not isinstance(item, dict):
+            raise ValueError("embedding service response data[] has invalid item")
+
+        index = item.get("index")
+        if type(index) is not int:
+            raise ValueError("embedding service response has invalid index")
+        if index in seen:
+            raise ValueError(f"embedding service response has duplicate index {index}")
+        seen.add(index)
+
+        embedding = item.get("embedding")
+        if not isinstance(embedding, list):
+            raise ValueError("embedding service response has invalid embeddings")
+        indexed_embeddings.append((index, embedding))
+
+    expected_indices = set(range(expected_count))
+    if seen != expected_indices:
+        raise ValueError(
+            "embedding service response indices mismatch: "
+            f"expected {sorted(expected_indices)}, got {sorted(seen)}"
+        )
+
+    return [
+        [float(value) for value in embedding]
+        for _, embedding in sorted(indexed_embeddings)
+    ]
+
+
+def embedding_provider_mode(model: str | None = None) -> EmbeddingProviderMode:
+    """Resolve the embedding provider mode for a model.
+
+    Backwards compatibility: a ``local/*`` model still uses the in-process
+    embedder unless the user explicitly chooses a mode or Claude Smart's legacy
+    ``CLAUDE_SMART_USE_LOCAL_EMBEDDING=1`` flag is present. That legacy flag
+    now means "use the shared local service" by default.
+    """
+    configured = os.environ.get(_ENV_PROVIDER)
+    if configured:
+        mode = configured.strip().lower()
+        if mode not in _VALID_MODES:
+            raise EmbeddingUnavailableError(
+                f"Invalid {_ENV_PROVIDER}={configured!r}; expected one of "
+                f"{', '.join(sorted(_VALID_MODES))}"
+            )
+        return mode  # type: ignore[return-value]
+
+    if os.environ.get(_ENV_CLAUDE_SMART_LOCAL) == "1":
+        return "local_service"
+
+    if os.environ.get(_ENV_SERVICE_URL):
+        return "internal_service"
+
+    if model and model.startswith("local/"):
+        return "inprocess"
+    return "cloud"
+
+
+def should_use_embedding_service(model: str) -> bool:
+    """Return True when embedding requests should call the HTTP service."""
+    return embedding_provider_mode(model) in _SERVICE_MODES
+
+
+def get_service_embeddings(
+    texts: list[str],
+    *,
+    model: str,
+    dimensions: int | None = None,
+) -> list[list[float]]:
+    """Call the OpenAI-compatible embedding service.
+
+    Args:
+        texts: Inputs to embed.
+        model: Embedding model name.
+        dimensions: Optional embedding dimensions.
+
+    Returns:
+        Embeddings in input order.
+
+    Raises:
+        EmbeddingUnavailableError: If the service cannot be reached or returns
+            an invalid response.
+    """
+    if not texts:
+        return []
+
+    mode = embedding_provider_mode(model)
+    if mode == "off":
+        raise EmbeddingUnavailableError("Embedding provider is disabled")
+    if mode not in _SERVICE_MODES:
+        raise EmbeddingUnavailableError(
+            f"Embedding service requested while {_ENV_PROVIDER}={mode}"
+        )
+
+    url = f"{embedding_service_url(mode)}/v1/embeddings"
+    payload: dict[str, Any] = {"model": model, "input": texts}
+    if dimensions:
+        payload["dimensions"] = dimensions
+
+    timeout = embedding_service_timeout_seconds(mode)
+    last_error: Exception | None = None
+    for attempt in range(2):
+        try:
+            with httpx.Client(timeout=timeout) as client:
+                response = client.post(url, json=payload)
+            response.raise_for_status()
+            body = response.json()
+            return _ordered_embeddings_from_response(body.get("data"), len(texts))
+        except Exception as exc:  # noqa: BLE001 - normalized to typed degradation signal
+            last_error = exc
+            if attempt == 0:
+                time.sleep(0.1)
+
+    _LOGGER.warning("Embedding service unavailable at %s: %s", url, last_error)
+    raise EmbeddingUnavailableError(
+        f"Embedding service unavailable at {url}: {last_error}"
+    ) from last_error

package/plugin/vendor/reflexio/reflexio/server/llm/providers/local_embedding_provider.py

@@ -0,0 +1,213 @@
+"""Local in-process embedder using Chroma's ONNX all-MiniLM-L6-v2.
+
+Lets reflexio run without any external embedding API key. Activation is
+opt-in via ``CLAUDE_SMART_USE_LOCAL_EMBEDDING=1`` and requires the
+``chromadb`` pip package to be installed (we re-use its packaged ONNX
+model + tokenizer rather than re-bundling them).
+
+The model natively produces 384-dim vectors; reflexio's storage schema
+expects 512 dims (``EMBEDDING_DIMENSIONS`` in the vec0 virtual tables).
+We zero-pad each vector to 512 inside this module so the rest of
+reflexio is unchanged. Cosine similarity is preserved on the 384-dim
+subspace — safe as long as *all* embeddings in a given DB come from
+this provider (mixing providers has always required a DB wipe).
+"""
+
+from __future__ import annotations
+
+import importlib.util
+import logging
+import os
+import threading
+from typing import Any
+
+_LOGGER = logging.getLogger(__name__)
+
+_ENV_ENABLE = "CLAUDE_SMART_USE_LOCAL_EMBEDDING"
+_MODEL_KEY = "local/minilm-l6-v2"
+
+# Reflexio's storage schema (vec0 virtual tables) expects this dimension.
+# MiniLM-L6-v2 natively produces 384; we pad with zeros to _TARGET_DIM.
+_NATIVE_DIM = 384
+_TARGET_DIM = 512
+
+# Conservative character budget to stay under MiniLM's 256-token hard cap.
+# ~4 chars/token in English prose; leave headroom so we never raise the
+# ValueError that ONNXMiniLM_L6_V2 throws on over-length input.
+_MAX_CHARS = 800
+
+
+class LocalEmbedderError(RuntimeError):
+    """Raised when the local embedder is called without chromadb installed."""
+
+
+class LocalEmbedder:
+    """Lazily-loaded singleton wrapping Chroma's ONNXMiniLM_L6_V2."""
+
+    _instance: LocalEmbedder | None = None
+    _lock = threading.Lock()
+
+    def __init__(self) -> None:
+        self._ef: Any | None = None
+        self._ef_lock = threading.Lock()
+
+    @classmethod
+    def get(cls) -> LocalEmbedder:
+        """Return the process-wide singleton, constructing it on first use."""
+        if cls._instance is None:
+            with cls._lock:
+                if cls._instance is None:
+                    cls._instance = cls()
+        return cls._instance
+
+    def _load(self) -> Any:
+        """Lazy-import and instantiate the ONNX embedding function."""
+        if self._ef is not None:
+            return self._ef
+        with self._ef_lock:
+            if self._ef is not None:
+                return self._ef
+            try:
+                from chromadb.utils.embedding_functions import (  # type: ignore[import-not-found]
+                    ONNXMiniLM_L6_V2,
+                )
+            except ImportError as exc:
+                raise LocalEmbedderError(
+                    f"{_ENV_ENABLE}=1 but `chromadb` is not installed. "
+                    "Install with `uv add chromadb` or `pip install chromadb`."
+                ) from exc
+            self._ef = ONNXMiniLM_L6_V2()
+            _LOGGER.info(
+                "Initialized local ONNX embedder (model=%s, cache=%s)",
+                ONNXMiniLM_L6_V2.MODEL_NAME,
+                ONNXMiniLM_L6_V2.DOWNLOAD_PATH,
+            )
+            return self._ef
+
+    def embed(self, texts: list[str]) -> list[list[float]]:
+        """Embed a batch of documents, returning 512-dim padded vectors.
+
+        Args:
+            texts: Documents to embed. Each is truncated to ``_MAX_CHARS``
+                characters to stay under the 256-token cap of MiniLM-L6-v2.
+
+        Returns:
+            list[list[float]]: One vector per input, each exactly
+                ``_TARGET_DIM`` (512) floats with the last 128 positions
+                zero-padded.
+        """
+        ef = self._load()
+        safe_inputs = [(text or "")[:_MAX_CHARS] for text in texts]
+        raw = ef(safe_inputs)
+        return [_pad(vec) for vec in raw]
+
+
+def _pad(vec: Any) -> list[float]:
+    """Zero-pad a 384-dim vector to ``_TARGET_DIM`` as a plain list[float]."""
+    as_list = list(vec) if not isinstance(vec, list) else vec
+    floats = [float(x) for x in as_list]
+    if len(floats) == _TARGET_DIM:
+        return floats
+    if len(floats) > _TARGET_DIM:
+        return floats[:_TARGET_DIM]
+    return floats + [0.0] * (_TARGET_DIM - len(floats))
+
+
+_REGISTERED = False
+
+
+def is_chromadb_importable() -> bool:
+    """Return True when the ``chromadb`` package is importable.
+
+    Independent of :data:`_ENV_ENABLE` (``CLAUDE_SMART_USE_LOCAL_EMBEDDING``).
+    Used by callers that want to know whether the local fallback is
+    *possible* regardless of whether claude-smart has explicitly opted in.
+
+    Returns:
+        bool: True if ``importlib.util.find_spec("chromadb")`` finds the
+            package, False otherwise.
+    """
+    return importlib.util.find_spec("chromadb") is not None
+
+
+def register_if_chromadb_available() -> bool:
+    """Make the local embedder available whenever ``chromadb`` imports.
+
+    This is the env-var-independent companion to
+    :func:`register_if_enabled`. Called once from ``litellm_client`` at
+    module import so the local-embedder dispatch is wired up regardless
+    of whether claude-smart's opt-in env var is set. Idempotent — safe
+    to call more than once per process.
+
+    The actual routing is done by a prefix check in
+    ``LiteLLMClient.get_embedding(s)``; this function's job is to
+    eagerly probe for ``chromadb`` and log a clear message.
+
+    Returns:
+        bool: True if the embedder is usable after this call, False
+            when ``chromadb`` is not importable.
+    """
+    global _REGISTERED
+    if _REGISTERED:
+        return True
+    if not is_chromadb_importable():
+        _LOGGER.debug("Local embedder not registered: `chromadb` is not installed.")
+        return False
+    _REGISTERED = True
+    _LOGGER.info("Local embedding provider enabled (model=%s)", _MODEL_KEY)
+    return True
+
+
+def register_if_enabled() -> bool:
+    """Backwards-compatible alias for :func:`register_if_chromadb_available`.
+
+    Historically gated on ``CLAUDE_SMART_USE_LOCAL_EMBEDDING=1``; now
+    delegates to the chromadb-only check so the local embedder is also
+    available as a silent fallback when no cloud embedder is configured.
+    The claude-smart opt-in env var continues to drive
+    :func:`is_local_embedder_available` (provider-priority ordering),
+    which is the public contract the env var actually owns.
+
+    Returns:
+        bool: True if the embedder is usable after this call, False
+            otherwise.
+    """
+    return register_if_chromadb_available()
+
+
+def is_enabled() -> bool:
+    """Return True when a previous registration call has succeeded.
+
+    Returns:
+        bool: True if the provider is currently registered and usable in
+            this process, False otherwise.
+    """
+    return _REGISTERED
+
+
+def is_local_embedder_available() -> bool:
+    """Return True iff both the env flag is set and ``chromadb`` imports.
+
+    Unlike :func:`is_enabled`, this does not require
+    :func:`register_if_enabled` to have run. It is the predicate
+    ``model_defaults.detect_available_providers`` uses to decide whether
+    to surface ``"local"`` as an option.
+
+    Returns:
+        bool: True when ``CLAUDE_SMART_USE_LOCAL_EMBEDDING=1``
+            AND ``chromadb`` is importable.
+    """
+    if os.environ.get(_ENV_ENABLE) != "1":
+        return False
+    return is_chromadb_importable()
+
+
+__all__ = [
+    "LocalEmbedder",
+    "LocalEmbedderError",
+    "is_chromadb_importable",
+    "is_enabled",
+    "is_local_embedder_available",
+    "register_if_chromadb_available",
+    "register_if_enabled",
+]